Moved the existing .go files out of the way and replaced ui.h with the alpha4 ui.h.

33 files changed, 934 insertions, 95 deletions

diff --git a/area.go b/AAA_GOFILES/area.go
index 358a391..358a391 100644
--- a/area.go
+++ b/AAA_GOFILES/area.go
diff --git a/areahandler.go b/AAA_GOFILES/areahandler.go
index 74cbe56..74cbe56 100644
--- a/areahandler.go
+++ b/AAA_GOFILES/areahandler.go
diff --git a/box.go b/AAA_GOFILES/box.go
index caf49e3..caf49e3 100644
--- a/box.go
+++ b/AAA_GOFILES/box.go
diff --git a/button.go b/AAA_GOFILES/button.go
index 2696f82..2696f82 100644
--- a/button.go
+++ b/AAA_GOFILES/button.go
diff --git a/checkbox.go b/AAA_GOFILES/checkbox.go
index b518b29..b518b29 100644
--- a/checkbox.go
+++ b/AAA_GOFILES/checkbox.go
diff --git a/combobox.go b/AAA_GOFILES/combobox.go
index 2afa294..2afa294 100644
--- a/combobox.go
+++ b/AAA_GOFILES/combobox.go
diff --git a/control.go b/AAA_GOFILES/control.go
index 94ea34f..94ea34f 100644
--- a/control.go
+++ b/AAA_GOFILES/control.go
diff --git a/datetimepicker.go b/AAA_GOFILES/datetimepicker.go
index 216b8b7..216b8b7 100644
--- a/datetimepicker.go
+++ b/AAA_GOFILES/datetimepicker.go
diff --git a/draw.go b/AAA_GOFILES/draw.go
index eb4158d..eb4158d 100644
--- a/draw.go
+++ b/AAA_GOFILES/draw.go
diff --git a/entry.go b/AAA_GOFILES/entry.go
index ee14fc8..ee14fc8 100644
--- a/entry.go
+++ b/AAA_GOFILES/entry.go
diff --git a/fontbutton.go b/AAA_GOFILES/fontbutton.go
index 4087794..4087794 100644
--- a/fontbutton.go
+++ b/AAA_GOFILES/fontbutton.go
diff --git a/group.go b/AAA_GOFILES/group.go
index 0f9b99a..0f9b99a 100644
--- a/group.go
+++ b/AAA_GOFILES/group.go
diff --git a/label.go b/AAA_GOFILES/label.go
index e143d50..e143d50 100644
--- a/label.go
+++ b/AAA_GOFILES/label.go
diff --git a/link_darwin_amd64.go b/AAA_GOFILES/link_darwin_amd64.go
index 687a62a..687a62a 100644
--- a/link_darwin_amd64.go
+++ b/AAA_GOFILES/link_darwin_amd64.go
diff --git a/link_linux_386.go b/AAA_GOFILES/link_linux_386.go
index 00a0598..00a0598 100644
--- a/link_linux_386.go
+++ b/AAA_GOFILES/link_linux_386.go
diff --git a/link_linux_amd64.go b/AAA_GOFILES/link_linux_amd64.go
index a1b2b3b..a1b2b3b 100644
--- a/link_linux_amd64.go
+++ b/AAA_GOFILES/link_linux_amd64.go
diff --git a/link_windows_386.go b/AAA_GOFILES/link_windows_386.go
index d617a20..d617a20 100644
--- a/link_windows_386.go
+++ b/AAA_GOFILES/link_windows_386.go
diff --git a/link_windows_amd64.go b/AAA_GOFILES/link_windows_amd64.go
index 73c94af..73c94af 100644
--- a/link_windows_amd64.go
+++ b/AAA_GOFILES/link_windows_amd64.go
diff --git a/main.go b/AAA_GOFILES/main.go
index dd1443a..dd1443a 100644
--- a/main.go
+++ b/AAA_GOFILES/main.go
diff --git a/progressbar.go b/AAA_GOFILES/progressbar.go
index ef5116c..ef5116c 100644
--- a/progressbar.go
+++ b/AAA_GOFILES/progressbar.go
diff --git a/radiobuttons.go b/AAA_GOFILES/radiobuttons.go
index b8399ea..b8399ea 100644
--- a/radiobuttons.go
+++ b/AAA_GOFILES/radiobuttons.go
diff --git a/separator.go b/AAA_GOFILES/separator.go
index 5f41891..5f41891 100644
--- a/separator.go
+++ b/AAA_GOFILES/separator.go
diff --git a/slider.go b/AAA_GOFILES/slider.go
index 99b8d2c..99b8d2c 100644
--- a/slider.go
+++ b/AAA_GOFILES/slider.go
diff --git a/spinbox.go b/AAA_GOFILES/spinbox.go
index 5e5e43f..5e5e43f 100644
--- a/spinbox.go
+++ b/AAA_GOFILES/spinbox.go
diff --git a/stddialogs.go b/AAA_GOFILES/stddialogs.go
index 0ff8a01..0ff8a01 100644
--- a/stddialogs.go
+++ b/AAA_GOFILES/stddialogs.go
diff --git a/tab.go b/AAA_GOFILES/tab.go
index d18cecd..d18cecd 100644
--- a/tab.go
+++ b/AAA_GOFILES/tab.go
diff --git a/util.go b/AAA_GOFILES/util.go
index b097004..b097004 100644
--- a/util.go
+++ b/AAA_GOFILES/util.go
diff --git a/window.go b/AAA_GOFILES/window.go
index bdd230c..bdd230c 100644
--- a/window.go
+++ b/AAA_GOFILES/window.go
diff --git a/zy_page1_test.go b/AAA_GOFILES/zy_page1_test.go
index 6a8d4a4..6a8d4a4 100644
--- a/zy_page1_test.go
+++ b/AAA_GOFILES/zy_page1_test.go
diff --git a/zy_page2_test.go b/AAA_GOFILES/zy_page2_test.go
index dd4a6be..dd4a6be 100644
--- a/zy_page2_test.go
+++ b/AAA_GOFILES/zy_page2_test.go
diff --git a/zz_test.go b/AAA_GOFILES/zz_test.go
index 83a8474..83a8474 100644
--- a/zz_test.go
+++ b/AAA_GOFILES/zz_test.go
diff --git a/bindTODO b/bindTODO
deleted file mode 100644
index 7efa25e..0000000
--- a/bindTODO
+++ /dev/null
@@ -1 +0,0 @@
-uiFontButton
diff --git a/ui.h b/ui.h
index c7a8858..253cd2f 100644
--- a/ui.h
+++ b/ui.h
@@ -2,6 +2,11 @@
 
 // TODO add a uiVerifyControlType() function that can be used by control implementations to verify controls
 
+// TODOs
+// - make getters that return whether something exists accept a NULL pointer to discard the value (and thus only return that the thing exists?)
+// - const-correct everything
+// - normalize documentation between typedefs and structs
+
 #ifndef __LIBUI_UI_H__
 #define __LIBUI_UI_H__
 
@@ -32,6 +37,14 @@ extern "C" {
 // This comes from Go's math.Pi, which in turn comes from http://oeis.org/A000796.
 #define uiPi 3.14159265358979323846264338327950288419716939937510582097494459
 
+// TODO uiBool?
+
+// uiForEach represents the return value from one of libui's various ForEach functions.
+_UI_ENUM(uiForEach) {
+	uiForEachContinue,
+	uiForEachStop,
+};
+
 typedef struct uiInitOptions uiInitOptions;
 
 struct uiInitOptions {
@@ -43,11 +56,20 @@ _UI_EXTERN void uiUninit(void);
 _UI_EXTERN void uiFreeInitError(const char *err);
 
 _UI_EXTERN void uiMain(void);
+_UI_EXTERN void uiMainSteps(void);
 _UI_EXTERN int uiMainStep(int wait);
 _UI_EXTERN void uiQuit(void);
 
 _UI_EXTERN void uiQueueMain(void (*f)(void *data), void *data);
 
+// TODO standardize the looping behavior return type, either with some enum or something, and the test expressions throughout the code
+// TODO figure out what to do about looping and the exact point that the timer is rescheduled so we can document it; see https://github.com/andlabs/libui/pull/277
+// TODO (also in the above link) document that this cannot be called from any thread, unlike uiQueueMain()
+// TODO document that the minimum exact timing, either accuracy (timer burst, etc.) or granularity (15ms on Windows, etc.), is OS-defined
+// TODO also figure out how long until the initial tick is registered on all platforms to document
+// TODO also add a comment about how useful this could be in bindings, depending on the language being bound to
+_UI_EXTERN void uiTimer(int milliseconds, int (*f)(void *data), void *data);
+
 _UI_EXTERN void uiOnShouldQuit(int (*f)(void *data), void *data);
 
 _UI_EXTERN void uiFreeText(char *text);
@@ -97,7 +119,14 @@ typedef struct uiWindow uiWindow;
 #define uiWindow(this) ((uiWindow *) (this))
 _UI_EXTERN char *uiWindowTitle(uiWindow *w);
 _UI_EXTERN void uiWindowSetTitle(uiWindow *w, const char *title);
+_UI_EXTERN void uiWindowContentSize(uiWindow *w, int *width, int *height);
+_UI_EXTERN void uiWindowSetContentSize(uiWindow *w, int width, int height);
+_UI_EXTERN int uiWindowFullscreen(uiWindow *w);
+_UI_EXTERN void uiWindowSetFullscreen(uiWindow *w, int fullscreen);
+_UI_EXTERN void uiWindowOnContentSizeChanged(uiWindow *w, void (*f)(uiWindow *, void *), void *data);
 _UI_EXTERN void uiWindowOnClosing(uiWindow *w, int (*f)(uiWindow *w, void *data), void *data);
+_UI_EXTERN int uiWindowBorderless(uiWindow *w);
+_UI_EXTERN void uiWindowSetBorderless(uiWindow *w, int borderless);
 _UI_EXTERN void uiWindowSetChild(uiWindow *w, uiControl *child);
 _UI_EXTERN int uiWindowMargined(uiWindow *w);
 _UI_EXTERN void uiWindowSetMargined(uiWindow *w, int margined);
@@ -113,7 +142,7 @@ _UI_EXTERN uiButton *uiNewButton(const char *text);
 typedef struct uiBox uiBox;
 #define uiBox(this) ((uiBox *) (this))
 _UI_EXTERN void uiBoxAppend(uiBox *b, uiControl *child, int stretchy);
-_UI_EXTERN void uiBoxDelete(uiBox *b, uintmax_t index);
+_UI_EXTERN void uiBoxDelete(uiBox *b, int index);
 _UI_EXTERN int uiBoxPadded(uiBox *b);
 _UI_EXTERN void uiBoxSetPadded(uiBox *b, int padded);
 _UI_EXTERN uiBox *uiNewHorizontalBox(void);
@@ -136,6 +165,8 @@ _UI_EXTERN void uiEntryOnChanged(uiEntry *e, void (*f)(uiEntry *e, void *data),
 _UI_EXTERN int uiEntryReadOnly(uiEntry *e);
 _UI_EXTERN void uiEntrySetReadOnly(uiEntry *e, int readonly);
 _UI_EXTERN uiEntry *uiNewEntry(void);
+_UI_EXTERN uiEntry *uiNewPasswordEntry(void);
+_UI_EXTERN uiEntry *uiNewSearchEntry(void);
 
 typedef struct uiLabel uiLabel;
 #define uiLabel(this) ((uiLabel *) (this))
@@ -146,11 +177,11 @@ _UI_EXTERN uiLabel *uiNewLabel(const char *text);
 typedef struct uiTab uiTab;
 #define uiTab(this) ((uiTab *) (this))
 _UI_EXTERN void uiTabAppend(uiTab *t, const char *name, uiControl *c);
-_UI_EXTERN void uiTabInsertAt(uiTab *t, const char *name, uintmax_t before, uiControl *c);
-_UI_EXTERN void uiTabDelete(uiTab *t, uintmax_t index);
-_UI_EXTERN uintmax_t uiTabNumPages(uiTab *t);
-_UI_EXTERN int uiTabMargined(uiTab *t, uintmax_t page);
-_UI_EXTERN void uiTabSetMargined(uiTab *t, uintmax_t page, int margined);
+_UI_EXTERN void uiTabInsertAt(uiTab *t, const char *name, int before, uiControl *c);
+_UI_EXTERN void uiTabDelete(uiTab *t, int index);
+_UI_EXTERN int uiTabNumPages(uiTab *t);
+_UI_EXTERN int uiTabMargined(uiTab *t, int page);
+_UI_EXTERN void uiTabSetMargined(uiTab *t, int page, int margined);
 _UI_EXTERN uiTab *uiNewTab(void);
 
 typedef struct uiGroup uiGroup;
@@ -169,33 +200,34 @@ _UI_EXTERN uiGroup *uiNewGroup(const char *title);
 
 typedef struct uiSpinbox uiSpinbox;
 #define uiSpinbox(this) ((uiSpinbox *) (this))
-_UI_EXTERN intmax_t uiSpinboxValue(uiSpinbox *s);
-_UI_EXTERN void uiSpinboxSetValue(uiSpinbox *s, intmax_t value);
+_UI_EXTERN int uiSpinboxValue(uiSpinbox *s);
+_UI_EXTERN void uiSpinboxSetValue(uiSpinbox *s, int value);
 _UI_EXTERN void uiSpinboxOnChanged(uiSpinbox *s, void (*f)(uiSpinbox *s, void *data), void *data);
-_UI_EXTERN uiSpinbox *uiNewSpinbox(intmax_t min, intmax_t max);
+_UI_EXTERN uiSpinbox *uiNewSpinbox(int min, int max);
 
 typedef struct uiSlider uiSlider;
 #define uiSlider(this) ((uiSlider *) (this))
-_UI_EXTERN intmax_t uiSliderValue(uiSlider *s);
-_UI_EXTERN void uiSliderSetValue(uiSlider *s, intmax_t value);
+_UI_EXTERN int uiSliderValue(uiSlider *s);
+_UI_EXTERN void uiSliderSetValue(uiSlider *s, int value);
 _UI_EXTERN void uiSliderOnChanged(uiSlider *s, void (*f)(uiSlider *s, void *data), void *data);
-_UI_EXTERN uiSlider *uiNewSlider(intmax_t min, intmax_t max);
+_UI_EXTERN uiSlider *uiNewSlider(int min, int max);
 
 typedef struct uiProgressBar uiProgressBar;
 #define uiProgressBar(this) ((uiProgressBar *) (this))
-// TODO uiProgressBarValue()
+_UI_EXTERN int uiProgressBarValue(uiProgressBar *p);
 _UI_EXTERN void uiProgressBarSetValue(uiProgressBar *p, int n);
 _UI_EXTERN uiProgressBar *uiNewProgressBar(void);
 
 typedef struct uiSeparator uiSeparator;
 #define uiSeparator(this) ((uiSeparator *) (this))
 _UI_EXTERN uiSeparator *uiNewHorizontalSeparator(void);
+_UI_EXTERN uiSeparator *uiNewVerticalSeparator(void);
 
 typedef struct uiCombobox uiCombobox;
 #define uiCombobox(this) ((uiCombobox *) (this))
 _UI_EXTERN void uiComboboxAppend(uiCombobox *c, const char *text);
-_UI_EXTERN intmax_t uiComboboxSelected(uiCombobox *c);
-_UI_EXTERN void uiComboboxSetSelected(uiCombobox *c, intmax_t n);
+_UI_EXTERN int uiComboboxSelected(uiCombobox *c);
+_UI_EXTERN void uiComboboxSetSelected(uiCombobox *c, int n);
 _UI_EXTERN void uiComboboxOnSelected(uiCombobox *c, void (*f)(uiCombobox *c, void *data), void *data);
 _UI_EXTERN uiCombobox *uiNewCombobox(void);
 
@@ -211,10 +243,18 @@ _UI_EXTERN uiEditableCombobox *uiNewEditableCombobox(void);
 typedef struct uiRadioButtons uiRadioButtons;
 #define uiRadioButtons(this) ((uiRadioButtons *) (this))
 _UI_EXTERN void uiRadioButtonsAppend(uiRadioButtons *r, const char *text);
+_UI_EXTERN int uiRadioButtonsSelected(uiRadioButtons *r);
+_UI_EXTERN void uiRadioButtonsSetSelected(uiRadioButtons *r, int n);
+_UI_EXTERN void uiRadioButtonsOnSelected(uiRadioButtons *r, void (*f)(uiRadioButtons *, void *), void *data);
 _UI_EXTERN uiRadioButtons *uiNewRadioButtons(void);
 
+struct tm;
 typedef struct uiDateTimePicker uiDateTimePicker;
 #define uiDateTimePicker(this) ((uiDateTimePicker *) (this))
+// TODO document that tm_wday and tm_yday are undefined, and tm_isdst should be -1
+_UI_EXTERN void uiDateTimePickerTime(uiDateTimePicker *d, struct tm *time);
+_UI_EXTERN void uiDateTimePickerSetTime(uiDateTimePicker *d, const struct tm *time);
+_UI_EXTERN void uiDateTimePickerOnChanged(uiDateTimePicker *d, void (*f)(uiDateTimePicker *, void *), void *data);
 _UI_EXTERN uiDateTimePicker *uiNewDateTimePicker(void);
 _UI_EXTERN uiDateTimePicker *uiNewDatePicker(void);
 _UI_EXTERN uiDateTimePicker *uiNewTimePicker(void);
@@ -273,15 +313,38 @@ struct uiAreaHandler {
 	int (*KeyEvent)(uiAreaHandler *, uiArea *, uiAreaKeyEvent *);
 };
 
+// TODO RTL layouts?
+// TODO reconcile edge and corner naming
+_UI_ENUM(uiWindowResizeEdge) {
+	uiWindowResizeEdgeLeft,
+	uiWindowResizeEdgeTop,
+	uiWindowResizeEdgeRight,
+	uiWindowResizeEdgeBottom,
+	uiWindowResizeEdgeTopLeft,
+	uiWindowResizeEdgeTopRight,
+	uiWindowResizeEdgeBottomLeft,
+	uiWindowResizeEdgeBottomRight,
+	// TODO have one for keyboard resizes?
+	// TODO GDK doesn't seem to have any others, including for keyboards...
+	// TODO way to bring up the system menu instead?
+};
+
 #define uiArea(this) ((uiArea *) (this))
 // TODO give a better name
 // TODO document the types of width and height
-_UI_EXTERN void uiAreaSetSize(uiArea *a, intmax_t width, intmax_t height);
+_UI_EXTERN void uiAreaSetSize(uiArea *a, int width, int height);
 // TODO uiAreaQueueRedraw()
 _UI_EXTERN void uiAreaQueueRedrawAll(uiArea *a);
 _UI_EXTERN void uiAreaScrollTo(uiArea *a, double x, double y, double width, double height);
+// TODO document these can only be called within Mouse() handlers
+// TODO should these be allowed on scrolling areas?
+// TODO decide which mouse events should be accepted; Down is the only one guaranteed to work right now
+// TODO what happens to events after calling this up to and including the next mouse up?
+// TODO release capture?
+_UI_EXTERN void uiAreaBeginUserWindowMove(uiArea *a);
+_UI_EXTERN void uiAreaBeginUserWindowResize(uiArea *a, uiWindowResizeEdge edge);
 _UI_EXTERN uiArea *uiNewArea(uiAreaHandler *ah);
-_UI_EXTERN uiArea *uiNewScrollingArea(uiAreaHandler *ah, intmax_t width, intmax_t height);
+_UI_EXTERN uiArea *uiNewScrollingArea(uiAreaHandler *ah, int width, int height);
 
 struct uiAreaDrawParams {
 	uiDrawContext *Context;
@@ -436,90 +499,514 @@ _UI_EXTERN void uiDrawClip(uiDrawContext *c, uiDrawPath *path);
 _UI_EXTERN void uiDrawSave(uiDrawContext *c);
 _UI_EXTERN void uiDrawRestore(uiDrawContext *c);
 
-// TODO manage the use of Text, Font, and TextFont, and of the uiDrawText prefix in general
+// uiAttribute stores information about an attribute in a
+// uiAttributedString.
+//
+// You do not create uiAttributes directly; instead, you create a
+// uiAttribute of a given type using the specialized constructor
+// functions. For every Unicode codepoint in the uiAttributedString,
+// at most one value of each attribute type can be applied.
+//
+// uiAttributes are immutable and the uiAttributedString takes
+// ownership of the uiAttribute object once assigned, copying its
+// contents as necessary.
+typedef struct uiAttribute uiAttribute;
+
+// @role uiAttribute destructor
+// uiFreeAttribute() frees a uiAttribute. You generally do not need to
+// call this yourself, as uiAttributedString does this for you. In fact,
+// it is an error to call this function on a uiAttribute that has been
+// given to a uiAttributedString. You can call this, however, if you
+// created a uiAttribute that you aren't going to use later.
+_UI_EXTERN void uiFreeAttribute(uiAttribute *a);
 
-///// TODO
-typedef struct uiDrawFontFamilies uiDrawFontFamilies;
+// uiAttributeType holds the possible uiAttribute types that may be
+// returned by uiAttributeGetType(). Refer to the documentation for
+// each type's constructor function for details on each type.
+_UI_ENUM(uiAttributeType) {
+	uiAttributeTypeFamily,
+	uiAttributeTypeSize,
+	uiAttributeTypeWeight,
+	uiAttributeTypeItalic,
+	uiAttributeTypeStretch,
+	uiAttributeTypeColor,
+	uiAttributeTypeBackground,
+	uiAttributeTypeUnderline,
+	uiAttributeTypeUnderlineColor,
+	uiAttributeTypeFeatures,
+};
 
-_UI_EXTERN uiDrawFontFamilies *uiDrawListFontFamilies(void);
-_UI_EXTERN uintmax_t uiDrawFontFamiliesNumFamilies(uiDrawFontFamilies *ff);
-_UI_EXTERN char *uiDrawFontFamiliesFamily(uiDrawFontFamilies *ff, uintmax_t n);
-_UI_EXTERN void uiDrawFreeFontFamilies(uiDrawFontFamilies *ff);
-///// END TODO
+// uiAttributeGetType() returns the type of a.
+// TODO I don't like this name
+_UI_EXTERN uiAttributeType uiAttributeGetType(const uiAttribute *a);
 
-typedef struct uiDrawTextLayout uiDrawTextLayout;
-typedef struct uiDrawTextFont uiDrawTextFont;
-typedef struct uiDrawTextFontDescriptor uiDrawTextFontDescriptor;
-typedef struct uiDrawTextFontMetrics uiDrawTextFontMetrics;
+// uiNewFamilyAttribute() creates a new uiAttribute that changes the
+// font family of the text it is applied to. family is copied; you do not
+// need to keep it alive after uiNewFamilyAttribute() returns. Font
+// family names are case-insensitive.
+_UI_EXTERN uiAttribute *uiNewFamilyAttribute(const char *family);
+
+// uiAttributeFamily() returns the font family stored in a. The
+// returned string is owned by a. It is an error to call this on a
+// uiAttribute that does not hold a font family.
+_UI_EXTERN const char *uiAttributeFamily(const uiAttribute *a);
+
+// uiNewSizeAttribute() creates a new uiAttribute that changes the
+// size of the text it is applied to, in typographical points.
+_UI_EXTERN uiAttribute *uiNewSizeAttribute(double size);
+
+// uiAttributeSize() returns the font size stored in a. It is an error to
+// call this on a uiAttribute that does not hold a font size.
+_UI_EXTERN double uiAttributeSize(const uiAttribute *a);
+
+// uiTextWeight represents possible text weights. These roughly
+// map to the OSx2 text weight field of TrueType and OpenType
+// fonts, or to CSS weight numbers. The named constants are
+// nominal values; the actual values may vary by font and by OS,
+// though this isn't particularly likely. Any value between
+// uiTextWeightMinimum and uiDrawTextWeightMaximum,
+// inclusive, is allowed.
+//
+// Note that due to restrictions in early versions of Windows, some
+// fonts have "special" weights be exposed in many programs as
+// separate font families. This is perhaps most notable with
+// Arial Black. libui does not do this, even on Windows (because the
+// DirectWrite API libui uses on Windows does not do this); to
+// specify Arial Black, use family Arial and weight uiTextWeightBlack.
+_UI_ENUM(uiTextWeight) {
+	uiTextWeightMinimum = 0,
+	uiTextWeightThin = 100,
+	uiTextWeightUltraLight = 200,
+	uiTextWeightLight = 300,
+	uiTextWeightBook = 350,
+	uiTextWeightNormal = 400,
+	uiTextWeightMedium = 500,
+	uiTextWeightSemiBold = 600,
+	uiTextWeightBold = 700,
+	uiTextWeightUltraBold = 800,
+	uiTextWeightHeavy = 900,
+	uiTextWeightUltraHeavy = 950,
+	uiTextWeightMaximum = 1000,
+};
+
+// uiNewWeightAttribute() creates a new uiAttribute that changes the
+// weight of the text it is applied to. It is an error to specify a weight
+// outside the range [uiTextWeightMinimum,
+// uiTextWeightMaximum].
+_UI_EXTERN uiAttribute *uiNewWeightAttribute(uiTextWeight weight);
 
-_UI_ENUM(uiDrawTextWeight) {
-	uiDrawTextWeightThin,
-	uiDrawTextWeightUltraLight,
-	uiDrawTextWeightLight,
-	uiDrawTextWeightBook,
-	uiDrawTextWeightNormal,
-	uiDrawTextWeightMedium,
-	uiDrawTextWeightSemiBold,
-	uiDrawTextWeightBold,
-	uiDrawTextWeightUtraBold,
-	uiDrawTextWeightHeavy,
-	uiDrawTextWeightUltraHeavy,
+// uiAttributeWeight() returns the font weight stored in a. It is an error
+// to call this on a uiAttribute that does not hold a font weight.
+_UI_EXTERN uiTextWeight uiAttributeWeight(const uiAttribute *a);
+
+// uiTextItalic represents possible italic modes for a font. Italic
+// represents "true" italics where the slanted glyphs have custom
+// shapes, whereas oblique represents italics that are merely slanted
+// versions of the normal glyphs. Most fonts usually have one or the
+// other.
+_UI_ENUM(uiTextItalic) {
+	uiTextItalicNormal,
+	uiTextItalicOblique,
+	uiTextItalicItalic,
+};
+
+// uiNewItalicAttribute() creates a new uiAttribute that changes the
+// italic mode of the text it is applied to. It is an error to specify an
+// italic mode not specified in uiTextItalic.
+_UI_EXTERN uiAttribute *uiNewItalicAttribute(uiTextItalic italic);
+
+// uiAttributeItalic() returns the font italic mode stored in a. It is an
+// error to call this on a uiAttribute that does not hold a font italic
+// mode.
+_UI_EXTERN uiTextItalic uiAttributeItalic(const uiAttribute *a);
+
+// uiTextStretch represents possible stretches (also called "widths")
+// of a font.
+//
+// Note that due to restrictions in early versions of Windows, some
+// fonts have "special" stretches be exposed in many programs as
+// separate font families. This is perhaps most notable with
+// Arial Condensed. libui does not do this, even on Windows (because
+// the DirectWrite API libui uses on Windows does not do this); to
+// specify Arial Condensed, use family Arial and stretch
+// uiTextStretchCondensed.
+_UI_ENUM(uiTextStretch) {
+	uiTextStretchUltraCondensed,
+	uiTextStretchExtraCondensed,
+	uiTextStretchCondensed,
+	uiTextStretchSemiCondensed,
+	uiTextStretchNormal,
+	uiTextStretchSemiExpanded,
+	uiTextStretchExpanded,
+	uiTextStretchExtraExpanded,
+	uiTextStretchUltraExpanded,
 };
 
-_UI_ENUM(uiDrawTextItalic) {
-	uiDrawTextItalicNormal,
-	uiDrawTextItalicOblique,
-	uiDrawTextItalicItalic,
+// uiNewStretchAttribute() creates a new uiAttribute that changes the
+// stretch of the text it is applied to. It is an error to specify a strech
+// not specified in uiTextStretch.
+_UI_EXTERN uiAttribute *uiNewStretchAttribute(uiTextStretch stretch);
+
+// uiAttributeStretch() returns the font stretch stored in a. It is an
+// error to call this on a uiAttribute that does not hold a font stretch.
+_UI_EXTERN uiTextStretch uiAttributeStretch(const uiAttribute *a);
+
+// uiNewColorAttribute() creates a new uiAttribute that changes the
+// color of the text it is applied to. It is an error to specify an invalid
+// color.
+_UI_EXTERN uiAttribute *uiNewColorAttribute(double r, double g, double b, double a);
+
+// uiAttributeColor() returns the text color stored in a. It is an
+// error to call this on a uiAttribute that does not hold a text color.
+_UI_EXTERN void uiAttributeColor(const uiAttribute *a, double *r, double *g, double *b, double *alpha);
+
+// uiNewBackgroundAttribute() creates a new uiAttribute that
+// changes the background color of the text it is applied to. It is an
+// error to specify an invalid color.
+_UI_EXTERN uiAttribute *uiNewBackgroundAttribute(double r, double g, double b, double a);
+
+// TODO reuse uiAttributeColor() for background colors, or make a new function...
+
+// uiUnderline specifies a type of underline to use on text.
+_UI_ENUM(uiUnderline) {
+	uiUnderlineNone,
+	uiUnderlineSingle,
+	uiUnderlineDouble,
+	uiUnderlineSuggestion,		// wavy or dotted underlines used for spelling/grammar checkers
 };
 
-_UI_ENUM(uiDrawTextStretch) {
-	uiDrawTextStretchUltraCondensed,
-	uiDrawTextStretchExtraCondensed,
-	uiDrawTextStretchCondensed,
-	uiDrawTextStretchSemiCondensed,
-	uiDrawTextStretchNormal,
-	uiDrawTextStretchSemiExpanded,
-	uiDrawTextStretchExpanded,
-	uiDrawTextStretchExtraExpanded,
-	uiDrawTextStretchUltraExpanded,
+// uiNewUnderlineAttribute() creates a new uiAttribute that changes
+// the type of underline on the text it is applied to. It is an error to
+// specify an underline type not specified in uiUnderline.
+_UI_EXTERN uiAttribute *uiNewUnderlineAttribute(uiUnderline u);
+
+// uiAttributeUnderline() returns the underline type stored in a. It is
+// an error to call this on a uiAttribute that does not hold an underline
+// style.
+_UI_EXTERN uiUnderline uiAttributeUnderline(const uiAttribute *a);
+
+// uiUnderlineColor specifies the color of any underline on the text it
+// is applied to, regardless of the type of underline. In addition to
+// being able to specify a custom color, you can explicitly specify
+// platform-specific colors for suggestion underlines; to use them
+// correctly, pair them with uiUnderlineSuggestion (though they can
+// be used on other types of underline as well).
+// 
+// If an underline type is applied but no underline color is
+// specified, the text color is used instead. If an underline color
+// is specified without an underline type, the underline color
+// attribute is ignored, but not removed from the uiAttributedString.
+_UI_ENUM(uiUnderlineColor) {
+	uiUnderlineColorCustom,
+	uiUnderlineColorSpelling,
+	uiUnderlineColorGrammar,
+	uiUnderlineColorAuxiliary,		// for instance, the color used by smart replacements on macOS or in Microsoft Office
 };
 
-struct uiDrawTextFontDescriptor {
-	const char *Family;
+// uiNewUnderlineColorAttribute() creates a new uiAttribute that
+// changes the color of the underline on the text it is applied to.
+// It is an error to specify an underline color not specified in
+// uiUnderlineColor.
+//
+// If the specified color type is uiUnderlineColorCustom, it is an
+// error to specify an invalid color value. Otherwise, the color values
+// are ignored and should be specified as zero.
+_UI_EXTERN uiAttribute *uiNewUnderlineColorAttribute(uiUnderlineColor u, double r, double g, double b, double a);
+
+// uiAttributeUnderlineColor() returns the underline color stored in
+// a. It is an error to call this on a uiAttribute that does not hold an
+// underline color.
+_UI_EXTERN void uiAttributeUnderlineColor(const uiAttribute *a, uiUnderlineColor *u, double *r, double *g, double *b, double *alpha);
+
+// uiOpenTypeFeatures represents a set of OpenType feature
+// tag-value pairs, for applying OpenType features to text.
+// OpenType feature tags are four-character codes defined by
+// OpenType that cover things from design features like small
+// caps and swashes to language-specific glyph shapes and
+// beyond. Each tag may only appear once in any given
+// uiOpenTypeFeatures instance. Each value is a 32-bit integer,
+// often used as a Boolean flag, but sometimes as an index to choose
+// a glyph shape to use.
+// 
+// If a font does not support a certain feature, that feature will be
+// ignored. (TODO verify this on all OSs)
+// 
+// See the OpenType specification at
+// https://www.microsoft.com/typography/otspec/featuretags.htm
+// for the complete list of available features, information on specific
+// features, and how to use them.
+// TODO invalid features
+typedef struct uiOpenTypeFeatures uiOpenTypeFeatures;
+
+// uiOpenTypeFeaturesForEachFunc is the type of the function
+// invoked by uiOpenTypeFeaturesForEach() for every OpenType
+// feature in otf. Refer to that function's documentation for more
+// details.
+typedef uiForEach (*uiOpenTypeFeaturesForEachFunc)(const uiOpenTypeFeatures *otf, char a, char b, char c, char d, uint32_t value, void *data);
+
+// @role uiOpenTypeFeatures constructor
+// uiNewOpenTypeFeatures() returns a new uiOpenTypeFeatures
+// instance, with no tags yet added.
+_UI_EXTERN uiOpenTypeFeatures *uiNewOpenTypeFeatures(void);
+
+// @role uiOpenTypeFeatures destructor
+// uiFreeOpenTypeFeatures() frees otf.
+_UI_EXTERN void uiFreeOpenTypeFeatures(uiOpenTypeFeatures *otf);
+
+// uiOpenTypeFeaturesClone() makes a copy of otf and returns it.
+// Changing one will not affect the other.
+_UI_EXTERN uiOpenTypeFeatures *uiOpenTypeFeaturesClone(const uiOpenTypeFeatures *otf);
+
+// uiOpenTypeFeaturesAdd() adds the given feature tag and value
+// to otf. The feature tag is specified by a, b, c, and d. If there is
+// already a value associated with the specified tag in otf, the old
+// value is removed.
+_UI_EXTERN void uiOpenTypeFeaturesAdd(uiOpenTypeFeatures *otf, char a, char b, char c, char d, uint32_t value);
+
+// uiOpenTypeFeaturesRemove() removes the given feature tag
+// and value from otf. If the tag is not present in otf,
+// uiOpenTypeFeaturesRemove() does nothing.
+_UI_EXTERN void uiOpenTypeFeaturesRemove(uiOpenTypeFeatures *otf, char a, char b, char c, char d);
+
+// uiOpenTypeFeaturesGet() determines whether the given feature
+// tag is present in otf. If it is, *value is set to the tag's value and
+// nonzero is returned. Otherwise, zero is returned.
+// 
+// Note that if uiOpenTypeFeaturesGet() returns zero, value isn't
+// changed. This is important: if a feature is not present in a
+// uiOpenTypeFeatures, the feature is NOT treated as if its
+// value was zero anyway. Script-specific font shaping rules and
+// font-specific feature settings may use a different default value
+// for a feature. You should likewise not treat a missing feature as
+// having a value of zero either. Instead, a missing feature should
+// be treated as having some unspecified default value.
+_UI_EXTERN int uiOpenTypeFeaturesGet(const uiOpenTypeFeatures *otf, char a, char b, char c, char d, uint32_t *value);
+
+// uiOpenTypeFeaturesForEach() executes f for every tag-value
+// pair in otf. The enumeration order is unspecified. You cannot
+// modify otf while uiOpenTypeFeaturesForEach() is running.
+_UI_EXTERN void uiOpenTypeFeaturesForEach(const uiOpenTypeFeatures *otf, uiOpenTypeFeaturesForEachFunc f, void *data);
+
+// uiNewFeaturesAttribute() creates a new uiAttribute that changes
+// the font family of the text it is applied to. otf is copied; you may
+// free it after uiNewFeaturesAttribute() returns.
+_UI_EXTERN uiAttribute *uiNewFeaturesAttribute(const uiOpenTypeFeatures *otf);
+
+// uiAttributeFeatures() returns the OpenType features stored in a.
+// The returned uiOpenTypeFeatures object is owned by a. It is an
+// error to call this on a uiAttribute that does not hold OpenType
+// features.
+_UI_EXTERN const uiOpenTypeFeatures *uiAttributeFeatures(const uiAttribute *a);
+
+// uiAttributedString represents a string of UTF-8 text that can
+// optionally be embellished with formatting attributes. libui
+// provides the list of formatting attributes, which cover common
+// formatting traits like boldface and color as well as advanced
+// typographical features provided by OpenType like superscripts
+// and small caps. These attributes can be combined in a variety of
+// ways.
+//
+// Attributes are applied to runs of Unicode codepoints in the string.
+// Zero-length runs are elided. Consecutive runs that have the same
+// attribute type and value are merged. Each attribute is independent
+// of each other attribute; overlapping attributes of different types
+// do not split each other apart, but different values of the same
+// attribute type do.
+//
+// The empty string can also be represented by uiAttributedString,
+// but because of the no-zero-length-attribute rule, it will not have
+// attributes.
+//
+// A uiAttributedString takes ownership of all attributes given to
+// it, as it may need to duplicate or delete uiAttribute objects at
+// any time. By extension, when you free a uiAttributedString,
+// all uiAttributes within will also be freed. Each method will
+// describe its own rules in more details.
+//
+// In addition, uiAttributedString provides facilities for moving
+// between grapheme clusters, which represent a character
+// from the point of view of the end user. The cursor of a text editor
+// is always placed on a grapheme boundary, so you can use these
+// features to move the cursor left or right by one "character".
+// TODO does uiAttributedString itself need this
+//
+// uiAttributedString does not provide enough information to be able
+// to draw itself onto a uiDrawContext or respond to user actions.
+// In order to do that, you'll need to use a uiDrawTextLayout, which
+// is built from the combination of a uiAttributedString and a set of
+// layout-specific properties.
+typedef struct uiAttributedString uiAttributedString;
+
+// uiAttributedStringForEachAttributeFunc is the type of the function
+// invoked by uiAttributedStringForEachAttribute() for every
+// attribute in s. Refer to that function's documentation for more
+// details.
+typedef uiForEach (*uiAttributedStringForEachAttributeFunc)(const uiAttributedString *s, const uiAttribute *a, size_t start, size_t end, void *data);
+
+// @role uiAttributedString constructor
+// uiNewAttributedString() creates a new uiAttributedString from
+// initialString. The string will be entirely unattributed.
+_UI_EXTERN uiAttributedString *uiNewAttributedString(const char *initialString);
+
+// @role uiAttributedString destructor
+// uiFreeAttributedString() destroys the uiAttributedString s.
+// It will also free all uiAttributes within.
+_UI_EXTERN void uiFreeAttributedString(uiAttributedString *s);
+
+// uiAttributedStringString() returns the textual content of s as a
+// '\0'-terminated UTF-8 string. The returned pointer is valid until
+// the next change to the textual content of s.
+_UI_EXTERN const char *uiAttributedStringString(const uiAttributedString *s);
+
+// uiAttributedStringLength() returns the number of UTF-8 bytes in
+// the textual content of s, excluding the terminating '\0'.
+_UI_EXTERN size_t uiAttributedStringLen(const uiAttributedString *s);
+
+// uiAttributedStringAppendUnattributed() adds the '\0'-terminated
+// UTF-8 string str to the end of s. The new substring will be
+// unattributed.
+_UI_EXTERN void uiAttributedStringAppendUnattributed(uiAttributedString *s, const char *str);
+
+// uiAttributedStringInsertAtUnattributed() adds the '\0'-terminated
+// UTF-8 string str to s at the byte position specified by at. The new
+// substring will be unattributed; existing attributes will be moved
+// along with their text.
+_UI_EXTERN void uiAttributedStringInsertAtUnattributed(uiAttributedString *s, const char *str, size_t at);
+
+// TODO add the Append and InsertAtExtendingAttributes functions
+// TODO and add functions that take a string + length
+
+// uiAttributedStringDelete() deletes the characters and attributes of
+// s in the byte range [start, end).
+_UI_EXTERN void uiAttributedStringDelete(uiAttributedString *s, size_t start, size_t end);
+
+// TODO add a function to uiAttributedString to get an attribute's value at a specific index or in a specific range, so we can edit
+
+// uiAttributedStringSetAttribute() sets a in the byte range [start, end)
+// of s. Any existing attributes in that byte range of the same type are
+// removed. s takes ownership of a; you should not use it after
+// uiAttributedStringSetAttribute() returns.
+_UI_EXTERN void uiAttributedStringSetAttribute(uiAttributedString *s, uiAttribute *a, size_t start, size_t end);
+
+// uiAttributedStringForEachAttribute() enumerates all the
+// uiAttributes in s. It is an error to modify s in f. Within f, s still
+// owns the attribute; you can neither free it nor save it for later
+// use.
+// TODO reword the above for consistency (TODO and find out what I meant by that)
+// TODO define an enumeration order (or mark it as undefined); also define how consecutive runs of identical attributes are handled here and sync with the definition of uiAttributedString itself
+_UI_EXTERN void uiAttributedStringForEachAttribute(const uiAttributedString *s, uiAttributedStringForEachAttributeFunc f, void *data);
+
+// TODO const correct this somehow (the implementation needs to mutate the structure)
+_UI_EXTERN size_t uiAttributedStringNumGraphemes(uiAttributedString *s);
+
+// TODO const correct this somehow (the implementation needs to mutate the structure)
+_UI_EXTERN size_t uiAttributedStringByteIndexToGrapheme(uiAttributedString *s, size_t pos);
+
+// TODO const correct this somehow (the implementation needs to mutate the structure)
+_UI_EXTERN size_t uiAttributedStringGraphemeToByteIndex(uiAttributedString *s, size_t pos);
+
+// uiFontDescriptor provides a complete description of a font where
+// one is needed. Currently, this means as the default font of a
+// uiDrawTextLayout and as the data returned by uiFontButton.
+// All the members operate like the respective uiAttributes.
+typedef struct uiFontDescriptor uiFontDescriptor;
+
+struct uiFontDescriptor {
+	// TODO const-correct this or figure out how to deal with this when getting a value
+	char *Family;
 	double Size;
-	uiDrawTextWeight Weight;
-	uiDrawTextItalic Italic;
-	uiDrawTextStretch Stretch;
+	uiTextWeight Weight;
+	uiTextItalic Italic;
+	uiTextStretch Stretch;
+};
+
+// uiDrawTextLayout is a concrete representation of a
+// uiAttributedString that can be displayed in a uiDrawContext.
+// It includes information important for the drawing of a block of
+// text, including the bounding box to wrap the text within, the
+// alignment of lines of text within that box, areas to mark as
+// being selected, and other things.
+//
+// Unlike uiAttributedString, the content of a uiDrawTextLayout is
+// immutable once it has been created.
+//
+// TODO talk about OS-specific differences with text drawing that libui can't account for...
+typedef struct uiDrawTextLayout uiDrawTextLayout;
+
+// uiDrawTextAlign specifies the alignment of lines of text in a
+// uiDrawTextLayout.
+// TODO should this really have Draw in the name?
+_UI_ENUM(uiDrawTextAlign) {
+	uiDrawTextAlignLeft,
+	uiDrawTextAlignCenter,
+	uiDrawTextAlignRight,
 };
 
-struct uiDrawTextFontMetrics {
-	double Ascent;
-	double Descent;
-	double Leading;
-	// TODO do these two mean the same across all platforms?
-	double UnderlinePos;
-	double UnderlineThickness;
+// uiDrawTextLayoutParams describes a uiDrawTextLayout.
+// DefaultFont is used to render any text that is not attributed
+// sufficiently in String. Width determines the width of the bounding
+// box of the text; the height is determined automatically.
+typedef struct uiDrawTextLayoutParams uiDrawTextLayoutParams;
+
+// TODO const-correct this somehow
+struct uiDrawTextLayoutParams {
+	uiAttributedString *String;
+	uiFontDescriptor *DefaultFont;
+	double Width;
+	uiDrawTextAlign Align;
 };
 
-_UI_EXTERN uiDrawTextFont *uiDrawLoadClosestFont(const uiDrawTextFontDescriptor *desc);
-_UI_EXTERN void uiDrawFreeTextFont(uiDrawTextFont *font);
-_UI_EXTERN uintptr_t uiDrawTextFontHandle(uiDrawTextFont *font);
-_UI_EXTERN void uiDrawTextFontDescribe(uiDrawTextFont *font, uiDrawTextFontDescriptor *desc);
-// TODO make copy with given attributes methods?
-// TODO yuck this name
-_UI_EXTERN void uiDrawTextFontGetMetrics(uiDrawTextFont *font, uiDrawTextFontMetrics *metrics);
+// @role uiDrawTextLayout constructor
+// uiDrawNewTextLayout() creates a new uiDrawTextLayout from
+// the given parameters.
+//
+// TODO
+// - allow creating a layout out of a substring
+// - allow marking compositon strings
+// - allow marking selections, even after creation
+// - add the following functions:
+// 	- uiDrawTextLayoutHeightForWidth() (returns the height that a layout would need to be to display the entire string at a given width)
+// 	- uiDrawTextLayoutRangeForSize() (returns what substring would fit in a given size)
+// 	- uiDrawTextLayoutNewWithHeight() (limits amount of string used by the height)
+// - some function to fix up a range (for text editing)
+_UI_EXTERN uiDrawTextLayout *uiDrawNewTextLayout(uiDrawTextLayoutParams *params);
 
-// TODO initial line spacing? and what about leading?
-_UI_EXTERN uiDrawTextLayout *uiDrawNewTextLayout(const char *text, uiDrawTextFont *defaultFont, double width);
-_UI_EXTERN void uiDrawFreeTextLayout(uiDrawTextLayout *layout);
-// TODO get width
-_UI_EXTERN void uiDrawTextLayoutSetWidth(uiDrawTextLayout *layout, double width);
-_UI_EXTERN void uiDrawTextLayoutExtents(uiDrawTextLayout *layout, double *width, double *height);
+// @role uiDrawFreeTextLayout destructor
+// uiDrawFreeTextLayout() frees tl. The underlying
+// uiAttributedString is not freed.
+_UI_EXTERN void uiDrawFreeTextLayout(uiDrawTextLayout *tl);
 
-// and the attributes that you can set on a text layout
-_UI_EXTERN void uiDrawTextLayoutSetColor(uiDrawTextLayout *layout, intmax_t startChar, intmax_t endChar, double r, double g, double b, double a);
+// uiDrawText() draws tl in c with the top-left point of tl at (x, y).
+_UI_EXTERN void uiDrawText(uiDrawContext *c, uiDrawTextLayout *tl, double x, double y);
 
-_UI_EXTERN void uiDrawText(uiDrawContext *c, double x, double y, uiDrawTextLayout *layout);
+// uiDrawTextLayoutExtents() returns the width and height of tl
+// in width and height. The returned width may be smaller than
+// the width passed into uiDrawNewTextLayout() depending on
+// how the text in tl is wrapped. Therefore, you can use this
+// function to get the actual size of the text layout.
+_UI_EXTERN void uiDrawTextLayoutExtents(uiDrawTextLayout *tl, double *width, double *height);
+
+// TODO metrics functions
+
+// TODO number of lines visible for clipping rect, range visible for clipping rect?
+
+// uiFontButton is a button that allows users to choose a font when they click on it.
+typedef struct uiFontButton uiFontButton;
+#define uiFontButton(this) ((uiFontButton *) (this))
+// uiFontButtonFont() returns the font currently selected in the uiFontButton in desc.
+// uiFontButtonFont() allocates resources in desc; when you are done with the font, call uiFreeFontButtonFont() to release them.
+// uiFontButtonFont() does not allocate desc itself; you must do so.
+// TODO have a function that sets an entire font descriptor to a range in a uiAttributedString at once, for SetFont?
+_UI_EXTERN void uiFontButtonFont(uiFontButton *b, uiFontDescriptor *desc);
+// TOOD SetFont, mechanics
+// uiFontButtonOnChanged() sets the function that is called when the font in the uiFontButton is changed.
+_UI_EXTERN void uiFontButtonOnChanged(uiFontButton *b, void (*f)(uiFontButton *, void *), void *data);
+// uiNewFontButton() creates a new uiFontButton. The default font selected into the uiFontButton is OS-defined.
+_UI_EXTERN uiFontButton *uiNewFontButton(void);
+// uiFreeFontButtonFont() frees resources allocated in desc by uiFontButtonFont().
+// After calling uiFreeFontButtonFont(), the contents of desc should be assumed to be undefined (though since you allocate desc itself, you can safely reuse desc for other font descriptors).
+// Calling uiFreeFontButtonFont() on a uiFontDescriptor not returned by uiFontButtonFont() results in undefined behavior.
+_UI_EXTERN void uiFreeFontButtonFont(uiFontDescriptor *desc);
 
 _UI_ENUM(uiModifiers) {
 	uiModifierCtrl = 1 << 0,
@@ -538,10 +1025,10 @@ struct uiAreaMouseEvent {
 	double AreaWidth;
 	double AreaHeight;
 
-	uintmax_t Down;
-	uintmax_t Up;
+	int Down;
+	int Up;
 
-	uintmax_t Count;
+	int Count;
 
 	uiModifiers Modifiers;
 
@@ -600,14 +1087,6 @@ struct uiAreaKeyEvent {
 	int Up;
 };
 
-typedef struct uiFontButton uiFontButton;
-#define uiFontButton(this) ((uiFontButton *) (this))
-// TODO document this returns a new font
-_UI_EXTERN uiDrawTextFont *uiFontButtonFont(uiFontButton *b);
-// TOOD SetFont, mechanics
-_UI_EXTERN void uiFontButtonOnChanged(uiFontButton *b, void (*f)(uiFontButton *, void *), void *data);
-_UI_EXTERN uiFontButton *uiNewFontButton(void);
-
 typedef struct uiColorButton uiColorButton;
 #define uiColorButton(this) ((uiColorButton *) (this))
 _UI_EXTERN void uiColorButtonColor(uiColorButton *b, double *r, double *g, double *bl, double *a);
@@ -615,6 +1094,367 @@ _UI_EXTERN void uiColorButtonSetColor(uiColorButton *b, double r, double g, doub
 _UI_EXTERN void uiColorButtonOnChanged(uiColorButton *b, void (*f)(uiColorButton *, void *), void *data);
 _UI_EXTERN uiColorButton *uiNewColorButton(void);
 
+typedef struct uiForm uiForm;
+#define uiForm(this) ((uiForm *) (this))
+_UI_EXTERN void uiFormAppend(uiForm *f, const char *label, uiControl *c, int stretchy);
+_UI_EXTERN void uiFormDelete(uiForm *f, int index);
+_UI_EXTERN int uiFormPadded(uiForm *f);
+_UI_EXTERN void uiFormSetPadded(uiForm *f, int padded);
+_UI_EXTERN uiForm *uiNewForm(void);
+
+_UI_ENUM(uiAlign) {
+	uiAlignFill,
+	uiAlignStart,
+	uiAlignCenter,
+	uiAlignEnd,
+};
+
+_UI_ENUM(uiAt) {
+	uiAtLeading,
+	uiAtTop,
+	uiAtTrailing,
+	uiAtBottom,
+};
+
+typedef struct uiGrid uiGrid;
+#define uiGrid(this) ((uiGrid *) (this))
+_UI_EXTERN void uiGridAppend(uiGrid *g, uiControl *c, int left, int top, int xspan, int yspan, int hexpand, uiAlign halign, int vexpand, uiAlign valign);
+_UI_EXTERN void uiGridInsertAt(uiGrid *g, uiControl *c, uiControl *existing, uiAt at, int xspan, int yspan, int hexpand, uiAlign halign, int vexpand, uiAlign valign);
+_UI_EXTERN int uiGridPadded(uiGrid *g);
+_UI_EXTERN void uiGridSetPadded(uiGrid *g, int padded);
+_UI_EXTERN uiGrid *uiNewGrid(void);
+
+// uiImage stores an image for display on screen.
+// 
+// Images are built from one or more representations, each with the
+// same aspect ratio but a different pixel size. libui automatically
+// selects the most appropriate representation for drawing the image
+// when it comes time to draw the image; what this means depends
+// on the pixel density of the target context. Therefore, one can use
+// uiImage to draw higher-detailed images on higher-density
+// displays. The typical use cases are either:
+// 
+// 	- have just a single representation, at which point all screens
+// 	  use the same image, and thus uiImage acts like a simple
+// 	  bitmap image, or
+// 	- have two images, one at normal resolution and one at 2x
+// 	  resolution; this matches the current expectations of some
+// 	  desktop systems at the time of writing (mid-2018)
+// 
+// uiImage is very simple: it only supports non-premultiplied 32-bit
+// RGBA images, and libui does not provide any image file loading
+// or image format conversion utilities on top of that.
+typedef struct uiImage uiImage;
+
+// @role uiImage constructor
+// uiNewImage creates a new uiImage with the given width and
+// height. This width and height should be the size in points of the
+// image in the device-independent case; typically this is the 1x size.
+// TODO for all uiImage functions: use const void * for const correctness
+_UI_EXTERN uiImage *uiNewImage(double width, double height);
+
+// @role uiImage destructor
+// uiFreeImage frees the given image and all associated resources.
+_UI_EXTERN void uiFreeImage(uiImage *i);
+
+// uiImageAppend adds a representation to the uiImage.
+// pixels should point to a byte array of non-premultiplied pixels
+// stored in [R G B A] order (so ((uint8_t *) pixels)[0] is the R of the
+// first pixel and [3] is the A of the first pixel). pixelWidth and
+// pixelHeight is the size *in pixels* of the image, and pixelStride is
+// the number *of bytes* per row of the pixels array. Therefore,
+// pixels itself must be at least byteStride * pixelHeight bytes long.
+// TODO see if we either need the stride or can provide a way to get the OS-preferred stride (in cairo we do)
+_UI_EXTERN void uiImageAppend(uiImage *i, void *pixels, int pixelWidth, int pixelHeight, int byteStride);
+
+// uiTableValue stores a value to be passed along uiTable and
+// uiTableModel.
+//
+// You do not create uiTableValues directly; instead, you create a
+// uiTableValue of a given type using the specialized constructor
+// functions.
+//
+// uiTableValues are immutable and the uiTableModel and uiTable
+// take ownership of the uiTableValue object once returned, copying
+// its contents as necessary.
+typedef struct uiTableValue uiTableValue;
+
+// @role uiTableValue destructor
+// uiFreeTableValue() frees a uiTableValue. You generally do not
+// need to call this yourself, as uiTable and uiTableModel do this
+// for you. In fact, it is an error to call this function on a uiTableValue
+// that has been given to a uiTable or uiTableModel. You can call this,
+// however, if you created a uiTableValue that you aren't going to
+// use later, or if you called a uiTableModelHandler method directly
+// and thus never transferred ownership of the uiTableValue.
+_UI_EXTERN void uiFreeTableValue(uiTableValue *v);
+
+// uiTableValueType holds the possible uiTableValue types that may
+// be returned by uiTableValueGetType(). Refer to the documentation
+// for each type's constructor function for details on each type.
+// TODO actually validate these
+_UI_ENUM(uiTableValueType) {
+	uiTableValueTypeString,
+	uiTableValueTypeImage,
+	uiTableValueTypeInt,
+	uiTableValueTypeColor,
+};
+
+// uiTableValueGetType() returns the type of v.
+// TODO I don't like this name
+_UI_EXTERN uiTableValueType uiTableValueGetType(const uiTableValue *v);
+
+// uiNewTableValueString() returns a new uiTableValue that contains
+// str. str is copied; you do not need to keep it alive after
+// uiNewTableValueString() returns.
+_UI_EXTERN uiTableValue *uiNewTableValueString(const char *str);
+
+// uiTableValueString() returns the string stored in v. The returned
+// string is owned by v. It is an error to call this on a uiTableValue
+// that does not hold a string.
+_UI_EXTERN const char *uiTableValueString(const uiTableValue *v);
+
+// uiNewTableValueImage() returns a new uiTableValue that contains
+// the given uiImage.
+// 
+// Unlike other similar constructors, uiNewTableValueImage() does
+// NOT copy the image. This is because images are comparatively
+// larger than the other objects in question. Therefore, you MUST
+// keep the image alive as long as the returned uiTableValue is alive.
+// As a general rule, if libui calls a uiTableModelHandler method, the
+// uiImage is safe to free once any of your code is once again
+// executed.
+_UI_EXTERN uiTableValue *uiNewTableValueImage(uiImage *img);
+
+// uiTableValueImage() returns the uiImage stored in v. As these
+// images are not owned by v, you should not assume anything
+// about the lifetime of the image (unless you created the image,
+// and thus control its lifetime). It is an error to call this on a
+// uiTableValue that does not hold an image.
+_UI_EXTERN uiImage *uiTableValueImage(const uiTableValue *v);
+
+// uiNewTableValueInt() returns a uiTableValue that stores the given
+// int. This can be used both for boolean values (nonzero is true, as
+// in C) or progresses (in which case the valid range is -1..100
+// inclusive).
+_UI_EXTERN uiTableValue *uiNewTableValueInt(int i);
+
+// uiTableValueInt() returns the int stored in v. It is an error to call
+// this on a uiTableValue that does not store an int.
+_UI_EXTERN int uiTableValueInt(const uiTableValue *v);
+
+// uiNewTableValueColor() returns a uiTableValue that stores the
+// given color.
+_UI_EXTERN uiTableValue *uiNewTableValueColor(double r, double g, double b, double a);
+
+// uiTableValueColor() returns the color stored in v. It is an error to
+// call this on a uiTableValue that does not store a color.
+// TODO define whether all this, for both uiTableValue and uiAttribute, is undefined behavior or a caught error
+_UI_EXTERN void uiTableValueColor(const uiTableValue *v, double *r, double *g, double *b, double *a);
+
+// uiTableModel is an object that provides the data for a uiTable.
+// This data is returned via methods you provide in the
+// uiTableModelHandler struct.
+//
+// uiTableModel represents data using a table, but this table does
+// not map directly to uiTable itself. Instead, you can have data
+// columns which provide instructions for how to render a given
+// uiTable's column — for instance, one model column can be used
+// to give certain rows of a uiTable a different background color.
+// Row numbers DO match with uiTable row numbers.
+//
+// Once created, the number and data types of columns of a
+// uiTableModel cannot change.
+//
+// Row and column numbers start at 0. A uiTableModel can be
+// associated with more than one uiTable at a time.
+typedef struct uiTableModel uiTableModel;
+
+// uiTableModelHandler defines the methods that uiTableModel
+// calls when it needs data. Once a uiTableModel is created, these
+// methods cannot change.
+typedef struct uiTableModelHandler uiTableModelHandler;
+
+// TODO validate ranges; validate types on each getter/setter call (? table columns only?)
+struct uiTableModelHandler {
+	// NumColumns returns the number of model columns in the
+	// uiTableModel. This value must remain constant through the
+	// lifetime of the uiTableModel. This method is not guaranteed
+	// to be called depending on the system.
+	// TODO strongly check column numbers and types on all platforms so these clauses can go away
+	int (*NumColumns)(uiTableModelHandler *, uiTableModel *);
+	// ColumnType returns the value type of the data stored in
+	// the given model column of the uiTableModel. The returned
+	// values must remain constant through the lifetime of the
+	// uiTableModel. This method is not guaranteed to be called
+	// depending on the system.
+	uiTableValueType (*ColumnType)(uiTableModelHandler *, uiTableModel *, int);
+	// NumRows returns the number or rows in the uiTableModel.
+	// This value must be non-negative.
+	int (*NumRows)(uiTableModelHandler *, uiTableModel *);
+	// CellValue returns a uiTableValue corresponding to the model
+	// cell at (row, column). The type of the returned uiTableValue
+	// must match column's value type. Under some circumstances,
+	// NULL may be returned; refer to the various methods that add
+	// columns to uiTable for details. Once returned, the uiTable
+	// that calls CellValue will free the uiTableValue returned.
+	uiTableValue *(*CellValue)(uiTableModelHandler *mh, uiTableModel *m, int row, int column);
+	// SetCellValue changes the model cell value at (row, column)
+	// in the uiTableModel. Within this function, either do nothing
+	// to keep the current cell value or save the new cell value as
+	// appropriate. After SetCellValue is called, the uiTable will
+	// itself reload the table cell. Under certain conditions, the
+	// uiTableValue passed in can be NULL; refer to the various
+	// methods that add columns to uiTable for details. Once
+	// returned, the uiTable that called SetCellValue will free the
+	// uiTableValue passed in.
+	void (*SetCellValue)(uiTableModelHandler *, uiTableModel *, int, int, const uiTableValue *);
+};
+
+// @role uiTableModel constructor
+// uiNewTableModel() creates a new uiTableModel with the given
+// handler methods.
+_UI_EXTERN uiTableModel *uiNewTableModel(uiTableModelHandler *mh);
+
+// @role uiTableModel destructor
+// uiFreeTableModel() frees the given table model. It is an error to
+// free table models currently associated with a uiTable.
+_UI_EXTERN void uiFreeTableModel(uiTableModel *m);
+
+// uiTableModelRowInserted() tells any uiTable associated with m
+// that a new row has been added to m at index index. You call
+// this function when the number of rows in your model has
+// changed; after calling it, NumRows() should returm the new row
+// count.
+_UI_EXTERN void uiTableModelRowInserted(uiTableModel *m, int newIndex);
+
+// uiTableModelRowChanged() tells any uiTable associated with m
+// that the data in the row at index has changed. You do not need to
+// call this in your SetCellValue() handlers, but you do need to call
+// this if your data changes at some other point.
+_UI_EXTERN void uiTableModelRowChanged(uiTableModel *m, int index);
+
+// uiTableModelRowDeleted() tells any uiTable associated with m
+// that the row at index index has been deleted. You call this
+// function when the number of rows in your model has changed;
+// after calling it, NumRows() should returm the new row
+// count.
+// TODO for this and Inserted: make sure the "after" part is right; clarify if it's after returning or after calling
+_UI_EXTERN void uiTableModelRowDeleted(uiTableModel *m, int oldIndex);
+// TODO reordering/moving
+
+// uiTableModelColumnNeverEditable and
+// uiTableModelColumnAlwaysEditable are the value of an editable
+// model column parameter to one of the uiTable create column
+// functions; if used, that jparticular uiTable colum is not editable
+// by the user and always editable by the user, respectively.
+#define uiTableModelColumnNeverEditable (-1)
+#define uiTableModelColumnAlwaysEditable (-2)
+
+// uiTableTextColumnOptionalParams are the optional parameters
+// that control the appearance of the text column of a uiTable.
+typedef struct uiTableTextColumnOptionalParams uiTableTextColumnOptionalParams;
+
+// uiTableParams defines the parameters passed to uiNewTable().
+typedef struct uiTableParams uiTableParams;
+
+struct uiTableTextColumnOptionalParams {
+	// ColorModelColumn is the model column containing the
+	// text color of this uiTable column's text, or -1 to use the
+	// default color.
+	//
+	// If CellValue() for this column for any cell returns NULL, that
+	// cell will also use the default text color.
+	int ColorModelColumn;
+};
+
+struct uiTableParams {
+	// Model is the uiTableModel to use for this uiTable.
+	// This parameter cannot be NULL.
+	uiTableModel *Model;
+	// RowBackgroundColorModelColumn is a model column
+	// number that defines the background color used for the
+	// entire row in the uiTable, or -1 to use the default color for
+	// all rows.
+	//
+	// If CellValue() for this column for any row returns NULL, that
+	// row will also use the default background color.
+	int RowBackgroundColorModelColumn;
+};
+
+// uiTable is a uiControl that shows tabular data, allowing users to
+// manipulate rows of such data at a time.
+typedef struct uiTable uiTable;
+#define uiTable(this) ((uiTable *) (this))
+
+// uiTableAppendTextColumn() appends a text column to t.
+// name is displayed in the table header.
+// textModelColumn is where the text comes from.
+// If a row is editable according to textEditableModelColumn,
+// SetCellValue() is called with textModelColumn as the column.
+_UI_EXTERN void uiTableAppendTextColumn(uiTable *t,
+	const char *name,
+	int textModelColumn,
+	int textEditableModelColumn,
+	uiTableTextColumnOptionalParams *textParams);
+
+// uiTableAppendImageColumn() appends an image column to t.
+// Images are drawn at icon size, appropriate to the pixel density
+// of the screen showing the uiTable.
+_UI_EXTERN void uiTableAppendImageColumn(uiTable *t,
+	const char *name,
+	int imageModelColumn);
+
+// uiTableAppendImageTextColumn() appends a column to t that
+// shows both an image and text.
+_UI_EXTERN void uiTableAppendImageTextColumn(uiTable *t,
+	const char *name,
+	int imageModelColumn,
+	int textModelColumn,
+	int textEditableModelColumn,
+	uiTableTextColumnOptionalParams *textParams);
+
+// uiTableAppendCheckboxColumn appends a column to t that
+// contains a checkbox that the user can interact with (assuming the
+// checkbox is editable). SetCellValue() will be called with
+// checkboxModelColumn as the column in this case.
+_UI_EXTERN void uiTableAppendCheckboxColumn(uiTable *t,
+	const char *name,
+	int checkboxModelColumn,
+	int checkboxEditableModelColumn);
+
+// uiTableAppendCheckboxTextColumn() appends a column to t
+// that contains both a checkbox and text.
+_UI_EXTERN void uiTableAppendCheckboxTextColumn(uiTable *t,
+	const char *name,
+	int checkboxModelColumn,
+	int checkboxEditableModelColumn,
+	int textModelColumn,
+	int textEditableModelColumn,
+	uiTableTextColumnOptionalParams *textParams);
+
+// uiTableAppendProgressBarColumn() appends a column to t
+// that displays a progress bar. These columns work like
+// uiProgressBar: a cell value of 0..100 displays that percentage, and
+// a cell value of -1 displays an indeterminate progress bar.
+_UI_EXTERN void uiTableAppendProgressBarColumn(uiTable *t,
+	const char *name,
+	int progressModelColumn);
+
+// uiTableAppendButtonColumn() appends a column to t
+// that shows a button that the user can click on. When the user
+// does click on the button, SetCellValue() is called with a NULL
+// value and buttonModelColumn as the column.
+// CellValue() on buttonModelColumn should return the text to show
+// in the button.
+_UI_EXTERN void uiTableAppendButtonColumn(uiTable *t,
+	const char *name,
+	int buttonModelColumn,
+	int buttonClickableModelColumn);
+
+// uiNewTable() creates a new uiTable with the specified parameters.
+_UI_EXTERN uiTable *uiNewTable(uiTableParams *params);
+
 #ifdef __cplusplus
 }
 #endif