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.
)

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

const DefaultDPI = 72.0

var (
    // DefaultFontFaceCatalog is a catalog for a basic font face.
    DefaultFontFaceCatalog FontFaceCatalog = defaultFontFaceCatalog{}

    // DefaultPalette is the default theme's palette.
    DefaultPalette = Palette{
        Light:      &image.Uniform{C: color.RGBA{0xf5, 0xf5, 0xf5, 0xff}},
        Neutral:    &image.Uniform{C: color.RGBA{0xee, 0xee, 0xee, 0xff}},
        Dark:       &image.Uniform{C: color.RGBA{0xe0, 0xe0, 0xe0, 0xff}},
        Accent:     &image.Uniform{C: color.RGBA{0x21, 0x96, 0xf3, 0xff}},
        Foreground: &image.Uniform{C: color.RGBA{0x00, 0x00, 0x00, 0xff}},
        Background: &image.Uniform{C: color.RGBA{0xff, 0xff, 0xff, 0xff}},
    }

    // DefaultTheme uses the default DPI, FontFaceCatalog and Palette.
    //
    // The nil-valued pointer is a valid receiver for a Theme's methods.
    DefaultTheme *Theme
)

type Arity uint8

type Axis uint8

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)
}

type ContainerClassEmbed struct{}

type Flow struct{ *Node }

type FlowLayoutData struct {
    // ExpandAlongWeight is the relative weight for distributing any excess
    // space along the Flow's axis. For example, if an AxisHorizontal Flow's
    // Rect width was 100 pixels greater than the sum of its children's natural
    // widths, and three children had non-zero FlowLayoutData.ExpandAlongWeight
    // values 6, 3 and 1, then those children's laid out widths would be larger
    // than their natural widths by 60, 30 and 10 pixels.
    ExpandAlongWeight int

    // ExpandAcross is whether the child's laid out size should expand to fill
    // the Flow's cross-axis. For example, if an AxisHorizontal Flow's Rect
    // height was 80 pixels, any child whose FlowLayoutData.ExpandAcross was
    // true would also be laid out with at least an 80 pixel height.
    ExpandAcross bool
}

type FontFaceCatalog interface {
    AcquireFontFace(FontFaceOptions) font.Face
    ReleaseFontFace(FontFaceOptions, font.Face)
}

type FontFaceOptions struct {
    Style  font.Style
    Weight font.Weight
}

type Image struct{ *Node }

type Label struct{ *Node }

type LeafClassEmbed struct{}

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{}

    // 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
}

type Palette struct {
    // Light, Neutral and Dark are three color tones used to fill in widgets
    // such as buttons, menu bars and panels.
    Light   *image.Uniform
    Neutral *image.Uniform
    Dark    *image.Uniform

    // Accent is the color used to accentuate selections or suggestions.
    Accent *image.Uniform

    // Foreground is the color used for text, dividers and icons.
    Foreground *image.Uniform

    // Background is the color used behind large blocks of text. Short,
    // non-editable label text will typically be on the Neutral color.
    Background *image.Uniform
}

type ShellClassEmbed struct{}

type Theme struct {
    // DPI is the screen resolution, in dots (i.e. pixels) per inch.
    //
    // A zero value means to use the DefaultDPI.
    DPI float64

    // FontFaceCatalog provides a theme's font faces.
    //
    // A zero value means to use the DefaultFontFaceCatalog.
    FontFaceCatalog FontFaceCatalog

    // Palette provides a theme's color palette.
    //
    // A zero value means to use the DefaultPalette.
    Palette *Palette
}

type Uniform struct{ *Node }