WMII Reforge  Check-in [15eae1e8e6]

Distributors
============

This file only applies to those who wish to distribute wmii in any
form. The conditions herein do not apply to end users in any manner
whatsoever.

License Terms
=============

wmii is licensed under the liberal MIT License. This license allows
for free modification and distribution of the source code, so long
as credit is given to the author. To this end, the LICENSE file, or
an equivalent statement of its contents, MUST be distributed with
any significant binary or source portions of this software. The file
SHOULD be included with the software's documentation. The default
installation sequence provides for this.

Note that this condition only applies to distribution, and that the
end user is under no obligation to keep or install a copy of the
LICENSE file. Note also that this software may be sub-licensed under
more restrictive terms, though the original LICENSE text MUST remain.

The wmii Name
=============

The following conditions apply to any distribution which uses the
name wmii. These conditions apply only to wmii name, and not to its
source code or any other included materials.

When in doubt about any of these conditions or other matters of
packaging or distribution, please contact the wmii mailing lists at
<dev@suckless.org> or Kris Maglione <maglione.k@gmail.com>. The
conditions herein MAY be contravened by any more lenient
distribution terms agreed upon by the latter, which SHOULD replace
this file in the form of a PGP signed permissions notice.

Version Strings
---------------

Any binary distribution of wmii MUST have a properly set VERSION
string. This is the string printed by the 'wmii' binary when
invoked with the '-v' flag.

This string may normally be set in 'mk/wmii.mk'. Unmodified builds
from the Mercurial tree automatically set this string based on the
Mercurial local revision number, so long as the 'hg' command is
present and properly functioning.

Any version which is an official release, alpha, or beta, MUST
contain the release version. Alpha and beta releases MUST be
proceeded directly by "a" or "b" followed by the alpha or beta
number respectively. wmii 4.0, Alpha 3, for instance, MUST be
formatted as 4.0a3

Any version which is not an official release or snapshot MUST
contain the Mercurial local revision number or changeset hash in its
version string. The local revision number MUST be within 5 revisions
of the equivalent changeset in the official canonical repositories
at http://hg.suckless.org/ and http://wmii.googlecode.com/. This
SHOULD be formatted as hgXXXX, where XXXX is the decimal revision
number.

The version string of any official snapshot release MUST, if it does
not contain Mercurial revision information as above, contain the
date of the snapshot in the form YYYYMMDD, and SHOULD contain the
word snap or snapshot.

The version string of a snapshot MAY contain the version name of a
full release that the snapshot is expected to precede, but it MUST
be either directly preceded, or directly followed by, the word
'pre', optionally separated by a non-alphanumeric character,
including -~_,./.

Modifications
-------------

Any binary distribution which is modified in any non-trivial way
MUST signify the modifications in its name or version string. This
DOES NOT include minor patches to improve consistency with the rest
of the system, including changing the default terminal emulator,
POSIX-compliant shell, or installation prefix.

Source form distribution MAY include non-trivial patches without
such modifications, provided that the user is made clearly aware of
them at build or install time and/or prompted in some way to enable
or disable them.

			     wmii 3.10

@@ If you're reading this file before it's been installed,
@@ substitute the following directories for their placeholders.
@@   @DOCDIR@		doc/
@@   @EXAMPLES@		examples/
@@   @LOCALCONF@	~/.wmii or ~/.wmii-hg (if this is a snapshot)
@@   @ALTDOC@		alternative_wmiircs/
@@
Frequently Asked Questions
==========================

1. I've just upgraded and something doesn't work.
-------------------------------------------------
If you compiled wmii yourself, please try again from a clean source
tree. If wmii still fails, try deleting or renaming your old
configuration files. If this fails, see questions #2.

2. I've read all of the docs, but I still need help.
----------------------------------------------------
You can get support[1] in the #suckless irc channel on irc.oftc.net, or
you can subscribe to the mailing list by sending an email to
dev+subscribe@suckless.org. You can also browse or search the
mailing list archives[2] at Gmane.

3. I think I've found a bug.
----------------------------
You can report bugs at the issue tracker at the Google Code
project[3]. Please be sure to search for your problem before you
open a new issue.

4. How do I get a list of keyboard shortcuts?
---------------------------------------------
The default keyboard shortcuts are listed in both the wmii(1)
manpage and in the user guide[4]. You can also get a list of all
current keyboard shortcuts at any time by selecting 'showkeys' from
the actions menu (M-a).

5. How do I customize wmii? How do I change my keyboard shortcuts?
------------------------------------------------------------------
You can customize wmii by editing its configuration script. If
you're using the stock wmiirc configuration script, you can add key
bindings and change your theme by editing @LOCALCONF@/wmiirc_local.
See @EXAMPLES@/wmiirc_local for more information. You should also be
sure to read wmii(1) and the user guide[4].

6. I've heard I can do my configuration in any language?
--------------------------------------------------------
While wmii is driven by a sh(1) script by default, it ships with
configuration scripts in several other languages, and more still are
available elsewhere on the web. See @ALTDOC@/README for more
information.

7. I've made some changes to my configuration. How do I reload it?
------------------------------------------------------------------
You can rerun your wmiirc script from the actions menu at any time.
If you're running the stock wmiirc, just select wmiirc. If you're
running the python wmiirc (and haven't moved it to
@LOCALCONF@/wmiirc), type python/wmiirc, and so on.

8. How do I restart wmii without killing X?
-------------------------------------------
You can either run 'exec wmii' from the actions menu or write 
'exec wmii' to the /ctl virtual file.

9. Why is there space around my terminal windows?
-------------------------------------------------
Your terminal has asked to only be resized in certain increments,
and there's not enough space for another row. `wmii` is forced to
compromise and leave blank space around it. If you'd rather wmii to
ignore the terminal's request, write 'incmode ignore'[5] to the /ctl
virtual file. Note, though, that this will prevent `wmii`'s normal
behavior of trying to keep these increment gaps as small as
possible, and will therefore result in more wasted space than
otherwise.

10. On FreeBSD, using p9p[6], I get an error about not being able to open /dev/fd/7.
------------------------------------------------------------------------------------
You need to mount fdescfs on /dev/fd. See the BUGS section of rc(1)
for details.

11. How do I set a background image?
------------------------------------
This isn't the job of a window manager. You can set the background
with a third party tool, such as wmsetbg, Esetbg, feh, qiv,
xsetroot, etc.

12. How do I enable sequential shortcuts (like in ratpoison)?
 or How do I use wmii with emacs? The shortcuts collide!
-------------------------------------------------------------

Some applications make extensive use of the Alt key. The preferred
solution is to use the Windows, Apple, or Penguin key in its place.
It's assigned the identifier Mod4 on most systems. Set the
following in wmiirc_local:

    MODKEY=Mod4

Alternatively, you can use key chains, so you're required to press a
certain key combination before wmii accepts its shortcuts:

    MODKEY=Control-i,

13. How do I find out the names of keys to define keyboard shorcuts?
--------------------------------------------------------------------
The easiest way is to run wikeyname(1) and type the key you want to
bind.


[1] http://suckless.org/community
[2] http://dir.gmane.org/gmane.comp.misc.suckless
[3] http://wmii.googlecode.com/
[4] @DOCDIR@/wmii.pdf
[5] For more information, see wmii(1).
[6] http://plan9.us

Copyright © 2006-2010 Kris Maglione <maglione.k@gmail.com>
Copyright © 2003-2006 Anselm R Garbe <anselm@garbe.us>
Portions Copyright © 2002 by Lucent Technologies.

Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the 
Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in 
all copies or substantial portions of the Software. 

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL 
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
DEALINGS IN THE SOFTWARE.

ROOT=.
include $(ROOT)/mk/hdr.mk
include $(ROOT)/mk/wmii.mk

DIRS = \
	doc	     \
	examples     \
	man	     \
	lib	     \
	cmd	     \
	rc	     \
	alternative_wmiircs

DOCS = FAQ \
       LICENSE \
       README.md

deb-dep:
	IFS=', '; \
	apt-get -qq install build-essential $$(sed -n 's/([^)]*)//; s/^Build-Depends: \(.*\)/\1/p' debian/control)

DISTRO = unstable
deb:
	$(ROOT)/util/genchangelog wmii-hg $(VERSION) $(DISTRO)
	dpkg-buildpackage -rfakeroot -b -nc
	[ -d .hg ] && hg revert debian/changelog || true

include $(ROOT)/mk/dir.mk

3.10b1:
    * /colrules widths may now be specified in pixels.
    * /tagrules has been replaced with the more general /rules
    * The format of the bar files has changed.
    * Add witray system tray program.
    * Floating clients can be collapsed by clicking their layout boxes.
    * Dock windows act more like dock windows.
    * The FocusFloating and FocusColumn events have been removed.
    * The tag '!' is no longer special.
    * Xft is now loaded on demand.

3.9.2:             
    * Fixed some managed move bugs.
    * Work around mawk bug that broke wmiirc.

3.9.1:
    * Workaround a dash 0.5.6 bug that broke wmiirc.
    * Noticably speed-up python wmiirc startup.
    * Disable static linking which breaks wmiir in glibc 2.12.

3.9:
    * wmii9menu is now Xinerama aware.
    * Install READMEs to $(PREFIX)/share/doc/wmii/.
    * Documentation updates. Add wmiir.1, wmii9menu.1.
    * Allow dragging floating clients from anywhere in their titlebars.
    * Allow specifying screen in area specs.
    * Change default $MODKEY to Mod4.
    * Minor changes to pygmi.events API.
    * Allow client to follow tag change in python wmiirc.
    * Update /tag/*/index to be more useful on Xinerama.
    * Add showkeys action to shell and python wmiirc.
    * Restore windows from floating layer to their original Xinerama screen.
    * Hide bar on non-primary Xinerama screens.
    * Allow resizing of rightmost and leftmost column dividers.

3.9a2:
    * Add Suraj's Rumai-based wmiirc.
    * Move rc.wmii to alternative_wmiircs/plan9port/wmiirc.
    * Install wmii.pdf to $(PREFIX)/share/doc/.
    * Focus windows regardless of whether they form a new group.
    * Update selection and execution of wmiirc: no more magic.
    * Update wmii.1
    * Add alternative_wmiircs READMEs.

3.9a1:
    * Add new wmii guide. See doc/wmii.pdf
    * Allow for programmable completion in wimenu.
    * Use pkg-config globally.
    * Add Xft (antialiased font) support.
    * Add python wmiirc/9P client library
    * Allow bindings to work regardless of caps lock.
    * Add M-f fullscreen toggle key binding.
    * Augment /client/*/ctl Fullscreen command.
    * Allow setting of increment display from /ctl.
    * Show a client's extra tags in its titlebar.
    * Darken background when floating area selected.
    * Allow bar on top or bottom.
    * Allow for wmiirc_local.
    * Add grow and nudge commands to /tag/*/ctl.
    * Cascade windows when the floating layer fills.
    * Support alpha-transparant windows.
    * Add regex tag support.
    * It is now possible to float/unfloat windows with the mouse.
    * Make the bar Xdnd aware; DND between views is now possible. Fixed some window raising/moving bugs.
    * Add a notification bar.
    * Improved floating mouse resizing.
    * Improved mouse move/resize support for managed mode.
    * Better return from floating/fullscreen to managed mode.
    * Allow comments (#.*\n) in rules and ctl files.
    * Add /client/*/ctl ‘slay’ command.
    * Detect unresponsive clients on ‘kill’.
    * Draw titlebars of floating clients differently.
    * Add wihack: LD_PRELOAD hack to set window properties of programs:
    * Respect window groups
    * Add ‘Kill’ to client right-click menu
    * wmii9menu now takes similar args to wimenu
    * Document grow/nudge commands.
    * Add wimenu with history and caret support
    * Add wistrut. Undocumented, not built by default.
    * EWMH strut support.
    * Basic EWMH support.
    * Better fullscreen support.
    * XRandR support.
    * Xinerama support.

2008-08-25:
    * libixp version 97 now required
    * Stack and max modes now affect floating clients:
        - max: Collapsed clients disappear, all clients disappear
               when managed layer is selected.
        - stack: All clients but selected are collapsed.
    * Adobe's Flash plugin's fullscreen mode now works.
    * Some annoying focus bugs are fixed.

pkgname=(wmii-hg python-pyxp-hg python-pygmi-hg)
pkgver=2755
pkgrel=1
pkgdesc="The latest hg pull of wmii, a lightweight, dynamic window manager for X11"
url="http://wmii.suckless.org"
license=(MIT)
arch=(i686 x86_64)
makedepends=(mercurial python "libixp-hg>="$(sed -rn <mk/wmii.mk 's/.*IXP_NEEDAPI=([0-9]+).*/\1/p'))
options=(!strip)
source=()

FORCE_VER=$(hg log -r . --template {rev})

_make() {
    cd $startdir
    make PREFIX=/usr		\
	 PYPREFIX=--prefix=/usr	\
         ETC=/etc		\
         DESTDIR="$pkgdir"	\
         "$@"
}

build() {
    _make "${flags[@]}" || return 1
}

package_wmii-hg() {
    depends=(libx11 libxinerama libxrandr)
    optdepends=("plan9port: for use of the alternative plan9port wmiirc" \
            "${pkgname[2]}: for use of the alternative Python wmiirc" \
            "ruby-rumai: for use of the alternative Ruby wmiirc" \
            "libxft: for anti-aliased font support")
    provides=(wmii)
    conflicts=(wmii)
    _make install PYMODULES= || return 1

    install -m644 -D ./debian/file/wmii.desktop "$pkgdir/etc/X11/sessions/wmii.desktop"
    install -m644 -D ./LICENSE "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
}

package_python-pyxp-hg() {
    pkgdesc="Python 9P client library"
    arch=(any)
    depends=(python)
    _make -C alternative_wmiircs/python pyclean pyxp.install
}

package_python-pygmi-hg() {
    pkgdesc="Python wmii interaction library"
    arch=(any)
    depends=(python-pyxp-hg)
    _make -C alternative_wmiircs/python pyclean pygmi.install
}

[![Build Status](https://travis-ci.org/0intro/wmii.svg?branch=master)](https://travis-ci.org/0intro/wmii)
[![Coverity Scan Build Status](https://scan.coverity.com/projects/0intro-wmii/badge.svg)](https://scan.coverity.com/projects/0intro-wmii)

Abstract
--------
wmii is a dynamic window manager for X11.  It supports classic and
tiled window management with extended keyboard, mouse, and 9P-based[1]
remote control.  It consists of the wmii(1) window manager and the
wmiir(1) the remote access utility.


Requirements
------------
In order to build wmii you need the Xlib header files and libixp.
xmessage is used by the default scripts.  Libixp, if not provided, can
be obtained from http://libs.suckless.org/.  On debian, you should be
able to obtain all dependencies by running `make deb-dep`.  Python is
recommended for more advanced configurations.


Installation
------------
First, edit config.mk to match your local setup.

To build, simply run:
	make

To install, run the following, as root if necessary:
	make install

On debian, you should only have to run `make deb` to create a debian
package.  No further configuration should be necessary.


Running wmii
------------
Add the following line to your .xinitrc to start wmii using startx:

    until wmii; do :; done

In order to connect wmii to a specific display, make sure that the
DISPLAY environment variable is set correctly.  For example:

    DISPLAY=:1 wmii

This will start wmii on display :1.


Configuration
-------------
The configuration of wmii is done by customizing the rc script wmiirc,
which remotely controls the window manager and handles various events.
The main wmiirc script lives in @GLOBALCONF@ while wmiirc_local goes
in @LOCALCONF@.

More advanced versions of wmiirc are provided in python and ruby.
For more information on them, see alternative_wmiircs/README.

Credits
-------
The following people have contributed especially to wmii in various
ways:

- Christoph Wegscheider <christoph dot wegscheider at wegi dot net>
- Georg Neis <gn at suckless dot org>
- Uwe Zeisberger <zeisberg at informatik dot uni-freiburg dot de>
- Uriel <uriel99 at gmail dot com>
- Scot Doyle <scot at scotdoyle dot com>
- Sebastian Hartmann <seb dot wmi at gmx dot de>
- Bernhard Leiner <bleiner at gmail dot com>
- Jonas Domeij <jonas dot domeij at gmail dot com>
- Vincent <10 dot 50 at free dot fr>
- Oliver Kopp <olly at flupp dot de>
- Sebastian Roth <sebastian dot roth at gmail dot com>
- Nico Golde <nico at ngolde dot de>
- Steve Hoffman <steveh at g2switchworks dot com>
- Christof Musik <christof at senfdax dot de>
- Steffen Liebergeld <perl at gmx dot org>
- Tobias Walkowiak <wal at ivu dot de>
- Sander van Dijk <a dot h dot vandijk at gmail dot com>
- Salvador Peiro <saoret dot one at gmail dot com>
- Anthony Martin <ality at pbrane dot org>
- Icarus Sparry <wmii at icarus dot freeuk dot com>
- Norman Golisz <norman dot golisz at arcor dot de>
- Stefano K. Lee <wizinblack at gmail dot com >
- Stefan Tibus <sjti at gmx dot net>
- Neptun <neptun at gmail dot com>
- Daniel Wäber <_wabu at web dot de>


References
----------
[1] http://9p.cat-v.org
[2] http://plan9.us

BUGS
* collapsed clients outside stacked mode don't always uncollapse when they receive focus
* various qiv brokenness
* dosbox won't grab the mouse

4.0
* Opaque managed moves. I know I've argued against it, but it may be doable.
* Clicking layout boxes should do useful things.
* Collapse/uncollapse frames with the keyboard.
* Open modes (to replace colmodes).
* Resizable managed area. Maybe. Struts seem to do everything this might.
* New dmenu, with real cursor; snarfable.

ROOT=..
include $(ROOT)/mk/hdr.mk
include $(ROOT)/mk/wmii.mk

BIN = $(GLOBALCONF)
DIRS =	python	\
	plan9port \
	ruby

DOCS   = README
DOCDIR = $(DOC)/alternative_wmiircs

include $(ROOT)/mk/dir.mk

Alternative wmiirc scripts
==========================

This folder contains alternative implementations of wmii's rc
scripts. Each folder contains a different implementation,
described below, including its own README, wmiirc script, and
possibly other suppporting files and libraries. These scripts
are installed along with wmii to $(ETC) as defined in config.mk.

It usually suffices to start the included `wmiirc` script at
wmii startup. Invoking wmii with the flag '-r python/wmiirc',
for instance, will start the python implementation.
Alternatively, if you use a session manager, you can add this
line to @LOCALCONF@/wmiirc (which must be executable):

    wmiir xwrite /ctl spawn python/wmiirc

  Index
  ------------- ----------------------------------------------------
  python/	A pure Python wmiirc implementation. 
  plan9port/	A Plan 9 Port/rc shell based wmiirc implementation
  ruby/		A pure-ruby wmiirc implementation, by Suraj Kurapati

ROOT=../..
include $(ROOT)/mk/hdr.mk
include $(ROOT)/mk/wmii.mk

DOCS    = README
EXECS   = wmiirc

DIR    = $(GLOBALCONF)/plan9port
DOCDIR = $(DOC)/alternative_wmiircs/plan9port

plan9port wmiirc
================

This directory contains a Plan 9 based wmiirc script.  This script was
traditionally the default wmiirc for wmii, but has been moved for
portability reasons.  To run this script, either Plan 9 from User
Space[1] (plan9port for short) or 9base[2] is required. Modifications
can be placed in @LOCALCONF@/wmiirc_local.rc, which must
be executable.

#!/bin/sh -f
test $#* '=' 0 || {
	p="$PATH"
	which rc >/dev/null || PATH="$PLAN9:$p"
	which rc >/dev/null || PATH="/usr/local/plan9/bin:$p"
	which rc >/dev/null || PATH="/usr/local/9/bin:$p"
	which rc >/dev/null || PATH="/opt/plan9/bin:$p"
	which rc >/dev/null || PATH="/opt/9/bin:$p"
	which rc >/dev/null || PATH="/usr/plan9/bin:$p"
	which rc >/dev/null || PATH="/usr/9/bin:$p"
	exec rc $0
}

cd
scriptname=$0
oldpath=$path; path=($PLAN9/bin $path)
. wmii.rc wmiirc # Include utility functions

# WMII Configuration

# Keys
MODKEY=Mod4
UP=k
DOWN=j
LEFT=h
RIGHT=l

# Bars
noticetimeout=5
noticebar=/rbar/!notice

# Theme
wmiifont='drift,-*-fixed-*-*-*-*-9-*-*-*-*-*-*-*'
wmiifont='-*-fixed-medium-r-*-*-13-*-*-*-*-*-*-*'
wmiinormcol=('#000000' '#c1c48b' '#81654f')
wmiifocuscol=('#000000' '#81654f' '#000000')
wmiibackground='#333333'
wmiifloatbackground='#222222'
fn setbackground { xsetroot -solid $* }

# Programs
WMII_TERM=(xterm)

# Column Rules
wmiir write /colrules <<!
    /gimp/ -> 17+83+41
    /.*/ -> 62+38 # Golden Ratio
!

# Tagging Rules
wmiir write /rules <<!
    # Apps with system tray icons like to their main windows
    # Give them permission.
    /^Pidgin:/ allow=+activate

    # MPlayer and VLC don't float by default, but should.
    /MPlayer|VLC/ floating=on

    # ROX puts all of its windows in the same group, so they open
    # with the same tags.  Disable grouping for ROX Filer.
    /^ROX-Filer:/ group=0
!

# Status Bar Info
fn status {
	echo -n label `{uptime | sed 's/.*://; s/, / /g'} '|' \
		      `{date} }

# Generic overridable startup details
fn startup { witray & }

# End Configuration

# For the time being, this file follows the lisp bracing
# convention. i.e.:
#  if(frob this) {
#    frob that
#    if(frob theother) {
#      unfrob this
#      unfrob that}}
# Comments welcome.

confpath=`{echo $WMII_CONFPATH | sed 'y/:/ /'}

# Events
fn sigexit {
	rm -f $progs_file
	wi_cleankeys}

fn Event-CreateTag {
	echo colors $wmiinormcol $wi_newline label $* | wmiir create /lbar/$"*}
fn Event-DestroyTag {
	wmiir remove /lbar/$"*}
fn Event-FocusTag {
	wmiir xwrite /lbar/$"* colors $wmiifocuscol}
fn Event-UnfocusTag {
	wmiir xwrite /lbar/$"* colors $wmiinormcol}
fn Event-UrgentTag {
	shift
	wmiir xwrite /lbar/$"* label '*'$"*}
fn Event-NotUrgentTag {
	shift
	wmiir xwrite /lbar/$"* label $"*}
fn Event-AreaFocus {
	if(~ $1 '~')
		setbackground $wmiifloatbackground
	if not
		setbackground $wmiibackground }

fn Event-Unresponsive {
	client = $1; shift
	@{
		msg = 'The following client is not responding. What would you like to do?'
		resp = `{wihack -transient $client \
				xmessage -nearmouse -buttons Kill,Wait -print \
				$msg $wi_newline '' `{wmiir read /client/$client/label}}
		if(~ $resp Kill)
			wmiir xwrite /client/$client/ctl slay
	}&}
fn Event-Notice {
	wmiir xwrite $noticebar label $wi_arg

	/bin/kill $xpid >[2]/dev/null # Let's hope this isn't reused...
	{ sleep $noticetimeout; wmiir xwrite $noticebar ' ' }& # Bug...
	xpid = $apid}

fn Event-LeftBar^(Click DND) {
	shift; wmiir xwrite /ctl view $*}

fn ClientMenu-3-Delete {
	wmiir xwrite /client/$1/ctl kill}
fn ClientMenu-3-Kill {
	wmiir xwrite /client/$1/ctl slay}
fn ClientMenu-3-Fullscreen {
	wmiir xwrite /client/$1/ctl Fullscreen on}
fn Event-ClientMouseDown {
	wi_fnmenu Client $2 $1 &}

fn LBarMenu-3-Delete {
	tag=$1; clients=`{wmiir read /tag/$tag/index | awk '/[^#]/{print $2}'}
	for(c in $clients) {
		if(~ $tag `{wmiir read /client/$c/tags})
			wmiir xwrite /client/$c/ctl kill
		if not
			wmiir xwrite /client/$c/tags -$tag}
	if(~ $tag `{wi_seltag}) {
		newtag = `{wi_tags | awk -v't='$tag '
			$1 == t { if(!l) getline l
				  print l
				  exit }
			{ l = $0 }'}
		wmiir xwrite /ctl view $newtag}}
fn Event-LeftBarMouseDown {
	wi_fnmenu LBar $* &}

# Actions
fn Action-exec {
	wmiir xwrite /ctl exec $*}
fn Action-quit {
	wmiir xwrite /ctl quit}
fn Action-rehash {
	comm -23 <{ls `{namespace}^/proglist.* >[2]/dev/null | awk -F'.' '{print $NF}'} \
		 <{ps | awk '{print $2}'} |
	while(id=`{read})
		rm `{namespace}^/proglist.$id
	wi_proglist $PATH >$progs_file}
fn Action-showkeys {
	echo $wmiikeyhelp | xmessage -file -
}
fn Action-status {
	flag x -; flag r -
	if(wmiir remove /rbar/status >[2]/dev/null)
		sleep 2
	echo colors $wmiinormcol | wmiir create /rbar/status
	while(status | wmiir write /rbar/status)
		sleep 1
}

# Source Variables, &c
if(~ $0 ('' */)wmiirc_local.rc)
	wi_notice This file should not be named wmiirc_local.rc
if not
	. `{wi_script -f wmiirc_local.rc}
echo colors $wmiinormcol | wmiir create $noticebar
startup

# Key Bindings
_keys = `{wi_getfuns Key}
fn keygroup {
	wmiikeyhelp = $wmiikeyhelp ^ $wi_newline ^ '  ' ^ $"* ^ $wi_newline}
fn key {
	help=$1; shift
	key=()
	for(k) {
		if(! ~ $k $_keys) {
			ifs=() { wmiikeyhelp = `{
				printf "%s    %- 20s %s\n" $wmiikeyhelp $k $help}}
			key = ($key Key-$k)}}
	~ $#key 0}

keygroup Moving around
key 'Select the client to the left' $MODKEY-$LEFT || fn $key {
	wmiir xwrite /tag/sel/ctl select left}
key 'Select the client to the right' $MODKEY-$RIGHT || fn $key {
	wmiir xwrite /tag/sel/ctl select right}
key 'Select the client below' $MODKEY-$DOWN || fn $key {
	wmiir xwrite /tag/sel/ctl select down}
key 'Select the client above' $MODKEY-$UP || fn $key {
	wmiir xwrite /tag/sel/ctl select up}

key 'Toggle between floating and managed layers' $MODKEY-space || fn $key {
	wmiir xwrite /tag/sel/ctl select toggle}

keygroup Moving through stacks
key 'Select the stack below' $MODKEY-Control-$DOWN || fn $key {
	wmiir xwrite /tag/sel/ctl select down stack}
key 'Select the stack above' $MODKEY-Control-$UP || fn $key {
	wmiir xwrite /tag/sel/ctl select up stack}

keygroup Moving clients around
key 'Move selected client to the left' $MODKEY-Shift-$LEFT || fn $key {
	wmiir xwrite /tag/sel/ctl send sel left}
key 'Move selected client to the right' $MODKEY-Shift-$RIGHT || fn $key {
	wmiir xwrite /tag/sel/ctl send sel right}
key 'Move selected client down' $MODKEY-Shift-$DOWN || fn $key {
	wmiir xwrite /tag/sel/ctl send sel down}
key 'Move selected client up' $MODKEY-Shift-$UP || fn $key {
	wmiir xwrite /tag/sel/ctl send sel up}

key 'Toggle selected client between floating and managed layers' $MODKEY-Shift-space || fn $key {
	wmiir xwrite /tag/sel/ctl send sel toggle}

keygroup Client actions
key 'Toggle selected client''s fullsceen state' $MODKEY-f || fn $key {
	wmiir xwrite /client/sel/ctl Fullscreen toggle}
key 'Close client' $MODKEY-Shift-c || fn $key {
	wmiir xwrite /client/sel/ctl kill}

keygroup Changing column modes
key 'Set column to default mode' $MODKEY-d || fn $key {
	wmiir xwrite /tag/sel/ctl colmode sel default-max}
key 'Toggle between floating and managed layers' $MODKEY-s || fn $key {
	wmiir xwrite /tag/sel/ctl colmode sel stack-max}
key 'Set column to max mode' $MODKEY-m || fn $key {
	wmiir xwrite /tag/sel/ctl colmode sel stack+max}

keygroup Running programs
key 'Open wmii actions menu' $MODKEY-a || fn $key {
	Action `{wi_actions | wimenu -h $hist.action -n $histlen} &}
key 'Open program menu' $MODKEY-p || fn $key {
	ifs=() { cmd = `{wimenu -h $hist.prog -n $histlen <$progs_file} }
	wi_runcmd $cmd & }

key 'Launch a terminal' $MODKEY-Return || fn $key {
	wi_runcmd $WMII_TERM &}

keygroup Other
key 'Toggle all other key bindings' $MODKEY-Control-t || fn $key {
	switch(`{wmiir read /keys | wc -l}) {
	case 0 1
		wmiir xwrite /keys $keys
		wmiir xwrite /ctl grabmod $MODKEY
	case *
		ifs=() { keys=`{wmiir read /keys} }
		wmiir xwrite /keys $MODKEY-Control-t
		wmiir xwrite /ctl grabmod Mod3
	}}

keygroup Tag actions
key 'Change to another tag' $MODKEY-t || fn $key {
	tag=`{wi_tags | wimenu -h $hist.tag -n 50} && wmiir xwrite /ctl view $tag &}
key 'Retag the selected client' $MODKEY-Shift-t || fn $key {
	sel=`{wi_selclient} {
	tag=`{wi_tags | wimenu -h $hist.tag -n 50} && wmiir xwrite /client/$sel/tags $tag } &}
key 'Move to the next tag' $MODKEY-n || fn $key {
	wmiir xwrite /ctl view `{wi_tags | wi_nexttag}}
key 'Move to the previous tag' $MODKEY-b || fn $key {
	wmiir xwrite /ctl view `{wi_tags | sort -r | wi_nexttag}}

key 'Move to the numbered view' $MODKEY-^`{seq 0 9} || fn $key {
	wmiir xwrite /ctl view `{echo $1 | sed 's/.*-//'}}
key 'Retag selected client with the numbered tag' Shift-$MODKEY-^`{seq 0 9} || fn $key {
	wmiir xwrite /client/sel/tags `{echo $1 | sed 's/.*-//'}}
# WM Configuration
wmiir write /ctl <<!
	grabmod $MODKEY
	border 2
	font $wmiifont
	focuscolors $wmiifocuscol
	normcolors $wmiinormcol
!
setbackground $wmiibackground

# Source Overrides
Action overridekeys

# Misc Setup
progs_file=`{namespace}^/proglist.$pid
hist=`{echo $WMII_CONFPATH | sed 's,:.*,/,'}^/history
histlen=5000
Action status &
Action rehash &

# Tag Bar Setup
ifs=$wi_newline {
	rc -c 'wmiir rm /lbar/^$*' >[2]/dev/null \
		`{comm -23 <{wmiir ls /lbar} \
			   <{wi_tags}}
	seltag=`{wi_seltag}
	for(tag in `{wi_tags}) {{
		if(~ $tag $seltag)
			echo colors $wmiifocuscol $wi_newline label $tag
		if not
			echo colors $wmiinormcol $wi_newline label $tag
		} | wmiir create /lbar/$tag}}
wi_eventloop

ROOT=../..
include $(ROOT)/mk/hdr.mk
include $(ROOT)/mk/wmii.mk

PYMODULES = pyxp pygmi

DOCS   = README
EXECS  = wmiirc
TEXT   = wmiirc.py

DIR    = $(GLOBALCONF)/python
DOCDIR = $(DOC)/alternative_wmiircs/python

include $(ROOT)/mk/python.mk

Python wmiirc
=============

This directory contains a pure Python implementation of
wmiirc. The two included libraries, pyxp and pygmi, are a 9P
client and wmii filesystem utility module, respectively. To
use this library, simply copy the contents of this direcctory
to @LOCALCONF@. To customize it, either modify wmiirc.py
directly, or create wmii_local.py and store your modifications
there. The latter approach is preferable in that future
modifications to wmiirc.py can usually be painlessly
integrated.

The documentation is sparse, but wmiirc.py should serve as a
fairly comprehensive example.

#!/usr/bin/env python

from distutils.core import setup

setup(name='pygmi',
      version='0.2',
      description='Python wmii interaction library',
      author='Kris Maglione',
      author_email='maglione.k@gmail.com',
      url='http://wmii.suckless.org',
      packages=['pygmi'],
      license='MIT',
     )

import os
import sys

from pyxp.asyncclient import Client

if 'WMII_ADDRESS' in os.environ:
    client = Client(os.environ['WMII_ADDRESS'])
else:
    client = Client(namespace='wmii')

confpath = os.environ.get('WMII_CONFPATH', '%s/.wmii' % os.environ['HOME']).split(':')
shell = os.environ['SHELL']

sys.path += confpath

from pygmi.util import *
from pygmi.event import *
from pygmi.fs import *
from pygmi.menu import *
from pygmi.monitor import *
from pygmi import util, event, fs, menu, monitor

__all__ = (fs.__all__ + monitor.__all__ + event.__all__ +
           menu.__all__ + util.__all__ +
           ('client', 'confpath', 'shell'))

# vim:se sts=4 sw=4 et:

import os
import re
import sys
import traceback

import pygmi
from pygmi.util import prop
from pygmi import monitor, client, curry, call, program_list, _

__all__ = ('keys', 'events', 'Match')

class Match(object):
    """
    A class used for matching events based on simple patterns.
    """
    def __init__(self, *args):
        """
        Creates a new Match object based on arbitrary arguments
        which constitute a match pattern. Each argument matches an
        element of the original event. Arguments are matched based
        on their type:

            _:      Matches anything
            set:    Matches any string equal to any of its elements
            list:   Matches any string equal to any of its elements
            tuple:  Matches any string equal to any of its elements

        Additionally, any type with a 'search' attribute matches if
        that callable attribute returns True given element in
        question as its first argument.

        Any other object matches if it compares equal to the
        element.
        """
        self.args = args
        self.matchers = []
        for a in args:
            if a is _:
                a = lambda k: True
            elif isinstance(a, basestring):
                a = a.__eq__
            elif isinstance(a, (list, tuple, set)):
                a = (lambda ary: (lambda k: k in ary))(a)
            elif hasattr(a, 'search'):
                a = a.search
            else:
                a = str(a).__eq__
            self.matchers.append(a)

    def match(self, string):
        """
        Returns true if this object matches an arbitrary string when
        split on ascii spaces.
        """
        ary = string.split(' ', len(self.matchers))
        if all(m(a) for m, a in zip(self.matchers, ary)):
            return ary

def flatten(items):
    """
    Given an iterator which returns (key, value) pairs, returns a
    new iterator of (k, value) pairs such that every list- or
    tuple-valued key in the original sequence yields an individual
    pair.

    Example: flatten({(1, 2, 3): 'foo', 4: 'bar'}.items()) ->
        (1, 'foo'), (2: 'foo'), (3: 'foo'), (4: 'bar')
    """
    for k, v in items:
        if isinstance(k, (list, tuple)):
            for key in k:
                yield key, v
        else:
            yield k, v

class Events():
    """
    A class to handle events read from wmii's '/event' file.
    """
    def __init__(self):
        """
        Initializes the event handler
        """
        self.events = {}
        self.eventmatchers = {}
        self.alive = True

    def dispatch(self, event, args=''):
        """
        Distatches an event to any matching event handlers.

        The handler which specifically matches the event name will
        be called first, followed by any handlers with a 'match'
        method which matches the event name concatenated to the args
        string.

        Param event: The name of the event to dispatch.
        Param args:  The single arguments string for the event.
        """
        try:
            if event in self.events:
                self.events[event](args)
            for matcher, action in self.eventmatchers.iteritems():
                ary = matcher.match(' '.join((event, args)))
                if ary is not None:
                    action(*ary)
        except Exception, e:
            try:
                traceback.print_exc(sys.stderr)
            except:
                pass

    def loop(self):
        """
        Enters the event loop, reading lines from wmii's '/event'
        and dispatching them, via #dispatch, to event handlers.
        Continues so long as #alive is True.
        """
        keys.mode = 'main'
        for line in client.readlines('/event'):
            if not self.alive:
                break
            self.dispatch(*line.split(' ', 1))
        self.alive = False

    def bind(self, items={}, **kwargs):
        """
        Binds a number of event handlers for wmii events. Keyword
        arguments other than 'items' are added to the 'items' dict.
        Handlers are called by #loop when a matching line is read
        from '/event'. Each handler is called with, as its sole
        argument, the string read from /event with its first token
        stripped.

        Param items: A dict of action-handler pairs to bind. Passed
            through pygmi.event.flatten. Keys with a 'match' method,
            such as pygmi.event.Match objects or regular expressions,
            are matched against the entire event string. Any other
            object matches if it compares equal to the first token of
            the event.
        """
        kwargs.update(items)
        for k, v in flatten(kwargs.iteritems()):
            if hasattr(k, 'match'):
                self.eventmatchers[k] = v
            else:
                self.events[k] = v

    def event(self, fn):
        """
        A decorator which binds its wrapped function, as via #bind,
        for the event which matches its name.
        """
        self.bind({fn.__name__: fn})
events = Events()

class Keys(object):
    """
    A class to manage wmii key bindings.
    """
    def __init__(self):
        """
        Initializes the class and binds an event handler for the Key
        event, as via pygmi.event.events.bind.

        Takes no arguments.
        """
        self.modes = {}
        self.modelist = []
        self.mode = 'main'
        self.defs = {}
        events.bind(Key=self.dispatch)

    def _add_mode(self, mode):
        if mode not in self.modes:
            self.modes[mode] = {
                'name': mode,
                'desc': {},
                'groups': [],
                'keys': {},
                'import': {},
            }
            self.modelist.append(mode)

    mode = property(lambda self: self._mode,
                   doc="The current mode for which to dispatch keys")
    @mode.setter
    def mode(self, mode):
        self._add_mode(mode)
        self._mode = mode
        self._keys = dict((k % self.defs, v) for k, v in
                          self.modes[mode]['keys'].items() +
                          self.modes[mode]['import'].items());
        if hasattr(self, 'defs'):
            client.write('/keys', '\n'.join(self._keys.keys()) + '\n')


    @prop(doc="Returns a short help text describing the bound keys in all modes")
    def help(self):
        return '\n\n'.join(
            ('Mode %s\n' % mode['name']) +
            '\n\n'.join(('  %s\n' % str(group or '')) +
                        '\n'.join('    %- 20s %s' % (key % self.defs,
                                                     mode['keys'][key].__doc__)
                                  for key in mode['desc'][group])
                        for group in mode['groups'])
            for mode in (self.modes[name]
                         for name in self.modelist))

    def bind(self, mode='main', keys=(), import_={}):
        """
        Binds a series of keys for the given 'mode'. Keys may be
        specified as a dict or as a sequence of tuple values and
        strings.
        
        In the latter case, documentation may be interspersed with
        key bindings. Any value in the sequence which is not a tuple
        begins a new key group, with that value as a description.
        A tuple with two values is considered a key-value pair,
        where the value is the handler for the named key. A
        three valued tuple is considered a key-description-value
        tuple, with the same semantics as above.

        Each key binding is interpolated with the values of
        #defs, as if processed by (key % self.defs)

        Param mode: The name of the mode for which to bind the keys.
        Param keys: A sequence of keys to bind.
        Param import_: A dict specifying keys which should be
                       imported from other modes, of the form 
                         { 'mode': ['key1', 'key2', ...] }
        """
        self._add_mode(mode)
        mode = self.modes[mode]
        group = None
        def add_desc(key, desc):
            if group not in mode['desc']:
                mode['desc'][group] = []
                mode['groups'].append(group)
            if key not in mode['desc'][group]:
                mode['desc'][group].append(key);

        if isinstance(keys, dict):
            keys = keys.iteritems()
        for obj in keys:
            if isinstance(obj, tuple) and len(obj) in (2, 3):
                if len(obj) == 2:
                    key, val = obj
                    desc = ''
                elif len(obj) == 3:
                    key, desc, val = obj
                mode['keys'][key] = val
                add_desc(key, desc)
                val.__doc__ = str(desc)
            else:
                group = obj

        def wrap_import(mode, key):
            return lambda k: self.modes[mode]['keys'][key](k)
        for k, v in flatten((v, k) for k, v in import_.iteritems()):
            mode['import'][k % self.defs] = wrap_import(v, k)

    def dispatch(self, key):
        """
        Dispatches a key event for the current mode.

        Param key: The key spec for which to dispatch.
        """
        mode = self.modes[self.mode]
        if key in self._keys:
            return self._keys[key](key)
keys = Keys()

class Actions(object):
    """
    A class to represent user-callable actions. All methods without
    leading underscores in their names are treated as callable actions.
    """
    def __getattr__(self, name):
        if name.startswith('_') or name.endswith('_'):
            raise AttributeError()
        if hasattr(self, name + '_'):
            return getattr(self, name + '_')
        cmd = pygmi.find_script(name)
        if not cmd:
            raise AttributeError()
        return lambda args='': call(pygmi.shell, '-c', '$* %s' % args, '--', cmd,
                                    background=True)

    def _call(self, args):
        """
        Calls a method named for the first token of 'args', with the
        rest of the string as its first argument. If the method
        doesn't exist, a trailing underscore is appended.
        """
        a = args.split(' ', 1)
        if a:
            getattr(self, a[0])(*a[1:])

    @prop(doc="Returns the names of the public methods callable as actions, with trailing underscores stripped.")
    def _choices(self):
        return sorted(
            program_list(pygmi.confpath) +
            [re.sub('_$', '', k) for k in dir(self)
             if not re.match('^_', k) and callable(getattr(self, k))])


# vim:se sts=4 sw=4 et:

import collections
from datetime import datetime, timedelta
import re

from pyxp import *
from pyxp.client import *
from pygmi import *
from pygmi.util import prop

__all__ = ('wmii', 'Tags', 'Tag', 'Area', 'Frame', 'Client',
           'Button', 'Colors', 'Color', 'Toggle', 'Always', 'Never')

spacere = re.compile(r'\s')
sentinel = {}

def tounicode(obj):
    if isinstance(obj, str):
        return obj.decode('UTF-8')
    return unicode(obj)

class utf8(object):
    def __str__(self):
        return unicode(self).encode('utf-8')

@apply
class Toggle(utf8):
    def __unicode__(self):
        return unicode(self.__class__.__name__)
@apply
class Always(Toggle.__class__):
    pass
@apply
class Never(Toggle.__class__):
    pass

def constrain(min, max, val):
    return min if val < min else max if val > max else val

class Map(collections.Mapping):
    def __init__(self, cls, *args):
        self.cls = cls
        self.args = args
    def __repr__(self):
        return 'Map(%s%s)' % (self.cls.__name__, (', %s' % ', '.join(map(repr, self.args)) if self.args else ''))
    def __getitem__(self, item):
        ret = self.cls(*(self.args + (item,)))
        if not ret.exists:
            raise KeyError('no such %s %s' % (self.cls.__name__.lower(), repr(item)))
        return ret
    def __len__(self):
        return len(iter(self))
    def __keys__(self):
        return [v for v in self.cls.all(*self.args)]
    def __iter__(self):
        return (v for v in self.cls.all(*self.args))
    def iteritems(self):
        return ((v, self.cls(*(self.args + (v,)))) for v in self.cls.all(*self.args))
    def itervalues(self):
        return (self.cls(*(self.args + (v,))) for v in self.cls.all(*self.args))

class Ctl(object):
    """
    An abstract class to represent the 'ctl' files of the wmii filesystem.
    Instances act as live, writable dictionaries of the settings represented
    in the file.

    Abstract roperty ctl_path: The path to the file represented by this
            control.
    Property ctl_hasid: When true, the first line of the represented
            file is treated as an id, rather than a key-value pair. In this
            case, the value is available via the 'id' property.
    Property ctl_types: A dict mapping named dictionary keys to two valued
            tuples, each containing a decoder and encoder function for the
            property's plain text value.
    """
    ctl_types = {}
    ctl_hasid = False
    ctl_open = 'aopen'
    ctl_file = None

    def __eq__(self, other):
        if self.ctl_hasid and isinstance(other, Ctl) and other.ctl_hasid:
            return self.id == other.id
        return False

    def __init__(self):
        self.cache = {}

    def ctl(self, *args):
        """
        Arguments are joined by ascii spaces and written to the ctl file.
        """
        def next(file):
            if file:
                self.ctl_file = file
                file.awrite(u' '.join(map(tounicode, args)))
        if self.ctl_file:
            return next(self.ctl_file)
        getattr(client, self.ctl_open)(self.ctl_path, callback=next, mode=OWRITE)

    def __getitem__(self, key):
        for line in self.ctl_lines():
            key_, rest = line.split(' ', 1)
            if key_ == key:
                if key in self.ctl_types:
                    return self.ctl_types[key][0](rest)
                return rest
        raise KeyError()
    def __hasitem__(self, key):
        return key in self.keys()
    def __setitem__(self, key, val):
        assert '\n' not in key
        self.cache[key] = val
        if key in self.ctl_types:
            if self.ctl_types[key][1] is None:
                raise NotImplementedError('%s: %s is not writable' % (self.ctl_path, key))
            val = self.ctl_types[key][1](val)
        self.ctl(key, val)

    def get(self, key, default=sentinel):
        """
        Gets the instance's dictionary value for 'key'. If the key doesn't
        exist, 'default' is returned. If 'default' isn't provided and the key
        doesn't exist, a KeyError is raised.
        """
        try:
            return self[key]
        except KeyError, e:
            if default is not self.sentinel:
                return default
            raise e
    def set(self, key, val):
        """
        Sets the dictionary value for 'key' to 'val', as self[key] = val
        """
        self[key] = val

    def keys(self):
        return [line.split(' ', 1)[0]
                for line in self.ctl_lines()]
    def iteritems(self):
        return (tuple(line.split(' ', 1))
                for line in self.ctl_lines())
    def items(self):
        return [tuple(line.split(' ', 1))
                for line in self.ctl_lines()]

    def ctl_lines(self):
        """
        Returns the lines of the ctl file as a tuple, with the first line
        stripped if #ctl_hasid is set.
        """
        lines = tuple(client.readlines(self.ctl_path))
        if self.ctl_hasid:
            lines = lines[1:]
        return lines

    _id = None
    @prop(doc="If #ctl_hasid is set, returns the id of this ctl file.")
    def id(self):
        if self._id is None and self.ctl_hasid:
            return self.name_read(client.read(self.ctl_path).split('\n', 1)[0])
        return self._id

class Dir(Ctl):
    """
    An abstract class representing a directory in the wmii filesystem with a
    ctl file and sub-objects.

    Abstract property base_path: The path directly under which all objects
            represented by this class reside. e.g., /client, /tag
    """
    ctl_hasid = True
    name_read = unicode
    name_write = unicode

    def __init__(self, id):
        """
        Initializes the directory object.

        Param id: The id of the object in question. If 'sel', the object
                dynamically represents the selected object, even as it
                changes. In this case, #id will return the actual ID of the
                object.
        """
        super(Dir, self).__init__()
        if isinstance(id, Dir):
            id = id.id
        if id != 'sel':
            self._id = self.name_read(id)

    def __eq__(self, other):
        return (self.__class__ == other.__class__ and
                self.id == other.id)

    class ctl_property(object):
        """
        A class which maps instance properties to ctl file properties.
        """
        def __init__(self, key):
            self.key = key
        def __get__(self, dir, cls):
            return dir.get(self.key, None)
        def __set__(self, dir, val):
            dir[self.key] = val

    class toggle_property(ctl_property):
        """
        A class which maps instance properties to ctl file properties. The
        values True and False map to the strings "on" and "off" in the
        filesystem.
        """
        props = {
            'on': True,
            'off': False,
            'toggle': Toggle,
            'always': Always,
            'never': Never
        }
        def __get__(self, dir, cls):
            val = dir[self.key]
            if val in self.props:
                return self.props[val]
            return val
        def __set__(self, dir, val):
            for k, v in self.props.iteritems():
                if v == val:
                    val = k
                    break
            dir[self.key] = val

    class file_property(object):
        """
        A class which maps instance properties to files in the directory
        represented by this object.
        """
        def __init__(self, name, writable=False):
            self.name = name
            self.writable = writable
        def __get__(self, dir, cls):
            return client.read('%s/%s' % (dir.path, self.name))
        def __set__(self, dir, val):
            if not self.writable:
                raise NotImplementedError('File %s is not writable' % self.name)
            return client.awrite('%s/%s' % (dir.path, self.name),
                                 str(val))

    @prop(doc="The path to this directory's ctl file")
    def ctl_path(self):
        return '%s/ctl' % self.path

    @prop(doc="The path to this directory")
    def path(self):
        return '%s/%s' % (self.base_path, self.name_write(self._id or 'sel'))
    @prop(doc="True if the given object exists in the wmii filesystem")
    def exists(self):
        return bool(client.stat(self.path))

    @classmethod
    def all(cls):
        """
        Returns all of the objects that exist for this type of directory.
        """
        return (cls.name_read(s.name)
                for s in client.readdir(cls.base_path)
                if s.name != 'sel')
    @classmethod
    def map(cls, *args):
        return Map(cls, *args)

    def __repr__(self):
        return '%s(%s)' % (self.__class__.__name__,
                           repr(self._id or 'sel'))

class Client(Dir):
    """
    A class which represents wmii clients. Maps to the directories directly
    below /client.
    """
    base_path = '/client'
    ctl_types = {
        'group': (lambda s: int(s, 16), str),
        'pid': (int, None),
    }
    @staticmethod
    def name_read(name):
        if isinstance(name, int):
            return name
        try:
            return int(name, 16)
        except:
            return unicode(name)
    name_write = lambda self, name: name if isinstance(name, basestring) else '%#x' % name

    allow  = Dir.ctl_property('allow')
    fullscreen = Dir.toggle_property('fullscreen')
    group  = Dir.ctl_property('group')
    pid    = Dir.ctl_property('pid')
    tags   = Dir.ctl_property('tags')
    urgent = Dir.toggle_property('urgent')

    label = Dir.file_property('label', writable=True)
    props = Dir.file_property('props')

    def kill(self):
        """Politely asks a client to quit."""
        self.ctl('kill')

    def slay(self):
        """Forcibly severs a client's connection to the X server."""
        self.ctl('slay')

class liveprop(object):
    def __init__(self, get):
        self.get = get
        self.attr = str(self)
    def __get__(self, area, cls):
        if getattr(area, self.attr, sentinel) is not sentinel:
            return getattr(area, self.attr)
        return self.get(area)
    def __set__(self, area, val):
        setattr(area, self.attr, val)

class Area(object):
    def __init__(self, tag, ord, screen='sel', offset=sentinel, width=sentinel, height=sentinel, frames=sentinel):
        self.tag = tag
        if ':' in str(ord):
            screen, ord = ord.split(':', 2)
        self.ord = str(ord)
        self.screen = str(screen)
        self.offset = offset
        self.width = width
        self.height = height
        self.frames = frames

    def prop(key):
        @liveprop
        def prop(self):
            for area in self.tag.index:
                if str(area.ord) == str(self.ord):
                    return getattr(area, key)
        return prop
    offset = prop('offset')
    width = prop('width')
    height = prop('height')
    frames = prop('frames')

    @property
    def spec(self):
        if self.screen is not None:
            return '%s:%s' % (self.screen, self.ord)
        return self.ord

    @property
    def mode(self):
        for k, v in self.tag.iteritems():
            if k == 'colmode':
                v = v.split(' ')
                if v[0] == self.ord:
                    return v[1]
    @mode.setter
    def mode(self, val):
        self.tag['colmode %s' % self.spec] = val

    def grow(self, dir, amount=None):
        self.tag.grow(self, dir, amount)
    def nudge(self, dir, amount=None):
        self.tag.nudge(self, dir, amount)

class Frame(object):
    live = False

    def __init__(self, client, area=sentinel, ord=sentinel, offset=sentinel, height=sentinel):
        self.client = client
        self.ord = ord
        self.offset = offset
        self.height = height

    @property
    def width(self):
        return self.area.width

    def prop(key):
        @liveprop
        def prop(self):
            for area in self.tag.index:
                for frame in area.frames:
                    if frame.client == self.client:
                        return getattr(frame, key)
        return prop
    offset = prop('area')
    offset = prop('ord')
    offset = prop('offset')
    height = prop('height')

    def grow(self, dir, amount=None):
        self.area.tag.grow(self, dir, amount)
    def nudge(self, dir, amount=None):
        self.area.tag.nudge(self, dir, amount)

class Tag(Dir):
    base_path = '/tag'

    @classmethod
    def framespec(cls, frame):
        if isinstance(frame, Frame):
            frame = frame.client
        if isinstance(frame, Area):
            frame = (frame.ord, 'sel')
        if isinstance(frame, Client):
            if frame._id is None:
                return 'sel sel'
            return 'client %s' % frame.id
        elif isinstance(frame, basestring):
            return frame
        else:
            return '%s %s' % tuple(map(str, frame))
    def dirspec(cls, dir):
        if isinstance(dir, tuple):
            dir = ' '.join(dir)
        return dir

    @property
    def selected(self):
        return tuple(self['select'].split(' '))
    @selected.setter
    def selected(self, frame):
        if not isinstance(frame, basestring) or ' ' not in frame:
            frame = self.framespec(frame)
        self['select'] = frame

    @property
    def selclient(self):
        for k, v in self.iteritems():
            if k == 'select' and 'client' in v:
                return Client(v.split(' ')[1])
        return None
    @selclient.setter
    def selclient(self, val):
        self['select'] = self.framespec(val)

    @property
    def selcol(self):
        return Area(self, self.selected[0])

    @property
    def index(self):
        areas = []
        for l in (l.split(' ')
                  for l in client.readlines('%s/index' % self.path)
                  if l):
            if l[0] == '#':
                m = re.match(r'(?:(\d+):)?(\d+|~)', l[1])
                if m.group(2) == '~':
                    area = Area(tag=self, screen=m.group(1), ord=l[1], width=l[2],
                                height=l[3], frames=[])
                else:
                    area = Area(tag=self, screen=m.group(1) or 0,
                                height=None, ord=m.group(2), offset=l[2], width=l[3],
                                frames=[])
                areas.append(area)
                i = 0
            else:
                area.frames.append(
                    Frame(client=Client(l[1]), area=area, ord=i,
                          offset=l[2], height=l[3]))
                i += 1
        return areas

    def delete(self):
        id = self.id
        for a in self.index:
            for f in a.frames:
                if f.client.tags == id:
                    f.client.kill()
                else:
                    f.client.tags = '-%s' % id
        if self == Tag('sel'):
            Tags.instance.select(Tags.instance.next())

    def select(self, frame, stack=False):
        self['select'] = '%s %s' % (
            self.framespec(frame),
            stack and 'stack' or '')

    def send(self, src, dest, stack=False, cmd='send'):
        if isinstance(src, tuple):
            src = ' '.join(src)
        if isinstance(src, Frame):
            src = src.client
        if isinstance(src, Client):
            src = src._id or 'sel'

        if isinstance(dest, tuple):
            dest = ' '.join(dest)

        self[cmd] = '%s %s' % (src, dest)

    def swap(self, src, dest):
        self.send(src, dest, cmd='swap')
    
    def nudge(self, frame, dir, amount=None):
        frame = self.framespec(frame)
        self['nudge'] = '%s %s %s' % (frame, dir, str(amount or ''))
    def grow(self, frame, dir, amount=None):
        frame = self.framespec(frame)
        self['grow'] = '%s %s %s' % (frame, dir, str(amount or ''))

class Color(utf8):
    def __init__(self, colors):
        if isinstance(colors, Color):
            colors = colors.rgb
        elif isinstance(colors, basestring):
            match = (re.match(r'^#(..)(..)(..)((?:..)?)$', colors) or
                     re.match(r'^rgba:(..)/(..)/(..)/(..)$', colors))
            colors = tuple(int(match.group(group), 16) for group in range(1, 4))
            if match.group(4):
                colors += int(match.group(4), 16),
        def toint(val):
            if isinstance(val, float):
                val = int(255 * val)
            assert 0 <= val <= 255
            return val
        self.rgb = tuple(map(toint, colors))

    def __getitem__(self, key):
        if isinstance(key, basestring):
            key = {'red': 0, 'green': 1, 'blue': 2}[key]
        return self.rgb[key]

    @property
    def hex(self):
        if len(self.rgb) > 3:
            return 'rgba:%02x/%02x/%02x/%02x' % self.rgb
        return '#%02x%02x%02x' % self.rgb

    def __unicode__(self):
        if len(self.rgb) > 3:
            return 'rgba(%d, %d, %d, %d)' % self.rgb
        return 'rgb(%d, %d, %d)' % self.rgb
    def __repr__(self):
        return 'Color(%s)' % repr(self.rgb)

class Colors(utf8):
    def __init__(self, foreground=None, background=None, border=None):
        vals = foreground, background, border
        self.vals = tuple(map(Color, vals))

    def __iter__(self):
        return iter(self.vals)
    def __list__(self):
        return list(self.vals)
    def __tuple__(self):
        return self.vals

    @classmethod
    def from_string(cls, val):
        return cls(*val.split(' '))

    def __getitem__(self, key):
        if isinstance(key, basestring):
            key = {'foreground': 0, 'background': 1, 'border': 2}[key]
        return self.vals[key]

    def __unicode__(self):
        return ' '.join(c.hex for c in self.vals)
    def __repr__(self):
        return 'Colors(%s, %s, %s)' % tuple(repr(c.rgb) for c in self.vals)

class Button(Ctl):
    sides = {
        'left': 'lbar',
        'right': 'rbar',
    }
    ctl_types = {
        'colors': (Colors.from_string, lambda c: str(Colors(*c))),
    }
    ctl_open = 'acreate'
    colors = Dir.ctl_property('colors')
    label  = Dir.ctl_property('label')

    def __init__(self, side, name, colors=None, label=None):
        super(Button, self).__init__()
        self.side = side
        self.name = name
        self.base_path = self.sides[side]
        self.ctl_path = '%s/%s' % (self.base_path, self.name)
        self.ctl_file = None
        if colors or label:
            self.create(colors, label)

    def create(self, colors=None, label=None):
        if not self.ctl_file:
            self.ctl_file = client.create(self.ctl_path, ORDWR)
        if colors:
            self.colors = colors
        if label:
            self.label = label

    def remove(self):
        if self.ctl_file:
            self.ctl_file.aremove()
            self.ctl_file = None

    @property
    def exists(self):
        return bool(self.file.stat() if self.file else client.stat(self.ctl_path))

    @classmethod
    def all(cls, side):
        return (s.name
                for s in client.readdir(cls.sides[side])
                if s.name != 'sel')
    @classmethod
    def map(cls, *args):
        return Map(cls, *args)

class Rules(collections.MutableMapping, utf8):

    _items = ()
    def __init__(self, path, rules=None):
        self.path = path
        if rules:
            self.setitems(rules)

    _quotere = re.compile(ur'(\\(.)|/)')
    @classmethod
    def quoteslash(cls, str):
        return cls._quotere.sub(lambda m: m.group(0) if m.group(2) else r'\/', str)

    __get__ = lambda self, obj, cls: self
    def __set__(self, obj, val):
        self.setitems(val)

    def __getitem__(self, key):
        for k, v in self.iteritems():
            if k == key:
                return v
        raise KeyError()
    def __setitem__(self, key, val):
        items = [(k, v) for k, v in self.iteritems() if k != key]
        items.append((key, val))
        self.setitems(items)
    def __delitem__(self, key):
        self.setitems((k, v) for k, v in self.iteritems() if k != key)

    def __len__(self):
        return len(tuple(self.iteritems()))
    def __iter__(self):
        return (k for k, v in self.iteritems())
    def __list__(self):
        return list(iter(self))
    def __tuple__(self):
        return tuple(iter(self))

    def append(self, item):
        self.setitems(self + (item,))
    def __add__(self, items):
        return tuple(self.iteritems()) + tuple(items)

    def rewrite(self):
        client.awrite(self.path, unicode(self))
    def setitems(self, items):
        self._items = [(k, v if isinstance(v, Rule) else Rule(self, k, v))
                       for (k, v) in items]
        self.rewrite()

    def __unicode__(self):
        return u''.join(unicode(value) for (key, value) in self.iteritems()) or u'\n'

    def iteritems(self):
        return iter(self._items)
    def items(self):
        return list(self._items())

class Rule(collections.MutableMapping, utf8):
    _items = ()
    parent = None

    @classmethod
    def quotekey(cls, key):
        if key.endswith('_'):
            key = key[:-1]
        return key.replace('_', '-')
    @classmethod
    def quotevalue(cls, val):
        if val is True:   return "on"
        if val is False:  return "off"
        if val in (Toggle, Always, Never):
            return unicode(val).lower()
        return tounicode(val)

    def __get__(self, obj, cls):
        return self
    def __set__(self, obj, val):
        self.setitems(val)

    def __init__(self, parent, key, items={}):
        self.key = key
        self._items = []
        self.setitems(items.iteritems() if isinstance(items, dict) else items)
        self.parent = parent

    def __getitem__(self, key):
        for k, v in reversed(self._items):
            if k == key:
                return v
        raise KeyError()

    def __setitem__(self, key, val):
        items = [(k, v) for k, v in self.iteritems() if k != key]
        items.append((key, val))
        self.setitems(items)

    def __delitem__(self, key):
        self.setitems([(k, v) for k, v in self.iteritems() if k != key])

    def __len__(self):
        return len(self._items)
    def __iter__(self):
        return iter(self._items)
    def __list__(self):
        return list(iter(self))
    def __tuple__(self):
        return tuple(iter(self))

    def append(self, item):
        self.setitems(self + (item,))
    def __add__(self, items):
        return tuple(self.iteritems()) + tuple(items)

    def setitems(self, items):
        items = list(items)
        assert not any('=' in key or
                       spacere.search(self.quotekey(key)) or
                       spacere.search(self.quotevalue(val)) for (key, val) in items)
        self._items = items
        if self.parent:
            self.parent.rewrite()

    def __unicode__(self):
        return u'/%s/ %s\n' % (
            Rules.quoteslash(self.key),
            u' '.join(u'%s=%s' % (self.quotekey(k), self.quotevalue(v))
                      for (k, v) in self.iteritems()))

    def iteritems(self):
        return iter(self._items)
    def items(self):
        return list(self._items)


@apply
class wmii(Ctl):
    ctl_path = '/ctl'
    ctl_types = {
        'normcolors': (Colors.from_string, lambda c: str(Colors(*c))),
        'focuscolors': (Colors.from_string, lambda c: str(Colors(*c))),
        'border': (int, str),
    }

    clients = Client.map()
    tags = Tag.map()
    lbuttons = Button.map('left')
    rbuttons = Button.map('right')

    rules    = Rules('/rules')

class Tags(object):
    PREV = []
    NEXT = []

    def __init__(self, normcol=None, focuscol=None):
        self.ignore = set()
        self.tags = {}
        self.sel = None
        self.normcol = normcol
        self.focuscol = focuscol
        self.lastselect = datetime.now()
        for t in wmii.tags:
            self.add(t)
        for b in wmii.lbuttons.itervalues():
            if b.name not in self.tags:
                b.remove()
        self.focus(Tag('sel').id)

        self.mru = [self.sel.id]
        self.idx = -1
        Tags.instance = self

    def add(self, tag):
        self.tags[tag] = Tag(tag)
        self.tags[tag].button = Button('left', tag, self.normcol or wmii.cache['normcolors'], tag)
    def delete(self, tag):
        self.tags.pop(tag).button.remove()

    def focus(self, tag):
        self.sel = self.tags[tag]
        self.sel.button.colors = self.focuscol or wmii.cache['focuscolors']
    def unfocus(self, tag):
        self.tags[tag].button.colors = self.normcol or wmii.cache['normcolors']

    def set_urgent(self, tag, urgent=True):
        self.tags[tag].button.label = urgent and '*' + tag or tag

    def next(self, reverse=False):
        tags = [t for t in wmii.tags if t not in self.ignore]
        tags.append(tags[0])
        if reverse:
            tags.reverse()
        for i in range(0, len(tags)):
            if tags[i] == self.sel.id:
                return tags[i+1]
        return self.sel

    def select(self, tag, take_client=None):
        def goto(tag):
            if take_client:
                # Make a new instance in case this is Client('sel'),
                # which would cause problems given 'sel' changes in the
                # process.
                client = Client(take_client.id)

                sel = Tag('sel').id
                client.tags = '+%s' % tag
                wmii['view'] = tag
                if tag != sel:
                    client.tags = '-%s' % sel
            else:
                wmii['view'] = tag

        if tag is self.PREV:
            if self.sel.id not in self.ignore:
                self.idx -= 1
        elif tag is self.NEXT:
            self.idx += 1
        else:
            if isinstance(tag, Tag):
                tag = tag.id
            goto(tag)

            if tag not in self.ignore:
                if self.idx < -1:
                    self.mru = self.mru[:self.idx + 1]
                    self.idx = -1
                if self.mru and datetime.now() - self.lastselect < timedelta(seconds=.5):
                    self.mru[self.idx] = tag
                elif tag != self.mru[-1]:
                    self.mru.append(tag)
                    self.mru = self.mru[-10:]
                self.lastselect = datetime.now()
            return

        self.idx = constrain(-len(self.mru), -1, self.idx)
        goto(self.mru[self.idx])

# vim:se sts=4 sw=4 et:

from threading import Thread
from pygmi.util import call

__all__ = 'Menu', 'ClickMenu'

def inthread(name, args, action, **kwargs):
    fn = lambda: call(*args, **kwargs)
    if not action:
        return fn()
    t = Thread(target=lambda: action(fn()))
    t.name += '-%s' % name
    t.daemon = True
    t.start()

class Menu(object):
    def __init__(self, choices=(), action=None,
                 histfile=None, nhist=None):
        self.choices = choices
        self.action = action
        self.histfile = histfile
        self.nhist = nhist

    def __call__(self, choices=None):
        if choices is None:
            choices = self.choices
        if callable(choices):
            choices = choices()
        args = ['wimenu']
        if self.histfile:
            args += ['-h', self.histfile]
        if self.nhist:
            args += ['-n', self.nhist]
        return inthread('Menu', map(str, args), self.action, input='\n'.join(choices))
    call = __call__

class ClickMenu(object):
    def __init__(self, choices=(), action=None,
                 histfile=None, nhist=None):
        self.choices = choices
        self.action = action
        self.prev = None

    def __call__(self, choices=None):
        if choices is None:
            choices = self.choices
        if callable(choices):
            choices = choices()
        args = ['wmii9menu']
        if self.prev:
            args += ['-i', self.prev]
        args += ['--'] + list(choices)
        return inthread('ClickMenu', map(str, args), self.action)
    call = __call__

# vim:se sts=4 sw=4 et:

from threading import Lock, Timer

from pygmi import client
from pygmi.fs import *

__all__ = 'monitors', 'defmonitor', 'Monitor'

monitors = {}

def defmonitor(*args, **kwargs):
    """
    Defines a new monitor to appear in wmii's bar based on
    the wrapped function. Creates a new Monitor object,
    initialized with *args and **kwargs. The wrapped function
    is assigned to the 'action' keyword argument for the
    Monitor, its name is assigned to the 'name' argument.

    The new monitor is added to the 'monitors' dict in this
    module.
    """
    def monitor(fn):
        kwargs['action'] = fn
        if not args and 'name' not in kwargs:
            kwargs['name'] = fn.__name__
        monitor = Monitor(*args, **kwargs)
        monitors[monitor.name] = monitor
        return monitor
    if args and callable(args[0]):
        fn = args[0]
        args = args[1:]
        return monitor(fn)
    return monitor

class Monitor(object):
    """
    A class to manage status monitors for wmii's bar. The bar item
    is updated on a fixed interval based on the values returned
    by the 'action' method.

    Property active: When true, the monitor is updated at regular
             intervals. When false, monitor is hidden.
    Property name: The name of the monitor, which acts as the name
           of the bar in wmii's filesystem.
    Property interval: The update interval, in seconds.
    Property side: The side of the bar on which to place the monitor.
    Property action: A function of no arguments which returns the
            value of the monitor. Called at each update interval.
            May return a string, a tuple of (Color, string), or None
            to hide the monitor for one iteration.
    """
    side = 'right'
    interval = 1.0

    define = classmethod(defmonitor)

    def __init__(self, name=None, interval=None, side=None,
                 action=None, colors=None, label=None):
        """
        Initializes the new monitor. For parameter values, see the
        corresponding property values in the class's docstring.

        Param colors: The initial colors for the monitor.
        Param label:  The initial label for the monitor.
        """
        if side:
            self.side = side
        if name:
            self.name = name
        if interval:
            self.interval = interval
        if action:
            self.action = action

        self.lock = Lock()
        self.timer = None
        self.button = Button(self.side, self.name, colors, label)
        self.tick()

    def tick(self):
        """
        Called internally at the interval defined by #interval.
        Calls #action and updates the monitor based on the result.
        """
        if self.timer and monitors.get(self.name, None) is not self:
            return
        if self.active:
            label = self.getlabel()
            if isinstance(label, basestring):
                label = None, label
            with self.lock:
                if self.active:
                    if label is None:
                        self.button.remove()
                    else:
                        self.button.create(*label)

                    self.timer = Timer(self.interval, self.tick)
                    self.timer.name = 'Monitor-Timer-%s' % self.name
                    self.timer.daemon = True
                    self.timer.start()

    def getlabel(self):
        """
        Calls #action and returns the result, ignoring any
        exceptions.
        """
        try:
            return self.action(self)
        except Exception:
            return None

    _active = True
    @property
    def active(self):
        return self._active

    @active.setter
    def active(self, val):
        with self.lock:
            self._active = bool(val)
        if val:
            self.tick()
        else:
            self.button.remove()

# vim:se sts=4 sw=4 et:

from functools import partial, update_wrapper, wraps
import os
import signal
import subprocess

import pygmi

__all__ = 'call', 'message', 'program_list', 'curry', 'find_script', '_', 'prop'

def _():
    pass

def call(*args, **kwargs):
    background = kwargs.pop('background', False)
    stdin = subprocess.PIPE if not background else open('/dev/null', 'r')
    pipe  = subprocess.PIPE if not background else None
    input = kwargs.pop('input', None)
    p = subprocess.Popen(args, stdin=stdin, stdout=pipe, stderr=pipe,
                         preexec_fn=lambda: signal.signal(signal.SIGPIPE, signal.SIG_DFL),
                         cwd=os.environ['HOME'], close_fds=True, **kwargs)
    if not background:
        return p.communicate(input)[0].rstrip('\n')

def message(message):
    args = ['xmessage', '-file', '-'];
    font = pygmi.wmii['font']
    if not font.startswith('xft:'):
        args += ['-fn', font.split(',')[0]]
    call(*args, input=message)

def program_list(path):
    names = set()
    for d in path:
        try:
            for f in os.listdir(d):
                p = '%s/%s' % (d, f)
                if (f not in names and os.access(p, os.X_OK) and
                    os.path.isfile(p)):
                    names.add(f)
        except Exception:
            pass
    return sorted(names)

def curry(func, *args, **kwargs):
    if _ in args:
        blank = [i for i in range(0, len(args)) if args[i] is _]
        @wraps(func)
        def curried(*newargs, **newkwargs):
            ary = list(args)
            for k, v in zip(blank, newargs):
                ary[k] = v
            ary = tuple(ary) + newargs[len(blank):]
            return func(*ary, **dict(kwargs, **newkwargs))
    else:
        curried = update_wrapper(partial(func, *args, **kwargs), func)
    curried.__name__ += '__curried__'
    return curried

def find_script(name):
    for path in pygmi.confpath:
        if os.access('%s/%s' % (path, name), os.X_OK):
            return '%s/%s' % (path, name)

def prop(**kwargs):
    def prop_(wrapped):
        kwargs['fget'] = wrapped
        return property(**kwargs)
    return prop_

# vim:se sts=4 sw=4 et:

#!/usr/bin/env python

from distutils.core import setup

setup(name='pyxp',
      version='0.2',
      description='Python 9P client library',
      author='Kris Maglione',
      author_email='maglione.k@gmail.com',
      url='http://wmii.suckless.org',
      packages=['pyxp'],
      license='MIT',
     )

from pyxp.client import Client
from pyxp.dial import dial
from pyxp.types import Qid, Stat

VERSION = '9P2000'

# vim:se sts=4 sw=4 et:

from pyxp import client, fcall
from pyxp.client import *
from functools import wraps

def send(iter, val, default=None):
    try:
        return iter.send(val)
    except StopIteration:
        return default

def awithfile(fn):
    @wraps(fn)
    def wrapper(self, path, *args, **kwargs):
        gen = fn(self, *args, **kwargs)
        callback, fail, mode = next(gen)
        def cont(file):
            send(gen, file)
        self.aopen(path, cont, fail=fail or callback, mode=mode)
    return wrapper

def requestchain(fn):
    @wraps(fn)
    def wrapper(self, *args, **kwargs):
        gen = fn(self, *args, **kwargs)
        callback, fail = next(gen)

        def cont(val):
            data = gen.send(val)
            if isinstance(data, fcall.Fcall):
                self._dorpc(data, cont, fail or callback)
            else:
                Client.respond(callback, data)
        cont(None)
    return wrapper

class Client(client.Client):
    ROOT_FID = 0

    def _awalk(fn):
        @wraps(fn)
        @requestchain
        def wrapper(self, *args, **kwargs):
            gen = fn(self, *args, **kwargs)
            path, callback, fail = next(gen)

            path = self._splitpath(path)
            fid  = self._getfid()
            ofid = ROOT_FID

            def fail_(resp, exc, tb):
                if ofid != ROOT_FID:
                    self._aclunk(fid)
                self.respond(fail or callback, resp, exc, tb)
            yield callback, fail_

            while path:
                wname = path[:fcall.MAX_WELEM]
                path = path[fcall.MAX_WELEM:]

                resp = yield fcall.Twalk(fid=ofid, newfid=fid, wname=wname)
                ofid = fid

            resp = fid
            while resp is not None:
                resp = yield send(gen, resp)

        return wrapper

    _file = property(lambda self: File)

    @_awalk
    def _aopen(self, path, mode, fcall, callback, fail=None, origpath=None):
        path = self._splitpath(path)

        fcall.fid = yield path, callback, fail
        resp = yield fcall
        yield self._file(self, origpath or '/'.join(path), resp, fcall.fid, mode,
                         cleanup=lambda: self._aclunk(fcall.fid))

    def aopen(self, path, callback=True, fail=None, mode=OREAD):
        assert callable(callback)
        self._aopen(path, mode, fcall.Topen(mode=mode), callback, fail)

    def acreate(self, path, callback=True, fail=None, mode=OREAD, perm=0):
        path = self._splitpath(path)
        name = path.pop()

        self._aopen(path, mode,
                    fcall.Tcreate(mode=mode, name=name, perm=perm),
                    callback if callable(callback) else lambda resp: resp and resp.close(),
                    fail, origpath='/'.join(path + [name]))

    @_awalk
    def aremove(self, path, callback=True, fail=None):
        yield fcall.Tremove(fid=(yield path, callback, fail))

    @_awalk
    def astat(self, path, callback, fail=None):
        resp = yield fcall.Tstat(fid=(yield path, callback, fail))
        yield resp.stat

    @awithfile
    def aread(self, callback, fail=None, count=None, offset=None, buf=''):
        file = yield callback, fail, OREAD
        file.aread(callback, fail, count, offset, buf)

    @awithfile
    def awrite(self, data, callback=True, fail=None, offset=None):
        file = yield callback, fail, OWRITE
        file.awrite(data, callback, fail, offset)

    @awithfile
    def areadlines(self, callback):
        file = yield callback, fail, OREAD
        file.areadlines(callback)

class File(client.File):

    @requestchain
    def stat(self, callback, fail=None):
        yield callback, fail
        resp = yield fcall.Tstat()
        yield resp.stat

    @requestchain
    def aread(self, callback, fail=None, count=None, offset=None, buf=''):
        yield callback, fail

        setoffset = offset is None
        if count is None:
            count = self.iounit
        if offset is  None:
            offset = self.offset

        res = []
        while count > 0:
            n = min(count, self.iounit)
            count -= n
            resp = yield fcall.Tread(offset=offset, count=n)
            res.append(resp.data)
            offset += len(resp.data)
            if len(resp.data) == 0:
                break

        if setoffset:
            self.offset = offset
        yield ''.join(res)

    def areadlines(self, callback):
        class ctxt:
            last = None
        def cont(data, exc, tb):
            res = True
            if data:
                lines = data.split('\n')
                if ctxt.last:
                    lines[0] = ctxt.last + lines[0]
                for i in range(0, len(lines) - 1):
                    res = callback(lines[i])
                    if res is False:
                        return
                ctxt.last = lines[-1]
                self.aread(cont)
            else:
                if ctxt.last:
                    callback(ctxt.last)
                callback(None)
        self.aread(cont)

    @requestchain
    def awrite(self, data, callback=True, fail=None, offset=None):
        yield callback, fail
        setoffset = offset is None
        if offset is None:
            offset = self.offset

        off = 0
        while off < len(data):
            n = min(len(data), self.iounit)
            resp = yield fcall.Twrite(offset=offset, data=data[off:off+n])
            off    += resp.count
            offset += resp.count

        if setoffset:
            self.offset = offset
        yield off

    @requestchain
    def aremove(self, callback=True, fail=None):
        yield callback, fail
        yield fcall.Tremove()
        self.close()
        yield True

# vim:se sts=4 sw=4 et:

# Copyright (C) 2009 Kris Maglione

import operator
import os
import re
import sys
from threading import *
import traceback

import pyxp
from pyxp import fcall, fields
from pyxp.mux import Mux
from pyxp.types import *

if os.environ.get('NAMESPACE', None):
    namespace = os.environ['NAMESPACE']
else:
    try:
        namespace = '/tmp/ns.%s.%s' % (
            os.environ['USER'], 
            re.sub(r'\.0$', '', os.environ['DISPLAY']))
    except Exception:
        pass
NAMESPACE = namespace

OREAD = 0x00
OWRITE = 0x01
ORDWR = 0x02
OEXEC = 0x03
OEXCL = 0x04
OTRUNC = 0x10
OREXEC = 0x20
ORCLOSE = 0x40
OAPPEND = 0x80

ROOT_FID = 0

class ProtocolException(Exception):
    pass
class RPCError(Exception):
    pass

class Client(object):
    ROOT_FID = 0

    @staticmethod
    def respond(callback, data, exc=None, tb=None):
        if hasattr(callback, 'func_code'):
            callback(*(data, exc, tb)[0:callback.func_code.co_argcount])
        elif callable(callback):
            callback(data)

    def __enter__(self):
        return self
    def __exit__(self, *args):
        self._cleanup()

    def __init__(self, conn=None, namespace=None, root=None):
        if not conn and namespace:
            conn = 'unix!%s/%s' % (NAMESPACE, namespace)
        try:
            self.lastfid = ROOT_FID
            self.fids = set()
            self.lock = RLock()

            def process(data):
                return fcall.Fcall.unmarshall(data)[1]
            self.mux = Mux(conn, process, maxtag=256)

            resp = self._dorpc(fcall.Tversion(version=pyxp.VERSION, msize=65535))
            if resp.version != pyxp.VERSION:
                raise ProtocolException, "Can't speak 9P version '%s'" % resp.version
            self.msize = resp.msize

            self._dorpc(fcall.Tattach(fid=ROOT_FID, afid=fcall.NO_FID,
                       uname=os.environ['USER'], aname=''))

            if root:
                path = self._splitpath(root)
                resp = self._dorpc(fcall.Twalk(fid=ROOT_FID,
                                               newfid=ROOT_FID,
                                               wname=path))
        except Exception:
            traceback.print_exc(sys.stdout)
            if getattr(self, 'mux', None):
                self.mux.fd.close()
            raise

    def _cleanup(self):
        try:
            for f in self.files:
                f.close()
        finally:
            self.mux.fd.close()
            self.mux = None

    def _dorpc(self, req, callback=None, error=None):
        def doresp(resp):
            if isinstance(resp, fcall.Rerror):
                raise RPCError, "%s[%d] RPC returned error: %s" % (
                    req.__class__.__name__, resp.tag, resp.ename)
            if req.type != resp.type ^ 1:
                raise ProtocolException, "Missmatched RPC message types: %s => %s" % (
                    req.__class__.__name__, resp.__class__.__name__)
            return resp

        def next(mux, resp):
            try:
                res = doresp(resp)
            except Exception, e:
                self.respond(error or callback, None, e, None)
            else:
                self.respond(callback, res)

        if not callback:
            return doresp(self.mux.rpc(req))
        self.mux.rpc(req, next)

    def _splitpath(self, path):
        if isinstance(path, list):
            return path
        return [v for v in path.split('/') if v != '']

    def _getfid(self):
        with self.lock:
            if self.fids:
                return self.fids.pop()
            self.lastfid += 1
            return self.lastfid
    def _putfid(self, fid):
        with self.lock:
            self.fids.add(fid)

    def _aclunk(self, fid, callback=None):
        def next(resp, exc, tb):
            if resp:
                self._putfid(fid)
            self.respond(callback, resp, exc, tb)
        self._dorpc(fcall.Tclunk(fid=fid), next)

    def _clunk(self, fid):
        try:
            self._dorpc(fcall.Tclunk(fid=fid))
        finally:
            self._putfid(fid)

    def _walk(self, path):
        fid = self._getfid()
        ofid = ROOT_FID
        while True:
            self._dorpc(fcall.Twalk(fid=ofid, newfid=fid,
                                   wname=path[0:fcall.MAX_WELEM]))
            path = path[fcall.MAX_WELEM:]
            ofid = fid
            if len(path) == 0:
                break

        @apply
        class Res:
            def __enter__(res):
                return fid
            def __exit__(res, exc_type, exc_value, traceback):
                if exc_type:
                    self._clunk(fid)
        return Res

    _file = property(lambda self: File)
    def _open(self, path, mode, fcall, origpath=None):
        resp = None

        with self._walk(path) as nfid:
            fid = nfid
            fcall.fid = fid
            resp = self._dorpc(fcall)

        def cleanup():
            self._aclunk(fid)
        file = self._file(self, origpath or '/'.join(path), resp, fid, mode, cleanup)
        return file

    def open(self, path, mode=OREAD):
        path = self._splitpath(path)

        return self._open(path, mode, fcall.Topen(mode=mode))

    def create(self, path, mode=OREAD, perm=0):
        path = self._splitpath(path)
        name = path.pop()

        return self._open(path, mode, fcall.Tcreate(mode=mode, name=name, perm=perm),
                          origpath='/'.join(path + [name]))

    def remove(self, path):
        path = self._splitpath(path)

        with self._walk(path) as fid:
            self._dorpc(fcall.Tremove(fid=fid))

    def stat(self, path):
        path = self._splitpath(path)

        try:
            with self._walk(path) as fid:
                resp = self._dorpc(fcall.Tstat(fid= fid))
                st = resp.stat
                self._clunk(fid)
            return st
        except RPCError:
            return None

    def read(self, path, *args, **kwargs):
        with self.open(path) as f:
            return f.read(*args, **kwargs)
    def readlines(self, path, *args, **kwargs):
        with self.open(path) as f:
            for l in f.readlines(*args, **kwargs):
                yield l
    def readdir(self, path, *args, **kwargs):
        with self.open(path) as f:
            for s in f.readdir(*args, **kwargs):
                yield s
    def write(self, path, *args, **kwargs):
        with self.open(path, OWRITE) as f:
            return f.write(*args, **kwargs)

class File(object):

    def __enter__(self):
        return self
    def __exit__(self, *args):
        self.close()

    def __init__(self, client, path, fcall, fid, mode, cleanup):
        self.lock = RLock()
        self.client = client
        self.path = path
        self.fid = fid
        self._cleanup = cleanup
        self.mode = mode
        self.iounit = fcall.iounit
        self.qid = fcall.qid
        self.closed = False

        self.offset = 0
    def __del__(self):
        if not self.closed:
            self._cleanup()

    def _dorpc(self, fcall, async=None, error=None):
        if hasattr(fcall, 'fid'):
            fcall.fid = self.fid
        return self.client._dorpc(fcall, async, error)

    def stat(self):
        resp = self._dorpc(fcall.Tstat())
        return resp.stat

    def read(self, count=None, offset=None, buf=''):
        if count is None:
            count = self.iounit
        res = []
        with self.lock:
            offs = self.offset
            if offset is not None:
                offs = offset
            while count > 0:
                n = min(count, self.iounit)
                count -= n

                resp = self._dorpc(fcall.Tread(offset=offs, count=n))
                data = resp.data

                offs += len(data)
                res.append(data)

                if len(data) < n:
                    break
            if offset is None:
                self.offset = offs
        return ''.join(res)

    def readlines(self):
        last = None
        while True:
            data = self.read()
            if not data:
                break
            lines = data.split('\n')
            if last:
                lines[0] = last + lines[0]
                last = None
            for i in range(0, len(lines) - 1):
                yield lines[i]
            last = lines[-1]
        if last:
            yield last

    def write(self, data, offset=None):
        if offset is None:
            offset = self.offset
        off = 0
        with self.lock:
            offs = self.offset
            if offset is not None:
                offs = offset
            while off < len(data):
                n = min(len(data), self.iounit)

                resp = self._dorpc(fcall.Twrite(offset=offs,
                                               data=data[off:off+n]))
                off += resp.count
                offs += resp.count
                if resp.count < n:
                    break
            if offset is None:
                self.offset = offs
        return off
    def readdir(self):
        if not self.qid.type & Qid.QTDIR:
            raise Exception, "Can only call readdir on a directory"
        off = 0
        while True:
            data = self.read(self.iounit, off)
            if not data:
                break
            off += len(data)
            for s in Stat.unmarshall_list(data):
                yield s

    def close(self):
        assert not self.closed
        self.closed = True
        try:
            self._cleanup()
        except:
            pass
        self.tg = None
        self.fid = None
        self.client = None
        self.qid = None

    def remove(self):
        try:
            self._dorpc(fcall.Tremove())
        finally:
            self.close()

# vim:se sts=4 sw=4 et:

from socket import *

__all__ = 'dial',

def dial_unix(address):
    sock = socket(AF_UNIX, SOCK_STREAM, 0)
    sock.connect(address)
    return sock

def dial_tcp(host):
    host = host.split('!')
    if len(host) != 2:
        return
    host, port = host

    res = getaddrinfo(host, port, AF_INET, SOCK_STREAM, 0, AI_PASSIVE)
    for family, socktype, protocol, name, addr in res:
        try:
            sock = socket(family, socktype, protocol)
            sock.connect(addr)
            return sock
        except error:
            if sock:
                sock.close()

def dial(address):
    proto, address = address.split('!', 1)
    if proto == 'unix':
        return dial_unix(address)
    elif proto == 'tcp':
        return dial_tcp(address)
    else:
        raise Exception('invalid protocol')

# vim:se sts=4 sw=4 et:

from pyxp.messages import MessageBase, Message
from pyxp.fields import *
from types import Qid, Stat

__all__ = 'Fcall',

NO_FID = 1<<32 - 1
MAX_WELEM = 16

class FcallBase(MessageBase):
    idx = 99
    def __new__(cls, name, bases, attrs):
        new_cls = super(FcallBase, cls).__new__(cls, name, bases, attrs)
        new_cls.type = FcallBase.idx
        if new_cls.type > 99:
            new_cls.types[new_cls.type] = new_cls
        FcallBase.idx += 1
        return new_cls

class Fcall(Message):
    __metaclass__ = FcallBase
    types = {}

    def response(self, *args, **kwargs):
        assert self.type % 2 == 0, "No respense type for response fcalls"
        kwargs['tag'] = self.tag
        return self.types[self.type + 1]()

    @classmethod
    def unmarshall(cls, data, offset=0):
        res = super(Fcall, cls).unmarshall(data, offset)
        if cls.type < 100:
            res = cls.types[res[1].type].unmarshall(data, offset)
        return res

    size = Size(4, 4)
    type = Int(1)
    tag  = Int(2)

class Tversion(Fcall):
    msize   = Int(4)
    version = String()
class Rversion(Fcall):
    msize   = Int(4)
    version = String()

class Tauth(Fcall):
    afid  = Int(4)
    uname = String()
    aname = String()
class Rauth(Fcall):
    aqid  = Qid.field()

class Tattach(Fcall):
    fid   = Int(4)
    afid  = Int(4)
    uname = String()
    aname = String()
class Rattach(Fcall):
    qid   = Qid.field()

class Terror(Fcall):
    def __init__(self):
        raise Exception("Illegal 9P tag 'Terror' encountered")
class Rerror(Fcall):
    ename = String()

class Tflush(Fcall):
    oldtag = Int(2)
class Rflush(Fcall):
    pass

class Twalk(Fcall):
    fid    = Int(4)
    newfid = Int(4)
    wname  = Array(2, String())
class Rwalk(Fcall):
    wqid   = Array(2, Qid.field())

class Topen(Fcall):
    fid    = Int(4)
    mode   = Int(1)
class Ropen(Fcall):
    qid    = Qid.field()
    iounit = Int(4)

class Tcreate(Fcall):
    fid    = Int(4)
    name   = String()
    perm   = Int(4)
    mode   = Int(1)
class Rcreate(Fcall):
    qid    = Qid.field()
    iounit = Int(4)

class Tread(Fcall):
    fid    = Int(4)
    offset = Int(8)
    count  = Int(4)
class Rread(Fcall):
    data   = Data(4)

class Twrite(Fcall):
    fid    = Int(4)
    offset = Int(8)
    data   = Data(4)
class Rwrite(Fcall):
    count  = Int(4)

class Tclunk(Fcall):
    fid    = Int(4)
class Rclunk(Fcall):
    pass

class Tremove(Tclunk):
    pass
class Rremove(Fcall):
    pass

class Tstat(Tclunk):
    pass
class Rstat(Fcall):
    sstat = Size(2)
    stat  = Stat.field()

class Twstat(Rstat):
    pass
class Rwstat(Fcall):
    pass

# vim:se sts=4 sw=4 et:

from datetime import datetime
import operator

class Field(object):
    idx = 0

    def __init__(self):
        Field.idx += 1
        self.id = Field.idx

    def repr(self):
        return self.__class__.__name__

    def __repr__(self):
        if hasattr(self, 'name'):
            return '<Field %s "%s">' % (self.repr(), self.name)
        return super(Field, self).__repr__()

class Int(Field):
    encoders = {}
    decoders = {}
    @classmethod
    def encoder(cls, n):
        if n not in cls.encoders:
            exec ('def enc(n):\n' +
                  '    assert n == n & 0x%s, "Arithmetic overflow"\n' +
                  '    return "".join((%s,))'
                 ) % ('ff' * n,
                      ','.join('chr((n >> %d) & 0xff)' % (i * 8)
                               for i in range(0, n)))

            cls.encoders[n] = enc
        return cls.encoders[n]
    @classmethod
    def decoder(cls, n):
        if n not in cls.decoders:
            cls.decoders[n] = eval('lambda data, offset: ' +
                                   '|'.join('ord(data[offset + %d]) << %d' % (i, i * 8)
                                            for i in range(0, n)))
        return cls.decoders[n]

    def __init__(self, size):
        super(Int, self).__init__()
        self.size = size
        self.encode = self.encoder(size)
        self.decode = self.decoder(size)
        if self.__class__ == Int:
            self.marshall = self.encode

    def unmarshall(self, data, offset):
        return self.size, self.decode(data, offset)
    def marshall(self, val):
        return self.encode(val)

    def repr(self):
        return '%s(%d)' % (self.__class__.__name__, self.size)

class Size(Int):
    def __init__(self, size, extra=0):
        super(Size, self).__init__(size)
        self.extra = extra

    def marshall(self, val):
        return lambda vals, i: self.encode(
            reduce(lambda n, i: n + len(vals[i]),
                   range(i + 1, len(vals)),
                   self.extra))

class Date(Int):
    def __init__(self):
        super(Date, self).__init__(4)

    def unmarshall(self, data, offset):
        val = self.decode(data, offset)
        return 4, datetime.fromtimestamp(val)
    def marshall(self, val):
        return self.encode(int(val.strftime('%s')))

class Data(Int):
    def __init__(self, size=2):
        super(Data, self).__init__(size)
    def unmarshall(self, data, offset):
        n = self.decode(data, offset)
        offset += self.size
        assert offset + n <= len(data), "String too long to unpack"
        return self.size + n, data[offset:offset + n]
    def marshall(self, val):
        if isinstance(val, unicode):
            val = val.encode('UTF-8')
        return [self.encode(len(val)), val]

# Note: Py3K strings are Unicode by default. They can't store binary
#       data.
class String(Data):
    def unmarshall(self, data, offset):
        off, val = super(String, self).unmarshall(data, offset)
        return off, val.decode('UTF-8')
    def marshall(self, val):
        if isinstance(val, str):
            # Check for valid UTF-8
            str.decode('UTF-8')
        else:
            val = val.encode('UTF-8')
        return super(String, self).marshall(val)

class Array(Int):
    def __init__(self, size, spec):
        super(Array, self).__init__(size)
        self.spec = spec

    def unmarshall(self, data, offset):
        start = offset
        n = self.decode(data, offset)
        offset += self.size
        res = []
        for i in range(0, n):
            size, val = self.spec.unmarshall(data, offset)
            if isinstance(val, list):
                res += val
            else:
                res.append(val)
            offset += size
        return offset - start, res
    def marshall(self, vals):
        res = [self.encode(len(vals))]
        for val in vals:
            val = self.spec.marshall(val)
            if isinstance(val, list):
                res += val
            else:
                res.append(val)
        return res

# vim:se sts=4 sw=4 et:

from pyxp.fields import *

class MessageBase(type):
    idx = 0

    def __new__(cls, name, bases, attrs):
        fields = []
        fieldmap = {}
        for k, v in attrs.items():
            if isinstance(v, Field):
                attrs[k] = None
                fields.append(v)
                fieldmap[k] = v
                v.name = k
        fields.sort(lambda a, b: cmp(a.id, b.id))

        new_cls = super(MessageBase, cls).__new__(cls, name, bases, attrs)

        map = getattr(new_cls, 'fieldmap', {})
        map.update(fieldmap)
        new_cls.fields = getattr(new_cls, 'fields', ()) + tuple(fields)
        new_cls.fieldmap = map
        for f in fields:
            f.message = new_cls
        return new_cls

class Message(object):
    __metaclass__ = MessageBase
    def __init__(self, *args, **kwargs):
        if args:
            args = dict(zip((f.name for f in self.fields), args))
            args.update(kwargs)
            kwargs = args;
        for k, v in kwargs.iteritems():
            assert k in self.fieldmap, "Invalid keyword argument"
            setattr(self, k, v)

    @classmethod
    def field(cls):
        class MessageField(Field):
            def repr(self):
                return cls.__name__
            def unmarshall(self, data, offset):
                return cls.unmarshall(data, offset)
            def marshall(self, val):
                return val.marshall()
        return MessageField()

    @classmethod
    def unmarshall(cls, data, offset=0):
        vals = {}
        start = offset
        for field in cls.fields:
            size, vals[field.name] = field.unmarshall(data, offset)
            offset += size
        return offset - start, cls(**vals)
    def marshall(self):
        res = []
        callbacks = []
        for field in self.fields:
            val = field.marshall(getattr(self, field.name, None))
            if callable(val):
                callbacks.append((val, len(res)))
            if isinstance(val, list):
                res += val
            else:
                res.append(val)
        for fn, i in reversed(callbacks):
            res[i] = fn(res, i)
        return res

# vim:se sts=4 sw=4 et:

# Derived from libmux, available in Plan 9 under /sys/src/libmux
# under the following terms:
#
# Copyright (C) 2003-2006 Russ Cox, Massachusetts Institute of Technology
# 
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to
# the following conditions:
# 
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.

import os
import sys
import traceback

from pyxp import fields
from pyxp.dial import dial
from threading import *
Condition = Condition().__class__

__all__ = 'Mux',

class Mux(object):
    def __init__(self, con, process, flush=None, mintag=0, maxtag=1<<16 - 1):
        self.lock = RLock()
        self.tagcond = Condition(self.lock)
        self.outlock = RLock()
        self.inlock = RLock()
        self.process = process
        self.flush = flush
        self.wait = {}
        self.free = set(range(mintag, maxtag))
        self.mintag = mintag
        self.maxtag = maxtag
        self.muxer = None

        self.async_mux = Queue(self.mux)
        self.async_dispatch = Queue(self.async_dispatch)

        if isinstance(con, basestring):
            con = dial(con)
        self.fd = con

        if self.fd is None:
            raise Exception("No connection")

    def mux(self, rpc):
        with self.lock:
            try:
                rpc.waiting = True
                while self.muxer and self.muxer != rpc and rpc.data is None:
                    rpc.wait()

                if rpc.data is None:
                    assert self.muxer in (rpc, None)
                    self.muxer = rpc
                    try:
                        self.lock.release()
                        while rpc.data is None:
                            data = self.recv()
                            if data is None:
                                raise Exception("unexpected eof")
                            self.dispatch(data)
                    finally:
                        self.lock.acquire()
                        self.electmuxer()
            except Exception:
                traceback.print_exc(sys.stderr)
                if rpc.tag in self.wait:
                    self.wait.pop(rpc.tag)
                if self.flush:
                    self.flush(self, rpc.data)
                raise

        return rpc.data

    def rpc(self, dat, async=None):
        rpc = self.newrpc(dat, async)
        if async:
            self.async_mux.push(rpc)
        else:
            return self.mux(rpc)

    def async_dispatch(self, rpc):
        rpc.async(self, rpc.data)

    def electmuxer(self):
        for rpc in self.wait.itervalues():
            if self.muxer != rpc and rpc.waiting:
                self.muxer = rpc
                rpc.notify()
                return
        self.muxer = None

    def dispatch(self, dat):
        with self.lock:
            rpc = self.wait.get(dat.tag, None)
            if rpc:
                self.puttag(rpc)
                rpc.dispatch(dat)
            elif False:
                print "bad rpc tag: %u (no one waiting on it)" % dat.tag

    def gettag(self, r):
        tag = 0

        while not self.free:
            self.tagcond.wait()

        tag = self.free.pop()

        if tag in self.wait:
            raise Exception("nwait botch")

        self.wait[tag] = r

        r.tag = tag
        r.orig.tag = r.tag
        return r.tag

    def puttag(self, rpc):
        if rpc.tag in self.wait:
            del self.wait[rpc.tag]
        self.free.add(rpc.tag)
        self.tagcond.notify()

    def send(self, dat):
        data = ''.join(dat.marshall())
        n = self.fd.send(data)
        return n == len(data)
    def recv(self):
        def readn(fd, n):
            data = ''
            while len(data) < n:
                try:
                    s = fd.recv(n - len(data))
                    if len(s) == 0:
                        raise Exception('unexpected end of file')
                    data += s
                except os.error, e:
                    if e.errno != os.errno.EINTR:
                        raise e
            return data

        try:
            with self.inlock:
                data = readn(self.fd, 4)
                if data:
                    nmsg = fields.Int.decoders[4](data, 0)
                    data += readn(self.fd, nmsg - 4)
                    return self.process(data)
        except Exception, e:
            print e.__class__.__name__
            print repr(e)
            traceback.print_exc(sys.stderr)
            return None

    def newrpc(self, dat, async=None):
        rpc = Rpc(self, dat, async)
        tag = None

        with self.lock:
            self.gettag(rpc)

        if rpc.tag >= 0 and self.send(dat):
            return rpc

        with self.lock:
            self.puttag(rpc)

class Rpc(Condition):
    def __init__(self, mux, data, async=None):
        super(Rpc, self).__init__(mux.lock)
        self.mux = mux
        self.orig = data
        self.data = None
        self.async = async
        self.waiting = False

    def __repr__(self):
        return '<Rpc tag=%s orig=%s data=%s async=%s waiting=%s>' % tuple(map(repr, (self.tag, self.orig, self.data, self.async, self.waiting)))

    def dispatch(self, data=None):
        self.data = data
        self.notify()
        if callable(self.async):
            self.mux.async_dispatch(self)

class Queue(Thread):
    _id = 1

    def __init__(self, op):
        super(Queue, self).__init__(name='Queue-%d-%s' % (Queue._id, repr(op)))
        Queue._id += 1
        self.cond = Condition()
        self.op = op
        self.queue = []
        self.daemon = True

    def __call__(self, item):
        return self.push(item)

    def push(self, item):
        with self.cond:
            self.queue.append(item)
            if not self.is_alive():
                self.start()
            self.cond.notify()
    def pop(self, item):
        with self.cond:
            if item in self.queue:
                self.queue.remove(item)
                return True
            return False

    def run(self):
        self.cond.acquire()
        while True:
            while self.queue:
                item = self.queue.pop(0)
                self.cond.release()
                try:
                    self.op(item)
                except Exception, e:
                    traceback.print_exc(sys.stderr)
                self.cond.acquire()
            self.cond.wait()

# vim:se sts=4 sw=4 et:

from pyxp.messages import Message
from pyxp.fields import *

__all__ = 'Qid', 'Stat'
          
class Qid(Message):
    QTFILE    = 0x00
    QTLINK    = 0x01
    QTSYMLINK = 0x02
    QTTMP     = 0x04
    QTAUTH    = 0x08
    QTMOUNT   = 0x10
    QTEXCL    = 0x20
    QTAPPEND  = 0x40
    QTDIR     = 0x80

    type    = Int(1)
    version = Int(4)
    path    = Int(8)

class Stat(Message):
    DMDIR       = 0x80000000
    DMAPPEND    = 0x40000000
    DMEXCL      = 0x20000000
    DMMOUNT     = 0x10000000
    DMAUTH      = 0x08000000
    DMTMP       = 0x04000000
    DMSYMLINK   = 0x02000000
    DMDEVICE    = 0x00800000
    DMNAMEDPIPE = 0x00200000
    DMSOCKET    = 0x00100000
    DMSETUID    = 0x00080000
    DMSETGID    = 0x00040000

    @classmethod
    def unmarshall_list(cls, data, offset=0):
        while offset < len(data):
            n, stat = cls.unmarshall(data, offset)
            offset += n
            yield stat

    size   = Size(2)
    type   = Int(2)
    dev    = Int(4)
    qid    = Qid.field()
    mode   = Int(4)
    atime  = Date()
    mtime  = Date()
    length = Int(8)
    name   = String()
    uid    = String()
    gid    = String()
    muid   = String()

# vim:se sts=4 sw=4 et:

#!/usr/bin/env @PYTHON@
import os, sys
path = []
for p in os.environ.get("WMII_CONFPATH", "").split(':'):
    path += [p, p + '/python']
sys.path = path + sys.path

from pygmi import events
import wmiirc

events.loop()

import datetime
import operator
import os
import re
import sys
import traceback
from threading import Thread, Timer

import pygmi
from pygmi import *
from pygmi import event

identity = lambda k: k

# Begin Configuration
#
# Note: This file loads ~/.wmii/wmiirc_local.py if it exists.
# Configuration should be placed in that file, and this file
# left unmodified, if possible. wmiirc_local should import
# wmiirc or any other modules it needs.
#
# Do *not* copy this file to wmiirc_local.py lest you want it
# executed twice.

# Keys
keys.defs = dict(
    mod='Mod4',
    left='h',
    down='j',
    up='k',
    right='l')

# Bars
noticetimeout=5
noticebar=('right', '!notice')

# Theme
background = '#333333'
floatbackground='#222222'

wmii['font'] = 'drift,-*-fixed-*-*-*-*-9-*-*-*-*-*-*-*'
wmii['normcolors'] = '#000000', '#c1c48b', '#81654f'
wmii['focuscolors'] = '#000000', '#81654f', '#000000'
wmii['grabmod'] = keys.defs['mod']
wmii['border'] = 2

def setbackground(color):
    call('xsetroot', '-solid', color, background=True)
setbackground(background)

terminal = 'wmiir', 'setsid', '@TERMINAL@'
pygmi.shell = os.environ.get('SHELL', 'sh')
tray = 'witray',

@defmonitor
def load(self):
    return wmii.cache['normcolors'], re.sub(r'^.*: ', '', call('uptime')).replace(', ', ' ')
@defmonitor
def time(self):
    return wmii.cache['focuscolors'], datetime.datetime.now().strftime('%c')

wmii.rules = (
    # Apps with system tray icons like to their main windows
    # Give them permission.
    (ur'^Pidgin:',       dict(allow='+activate')),

    # MPlayer and VLC don't float by default, but should.
    (ur'MPlayer|VLC',   dict(floating=True)),

    # ROX puts all of its windows in the same group, so they open
    # with the same tags.  Disable grouping for ROX Filer.
    (ur'^ROX-Filer:',   dict(group=0)),
)

def unresponsive_client(client):
    msg = 'The following client is not responding. What would you like to do?'
    resp = call('wihack', '-transient', str(client.id),
                'xmessage', '-nearmouse', '-buttons', 'Kill,Wait', '-print',
                '%s\n  %s' % (msg, client.label))
    if resp == 'Kill':
        client.slay()

# End Configuration

client.awrite('/event', 'Start wmiirc')

tags = Tags()
events.bind({
    ('Quit', Match('Start', 'wmiirc')): lambda *a: sys.exit(),
    'CreateTag':    tags.add,
    'DestroyTag':   tags.delete,
    'FocusTag':     tags.focus,
    'UnfocusTag':   tags.unfocus,
    'UrgentTag':    lambda args: tags.set_urgent(args.split()[1], True),
    'NotUrgentTag': lambda args: tags.set_urgent(args.split()[1], False),

    'AreaFocus':    lambda args: (args == '~' and
                                  (setbackground(floatbackground), True) or
                                  setbackground(background)),

    'Unresponsive': lambda args: Thread(target=unresponsive_client,
                                        args=(Client(args),)).start(),

    'Notice':       lambda args: notice.show(args),

    'ScreenChange': lambda args: wmii.ctl('wipescreens'),

    Match(('LeftBarClick', 'LeftBarDND'), 1): lambda e, b, tag: tags.select(tag),
    Match('LeftBarClick', 4): lambda *a: tags.select(tags.next(True)),
    Match('LeftBarClick', 5): lambda *a: tags.select(tags.next()),

    Match('LeftBarMouseDown', 3):   lambda e, n, tag: clickmenu((
            ('Delete',     lambda t: Tag(t).delete()),
        ), (tag,)),
    Match('ClientMouseDown', _, 3): lambda e, client, n: clickmenu((
            ('Delete',     lambda c: Client(c).kill()),
            ('Kill',       lambda c: Client(c).slay()),
            ('Fullscreen', lambda c: Client(c).set('Fullscreen', 'on')),
        ), (client,)),

    Match('ClientClick', _, 4): lambda e, c, n: Tag('sel').select('up'),
    Match('ClientClick', _, 5): lambda e, c, n: Tag('sel').select('down'),
})

@apply
class Actions(event.Actions):
    def rehash(self, args=''):
        program_menu.choices = program_list(os.environ['PATH'].split(':'))
    def showkeys(self, args=''):
        message(keys.help)
    def quit(self, args=''):
        wmii.ctl('quit')
    def eval_(self, args=''):
        exec args
    def exec_(self, args=''):
        wmii['exec'] = args
    def exit(self, args=''):
        client.awrite('/event', 'Quit')

program_menu = Menu(histfile='%s/history.progs' % confpath[0], nhist=5000,
                    action=curry(call, 'wmiir', 'setsid',
                                 pygmi.shell, '-c', background=True))
action_menu = Menu(histfile='%s/history.actions' % confpath[0], nhist=500,
                   choices=lambda: Actions._choices,
                   action=Actions._call)
tag_menu = Menu(histfile='%s/history.tags' % confpath[0], nhist=100,
                choices=lambda: sorted(tags.tags.keys()))

def clickmenu(choices, args):
    ClickMenu(choices=(k for k, v in choices),
              action=lambda choice: dict(choices).get(choice, identity)(*args)
             ).call()

class Notice(Button):
    def __init__(self):
        super(Notice, self).__init__(*noticebar, colors=wmii.cache['normcolors'])
        self.timer = None
        self.show(' ')

    def tick(self):
        self.create(wmii.cache['normcolors'], ' ')

    def write(self, notice):
        client.awrite('/event', 'Notice %s' % notice.replace('\n', ' '))

    def show(self, notice):
        if self.timer:
            self.timer.cancel()
        self.create(wmii.cache['normcolors'], notice)
        self.timer = Timer(noticetimeout, self.tick)
        self.timer.start()
notice = Notice()

keys.bind('main', (
    "Moving around",
    ('%(mod)s-%(left)s',  "Select the client to the left",
        lambda k: Tag('sel').select('left')),
    ('%(mod)s-%(right)s', "Select the client to the right",
        lambda k: Tag('sel').select('right')),
    ('%(mod)s-%(up)s',    "Select the client above",
        lambda k: Tag('sel').select('up')),
    ('%(mod)s-%(down)s',  "Select the client below",
        lambda k: Tag('sel').select('down')),

    ('%(mod)s-space',     "Toggle between floating and managed layers",
        lambda k: Tag('sel').select('toggle')),

    "Moving through stacks",
    ('%(mod)s-Control-%(up)s',   "Select the stack above",
        lambda k: Tag('sel').select('up', stack=True)),
    ('%(mod)s-Control-%(down)s', "Select the stack below",
        lambda k: Tag('sel').select('down', stack=True)),


    "Moving clients around",
    ('%(mod)s-Shift-%(left)s',  "Move selected client to the left",
        lambda k: Tag('sel').send(Client('sel'), 'left')),
    ('%(mod)s-Shift-%(right)s', "Move selected client to the right",
        lambda k: Tag('sel').send(Client('sel'), 'right')),
    ('%(mod)s-Shift-%(up)s',    "Move selected client up",
        lambda k: Tag('sel').send(Client('sel'), 'up')),
    ('%(mod)s-Shift-%(down)s',  "Move selected client down",
        lambda k: Tag('sel').send(Client('sel'), 'down')),

    ('%(mod)s-Shift-space',     "Toggle selected client between floating and managed layers",
        lambda k: Tag('sel').send(Client('sel'), 'toggle')),

    "Client actions",
    ('%(mod)s-f',       "Toggle selected client's fullsceen state",
        lambda k: Client('sel').set('Fullscreen', 'toggle')),
    ('%(mod)s-Shift-c', "Close client",
        lambda k: Client('sel').kill()),

    "Changing column modes",
    ('%(mod)s-d', "Set column to default mode",
        lambda k: setattr(Tag('sel').selcol, 'mode', 'default-max')),
    ('%(mod)s-s', "Set column to stack mode",
        lambda k: setattr(Tag('sel').selcol, 'mode', 'stack-max')),
    ('%(mod)s-m', "Set column to max mode",
        lambda k: setattr(Tag('sel').selcol, 'mode', 'stack+max')),

    "Running programs",
    ('%(mod)s-a',      "Open wmii actions menu",
        lambda k: action_menu()),
    ('%(mod)s-p',      "Open program menu",
        lambda k: program_menu()),

    ('%(mod)s-Return', "Launch a terminal",
        lambda k: call(*terminal, background=True)),

    "Tag actions",
    ('%(mod)s-t',       "Change to another tag",
        lambda k: tags.select(tag_menu())),
    ('%(mod)s-Shift-t', "Retag the selected client",
        lambda k: setattr(Client('sel'), 'tags', tag_menu())),

    ('%(mod)s-n', "Move to the view to the left",
        lambda k: tags.select(tags.next())),
    ('%(mod)s-b', "Move to the view to the right",
        lambda k: tags.select(tags.next(True))),
    ('%(mod)s-Shift-n', "Move to the view to the left, take along current client",
        lambda k: tags.select(tags.next(), take_client=Client('sel'))),
    ('%(mod)s-Shift-b', "Move to the view to the right, take along current client",
        lambda k: tags.select(tags.next(True), take_client=Client('sel'))),

    ('%(mod)s-i', "Move to the newer tag in the tag stack",
        lambda k: tags.select(tags.NEXT)),
    ('%(mod)s-o', "Move to the older tag in the tag stack",
        lambda k: tags.select(tags.PREV)),
    ('%(mod)s-Shift-i', "Move to the newer tag in the tag stack, take along current client",
        lambda k: tags.select(tags.NEXT, take_client=Client('sel'))),
    ('%(mod)s-Shift-o', "Move to the older tag in the tag stack, take along current client",
        lambda k: tags.select(tags.PREV, take_client=Client('sel'))),

))
def bind_num(i):
    keys.bind('main', (
        "Tag actions",
        ('%%(mod)s-%d' % i,       "Move to view '%d'" % i,
            lambda k: tags.select(str(i))),
        ('%%(mod)s-Shift-%d' % i, "Retag selected client with tag '%d'" % i,
            lambda k: setattr(Client('sel'), 'tags', i)),
    ))
map(bind_num, range(0, 10))

keys.bind('main', (
    "Changing modes",
    ('%(mod)s-Control-r', "Enter resize mode",
        lambda k: setattr(keys, 'mode', 'resize')),
    ('%(mod)s-Control-t', "Enter passthrough mode",
        lambda k: setattr(keys, 'mode', 'passthrough')),
));
keys.bind('passthrough', (
    "Changing modes",
    ('%(mod)s-Control-t', "Leave passthrough mode",
        lambda k: setattr(keys, 'mode', 'main')),
));

keys.bind('resize', (
    ('Escape', "Leave resize mode",
        lambda k: setattr(keys, 'mode', 'main')),
), import_={'main': ('%(mod)s-%(left)s', '%(mod)s-%(right)s',
                     '%(mod)s-%(up)s', '%(mod)s-%(down)s',
                     '%(mod)s-Space')})

def addresize(mod, desc, cmd, *args):
    keys.bind('resize', (
        (mod + '%(left)s',  "%s selected client to the left" % desc,
            lambda k: Tag('sel').ctl(cmd, 'sel sel', 'left',
                                     *args)),
        (mod + '%(right)s', "%s selected client to the right" % desc,
            lambda k: Tag('sel').ctl(cmd, 'sel sel', 'right',
                                     *args)),
        (mod + '%(up)s',    "%s selected client up" % desc,
            lambda k: Tag('sel').ctl(cmd, 'sel sel', 'up',
                                     *args)),
        (mod + '%(down)s',  "%s selected client down" % desc,
            lambda k: Tag('sel').ctl(cmd, 'sel sel', 'down',
                                     *args)),
    ));
addresize('',         'Grow', 'grow')
addresize('Control-', 'Shrink', 'grow', '-1')
addresize('Shift-',   'Nudge', 'nudge')

Thread(target=lambda: Actions.rehash()).start()

if not os.environ.get('WMII_NOPLUGINS', ''):
    dirs = filter(curry(os.access, _, os.R_OK),
                  ('%s/plugins' % dir for dir in confpath))
    files = filter(re.compile(r'\.py$').search,
                   reduce(operator.add, map(os.listdir, dirs), []))
    for f in ['wmiirc_local'] + ['plugins.%s' % file[:-3] for file in files]:
        try:
            __import__(f)
        except Exception, e:
            traceback.print_exc(sys.stdout)

call(*tray, background=True)

# vim:se sts=4 sw=4 et:

= 2006-09-30

* Included 1.1.0 release of Ruby-IXP.


= 2006-09-29

* Fixed bug in toggle_maximize method (in rc.rb) due
  to accessing a nonexistent file in IXP file system.

  Thanks to Christian von Mueffling for reporting this bug.

* Fixed problem with reading
  index (Wmii::Client#index) of
  currently selected client.

* Wmii.find_client now accepts a variable number of places to be searched.


= 2006-09-28

* Added number_view_buttons method (in rc.rb) which numbers
  the view buttons displayed on the bar, from left to right.


= 2006-09-27

* Included two main concurrency fixes for Ruby-IXP.


= 2006-09-24

* Added two-stage event handling,
  to minimize the number of events
  missed while processing an event.


= 2006-09-23

* Fixed event & status bar loop. It was forgotten when I transitioned
  to the new Ixp::Node#method_missing behavior on 2006-09-22.

  Thanks to Fredrik Ternerot for reporting this bug.

* When selecting views based on their first letter: if more than one
  view matches, then they are cycled (adapted from Fredrik Ternerot).

* Added focus_view_matching method in rc.rb.

* Fixed errors that occurred when the tile and
  diamond arrangements were applied to empty views.


= 2006-09-22

* Ixp::Node#method_missing now only dereferences files. Also,
  the ! notation has been removed, as you can see below.

    >> Wmii.fs.bar.status
    => #<Ixp::Node:0xb7b5940c @path="/bar/status">
    >> Wmii.fs.bar.status.read
    => ["colors", "data"]
    >> Wmii.fs.bar.status.data
    => "Fri Sep 22 18:46:11 PDT 2006 | 0.06 0.10 0.08 | 531M 100% /home"
    >> Wmii.fs.bar.status.data!
    => #<Ixp::Node:0xb7b377e4 @path="/bar/status/data!">


= 2006-09-21

* Fix some forgotten changes from show_menu() returning *nil*.

* Exception error message (xmessage) now lets you restart *wmiirc*.

* Updated event loop to generate less 9P traffic.


= 2006-09-20

* Included code from upcoming Ruby-IXP 1.1.0 release.

* Ixp::Node#method_missing now only dereferences a node
  if the method is suffixed with an exclamation mark.

* show_menu now returns *nil* if nothing was chosen.

* Updated event loop for {wmii-3.1's /event overload bug
  fix}[http://wmii.de/pipermail/wmii/2006-September/002718.html].

* Added explicit termination of already running instances
  in *wmiirc* via Process.kill and `ps`, instead of using
  /event as a means of coordinating said task.


= 2006-09-19

* Included Ruby-IXP 1.0.3 release.

* Added Ixp::Node#open method to reduce 9P traffic.

* Added ability to fetch a sub-node
  via Ixp::Node#method_missing, while
  not dereferencing it (reading its
  contents if it is a file), by adding
  an exclamation to the file name.

  For example, consider the following output in *wmiish*.

    >> Wmii.fs.bar.status.data
    => "Tue Sep 19 10:50:41 PDT 2006 | 0.30 0.43 0.29 | 1.7G 98% /home"
    >> Wmii.fs.bar.status.data!
    => #<Ixp::Node:0xb7bf1f18 @path="/bar/status/data">

* *wmiirc* no longer automatically resumes from error. Instead,
  it throws you a terminal and shows you the error details so
  you have a chance to fix it and restart *wmiirc* yourself.


= 2006-09-18

* Included Ruby-IXP 1.0.2 release.


= 2006-09-17

* Added Wmii::View#empty? and Wmii::Area#empty? methods.

* change_tag_from_menu now returns the chosen tag.

* Included Ruby-IXP 1.0.1 release.


= 2006-09-16

* Fixed toggling of maximization
  of currently focused client,
  via toggle_maximize in rc.rb.

  Thanks to Fredrik Ternerot for reporting this bug.


= 2006-09-15

* Added Wmii.get_view and Wmii.get_client
  methods, to further minimize hard-coded
  IXP file system paths. This will make it
  easier to upgrade to wmii-4 later on.

* Fixed ruby-ixp to be internally buffered for Ixp#read.

* Event loop now uses Ixp#read instead of *wmiir*.

* Already running configurations now correctly
  exit when another instance starts up.


= 2006-09-14

* Added ability to swap current client with the
  currently focused client in any other column.


= 2006-09-13

* Reverted to *wmiir* for event loop, because
  Ixp#read isn't internally buffered!

* Changed Wmii::View#each to Wmii::View#each_column because
  floating area isn't a column (it doesn't have /mode file).

* Added shortcuts for setting layouts of all columns in current view.

* Added shortcuts for selection of current column.

* Fixed ability to terminate multiple clients.


= 2006-09-12

* Event loop now uses Ixp#read instead of *wmiir*.

  * Already running configurations now correctly
    exit when another instance starts up.

* Added Wmii::View#diamond! -- a diamond-shaped automated client arrangement.

* Added Wmii::Area#length= for setting number of clients in a column.


= 2006-09-11

* Added exception logging and recovery mechanism.

  * wmiirc is now split into a loader
    file (wmiirc) and a configuration
    file (wmiirc-config.rb), just
    like in the ruby-wmii project.

* IXPException' are no longer hidden away inside Ixp.

* Moved support for destructive area-operations
  from Wmii#with_selection into Array#each so
  that it is generally available.


= 2006-09-10

* Added wmiish--an interactive Ruby shell for controlling wmii.

* Lots of major refactoring in Ixp and Wmii.
  * Moved utility methods from wmiirc into rc.rb.


= 2006-09-09

* Cleaned up IXP abstraction... now
  multiple levels of method_missing
  works, and so does self[sub_path]

* Wmii#with_selection now supports destructive area-operations.

* Update for compliance with new unique-client-id in filesystem patch.


= 2006-08-31

* Added facility which sends the selection
  to temporary view or switches back again.


= 2006-08-30

* Add Wmii#with_selection method for operating on all clients in selection.

(the ISC license)

Copyright 2006 Suraj N. Kurapati <sunaku@gmail.com>
Copyright 2007 Kris Maglione <jg@suckless.org>
Copyright 2007 Nick Stenning <nick@whiteink.com>
Copyright 2009 Daniel Wäber <waeber@inf.fu-berlin.de>
Copyright 2009 Michael Andrus <centyx@centyx.net>
Copyright 2009 Simon Hafner <hafnersimon@gmail.com>

Permission to use, copy, modify, and distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

ROOT=../..
include $(ROOT)/mk/hdr.mk
include $(ROOT)/mk/wmii.mk

DOCS   = README  \
	 HISTORY \
	 LICENSE
EXECS  = wmiirc
TEXT   = config.rb \
	 config.yaml

DIR    = $(GLOBALCONF)/ruby
DOCDIR = $(DOC)/alternative_wmiircs/ruby

This is a modified version of sunaku's wmiirc, designed for
his Rumai Ruby module. Minor configuration changes, namely to
the color scheme and default key bindings, as well as the
configuration search path, exist in this version. Builtin mpd
support has also been removed. Also added is support for
string interpolation in key bindings, as should be apparent in
the included config.yaml.

In particular, not that there is no need to copy any files to
@LOCALCONF@ other than config.yaml. The script will happily load
the requisite files from their default install location. They
can be loaded either by involing wmii as follows:

    wmiir -r ruby/wmiirc

or running the following after startup:

    wmiir xwrite /ctl spawn ruby/wmiirc

The rumai gem is still required, as noted below.

The original readme appears below unmodified:

sunaku's Ruby wmiirc
====================

This is my wmii configuration, described in these articles:

  http://wmii.suckless.org/alternative_wmiirc_scripts

  http://snk.tuxfamily.org/lib/rumai/

  http://article.gmane.org/gmane.comp.window-managers.wmii/1704

  http://snk.tuxfamily.org/web/2006-07-01-wmii-3-1-configuration-in-ruby.html

Dependencies:

    wmii 3.6 or newer (preferably wmii-hg)

    Ruby 1.8.6 or newer

    RubyGems 1.3.1 or newer

Installation:

    # library
    gem install rumai     # required
    gem install librmpd   # optional

    # install
    mv @LOCALCONF@ @LOCALCONF@.backup
    git clone git://github.com/sunaku/wmiirc.git @LOCALCONF@

    # choose
    cd @LOCALCONF@
    git checkout --track -b CHOICE origin/CHOICE # choices are:

    +--------+------------------------------------------------+
    | CHOICE | DESCRIPTION                                    |
    +--------+------------------------------------------------+
    | dvorak | sunaku's personal configuration; DSK friendly! |
    | qwerty | QWERTY port of sunaku's personal configuration |
    | strict | port of the default wmiirc shipped with wmii   |
    | master | barebones template for starting from scratch   |
    +--------+------------------------------------------------+

    # run
    @LOCALCONF@/wmiirc

Documentation:

    # see list of all key bindings
    egrep '^ +\$\{\w+\}' @LOCALCONF@/config.yaml

    # read the configuration file
    less @LOCALCONF@/config.yaml

Configuration:

    Edit @LOCALCONF@/config.yaml to your liking.

    Run @LOCALCONF@/wmiirc to apply your changes.

Contribution:

    Fork this project on GitHub and send pull requests.

Questions:

    Send me an e-mail (see LICENSE for my address).

# DSL for wmiirc configuration.
#--
# Copyright protects this work.
# See LICENSE file for details.
#++

require 'shellwords'
require 'pathname'
require 'yaml'

require 'rubygems'
gem 'rumai', '~> 3'
require 'rumai'

include Rumai

class Handler < Hash
  def initialize
    super {|h,k| h[k] = [] }
  end

  ##
  # If a block is given, registers a handler
  # for the given key and returns the handler.
  #
  # Otherwise, executes all handlers registered for the given key.
  #
  def handle key, *args, &block
    if block
      self[key] << block

    elsif key? key
      self[key].each do |block|
        block.call(*args)
      end
    end

    block
  end
end

EVENTS  = Handler.new
ACTIONS = Handler.new
KEYS    = Handler.new

##
# If a block is given, registers a handler
# for the given event and returns the handler.
#
# Otherwise, executes all handlers for the given event.
#
def event *a, &b
  EVENTS.handle(*a, &b)
end

##
# Returns a list of registered event names.
#
def events
  EVENTS.keys
end

##
# If a block is given, registers a handler for
# the given action and returns the handler.
#
# Otherwise, executes all handlers for the given action.
#
def action *a, &b
  ACTIONS.handle(*a, &b)
end

##
# Returns a list of registered action names.
#
def actions
  ACTIONS.keys
end

##
# If a block is given, registers a handler for
# the given keypress and returns the handler.
#
# Otherwise, executes all handlers for the given keypress.
#
def key *a, &b
  KEYS.handle(*a, &b)
end

##
# Returns a list of registered action names.
#
def keys
  KEYS.keys
end

##
# Shows a menu (where the user must press keys on their keyboard to
# make a choice) with the given items and returns the chosen item.
#
# If nothing was chosen, then nil is returned.
#
# ==== Parameters
#
# [prompt]
#   Instruction on what the user should enter or choose.
#
def key_menu choices, prompt = nil
  words = ['dmenu', '-fn', CONFIG['display']['font']]

  # show menu at the same location as the status bar
  words << '-b' if CONFIG['display']['bar'] == 'bottom'

  words.concat %w[-nf -nb -sf -sb].zip(
    [
      CONFIG['display']['color']['normal'],
      CONFIG['display']['color']['focus'],

    ].map {|c| c.to_s.split[0,2] }.flatten

  ).flatten

  words.push '-p', prompt if prompt

  command = words.shelljoin
  IO.popen(command, 'r+') do |menu|
    menu.puts choices
    menu.close_write

    choice = menu.read
    choice unless choice.empty?
  end
end

##
# Shows a menu (where the user must click a menu
# item using their mouse to make a choice) with
# the given items and returns the chosen item.
#
# If nothing was chosen, then nil is returned.
#
# ==== Parameters
#
# [choices]
#   List of choices to display in the menu.
#
# [initial]
#   The choice that should be initially selected.
#
#   If this choice is not included in the list
#   of choices, then this item will be made
#   into a makeshift title-bar for the menu.
#
def click_menu choices, initial = nil
  words = ['wmii9menu']

  if initial
    words << '-i'

    unless choices.include? initial
      initial = "<<#{initial}>>:"
      words << initial
    end

    words << initial
  end

  words.concat choices
  command = words.shelljoin

  choice = `#{command}`.chomp
  choice unless choice.empty?
end

##
# Shows a key_menu() containing the given
# clients and returns the chosen client.
#
# If nothing was chosen, then nil is returned.
#
# ==== Parameters
#
# [prompt]
#   Instruction on what the user should enter or choose.
#
# [clients]
#   List of clients to present as choices to the user.
#
#   If this parameter is not specified,
#   its default value will be a list of
#   all currently available clients.
#
def client_menu prompt = nil, clients = Rumai.clients
  choices = []

  clients.each_with_index do |c, i|
    choices << "%d. [%s] %s" % [i, c[:tags].read, c[:label].read.downcase]
  end

  if target = key_menu(choices, prompt)
    clients[target.scan(/\d+/).first.to_i]
  end
end

##
# Returns the basenames of executable files present in the given directories.
#
def find_programs *dirs
  dirs.flatten.
  map {|d| Pathname.new(d).expand_path.children rescue [] }.flatten.
  map {|f| f.basename.to_s if f.file? and f.executable? }.compact.uniq.sort
end

##
# Launches the command built from the given words in the background.
#
def launch *words
  command = words.shelljoin
  system "#{command} &"
end

##
# A button on a bar.
#
class Button < Thread
  ##
  # Creates a new button at the given node and updates its label
  # according to the given refresh rate (measured in seconds).  The
  # given block is invoked to calculate the label of the button.
  #
  # The return value of the given block can be either an
  # array (whose first item is a wmii color sequence for the
  # button, and the remaining items compose the label of the
  # button) or a string containing the label of the button.
  #
  # If the given block raises a standard exception, then that will be
  # rescued and displayed (using error colors) as the button's label.
  #
  def initialize fs_bar_node, refresh_rate, &button_label
    raise ArgumentError, 'block must be given' unless block_given?

    super(fs_bar_node) do |button|
      while true
        label =
          begin
            Array(button_label.call)
          rescue Exception => e
            LOG.error e
            [CONFIG['display']['color']['error'], e]
          end

        # provide default color
        unless label.first =~ /(?:#[[:xdigit:]]{6} ?){3}/
          label.unshift CONFIG['display']['color']['normal']
        end

        button.create unless button.exist?
        button.write label.join(' ')
        sleep refresh_rate
      end
    end
  end

  ##
  # Refreshes the label of this button.
  #
  alias refresh wakeup
end

##
# Loads the given YAML configuration file.
#
def load_config config_file
  Object.const_set :CONFIG, YAML.load_file(config_file)

  # script
    eval CONFIG['script']['before'].to_s, TOPLEVEL_BINDING,
         "#{config_file}:script:before"

  # display
    fo = ENV['WMII_FONT']        = CONFIG['display']['font']
    fc = ENV['WMII_FOCUSCOLORS'] = CONFIG['display']['color']['focus']
    nc = ENV['WMII_NORMCOLORS']  = CONFIG['display']['color']['normal']

    settings = {
      'font'        => fo,
      'focuscolors' => fc,
      'normcolors'  => nc,
      'border'      => CONFIG['display']['border'],
      'bar on'      => CONFIG['display']['bar'],
      'colmode'     => CONFIG['display']['column']['mode'],
      'grabmod'     => CONFIG['control']['grab'],
    }

    begin
      fs.ctl.write settings.map {|pair| pair.join(' ') }.join("\n")

    rescue Rumai::IXP::Error => e
      #
      # settings that are not supported in a particular wmii version
      # are ignored, and those that are supported are (silently)
      # applied.  but a "bad command" error is raised nevertheless!
      #
      warn e.inspect
      warn e.backtrace.join("\n")
    end

    launch 'xsetroot', '-solid', CONFIG['display']['background']

    # column
      fs.colrules.write CONFIG['display']['column']['rule']

    # client
      event 'CreateClient' do |client_id|
        client = Client.new(client_id)

        unless defined? @client_tags_by_regexp
          @client_tags_by_regexp = CONFIG['display']['client'].map {|hash|
            k, v = hash.to_a.first
            [eval(k, TOPLEVEL_BINDING, "#{config_file}:display:client"), v]
          }
        end

        if label = client.props.read rescue nil
          catch :found do
            @client_tags_by_regexp.each do |regexp, tags|
              if label =~ regexp
                client.tags = tags
                throw :found
              end
            end

            # force client onto current view
            begin
              client.tags = curr_tag
              client.focus
            rescue
              # ignore
            end
          end
        end
      end

    # status
      action 'status' do
        fs.rbar.clear

        unless defined? @status_button_by_name
          @status_button_by_name     = {}
          @status_button_by_file     = {}
          @on_click_by_status_button = {}

          CONFIG['display']['status'].each_with_index do |hash, position|
            name, defn = hash.to_a.first

            # buttons appear in ASCII order of their IXP file name
            file = "#{position}-#{name}"

            button = eval(
              "Button.new(fs.rbar[#{file.inspect}], #{defn['refresh']}) { #{defn['content']} }",
              TOPLEVEL_BINDING, "#{config_file}:display:status:#{name}"
            )

            @status_button_by_name[name] = button
            @status_button_by_file[file] = button

            # mouse click handler
            if code = defn['click']
              @on_click_by_status_button[button] = eval(
                "lambda {|mouse_button| #{code} }", TOPLEVEL_BINDING,
                "#{config_file}:display:status:#{name}:click"
              )
            end
          end
        end

        @status_button_by_name.each_value {|b| b.refresh }

      end

      ##
      # Returns the status button associated with the given name.
      #
      # ==== Parameters
      #
      # [name]
      #   Either the the user-defined name of
      #   the status button or the basename
      #   of the status button's IXP file.
      #
      def status_button name
        @status_button_by_name[name] || @status_button_by_file[name]
      end

      ##
      # Refreshes the content of the status button with the given name.
      #
      # ==== Parameters
      #
      # [name]
      #   Either the the user-defined name of
      #   the status button or the basename
      #   of the status button's IXP file.
      #
      def status name
        if button = status_button(name)
          button.refresh
        end
      end

      ##
      # Invokes the mouse click handler for the given mouse
      # button on the status button that has the given name.
      #
      # ==== Parameters
      #
      # [name]
      #   Either the the user-defined name of
      #   the status button or the basename
      #   of the status button's IXP file.
      #
      # [mouse_button]
      #   The identification number of
      #   the mouse button (as defined
      #   by X server) that was clicked.
      #
      def status_click name, mouse_button
        if button = status_button(name) and
           handle = @on_click_by_status_button[button]
        then
          handle.call mouse_button.to_i
        end
      end

  # control
    action 'reload' do
      # reload this wmii configuration
      reload_config
    end

    action 'rehash' do
      # scan for available programs and actions
      @programs = find_programs(ENV['PATH'].squeeze(':').split(':'))
    end

    # kill all currently open clients
    action 'clear' do
      # firefox's restore session feature does not
      # work unless the whole process is killed.
      system 'killall firefox firefox-bin thunderbird thunderbird-bin'

      # gnome-panel refuses to die by any other means
      system 'killall -s TERM gnome-panel'

      Thread.pass until clients.each do |c|
        begin
          c.focus # XXX: client must be on current view in order to be killed
          c.kill
        rescue
          # ignore
        end
      end.empty?
    end

    # kill the window manager only; do not touch the clients!
    action 'kill' do
      fs.ctl.write 'quit'
    end

    # kill both clients and window manager
    action 'quit' do
      action 'clear'
      action 'kill'
    end

    event 'Unresponsive' do |client_id|
      client = Client.new(client_id)

      IO.popen('xmessage -nearmouse -file - -buttons Kill,Wait -print', 'w+') do |f|
        f.puts 'The following client is not responding.', ''
        f.puts client.inspect
        f.puts client.label.read

        f.puts '', 'What would you like to do?'
        f.close_write

        if f.read.chomp == 'Kill'
          client.slay
        end
      end
    end

    event 'Notice' do |*argv|
      unless defined? @notice_mutex
        require 'thread'
        @notice_mutex = Mutex.new
      end

      Thread.new do
        # prevent notices from overwriting each other
        @notice_mutex.synchronize do
          button = fs.rbar['!notice']
          button.create unless button.exist?

          # display the notice
          message = argv.join(' ')

          LOG.info message # also log it in case the user is AFK
          button.write "#{CONFIG['display']['color']['notice']} #{message}"

          # clear the notice
          sleep [1, CONFIG['display']['notice'].to_i].max
          button.remove
        end
      end
    end

    %w[key action event].each do |param|
      if settings = CONFIG['control'][param]
        settings.each do |name, code|
          if param == 'key'
            # expand ${...} expressions in shortcut key sequences
            name = name.gsub(/\$\{(.+?)\}/) { CONFIG['control'][$1] }
          end

          eval "#{param}(#{name.inspect}) {|*argv| #{code} }",
               TOPLEVEL_BINDING, "#{config_file}:control:#{param}:#{name}"
        end
      end
    end

  # script
    action 'status'
    action 'rehash'

    eval CONFIG['script']['after'].to_s, TOPLEVEL_BINDING,
         "#{config_file}:script:after"

end

##
# Reloads the entire wmii configuration.
#
def reload_config
  LOG.info 'reload'
  exec $0
end

#
# High-level wmii configuration.
#
# Ruby code in this file has access
# to a CONFIG constant which contains
# the data in this configuration file.
#
#--
# Copyright protects this work.
# See LICENSE file for details.
#++


##
# Program preferences.
#
program:
  terminal: @TERMINAL@
  browser: firefox
  editor: mousepad
  filer: thunar


##
# Appearance settings.
#
display:

  ##
  # Where to display the horizontal status bar?
  #
  # Possible choices are "top" and "bottom".
  #
  bar: bottom

  ##
  # The font to use in all text drawn by wmii.
  #
  font: -*-fixed-medium-r-*-*-13-*-*-*-*-*-*-*

  ##
  # Thickness of client border (measured in pixels).
  #
  border: 1

  ##
  # Number of seconds a notice should be displayed.
  #
  notice: 5

  ##
  # Color schemes for everything drawn by wmii.
  #
  #   <scheme>: "<text> <background> <border>"
  #
  # You can find more color schemes here:
  #
  #   http://wmii.suckless.org/scripts_n_snips/themes
  #
  color:
    normal:   "#000000 #c1c48b #81654f"
    focus:    "#000000 #81654f #000000"
    error:    "#000000 #81654f #000000"
    notice:   "#000000 #a1956d #413328"
    success:  "#000000 #c1c48b #81654f"

  ##
  # Color of desktop background.
  #
  background: "#333333"

  ##
  # Settings for columns drawn by wmii.
  #
  #   mode: <the wmii "colmode" setting>
  #   rule: <the wmii "colrules" setting>
  #
  column:
    mode: default
    rule: |
      /gimp/ -> 17+83+41
      /.*/ -> 62+38 # Golden Ratio

  ##
  # Mapping of clients to views they must appear on.
  #
  #   - <client props regular expression> : <tags to apply>
  #
  # These mappings are processed in top-to-bottom order.
  # Processing stops after the first matching mapping is applied.
  #
  client:
    - /MPlayer|VLC/ : ~

  ##
  # Self-refreshing buttons on the status bar.
  #
  #   - <button name>:
  #       refresh:  <number of seconds to wait before refreshing the content>
  #       content:  <Ruby code whose result is displayed as the content>
  #       click:    <Ruby code to handle mouse clicks on the status button.
  #                  This code has access to a "mouse_button" variable which is
  #                  an integer representing the mouse button that was clicked.>
  #
  # You can refresh a particular status button in Ruby using:
  #
  #   status "your button name"
  #
  # The horizontal order in which these buttons appear on the status
  # bar reflects the vertical order in which they are defined below.
  #
  status:
    - system_load:
        refresh: 10
        content: |
          load_averages = File.read('/proc/loadavg').split.first(3)
          current_load  = load_averages.first.to_f

          # visually indicate the intensity of system load
          color = case
            when current_load > 3.0 then CONFIG['display']['color']['error']
            when current_load > 1.5 then CONFIG['display']['color']['notice']
          end

          [color, *load_averages]

    - clock:
        refresh: 5
        content: Time.now.to_s


##
# Interaction settings.
#
control:

  ##
  # The wmii "grabmod" setting.
  #
  grab: Mod4

  ##
  # Key sequence prefixes.
  #
  mod:    Mod4
  move:   Mod4-Shift
  swap:   Mod4-w
  view:   Mod4-v
  group:  Mod4-g

  ##
  # Direction keys.
  #
  up:    k
  down:  j
  left:  h
  right: l

  ##
  # Sequence keys.
  #
  prev: b
  next: n

  ##
  # Key bindings.
  #
  #   <key sequence>: <Ruby code to execute>
  #
  # A key sequence may contain ${...} expressions which
  # are replaced with the value corresponding to '...'
  # in the 'control' section of this configuration file.
  #
  # For example, if the 'control' section of
  # this configuration file appeared like this:
  #
  #   control:
  #     foo: Mod4
  #     bar: y
  #
  # and the following key sequence was used:
  #
  #   ${foo}-${bar},${bar}
  #
  # then after ${...} expression replacement,
  # that key sequence would appear like this:
  #
  #   Mod4-y,y
  #
  key:
    #---------------------------------------------------------------------------
    # focus
    #---------------------------------------------------------------------------

    ${mod}-${up}: | # focus above client
      curr_view.select(:up) rescue nil

    ${mod}-${down}: | # focus below client
      curr_view.select(:down) rescue nil

    ${mod}-${left}: | # focus left client
      curr_view.select(:left) rescue nil

    ${mod}-${right}: | # focus right client
      curr_view.select(:right) rescue nil

    ${mod}-space: | # focus floating area (toggle)
      curr_view.select(:toggle)

    ${mod}-${prev}: | # focus previous view
      prev_view.focus

    ${mod}-${next}: | # focus next view
      next_view.focus

    # focus the view whose index or name equals the pressed number
    ${mod}-1: focus_view tags[0] || 1
    ${mod}-2: focus_view tags[1] || 2
    ${mod}-3: focus_view tags[2] || 3
    ${mod}-4: focus_view tags[3] || 4
    ${mod}-5: focus_view tags[4] || 5
    ${mod}-6: focus_view tags[5] || 6
    ${mod}-7: focus_view tags[6] || 7
    ${mod}-8: focus_view tags[7] || 8
    ${mod}-9: focus_view tags[8] || 9
    ${mod}-0: focus_view tags[9] || 10

    # focus the view whose name begins with the pressed alphabet
    ${view},a: t = tags.grep(/^a/i).first and focus_view(t)
    ${view},b: t = tags.grep(/^b/i).first and focus_view(t)
    ${view},c: t = tags.grep(/^c/i).first and focus_view(t)
    ${view},d: t = tags.grep(/^d/i).first and focus_view(t)
    ${view},e: t = tags.grep(/^e/i).first and focus_view(t)
    ${view},f: t = tags.grep(/^f/i).first and focus_view(t)
    ${view},g: t = tags.grep(/^g/i).first and focus_view(t)
    ${view},h: t = tags.grep(/^h/i).first and focus_view(t)
    ${view},i: t = tags.grep(/^i/i).first and focus_view(t)
    ${view},j: t = tags.grep(/^j/i).first and focus_view(t)
    ${view},k: t = tags.grep(/^k/i).first and focus_view(t)
    ${view},l: t = tags.grep(/^l/i).first and focus_view(t)
    ${view},m: t = tags.grep(/^m/i).first and focus_view(t)
    ${view},n: t = tags.grep(/^n/i).first and focus_view(t)
    ${view},o: t = tags.grep(/^o/i).first and focus_view(t)
    ${view},p: t = tags.grep(/^p/i).first and focus_view(t)
    ${view},q: t = tags.grep(/^q/i).first and focus_view(t)
    ${view},r: t = tags.grep(/^r/i).first and focus_view(t)
    ${view},s: t = tags.grep(/^s/i).first and focus_view(t)
    ${view},t: t = tags.grep(/^t/i).first and focus_view(t)
    ${view},u: t = tags.grep(/^u/i).first and focus_view(t)
    ${view},v: t = tags.grep(/^v/i).first and focus_view(t)
    ${view},w: t = tags.grep(/^w/i).first and focus_view(t)
    ${view},x: t = tags.grep(/^x/i).first and focus_view(t)
    ${view},y: t = tags.grep(/^y/i).first and focus_view(t)
    ${view},z: t = tags.grep(/^z/i).first and focus_view(t)

    #---------------------------------------------------------------------------
    # move
    #---------------------------------------------------------------------------

    ${move}-${up}: | # move grouping toward the top
      grouping.each {|c| c.send(:up) rescue nil }

    ${move}-${down}: | # move grouping toward the bottom
      grouping.each {|c| c.send(:down) rescue nil }

    ${move}-${left}: | # move grouping toward the left
      grouping.each {|c| c.send(:left) rescue nil }

    ${move}-${right}: | # move grouping toward the right
      grouping.each {|c| c.send(:right) rescue nil }

    ${move}-space: | # move grouping to floating area (toggle)
      grouping.each {|c| c.send(:toggle) rescue nil }

    ${move}-t: | # move grouping to chosen view
      #
      # Changes the tag (according to a menu choice) of
      # each grouped client and returns the chosen tag.
      #
      # The +tag -tag idea is from Jonas Pfenniger:
      #
      #   http://zimbatm.oree.ch/articles/2006/06/15/wmii-3-and-ruby
      #
      choices = tags.map {|t| [t, "+#{t}", "-#{t}"] }.flatten

      if target = key_menu(choices, 'tag as:')
        grouping.each {|c| c.tags = target }
      end

    # move grouping to the view whose index or name equals the pressed number
    ${move}-1: grouping.each {|c| c.tags = tags[0] || 1  }
    ${move}-2: grouping.each {|c| c.tags = tags[1] || 2  }
    ${move}-3: grouping.each {|c| c.tags = tags[2] || 3  }
    ${move}-4: grouping.each {|c| c.tags = tags[3] || 4  }
    ${move}-5: grouping.each {|c| c.tags = tags[4] || 5  }
    ${move}-6: grouping.each {|c| c.tags = tags[5] || 6  }
    ${move}-7: grouping.each {|c| c.tags = tags[6] || 7  }
    ${move}-8: grouping.each {|c| c.tags = tags[7] || 8  }
    ${move}-9: grouping.each {|c| c.tags = tags[8] || 9  }
    ${move}-0: grouping.each {|c| c.tags = tags[9] || 10 }

    #---------------------------------------------------------------------------
    # group
    #---------------------------------------------------------------------------

    ${group},g: | # toggle current client from grouping
      curr_client.group!

    ${group},c: | # add clients in current area to grouping
      curr_area.group

    ${group},Shift-c: | # remove clients in current area from grouping
      curr_area.ungroup

    ${group},f: | # add clients in floating area to grouping
      Area.floating.group

    ${group},Shift-f: | # remove clients in floating area from grouping
      Area.floating.ungroup

    ${group},m: | # add clients in managed areas to grouping
      curr_view.managed_areas.each {|a| a.group }

    ${group},Shift-m: | # remove clients in managed areas from grouping
      curr_view.managed_areas.each {|a| a.ungroup }

    ${group},v: | # add clients in current view to grouping
      curr_view.group

    ${group},Shift-v: | # remove clients in current view from grouping
      curr_view.ungroup

    ${group},i: | # invert the grouping in the current view
      curr_view.group!

    ${group},Shift-i: | # invert the grouping in all views
      Rumai.group!

    ${group},n: | # remove all clients everywhere from grouping
      Rumai.ungroup

    #---------------------------------------------------------------------------
    # swap
    #---------------------------------------------------------------------------

    ${swap},${up}: | # swap with above client
      curr_client.swap(:up) rescue nil

    ${swap},${down}: | # swap with below client
      curr_client.swap(:down) rescue nil

    ${swap},${left}: | # swap with left client
      curr_client.swap(:left) rescue nil

    ${swap},${right}: | # swap with right client
      curr_client.swap(:right) rescue nil

    # swap current client with the column whose index equals the pressed number
    ${swap},1: curr_client.swap 1
    ${swap},2: curr_client.swap 2
    ${swap},3: curr_client.swap 3
    ${swap},4: curr_client.swap 4
    ${swap},5: curr_client.swap 5
    ${swap},6: curr_client.swap 6
    ${swap},7: curr_client.swap 7
    ${swap},8: curr_client.swap 8
    ${swap},9: curr_client.swap 9
    ${swap},0: curr_client.swap 10

    #---------------------------------------------------------------------------
    # client
    #---------------------------------------------------------------------------

    ${mod}-f: | # zoom client to fullscreen (toggle)
      curr_client.fullscreen!

    ${mod}-Shift-c: | # kill the current client
      curr_client.kill

    #---------------------------------------------------------------------------
    # column
    #---------------------------------------------------------------------------

    ${mod}-d: | # apply equal-spacing layout to current column
      curr_area.layout = 'default-max'

    ${mod}-s: | # apply stacked layout to current column
      curr_area.layout = 'stack-max'

    ${mod}-m: | # apply maximized layout to current column
      curr_area.layout = 'stack+max'

    #---------------------------------------------------------------------------
    # menu
    #---------------------------------------------------------------------------

    ${mod}-a: | # run internal action chosen from a menu
      if choice = key_menu(actions, 'run action:')
        action choice
      end

    ${mod}-p: | # run external program chosen from a menu
      if choice = key_menu(@programs, 'run program:')
        launch choice
      end

    ${mod}-t: | # focus view chosen from a menu
      if choice = key_menu(tags, 'show view:')
        focus_view choice
      end

    #---------------------------------------------------------------------------
    # launcher
    #---------------------------------------------------------------------------

    ${mod}-Return: | # launch a terminal
      #
      # Launch a new terminal and set its
      # working directory to be the same
      # as the currently focused terminal.
      #
      work = ENV['HOME']

      label = curr_client.label.read rescue ''

      # iterate in reverse order because
      # paths are usually at end of label
      label.split(' ').reverse_each do |s|
        path = File.expand_path(s)

        if File.exist? path
          unless File.directory? path
            path = File.dirname(path)
          end

          work = path
          break
        end
      end

      require 'fileutils'
      FileUtils.cd work do
        launch CONFIG['program']['terminal']
      end

  ##
  # Event handlers.
  #
  #   <event name>: <Ruby code to execute>
  #
  # The Ruby code has access to an "argv" variable which
  # is a list of arguments that were passed to the event.
  #
  event:
    CreateTag: |
      tag = argv[0]
      but = fs.lbar[tag]
      but.create unless but.exist?
      but.write "#{CONFIG['display']['color']['normal']} #{tag}"

    DestroyTag: |
      tag = argv[0]
      but = fs.lbar[tag]
      but.remove if but.exist?

    FocusTag: |
      tag = argv[0]
      but = fs.lbar[tag]
      but.write "#{CONFIG['display']['color']['focus']} #{tag}" if but.exist?

    UnfocusTag: |
      tag = argv[0]
      but = fs.lbar[tag]
      but.write "#{CONFIG['display']['color']['normal']} #{tag}" if but.exist?

    UrgentTag: |
      tag = argv[1]
      but = fs.lbar[tag]
      but.write "#{CONFIG['display']['color']['notice']} #{tag}" if but.exist?

    NotUrgentTag: |
      tag = argv[1]
      but = fs.lbar[tag]
      color = curr_view.id == tag ? 'focus' : 'normal'
      but.write "#{CONFIG['display']['color'][color]} #{tag}" if but.exist?

    LeftBarClick: &LeftBarClick |
      mouse_button, view_id = argv

      if mouse_button == '1' # primary button
        focus_view view_id
      end

    ##
    # allows the user to drag a file over a
    # view button and activate that view while
    # still holding on to their dragged file!
    #
    LeftBarDND: *LeftBarClick

    RightBarClick: |
      status_click *argv.reverse

    ClientMouseDown: |
      client_id, mouse_button = argv

      if mouse_button == '3' # secondary button
        client = Client.new(client_id)

        case click_menu %w[stick group fullscreen kill slay], 'client'
        when 'stick'      then client.stick!
        when 'group'      then client.group!
        when 'fullscreen' then client.fullscreen!
        when 'kill'       then client.kill
        when 'slay'       then client.slay
        end
      end

  ##
  # Internal scripts.
  #
  #   <action name>: <Ruby code to execute>
  #
  action:


##
# Arbitrary logic.
#
#   script:
#     before: <Ruby code to execute before processing this file>
#     after:  <Ruby code to execute after processing this file>
#
script:
  before:
  after:

#!/usr/bin/env ruby
#
# Bootloader for wmii configuration.
#
#--
# Copyright protects this work.
# See LICENSE file for details.
#++

# create a logger to aid debugging
require 'logger'
LOG = Logger.new(__FILE__ + '.log', 5)

class << LOG
  # emulate IO.write
  alias write <<

  def flush
    # ignore
  end
end

# capture standard output in logger
$stdout = $stderr = LOG

begin
  LOG.info 'birth'

  # load configuration library
    def find_config file
      base_dirs = ENV['WMII_CONFPATH'].to_s.split(/:+/)
      ruby_dirs = base_dirs.map {|dir| File.join(dir, 'ruby') }

      Dir["{#{base_dirs.zip(ruby_dirs).join(',')}}/#{file}"].first
    end

    require find_config('config.rb')

  # terminate any existing wmiirc
    fs.event.write 'Start wmiirc'

    event 'Start' do |arg|
      exit if arg == 'wmiirc'
    end

  # apply user configuration
    load_config find_config('config.yaml')

  # setup tag bar (buttons that correspond to views)
    fs.lbar.clear
    tags.each {|t| event 'CreateTag', t }
    event 'FocusTag', curr_tag

  # register key bindings
    fs.keys.write keys.join("\n")
    event('Key') {|*a| key(*a) }

  # the main event loop
    fs.event.each_line do |line|
      line.split("\n").each do |call|
        name, args = call.split(' ', 2)

        argv = args.to_s.split(' ')
        event name, *argv
      end
    end

rescue SystemExit
  # ignore it; the program wants to terminate

rescue Exception => e
  LOG.error e

  # allow the user to rescue themselves
  system '@TERMINAL@ &'

  IO.popen('xmessage -nearmouse -file - -buttons Recover,Ignore -print', 'w+') do |f|
    f.puts e.inspect, e.backtrace
    f.close_write

    if f.read.chomp == 'Recover'
      reload_config
    end
  end

ensure
  LOG.info 'death'
end

ROOT=..
include $(ROOT)/mk/hdr.mk
include $(ROOT)/mk/wmii.mk

wmiir.c: $(ROOT)/mk/wmii.mk

DIRS =	menu \
	strut \
	tray \
	wmii \
	x11
TARG =	wihack    \
	wmii.rc   \
	wmii.sh   \
	wmiir

LIBS += $(LIBS9) $(LIBIXP)

include $(ROOT)/mk/many.mk
include $(ROOT)/mk/dir.mk

ROOT= ../..
include $(ROOT)/mk/hdr.mk
include $(ROOT)/mk/wmii.mk

main.c: $(ROOT)/mk/wmii.mk

bindings.c: keys.txt Makefile
	( echo "char binding_spec[] ="; \
	  sed 's/.*/	"&\\n"/' keys.txt; \
	  echo "	;" ) >$@

TARG =	wimenu
HFILES=	dat.h fns.h
TAGFILES= dat.h $(ROOT)/include/*.h $(ROOT)/include/stuff/*.h

PACKAGES += $(X11PACKAGES)

LIB = $(LIBS9) $(LIBIXP)
LIBS += -lm
OBJ =	main	\
	caret	\
	history	\
	menu	\
	keys	\
	bindings

include $(ROOT)/mk/one.mk

#include "dat.h"
#include <ctype.h>
#include <string.h>
#include "fns.h"

static int
iswordrune(Rune r) {
	if(isalpharune(r))
		return 1;
	return r < 0x80 && (r == '_' || isdigit(r));
}

static char*
prev_rune(char *start, char *p, Rune *r) {

	*r = 0;
	if(p == start)
		return p;
	while(p > start && (*(--p)&0xC0) == 0x80)
		;
	chartorune(r, p);
	return p;
}

static char*
next_rune(char *p, Rune *r) {
	int i;

	*r = 0;
	if(!*p)
		return p;
	i = chartorune(r, p);
	return p + i;
}

void
caret_set(int start, int end) {
	int len;

	len = input.end - input.string;
	start = max(0, min(len, start));

	input.pos = input.string + start;
	if(end < 0)
		input.pos_end = nil;
	else
		input.pos_end = input.string + max(start, end);
}

char*
caret_find(int dir, int type) {
	char *end;
	char *next, *p;
	Rune r;
	int res;

	p = input.pos;
	if(dir == FORWARD) {
		end = input.end;
		switch(type) {
		case LINE:
			return end;
		case WORD:
			chartorune(&r, p);
			res = iswordrune(r);
			while(next=next_rune(p, &r), r && iswordrune(r) == res && !isspacerune(r))
				p = next;
			while(next=next_rune(p, &r), r && isspacerune(r))
				p = next;
			return p;
		case CHAR:
			return next_rune(p, &r);
		}
	}
	else if(dir == BACKWARD) {
		end = input.string;
		switch(type) {
		case LINE:
			return end;
		case WORD:
			while(next=prev_rune(end, p, &r), r && isspacerune(r))
				p = next;
			prev_rune(end, p, &r);
			res = iswordrune(r);
			while(next=prev_rune(end, p, &r), r && iswordrune(r) == res && !isspacerune(r))
				p = next;
			return p;
		case CHAR:
			return prev_rune(end, p, &r);
		}
	}
	input.pos_end = nil;
	return input.pos;
}

void
caret_move(int dir, int type) {
	input.pos = caret_find(dir, type);
	input.pos_end = nil;
}

void
caret_delete(int dir, int type) {
	char *pos, *p;
	int n;

	if(input.pos_end)
		p = input.pos_end;
	else
		p = caret_find(dir, type);
	pos = input.pos;
	if(p == input.end)
		input.end = pos;
	else {
		if(p < pos) {
			pos = p;
			p = input.pos;
		}
		n = input.end - p;
		memmove(pos, p, n);
		input.pos = pos;
		input.end = pos + n;
	}
	*input.end = '\0';
	input.pos_end = nil;
}

void
caret_insert(char *s, bool clear) {
	int pos, end, len, size;

	if(s == nil)
		return;
	if(clear) {
		input.pos = input.string;
		input.end = input.string;
	}else if(input.pos_end)
		caret_delete(0, 0);

	len = strlen(s);
	pos = input.pos - input.string;
	end = input.end - input.string;

	size = input.size;
	if(input.size == 0)
		input.size = 1;
	while(input.size < end + len + 1)
		input.size <<= 2;
	if(input.size != size)
		input.string = erealloc(input.string, input.size);

	input.pos = input.string + pos;
	input.end = input.string + end + len;
	*input.end = '\0';
	memmove(input.pos + len, input.pos, end - pos);
	memmove(input.pos, s, len);
	input.pos += len;
	input.pos_end = nil;
}

#define _XOPEN_SOURCE 600
#define IXP_P9_STRUCTS
#define IXP_NO_P9_
#include <fmt.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <ixp.h>
#include <stuff/x.h>
#include <stuff/util.h>

#ifndef EXTERN
# define EXTERN extern
#endif

enum {
	FORWARD,
	BACKWARD,
	LINE,
	WORD,
	CHAR,
	CARET_LAST,
};

enum {
	LACCEPT,
	LBACKWARD,
	LCHAR,
	LCOMPLETE,
	LDELETE,
	LFIRST,
	LFORWARD,
	LHISTORY,
	LKILL,
	LLAST,
	LLINE,
	LLITERAL,
	LNEXT,
	LNEXTPAGE,
	LPASTE,
	LPREV,
	LPREVPAGE,
	LREJECT,
	LWORD,
};

typedef struct Item	Item;

struct Item {
	char*	string;
	char*	retstring;
	Item*	next_link;
	Item*	next;
	Item*	prev;
	int	len;
	int	width;
};

EXTERN struct {
	char*	string;
	char*	end;
	char*	pos;
	char*	pos_end;
	int	size;

	char*	filter;
	int	filter_start;
} input;

EXTERN struct {
	Window*		win;
	Image*		buf;
	char*		prompt;
	int		height;
	int		rows;
	bool		ontop;
	Rectangle	itemr;
	Point		arrow;
} menu;

extern char	binding_spec[];

EXTERN IxpServer	srv;

EXTERN struct {
	Item*	all;
	Item*	first;
	Item*	start;
	Item*	end;
	Item*	sel;
	int	maxwidth;
} match;

Font*		font;
CTuple		cnorm;
CTuple		csel;

EXTERN Item	hist;
EXTERN Item*	histsel;

EXTERN int	itempad;
EXTERN int	result;

EXTERN char*	(*find)(const char*, const char*);
EXTERN int	(*compare)(const char*, const char*, size_t);

/* caret.c */
void	caret_delete(int, int);
char*	caret_find(int, int);
void	caret_insert(char*, bool);
void	caret_move(int, int);
void	caret_set(int, int);

/* history.c */
void	history_dump(const char*, int);
char*	history_search(int, char*, int);

/* main.c */
void	debug(int, const char*, ...);
Item*	filter_list(Item*, char*);
void	update_filter(bool);
void	update_input(void);

/* menu.c */
void	menu_draw(void);
void	menu_init(void);
void	menu_show(void);

/* keys.c */
void	parse_keys(char*);
char**	find_key(char*, long);
int	getsym(char*);

#include "dat.h"
#include <assert.h>
#include <bio.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include "fns.h"

static void
splice(Item *i) {
	if(i->next != nil)
		i->next->prev = i->prev;
	if(i->prev != nil)
		i->prev->next = i->next;
}

char*
history_search(int dir, char *string, int n) {
	Item *i;

	if(dir == FORWARD) {
		if(histsel == &hist)
			return hist.string;
		for(i=histsel->next; i != hist.next; i=i->next)
			if(!i->string || !compare(i->string, string, n)) {
				histsel = i;
				return i->string;
			}
		return string;
	}
	assert(dir == BACKWARD);

	if(histsel == &hist) {
		free(hist.string);
		hist.string = estrdup(input.string);
	}

	for(i=histsel->prev; i != &hist; i=i->prev)
		if(!compare(i->string, string, n)) {
			histsel = i;
			return i->string;
		}
	return string;
}

void
history_dump(const char *path, int max) {
	static char *items[20];
	static char *tmp;
	Biobuf b;
	Item *h, *first;
	int i, n, fd;

	SET(first);
	if(fork() != 0)
		return;

	tmp = smprint("%s.XXXXXX", path);
	fd = mkstemp(tmp);
	if(fd < 0) {
		fprint(2, "%s: Can't create temporary history file %q: %r\n", argv0, path);
		_exit(1);
	}

	hist.string = input.string;
	n = 0;
	hist.next->prev = nil;
	for(h=&hist; h; h=h->prev) {
		for(i=0; i < nelem(items); i++)
			if(items[i] && !strcmp(h->string, items[i])) {
				splice(h);
				goto next;
			}
		items[n++ % nelem(items)] = h->string;
		first = h;
		if(!max || n >= max)
			break;
	next:
		continue;
	}

	Binit(&b, fd, OWRITE);
	hist.next = nil;
	for(h=first; h; h=h->next)
		if(Bprint(&b, "%s\n", h->string) < 0) {
			unlink(tmp);
			fprint(2, "%s: Can't write temporary history file %q: %r\n", argv0, path);
			_exit(1);
		}
	Bterm(&b);
	rename(tmp, path);
	_exit(0);
}

#include "dat.h"
#include <ctype.h>
#include <strings.h>
#include <unistd.h>
#include "fns.h"

typedef struct Key Key;

struct Key {
	Key*	next;
	long	mask;
	char*	key;
	char**	action;
};

static Key*	bindings;
static int	numlock;

/*
 * To do: Find my red black tree implementation.
 */
void
parse_keys(char *spec) {
	static char *lines[1024];
	static char *words[16];
	Key *k;
	char *p, *line;
	int mask;
	int i, nlines, nwords;

	if(!numlock)
		numlock = numlockmask();

	nlines = tokenize(lines, nelem(lines), spec, '\n');
	for(i=0; i < nlines; i++) {
		line = lines[i];
		p = strchr(line, '#');
		if(p)
			*p = '\0';

		nwords = stokenize(words, nelem(words) - 1, line, " \t");
		words[nwords] = nil;
		if(!words[0])
			continue;
		if(parsekey(words[0], &mask, &p)) {
			k = emallocz(sizeof *k);
			k->key    = p;
			k->mask   = mask;
			k->action = strlistdup(words + 1);
			k->next   = bindings;
			bindings = k;
		}
	}
}

char**
find_key(char *key, long mask) {
	Key *k;

	/* Horrible hack. */
	if(!strcmp(key, "ISO_Left_Tab"))
		key = "Tab";

	mask &= ~(numlock | LockMask) & ((1<<8) - 1);
	for(k=bindings; k; k=k->next)
		if(!strcasecmp(k->key, key) && k->mask == mask)
			return k->action;
	return nil;
}

	/* sed 's/"([^"]+)"/L\1/g' | tr 'a-z' 'A-Z' */
	/* awk '{$1=""; print}' keys.txt | perl -e '$_=lc join "", <>; print join "\n", m/(\w+)/g;' | sort -u | sed 's:.*:	"&",:' */
char *symtab[] = {
	"accept",
	"backward",
	"char",
	"complete",
	"delete",
	"first",
	"forward",
	"history",
	"kill",
	"last",
	"line",
	"literal",
	"next",
	"nextpage",
	"paste",
	"prev",
	"prevpage",
	"reject",
	"word",
};

static int
_bsearch(char *s, char **tab, int ntab) {
	int i, n, m, cmp;

	if(s == nil)
		return -1;

	n = ntab;
	i = 0;
	while(n) {
		m = n/2;
		cmp = strcasecmp(s, tab[i+m]);
		if(cmp == 0)
			return i+m;
		if(cmp < 0 || m == 0)
			n = m;
		else {
			i += m;
			n = n-m;
		}
	}
	return -1;
}

int
getsym(char *s) {
	return _bsearch(s, symtab, nelem(symtab));
}

Control-j           Accept
Control-m           Accept
Return              Accept
Control-Shift-j     Accept literal
Control-Shift-m     Accept literal
Shift-Return        Accept literal

Escape		    Reject
Control-Bracketleft Reject

Left                Backward char
Control-b           Backward char
Right               Forward  char
Control-f           Forward  char

Mod1-b              Backward word
Mod1-f              Forward  word

Control-a           Backward line
Control-e           Forward  line

Control-p           History backward
Up                  History backward
Control-n           History forward
Down                History forward

Backspace           Kill char
Control-h           Kill char
Control-Backspace   Kill word
Control-w           Kill word
Control-u           Kill line
Control-k           Delete line

Tab                 Complete next
Control-i           Complete next
Mod1-l              Complete next

Mod1-p	            Paste PRIMARY

Shift-Tab           Complete prev
Control-Shift-i     Complete prev
Mod1-h              Complete prev

Prior               Complete prevpage
Mod1-k              Complete prevpage
Next                Complete nextpage
Mod1-j              Complete nextpage
Home                Complete first
Mod1-g              Complete first
End                 Complete last
Mod1-Shift-g        Complete last

/* Copyright ©2006-2010 Kris Maglione <maglione.k at Gmail>
 * See LICENSE file for license details.
 */
#define EXTERN
#include "dat.h"
#include <X11/Xproto.h>
#include <locale.h>
#include <strings.h>
#include <unistd.h>
#include <bio.h>
#include <stuff/clientutil.h>
#include "fns.h"
#define link _link

static const char version[] = "wimenu-"VERSION", "COPYRIGHT"\n";
static Biobuf*	cmplbuf;
static Biobuf*	inbuf;
static bool	alwaysprint;
static char*	cmdsep;
static int	screen_hint;

static void
usage(void) {
	fprint(2, "usage: %s -i [-a <address>] [-h <history>] [-p <prompt>] [-r <rows>] [-s <screen>]\n", argv0);
	fprint(2, "       See manual page for full usage details.\n");
	exit(1);
}

static int
errfmt(Fmt *f) {
	return fmtstrcpy(f, ixp_errbuf());
}

static inline void
splice(Item *i) {
	i->next->prev = i->prev;
	i->prev->next = i->next;
}
static inline void
link(Item *i, Item *j) {
	i->next = j;
	j->prev = i;
}

static Item*
populate_list(Biobuf *buf, bool hist) {
	Item ret;
	Item *i;
	char *p;
	bool stop;

	stop = !hist && !isatty(buf->fid);
	ret.next_link = nil;
	i = &ret;
	while((p = Brdstr(buf, '\n', true))) {
		if(stop && p[0] == '\0')
			break;
		i->next_link = emallocz(sizeof *i);
		i = i->next_link;
		i->string = p;
		i->retstring = p;
		if(cmdsep && (p = strstr(p, cmdsep))) {
			*p = '\0';
			i->retstring = p + strlen(cmdsep);
		}
		if(!hist) {
			i->len = strlen(i->string);
			i->width = textwidth_l(font, i->string, i->len) + itempad;
			match.maxwidth = max(i->width, match.maxwidth);
		}
	}

	return ret.next_link;
}

static void
check_competions(IxpConn *c) {
	char *s;

	s = Brdstr(cmplbuf, '\n', true);
	if(!s) {
		ixp_hangup(c);
		return;
	}
	input.filter_start = strtol(s, nil, 10);
	match.all = populate_list(cmplbuf, false);
	update_filter(false);
	menu_draw();
}

Item*
filter_list(Item *i, char *filter) {
	static Item exact;
	Item start, substr;
	Item *exactp, *startp, *substrp;
	Item **ip;
	char *p;
	int len;

	len = strlen(filter);
	exactp = &exact;
	startp = &start;
	substrp = &substr;
	for(; i; i=i->next_link)
		if((p = find(i->string, filter))) {
			ip = &substrp;
			if(p == i->string)
				if(strlen(p) == len)
					ip = &exactp;
				else
					ip = &startp;
			link(*ip, i);
			*ip = i;
		}

	link(substrp, &exact);
	link(startp,  &substr);
	link(exactp,  &start);
	splice(&substr);
	splice(&start);
	splice(&exact);
	return exact.next;
}

void
update_input(void) {
	if(alwaysprint) {
		write(1, input.string, input.pos - input.string);
		write(1, "\n", 1);
		write(1, input.pos, input.end - input.pos);
		write(1, "\n", 1);
	}
}

void
update_filter(bool print) {
	char *filter;

	filter = input.string + min(input.filter_start, input.pos - input.string);
	if(input.pos < input.end)
		filter = freelater(estrndup(filter, input.pos - filter));

	match.sel = nil;
	match.first = match.start = filter_list(match.all, filter);
	if(print)
		update_input();
}

enum { PointerScreen = -1 };

void
init_screens(void) {
	Rectangle *rects;
	Point p;
	int i, n;

	rects = xinerama_screens(&n);
	if(screen_hint >= 0 && screen_hint < n)
		i = screen_hint;
	else {
		/* Pick the screen with the pointer, for now. Later,
		 * try for the screen with the focused window first.
		 */
		p = querypointer(&scr.root);
		for(i=0; i < n; i++)
			if(rect_haspoint_p(rects[i], p))
				break;
		if(i == n)
			i = 0;
	}
	scr.rect = rects[i];
	menu_show();
}

ErrorCode ignored_xerrors[] = {
	{ 0, BadWindow },
	{ X_GetAtomName, BadAtom },
};

int
main(int argc, char *argv[]) {
	static char *address;
	static char *histfile;
	static char *keyfile;
	static bool nokeys;
	Item *item;
	int i;
	long ndump;

	setlocale(LC_ALL, "");
	fmtinstall('r', errfmt);
	quotefmtinstall();

	screen_hint = PointerScreen;

	find = strstr;
	compare = strncmp;

	ndump = -1;

	ARGBEGIN{
	case 'a':
		address = EARGF(usage());
		break;
	case 'c':
		alwaysprint = true;
		break;
	case 'h':
		histfile = EARGF(usage());
		break;
	case 'i':
		find = strcasestr;
		compare = strncasecmp;
		break;
	case 'K':
		nokeys = true;
	case 'k':
		keyfile = EARGF(usage());
		break;
	case 'n':
		ndump = strtol(EARGF(usage()), nil, 10);
		break;
	case 'p':
		menu.prompt = EARGF(usage());
		break;
	case 'r':
		menu.rows = strtol(EARGF(usage()), nil, 10);
		break;
	case 's':
		screen_hint = strtol(EARGF(usage()), nil, 10);
		break;
	case 'S':
		cmdsep = EARGF(usage());
		break;
	case 'v':
		lprint(1, "%s", version);
		return 0;
	default:
		usage();
	}ARGEND;

	if(argc)
		usage();

	initdisplay();

	xext_init();
	if(!isatty(0))
		menu_init();

	client_init(address);

	srv.preselect = event_preselect;
	ixp_listen(&srv, ConnectionNumber(display), nil, event_fdready, event_fdclosed);

	menu.ontop = !strcmp(readctl("/ctl", "bar "), "on top");
	client_readconfig(&cnorm, &csel, &font);

	itempad = (font->height & ~1) + font->pad.min.x + font->pad.max.x;

	cmplbuf = Bfdopen(0, OREAD);
	match.all = populate_list(cmplbuf, false);
	if(!isatty(cmplbuf->fid))
		ixp_listen(&srv, cmplbuf->fid, inbuf, check_competions, nil);

	caret_insert("", true);
	update_filter(false);

	if(!nokeys)
		parse_keys(binding_spec);
	if(keyfile) {
		i = open(keyfile, O_RDONLY);
		if(read(i, buffer, sizeof(buffer)) > 0)
			parse_keys(buffer);
	}

	histsel = &hist;
	link(&hist, &hist);
	if(histfile && (inbuf = Bopen(histfile, OREAD))) {
		item = filter_list(populate_list(inbuf, true), "");
		if(item->string) {
			link(item->prev, &hist);
			link(&hist, item);
		}
		Bterm(inbuf);
	}

	if(menu.win == nil)
		menu_init();

	init_screens();

	i = ixp_serverloop(&srv);
	if(i)
		fprint(2, "%s: error: %r\n", argv0);
	XCloseDisplay(display);

	if(ndump >= 0 && histfile && result == 0)
		history_dump(histfile, ndump);

	return result;
}

#include "dat.h"
#include <ctype.h>
#include <strings.h>
#include <unistd.h>
#include "fns.h"

static Handlers	handlers;
static int	promptw;

void
menu_init(void) {
	WinAttr wa;

	wa.event_mask = ExposureMask | KeyPressMask;
	menu.win = createwindow(&scr.root, Rect(-1, -1, 1, 1), scr.depth, InputOutput,
				&wa, CWEventMask);
	if(scr.xim)
		menu.win->xic = XCreateIC(scr.xim,
					  XNInputStyle, XIMPreeditNothing | XIMStatusNothing,
					  XNClientWindow, menu.win->xid,
					  XNFocusWindow, menu.win->xid,
					  nil);

	changeprop_long(menu.win, Net("WM_WINDOW_TYPE"), "ATOM", (long[]){ TYPE("MENU") }, 1);
	changeprop_string(menu.win, "_WMII_TAGS", "sel");
	changeprop_textlist(menu.win, "WM_CLASS", "STRING", (char*[3]){ "wimenu", "wimenu" });

	sethandler(menu.win, &handlers);
	mapwin(menu.win);

	int i = 0;
	while(!grabkeyboard(menu.win)) {
		if(i++ > 1000)
			fatal("can't grab keyboard");
		usleep(1000);
	}
}

void
menu_show(void) {
	Rectangle r;

	if(menu.prompt)
		promptw = textwidth(font, menu.prompt) + itempad;

	r = textextents_l(font, "<", 1, nil);
	menu.arrow = Pt(Dy(r) + itempad/2, Dx(r) + itempad/2);

	menu.height = labelh(font);

	freeimage(menu.buf);
	menu.buf = allocimage(Dx(scr.rect),
			      !!menu.rows * 2 * menu.arrow.y + (menu.rows + 1) * menu.height,
			      menu.win->depth);

	mapwin(menu.win);
	raisewin(menu.win);
	menu_draw();
}

/* I'd prefer to use ⌃ and ⌄, but few fonts support them. */
static void
drawarrow(Image *img, Rectangle r, int up, Color *col) {
	Point p[3], pt;

	pt = Pt(menu.arrow.x - itempad/2, menu.arrow.y - itempad/2 & ~1);

	p[1] = Pt(r.min.x + Dx(r)/2,	up ? r.min.y + itempad/4 : r.max.y - itempad/4);
	p[0] = Pt(p[1].x - pt.x/2,	up ? p[1].y + pt.y	 : p[1].y - pt.y);
	p[2] = Pt(p[1].x + pt.x/2,	p[0].y);
	drawpoly(img, p, nelem(p), CapProjecting, 1, col);
}

static Rectangle
slice(Rectangle *rp, int x, int y) {
	Rectangle r;

	r = *rp;
	if(x) rp->min.x += x, r.max.x = min(rp->min.x, rp->max.x);
	if(y) rp->min.y += y, r.max.y = min(rp->min.y, rp->max.y);
	return r;
}

static bool
nextrect(Item *i, Rectangle *rp, Rectangle *src) {
	Rectangle r;

	if(menu.rows)
		r = slice(src, 0, menu.height);
	else
		r = slice(src, i->width, 0);
	return (Dx(*src) >= 0 && Dy(*src) >= 0) && (*rp = r, 1);
}

void
menu_draw(void) {
	Rectangle barr, extent, itemr, inputr, r, r2;
	Item *item;
	int inputw, offset;

	barr = r2 = Rect(0, 0, Dx(menu.win->r), menu.height);

	inputw = max(match.maxwidth + textwidth_l(font, input.string, min(input.filter_start, strlen(input.string))),
		     max(itempad    + textwidth(font, input.string),
			 Dx(barr) / 3));

	/* Calculate items box, w/ and w/o arrows */
	if(menu.rows) {
		menu.itemr = barr;
		menu.itemr.max.y += Dy(barr) * (menu.rows - 1);
		if(menu.ontop)
			menu.itemr = rectaddpt(menu.itemr, Pt(0, Dy(barr)));
		itemr = menu.itemr;
		if(match.start != match.first)
			menu.itemr = rectaddpt(menu.itemr, Pt(0, menu.arrow.y));
	}
	else {
		itemr = r2;
		slice(&itemr, inputw + promptw, 0);
		menu.itemr = Rect(itemr.min.x + menu.arrow.x, itemr.min.y,
				  itemr.max.x - menu.arrow.x, itemr.max.y);
	}

	fill(menu.buf, menu.buf->r, &cnorm.bg);

	/* Draw items */
	item = match.start, r2 = menu.itemr;
	nextrect(item, &r, &r2);
	do {
		match.end = item;
		if(item->string)
			fillstring(menu.buf, font, r, West, item->string,
				   (item == match.sel ? &csel : &cnorm), 0);
		item = item->next;
	} while(item != match.first && nextrect(item, &r, &r2));

	/* Adjust dimensions for arrows/number of items */
	if(menu.rows)
		itemr.max.y = r.max.y + (match.end->next != match.first ? menu.arrow.y : 0);
	else
		itemr.max.x = r.max.x + menu.arrow.x;
	if(menu.rows && !menu.ontop)
		barr = rectaddpt(barr, Pt(0, itemr.max.y));

	/* Draw indicators */
	if(!menu.rows && match.start != match.first)
		drawstring(menu.buf, font, itemr, West, "<", &cnorm.fg);
	if(!menu.rows && match.end->next != match.first)
		drawstring(menu.buf, font, itemr, East, ">", &cnorm.fg);

	if(menu.rows && match.start != match.first)
		drawarrow(menu.buf, itemr, 1, &cnorm.fg);
	if(menu.rows && match.end->next != match.first)
		drawarrow(menu.buf, itemr, 0, &cnorm.fg);

	/* Draw prompt */
	r2 = barr;
	if(menu.prompt)
		drawstring(menu.buf, font, slice(&r2, promptw, 0),
			   West, menu.prompt, &cnorm.fg);

	/* Border input/horizontal items */
	border(menu.buf, r2, 1, &cnorm.border);

	/* Draw input */
	inputr = slice(&r2, inputw, 0);
	drawstring(menu.buf, font, inputr, West, input.string, &cnorm.fg);

	/* Draw cursor */
	extent = textextents_l(font, input.string, input.pos - input.string, &offset);
	r2 = insetrect(inputr, 2);
	r2.min.x = inputr.min.x - extent.min.x + offset + font->pad.min.x + itempad/2 - 1;
	r2.max.x = r2.min.x + 1;
	fill(menu.buf, r2, &cnorm.border);

	/* Reshape window */
	r = scr.rect;
	if(menu.ontop)
		r.max.y = r.min.y + itemr.max.y;
	else
		r.min.y = r.max.y - barr.max.y;
	reshapewin(menu.win, r);

	/* Border window */
	r = rectsubpt(r, r.min);
	border(menu.buf, r, 1, &cnorm.border);
	copyimage(menu.win, r, menu.buf, ZP);
}

static Item*
pagestart(Item *i) {
	Rectangle r, r2;

	r = menu.itemr;
	nextrect(i, &r2, &r);
	while(i->prev != match.first->prev && nextrect(i->prev, &r2, &r))
		i = i->prev;
	return i;
}

static void
selectitem(Item *i) {
	if(i != match.sel) {
		caret_set(input.filter_start, input.pos - input.string);
		caret_insert(i->string, 0);
		match.sel = i;
		if(i == match.start->prev)
			match.start = pagestart(i);
		if(i == match.end->next)
			match.start = i;
	}
}

static void
paste(void *aux, char *str) {
	if(str)
		caret_insert(str, false);
	menu_draw();
}

static bool
kdown_event(Window *w, void *aux, XKeyEvent *e) {
	char **action, **p;
	char *key;
	char buf[128];
	int num, status;
	KeySym ksym;

	if(XFilterEvent((XEvent*)e, w->xid))
		return false;

	status = XLookupBoth;
	if(w->xic)
		num = Xutf8LookupString(w->xic, e, buf, sizeof buf - 1, &ksym, &status);
	else
		num = XLookupString(e, buf, sizeof buf - 1, &ksym, nil);

	if(status != XLookupChars && status != XLookupKeySym && status != XLookupBoth)
		return false;

	if(status == XLookupKeySym || status == XLookupBoth) {
		key = XKeysymToString(ksym);
		if(IsKeypadKey(ksym))
			if(ksym == XK_KP_Enter)
				ksym = XK_Return;
			else if(ksym >= XK_KP_0 && ksym <= XK_KP_9)
				ksym = (ksym - XK_KP_0) + XK_0;

		if(IsFunctionKey(ksym)
		|| IsMiscFunctionKey(ksym)
		|| IsKeypadKey(ksym)
		|| IsPrivateKeypadKey(ksym)
		|| IsPFKey(ksym))
			return false;
		action = find_key(key, e->state);
	}

	if(status == XLookupChars || action == nil || action[0] == nil) {
		if(num && !iscntrl(buf[0])) {
			buf[num] = '\0';
			caret_insert(buf, false);
			update_filter(true);
			menu_draw();
		}
	}
	else {
		long mask = 0;
#		define have(val) !!(mask & (1 << val))
		for(p=action+1; *p; p++)
			mask |= 1 << getsym(*p);
		int amount = (
			have(LCHAR) ? CHAR :
			have(LWORD) ? WORD :
			have(LLINE) ? LINE :
			-1);

		switch(getsym(action[0])) {
		default:
			return false;
		case LHISTORY:
			num = input.pos - input.string;
			amount = have(LBACKWARD) ? BACKWARD : FORWARD;
			caret_insert(history_search(amount, input.string, num), true);
			input.pos = input.string + num;
			update_filter(true);
			break;
		case LKILL:
			caret_delete(BACKWARD, amount);
			update_filter(true);
			break;
		case LDELETE:
			caret_delete(FORWARD, amount);
			update_filter(true);
			break;

		case LACCEPT:
			srv.running = false;
			if(!have(LLITERAL) && !match.sel && match.start->retstring)
				if(input.filter_start == 0 && input.pos == input.end)
					selectitem(match.start);

			if(!have(LLITERAL) && match.sel && !strcmp(input.string, match.sel->string))
				lprint(1, "%s", match.sel->retstring);
			else
				lprint(1, "%s", input.string);
			break;
		case LBACKWARD:
			caret_move(BACKWARD, amount);
			update_input();
			break;
		case LCOMPLETE:
			if(have(LNEXT))
				selectitem(match.sel ? match.sel->next : match.first);
			else if(have(LPREV))
				selectitem((match.sel ? match.sel : match.start)->prev);
			else if(have(LFIRST)) {
				match.start = match.first;
				selectitem(match.start);
			}
			else if(have(LLAST))
				selectitem(match.first->prev);
			else if(have(LNEXTPAGE))
				selectitem(match.end->next);
			else if(have(LPREVPAGE)) {
				match.start = pagestart(match.start->prev);
				selectitem(match.start);
			}
			break;
		case LFORWARD:
			caret_move(FORWARD, amount);
			update_input();
			break;
		case LPASTE:
			getselection(action[1] ? action[1] : "PRIMARY", paste, nil);
			break;
		case LREJECT:
			srv.running = false;
			result = 1;
			break;
		}
		menu_draw();
	}
	return false;
}

static bool
expose_event(Window *w, void *aux, XExposeEvent *e) {

	USED(w);
	menu_draw();
	return false;
}

static Handlers handlers = {
	.expose = expose_event,
	.kdown = kdown_event,
};

ROOT= ../..
include $(ROOT)/mk/hdr.mk
include $(ROOT)/mk/wmii.mk

main.c: $(ROOT)/mk/wmii.mk

TARG =	wistrut
HFILES=	dat.h fns.h

PACKAGES += $(X11PACKAGES)

LIB = $(LIBS9)
LIBS += -lm
OBJ =	main	\
	ewmh	\
	win

include $(ROOT)/mk/one.mk

#include <fmt.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdlib.h>
#include <unistd.h>
#include <stuff/x.h>
#include <stuff/util.h>

#ifndef EXTERN
# define EXTERN extern
#endif

enum { DAuto, DHorizontal, DVertical };

EXTERN Handlers	handlers;
EXTERN int	direction;

/* Copyright ©2007-2010 Kris Maglione <maglione.k at Gmail>
 * See LICENSE file for license details.
 */
#include "dat.h"
#include <limits.h>
#include <string.h>
#include "fns.h"

enum {
	Left, Right, Top, Bottom,
	LeftMin, LeftMax,
	RightMin, RightMax,
	TopMin, TopMax,
	BottomMin, BottomMax,
	Last
};

void
ewmh_getstrut(Window *w, Rectangle struts[4]) {
	long *strut;
	ulong n;

	memset(struts, 0, sizeof struts);

	n = getprop_long(w, Net("WM_STRUT_PARTIAL"), "CARDINAL",
		0L, &strut, Last);
	if(n != Last) {
		free(strut);
		n = getprop_long(w, Net("WM_STRUT"), "CARDINAL",
			0L, &strut, 4L);
		if(n != 4) {
			free(strut);
			return;
		}
		strut = erealloc(strut, Last * sizeof *strut);
		strut[LeftMin] = strut[RightMin] = 0;
		strut[LeftMax] = strut[RightMax] = INT_MAX;
		strut[TopMin] = strut[BottomMin] = 0;
		strut[TopMax] = strut[BottomMax] = INT_MAX;
	}
	struts[Left] =   Rect(0,                strut[LeftMin],  strut[Left],      strut[LeftMax]);
	struts[Right] =  Rect(-strut[Right],    strut[RightMin], 0,                strut[RightMax]);
	struts[Top] =    Rect(strut[TopMin],    0,               strut[TopMax],    strut[Top]);
	struts[Bottom] = Rect(strut[BottomMin], -strut[Bottom],  strut[BottomMax], 0);
	free(strut);
}

void
ewmh_setstrut(Window *w, Rectangle struts[4]) {
	long strut[Last];
	int i;

	strut[LeftMin] = struts[Left].min.y;
	strut[Left] = struts[Left].max.x;
	strut[LeftMax] = struts[Left].max.y;

	strut[RightMin] = struts[Right].min.y;
	strut[Right] = -struts[Right].min.x;
	strut[RightMax] = struts[Right].max.y;

	strut[TopMin] = struts[Top].min.x;
	strut[Top] = struts[Top].max.y;
	strut[TopMax] = struts[Top].max.x;

	strut[BottomMin] = struts[Bottom].min.x;
	strut[Bottom] = -struts[Bottom].min.y;
	strut[BottomMax] = struts[Bottom].max.x;

	for(i=0; i<Last; i++)
		if(strut[i] < 0)
			strut[i] = 0;

	changeprop_long(w, Net("WM_STRUT_PARTIAL"), "CARDINAL", strut, nelem(strut));
}

void	restrut(Window*);

void	ewmh_getstrut(Window*, Rectangle[4]);
void	ewmh_setstrut(Window*, Rectangle[4]);

/* Copyright ©2006-2010 Kris Maglione <maglione.k at Gmail>
 * See LICENSE file for license details.
 */
#define EXTERN
#include "dat.h"
#include <X11/Xproto.h>
#include <locale.h>
#include <string.h>
#include <time.h>
#include "fns.h"

static Window*	testwin;
static ulong	testtime[2];

static const char version[] = "wistrut-"VERSION", "COPYRIGHT"\n";

static void manage(ulong);

static void
usage(void) {
	fatal("usage: %s [-HV] <window|class>...\n", argv0);
}

static void
search_wins(char *pattern) {
	ulong *wins;
	ulong n, num;
	int i;
	char **class;
	Reprog *regexp;
	Window *win;

	regexp = regcomp(pattern);

	num = getprop_ulong(&scr.root, "_NET_CLIENT_LIST", "WINDOW", 0L, &wins, 1024L);
	for(i = 0; i < num; i++) {
		win = window(wins[i]);

		n = getprop_textlist(win, "WM_CLASS", &class);
		bufclear();
		bufprint("%s:%s:%s",
			 (n > 0 ? class[0] : "<nil>"),
			 (n > 1 ? class[1] : "<nil>"),
			 freelater(windowname(win)));
		freestringlist(class);
		if(regexec(regexp, buffer, nil, 0))
			manage(wins[i]);
	}
	free(wins);
}

static Window
findframe(Window *w) {
	XWindow *children;
	XWindow xw, par, root;
	Window ret = {0, };
	uint n;

	xw = w->xid;
	for(par=w->xid; par != scr.root.xid; ) {
		xw = par;
		XQueryTree(display, xw, &root, &par, &children, &n);
		XFree(children);
	}
	ret.type = WWindow;
	ret.xid = xw;
	ret.parent = &scr.root;
	return ret;
}

static void
getwinsize(Window *win) {
	int x, y;
	uint w, h;
	XWindow root;
	uint border, depth;

	XGetGeometry(display, win->xid, &root,
		     &x, &y, &w, &h,
		     &border, &depth);
	win->r = rectaddpt(Rect(0, 0, w, h),
			   Pt(x+border, y+border));
}

static bool
managable(ulong xid) {
	ulong *ret;
	ulong n;
	bool retval;

	n = getprop_ulong(window(xid), "_WMII_STRUT", "WINDOW", 0L, &ret, 1L);
	if(n < 0)
		retval = true;
	else {
		if(ret[0] == xid)
			retval = ret[0] != testtime[0] || ret[1] != testtime[1];
		else
			retval = managable(ret[0]);
	}
	free(ret);
	return retval;
}

static void
manage(ulong xid) {
	Window *frame;
	Window *win;

	if(!managable(xid))
		return;

	win = emallocz(sizeof *win);
	frame = emalloc(sizeof *frame);

	win->type = WWindow;
	win->xid = xid;
	*frame = findframe(win);
	frame->aux = win;

	getwinsize(frame);
	restrut(frame);
	sethandler(frame, &handlers);
	selectinput(frame, StructureNotifyMask);

	changeprop_ulong(frame, "_WMII_STRUT", "WINDOW", testtime, nelem(testtime));
}

int
main(int argc, char *argv[]) {
	ulong win;
	char *s;

	setlocale(LC_CTYPE, "");
	fmtinstall('E', fmtevent);

	ARGBEGIN{
	case 'H':
		direction = DHorizontal;
		break;
	case 'V':
		direction = DVertical;
		break;
	case 'v':
		lprint(1, "%s", version);
		return 0;
	default:
		usage();
	}ARGEND;

	initdisplay();

	testwin = createwindow(&scr.root, Rect(0, 0, 1, 1), 0,
			    InputOnly, nil, 0);
	testtime[0] = testwin->xid;
	testtime[1] = time(nil);

	while(argc) {
		s = ARGF();
		if(getulong(s, &win))
			manage(win);
		else
			search_wins(s);
	}

	changeprop_ulong(testwin, "_WMII_STRUT", "WINDOW", testtime, nelem(testtime));

	if(windowmap.nmemb > 0)
		event_loop();

	XCloseDisplay(display);
	return 0;
}