Moved containers into a separate package

elements/containers/container.go

@@ -0,0 +1,246 @@
+package containers
+
+import "image"
+import "git.tebibyte.media/sashakoshka/tomo/input"
+import "git.tebibyte.media/sashakoshka/tomo/theme"
+import "git.tebibyte.media/sashakoshka/tomo/config"
+import "git.tebibyte.media/sashakoshka/tomo/canvas"
+import "git.tebibyte.media/sashakoshka/tomo/artist"
+import "git.tebibyte.media/sashakoshka/tomo/layouts"
+import "git.tebibyte.media/sashakoshka/tomo/elements"
+import "git.tebibyte.media/sashakoshka/tomo/elements/core"
+
+// Container is an element capable of containg other elements, and arranging
+// them in a layout.
+type Container struct {
+	*core.Core
+	*core.Propagator
+	core core.CoreControl
+
+	layout    layouts.Layout
+	children  []layouts.LayoutEntry
+	warping   bool
+	
+	config config.Wrapped
+	theme  theme.Wrapped
+	
+	onFocusRequest func () (granted bool)
+	onFocusMotionRequest func (input.KeynavDirection) (granted bool)
+}
+
+// NewContainer creates a new container.
+func NewContainer (layout layouts.Layout) (element *Container) {
+	element = &Container { }
+	element.theme.Case = theme.C("containers", "container")
+	element.Core, element.core = core.NewCore(element, element.redoAll)
+	element.Propagator = core.NewPropagator(element, element.core)
+	element.SetLayout(layout)
+	return
+}
+
+// SetLayout sets the layout of this container.
+func (element *Container) SetLayout (layout layouts.Layout) {
+	element.layout = layout
+	if element.core.HasImage() {
+		element.redoAll()
+		element.core.DamageAll()
+	}
+}
+
+// Adopt adds a new child element to the container. If expand is set to true,
+// the element will expand (instead of contract to its minimum size), in
+// whatever way is defined by the current layout.
+func (element *Container) Adopt (child elements.Element, expand bool) {
+	if child0, ok := child.(elements.Themeable); ok {
+		child0.SetTheme(element.theme.Theme)
+	}
+	if child0, ok := child.(elements.Configurable); ok {
+		child0.SetConfig(element.config.Config)
+	}
+	child.SetParent(element)
+
+	// add child
+	element.children = append (element.children, layouts.LayoutEntry {
+		Element: child,
+		Expand:  expand,
+	})
+
+	// refresh stale data
+	element.updateMinimumSize()
+	if element.core.HasImage() && !element.warping {
+		element.redoAll()
+		element.core.DamageAll()
+	}
+}
+
+// Warp runs the specified callback, deferring all layout and rendering updates
+// until the callback has finished executing. This allows for aplications to
+// perform batch gui updates without flickering and stuff.
+func (element *Container) Warp (callback func ()) {
+	if element.warping {
+		callback()
+		return
+	}
+
+	element.warping = true
+	callback()
+	element.warping = false
+	
+	// TODO: create some sort of task list so we don't do a full recalculate
+	// and redraw every time, because although that is the most likely use
+	// case, it is not the only one.
+	if element.core.HasImage() {
+		element.redoAll()
+		element.core.DamageAll()
+	}
+}
+
+// Disown removes the given child from the container if it is contained within
+// it.
+func (element *Container) Disown (child elements.Element) {
+	for index, entry := range element.children {
+		if entry.Element == child {
+			element.clearChildEventHandlers(entry.Element)
+			element.children = append (
+				element.children[:index],
+				element.children[index + 1:]...)
+				break
+		}
+	}
+
+	element.updateMinimumSize()
+	if element.core.HasImage() && !element.warping {
+		element.redoAll()
+		element.core.DamageAll()
+	}
+}
+
+func (element *Container) clearChildEventHandlers (child elements.Element) {
+	child.DrawTo(nil, image.Rectangle { }, nil)
+	child.SetParent(nil)
+	
+	if child, ok := child.(elements.Focusable); ok {
+		if child.Focused() {
+			child.HandleUnfocus()
+		}
+	}
+}
+
+// DisownAll removes all child elements from the container at once.
+func (element *Container) DisownAll () {
+	for _, entry := range element.children {
+		element.clearChildEventHandlers(entry.Element)
+	}
+	element.children = nil
+
+	element.updateMinimumSize()
+	if element.core.HasImage() && !element.warping {
+		element.redoAll()
+		element.core.DamageAll()
+	}
+}
+
+// Children returns a slice containing this element's children.
+func (element *Container) Children () (children []elements.Element) {
+	children = make([]elements.Element, len(element.children))
+	for index, entry := range element.children {
+		children[index] = entry.Element
+	}
+	return
+}
+
+// CountChildren returns the amount of children contained within this element.
+func (element *Container) CountChildren () (count int) {
+	return len(element.children)
+}
+
+// Child returns the child at the specified index. If the index is out of
+// bounds, this method will return nil.
+func (element *Container) Child (index int) (child elements.Element) {
+	if index < 0 || index > len(element.children) { return }
+	return element.children[index].Element
+}
+
+// ChildAt returns the child that contains the specified x and y coordinates. If
+// there are no children at the coordinates, this method will return nil.
+func (element *Container) ChildAt (point image.Point) (child elements.Element) {
+	for _, entry := range element.children {
+		if point.In(entry.Bounds) {
+			child = entry.Element
+		}
+	}
+	return
+}
+
+func (element *Container) redoAll () {
+	if !element.core.HasImage() { return }
+
+	// remove child canvasses so that any operations done in here will not
+	// cause a child to draw to a wack ass canvas.
+	for _, entry := range element.children {
+		entry.DrawTo(nil, entry.Bounds, nil)
+	}
+	
+	// do a layout
+	element.doLayout()
+
+	// draw a background
+	rocks := make([]image.Rectangle, len(element.children))
+	for index, entry := range element.children {
+		rocks[index] = entry.Bounds
+	}
+	pattern := element.theme.Pattern (
+		theme.PatternBackground,
+		theme.State { })
+	artist.DrawShatter(element.core, pattern, element.Bounds(), rocks...)
+
+	// cut our canvas up and give peices to child elements
+	for _, entry := range element.children {
+		entry.DrawTo (
+			canvas.Cut(element.core, entry.Bounds),
+			entry.Bounds, func (region image.Rectangle) {
+				element.core.DamageRegion(region)
+			})
+	}
+}
+
+// NotifyMinimumSizeChange notifies the container that the minimum size of a
+// child element has changed.
+func (element *Container) NotifyMinimumSizeChange (child elements.Element) {
+	element.updateMinimumSize()
+	element.redoAll()
+	element.core.DamageAll()
+}
+
+// SetTheme sets the element's theme.
+func (element *Container) SetTheme (new theme.Theme) {
+	if new == element.theme.Theme { return }
+	element.theme.Theme = new
+	element.Propagator.SetTheme(new)
+	element.updateMinimumSize()
+	element.redoAll()
+}
+
+// SetConfig sets the element's configuration.
+func (element *Container) SetConfig (new config.Config) {
+	if new == element.config.Config { return }
+	element.Propagator.SetConfig(new)
+	element.updateMinimumSize()
+	element.redoAll()
+}
+
+func (element *Container) updateMinimumSize () {
+	margin  := element.theme.Margin(theme.PatternBackground)
+	padding := element.theme.Padding(theme.PatternBackground)
+	width, height := element.layout.MinimumSize (
+		element.children, margin, padding)
+	element.core.SetMinimumSize(width, height)
+}
+
+func (element *Container) doLayout () {
+	margin := element.theme.Margin(theme.PatternBackground)
+	padding := element.theme.Padding(theme.PatternBackground)
+	element.layout.Arrange (
+		element.children, margin,
+		padding, element.Bounds())
+}

elements/containers/document.go

@@ -0,0 +1,335 @@
+package containers
+
+import "image"
+import "git.tebibyte.media/sashakoshka/tomo/theme"
+import "git.tebibyte.media/sashakoshka/tomo/config"
+import "git.tebibyte.media/sashakoshka/tomo/canvas"
+import "git.tebibyte.media/sashakoshka/tomo/artist"
+import "git.tebibyte.media/sashakoshka/tomo/layouts"
+import "git.tebibyte.media/sashakoshka/tomo/elements"
+import "git.tebibyte.media/sashakoshka/tomo/elements/core"
+
+type DocumentContainer struct {
+	*core.Core
+	*core.Propagator
+	core core.CoreControl
+
+	children []layouts.LayoutEntry
+	scroll   image.Point
+	warping  bool
+	contentBounds image.Rectangle
+	
+	config config.Wrapped
+	theme  theme.Wrapped
+
+	onScrollBoundsChange func ()
+}
+
+// NewDocumentContainer creates a new document container.
+func NewDocumentContainer () (element *DocumentContainer) {
+	element = &DocumentContainer { }
+	element.theme.Case = theme.C("containers", "documentContainer")
+	element.Core, element.core = core.NewCore(element, element.redoAll)
+	element.Propagator = core.NewPropagator(element, element.core)
+	return
+}
+
+// Adopt adds a new child element to the container.
+func (element *DocumentContainer) Adopt (child elements.Element) {
+	// set event handlers
+	if child0, ok := child.(elements.Themeable); ok {
+		child0.SetTheme(element.theme.Theme)
+	}
+	if child0, ok := child.(elements.Configurable); ok {
+		child0.SetConfig(element.config.Config)
+	}
+
+	// add child
+	element.children = append (element.children, layouts.LayoutEntry {
+		Element: child,
+	})
+
+	child.SetParent(element)
+
+	// refresh stale data
+	element.reflectChildProperties()
+	if element.core.HasImage() && !element.warping {
+		element.redoAll()
+		element.core.DamageAll()
+	}
+}
+
+// Warp runs the specified callback, deferring all layout and rendering updates
+// until the callback has finished executing. This allows for aplications to
+// perform batch gui updates without flickering and stuff.
+func (element *DocumentContainer) Warp (callback func ()) {
+	if element.warping {
+		callback()
+		return
+	}
+
+	element.warping = true
+	callback()
+	element.warping = false
+	
+	if element.core.HasImage() {
+		element.redoAll()
+		element.core.DamageAll()
+	}
+}
+
+// Disown removes the given child from the container if it is contained within
+// it.
+func (element *DocumentContainer) Disown (child elements.Element) {
+	for index, entry := range element.children {
+		if entry.Element == child {
+			element.clearChildEventHandlers(entry.Element)
+			element.children = append (
+				element.children[:index],
+				element.children[index + 1:]...)
+				break
+		}
+	}
+
+	element.reflectChildProperties()
+	if element.core.HasImage() && !element.warping {
+		element.redoAll()
+		element.core.DamageAll()
+	}
+}
+
+func (element *DocumentContainer) clearChildEventHandlers (child elements.Element) {
+	child.DrawTo(nil, image.Rectangle { }, nil)
+	child.SetParent(nil)
+	
+	if child, ok := child.(elements.Focusable); ok {
+		if child.Focused() {
+			child.HandleUnfocus()
+		}
+	}
+}
+
+// DisownAll removes all child elements from the container at once.
+func (element *DocumentContainer) DisownAll () {
+	for _, entry := range element.children {
+		element.clearChildEventHandlers(entry.Element)
+	}
+	element.children = nil
+
+	element.reflectChildProperties()
+	if element.core.HasImage() && !element.warping {
+		element.redoAll()
+		element.core.DamageAll()
+	}
+}
+
+// Children returns a slice containing this element's children.
+func (element *DocumentContainer) Children () (children []elements.Element) {
+	children = make([]elements.Element, len(element.children))
+	for index, entry := range element.children {
+		children[index] = entry.Element
+	}
+	return
+}
+
+// CountChildren returns the amount of children contained within this element.
+func (element *DocumentContainer) CountChildren () (count int) {
+	return len(element.children)
+}
+
+// Child returns the child at the specified index. If the index is out of
+// bounds, this method will return nil.
+func (element *DocumentContainer) Child (index int) (child elements.Element) {
+	if index < 0 || index > len(element.children) { return }
+	return element.children[index].Element
+}
+
+// ChildAt returns the child that contains the specified x and y coordinates. If
+// there are no children at the coordinates, this method will return nil.
+func (element *DocumentContainer) ChildAt (point image.Point) (child elements.Element) {
+	for _, entry := range element.children {
+		if point.In(entry.Bounds) {
+			child = entry.Element
+		}
+	}
+	return
+}
+
+func (element *DocumentContainer) redoAll () {
+	if !element.core.HasImage() { return }
+	
+	// do a layout
+	element.doLayout()
+	
+	maxScrollHeight := element.maxScrollHeight()
+	if element.scroll.Y > maxScrollHeight {
+		element.scroll.Y = maxScrollHeight
+		element.doLayout()
+	}
+
+	// draw a background
+	rocks := make([]image.Rectangle, len(element.children))
+	for index, entry := range element.children {
+		rocks[index] = entry.Bounds
+	}
+	pattern := element.theme.Pattern (
+		theme.PatternBackground,
+		theme.State { })
+	artist.DrawShatter(element.core, pattern, element.Bounds(), rocks...)
+
+	element.partition()
+	if parent, ok := element.core.Parent().(elements.ScrollableParent); ok {
+		parent.NotifyScrollBoundsChange(element)
+	}
+}
+
+func (element *DocumentContainer) partition () {
+	for _, entry := range element.children {
+		entry.DrawTo(nil, entry.Bounds, nil)
+	}
+
+	// cut our canvas up and give peices to child elements
+	for _, entry := range element.children {
+		if entry.Bounds.Overlaps(element.Bounds()) {
+			entry.DrawTo (	
+				canvas.Cut(element.core, entry.Bounds),
+				entry.Bounds, func (region image.Rectangle) {
+					element.core.DamageRegion(region)
+				})
+		}
+	}
+}
+
+// NotifyMinimumSizeChange notifies the container that the minimum size of a
+// child element has changed.
+func (element *DocumentContainer) NotifyMinimumSizeChange (child elements.Element) {
+	element.redoAll()
+	element.core.DamageAll()
+}
+
+// NotifyFlexibleHeightChange notifies the parent that the parameters
+// affecting a child's flexible height have changed. This method is
+// expected to be called by flexible child element when their content
+// changes.
+func (element *DocumentContainer) NotifyFlexibleHeightChange (child elements.Flexible) {
+	element.redoAll()
+	element.core.DamageAll()
+}
+
+
+// SetTheme sets the element's theme.
+func (element *DocumentContainer) SetTheme (new theme.Theme) {
+	if new == element.theme.Theme { return }
+	element.theme.Theme = new
+	element.Propagator.SetTheme(new)
+	element.redoAll()
+}
+
+// SetConfig sets the element's configuration.
+func (element *DocumentContainer) SetConfig (new config.Config) {
+	if new == element.config.Config { return }
+	element.Propagator.SetConfig(new)
+	element.redoAll()
+}
+
+// ScrollContentBounds returns the full content size of the element.
+func (element *DocumentContainer) ScrollContentBounds () image.Rectangle {
+	return element.contentBounds
+}
+
+// ScrollViewportBounds returns the size and position of the element's
+// viewport relative to ScrollBounds.
+func (element *DocumentContainer) ScrollViewportBounds () image.Rectangle {
+	padding := element.theme.Padding(theme.PatternBackground)
+	bounds  := padding.Apply(element.Bounds())
+	bounds   = bounds.Sub(bounds.Min).Add(element.scroll)
+	return bounds
+}
+
+// ScrollTo scrolls the viewport to the specified point relative to
+// ScrollBounds.
+func (element *DocumentContainer) ScrollTo (position image.Point) {
+	if position.Y < 0 {
+		position.Y = 0
+	}
+	maxScrollHeight := element.maxScrollHeight()
+	if position.Y > maxScrollHeight {
+		position.Y = maxScrollHeight
+	}
+	element.scroll = position
+	if element.core.HasImage() && !element.warping {
+		element.redoAll()
+		element.core.DamageAll()
+	}
+}
+
+// OnScrollBoundsChange sets a function to be called when the element's viewport
+// bounds, content bounds, or scroll axes change.
+func (element *DocumentContainer) OnScrollBoundsChange (callback func ()) {
+	element.onScrollBoundsChange = callback
+}
+
+func (element *DocumentContainer) maxScrollHeight () (height int) {
+	padding := element.theme.Padding(theme.PatternSunken)
+	viewportHeight := element.Bounds().Dy() - padding.Vertical()
+	height = element.contentBounds.Dy() - viewportHeight
+	if height < 0 { height = 0 }
+	return
+}
+
+// ScrollAxes returns the supported axes for scrolling.
+func (element *DocumentContainer) ScrollAxes () (horizontal, vertical bool) {
+	return false, true
+}
+
+func (element *DocumentContainer) reflectChildProperties () {
+	focusable := false
+	for _, entry := range element.children {
+		_, focusable := entry.Element.(elements.Focusable)
+		if focusable {
+			focusable = true
+			break
+		}
+	}
+	if !focusable && element.Focused() {
+		element.Propagator.HandleUnfocus()
+	}
+}
+
+func (element *DocumentContainer) doLayout () {
+	margin := element.theme.Margin(theme.PatternBackground)
+	padding := element.theme.Padding(theme.PatternBackground)
+	bounds := padding.Apply(element.Bounds())
+	element.contentBounds = image.Rectangle { }
+
+	minimumWidth := 0
+	dot := bounds.Min.Sub(element.scroll)
+	for index, entry := range element.children {
+		if index > 0 {
+			dot.Y += margin.Y
+		}
+	
+		width, height := entry.MinimumSize()
+		if width > minimumWidth {
+			minimumWidth = width
+		}
+		if width < bounds.Dx() {
+			width = bounds.Dx()
+		}
+		if typedChild, ok := entry.Element.(elements.Flexible); ok {
+			height = typedChild.FlexibleHeightFor(width)
+		}
+		
+		entry.Bounds.Min = dot
+		entry.Bounds.Max = image.Pt(dot.X + width, dot.Y + height)
+		element.children[index] = entry
+		element.contentBounds = element.contentBounds.Union(entry.Bounds)
+		dot.Y += height
+	}
+	
+	element.contentBounds =
+		element.contentBounds.Sub(element.contentBounds.Min)	
+	element.core.SetMinimumSize (
+		minimumWidth + padding.Horizontal(),
+		padding.Vertical())
+}

elements/containers/scroll.go

@@ -0,0 +1,295 @@
+package containers
+
+import "image"
+import "git.tebibyte.media/sashakoshka/tomo/input"
+import "git.tebibyte.media/sashakoshka/tomo/theme"
+import "git.tebibyte.media/sashakoshka/tomo/config"
+import "git.tebibyte.media/sashakoshka/tomo/canvas"
+import "git.tebibyte.media/sashakoshka/tomo/elements"
+import "git.tebibyte.media/sashakoshka/tomo/elements/core"
+import "git.tebibyte.media/sashakoshka/tomo/elements/basic"
+
+// ScrollContainer is a container that is capable of holding a scrollable
+// element.
+type ScrollContainer struct {
+	*core.Core
+	*core.Propagator
+	core core.CoreControl
+	
+	child      elements.Scrollable
+	horizontal *basicElements.ScrollBar
+	vertical   *basicElements.ScrollBar
+	
+	config config.Wrapped
+	theme  theme.Wrapped
+
+	onFocusRequest func () (granted bool)
+	onFocusMotionRequest func (input.KeynavDirection) (granted bool)
+}
+
+// NewScrollContainer creates a new scroll container with the specified scroll
+// bars.
+func NewScrollContainer (horizontal, vertical bool) (element *ScrollContainer) {
+	element = &ScrollContainer { }
+	element.theme.Case = theme.C("containers", "scrollContainer")
+	element.Core, element.core = core.NewCore(element, element.redoAll)
+	element.Propagator = core.NewPropagator(element, element.core)
+
+	if horizontal {
+		element.horizontal = basicElements.NewScrollBar(false)
+		element.setUpChild(element.horizontal)
+		element.horizontal.OnScroll (func (viewport image.Point) {
+			if element.child != nil {
+				element.child.ScrollTo(viewport)
+			}
+			if element.vertical != nil {
+				element.vertical.SetBounds (
+					element.child.ScrollContentBounds(),
+					element.child.ScrollViewportBounds())
+			}
+		})
+	}
+	if vertical {
+		element.vertical = basicElements.NewScrollBar(true)
+		element.setUpChild(element.vertical)
+		element.vertical.OnScroll (func (viewport image.Point) {
+			if element.child != nil {
+				element.child.ScrollTo(viewport)
+			}
+			if element.horizontal != nil {
+				element.horizontal.SetBounds (
+					element.child.ScrollContentBounds(),
+					element.child.ScrollViewportBounds())
+			}
+		})
+	}
+	return
+}
+
+
+// Adopt adds a scrollable element to the scroll container. The container can
+// only contain one scrollable element at a time, and when a new one is adopted
+// it replaces the last one.
+func (element *ScrollContainer) Adopt (child elements.Scrollable) {
+	// disown previous child if it exists
+	if element.child != nil {
+		element.disownChild(child)
+	}
+
+	// adopt new child
+	element.child = child
+	if child != nil {
+		element.setUpChild(child)
+	}
+	
+	element.updateEnabled()
+	element.updateMinimumSize()
+	if element.core.HasImage() {
+		element.redoAll()
+		element.core.DamageAll()
+	}
+}
+
+func (element *ScrollContainer) setUpChild (child elements.Element) {
+	child.SetParent(element)
+	if child, ok := child.(elements.Themeable); ok {
+		child.SetTheme(element.theme.Theme)
+	}
+	if child, ok := child.(elements.Configurable); ok {
+		child.SetConfig(element.config.Config)
+	}
+}
+
+func (element *ScrollContainer) disownChild (child elements.Scrollable) {
+	child.DrawTo(nil, image.Rectangle { }, nil)
+	child.SetParent(nil)
+	if child, ok := child.(elements.Focusable); ok {
+		if child.Focused() {
+			child.HandleUnfocus()
+		}
+	}
+}
+
+// NotifyMinimumSizeChange notifies the container that the minimum size of a
+// child element has changed.
+func (element *ScrollContainer) NotifyMinimumSizeChange (child elements.Element) {
+	element.redoAll()
+	element.core.DamageAll()
+}
+
+// NotifyScrollBoundsChange notifies the container that the scroll bounds or
+// axes of a child have changed.
+func (element *ScrollContainer) NotifyScrollBoundsChange (child elements.Scrollable) {
+	element.updateEnabled()
+	viewportBounds := element.child.ScrollViewportBounds()
+	contentBounds  := element.child.ScrollContentBounds()
+	if element.horizontal != nil {
+		element.horizontal.SetBounds(contentBounds, viewportBounds)
+	}
+	if element.vertical != nil {
+		element.vertical.SetBounds(contentBounds, viewportBounds)
+	}
+}
+
+// SetTheme sets the element's theme.
+func (element *ScrollContainer) SetTheme (new theme.Theme) {
+	if new == element.theme.Theme { return }
+	element.theme.Theme = new
+	element.Propagator.SetTheme(new)
+	element.updateMinimumSize()
+	element.redoAll()
+}
+
+// SetConfig sets the element's configuration.
+func (element *ScrollContainer) SetConfig (new config.Config) {
+	if new == element.config.Config { return }
+	element.Propagator.SetConfig(new)
+	element.updateMinimumSize()
+	element.redoAll()
+}
+
+func (element *ScrollContainer) HandleScroll (
+	x, y int,
+	deltaX, deltaY float64,
+) {
+	element.scrollChildBy(int(deltaX), int(deltaY))
+}
+
+// CountChildren returns the amount of children contained within this element.
+func (element *ScrollContainer) CountChildren () (count int) {
+	return 3
+}
+
+// Child returns the child at the specified index. If the index is out of
+// bounds, this method will return nil.
+func (element *ScrollContainer) Child (index int) (child elements.Element) {
+	switch index {
+	case 0: return element.child
+	case 1:
+		if element.horizontal == nil {
+			return nil
+		} else {
+			return element.horizontal
+		}
+	case 2:
+		if element.vertical == nil {
+			return nil
+		} else {
+			return element.vertical
+		}
+	default: return nil
+	}
+}
+
+func (element *ScrollContainer) redoAll () {
+	if !element.core.HasImage() { return }
+
+	zr := image.Rectangle { }
+	if element.child      != nil { element.child.DrawTo(nil, zr, nil)      }
+	if element.horizontal != nil { element.horizontal.DrawTo(nil, zr, nil) }
+	if element.vertical   != nil { element.vertical.DrawTo(nil, zr, nil)   }
+	
+	childBounds, horizontalBounds, verticalBounds := element.layout()
+	if element.child != nil {
+		element.child.DrawTo (
+			canvas.Cut(element.core, childBounds),
+			childBounds, element.childDamageCallback)
+	}
+	if element.horizontal != nil {
+		element.horizontal.DrawTo (
+			canvas.Cut(element.core, horizontalBounds),
+			horizontalBounds, element.childDamageCallback)
+	}
+	if element.vertical != nil {
+		element.vertical.DrawTo (
+			canvas.Cut(element.core, verticalBounds),
+			verticalBounds, element.childDamageCallback)
+	}
+	element.draw()
+}
+
+func (element *ScrollContainer) scrollChildBy (x, y int) {
+	if element.child == nil { return }
+	scrollPoint :=
+		element.child.ScrollViewportBounds().Min.
+		Add(image.Pt(x, y))
+	element.child.ScrollTo(scrollPoint)
+}
+
+func (element *ScrollContainer) childDamageCallback (region image.Rectangle) {
+	element.core.DamageRegion(region)
+}
+
+func (element *ScrollContainer) layout () (
+	child      image.Rectangle,
+	horizontal image.Rectangle,
+	vertical   image.Rectangle,
+) {
+	bounds := element.Bounds()
+	child = bounds
+
+	if element.horizontal != nil {
+		_, hMinHeight := element.horizontal.MinimumSize()
+		child.Max.Y -= hMinHeight
+	}
+	if element.vertical != nil {
+		vMinWidth, _  := element.vertical.MinimumSize()
+		child.Max.X -= vMinWidth
+	}
+	
+	vertical.Min.X = child.Max.X
+	vertical.Max.X = bounds.Max.X
+	vertical.Min.Y = bounds.Min.Y
+	vertical.Max.Y = child.Max.Y
+
+	horizontal.Min.X = bounds.Min.X
+	horizontal.Max.X = child.Max.X
+	horizontal.Min.Y = child.Max.Y
+	horizontal.Max.Y = bounds.Max.Y
+	return
+}
+
+func (element *ScrollContainer) draw () {
+	if element.horizontal != nil && element.vertical != nil {
+		bounds := element.Bounds()
+		bounds.Min = image.Pt (
+			bounds.Max.X - element.vertical.Bounds().Dx(),
+			bounds.Max.Y - element.horizontal.Bounds().Dy())
+		state := theme.State { }
+		deadArea := element.theme.Pattern(theme.PatternDead, state)
+		deadArea.Draw(canvas.Cut(element.core, bounds), bounds)
+	}
+}
+
+func (element *ScrollContainer) updateMinimumSize () {
+	var width, height int
+
+	if element.child != nil {
+		width, height = element.child.MinimumSize()
+	}
+	if element.horizontal != nil {
+		hMinWidth, hMinHeight := element.horizontal.MinimumSize()
+		height += hMinHeight
+		if hMinWidth > width {
+			width = hMinWidth
+		}
+	}
+	if element.vertical != nil {
+		vMinWidth, vMinHeight := element.vertical.MinimumSize()
+		width += vMinWidth
+		if vMinHeight > height {
+			height = vMinHeight
+		}
+	}
+	element.core.SetMinimumSize(width, height)
+}
+
+func (element *ScrollContainer) updateEnabled () {
+	horizontal, vertical := element.child.ScrollAxes()
+	if element.horizontal != nil {
+		element.horizontal.SetEnabled(horizontal)
+	}
+	if element.vertical != nil {
+		element.vertical.SetEnabled(vertical)
+	}
+}