shiny/widget/widget.go - exp - Git at Google

 // Copyright 2016 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 // Package widget provides graphical user interface widgets.
 //
 // TODO: give an overview and some example code.
 package widget // import "golang.org/x/exp/shiny/widget"

 import (
 	"image"
 )

 func max(x, y int) int {
 	if x > y {
 		return x
 	}
 	return y
 }

 // Arity is the number of children a class of nodes can have.
 type Arity uint8

 const (
 	Leaf      = Arity(0) // Leaf nodes have no children.
 	Shell     = Arity(1) // Shell nodes have at most one child.
 	Container = Arity(2) // Container nodes can have any number of children.
 )

 // Axis is zero, one or both of the horizontal and vertical axes. For example,
 // a widget may be scrollable in one of the four AxisXxx values.
 type Axis uint8

 const (
 	AxisNone       = Axis(0)
 	AxisHorizontal = Axis(1)
 	AxisVertical   = Axis(2)
 	AxisBoth       = Axis(3) // AxisBoth equals AxisHorizontal | AxisVertical.
 )

 // Class is a class of nodes. For example, all button widgets would be Nodes
 // whose Class values have the buttonClass type.
 type Class interface {
 	// Arity returns the number of children a specific node can have.
 	Arity(n *Node) Arity

 	// Measure sets n.MeasuredSize to the natural size, in pixels, of a
 	// specific node (and its children) of this class.
 	Measure(n *Node, t *Theme)

 	// Layout lays out a specific node (and its children) of this class,
 	// setting the Node.Rect fields of each child. The n.Rect field should have
 	// previously been set during the parent node's layout.
 	Layout(n *Node, t *Theme)

 	// Paint paints a specific node (and its children) of this class onto a
 	// destination image. origin is the parent widget's origin with respect to
 	// the dst image's origin; n.Rect.Add(origin) will be n's position and size
 	// in dst's coordinate space.
 	//
 	// TODO: add a clip rectangle? Or rely on the RGBA.SubImage method to pass
 	// smaller dst images?
 	Paint(n *Node, t *Theme, dst *image.RGBA, origin image.Point)

 	// TODO: OnXxxEvent methods.
 }

 // LeafClassEmbed is designed to be embedded in struct types that implement the
 // Class interface and have Leaf arity. It provides default implementations of
 // the Class interface's methods.
 type LeafClassEmbed struct{}

 func (LeafClassEmbed) Arity(n *Node) Arity { return Leaf }

 func (LeafClassEmbed) Measure(n *Node, t *Theme) { n.MeasuredSize = image.Point{} }

 func (LeafClassEmbed) Layout(n *Node, t *Theme) {}

 func (LeafClassEmbed) Paint(n *Node, t *Theme, dst *image.RGBA, origin image.Point) {}

 // ShellClassEmbed is designed to be embedded in struct types that implement
 // the Class interface and have Shell arity. It provides default
 // implementations of the Class interface's methods.
 type ShellClassEmbed struct{}

 func (ShellClassEmbed) Arity(n *Node) Arity { return Shell }

 func (ShellClassEmbed) Measure(n *Node, t *Theme) {
 	if c := n.FirstChild; c != nil {
 		c.Measure(t)
 		n.MeasuredSize = c.MeasuredSize
 	} else {
 		n.MeasuredSize = image.Point{}
 	}
 }

 func (ShellClassEmbed) Layout(n *Node, t *Theme) {
 	if c := n.FirstChild; c != nil {
 		c.Rect = n.Rect.Sub(n.Rect.Min)
 		c.Layout(t)
 	}
 }

 func (ShellClassEmbed) Paint(n *Node, t *Theme, dst *image.RGBA, origin image.Point) {
 	if c := n.FirstChild; c != nil {
 		c.Paint(t, dst, origin.Add(n.Rect.Min))
 	}
 }

 // ContainerClassEmbed is designed to be embedded in struct types that
 // implement the Class interface and have Container arity. It provides default
 // implementations of the Class interface's methods.
 type ContainerClassEmbed struct{}

 func (ContainerClassEmbed) Arity(n *Node) Arity { return Container }

 func (ContainerClassEmbed) Measure(n *Node, t *Theme) {
 	mSize := image.Point{}
 	for c := n.FirstChild; c != nil; c = c.NextSibling {
 		c.Measure(t)
 		if mSize.X < c.MeasuredSize.X {
 			mSize.X = c.MeasuredSize.X
 		}
 		if mSize.Y < c.MeasuredSize.Y {
 			mSize.Y = c.MeasuredSize.Y
 		}
 	}
 	n.MeasuredSize = mSize
 }

 func (ContainerClassEmbed) Layout(n *Node, t *Theme) {
 	for c := n.FirstChild; c != nil; c = c.NextSibling {
 		c.Rect = image.Rectangle{Max: c.MeasuredSize}
 		c.Layout(t)
 	}
 }

 func (ContainerClassEmbed) Paint(n *Node, t *Theme, dst *image.RGBA, origin image.Point) {
 	for c := n.FirstChild; c != nil; c = c.NextSibling {
 		c.Paint(t, dst, origin.Add(n.Rect.Min))
 	}
 }

 // Node is an element of a widget tree.
 //
 // Every element of a widget tree is a node, but nodes can be of different
 // classes. For example, a Flow node (i.e. one whose Class is FlowClass) can
 // contain two Button nodes and an Image node.
 type Node struct {
 	// Parent, FirstChild, LastChild, PrevSibling and NextSibling describe the
 	// widget tree structure.
 	//
 	// These fields are exported to enable walking the node tree, but they
 	// should not be modified directly. Instead, call the AppendChild and
 	// RemoveChild methods, which keeps the tree structure consistent.
 	Parent, FirstChild, LastChild, PrevSibling, NextSibling *Node

 	// Class is class-specific data and behavior for this node. For example, a
 	// buttonClass-typed value may store an image and some text in this field.
 	// A progressBarClass-typed value may store a numerical percentage.
 	// Different class types would paint their nodes differently.
 	Class Class

 	// LayoutData is layout-specific data for this node. Its type is determined
 	// by its parent node's class. For example, each child of a Flow may hold a
 	// FlowLayoutData in this field.
 	LayoutData interface{}

 	// TODO: add commentary about the Measure / Layout / Paint model, and about
 	// the lifetime of the MeasuredSize and Rect fields, and when user code can
 	// access and/or modify them. At some point a new cycle begins, a call to
 	// measure is necessary, and using MeasuredSize is incorrect (unless you're
 	// trying to recall something about the past).

 	// MeasuredSize is the widget's natural size, in pixels, as calculated by
 	// the most recent Class.Measure call.
 	MeasuredSize image.Point

 	// Rect is the widget's position and actual (as opposed to natural) size,
 	// in pixels, as calculated by the most recent Class.Layout call on its
 	// parent node. A parent may lay out a child at a size different to its
 	// natural size in order to satisfy a layout constraint, such as a row of
 	// buttons expanding to fill a panel's width.
 	//
 	// The position (Rectangle.Min) is relative to its parent node. This is not
 	// necessarily the same as relative to the screen's, window's or image
 	// buffer's origin.
 	Rect image.Rectangle
 }

 // Arity calls n.Class.Arity with n as its first argument.
 func (n *Node) Arity() Arity {
 	return n.Class.Arity(n)
 }

 // Measure calls n.Class.Measure with n as its first argument.
 func (n *Node) Measure(t *Theme) {
 	n.Class.Measure(n, t)
 }

 // Layout calls n.Class.Layout with n as its first argument.
 func (n *Node) Layout(t *Theme) {
 	n.Class.Layout(n, t)
 }

 // Paint calls n.Class.Paint with n as its first argument.
 func (n *Node) Paint(t *Theme, dst *image.RGBA, origin image.Point) {
 	n.Class.Paint(n, t, dst, origin)
 }

 // AppendChild adds a node c as a child of n.
 //
 // It will panic if c already has a parent or siblings.
 func (n *Node) AppendChild(c *Node) {
 	if c.Parent != nil || c.PrevSibling != nil || c.NextSibling != nil {
 		panic("widget: AppendChild called for an attached child Node")
 	}
 	switch n.Arity() {
 	case Leaf:
 		panic("widget: AppendChild called for a leaf parent Node")
 	case Shell:
 		if n.FirstChild != nil {
 			panic("widget: AppendChild called for a shell parent Node that already has a child Node")
 		}
 	}
 	last := n.LastChild
 	if last != nil {
 		last.NextSibling = c
 	} else {
 		n.FirstChild = c
 	}
 	n.LastChild = c
 	c.Parent = n
 	c.PrevSibling = last
 }

 // RemoveChild removes a node c that is a child of n. Afterwards, c will have
 // no parent and no siblings.
 //
 // It will panic if c's parent is not n.
 func (n *Node) RemoveChild(c *Node) {
 	if c.Parent != n {
 		panic("widget: RemoveChild called for a non-child Node")
 	}
 	if n.FirstChild == c {
 		n.FirstChild = c.NextSibling
 	}
 	if c.NextSibling != nil {
 		c.NextSibling.PrevSibling = c.PrevSibling
 	}
 	if n.LastChild == c {
 		n.LastChild = c.PrevSibling
 	}
 	if c.PrevSibling != nil {
 		c.PrevSibling.NextSibling = c.NextSibling
 	}
 	c.Parent = nil
 	c.PrevSibling = nil
 	c.NextSibling = nil
 }
	// Copyright 2016 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	// Package widget provides graphical user interface widgets.
	//
	// TODO: give an overview and some example code.
	package widget // import "golang.org/x/exp/shiny/widget"

	import (
	"image"
	)

	func max(x, y int) int {
	if x > y {
	return x
	}
	return y
	}

	// Arity is the number of children a class of nodes can have.
	type Arity uint8

	const (
	Leaf = Arity(0) // Leaf nodes have no children.
	Shell = Arity(1) // Shell nodes have at most one child.
	Container = Arity(2) // Container nodes can have any number of children.
	)

	// Axis is zero, one or both of the horizontal and vertical axes. For example,
	// a widget may be scrollable in one of the four AxisXxx values.
	type Axis uint8

	const (
	AxisNone = Axis(0)
	AxisHorizontal = Axis(1)
	AxisVertical = Axis(2)
	AxisBoth = Axis(3) // AxisBoth equals AxisHorizontal \| AxisVertical.
	)

	// Class is a class of nodes. For example, all button widgets would be Nodes
	// whose Class values have the buttonClass type.
	type Class interface {
	// Arity returns the number of children a specific node can have.
	Arity(n *Node) Arity

	// Measure sets n.MeasuredSize to the natural size, in pixels, of a
	// specific node (and its children) of this class.
	Measure(n Node, t Theme)

	// Layout lays out a specific node (and its children) of this class,
	// setting the Node.Rect fields of each child. The n.Rect field should have
	// previously been set during the parent node's layout.
	Layout(n Node, t Theme)

	// Paint paints a specific node (and its children) of this class onto a
	// destination image. origin is the parent widget's origin with respect to
	// the dst image's origin; n.Rect.Add(origin) will be n's position and size
	// in dst's coordinate space.
	//
	// TODO: add a clip rectangle? Or rely on the RGBA.SubImage method to pass
	// smaller dst images?
	Paint(n Node, t Theme, dst *image.RGBA, origin image.Point)

	// TODO: OnXxxEvent methods.
	}

	// LeafClassEmbed is designed to be embedded in struct types that implement the
	// Class interface and have Leaf arity. It provides default implementations of
	// the Class interface's methods.
	type LeafClassEmbed struct{}

	func (LeafClassEmbed) Arity(n *Node) Arity { return Leaf }

	func (LeafClassEmbed) Measure(n Node, t Theme) { n.MeasuredSize = image.Point{} }

	func (LeafClassEmbed) Layout(n Node, t Theme) {}

	func (LeafClassEmbed) Paint(n Node, t Theme, dst *image.RGBA, origin image.Point) {}

	// ShellClassEmbed is designed to be embedded in struct types that implement
	// the Class interface and have Shell arity. It provides default
	// implementations of the Class interface's methods.
	type ShellClassEmbed struct{}

	func (ShellClassEmbed) Arity(n *Node) Arity { return Shell }

	func (ShellClassEmbed) Measure(n Node, t Theme) {
	if c := n.FirstChild; c != nil {
	c.Measure(t)
	n.MeasuredSize = c.MeasuredSize
	} else {
	n.MeasuredSize = image.Point{}
	}
	}

	func (ShellClassEmbed) Layout(n Node, t Theme) {
	if c := n.FirstChild; c != nil {
	c.Rect = n.Rect.Sub(n.Rect.Min)
	c.Layout(t)
	}
	}

	func (ShellClassEmbed) Paint(n Node, t Theme, dst *image.RGBA, origin image.Point) {
	if c := n.FirstChild; c != nil {
	c.Paint(t, dst, origin.Add(n.Rect.Min))
	}
	}

	// ContainerClassEmbed is designed to be embedded in struct types that
	// implement the Class interface and have Container arity. It provides default
	// implementations of the Class interface's methods.
	type ContainerClassEmbed struct{}

	func (ContainerClassEmbed) Arity(n *Node) Arity { return Container }

	func (ContainerClassEmbed) Measure(n Node, t Theme) {
	mSize := image.Point{}
	for c := n.FirstChild; c != nil; c = c.NextSibling {
	c.Measure(t)
	if mSize.X < c.MeasuredSize.X {
	mSize.X = c.MeasuredSize.X
	}
	if mSize.Y < c.MeasuredSize.Y {
	mSize.Y = c.MeasuredSize.Y
	}
	}
	n.MeasuredSize = mSize
	}

	func (ContainerClassEmbed) Layout(n Node, t Theme) {
	for c := n.FirstChild; c != nil; c = c.NextSibling {
	c.Rect = image.Rectangle{Max: c.MeasuredSize}
	c.Layout(t)
	}
	}

	func (ContainerClassEmbed) Paint(n Node, t Theme, dst *image.RGBA, origin image.Point) {
	for c := n.FirstChild; c != nil; c = c.NextSibling {
	c.Paint(t, dst, origin.Add(n.Rect.Min))
	}
	}

	// Node is an element of a widget tree.
	//
	// Every element of a widget tree is a node, but nodes can be of different
	// classes. For example, a Flow node (i.e. one whose Class is FlowClass) can
	// contain two Button nodes and an Image node.
	type Node struct {
	// Parent, FirstChild, LastChild, PrevSibling and NextSibling describe the
	// widget tree structure.
	//
	// These fields are exported to enable walking the node tree, but they
	// should not be modified directly. Instead, call the AppendChild and
	// RemoveChild methods, which keeps the tree structure consistent.
	Parent, FirstChild, LastChild, PrevSibling, NextSibling *Node

	// Class is class-specific data and behavior for this node. For example, a
	// buttonClass-typed value may store an image and some text in this field.
	// A progressBarClass-typed value may store a numerical percentage.
	// Different class types would paint their nodes differently.
	Class Class

	// LayoutData is layout-specific data for this node. Its type is determined
	// by its parent node's class. For example, each child of a Flow may hold a
	// FlowLayoutData in this field.
	LayoutData interface{}

	// TODO: add commentary about the Measure / Layout / Paint model, and about
	// the lifetime of the MeasuredSize and Rect fields, and when user code can
	// access and/or modify them. At some point a new cycle begins, a call to
	// measure is necessary, and using MeasuredSize is incorrect (unless you're
	// trying to recall something about the past).

	// MeasuredSize is the widget's natural size, in pixels, as calculated by
	// the most recent Class.Measure call.
	MeasuredSize image.Point

	// Rect is the widget's position and actual (as opposed to natural) size,
	// in pixels, as calculated by the most recent Class.Layout call on its
	// parent node. A parent may lay out a child at a size different to its
	// natural size in order to satisfy a layout constraint, such as a row of
	// buttons expanding to fill a panel's width.
	//
	// The position (Rectangle.Min) is relative to its parent node. This is not
	// necessarily the same as relative to the screen's, window's or image
	// buffer's origin.
	Rect image.Rectangle
	}

	// Arity calls n.Class.Arity with n as its first argument.
	func (n *Node) Arity() Arity {
	return n.Class.Arity(n)
	}

	// Measure calls n.Class.Measure with n as its first argument.
	func (n Node) Measure(t Theme) {
	n.Class.Measure(n, t)
	}

	// Layout calls n.Class.Layout with n as its first argument.
	func (n Node) Layout(t Theme) {
	n.Class.Layout(n, t)
	}

	// Paint calls n.Class.Paint with n as its first argument.
	func (n Node) Paint(t Theme, dst *image.RGBA, origin image.Point) {
	n.Class.Paint(n, t, dst, origin)
	}

	// AppendChild adds a node c as a child of n.
	//
	// It will panic if c already has a parent or siblings.
	func (n Node) AppendChild(c Node) {
	if c.Parent != nil \|\| c.PrevSibling != nil \|\| c.NextSibling != nil {
	panic("widget: AppendChild called for an attached child Node")
	}
	switch n.Arity() {
	case Leaf:
	panic("widget: AppendChild called for a leaf parent Node")
	case Shell:
	if n.FirstChild != nil {
	panic("widget: AppendChild called for a shell parent Node that already has a child Node")
	}
	}
	last := n.LastChild
	if last != nil {
	last.NextSibling = c
	} else {
	n.FirstChild = c
	}
	n.LastChild = c
	c.Parent = n
	c.PrevSibling = last
	}

	// RemoveChild removes a node c that is a child of n. Afterwards, c will have
	// no parent and no siblings.
	//
	// It will panic if c's parent is not n.
	func (n Node) RemoveChild(c Node) {
	if c.Parent != n {
	panic("widget: RemoveChild called for a non-child Node")
	}
	if n.FirstChild == c {
	n.FirstChild = c.NextSibling
	}
	if c.NextSibling != nil {
	c.NextSibling.PrevSibling = c.PrevSibling
	}
	if n.LastChild == c {
	n.LastChild = c.PrevSibling
	}
	if c.PrevSibling != nil {
	c.PrevSibling.NextSibling = c.NextSibling
	}
	c.Parent = nil
	c.PrevSibling = nil
	c.NextSibling = nil
	}