path: root/xlsclients.go

package main

import (
	"bytes"
	"flag"
	"fmt"
	"strings"
	"unicode"
	"xgob"
	"xgob/util/atom"
	"xgob/xproto"
	"xmu"
)

var display = flag.String("display", "", "Display to connect to")
var maxcmdlen = flag.Uint("max", 10000, "Maximum command length to show")
var all = flag.Bool("all", false, "Show all screens")
var verbose = flag.Bool("long", false, "Verbose output")

func initAtoms(c *xgob.Connection) {
	atom.PreloadAtom(c, "WM_STATE")

	/* The rest of these are pre-defined atoms.
	   They can be removed when we have a real xproto generator. */
	atom.PreloadAtom(c, "WM_CLIENT_MACHINE")
	atom.PreloadAtom(c, "WM_COMMAND")
	atom.PreloadAtom(c, "WM_NAME")
	atom.PreloadAtom(c, "WM_ICON_NAME")
	atom.PreloadAtom(c, "WM_CLASS")
	atom.PreloadAtom(c, "STRING")
}

func formatTextField(c *xgob.Connection, s string, t *xproto.GetPropertyReply) string {
	if t.Error != nil || t.Type == xproto.Atom(0) || t.Format == 0 {
		return "''"
	}

	rv := s

	if t.Type == atom.Atom(c, "STRING") && t.Format == 8 {
		rv += string(t.Value)
	} else {
		rv += "<unknown type "
		if t.Type == xproto.Atom(0) {
			rv += "None"
		} else {
			/* This should happen so rarely as to make no odds. Eat a round-trip: */
			rv += atom.AtomName(c, t.Type)
		}
		rv += fmt.Sprintf(" (%d) or format %d>", t.Type, t.Format)
	}

	if s != "" {
		rv += "\n"
	}
	return rv
}

func quotedWord(buf *bytes.Buffer, word []byte, maxlen uint) uint {
	quote := '\''
	otherQuote := '"'
	var printed uint

	/*
	 * walk down seeing whether or not we need to quote
	 */
	needQuote := false
	for _, c := range word {
		if !(c < 0x80 && (unicode.IsLetter(int(c)) || unicode.IsDigit(int(c))) ||
			(c == '-' || c == '_' || c == '.' || c == '+' ||
				c == '/' || c == '=' || c == ':' || c == ',')) {
			needQuote = true
			break
		}
	}

	/*
	 * write out the string: if we hit a quote, then close any previous quote,
	 * emit the other quote, swap quotes and continue on.
	 */
	inQuote := needQuote
	if needQuote {
		buf.WriteRune(quote)
		printed++
	}
	for _, c := range word {
		if int(c) == quote {
			if inQuote {
				buf.WriteRune(quote)
				printed++
			}
			buf.WriteRune(otherQuote)
			printed++
			tmp := otherQuote
			otherQuote = quote
			quote = tmp
			inQuote = true
		}
		buf.WriteRune(int(c))
		printed++
		if printed >= maxlen {
			break
		}
	}

	/* close the quote if we opened one and if we printed the whole string */
	if inQuote && printed < maxlen {
		buf.WriteRune(quote)
		printed++
	}

	return printed
}

func quotedWords(prop []byte) string {
	buf := bytes.NewBufferString("")

	charsleft := *maxcmdlen
	words := bytes.Split(prop, []byte{0}, -1)
	for i, word := range words {
		charsleft -= quotedWord(buf, word, charsleft)
		if i < len(words)-1 {
			if charsleft > 0 {
				buf.WriteRune(' ')
			} else {
				break
			}
		}
	}

	return buf.String()
}

func clientProperties(c *xgob.Connection, win xproto.Window, result chan string) {
	machineCookie := xproto.GetProperty(c, false, win, atom.Atom(c, "WM_CLIENT_MACHINE"), xproto.Atom(0), 0, 1000000)
	commandCookie := xproto.GetProperty(c, false, win, atom.Atom(c, "WM_COMMAND"), xproto.Atom(0), 0, 1000000)
	var nameCookie chan xproto.GetPropertyReply
	var iconNameCookie chan xproto.GetPropertyReply
	var classCookie chan xproto.GetPropertyReply
	if *verbose {
		nameCookie = xproto.GetProperty(c, false, win, atom.Atom(c, "WM_NAME"), xproto.Atom(0), 0, 1000000)
		iconNameCookie = xproto.GetProperty(c, false, win, atom.Atom(c, "WM_ICON_NAME"), xproto.Atom(0), 0, 1000000)
		classCookie = xproto.GetProperty(c, false, win, atom.Atom(c, "WM_CLASS"), xproto.Atom(0), 0, 1000000)
	}
	c.Flush()

	machine := <-machineCookie
	command := <-commandCookie

	if command.Error != nil || command.Format != 8 {
		result <- ""
		return
	}

	var name, iconName, class xproto.GetPropertyReply
	if *verbose {
		name = <-nameCookie
		iconName = <-iconNameCookie
		class = <-classCookie
	}

	list := make([]string, 0)

	// Header
	if *verbose {
		list = append(list, fmt.Sprintf("Window 0x%X:\n", win))
		list = append(list, formatTextField(c, "  Machine:  ", &machine))
		if name.Error == nil && name.Type != 0 {
			list = append(list, formatTextField(c, "  Name:  ", &name))
		}
		if iconName.Error == nil && iconName.Type != 0 {
			list = append(list, formatTextField(c, "  Icon Name:  ", &iconName))
		}
	} else {
		list = append(list, formatTextField(c, "", &machine))
	}

	// Command
	commandHeader := "  "
	if *verbose {
		commandHeader = "  Command:  "
	}
	list = append(list, commandHeader)
	list = append(list, quotedWords(command.Value))
	list = append(list, "\n")

	// Trailer
	if *verbose {
		if class.Error == nil && class.Type != xproto.Atom(0) {
			name := ""
			cls := "(nil)"
			index := bytes.IndexByte(class.Value, 0)
			if index >= 0 {
				name = string(class.Value[:index])
				cls = string(class.Value[index+1:])
			} else {
				name = string(class.Value)
			}
			list = append(list, fmt.Sprintf("  Instance/Class: %s/%s\n", name, cls))
		}
	}
	result <- strings.Join(list, "")
}

func findClientProperties(c *xgob.Connection, win xproto.Window, result chan string) {
	client := xmu.ClientWindow(c, win)
	if client == xproto.Window(0) {
		result <- ""
		return
	}
	clientProperties(c, client, result)
}

func lookat(c *xgob.Connection, root xproto.Window, result chan string) {
	var count uint
	prop := make(chan string)

	/*
	 * clients are not allowed to stomp on the root and ICCCM doesn't yet
	 * say anything about window managers putting stuff there; but, try
	 * anyway.
	 */
	go clientProperties(c, root, prop)
	count++

	treeCookie := xproto.QueryTree(c, root)
	c.Flush()
	tree := <-treeCookie
	for _, child := range tree.Children {
		go findClientProperties(c, child, prop)
		count++
	}

	list := make([]string, 0, count)
	for i := uint(0); i < count; i++ {
		list = append(list, <-prop)
	}
	result <- strings.Join(list, "")
}

func main() {
	flag.Parse()
	c, screen := xgob.Connect(*display)

	if c.HasError() {
		println("Cannot open display", *display)
		return
	}

	if screen >= len(c.Setup.Roots) && !*all {
		println("Invalid Screen", screen)
		return
	}

	initAtoms(c)

	results := make([]chan string, 0)

	if *all {
		for _, r := range c.Setup.Roots {
			out := make(chan string)
			go lookat(c, xproto.Window(r.Root), out)
			results = append(results, out)
		}
	} else {
		out := make(chan string)
		go lookat(c, xproto.Window(c.Setup.Roots[screen].Root), out)
		results = append(results, out)
	}

	for _, result := range results {
		fmt.Print(<-result)
	}
}