Initial commit

vendor/go.i3wm.org/i3/tree.go

@@ -0,0 +1,164 @@
+package i3
+
+import (
+	"encoding/json"
+)
+
+// NodeType indicates the specific kind of Node.
+type NodeType string
+
+// i3 currently implements the following node types:
+const (
+	Root          NodeType = "root"
+	OutputNode    NodeType = "output"
+	Con           NodeType = "con"
+	FloatingCon   NodeType = "floating_con"
+	WorkspaceNode NodeType = "workspace"
+	DockareaNode  NodeType = "dockarea"
+)
+
+// Layout indicates the layout of a Node.
+type Layout string
+
+// i3 currently implements the following layouts:
+const (
+	SplitH         Layout = "splith"
+	SplitV         Layout = "splitv"
+	Stacked        Layout = "stacked"
+	Tabbed         Layout = "tabbed"
+	DockareaLayout Layout = "dockarea"
+	OutputLayout   Layout = "output"
+)
+
+// BorderStyle indicates the border style of a node.
+type BorderStyle string
+
+// i3 currently implements the following border styles:
+const (
+	NormalBorder BorderStyle = "normal"
+	NoBorder     BorderStyle = "none"
+	PixelBorder  BorderStyle = "pixel"
+)
+
+// Rect is a rectangle, used for various dimensions in Node, for example.
+type Rect struct {
+	X      int64 `json:"x"`
+	Y      int64 `json:"y"`
+	Width  int64 `json:"width"`
+	Height int64 `json:"height"`
+}
+
+// WindowProperties correspond to X11 window properties
+//
+// See https://build.i3wm.org/docs/ipc.html#_tree_reply
+type WindowProperties struct {
+	Title     string `json:"title"`
+	Instance  string `json:"instance"`
+	Class     string `json:"class"`
+	Role      string `json:"window_role"`
+	Transient NodeID `json:"transient_for"`
+}
+
+// NodeID is an i3-internal ID for the node, which can be used to identify
+// containers within the IPC interface.
+type NodeID int64
+
+// Node is a node in a Tree.
+//
+// See https://i3wm.org/docs/ipc.html#_tree_reply for more details.
+type Node struct {
+	ID                 NodeID           `json:"id"`
+	Name               string           `json:"name"` // window: title, container: internal name
+	Type               NodeType         `json:"type"`
+	Border             BorderStyle      `json:"border"`
+	CurrentBorderWidth int64            `json:"current_border_width"`
+	Layout             Layout           `json:"layout"`
+	Percent            float64          `json:"percent"`
+	Rect               Rect             `json:"rect"`        // absolute (= relative to X11 display)
+	WindowRect         Rect             `json:"window_rect"` // window, relative to Rect
+	DecoRect           Rect             `json:"deco_rect"`   // decoration, relative to Rect
+	Geometry           Rect             `json:"geometry"`    // original window geometry, absolute
+	Window             int64            `json:"window"`      // X11 window ID of the client window
+	WindowProperties   WindowProperties `json:"window_properties"`
+	Urgent             bool             `json:"urgent"` // urgency hint set
+	Focused            bool             `json:"focused"`
+	Focus              []NodeID         `json:"focus"`
+	Nodes              []*Node          `json:"nodes"`
+	FloatingNodes      []*Node          `json:"floating_nodes"`
+}
+
+// FindChild returns the first Node matching predicate, using pre-order
+// depth-first search.
+func (n *Node) FindChild(predicate func(*Node) bool) *Node {
+	if predicate(n) {
+		return n
+	}
+	for _, c := range n.Nodes {
+		if con := c.FindChild(predicate); con != nil {
+			return con
+		}
+	}
+	for _, c := range n.FloatingNodes {
+		if con := c.FindChild(predicate); con != nil {
+			return con
+		}
+	}
+	return nil
+}
+
+// FindFocused returns the first Node matching predicate from the sub-tree of
+// directly and indirectly focused containers.
+//
+// As an example, consider this layout tree (simplified):
+//
+//       root
+//         │
+//       HDMI2
+//        ╱ ╲
+//      …  workspace 1
+//           ╱ ╲
+//      XTerm   Firefox
+//
+// In this example, if Firefox is focused, FindFocused will return the first
+// container matching predicate of root, HDMI2, workspace 1, Firefox (in this
+// order).
+func (n *Node) FindFocused(predicate func(*Node) bool) *Node {
+	if predicate(n) {
+		return n
+	}
+	if len(n.Focus) == 0 {
+		return nil
+	}
+	first := n.Focus[0]
+	for _, c := range n.Nodes {
+		if c.ID == first {
+			return c.FindFocused(predicate)
+		}
+	}
+	for _, c := range n.FloatingNodes {
+		if c.ID == first {
+			return c.FindFocused(predicate)
+		}
+	}
+	return nil
+}
+
+// Tree is an i3 layout tree, starting with Root.
+type Tree struct {
+	// Root is the root node of the layout tree.
+	Root *Node
+}
+
+// GetTree returns i3’s layout tree.
+//
+// GetTree is supported in i3 ≥ v4.0 (2011-07-31).
+func GetTree() (Tree, error) {
+	reply, err := roundTrip(messageTypeGetTree, nil)
+	if err != nil {
+		return Tree{}, err
+	}
+
+	var root Node
+	err = json.Unmarshal(reply.Payload, &root)
+	return Tree{Root: &root}, err
+}