~jackmordaunt via chat
A framework for building chat interfaces with gioui.org.
The canonical copy of this repository is hosted on Sourcehut. We also have:
Work in progress. Expect breaking API changes often.
This repo contains many packages with different goals:
list: This package implements logic to allow a Gio list to scroll over arbitrarily large quantities of elements while keeping a fixed number in RAM.
layout: This package exposes some layout types and functions helpful for building chat interfaces.
ninepatch: A ninepatch image decoder.
widget: This package exposes the state types for some helpful chat widgets.
widget/material: This package exposes some material-design-themed components for building chat interfaces.
example/kitchen: An example of using all of this parts of this module together to build a chat interface.
example/ninepatch: An example of the ninepatch decoder.
example/unconfigured: A demonstration of the default behavior of the
list.Manager if no custom hooks are provided to it.
profile: Simple profiling for Gio programs.
./example directory for applications showcasing how to use the current
./example/kitchen tries to exercise the full range of this
list package API deserves some discussion.
list.Manager handles the complex task of maintaining a sliding window of list elements atop an arbitrarily-long (maybe infinite) underlying list of content. This means that
list.Manager handles all of the following:
list.Manager is able to accomplish all of the above in a generic way by reqiring a set of "hooks" provided by your application. These hooks supply application specific intelligence about the concrete types of your data, the way that your data relates to itself, and the way that your list elements should be presented to the user.
The required hooks are:
Loader: a function that the
list.Manager can invoke to load more elements from the source of truth for the list data. This function is expected to block during the load, and the parameters provided to it indicate the direction and relative position of the requested content within the source of truth.
Comparator: a function used to sort list elements. It is provided two elements and returns whether the first sorts before the second.
Sythesizer: a function that can transform the list elements from within the state management goroutine. Many applications may have list elements with dynamic properties. Those properties require and API call or database interaction to resolve, and you don't want to perform such blocking I/O from the layout goroutine. This hook provides a place to perform blocking queries and other data transformations without blocking the layout goroutine. In particular, this hook can return zero or more elements, meaning that it can choose to hide list elements or to insert other elements around them prior to layout.
Invalidator: a function that can invalidate the window. This is necessary so that the
list.Manager can ensure that Gio draws a new frame once it finishes a state update.
Allocator: a function that accepts a
list.Element and returns the appropriate state type for it. The returned state type will be persisted by the
list.Manager. For instance, a
list.Element that renders a button would return
*widget.Clickable from this hook, so that it has somewhere to store its click state across frames.
Presenter: a function that accepts a
list.Element, some state from the
Allocator, and returns a Gio
layout.Widget that will lay out the list element as a widget.
As much work as possible is performed in a background state management goroutine so that the layout goroutine has no reason to block.
Here's a diagram showing how the various hooks work together:
For a relatively simple implementation of using all of the hooks together to build something useful, see
Dual Unlicense/MIT, same as Gio