another UI attempt, I guess.

sorry.

244 files changed, 35965 insertions, 0 deletions

diff --git a/src/libui_sdl/libui/.travis.yml b/src/libui_sdl/libui/.travis.yml
new file mode 100644
index 0000000..d271bd8
--- /dev/null
+++ b/src/libui_sdl/libui/.travis.yml
@@ -0,0 +1,23 @@
+os:
+  - linux
+  - osx
+
+# This makes us use Ubuntu 14 instead of 12
+dist: trusty
+
+# Notes:
+# - Travis uses cmake 3.0.2 on OS X; we need 3.1 or newer (thanks tbodt)
+
+language: c
+script:
+  - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo apt-get update; fi
+  - if [ "$TRAVIS_OS_NAME" == "linux" ]; then sudo apt-get install libgtk-3-dev -y || sudo apt-cache search libgtk3; fi
+  - if [ "$TRAVIS_OS_NAME" == "osx" ]; then brew update; fi
+  - mkdir build
+  - cd build
+  - cmake --version
+  - cmake .. -G "Unix Makefiles"
+  - make tester examples
+  - rm -rf *
+  - cmake .. -G "Unix Makefiles" -DBUILD_SHARED_LIBS=OFF
+  - make tester examples
diff --git a/src/libui_sdl/libui/ANNOUNCE.md b/src/libui_sdl/libui/ANNOUNCE.md
new file mode 100644
index 0000000..4db42eb
--- /dev/null
+++ b/src/libui_sdl/libui/ANNOUNCE.md
@@ -0,0 +1,22 @@
+# Old Announcements
+
+* **29 May 2016**
+	* **Alpha 3 is here!** Get it [here](https://github.com/andlabs/libui/releases/tag/alpha3).
+	* The next packaged release will introduce:
+		* uiGrid, another way to lay out controls, a la GtkGrid
+		* uiOpenGLArea, a way to render OpenGL content in a libui uiArea
+		* uiTable, a data grid control that may or may not have tree facilities (if it does, it will be called uiTree instead)
+		* a complete, possibly rewritten, drawing and text rendering infrastructure
+
+* **24 May 2016**
+	* You can now help choose [a potential new build system for libui](https://github.com/andlabs/libui/issues/62).
+	* Tomorrow I will decide if OS X 10.7 will also be dropped alongside GTK+ 3.4-3.8 this Saturday. Stay tuned.
+
+* **22 May 2016**
+	* Two more open questions I'd like your feedback on are available [here](https://github.com/andlabs/libui/issues/48) and [here](https://github.com/andlabs/libui/issues/25).
+	* Sometime in the next 48 hours (before 23:59 EDT on 24 May 2016) I will split `uiCombobox` into two separate controls, `uiCombobox` and `uiEditableCombobox`, each with slightly different events and "selected item" mechanics. Prepare your existing code.
+
+* **21 May 2016**
+	* I will now post announcements and updates here.
+	* Now that Ubuntu 16.04 LTS is here, no earlier than next Saturday, 28 May 2016 at noon EDT, **I will bump the minimum GTK+ version from 3.4 to 3.10**. This will add a lot of new features that I can now add to libui, such as search-oriented uiEntries, lists of arbitrary control layouts, and more. If you are still running a Linux distribution that doesn't come with 3.10, you will either need to upgrade or use jhbuild to set up a newer version of GTK+ in a private environment.
+	* You can decide if I should also drop OS X 10.7 [here](https://github.com/andlabs/libui/issues/46).
diff --git a/src/libui_sdl/libui/CMakeLists.txt b/src/libui_sdl/libui/CMakeLists.txt
new file mode 100644
index 0000000..eb1696d
--- /dev/null
+++ b/src/libui_sdl/libui/CMakeLists.txt
@@ -0,0 +1,219 @@
+# 3 june 2016
+# see https://cmake.org/gitweb?p=cmake.git;a=commit;h=95cdf132489c79e88a10fdf7a7566fa002c7680b (thanks ngladitz in irc.freenode.net/#cmake)
+cmake_minimum_required(VERSION 3.1.0 FATAL_ERROR)
+
+# TODOs
+# - silence entering/leaving messages?
+# - uname -s for more refined OS control
+# 	- Haiku for haiku
+# - debian DESTDIR? https://github.com/andlabs/libui/pull/10
+# - libui-combined* needs to be deleted so that custom command can run every time
+# - add notelemetry.obj to *ALL TARGETS* on VS2015 and up - https://www.infoq.com/news/2016/06/visual-cpp-telemetry
+# - switch to 3.1.0 features
+
+# the docs say we need to set this up prior to project()
+set(CMAKE_OSX_DEPLOYMENT_TARGET "10.8")
+
+# we want to disable incremental linking
+# see also:
+# - https://github.com/bulletphysics/bullet3/blob/master/CMakeLists.txt#L43
+# - https://cmake.org/pipermail/cmake/2010-February/035174.html
+# this must also go before project()
+set(MSVC_INCREMENTAL_DEFAULT ON)
+
+# default to debug builds
+# do this before project() just to be safe
+if(NOT CMAKE_BUILD_TYPE)
+	set(CMAKE_BUILD_TYPE DEBUG CACHE STRING "" FORCE)
+endif()
+
+project(libui)
+option(BUILD_SHARED_LIBS "Whether to build libui as a shared library or a static library" ON)
+
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/out")
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/out")
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/out")
+set(CMAKE_PDB_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/out")
+
+if(APPLE)
+	set(_OSNAME darwin)
+	set(_HASVERSION TRUE)
+	set(_VERSION "A")
+
+	# always use our rpath
+	set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
+	# the / is required by some older versions of OS X
+	set(CMAKE_INSTALL_RPATH "@executable_path/")
+	set(CMAKE_MACOSX_RPATH TRUE)
+elseif(WIN32)
+	set(_OSNAME windows)
+
+	# and don't include the default libraries with ANY of the builds
+	# note the CACHE FORCE stuff is required here
+	set(CMAKE_C_STANDARD_LIBRARIES CACHE STRING "" FORCE)
+	set(CMAKE_CXX_STANDARD_LIBRARIES CACHE STRING "" FORCE)
+else()
+	set(_OSNAME unix)
+	set(_HASVERSION TRUE)
+	set(_VERSION "0")
+
+	# always use our rpath
+	set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
+	set(CMAKE_INSTALL_RPATH "\$ORIGIN")
+endif()
+
+# common flags
+if(MSVC)
+	# TODO subsystem version
+
+	# TODO /Wall does too much
+	# TODO -Wno-switch equivalent
+	# TODO /sdl turns C4996 into an ERROR
+	# don't use /analyze; that requires us to write annotations everywhere
+	# TODO undecided flags from qo?
+	# /RTCc is not supplied because it's discouraged as of VS2015; see https://www.reddit.com/r/cpp/comments/46mhne/rtcc_rejects_conformant_code_with_visual_c_2015/d06auq5
+	# /EHsc is to shut the compiler up in some cases
+	# TODO make /EHsc C++-only
+	set(_COMMON_CFLAGS
+		/W4 /wd4100
+		/bigobj /nologo
+		/RTC1 /RTCs /RTCu
+		/EHsc
+	)
+
+	# note the /MANIFEST:NO (which must be / and uppercase); thanks FraGag (https://github.com/andlabs/libui/issues/93#issuecomment-223183436)
+	# TODO warnings on undefined symbols
+	set(_COMMON_LDFLAGS
+		/LARGEADDRESSAWARE
+		/NOLOGO
+		/INCREMENTAL:NO
+		/MANIFEST:NO
+	)
+
+	# TODO autogenerate a .def file?
+
+	# more incremental linking fixes
+	# TODO actually get rid of incremental linking here
+else()
+	set(_COMMON_CFLAGS
+		-Wall -Wextra -pedantic
+		-Wno-unused-parameter
+		-Wno-switch
+		-fvisibility=hidden
+	)
+	# don't use C_VERSION or CXX_VERSION because they use GNU standards
+	# TODO we can actually do this; set both C_EXTENSIONS and CXX_EXTENSIONS to OFF
+	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} --std=c99")
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --std=c++11")
+
+	set(_COMMON_LDFLAGS
+		-fvisibility=hidden
+	)
+
+	# don't require shipping the MinGW-w64 DLLs
+	if(WIN32)
+		list(APPEND _COMMON_LDFLAGS
+			-static
+			-static-libgcc
+			-static-libstdc++
+		)
+	endif()
+endif()
+
+# problem:
+# - target_link_libraries() only supports - for flags
+# - but cmake only doesn't generate the manifest if the flag has a /
+macro(_target_link_options_private _target)
+	foreach(_opt IN LISTS ${ARGN})
+		set_property(TARGET ${_target} APPEND_STRING PROPERTY
+			LINK_FLAGS " ${_opt}")
+	endforeach()
+endmacro()
+
+add_subdirectory("common")
+add_subdirectory("${_OSNAME}")
+add_library(${_LIBUINAME} ${_LIBUI_SOURCES})
+target_include_directories(${_LIBUINAME}
+	PUBLIC .
+	PRIVATE ${_LIBUI_INCLUEDIRS})
+target_compile_definitions(${_LIBUINAME}
+	PRIVATE ${_LIBUI_DEFS})
+# cmake produces this for us by default but only for shared libraries
+target_compile_definitions(${_LIBUINAME}
+	PRIVATE libui_EXPORTS)
+target_compile_options(${_LIBUINAME}
+	PUBLIC ${_COMMON_CFLAGS}
+	PRIVATE ${_LIBUI_CFLAGS})
+# TODO link directories?
+if(BUILD_SHARED_LIBS)
+	target_link_libraries(${_LIBUINAME}
+		PRIVATE ${_LIBUI_LIBS})
+endif()
+# TODO INTERFACE libs don't inherit to grandhcildren?
+# on Windows the linker for static libraries is different; don't give it the flags
+if(BUILD_SHARED_LIBS)
+	_target_link_options_private(${_LIBUINAME}
+		_COMMON_LDFLAGS
+		_LIBUI_LDFLAGS)
+endif()
+if(NOT BUILD_SHARED_LIBS)
+	_handle_static()
+	# TODO figure out a way to tell libui that it's static
+	target_compile_definitions(${_LIBUINAME}
+		PUBLIC _UI_STATIC)
+endif()
+if(NOT MSVC)
+	# on non-MSVC compilers cmake adds an extra lib-
+	# note that we apply this to libui, not to any intermediates
+	set_target_properties(libui PROPERTIES
+		OUTPUT_NAME ui)
+
+	# flags for warning on undefined symbols
+	# TODO figure out why FreeBSD follows linked libraries here
+	# TODO figure out MSVC equivalents
+	if(BUILD_SHARED_LIBS)
+		if(NOT (${CMAKE_SYSTEM_NAME} STREQUAL FreeBSD))
+			# on OS X we don't need to do this; Apple's linker warns about undefined symbols in -shared builds!
+			if(NOT APPLE)
+				target_link_libraries(libui
+					PRIVATE -Wl,--no-undefined -Wl,--no-allow-shlib-undefined
+				)
+			endif()
+		endif()
+	endif()
+endif()
+if(BUILD_SHARED_LIBS)
+	if(_HASVERSION)
+		set_target_properties(${_LIBUINAME} PROPERTIES
+			SOVERSION "${_VERSION}")
+	endif()
+endif()
+
+macro(_add_exec _name)
+	add_executable(${_name}
+		WIN32 EXCLUDE_FROM_ALL
+		${ARGN})
+	target_link_libraries(${_name} libui ${_LIBUI_STATIC_RES})
+	_target_link_options_private(${_name}
+		_COMMON_LDFLAGS)
+	# make shared-linked executables PIC too
+	if(BUILD_SHARED_LIBS)
+		set_property(TARGET ${_name} PROPERTY
+			POSITION_INDEPENDENT_CODE True)
+	endif()
+	# TODO see above about INTERFACE
+	if(NOT BUILD_SHARED_LIBS)
+		target_link_libraries(${_name}
+			${_LIBUI_LIBS})
+	endif()
+
+	# TODOfor some reason these don't propagate
+	if(NOT WIN32)
+		target_include_directories(${_name}
+			PUBLIC .)
+		target_compile_options(${_name}
+			PUBLIC ${_COMMON_CFLAGS})
+	endif()
+endmacro()
+add_subdirectory("test")
+add_subdirectory("examples")
diff --git a/src/libui_sdl/libui/Changelog.md b/src/libui_sdl/libui/Changelog.md
new file mode 100644
index 0000000..29fac27
--- /dev/null
+++ b/src/libui_sdl/libui/Changelog.md
@@ -0,0 +1,33 @@
+# Old Updates
+
+* **29 May 2016**
+	* Thanks to @pcwalton, we can now statically link libui! Simply do `make STATIC=1` instead of just `make`.
+		* On Windows you must link both `libui.lib` and `libui.res` AND provide a Common Controls 6 manifest for output static binaries to work properly.
+
+* **28 May 2016**
+	* As promised, **the minimum system requirements are now OS X 10.8 and GTK+ 3.10 for OS X and Unix, respectively**.
+
+* **26 May 2016**
+	* Two OS X-specific functions have been added: `uiDarwinMarginAmount()` and `uiDarwinPaddingAmount()`. These return the amount of margins and padding, respectively, to give to a control, and are intended for container implementations. These are suitable for the constant of a NSLayoutConstraint. They both take a pointer parameter that is reserved for future use and should be `NULL`.
+
+* **25 May 2016**
+	* uiDrawTextLayout attributes are now specified in units of *graphemes* on all platforms. This means characters as seen from a user's perspective, not Unicode codepoints or UTF-8 bytes. So a long string of combining marker codepoints after one codepoint would still count as one grapheme.
+
+* **24 May 2016**
+	* As promised, `uiCombobox` is now split into `uiCombobox` for non-editable comboboxes and `uiEditableCombobox` for editable comboboxes. Mind the function changes as well :)
+	* There is a new function `uiMainStep()`, which runs one iteration of the main loop. It takes a single boolean argument, indicating whether to wait for an event to occur or not. It returns true if an event was processed (or if no event is available if you don't want to wait) and false if the event loop was told to stop (for instance, `uiQuit()` was called).
+
+* **23 May 2016**
+	* Fixed surrogate pair drawing on OS X.
+
+* **22 May 2016**
+	* Removed `uiControlVerifyDestroy()`; that is now part of `uiFreeControl()` itself.
+	* Added `uiPi`, a constant for π. This is provided for C and C++ programmers, where there is no standard named constant for π; bindings authors shouldn't need to worry about this.
+	* Fixed uiMultilineEntry not properly having line breaks on Windows.
+	* Added `uiNewNonWrappingMultilineEntry()`, which creates a uiMultilineEntry that scrolls horizontally instead of wrapping lines. (This is not documented as being changeable after the fact on Windows, hence it's a creation-time choice.)
+	* uiAreas on Windows and some internal Direct2D areas now respond to `WM_PRINTCLIENT` properly, which should hopefully increase the quality of screenshots.
+	* uiDateTimePicker on GTK+ works properly on RTL layouts and no longer disappears off the bottom of the screen if not enough room is available. It will also no longer be marked for localization of the time format (what the separator should be and whether to use 24-hour time), as that information is not provided by the locale system. :(
+	* Added `uiUserBugCannotSetParentOnToplevel()`, which should be used by implementations of toplevel controls in their `SetParent()` implementations. This will also be the beginning of consolidating common user bug messages into a single place, though this will be one of the only few exported user bug functions.
+	* uiSpinbox and uiSlider now merely swap their min and max if min ≥ max. They will no longer panic and do nothing, respectively.
+	* Matrix scaling will no longer leave the matrix in an invalid state on OS X and GTK+.
+	* `uiMultilineEntrySetText()` and `uiMutlilineEntryAppend()` on GTK+ no longer fire `OnChanged()` events.
diff --git a/src/libui_sdl/libui/Compatibility.md b/src/libui_sdl/libui/Compatibility.md
new file mode 100644
index 0000000..bc16f1b
--- /dev/null
+++ b/src/libui_sdl/libui/Compatibility.md
@@ -0,0 +1,141 @@
+# Useful things in newer versions
+
+## Windows
+### Windows 7
+http://channel9.msdn.com/blogs/pdc2008/pc43
+
+TODO look up PDC 2008 talk "new shell user interface"
+
+- new animation and text engine
+- ribbon control (didn't this have some additional license?)
+- LVITEM.piColFmt
+
+### Windows 8
+
+### Windows 8.1
+
+### Windows 10
+
+## GTK+
+TODO what ships with Ubuntu Quantal (12.10)?
+
+### GTK+ 3.6
+ships with: Ubuntu Raring (13.04)
+
+- GtkEntry and GtkTextView have input purposes and input hints for external input methods but do not change input themselves
+	- according to Company, we connect to insert-text for that
+- GtkLevelBar
+- GtkMenuButton
+- **GtkSearchEntry**
+
+### GTK+ 3.8
+ships with: Ubuntu Saucy (13.10)
+
+Not many interesting new things to us here, unless you count widget-internal tickers and single-click instead of double-click to select list items (a la KDE)... and oh yeah, also widget opacity.
+
+### GTK+ 3.10
+ships with: **Ubuntu Trusty (14.04 LTS)**
+<br>GLib version: 2.40
+
+- tab character stops in GtkEntry
+- GtkHeaderBar
+	- intended for titlebar overrides; GtkInfoBar is what I keep thinking GtkHeaderBar is
+- **GtkListBox**
+- GtkRevealer for smooth animations of disclosure triangles
+- GtkSearchBar for custom search popups
+- **GtkStack and GtkStackSwitcher**
+- titlebar overrides (seems to be the hot new thing)
+
+### GTK+ 3.12
+ships with: Ubuntu Utopic (14.10)
+<br>GLib version: 2.42
+
+- GtkActionBar (basically like the bottom-of-the-window toolbars in Mac programs)
+- gtk_get_locale_direction(), for internationalization
+- more control over GtkHeaderBar
+- **GtkPopover**
+	- GtkPopovers on GtkMenuButtons
+- GtkStack signaling
+- **gtk_tree_path_new_from_indicesv()** (for when we add Table if we have trees too)
+
+### GTK+ 3.14
+ships with: **Debian Jessie**, Ubuntu Vivid (15.04)
+<br>GLib version: Debian: 2.42, Ubuntu: 2.44
+
+- gestures
+- better GtkListbox selection handling
+- more style classes (TODO also prior?)
+- delayed switch changes on GtkSwitch
+
+### GTK+ 3.16
+ships with: Ubuntu Wily (15.10)
+<br>GLib version: 2.46
+
+- gtk_clipboard_get_default() (???)
+- **GtkGLArea**
+- proper xalign and yalign for GtkLabel; should get rid of runtime deprecation warnings
+- better control of GtkListBox model-based creation (probably not relevant but)
+- GtkModelButton (for GActions; probably not relevant?)
+- wide handles on GtkPaned
+- GtkPopoverMenu
+- IPP paper names in GtkPaperSize (TODO will this be important for printing?)
+- multiple matches in GtkSearchEntry (TODO evaluate priority)
+- **GtkStackSidebar**
+-  GTK_STYLE_CLASS_LABEL, GTK_STYLE_CLASS_MONOSPACE, GTK_STYLE_CLASS_STATUSBAR, GTK_STYLE_CLASS_TOUCH_SELECTION, GTK_STYLE_CLASS_WIDE (TODO figure out which of these are useful)
+- GtkTextView: extend-selection
+- GtkTextView: font fallbacks
+
+### GTK+ 3.18
+
+### GTK+ 3.20
+
+## Cocoa
+### Mac OS X 10.8
+
+- Foundation ([full details](https://developer.apple.com/library/mac/releasenotes/Foundation/RN-FoundationOlderNotes/#//apple_ref/doc/uid/TP40008080-TRANSLATED_CHAPTER_965-TRANSLATED_DEST_999B))
+	- NSDateComponents supports leap months
+	- NSNumberFormatter and NSDateFormatter default to 10.4 behavior by default (need to explicitly do this on 10.7)
+	- **NSUserNotification and NSUserNotificationCenter for Growl-style notifications**
+	- better linguistic triggers for Spanish and Italian
+	- NSByteCountFormatter
+- AppKit ([full details](https://developer.apple.com/library/mac/releasenotes/AppKit/RN-AppKitOlderNotes/#X10_8Notes))
+	- view-based NSTableView/NSOutlineView have expansion tooltips
+	- NSScrollView magnification
+	- Quick Look events; TODO see if they conflict with keyboard handling in Area
+	- NSPageController (maybe useful?)
+	- not useful for package UI, but may be useful for a new library (probably not by me): NSSharingService
+	- NSOpenPanel and NSSavePanel are now longer NSPanels or NSWindows in sandboxed applications; this may be an issue should anyone dare to enable sandboxing on a program that uses package ui
+	- NSTextAlternatives
+	- -[NSOpenGLContext setFullScreen] now ineffective
+	- +[NSColor underPageBackgroundColor]
+
+### Mac OS X 10.9
+
+- Foundation ([full details](https://developer.apple.com/library/mac/releasenotes/Foundation/RN-Foundation/))
+	- system-provided progress reporting/cancellation support
+	- NSURLComponents
+	- **NSCalendar, NSDateFormatter, and NSNumberFormatter are now thread-safe**
+	- various NSCalendar and NSDateComponents improvements
+- AppKit ([full details](https://developer.apple.com/library/mac/releasenotes/AppKit/RN-AppKit/))
+	- sheet handling is now block-based, queued, and in NSWindow; the delegate-based NSApplication API will still exist, except without the queue
+	- similar changes to NSAlert
+	- **return value changes to NSAlert**
+	- window visibility APIs (occlusion)
+	- NSApplicationActivationPolicyAccessory
+	- fullscreen toolbar behavior changes
+	- status items for multiple menu bars
+	- better NSSharingService support
+	- a special accelerated scrolling mode, Responsive Scrolling; won't matter for us since I plan to support the scroll wheel and it won't
+	- NSScrollView live scrolling notifications
+	- NSScrollView floating (anchored/non-scrolling) subviews
+	- better multimonitor support
+	- better key-value observing for NSOpenPanel/NSSavePanel (might want to look this up to see if we can override some other juicy details... TODO)
+	- better accessory view key-view handling in NSOpenPanel/NSSavePanel
+	- NSAppearance
+	- **-[NSTableView moveRowAtIndex:toIndex:] bug regarding first responders fixed**
+	- view-specific RTL overrides
+
+### Mac OS X 10.10
+
+### Mac OS X 10.11
+* **NSLayoutGuide**
diff --git a/src/libui_sdl/libui/LICENSE b/src/libui_sdl/libui/LICENSE
new file mode 100644
index 0000000..2351d66
--- /dev/null
+++ b/src/libui_sdl/libui/LICENSE
@@ -0,0 +1,9 @@
+Copyright (c) 2014 Pietro Gagliardi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+(this is called the MIT License or Expat License; see http://www.opensource.org/licenses/MIT)
diff --git a/src/libui_sdl/libui/README.md b/src/libui_sdl/libui/README.md
new file mode 100644
index 0000000..01275c0
--- /dev/null
+++ b/src/libui_sdl/libui/README.md
@@ -0,0 +1,185 @@
+# libui: a portable GUI library for C
+
+This README is being written.<br>
+[![Build Status](https://travis-ci.org/andlabs/libui.svg)](https://travis-ci.org/andlabs/libui)
+
+## Announcements
+
+* **27 November 2016**
+	* Decided to split the table stuff into its own branch. It will be developed independently of everything else, along with a few other features.
+
+* **2 November 2016**
+	* Added two new functions to replace the deleted `uiWindowPosition()` and friends: `uiAreaBeginUserWindowMove()` and `uiAreaBeginUserWindowResize()`. When used in a `uiAreaHandler.Mouse()` event handler, these let you initiate a user-driven mouse move or mouse resize of the window at any point in a uiArea.
+
+* **31 October 2016**
+	* @krakjoe noticed that I accidentally used thread-unsafe code in uiQueueMain() on Unix. Fixed.
+
+* **24 October 2016**
+	* `uiWindowSetContentSize()` on Unix no longer needs to call up the GTK+ main loop. As a result, bugs related to strange behavior using that function (and the now-deleted `uiWindowSetPosition()` and `uiWindowCenter()`) should go away. I'll need to go through the bugs to verify as much, though.
+
+* **22 October 2016**
+	* Due to being unable to guarantee they will work (especially as we move toward capability-driven window systems like Wayland), or being unable to work without hacking that breaks other things, the following functions have been removed: `uiWindowPosition()`, `uiWindowSetPosition()`, `uiWindowCenter()`, and `uiWindowOnPositionChanged()`. Centering may come back at some point in the future, albeit in a possibly restricted form. A function to initiate a user move when a part of a uiArea is clicked will be provided soon.
+
+* **21 October 2016**
+	* `uiDrawTextWeightUltraBold` is now spelled correctly. Thanks to @krakjoe.
+
+* **18 June 2016**
+	* Help decide [the design of tables and trees in libui](https://github.com/andlabs/libui/issues/159); the implementation starts within the next few days, if not tomorrow!
+
+* **17 June 2016**
+	* **CMake 3.1.0 is now required.** This is due to CMake's rapid development pace in the past few years adding things libui needs to build on as many systems as possible. If your OS is supported by libui but its repositories ship with an older version of CMake, you will need to find an updated one somewhere.
+	* Please help [plan out a better menu API](https://github.com/andlabs/libui/issues/152).
+
+* **5 June 2016**
+	* **Alpha 3.1 is here.** This was a much-needed update to Alpha 3 that changes a few things:
+		* **The build system is now cmake.** cmake 2.8.11 or higher is needed.
+		* Static linking is now fully possible.
+		* MinGW linking is back, but static only.
+
+*Old announcements can be found in the ANNOUNCE.md file.*
+
+## Updates
+
+*Note that today's entry (Eastern Time) may be updated later today.*
+
+* **<codedate**
+	* Added `uiTable` TODO
+
+* **17 June 2016**
+	* `uiMainSteps()` no longer takes any arguments and no longer needs to invoke a function to do the work. You still need to call it, but once you do, it will return immediately and you can then get right to your main loop.
+	* **CMake 3.1.0 is now required.** This is due to CMake's rapid development pace in the past few years adding things libui needs to build on as many systems as possible. If your OS is supported by libui but its repositories ship with an older version of CMake, you will need to find an updated one somewhere.
+	* Added `uiNewVerticalSeparator()` to complement `uiNewHorizontalSeparator()`.
+
+* **16 June 2016**
+	* Added `uiWindowContentSize()`, `uiWindowSetContentSize()`, and `uiWindowOnContentSizeChanged()` methods for manipulating uiWindow content sizes. Note the use of "content size"; the size you work with does NOT include window decorations (titlebars, menus, etc.).
+	* Added `uiWindowFullscreen()` and `uiWindowSetFullscreen()` to allow making fullscreen uiWindows, taking advantage of OS facilities for fullscreen and without changing the screen resolution (!).
+	* Added `uiWindowBorderless()` and `uiWindowSetBorderless()` for allowing borderless uiWindows.
+	* Added `uiMainSteps()`. You call this instead of `uiMain()` if you want to run the main loop yourself. You pass in a function that will be called; within that function, you call `uiMainStep()` repeatedly until it returns 0, doing whatever you need to do in the meantime. (This was needed because just having `uiMainStep()` by itself only worked on some systems.)
+	* Added `uiProgressBarValue()` and allowed passing -1 to `uiProgressBarSetValue()` to make an indeterminate progress bar. Thanks to @emersion.
+
+* **15 June 2016**
+	* Added `uiFormDelete()`; thanks to @emersion.
+	* Added `uiWindowPosition()`, `uiWindowSetPosition()`, `uiWindowCenter()`, and `uiWindowOnPositionChanged()`, methods for manipulating uiWindow position.
+
+* **14 June 2016**
+	* uiDarwinControl now has a `ChildVisibilityChanged()` method and a corresponding `NotifyVisibilityChanged()` function that is called by the default show/hide handlers. This is used to make visibility changes work on OS X; uiBox, uiForm, and uiGrid all respect these now.
+	* The same has been done on the Windows side as well.
+	* Hiding and showing controls and padding calculations are now correct on Windows at long last.
+	* Hiding a control in a uiForm now hides its label on all platforms.
+
+* **13 June 2016**
+	* `intmax_t` and `uintmax_t` are no longer used for libui API functions; now we use `int`. This should make things much easier for bindings. `int` should be at least 32 bits wide; this should be sufficient for all but the most extreme cases.
+
+* **12 June 2016**
+	* Added `uiGrid`, a new container control that arranges controls in rows and columns, with stretchy ("expanding") rows, stretchy ("expanding") columns, cells that span rows and columns, and cells whose content is aligned in either direction rather than just filling. It's quite powerful, is it? =P
+
+* **8 June 2016**
+	* Added `uiForm`, a new container control that arranges controls vertically, with properly aligned labels on each. Have fun!
+
+* **6 June 2016**
+	* Added `uiRadioButtonsSelected()`, `uiRadioButtonsSetSelected()`, and `uiRadioButtonsOnSelected()` to control selection of a radio button and catch an event when such a thing happens.
+
+* **5 June 2016**
+	* Added `uiNewPasswordEntry()`, which creates a new `uiEntry` suitable for entering passwords.
+	* Added `uiNewSearchEntry()`, which creates a new `uiEntry` suitable for searching. On some systems, the `OnChanged()` event will be slightly delayed and/or combined, to produce a more natural feel when searching.
+
+*Old updates can be found in the Changelog.md file.*
+
+## Runtime Requirements
+
+* Windows: Windows Vista SP2 with Platform Update or newer
+* Unix: GTK+ 3.10 or newer
+* Mac OS X: OS X 10.8 or newer
+
+## Build Requirements
+
+* All platforms:
+	* CMake 3.1.0 or newer
+* Windows: either
+	* Microsoft Visual Studio 2013 or newer (2013 is needed for `va_copy()`) — you can build either a static or a shared library
+	* MinGW-w64 (other flavors of MinGW may not work) — **you can only build a static library**; shared library support will be re-added once the following features come in:
+		* [Isolation awareness](https://msdn.microsoft.com/en-us/library/aa375197%28v=vs.85%29.aspx), which is how you get themed controls from a DLL without needing a manifest
+* Unix: nothing else specific
+* Mac OS X: nothing else specific, so long as you can build Cocoa programs
+
+## Building
+
+Out-of-tree builds typical of cmake are preferred:
+
+```
+$ # you must be in the top-level libui directory, otherwise this won't work
+$ mkdir build
+$ cd build
+$ cmake ..
+```
+
+Pass `-DBUILD_SHARED_LIBS=OFF` to `cmake` to build a static library. The standard cmake build configurations are provided; if none is specified, `Debug` is used.
+
+If you use a makefile generator with cmake, then
+
+```
+$ make
+$ make tester         # for the test program
+$ make examples       # for examples
+```
+
+and pass `VERBOSE=1` to see build commands. Build targets will be in the `build/out` folder.
+
+Project file generators should work, but are untested by me.
+
+On Windows, I use the `Unix Makefiles` generator and GNU make (built using the `build_w32.bat` script included in the source and run in the Visual Studio command line). In this state, if MinGW-w64 (either 32-bit or 64-bit) is not in your `%PATH%`, cmake will use MSVC by default; otherwise, cmake will use with whatever MinGW-w64 is in your path. `set PATH=%PATH%;c:\msys2\mingw(32/64)\bin` should be enough to temporarily change to a MinGW-w64 build for the current command line session only if you installed MinGW-w64 through [MSYS2](https://msys2.github.io/); no need to change global environment variables constantly.
+
+## Installation
+
+#### Arch Linux
+
+Can be built from AUR: https://aur.archlinux.org/packages/libui-git/
+
+## Documentation
+
+Needs to be written. Consult `ui.h` and the examples for details for now.
+
+## Language Bindings
+
+libui was originally written as part of my [package ui for Go](https://github.com/andlabs/ui). Now that libui is separate, package ui has become a binding to libui. As such, package ui is the only official binding.
+
+Other people have made bindings to other languages:
+
+Language | Bindings
+--- | ---
+C#/.net | [LibUI.Binding](https://github.com/NattyNarwhal/LibUI.Binding), [SharpUI](https://github.com/benpye/sharpui/)
+CHICKEN Scheme | [wasamasa/libui](https://github.com/wasamasa/libui)
+Crystal | [libui.cr](https://github.com/Fusion/libui.cr)
+D | [DerelictLibui (flat API)](https://github.com/Extrawurst/DerelictLibui), [libuid (object-oriented)](https://github.com/mogud/libuid)
+Euphoria | [libui-euphoria](https://github.com/ghaberek/libui-euphoria)
+Harbour | [HBUI](https://github.com/RJopek/HBUI)
+Haskell | [libui-haskell](https://github.com/ajnsit/libui-haskell), [beijaflor-io/haskell-libui (complete FFI bindings, extensions and higher-level API)](https://github.com/beijaflor-io/haskell-libui)
+JavaScript | [libui.js (merged into libui-node?)](https://github.com/mavenave/libui.js)
+Julia | [Libui.jl](https://github.com/joa-quim/Libui.jl)
+Lua | [libuilua](https://github.com/zevv/libuilua), [libui-lua](https://github.com/mdombroski/libui-lua)
+Nim | [ui](https://github.com/nim-lang/ui)
+Node.js | [libui-node](https://github.com/parro-it/libui-node)
+PHP | [ui](https://github.com/krakjoe/ui)
+Python | [pylibui](https://github.com/joaoventura/pylibui)
+Ruby | [libui-ruby](https://github.com/jamescook/libui-ruby)
+Rust | [libui-rs](https://github.com/pcwalton/libui-rs)
+Swift | [libui-swift](https://github.com/sclukey/libui-swift)
+
+## Frequently Asked Questions
+
+### Why does my program start in the background on OS X if I run from the command line?
+OS X normally does not start program executables directly; instead, it uses [Launch Services](https://developer.apple.com/reference/coreservices/1658613-launch_services?language=objc) to coordinate the launching of the program between the various parts of the system and the loading of info from an .app bundle. One of these coordination tasks is responsible for bringing a newly launched app into the foreground. This is called "activation".
+
+When you run a binary directly from the Terminal, however, you are running it directly, not through Launch Services. Therefore, the program starts in the background, because no one told it to activate! Now, it turns out [there is an API](https://developer.apple.com/reference/appkit/nsapplication/1428468-activateignoringotherapps) that we can use to force our app to be activated. But if we use it, then we'd be trampling over Launch Services, which already knows whether it should activate or not. Therefore, libui does not step over Launch Services, at the cost of requiring an extra user step if running directly from the command line.
+
+See also [this](https://github.com/andlabs/libui/pull/20#issuecomment-211381971) and [this](http://stackoverflow.com/questions/25318524/what-exactly-should-i-pass-to-nsapp-activateignoringotherapps-to-get-my-appl).
+
+## Screenshots
+
+From examples/controlgallery:
+
+![Windows](examples/controlgallery/windows.png)
+
+![Unix](examples/controlgallery/unix.png)
+
+![OS X](examples/controlgallery/darwin.png)
diff --git a/src/libui_sdl/libui/TODO.md b/src/libui_sdl/libui/TODO.md
new file mode 100644
index 0000000..33ac95a
--- /dev/null
+++ b/src/libui_sdl/libui/TODO.md
@@ -0,0 +1,129 @@
+- make sure the last line of text layouts include leading
+
+- documentation notes:
+	- static binaries do not link system libraries, meaning apps still depend on shared GTK+, etc.
+	- ui*Buttons are NOT compatible with uiButton functions
+
+- more robust layout handling
+	- uiFormTie() for ensuring multiple uiForms have the same label area widths
+	- uiSizeGroup for size groups (GtkSizeGroup on GTK+, auto layout constraints on OS X; consider adding after 10.8 is gone)
+
+- windows: should the initial hwndInsertAfter be HWND_BOTTOM for what we want?
+
+- windows: document the rules for controls and containers
+
+- windows: document the minimum size change propagation system
+
+- provisions for controls that cannot be grown? especiailly for windows
+
+- LC_VERSION_MIN_MACOSX has the 10.11 SDK; see if we can knock it down to 10.8 too; OS version is fine
+	- apply the OS version stuff to the test program and examples too
+	- what about micro versions (10.8.x)? force 10.8.0?
+
+- go through ALL the objective-c objects we create and make sure we are using the proper ownership (alloc/init and new are owned by us, all class method constructors are autoreleased - thanks mikeash)
+
+- on OS X, edit shortcuts like command-C working require that the menu entries be defined, or so it seems, even for NSAlert
+	- other platforms?
+
+- make sure all OS X event handlers that use target-action set the action to NULL when the target is unset
+
+- provide a way to get the currently selected uiTab page? set?
+
+- make it so that the windows cntrols only register a resize if their new minimum size is larger than their current size to easen the effect of flicker
+	- it won't remove that outright, but it'll help
+
+- add an option to the test program to run page7b as an independent test in its own window
+	- same for page7c
+
+- http://blogs.msdn.com/b/oldnewthing/archive/2004/01/12/57833.aspx provide a DEF file on Windows
+
+- all ports: update state when adding a control to a parent
+- should uiWindowsSizing be computed against the window handle, not the parent?
+
+- DPI awareness on windows
+
+- http://stackoverflow.com/questions/4543087/applicationwillterminate-and-the-dock-but-wanting-to-cancel-this-action
+
+ultimately:
+- MAYBE readd lifetime handling/destruction blocking
+- related? [12:25] <ZeroOne> And the blue outline on those buttons [ALL clicked buttons on Windows 7] won't go away
+	- I get this too
+		- not anymore
+- SWP_NOCOPYBITS to avoid button redraw issues on Windows when not in tab, but only when making resize faster
+- secondary side alignment control in uiBox
+- Windows: don't abort if a cleanup function fails?
+
+- 32-bit Mac OS X support (requires lots of code changes)
+	- change the build system to be more receptive to arch changes
+
+notes to self
+- explicitly document label position at top-left corner
+- explicitly document that if number of radio buttons >= 1 there will always be a selection
+- mark that uiControlShow() on a uiWindow() will bring to front and give keyboard focus because of OS X
+	- make sure ShowWindow() is sufficient for zorder on Windows
+- document that you CAN use InsertAt functions to insert at the first invalid index, even if the array is empty
+- note that uiTabInsertAt() does NOT change the current tab page (it may change its index if inserting before the current page)
+- note that the default action for uiWindowOnClosing() is to return 0 (keep the window open)
+- note that uiInitOptions should be initialized to zero
+- explicitly document that uiCheckboxSetChecked() and uiEntrySetText() do not fire uiCheckboxOnToggled() and uiEntryOnChanged(), respectively
+- note that if a menu is requested on systems with menubars on windows but no menus are defined, the result is a blank menubar, with whatever that means left up to the OS to decide
+- note that handling of multiple consecutive separators in menus, leading separators in menus, and trailing separators in menus are all OS-defined
+- note that uiDrawMatrixInvert() does not change the matrix if it fails
+- note that the use of strings that are not strictly valid UTF-8 results in undefined behavior
+
+- test RTL
+	- automate RTL
+- now that stock items are deprecated, I have to maintain translations of the Cancel, Open, and Save buttons on GTK+ myself (thanks baedert in irc.gimp.net/#gtk+)
+	- either that or keep using stock items
+
+- http://blogs.msdn.com/b/oldnewthing/archive/2014/02/26/10503148.aspx
+
+- build optimizations
+
+- use http://www.appveyor.com/ to do Windows build CI since people want CI
+
+
+
+
+
+
+- consider just having the windows backend in C++
+	- consider having it all in C++
+
+
+
+don't forget LONGTERMs as well
+
+notes
+- http://blogs.msdn.com/b/oldnewthing/archive/2004/03/29/101121.aspx on accelerators
+
+- group and tab should act as if they have no child if the child is hidden
+on windows
+
+
+
+- a way to do recursive main loops
+	- how do we handle 0 returns from non-recursive uiMainStep() calls that aren't the main loop? (event handlers, for instance)
+- should repeated calls to uiMainStep() after uiQuit() return 0 reliably? this will be needed for non-recursive loops
+
+http://stackoverflow.com/questions/38338426/meaning-of-ampersand-in-rc-files/38338841?noredirect=1#comment64093084_38338841
+
+label shortcut keys
+
+- remove whining from source code
+
+[01:41:47]  <vrishab>	Hi. does pango support "fgalpha". I see that foreground="112233xx" works ( alpha=xx ), but fgalpha is a no-op
+[01:52:29]  <vrishab>	pango_attr_foreground_alpha_new (32767) seems to be called in either case, but only the "foreground" attr works
+[01:56:09] 	lolek (lolek@ip-91-244-230-76.simant.pl) joined the channel
+[01:57:48]  <vrishab>	ok. seems like "foreground" is mandatory attr, 1. "foreground-without-alpha" + "alpha" works 2. "foreground-with-alpha" works. 3. "alpha" alone doesn
+[01:57:52]  <vrishab>	't work
+[01:58:29]  <vrishab>	Is there a way to just specify alpha on the current foreground color ?
+[02:00:23] 	lolek (lolek@ip-91-244-230-76.simant.pl) left the channel
+[02:07:41] 	mjog (mjog@uniwide-pat-pool-129-94-8-98.gw.unsw.edu.au) left IRC (Quit: mjog)
+[02:08:10] 	seb128 (seb128@53542B83.cm-6-5a.dynamic.ziggo.nl) joined the channel
+[02:12:37]  <andlabs>	huh
+[02:12:41]  <andlabs>	what version of pango?
+[02:13:05]  <vrishab>	the latest .
+[02:15:00]  <vrishab>	1.40.3
+[02:20:46]  <andlabs>	I'll ahve to keep this in mind then, thanks
+[02:20:59]  <andlabs>	if only there was a cairo-specific attribute for alpha...
diff --git a/src/libui_sdl/libui/_abort/windowevents/darwin_window.m b/src/libui_sdl/libui/_abort/windowevents/darwin_window.m
new file mode 100644
index 0000000..76180d8
--- /dev/null
+++ b/src/libui_sdl/libui/_abort/windowevents/darwin_window.m
@@ -0,0 +1,90 @@
+struct uiWindow {
+	// constraints
+	void (*onPositionChanged)(uiWindow *, void *);
+	void *onPositionChangedData;
+	BOOL suppressPositionChanged;
+	// onContentSizeChanged
+};
+
+@interface windowDelegateClass : NSObject<NSWindowDelegate> {
+// windowShouldClose:
+- (void)windowDidMove:(NSNotification *)note;
+// windowDidResize:
+@end
+
+@implementation windowDelegateClass
+
+// - (BOOL)windowShouldClose:(id)sender
+
+// TODO doesn't happen live
+- (void)windowDidMove:(NSNotification *)note
+{
+	uiWindow *w;
+
+	w = [self lookupWindow:((NSWindow *) [note object])];
+	if (!w->suppressPositionChanged)
+		(*(w->onPositionChanged))(w, w->onPositionChangedData);
+}
+
+// - (void)windowDidResize:(NSNotification *)note
+
+// void uiWindowSetTitle(uiWindow *w, const char *title)
+
+void uiWindowPosition(uiWindow *w, int *x, int *y)
+{
+	NSScreen *screen;
+	NSRect r;
+
+	r = [w->window frame];
+	*x = r.origin.x;
+	// this is the right screen to use; thanks mikeash in irc.freenode.net/#macdev
+	// -mainScreen is useless for positioning (it's just the key window's screen)
+	// and we use -frame, not -visibleFrame, for dealing with absolute positions
+	screen = (NSScreen *) [[NSScreen screens] objectAtIndex:0];
+	*y = ([screen frame].size.height - r.origin.y) - r.size.height;
+}
+
+void uiWindowSetPosition(uiWindow *w, int x, int y)
+{
+	// -[NSWindow setFrameTopLeftPoint:] is acting weird so...
+	NSRect r;
+	NSScreen *screen;
+
+	// this fires windowDidMove:
+	w->suppressPositionChanged = YES;
+	r = [w->window frame];
+	r.origin.x = x;
+	screen = (NSScreen *) [[NSScreen screens] objectAtIndex:0];
+	r.origin.y = [screen frame].size.height - (y + r.size.height);
+	[w->window setFrameOrigin:r.origin];
+	w->suppressPositionChanged = NO;
+}
+
+void uiWindowCenter(uiWindow *w)
+{
+	w->suppressPositionChanged = YES;
+	[w->window center];
+	w->suppressPositionChanged = NO;
+}
+
+void uiWindowOnPositionChanged(uiWindow *w, void (*f)(uiWindow *, void *), void *data)
+{
+	w->onPositionChanged = f;
+	w->onPositionChangedData = data;
+}
+
+// void uiWindowContentSize(uiWindow *w, int *width, int *height)
+
+// static int defaultOnClosing(uiWindow *w, void *data)
+
+static void defaultOnPositionContentSizeChanged(uiWindow *w, void *data)
+{
+	// do nothing
+}
+
+uiWindow *uiNewWindow(const char *title, int width, int height, int hasMenubar)
+{
+//	uiWindowOnClosing(w, defaultOnClosing, NULL);
+	uiWindowOnPositionChanged(w, defaultOnPositionContentSizeChanged, NULL);
+//	uiWindowOnContentSizeChanged(w, defaultOnPositionContentSizeChanged, NULL);
+}
diff --git a/src/libui_sdl/libui/_abort/windowevents/page15.c b/src/libui_sdl/libui/_abort/windowevents/page15.c
new file mode 100644
index 0000000..0cceba8
--- /dev/null
+++ b/src/libui_sdl/libui/_abort/windowevents/page15.c
@@ -0,0 +1,65 @@
+static uiSpinbox *x, *y;
+
+static void moveX(uiSpinbox *s, void *data)
+{
+	uiWindow *w = uiWindow(data);
+	int xp, yp;
+
+	uiWindowPosition(w, &xp, &yp);
+	xp = uiSpinboxValue(x);
+	uiWindowSetPosition(w, xp, yp);
+}
+
+static void moveY(uiSpinbox *s, void *data)
+{
+	uiWindow *w = uiWindow(data);
+	int xp, yp;
+
+	uiWindowPosition(w, &xp, &yp);
+	yp = uiSpinboxValue(y);
+	uiWindowSetPosition(w, xp, yp);
+}
+
+static void updatepos(uiWindow *w)
+{
+	int xp, yp;
+
+	uiWindowPosition(w, &xp, &yp);
+	uiSpinboxSetValue(x, xp);
+	uiSpinboxSetValue(y, yp);
+}
+
+static void center(uiButton *b, void *data)
+{
+	uiWindow *w = uiWindow(data);
+
+	uiWindowCenter(w);
+	updatepos(w);
+}
+
+void onMove(uiWindow *w, void *data)
+{
+	printf("move\n");
+	updatepos(w);
+}
+
+uiBox *makePage15(uiWindow *w)
+{
+	hbox = newHorizontalBox();
+	// TODO if I make this 1 and not add anything else AND not call uiWindowOnPositionChanged(), on OS X the box won't be able to grow vertically
+	uiBoxAppend(page15, uiControl(hbox), 0);
+
+	uiBoxAppend(hbox, uiControl(uiNewLabel("Position")), 0);
+	x = uiNewSpinbox(INT_MIN, INT_MAX);
+	uiBoxAppend(hbox, uiControl(x), 1);
+	y = uiNewSpinbox(INT_MIN, INT_MAX);
+	uiBoxAppend(hbox, uiControl(y), 1);
+	button = uiNewButton("Center");
+	uiBoxAppend(hbox, uiControl(button), 0);
+
+	uiSpinboxOnChanged(x, moveX, w);
+	uiSpinboxOnChanged(y, moveY, w);
+	uiButtonOnClicked(button, center, w);
+	uiWindowOnPositionChanged(w, onMove, NULL);
+	updatepos(w);
+}
diff --git a/src/libui_sdl/libui/_abort/windowevents/ui.h b/src/libui_sdl/libui/_abort/windowevents/ui.h
new file mode 100644
index 0000000..e0d24c7
--- /dev/null
+++ b/src/libui_sdl/libui/_abort/windowevents/ui.h
@@ -0,0 +1,6 @@
+// uiWindowSetTitle
+_UI_EXTERN void uiWindowPosition(uiWindow *w, int *x, int *y);
+_UI_EXTERN void uiWindowSetPosition(uiWindow *w, int x, int y);
+_UI_EXTERN void uiWindowCenter(uiWindow *w);
+_UI_EXTERN void uiWindowOnPositionChanged(uiWindow *w, void (*f)(uiWindow *, void *), void *data);
+// uiWindowContentSize
diff --git a/src/libui_sdl/libui/_abort/windowevents/unix_window.c b/src/libui_sdl/libui/_abort/windowevents/unix_window.c
new file mode 100644
index 0000000..96af26a
--- /dev/null
+++ b/src/libui_sdl/libui/_abort/windowevents/unix_window.c
@@ -0,0 +1,97 @@
+struct uiWindow {
+//	void *onClosingData;
+	void (*onPositionChanged)(uiWindow *, void *);
+	void *onPositionChangedData;
+	gboolean changingPosition;
+//	void (*onContentSizeChanged)(uiWindow *, void *);
+};
+
+// static gboolean onClosing(GtkWidget *win, GdkEvent *e, gpointer data)
+
+static gboolean onConfigure(GtkWidget *win, GdkEvent *e, gpointer data)
+{
+	uiWindow *w = uiWindow(data);
+
+	// there doesn't seem to be a way to determine if only moving or only resizing is happening :/
+	if (w->changingPosition)
+		w->changingPosition = FALSE;
+	else
+		(*(w->onPositionChanged))(w, w->onPositionChangedData);
+	// always continue handling
+	return FALSE;
+}
+
+// static void onSizeAllocate(GtkWidget *widget, GdkRectangle *allocation, gpointer data)
+
+// static int defaultOnClosing(uiWindow *w, void *data)
+
+static void defaultOnPositionContentSizeChanged(uiWindow *w, void *data)
+{
+	// do nothing
+}
+
+// static void uiWindowDestroy(uiControl *c)
+
+// void uiWindowSetTitle(uiWindow *w, const char *title)
+
+// TODO allow specifying either as NULL on all platforms
+void uiWindowPosition(uiWindow *w, int *x, int *y)
+{
+	gint rx, ry;
+
+	gtk_window_get_position(w->window, &rx, &ry);
+	*x = rx;
+	*y = ry;
+}
+
+void uiWindowSetPosition(uiWindow *w, int x, int y)
+{
+	w->changingPosition = TRUE;
+	gtk_window_move(w->window, x, y);
+	// gtk_window_move() is asynchronous
+	// we need to wait for a configure-event
+	// thanks to hergertme in irc.gimp.net/#gtk+
+	while (w->changingPosition)
+		if (!uiMainStep(1))
+			break;		// stop early if uiQuit() called
+}
+
+void uiWindowCenter(uiWindow *w)
+{
+	gint x, y;
+	GtkAllocation winalloc;
+	GdkWindow *gdkwin;
+	GdkScreen *screen;
+	GdkRectangle workarea;
+
+	gtk_widget_get_allocation(w->widget, &winalloc);
+	gdkwin = gtk_widget_get_window(w->widget);
+	screen = gdk_window_get_screen(gdkwin);
+	gdk_screen_get_monitor_workarea(screen,
+		gdk_screen_get_monitor_at_window(screen, gdkwin),
+		&workarea);
+
+	x = (workarea.width - winalloc.width) / 2;
+	y = (workarea.height - winalloc.height) / 2;
+	// TODO move up slightly? see what Mutter or GNOME Shell or GNOME Terminal do(es)?
+	uiWindowSetPosition(w, x, y);
+}
+
+// TODO this and size changed get set during uiWindowDestroy
+void uiWindowOnPositionChanged(uiWindow *w, void (*f)(uiWindow *, void *), void *data)
+{
+	w->onPositionChanged = f;
+	w->onPositionChangedData = data;
+}
+
+// void uiWindowContentSize(uiWindow *w, int *width, int *height)
+
+uiWindow *uiNewWindow(const char *title, int width, int height, int hasMenubar)
+{
+//	g_signal_connect(w->widget, "delete-event", G_CALLBACK(onClosing), w);
+	g_signal_connect(w->widget, "configure-event", G_CALLBACK(onConfigure), w);
+//	g_signal_connect(w->childHolderWidget, "size-allocate", G_CALLBACK(onSizeAllocate), w);
+//	uiWindowOnClosing(w, defaultOnClosing, NULL);
+	uiWindowOnPositionChanged(w, defaultOnPositionContentSizeChanged, NULL);
+//	uiWindowOnContentSizeChanged(w, defaultOnPositionContentSizeChanged, NULL);
+}
diff --git a/src/libui_sdl/libui/_abort/windowevents/windows_window.cpp b/src/libui_sdl/libui/_abort/windowevents/windows_window.cpp
new file mode 100644
index 0000000..769c6db
--- /dev/null
+++ b/src/libui_sdl/libui/_abort/windowevents/windows_window.cpp
@@ -0,0 +1,86 @@
+struct uiWindow {
+//	BOOL hasMenubar;
+	void (*onPositionChanged)(uiWindow *, void *);
+	void *onPositionChangedData;
+	BOOL changingPosition;		// to avoid triggering the above when programmatically doing this
+//	void (*onContentSizeChanged)(uiWindow *, void *);
+};
+
+static LRESULT CALLBACK windowWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+	case WM_WINDOWPOSCHANGED:
+		if ((wp->flags & SWP_NOMOVE) == 0)
+			if (!w->changingPosition)
+				(*(w->onPositionChanged))(w, w->onPositionChangedData);
+			// and continue anyway
+//		if ((wp->flags & SWP_NOSIZE) != 0)
+}
+
+// static int defaultOnClosing(uiWindow *w, void *data)
+
+static void defaultOnPositionContentSizeChanged(uiWindow *w, void *data)
+{
+	// do nothing
+}
+
+// static std::map<uiWindow *, bool> windows;
+
+// void uiWindowSetTitle(uiWindow *w, const char *title)
+
+void uiWindowPosition(uiWindow *w, int *x, int *y)
+{
+	RECT r;
+
+	uiWindowsEnsureGetWindowRect(w->hwnd, &r);
+	*x = r.left;
+	*y = r.top;
+}
+
+void uiWindowSetPosition(uiWindow *w, int x, int y)
+{
+	w->changingPosition = TRUE;
+	if (SetWindowPos(w->hwnd, NULL, x, y, 0, 0, SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOSIZE | SWP_NOZORDER) == 0)
+		logLastError(L"error moving window");
+	w->changingPosition = FALSE;
+}
+
+// static void windowMonitorRect(HWND hwnd, RECT *r)
+
+// TODO use the work rect instead?
+void uiWindowCenter(uiWindow *w)
+{
+	RECT wr, mr;
+	int x, y;
+	LONG wwid, mwid;
+	LONG wht, mht;
+
+	uiWindowsEnsureGetWindowRect(w->hwnd, &wr);
+	windowMonitorRect(w->hwnd, &mr);
+	wwid = wr.right - wr.left;
+	mwid = mr.right - mr.left;
+	x = (mwid - wwid) / 2;
+	wht = wr.bottom - wr.top;
+	mht = mr.bottom - mr.top;
+	y = (mht - wht) / 2;
+	// y is now evenly divided, however https://msdn.microsoft.com/en-us/library/windows/desktop/dn742502(v=vs.85).aspx says that 45% should go above and 55% should go below
+	// so just move 5% of the way up
+	// TODO should this be on the work area?
+	// TODO is this calculation correct?
+	y -= y / 20;
+	uiWindowSetPosition(w, x, y);
+}
+
+void uiWindowOnPositionChanged(uiWindow *w, void (*f)(uiWindow *, void *), void *data)
+{
+	w->onPositionChanged = f;
+	w->onPositionChangedData = data;
+}
+
+// void uiWindowContentSize(uiWindow *w, int *width, int *height)
+
+uiWindow *uiNewWindow(const char *title, int width, int height, int hasMenubar)
+{
+//	uiWindowOnClosing(w, defaultOnClosing, NULL);
+	uiWindowOnPositionChanged(w, defaultOnPositionContentSizeChanged, NULL);
+//	uiWindowOnContentSizeChanged(w, defaultOnPositionContentSizeChanged, NULL);
+}
diff --git a/src/libui_sdl/libui/_wip/rules.darwin b/src/libui_sdl/libui/_wip/rules.darwin
new file mode 100644
index 0000000..e736a14
--- /dev/null
+++ b/src/libui_sdl/libui/_wip/rules.darwin
@@ -0,0 +1,6 @@
+every rule in ui_darwin.h
+SetParent must be followed by SetSuperview and SyncEnableState
+	TODO can child cache it?
+adding a child must be followed by a call to SyncEnableState
+SyncEnableState() must call ShouldStopSyncEnableState() first thing
+Enable() and Disable() must call SyncEnableState() AFTER CHANGING WHAT Enabled() WILL RETURN
diff --git a/src/libui_sdl/libui/_wip/rules.unix b/src/libui_sdl/libui/_wip/rules.unix
new file mode 100644
index 0000000..24765a9
--- /dev/null
+++ b/src/libui_sdl/libui/_wip/rules.unix
@@ -0,0 +1,3 @@
+every rule in ui_unix.h
+SetParent must be followed by SetContainer
+	TODO can child cache it?
diff --git a/src/libui_sdl/libui/_wip/sv/normal b/src/libui_sdl/libui/_wip/sv/normal
new file mode 100644
index 0000000..8b6af87
--- /dev/null
+++ b/src/libui_sdl/libui/_wip/sv/normal
@@ -0,0 +1,25 @@
+2016-05-26 22:38:12.877 svtest[81790:544681]       backgroundColor       NSNamedColorSpace System controlColor
+2016-05-26 22:38:12.877 svtest[81790:544681]       drawsBackground       1
+2016-05-26 22:38:12.877 svtest[81790:544681]       borderType            2
+2016-05-26 22:38:12.877 svtest[81790:544681]       documentCursor        (null)
+2016-05-26 22:38:12.877 svtest[81790:544681]       hasHorizontalScroller 1
+2016-05-26 22:38:12.877 svtest[81790:544681]       hasVerticalScroller   1
+2016-05-26 22:38:12.877 svtest[81790:544681]       autohidesScrollers    0
+2016-05-26 22:38:12.877 svtest[81790:544681]       hasHorizontalRuler    0
+2016-05-26 22:38:12.878 svtest[81790:544681]       hasVerticalRuler      0
+2016-05-26 22:38:12.878 svtest[81790:544681]       rulersVisible         0
+2016-05-26 22:38:12.878 svtest[81790:544681] 10.10 autoAdjContentInsets  1
+2016-05-26 22:38:12.878 svtest[81790:544681]       scrollerKnobStyle     0
+2016-05-26 22:38:12.878 svtest[81790:544681]       scrollerStyle         1
+2016-05-26 22:38:12.878 svtest[81790:544681]       horizontalLineScroll  10
+2016-05-26 22:38:12.878 svtest[81790:544681]       verticalLineScroll    10
+2016-05-26 22:38:12.886 svtest[81790:544681]       horizontalPageScroll  10
+2016-05-26 22:38:12.886 svtest[81790:544681]       verticalPageScroll    10
+2016-05-26 22:38:12.886 svtest[81790:544681]       scrollsDynamically    1
+2016-05-26 22:38:12.886 svtest[81790:544681]       findBarPosition       1
+2016-05-26 22:38:12.886 svtest[81790:544681]       usesPredomAxisScroll  0
+2016-05-26 22:38:12.886 svtest[81790:544681]       horizontalElasticity  0
+2016-05-26 22:38:12.886 svtest[81790:544681]       verticalElasticity    0
+2016-05-26 22:38:12.887 svtest[81790:544681] 10.8  allowsMagnification   0
+2016-05-26 22:38:12.887 svtest[81790:544681] 10.8  maxMagnification      4
+2016-05-26 22:38:12.887 svtest[81790:544681] 10.8  minMagnification      0.25
diff --git a/src/libui_sdl/libui/_wip/sv/normal.nots b/src/libui_sdl/libui/_wip/sv/normal.nots
new file mode 100644
index 0000000..411d1d6
--- /dev/null
+++ b/src/libui_sdl/libui/_wip/sv/normal.nots
@@ -0,0 +1,25 @@
+         backgroundColor       NSNamedColorSpace System controlColor
+         drawsBackground       1
+         borderType            2
+         documentCursor        (null)
+         hasHorizontalScroller 1
+         hasVerticalScroller   1
+         autohidesScrollers    0
+         hasHorizontalRuler    0
+         hasVerticalRuler      0
+         rulersVisible         0
+   10.10 autoAdjContentInsets  1
+         scrollerKnobStyle     0
+         scrollerStyle         1
+         horizontalLineScroll  10
+         verticalLineScroll    10
+         horizontalPageScroll  10
+         verticalPageScroll    10
+         scrollsDynamically    1
+         findBarPosition       1
+         usesPredomAxisScroll  0
+         horizontalElasticity  0
+         verticalElasticity    0
+   10.8  allowsMagnification   0
+   10.8  maxMagnification      4
+   10.8  minMagnification      0.25
diff --git a/src/libui_sdl/libui/_wip/sv/outlineview b/src/libui_sdl/libui/_wip/sv/outlineview
new file mode 100644
index 0000000..67a3087
--- /dev/null
+++ b/src/libui_sdl/libui/_wip/sv/outlineview
@@ -0,0 +1,25 @@
+2016-05-26 22:42:16.208 svtest[82103:547159]       backgroundColor       NSNamedColorSpace System controlBackgroundColor
+2016-05-26 22:42:16.208 svtest[82103:547159]       drawsBackground       1
+2016-05-26 22:42:16.208 svtest[82103:547159]       borderType            2
+2016-05-26 22:42:16.208 svtest[82103:547159]       documentCursor        (null)
+2016-05-26 22:42:16.209 svtest[82103:547159]       hasHorizontalScroller 1
+2016-05-26 22:42:16.209 svtest[82103:547159]       hasVerticalScroller   1
+2016-05-26 22:42:16.209 svtest[82103:547159]       autohidesScrollers    1
+2016-05-26 22:42:16.209 svtest[82103:547159]       hasHorizontalRuler    0
+2016-05-26 22:42:16.209 svtest[82103:547159]       hasVerticalRuler      0
+2016-05-26 22:42:16.209 svtest[82103:547159]       rulersVisible         0
+2016-05-26 22:42:16.209 svtest[82103:547159] 10.10 autoAdjContentInsets  1
+2016-05-26 22:42:16.209 svtest[82103:547159]       scrollerKnobStyle     0
+2016-05-26 22:42:16.209 svtest[82103:547159]       scrollerStyle         1
+2016-05-26 22:42:16.209 svtest[82103:547159]       horizontalLineScroll  19
+2016-05-26 22:42:16.209 svtest[82103:547159]       verticalLineScroll    19
+2016-05-26 22:42:16.217 svtest[82103:547159]       horizontalPageScroll  10
+2016-05-26 22:42:16.218 svtest[82103:547159]       verticalPageScroll    10
+2016-05-26 22:42:16.218 svtest[82103:547159]       scrollsDynamically    1
+2016-05-26 22:42:16.218 svtest[82103:547159]       findBarPosition       1
+2016-05-26 22:42:16.218 svtest[82103:547159]       usesPredomAxisScroll  0
+2016-05-26 22:42:16.218 svtest[82103:547159]       horizontalElasticity  0
+2016-05-26 22:42:16.218 svtest[82103:547159]       verticalElasticity    0
+2016-05-26 22:42:16.218 svtest[82103:547159] 10.8  allowsMagnification   0
+2016-05-26 22:42:16.218 svtest[82103:547159] 10.8  maxMagnification      4
+2016-05-26 22:42:16.218 svtest[82103:547159] 10.8  minMagnification      0.25
diff --git a/src/libui_sdl/libui/_wip/sv/outlineview.nots b/src/libui_sdl/libui/_wip/sv/outlineview.nots
new file mode 100644
index 0000000..fcf1849
--- /dev/null
+++ b/src/libui_sdl/libui/_wip/sv/outlineview.nots
@@ -0,0 +1,25 @@
+         backgroundColor       NSNamedColorSpace System controlBackgroundColor
+         drawsBackground       1
+         borderType            2
+         documentCursor        (null)
+         hasHorizontalScroller 1
+         hasVerticalScroller   1
+         autohidesScrollers    1
+         hasHorizontalRuler    0
+         hasVerticalRuler      0
+         rulersVisible         0
+   10.10 autoAdjContentInsets  1
+         scrollerKnobStyle     0
+         scrollerStyle         1
+         horizontalLineScroll  19
+         verticalLineScroll    19
+         horizontalPageScroll  10
+         verticalPageScroll    10
+         scrollsDynamically    1
+         findBarPosition       1
+         usesPredomAxisScroll  0
+         horizontalElasticity  0
+         verticalElasticity    0
+   10.8  allowsMagnification   0
+   10.8  maxMagnification      4
+   10.8  minMagnification      0.25
diff --git a/src/libui_sdl/libui/_wip/sv/sourcelist b/src/libui_sdl/libui/_wip/sv/sourcelist
new file mode 100644
index 0000000..010d652
--- /dev/null
+++ b/src/libui_sdl/libui/_wip/sv/sourcelist
@@ -0,0 +1,25 @@
+2016-05-26 22:43:58.600 svtest[82237:548359]       backgroundColor       (null)
+2016-05-26 22:43:58.600 svtest[82237:548359]       drawsBackground       0
+2016-05-26 22:43:58.600 svtest[82237:548359]       borderType            2
+2016-05-26 22:43:58.600 svtest[82237:548359]       documentCursor        (null)
+2016-05-26 22:43:58.600 svtest[82237:548359]       hasHorizontalScroller 1
+2016-05-26 22:43:58.600 svtest[82237:548359]       hasVerticalScroller   1
+2016-05-26 22:43:58.600 svtest[82237:548359]       autohidesScrollers    1
+2016-05-26 22:43:58.600 svtest[82237:548359]       hasHorizontalRuler    0
+2016-05-26 22:43:58.600 svtest[82237:548359]       hasVerticalRuler      0
+2016-05-26 22:43:58.600 svtest[82237:548359]       rulersVisible         0
+2016-05-26 22:43:58.601 svtest[82237:548359] 10.10 autoAdjContentInsets  1
+2016-05-26 22:43:58.601 svtest[82237:548359]       scrollerKnobStyle     0
+2016-05-26 22:43:58.601 svtest[82237:548359]       scrollerStyle         1
+2016-05-26 22:43:58.601 svtest[82237:548359]       horizontalLineScroll  19
+2016-05-26 22:43:58.601 svtest[82237:548359]       verticalLineScroll    19
+2016-05-26 22:43:58.645 svtest[82237:548359]       horizontalPageScroll  10
+2016-05-26 22:43:58.645 svtest[82237:548359]       verticalPageScroll    10
+2016-05-26 22:43:58.645 svtest[82237:548359]       scrollsDynamically    1
+2016-05-26 22:43:58.645 svtest[82237:548359]       findBarPosition       1
+2016-05-26 22:43:58.645 svtest[82237:548359]       usesPredomAxisScroll  0
+2016-05-26 22:43:58.645 svtest[82237:548359]       horizontalElasticity  0
+2016-05-26 22:43:58.646 svtest[82237:548359]       verticalElasticity    0
+2016-05-26 22:43:58.646 svtest[82237:548359] 10.8  allowsMagnification   0
+2016-05-26 22:43:58.646 svtest[82237:548359] 10.8  maxMagnification      4
+2016-05-26 22:43:58.646 svtest[82237:548359] 10.8  minMagnification      0.25
diff --git a/src/libui_sdl/libui/_wip/sv/sourcelist.nots b/src/libui_sdl/libui/_wip/sv/sourcelist.nots
new file mode 100644
index 0000000..742f41e
--- /dev/null
+++ b/src/libui_sdl/libui/_wip/sv/sourcelist.nots
@@ -0,0 +1,25 @@
+         backgroundColor       (null)
+         drawsBackground       0
+         borderType            2
+         documentCursor        (null)
+         hasHorizontalScroller 1
+         hasVerticalScroller   1
+         autohidesScrollers    1
+         hasHorizontalRuler    0
+         hasVerticalRuler      0
+         rulersVisible         0
+   10.10 autoAdjContentInsets  1
+         scrollerKnobStyle     0
+         scrollerStyle         1
+         horizontalLineScroll  19
+         verticalLineScroll    19
+         horizontalPageScroll  10
+         verticalPageScroll    10
+         scrollsDynamically    1
+         findBarPosition       1
+         usesPredomAxisScroll  0
+         horizontalElasticity  0
+         verticalElasticity    0
+   10.8  allowsMagnification   0
+   10.8  maxMagnification      4
+   10.8  minMagnification      0.25
diff --git a/src/libui_sdl/libui/_wip/sv/tableview b/src/libui_sdl/libui/_wip/sv/tableview
new file mode 100644
index 0000000..558b6e1
--- /dev/null
+++ b/src/libui_sdl/libui/_wip/sv/tableview
@@ -0,0 +1,25 @@
+2016-05-26 22:41:26.514 svtest[82032:546554]       backgroundColor       NSNamedColorSpace System controlBackgroundColor
+2016-05-26 22:41:26.514 svtest[82032:546554]       drawsBackground       1
+2016-05-26 22:41:26.514 svtest[82032:546554]       borderType            2
+2016-05-26 22:41:26.514 svtest[82032:546554]       documentCursor        (null)
+2016-05-26 22:41:26.515 svtest[82032:546554]       hasHorizontalScroller 1
+2016-05-26 22:41:26.515 svtest[82032:546554]       hasVerticalScroller   1
+2016-05-26 22:41:26.515 svtest[82032:546554]       autohidesScrollers    1
+2016-05-26 22:41:26.515 svtest[82032:546554]       hasHorizontalRuler    0
+2016-05-26 22:41:26.516 svtest[82032:546554]       hasVerticalRuler      0
+2016-05-26 22:41:26.516 svtest[82032:546554]       rulersVisible         0
+2016-05-26 22:41:26.516 svtest[82032:546554] 10.10 autoAdjContentInsets  1
+2016-05-26 22:41:26.516 svtest[82032:546554]       scrollerKnobStyle     0
+2016-05-26 22:41:26.516 svtest[82032:546554]       scrollerStyle         1
+2016-05-26 22:41:26.516 svtest[82032:546554]       horizontalLineScroll  19
+2016-05-26 22:41:26.516 svtest[82032:546554]       verticalLineScroll    19
+2016-05-26 22:41:26.528 svtest[82032:546554]       horizontalPageScroll  10
+2016-05-26 22:41:26.528 svtest[82032:546554]       verticalPageScroll    10
+2016-05-26 22:41:26.528 svtest[82032:546554]       scrollsDynamically    1
+2016-05-26 22:41:26.528 svtest[82032:546554]       findBarPosition       1
+2016-05-26 22:41:26.528 svtest[82032:546554]       usesPredomAxisScroll  0
+2016-05-26 22:41:26.528 svtest[82032:546554]       horizontalElasticity  0
+2016-05-26 22:41:26.528 svtest[82032:546554]       verticalElasticity    0
+2016-05-26 22:41:26.528 svtest[82032:546554] 10.8  allowsMagnification   0
+2016-05-26 22:41:26.528 svtest[82032:546554] 10.8  maxMagnification      4
+2016-05-26 22:41:26.528 svtest[82032:546554] 10.8  minMagnification      0.25
diff --git a/src/libui_sdl/libui/_wip/sv/tableview.nots b/src/libui_sdl/libui/_wip/sv/tableview.nots
new file mode 100644
index 0000000..fcf1849
--- /dev/null
+++ b/src/libui_sdl/libui/_wip/sv/tableview.nots
@@ -0,0 +1,25 @@
+         backgroundColor       NSNamedColorSpace System controlBackgroundColor
+         drawsBackground       1
+         borderType            2
+         documentCursor        (null)
+         hasHorizontalScroller 1
+         hasVerticalScroller   1
+         autohidesScrollers    1
+         hasHorizontalRuler    0
+         hasVerticalRuler      0
+         rulersVisible         0
+   10.10 autoAdjContentInsets  1
+         scrollerKnobStyle     0
+         scrollerStyle         1
+         horizontalLineScroll  19
+         verticalLineScroll    19
+         horizontalPageScroll  10
+         verticalPageScroll    10
+         scrollsDynamically    1
+         findBarPosition       1
+         usesPredomAxisScroll  0
+         horizontalElasticity  0
+         verticalElasticity    0
+   10.8  allowsMagnification   0
+   10.8  maxMagnification      4
+   10.8  minMagnification      0.25
diff --git a/src/libui_sdl/libui/_wip/sv/textview b/src/libui_sdl/libui/_wip/sv/textview
new file mode 100644
index 0000000..e636362
--- /dev/null
+++ b/src/libui_sdl/libui/_wip/sv/textview
@@ -0,0 +1,25 @@
+2016-05-26 22:40:02.050 svtest[81927:545793]       backgroundColor       NSCalibratedWhiteColorSpace 1 1
+2016-05-26 22:40:02.050 svtest[81927:545793]       drawsBackground       1
+2016-05-26 22:40:02.051 svtest[81927:545793]       borderType            2
+2016-05-26 22:40:02.052 svtest[81927:545793]       documentCursor        <NSCursor: 0x608000041f20>
+2016-05-26 22:40:02.052 svtest[81927:545793]       hasHorizontalScroller 0
+2016-05-26 22:40:02.052 svtest[81927:545793]       hasVerticalScroller   1
+2016-05-26 22:40:02.052 svtest[81927:545793]       autohidesScrollers    0
+2016-05-26 22:40:02.052 svtest[81927:545793]       hasHorizontalRuler    0
+2016-05-26 22:40:02.052 svtest[81927:545793]       hasVerticalRuler      0
+2016-05-26 22:40:02.052 svtest[81927:545793]       rulersVisible         0
+2016-05-26 22:40:02.052 svtest[81927:545793] 10.10 autoAdjContentInsets  1
+2016-05-26 22:40:02.052 svtest[81927:545793]       scrollerKnobStyle     0
+2016-05-26 22:40:02.052 svtest[81927:545793]       scrollerStyle         1
+2016-05-26 22:40:02.054 svtest[81927:545793]       horizontalLineScroll  10
+2016-05-26 22:40:02.055 svtest[81927:545793]       verticalLineScroll    10
+2016-05-26 22:40:02.062 svtest[81927:545793]       horizontalPageScroll  10
+2016-05-26 22:40:02.062 svtest[81927:545793]       verticalPageScroll    10
+2016-05-26 22:40:02.062 svtest[81927:545793]       scrollsDynamically    1
+2016-05-26 22:40:02.062 svtest[81927:545793]       findBarPosition       1
+2016-05-26 22:40:02.062 svtest[81927:545793]       usesPredomAxisScroll  0
+2016-05-26 22:40:02.062 svtest[81927:545793]       horizontalElasticity  0
+2016-05-26 22:40:02.062 svtest[81927:545793]       verticalElasticity    0
+2016-05-26 22:40:02.062 svtest[81927:545793] 10.8  allowsMagnification   0
+2016-05-26 22:40:02.062 svtest[81927:545793] 10.8  maxMagnification      4
+2016-05-26 22:40:02.063 svtest[81927:545793] 10.8  minMagnification      0.25
diff --git a/src/libui_sdl/libui/_wip/sv/textview.nots b/src/libui_sdl/libui/_wip/sv/textview.nots
new file mode 100644
index 0000000..7476b0e
--- /dev/null
+++ b/src/libui_sdl/libui/_wip/sv/textview.nots
@@ -0,0 +1,25 @@
+         backgroundColor       NSCalibratedWhiteColorSpace 1 1
+         drawsBackground       1
+         borderType            2
+         documentCursor        <NSCursor: 0x608000041f20>
+         hasHorizontalScroller 0
+         hasVerticalScroller   1
+         autohidesScrollers    0
+         hasHorizontalRuler    0
+         hasVerticalRuler      0
+         rulersVisible         0
+   10.10 autoAdjContentInsets  1
+         scrollerKnobStyle     0
+         scrollerStyle         1
+         horizontalLineScroll  10
+         verticalLineScroll    10
+         horizontalPageScroll  10
+         verticalPageScroll    10
+         scrollsDynamically    1
+         findBarPosition       1
+         usesPredomAxisScroll  0
+         horizontalElasticity  0
+         verticalElasticity    0
+   10.8  allowsMagnification   0
+   10.8  maxMagnification      4
+   10.8  minMagnification      0.25
diff --git a/src/libui_sdl/libui/_wip/table/test_page9.c b/src/libui_sdl/libui/_wip/table/test_page9.c
new file mode 100644
index 0000000..f2351f2
--- /dev/null
+++ b/src/libui_sdl/libui/_wip/table/test_page9.c
@@ -0,0 +1,80 @@
+// 18 october 2015
+#include "test.h"
+
+// TODO manage the memory of the uiTableModel
+
+static intmax_t nColumns = 4;
+static uiTableColumnType coltypes[] = {
+	uiTableColumnText,
+	uiTableColumnText,
+	uiTableColumnCheckbox,
+	uiTableColumnCheckbox,
+};
+
+static intmax_t nRows = 6;
+
+static intmax_t modelNumRows(uiTableModel *m, void *mData)
+{
+	return nRows;
+}
+
+void *modelCellValue(uiTableModel *m, void *mData, intmax_t row, intmax_t column)
+{
+	char line[20];
+
+	line[0] = 'R';
+	line[1] = 'o';
+	line[2] = 'w';
+	line[3] = ' ';
+	line[4] = row + '0';
+	line[5] = '\0';
+	switch (column) {
+	case 0:
+	case 1:
+		return uiTableModelFromString(line);
+	case 2:
+		return uiTableModelFromBool(row % 2 == 0);
+	case 3:
+		return uiTableModelFromBool(row % 3 == 0);
+	}
+	// TODO
+	return NULL;
+}
+
+// TODO make this not need to be static
+uiTableModelSpec spec;
+
+void modelSetCellValue(uiTableModel *m, void *mData, intmax_t row, intmax_t column, void *value)
+{
+	// TODO
+}
+
+uiBox *makePage9(void)
+{
+	uiBox *page9;
+	uiTable *table;
+	uiTableModel *model;
+	uiTableColumnParams p;
+	intmax_t i;
+
+	page9 = newVerticalBox();
+
+	table = uiNewTable();
+	uiBoxAppend(page9, uiControl(table), 1);
+
+	spec.NumRows = modelNumRows;
+	spec.CellValue = modelCellValue;
+	spec.SetCellValue = modelSetCellValue;
+	model = uiNewTableModel(nColumns, coltypes, &spec, NULL);
+	uiTableSetModel(table, model);
+
+	for (i = 0; i < nColumns; i++) {
+		p.Name = "Column";
+		p.Type = coltypes[i];
+		p.Mutable = i % 2 == 1;
+		p.ValueColumn = i;
+		uiTableAppendColumn(table, &p);
+	}
+
+	return page9;
+}
diff --git a/src/libui_sdl/libui/_wip/table/ui.h b/src/libui_sdl/libui/_wip/table/ui.h
new file mode 100644
index 0000000..a5c30c8
--- /dev/null
+++ b/src/libui_sdl/libui/_wip/table/ui.h
@@ -0,0 +1,46 @@
+typedef struct uiTable uiTable;
+typedef struct uiTableModel uiTableModel;
+typedef struct uiTableModelSpec uiTableModelSpec;
+typedef struct uiTableColumnParams uiTableColumnParams;
+typedef enum uiTableColumnType uiTableColumnType;
+typedef enum uiTableNotification uiTableNotification;
+
+_UI_EXTERN uintmax_t uiTableType(void);
+#define uiTable(this) ((uiTable *) uiIsA((this), uiTableType(), 1))
+_UI_EXTERN void uiTableSetModel(uiTable *t, uiTableModel *m);
+_UI_EXTERN void uiTableAppendColumn(uiTable *t, uiTableColumnParams *p);
+_UI_EXTERN uiTable *uiNewTable(void);
+
+enum uiTableColumnType {
+	uiTableColumnText,
+//TODO	uiTableColumnImage,
+	uiTableColumnCheckbox,
+};
+
+struct uiTableModelSpec {
+	intmax_t (*NumRows)(uiTableModel *m, void *mData);
+	void *(*CellValue)(uiTableModel *m, void *mData, intmax_t row, intmax_t column);
+	void (*SetCellValue)(uiTableModel *m, void *mData, intmax_t row, intmax_t column, void *value);
+};
+
+enum uiTableNotification {
+	uiTableRowInserted,
+	uiTableRowDeleted,
+	uiTableCellChanged,
+};
+
+_UI_EXTERN uiTableModel *uiNewTableModel(uintmax_t nCols, uiTableColumnType *types, uiTableModelSpec *spec, void *mData);
+_UI_EXTERN void uiFreeTableModel(uiTableModel *m);
+_UI_EXTERN void uiTableModelNotify(uiTableModel *m, uiTableNotification notification, intmax_t row, intmax_t column);
+
+#define uiTableModelFromBool(b) ((void *) ((intptr_t) (b)))
+_UI_EXTERN void *uiTableModelFromString(const char *str);
+
+struct uiTableColumnParams {
+	const char *Name;
+	// TODO make this unnecessary
+	uiTableColumnType Type;
+	int Mutable;			// TODO move to the model?
+	intmax_t ValueColumn;
+	// TODO background color
+};
diff --git a/src/libui_sdl/libui/_wip/table/unix_table.c b/src/libui_sdl/libui/_wip/table/unix_table.c
new file mode 100644
index 0000000..825cf67
--- /dev/null
+++ b/src/libui_sdl/libui/_wip/table/unix_table.c
@@ -0,0 +1,87 @@
+// 18 october 2015
+#include "uipriv_unix.h"
+
+struct uiTable {
+	uiUnixControl c;
+	GtkWidget *widget;
+	GtkContainer *scontainer;
+	GtkScrolledWindow *sw;
+	GtkWidget *treeWidget;
+	GtkTreeView *treeview;
+	GtkTreeSelection *selection;
+	uiTableModel *model;
+};
+
+uiUnixDefineControl(
+	uiTable								// type name
+)
+
+void uiTableSetModel(uiTable *t, uiTableModel *m)
+{
+	t->model = m;
+	gtk_tree_view_set_model(t->treeview, GTK_TREE_MODEL(t->model));
+}
+
+void uiTableAppendColumn(uiTable *t, uiTableColumnParams *p)
+{
+	GtkTreeViewColumn *col;
+	GtkCellRenderer *r;
+	const char *attribute;
+	const char *mutableAttr;
+	gboolean mutable;
+
+	switch (p->Type) {
+	case uiTableColumnText:
+		r = gtk_cell_renderer_text_new();
+		attribute = "text";
+		mutableAttr = "editable";
+		break;
+//TODO	case uiTableColumnImage:
+		// TODO
+	case uiTableColumnCheckbox:
+		r = gtk_cell_renderer_toggle_new();
+		attribute = "active";
+		mutableAttr = "activatable";
+		break;
+	default:
+		complain("unknown table column type %d in uiTableAppendColumn()", p->Type);
+	}
+	mutable = FALSE;
+	if (p->Mutable)
+		mutable = TRUE;
+	g_object_set(r,
+		mutableAttr, mutable,
+		NULL);
+	col = gtk_tree_view_column_new_with_attributes(p->Name, r,
+		attribute, p->ValueColumn,
+		NULL);
+	// allow columns to be resized
+	gtk_tree_view_column_set_resizable(col, TRUE);
+	gtk_tree_view_append_column(t->treeview, col);
+}
+
+uiTable *uiNewTable(void)
+{
+	uiTable *t;
+
+	t = (uiTable *) uiNewControl(uiTableType());
+
+	t->widget = gtk_scrolled_window_new(NULL, NULL);
+	t->scontainer = GTK_CONTAINER(t->widget);
+	t->sw = GTK_SCROLLED_WINDOW(t->widget);
+
+	t->treeWidget = gtk_tree_view_new();
+	t->treeview = GTK_TREE_VIEW(t->treeWidget);
+
+	t->selection = gtk_tree_view_get_selection(t->treeview);
+
+	// give a border and add the table
+	gtk_scrolled_window_set_shadow_type(t->sw, GTK_SHADOW_IN);
+	gtk_container_add(t->scontainer, t->treeWidget);
+	// and make the table visible; only the scrolled window's visibility is controlled by libui
+	gtk_widget_show(t->treeWidget);
+
+	uiUnixFinishNewControl(t, uiTable);
+
+	return t;
+}
diff --git a/src/libui_sdl/libui/_wip/table/unix_tablemodel.c b/src/libui_sdl/libui/_wip/table/unix_tablemodel.c
new file mode 100644
index 0000000..0223465
--- /dev/null
+++ b/src/libui_sdl/libui/_wip/table/unix_tablemodel.c
@@ -0,0 +1,303 @@
+// 18 october 2015
+#include "uipriv_unix.h"
+
+// On GTK+, uiTableModel is a GtkTreeModel.
+
+#define uiTableModelType (uiTableModel_get_type())
+#define uiTableModel(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), uiTableModelType, uiTableModel))
+#define isAreaWidget(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), uiTableModelType))
+#define uiTableModelClass(class) (G_TYPE_CHECK_CLASS_CAST((class), uiTableModelType, uiTableModelClass))
+#define isAreaWidgetClass(class) (G_TYPE_CHECK_CLASS_TYPE((class), uiTableModel))
+#define getAreaWidgetClass(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), uiTableModelType, uiTableModelClass))
+
+typedef struct uiTableModel uiTableModel;
+typedef struct uiTableModelClass uiTableModelClass;
+
+struct uiTableModel {
+	GObject parent_instance;
+	uiTableModelSpec *spec;
+	void *mData;
+	intmax_t nColumns;
+	GType *coltypes;
+};
+
+struct uiTableModelClass {
+	GObjectClass parent_class;
+};
+
+static void uiTableModel_treeModel_init(GtkTreeModelIface *);
+
+G_DEFINE_TYPE_WITH_CODE(uiTableModel, uiTableModel, G_TYPE_OBJECT,
+	G_IMPLEMENT_INTERFACE(GTK_TYPE_TREE_MODEL, uiTableModel_treeModel_init))
+
+static void uiTableModel_init(uiTableModel *m)
+{
+	// do nothing
+}
+
+static void uiTableModel_dispose(GObject *obj)
+{
+	G_OBJECT_CLASS(uiTableModel_parent_class)->dispose(obj);
+}
+
+static void uiTableModel_finalize(GObject *obj)
+{
+	uiTableModel *m = uiTableModel(obj);
+
+	uiFree(m->coltypes);
+	G_OBJECT_CLASS(uiTableModel_parent_class)->finalize(obj);
+}
+
+static GtkTreeModelFlags uiTableModel_get_flags(GtkTreeModel *mb)
+{
+	return GTK_TREE_MODEL_LIST_ONLY;
+}
+
+static gint uiTableModel_get_n_columns(GtkTreeModel *mb)
+{
+	uiTableModel *m = uiTableModel(mb);
+
+	return m->nColumns;
+}
+
+static GType uiTableModel_get_column_type(GtkTreeModel *mb, gint index)
+{
+	uiTableModel *m = uiTableModel(mb);
+
+	return m->coltypes[index];
+}
+
+/*
+how our GtkTreeIters are stored:
+	stamp: either GOOD_STAMP or BAD_STAMP
+	user_data: row index
+Thanks to Company in irc.gimp.net/#gtk+ for suggesting the GSIZE_TO_POINTER() t
+rick.
+*/
+#define GOOD_STAMP 0x1234
+#define BAD_STAMP 0x5678
+#define FROM(x) ((gint) GPOINTER_TO_SIZE((x)))
+#define TO(x) GSIZE_TO_POINTER((gsize) (x))
+
+#define numRows(m) ((*((m)->spec->NumRows))((m), (m)->mData))
+#define cellValue(m, row, col) ((*((m)->spec->CellValue))((m), (m)->mData, row, column))
+
+static gboolean uiTableModel_get_iter(GtkTreeModel *mb, GtkTreeIter *iter, GtkTreePath *path)
+{
+	uiTableModel *m = uiTableModel(mb);
+	gint index;
+
+	if (gtk_tree_path_get_depth(path) != 1)
+		goto bad;
+	index = gtk_tree_path_get_indices(path)[0];
+	if (index < 0)
+		goto bad;
+	if (index >= numRows(m))
+		goto bad;
+	iter->stamp = GOOD_STAMP;
+	iter->user_data = TO(index);
+	return TRUE;
+bad:
+	iter->stamp = BAD_STAMP;
+	return FALSE;
+}
+
+static GtkTreePath *uiTableModel_get_path(GtkTreeModel *mb, GtkTreeIter *iter)
+{
+	// note: from this point forward, the GOOD_STAMP checks ensure that the index stored in iter is nonnegative
+	if (iter->stamp != GOOD_STAMP)
+		return NULL;			// this is what both GtkListStore and GtkTreeStore do
+	return gtk_tree_path_new_from_indices(FROM(iter->user_data), -1);
+}
+
+void *uiTableModelFromString(const char *str)
+{
+	return g_strdup(str);
+}
+
+#define toBool(v) ((int) ((intptr_t) (v)))
+#define toStr(v) ((char *) (v))
+
+static void uiTableModel_get_value(GtkTreeModel *mb, GtkTreeIter *iter, gint column, GValue *value)
+{
+	uiTableModel *m = uiTableModel(mb);
+	void *v;
+	GType type;
+
+	if (iter->stamp != GOOD_STAMP)
+		return;				// this is what both GtkListStore and GtkTreeStore do
+	v = cellValue(m, FROM(iter->user_data), column);
+	type = m->coltypes[column];
+	g_value_init(value, type);
+	if (type == G_TYPE_STRING)
+		g_value_take_string(value, toStr(v));
+		// the GValue now manages the memory of the string that was g_strdup()'d before
+	// TODO image
+	else if (type == G_TYPE_BOOLEAN)
+		g_value_set_boolean(value, toBool(v));
+	else
+		complain("unknown GType in uiTableModel_get_value()");
+}
+
+static gboolean uiTableModel_iter_next(GtkTreeModel *mb, GtkTreeIter *iter)
+{
+	uiTableModel *m = uiTableModel(mb);
+	gint index;
+
+	if (iter->stamp != GOOD_STAMP)
+		return FALSE;				// this is what both GtkListStore and GtkTreeStore do
+	index = FROM(iter->user_data);
+	index++;
+	if (index >= numRows(m)) {
+		iter->stamp = BAD_STAMP;
+		return FALSE;
+	}
+	iter->user_data = TO(index);
+	return TRUE;
+}
+
+static gboolean uiTableModel_iter_previous(GtkTreeModel *mb, GtkTreeIter *iter)
+{
+	uiTableModel *m = uiTableModel(mb);
+	gint index;
+
+	if (iter->stamp != GOOD_STAMP)
+		return FALSE;			// this is what both GtkListStore and GtkTreeStore do
+	index = FROM(iter->user_data);
+	if (index <= 0) {
+		iter->stamp = BAD_STAMP;
+		return FALSE;
+	}
+	index--;
+	iter->user_data = TO(index);
+	return TRUE;
+}
+
+static gboolean uiTableModel_iter_children(GtkTreeModel *mb, GtkTreeIter *iter, GtkTreeIter *parent)
+{
+	uiTableModel *m = uiTableModel(mb);
+
+	if (parent == NULL && numRows(m) > 0) {
+		iter->stamp = GOOD_STAMP;
+		iter->user_data = 0;
+		return TRUE;
+	}
+	iter->stamp = BAD_STAMP;
+	return FALSE;
+}
+
+static gboolean uiTableModel_iter_has_child(GtkTreeModel *mb, GtkTreeIter *iter)
+{
+	return FALSE;
+}
+
+static gint uiTableModel_iter_n_children(GtkTreeModel *mb, GtkTreeIter *iter)
+{
+	uiTableModel *m = uiTableModel(mb);
+
+	if (iter == NULL)
+		return numRows(m);
+	return 0;
+}
+
+static gboolean uiTableModel_iter_nth_child(GtkTreeModel *mb, GtkTreeIter *iter, GtkTreeIter *parent, gint n)
+{
+	uiTableModel *m = uiTableModel(mb);
+
+	if (parent == NULL && n >= 0 && n < numRows(m)) {
+		iter->stamp = GOOD_STAMP;
+		iter->user_data = TO(n);
+		return TRUE;
+	}
+	iter->stamp = BAD_STAMP;
+	return FALSE;
+}
+
+static gboolean uiTableModel_iter_parent(GtkTreeModel *mb, GtkTreeIter *iter, GtkTreeIter *child)
+{
+	iter->stamp = BAD_STAMP;
+	return FALSE;
+}
+
+static void uiTableModel_class_init(uiTableModelClass *class)
+{
+	G_OBJECT_CLASS(class)->dispose = uiTableModel_dispose;
+	G_OBJECT_CLASS(class)->finalize = uiTableModel_finalize;
+}
+
+static void uiTableModel_treeModel_init(GtkTreeModelIface *iface)
+{
+	iface->get_flags = uiTableModel_get_flags;
+	iface->get_n_columns = uiTableModel_get_n_columns;
+	iface->get_column_type = uiTableModel_get_column_type;
+	iface->get_iter = uiTableModel_get_iter;
+	iface->get_path = uiTableModel_get_path;
+	iface->get_value = uiTableModel_get_value;
+	iface->iter_next = uiTableModel_iter_next;
+	iface->iter_previous = uiTableModel_iter_previous;
+	iface->iter_children = uiTableModel_iter_children;
+	iface->iter_has_child = uiTableModel_iter_has_child;
+	iface->iter_n_children = uiTableModel_iter_n_children;
+	iface->iter_nth_child = uiTableModel_iter_nth_child;
+	iface->iter_parent = uiTableModel_iter_parent;
+	// no need for ref_node or unref_node
+}
+
+uiTableModel *uiNewTableModel(uintmax_t nCols, uiTableColumnType *types, uiTableModelSpec *spec, void *mData)
+{
+	uiTableModel *m;
+	intmax_t i;
+
+	m = uiTableModel(g_object_new(uiTableModelType, NULL));
+	m->spec = spec;
+	m->mData = mData;
+	m->nColumns = nCols;
+	m->coltypes = (GType *) uiAlloc(m->nColumns * sizeof (GType), "GType[]");
+	for (i = 0; i < m->nColumns; i++)
+		switch (types[i]) {
+		case uiTableColumnText:
+			m->coltypes[i] = G_TYPE_STRING;
+			break;
+//TODO		case uiTableColumnImage:
+			// TODO
+		case uiTableColumnCheckbox:
+			m->coltypes[i] = G_TYPE_BOOLEAN;
+			break;
+		default:
+			complain("unknown column type %d in uiNewTableModel()", types[i]);
+		}
+	return m;
+}
+
+// TODO ensure no tables are subscribed
+void uiFreeTableModel(uiTableModel *m)
+{
+	g_object_unref(m);
+}
+
+void uiTableModelNotify(uiTableModel *m, uiTableNotification notification, intmax_t row, intmax_t column)
+{
+	GtkTreeModel *model = GTK_TREE_MODEL(m);
+	GtkTreePath *path;
+	GtkTreeIter iter;
+
+	path = gtk_tree_path_new_from_indices(row, -1);
+	switch (notification) {
+	case uiTableRowInserted:
+		if (gtk_tree_model_get_iter(model, &iter, path) == FALSE)
+			complain("invalid row given to row inserted in uiTableModelNotify()");
+		gtk_tree_model_row_inserted(model, path, &iter);
+		break;
+	case uiTableRowDeleted:
+		gtk_tree_model_row_deleted(model, path);
+		break;
+	case uiTableCellChanged:
+		if (gtk_tree_model_get_iter(model, &iter, path) == FALSE)
+			complain("invalid row given to row changed in uiTableModelNotify()");
+		gtk_tree_model_row_changed(model, path, &iter);
+		break;
+	default:
+		complain("unknown uiTable notification %d in uiTableModelNotify()", notification);
+	}
+	gtk_tree_path_free(path);
+}
diff --git a/src/libui_sdl/libui/common/CMakeLists.txt b/src/libui_sdl/libui/common/CMakeLists.txt
new file mode 100644
index 0000000..91d7949
--- /dev/null
+++ b/src/libui_sdl/libui/common/CMakeLists.txt
@@ -0,0 +1,16 @@
+# 3 june 2016
+
+list(APPEND _LIBUI_SOURCES
+	common/areaevents.c
+	common/control.c
+	common/debug.c
+	common/matrix.c
+	common/shouldquit.c
+	common/userbugs.c
+)
+set(_LIBUI_SOURCES ${_LIBUI_SOURCES} PARENT_SCOPE)
+
+list(APPEND _LIBUI_INCLUDEDIRS
+	common
+)
+set(_LIBUI_INCLUDEDIRS ${_LIBUI_INCLUDEDIRS} PARENT_SCOPE)
diff --git a/src/libui_sdl/libui/common/areaevents.c b/src/libui_sdl/libui/common/areaevents.c
new file mode 100644
index 0000000..cf3c288
--- /dev/null
+++ b/src/libui_sdl/libui/common/areaevents.c
@@ -0,0 +1,167 @@
+// 29 march 2014
+#include "../ui.h"
+#include "uipriv.h"
+
+/*
+Windows and GTK+ have a limit of 2 and 3 clicks, respectively, natively supported. Fortunately, we can simulate the double/triple-click behavior to build higher-order clicks. We can use the same algorithm Windows uses on both:
+	http://blogs.msdn.com/b/oldnewthing/archive/2004/10/18/243925.aspx
+For GTK+, we pull the double-click time and double-click distance, which work the same as the equivalents on Windows (so the distance is in all directions), from the GtkSettings system.
+
+On GTK+ this will also allow us to discard the GDK_BUTTON_2PRESS and GDK_BUTTON_3PRESS events, so the button press stream will be just like on other platforms.
+
+Thanks to mclasen, garnacho_, halfline, and tristan in irc.gimp.net/#gtk+.
+*/
+
+// x, y, xdist, ydist, and c.rect must have the same units
+// so must time, maxTime, and c.prevTime
+int clickCounterClick(clickCounter *c, int button, int x, int y, uintptr_t time, uintptr_t maxTime, int32_t xdist, int32_t ydist)
+{
+	// different button than before? if so, don't count
+	if (button != c->curButton)
+		c->count = 0;
+
+	// (x, y) in the allowed region for a double-click? if not, don't count
+	if (x < c->rectX0)
+		c->count = 0;
+	if (y < c->rectY0)
+		c->count = 0;
+	if (x >= c->rectX1)
+		c->count = 0;
+	if (y >= c->rectY1)
+		c->count = 0;
+
+	// too slow? if so, don't count
+	// note the below expression; time > (c.prevTime + maxTime) can overflow!
+	if ((time - c->prevTime) > maxTime)	// too slow; don't count
+		c->count = 0;
+
+	c->count++;		// if either of the above ifs happened, this will make the click count 1; otherwise it will make the click count 2, 3, 4, 5, ...
+
+	// now we need to update the internal structures for the next test
+	c->curButton = button;
+	c->prevTime = time;
+	c->rectX0 = x - xdist;
+	c->rectY0 = y - ydist;
+	c->rectX1 = x + xdist;
+	c->rectY1 = y + ydist;
+
+	return c->count;
+}
+
+void clickCounterReset(clickCounter *c)
+{
+	c->curButton = 0;
+	c->rectX0 = 0;
+	c->rectY0 = 0;
+	c->rectX1 = 0;
+	c->rectY1 = 0;
+	c->prevTime = 0;
+	c->count = 0;
+}
+
+/*
+For position independence across international keyboard layouts, typewriter keys are read using scancodes (which are always set 1).
+Windows provides the scancodes directly in the LPARAM.
+GTK+ provides the scancodes directly from the underlying window system via GdkEventKey.hardware_keycode.
+On X11, this is scancode + 8 (because X11 keyboard codes have a range of [8,255]).
+Wayland is guaranteed to give the same result (thanks ebassi in irc.gimp.net/#gtk+).
+On Linux, where evdev is used instead of polling scancodes directly from the keyboard, evdev's typewriter section key code constants are the same as scancodes anyway, so the rules above apply.
+Typewriter section scancodes are the same across international keyboards with some exceptions that have been accounted for (see KeyEvent's documentation); see http://www.quadibloc.com/comp/scan.htm for details.
+Non-typewriter keys can be handled safely using constants provided by the respective backend API.
+
+Because GTK+ keysyms may or may not obey Num Lock, we also handle the 0-9 and . keys on the numeric keypad with scancodes (they match too).
+*/
+
+// use uintptr_t to be safe; the size of the scancode/hardware key code field on each platform is different
+static const struct {
+	uintptr_t scancode;
+	char equiv;
+} scancodeKeys[] = {
+	{ 0x02, '1' },
+	{ 0x03, '2' },
+	{ 0x04, '3' },
+	{ 0x05, '4' },
+	{ 0x06, '5' },
+	{ 0x07, '6' },
+	{ 0x08, '7' },
+	{ 0x09, '8' },
+	{ 0x0A, '9' },
+	{ 0x0B, '0' },
+	{ 0x0C, '-' },
+	{ 0x0D, '=' },
+	{ 0x0E, '\b' },
+	{ 0x0F, '\t' },
+	{ 0x10, 'q' },
+	{ 0x11, 'w' },
+	{ 0x12, 'e' },
+	{ 0x13, 'r' },
+	{ 0x14, 't' },
+	{ 0x15, 'y' },
+	{ 0x16, 'u' },
+	{ 0x17, 'i' },
+	{ 0x18, 'o' },
+	{ 0x19, 'p' },
+	{ 0x1A, '[' },
+	{ 0x1B, ']' },
+	{ 0x1C, '\n' },
+	{ 0x1E, 'a' },
+	{ 0x1F, 's' },
+	{ 0x20, 'd' },
+	{ 0x21, 'f' },
+	{ 0x22, 'g' },
+	{ 0x23, 'h' },
+	{ 0x24, 'j' },
+	{ 0x25, 'k' },
+	{ 0x26, 'l' },
+	{ 0x27, ';' },
+	{ 0x28, '\'' },
+	{ 0x29, '`' },
+	{ 0x2B, '\\' },
+	{ 0x2C, 'z' },
+	{ 0x2D, 'x' },
+	{ 0x2E, 'c' },
+	{ 0x2F, 'v' },
+	{ 0x30, 'b' },
+	{ 0x31, 'n' },
+	{ 0x32, 'm' },
+	{ 0x33, ',' },
+	{ 0x34, '.' },
+	{ 0x35, '/' },
+	{ 0x39, ' ' },
+	{ 0xFFFF, 0 },
+};
+
+static const struct {
+	uintptr_t scancode;
+	uiExtKey equiv;
+} scancodeExtKeys[] = {
+	{ 0x47, uiExtKeyN7 },
+	{ 0x48, uiExtKeyN8 },
+	{ 0x49, uiExtKeyN9 },
+	{ 0x4B, uiExtKeyN4 },
+	{ 0x4C, uiExtKeyN5 },
+	{ 0x4D, uiExtKeyN6 },
+	{ 0x4F, uiExtKeyN1 },
+	{ 0x50, uiExtKeyN2 },
+	{ 0x51, uiExtKeyN3 },
+	{ 0x52, uiExtKeyN0 },
+	{ 0x53, uiExtKeyNDot },
+	{ 0xFFFF, 0 },
+};
+
+int fromScancode(uintptr_t scancode, uiAreaKeyEvent *ke)
+{
+	int i;
+
+	for (i = 0; scancodeKeys[i].scancode != 0xFFFF; i++)
+		if (scancodeKeys[i].scancode == scancode) {
+			ke->Key = scancodeKeys[i].equiv;
+			return 1;
+		}
+	for (i = 0; scancodeExtKeys[i].scancode != 0xFFFF; i++)
+		if (scancodeExtKeys[i].scancode == scancode) {
+			ke->ExtKey = scancodeExtKeys[i].equiv;
+			return 1;
+		}
+	return 0;
+}
diff --git a/src/libui_sdl/libui/common/control.c b/src/libui_sdl/libui/common/control.c
new file mode 100644
index 0000000..2806646
--- /dev/null
+++ b/src/libui_sdl/libui/common/control.c
@@ -0,0 +1,101 @@
+// 26 may 2015
+#include "../ui.h"
+#include "uipriv.h"
+
+void uiControlDestroy(uiControl *c)
+{
+	(*(c->Destroy))(c);
+}
+
+uintptr_t uiControlHandle(uiControl *c)
+{
+	return (*(c->Handle))(c);
+}
+
+uiControl *uiControlParent(uiControl *c)
+{
+	return (*(c->Parent))(c);
+}
+
+void uiControlSetParent(uiControl *c, uiControl *parent)
+{
+	(*(c->SetParent))(c, parent);
+}
+
+int uiControlToplevel(uiControl *c)
+{
+	return (*(c->Toplevel))(c);
+}
+
+int uiControlVisible(uiControl *c)
+{
+	return (*(c->Visible))(c);
+}
+
+void uiControlShow(uiControl *c)
+{
+	(*(c->Show))(c);
+}
+
+void uiControlHide(uiControl *c)
+{
+	(*(c->Hide))(c);
+}
+
+int uiControlEnabled(uiControl *c)
+{
+	return (*(c->Enabled))(c);
+}
+
+void uiControlEnable(uiControl *c)
+{
+	(*(c->Enable))(c);
+}
+
+void uiControlDisable(uiControl *c)
+{
+	(*(c->Disable))(c);
+}
+
+#define uiControlSignature 0x7569436F
+
+uiControl *uiAllocControl(size_t size, uint32_t OSsig, uint32_t typesig, const char *typenamestr)
+{
+	uiControl *c;
+
+	c = (uiControl *) uiAlloc(size, typenamestr);
+	c->Signature = uiControlSignature;
+	c->OSSignature = OSsig;
+	c->TypeSignature = typesig;
+	return c;
+}
+
+void uiFreeControl(uiControl *c)
+{
+	if (uiControlParent(c) != NULL)
+		userbug("You cannot destroy a uiControl while it still has a parent. (control: %p)", c);
+	uiFree(c);
+}
+
+void uiControlVerifySetParent(uiControl *c, uiControl *parent)
+{
+	uiControl *curParent;
+
+	if (uiControlToplevel(c))
+		userbug("You cannot give a toplevel uiControl a parent. (control: %p)", c);
+	curParent = uiControlParent(c);
+	if (parent != NULL && curParent != NULL)
+		userbug("You cannot give a uiControl a parent while it already has one. (control: %p; current parent: %p; new parent: %p)", c, curParent, parent);
+	if (parent == NULL && curParent == NULL)
+		implbug("attempt to double unparent uiControl %p", c);
+}
+
+int uiControlEnabledToUser(uiControl *c)
+{
+	while (c != NULL) {
+		if (!uiControlEnabled(c))
+			return 0;
+		c = uiControlParent(c);
+	}
+	return 1;
+}
diff --git a/src/libui_sdl/libui/common/controlsigs.h b/src/libui_sdl/libui/common/controlsigs.h
new file mode 100644
index 0000000..1cbf18d
--- /dev/null
+++ b/src/libui_sdl/libui/common/controlsigs.h
@@ -0,0 +1,25 @@
+// 24 april 2016
+
+#define uiAreaSignature 0x41726561
+#define uiBoxSignature 0x426F784C
+#define uiButtonSignature 0x42746F6E
+#define uiCheckboxSignature 0x43686B62
+#define uiColorButtonSignature 0x436F6C42
+#define uiComboboxSignature 0x436F6D62
+#define uiDateTimePickerSignature 0x44545069
+#define uiEditableComboboxSignature 0x45644362
+#define uiEntrySignature 0x456E7472
+#define uiFontButtonSignature 0x466F6E42
+#define uiFormSignature 0x466F726D
+#define uiGridSignature 0x47726964
+#define uiGroupSignature 0x47727062
+#define uiLabelSignature 0x4C61626C
+#define uiMultilineEntrySignature 0x4D6C6E45
+#define uiProgressBarSignature 0x50426172
+#define uiRadioButtonsSignature 0x5264696F
+#define uiSeparatorSignature 0x53657061
+#define uiSliderSignature 0x536C6964
+#define uiSpinboxSignature 0x5370696E
+#define uiTabSignature 0x54616273
+#define uiTableSignature 0x5461626C
+#define uiWindowSignature 0x57696E64
diff --git a/src/libui_sdl/libui/common/debug.c b/src/libui_sdl/libui/common/debug.c
new file mode 100644
index 0000000..97280b4
--- /dev/null
+++ b/src/libui_sdl/libui/common/debug.c
@@ -0,0 +1,21 @@
+// 13 may 2016
+#include "../ui.h"
+#include "uipriv.h"
+
+void _implbug(const char *file, const char *line, const char *func, const char *format, ...)
+{
+	va_list ap;
+
+	va_start(ap, format);
+	realbug(file, line, func, "POSSIBLE IMPLEMENTATION BUG; CONTACT ANDLABS:\n", format, ap);
+	va_end(ap);
+}
+
+void _userbug(const char *file, const char *line, const char *func, const char *format, ...)
+{
+	va_list ap;
+
+	va_start(ap, format);
+	realbug(file, line, func, "You have a bug: ", format, ap);
+	va_end(ap);
+}
diff --git a/src/libui_sdl/libui/common/matrix.c b/src/libui_sdl/libui/common/matrix.c
new file mode 100644
index 0000000..676885d
--- /dev/null
+++ b/src/libui_sdl/libui/common/matrix.c
@@ -0,0 +1,50 @@
+// 11 october 2015
+#include <math.h>
+#include "../ui.h"
+#include "uipriv.h"
+
+void uiDrawMatrixSetIdentity(uiDrawMatrix *m)
+{
+	m->M11 = 1;
+	m->M12 = 0;
+	m->M21 = 0;
+	m->M22 = 1;
+	m->M31 = 0;
+	m->M32 = 0;
+}
+
+// The rest of this file provides basic utilities in case the platform doesn't provide any of its own for these tasks.
+// Keep these as minimal as possible. They should generally not call other fallbacks.
+
+// see https://msdn.microsoft.com/en-us/library/windows/desktop/ff684171%28v=vs.85%29.aspx#skew_transform
+// TODO see if there's a way we can avoid the multiplication
+void fallbackSkew(uiDrawMatrix *m, double x, double y, double xamount, double yamount)
+{
+	uiDrawMatrix n;
+
+	uiDrawMatrixSetIdentity(&n);
+	// TODO explain this
+	n.M12 = tan(yamount);
+	n.M21 = tan(xamount);
+	n.M31 = -y * tan(xamount);
+	n.M32 = -x * tan(yamount);
+	uiDrawMatrixMultiply(m, &n);
+}
+
+void scaleCenter(double xCenter, double yCenter, double *x, double *y)
+{
+	*x = xCenter - (*x * xCenter);
+	*y = yCenter - (*y * yCenter);
+}
+
+// the basic algorithm is from cairo
+// but it's the same algorithm as the transform point, just without M31 and M32 taken into account, so let's just do that instead
+void fallbackTransformSize(uiDrawMatrix *m, double *x, double *y)
+{
+	uiDrawMatrix m2;
+
+	m2 = *m;
+	m2.M31 = 0;
+	m2.M32 = 0;
+	uiDrawMatrixTransformPoint(&m2, x, y);
+}
diff --git a/src/libui_sdl/libui/common/shouldquit.c b/src/libui_sdl/libui/common/shouldquit.c
new file mode 100644
index 0000000..4e7aa5c
--- /dev/null
+++ b/src/libui_sdl/libui/common/shouldquit.c
@@ -0,0 +1,22 @@
+// 9 may 2015
+#include "../ui.h"
+#include "uipriv.h"
+
+static int defaultOnShouldQuit(void *data)
+{
+	return 0;
+}
+
+static int (*onShouldQuit)(void *) = defaultOnShouldQuit;
+static void *onShouldQuitData;
+
+void uiOnShouldQuit(int (*f)(void *), void *data)
+{
+	onShouldQuit = f;
+	onShouldQuitData = data;
+}
+
+int shouldQuit(void)
+{
+	return (*onShouldQuit)(onShouldQuitData);
+}
diff --git a/src/libui_sdl/libui/common/uipriv.h b/src/libui_sdl/libui/common/uipriv.h
new file mode 100644
index 0000000..d6b54e8
--- /dev/null
+++ b/src/libui_sdl/libui/common/uipriv.h
@@ -0,0 +1,58 @@
+// 6 april 2015
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdarg.h>
+#include "controlsigs.h"
+
+extern uiInitOptions options;
+
+extern void *uiAlloc(size_t, const char *);
+#define uiNew(T) ((T *) uiAlloc(sizeof (T), #T))
+extern void *uiRealloc(void *, size_t, const char *);
+extern void uiFree(void *);
+
+// ugh, this was only introduced in MSVC 2015...
+#ifdef _MSC_VER
+#define __func__ __FUNCTION__
+#endif
+extern void realbug(const char *file, const char *line, const char *func, const char *prefix, const char *format, va_list ap);
+#define _ns2(s) #s
+#define _ns(s) _ns2(s)
+extern void _implbug(const char *file, const char *line, const char *func, const char *format, ...);
+#define implbug(...) _implbug(__FILE__, _ns(__LINE__), __func__, __VA_ARGS__)
+extern void _userbug(const char *file, const char *line, const char *func, const char *format, ...);
+#define userbug(...) _userbug(__FILE__, _ns(__LINE__), __func__, __VA_ARGS__)
+
+// control.c
+extern uiControl *newControl(size_t size, uint32_t OSsig, uint32_t typesig, const char *typenamestr);
+
+// shouldquit.c
+extern int shouldQuit(void);
+
+// areaevents.c
+typedef struct clickCounter clickCounter;
+// you should call Reset() to zero-initialize a new instance
+// it doesn't matter that all the non-count fields are zero: the first click will fail the curButton test straightaway, so it'll return 1 and set the rest of the structure accordingly
+struct clickCounter {
+	int curButton;
+	int rectX0;
+	int rectY0;
+	int rectX1;
+	int rectY1;
+	uintptr_t prevTime;
+	int count;
+};
+int clickCounterClick(clickCounter *c, int button, int x, int y, uintptr_t time, uintptr_t maxTime, int32_t xdist, int32_t ydist);
+extern void clickCounterReset(clickCounter *);
+extern int fromScancode(uintptr_t, uiAreaKeyEvent *);
+
+// matrix.c
+extern void fallbackSkew(uiDrawMatrix *, double, double, double, double);
+extern void scaleCenter(double, double, double *, double *);
+extern void fallbackTransformSize(uiDrawMatrix *, double *, double *);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/libui_sdl/libui/common/userbugs.c b/src/libui_sdl/libui/common/userbugs.c
new file mode 100644
index 0000000..0a85874
--- /dev/null
+++ b/src/libui_sdl/libui/common/userbugs.c
@@ -0,0 +1,8 @@
+// 22 may 2016
+#include "../ui.h"
+#include "uipriv.h"
+
+void uiUserBugCannotSetParentOnToplevel(const char *type)
+{
+	userbug("You cannot make a %s a child of another uiControl,", type);
+}
diff --git a/src/libui_sdl/libui/darwin/CMakeLists.txt b/src/libui_sdl/libui/darwin/CMakeLists.txt
new file mode 100644
index 0000000..dbef5d4
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/CMakeLists.txt
@@ -0,0 +1,79 @@
+# 3 june 2016
+
+list(APPEND _LIBUI_SOURCES
+	darwin/alloc.m
+	darwin/area.m
+	darwin/areaevents.m
+	darwin/autolayout.m
+	darwin/box.m
+	darwin/button.m
+	darwin/checkbox.m
+	darwin/colorbutton.m
+	darwin/combobox.m
+	darwin/control.m
+	darwin/datetimepicker.m
+	darwin/debug.m
+	darwin/draw.m
+	darwin/drawtext.m
+	darwin/editablecombo.m
+	darwin/entry.m
+	darwin/fontbutton.m
+	darwin/form.m
+	darwin/grid.m
+	darwin/group.m
+	darwin/image.m
+	darwin/label.m
+	darwin/main.m
+	darwin/map.m
+	darwin/menu.m
+	darwin/multilineentry.m
+	darwin/progressbar.m
+	darwin/radiobuttons.m
+	darwin/scrollview.m
+	darwin/separator.m
+	darwin/slider.m
+	darwin/spinbox.m
+	darwin/stddialogs.m
+	darwin/tab.m
+	darwin/text.m
+	darwin/util.m
+	darwin/window.m
+	darwin/winmoveresize.m
+)
+set(_LIBUI_SOURCES ${_LIBUI_SOURCES} PARENT_SCOPE)
+
+list(APPEND _LIBUI_INCLUDEDIRS
+	darwin
+)
+set(_LIBUI_INCLUDEDIRS _LIBUI_INCLUDEDIRS PARENT_SCOPE)
+
+set(_LIBUINAME libui PARENT_SCOPE)
+if(NOT BUILD_SHARED_LIBS)
+	set(_LIBUINAME libui-temporary PARENT_SCOPE)
+endif()
+# thanks to Mr-Hide in irc.freenode.net/#cmake
+macro(_handle_static)
+	set_target_properties(${_LIBUINAME} PROPERTIES
+		ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}")
+	set(_aname $<TARGET_FILE:${_LIBUINAME}>)
+	set(_lname libui-combined.list)
+	set(_oname libui-combined.o)
+	add_custom_command(
+		OUTPUT ${_oname}
+		COMMAND
+			nm -m ${_aname} | sed -E -n "'s/^[0-9a-f]* \\([A-Z_]+,[a-z_]+\\) external //p'" > ${_lname}
+		COMMAND
+			ld -exported_symbols_list ${_lname} -r -all_load ${_aname} -o ${_oname}
+		COMMENT "Removing hidden symbols")
+	add_library(libui STATIC ${_oname})
+	# otherwise cmake won't know which linker to use
+	set_target_properties(libui PROPERTIES
+		LINKER_LANGUAGE C)
+	set(_aname)
+	set(_lname)
+	set(_oname)
+endmacro()
+
+set(_LIBUI_LIBS
+	objc "-framework Foundation" "-framework AppKit"
+PARENT_SCOPE)
diff --git a/src/libui_sdl/libui/darwin/alloc.m b/src/libui_sdl/libui/darwin/alloc.m
new file mode 100644
index 0000000..e271b90
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/alloc.m
@@ -0,0 +1,89 @@
+// 4 december 2014
+#import <stdlib.h>
+#import "uipriv_darwin.h"
+
+static NSMutableArray *allocations;
+NSMutableArray *delegates;
+
+void initAlloc(void)
+{
+	allocations = [NSMutableArray new];
+	delegates = [NSMutableArray new];
+}
+
+#define UINT8(p) ((uint8_t *) (p))
+#define PVOID(p) ((void *) (p))
+#define EXTRA (sizeof (size_t) + sizeof (const char **))
+#define DATA(p) PVOID(UINT8(p) + EXTRA)
+#define BASE(p) PVOID(UINT8(p) - EXTRA)
+#define SIZE(p) ((size_t *) (p))
+#define CCHAR(p) ((const char **) (p))
+#define TYPE(p) CCHAR(UINT8(p) + sizeof (size_t))
+
+void uninitAlloc(void)
+{
+	NSMutableString *str;
+	NSValue *v;
+
+	[delegates release];
+	if ([allocations count] == 0) {
+		[allocations release];
+		return;
+	}
+	str = [NSMutableString new];
+	for (v in allocations) {
+		void *ptr;
+
+		ptr = [v pointerValue];
+		[str appendString:[NSString stringWithFormat:@"%p %s\n", ptr, *TYPE(ptr)]];
+	}
+	userbug("Some data was leaked; either you left a uiControl lying around or there's a bug in libui itself. Leaked data:\n%s", [str UTF8String]);
+	[str release];
+}
+
+void *uiAlloc(size_t size, const char *type)
+{
+	void *out;
+
+	out = malloc(EXTRA + size);
+	if (out == NULL) {
+		fprintf(stderr, "memory exhausted in uiAlloc()\n");
+		abort();
+	}
+	memset(DATA(out), 0, size);
+	*SIZE(out) = size;
+	*TYPE(out) = type;
+	[allocations addObject:[NSValue valueWithPointer:out]];
+	return DATA(out);
+}
+
+void *uiRealloc(void *p, size_t new, const char *type)
+{
+	void *out;
+	size_t *s;
+
+	if (p == NULL)
+		return uiAlloc(new, type);
+	p = BASE(p);
+	out = realloc(p, EXTRA + new);
+	if (out == NULL) {
+		fprintf(stderr, "memory exhausted in uiRealloc()\n");
+		abort();
+	}
+	s = SIZE(out);
+	if (new <= *s)
+		memset(((uint8_t *) DATA(out)) + *s, 0, new - *s);
+	*s = new;
+	[allocations removeObject:[NSValue valueWithPointer:p]];
+	[allocations addObject:[NSValue valueWithPointer:out]];
+	return DATA(out);
+}
+
+void uiFree(void *p)
+{
+	if (p == NULL)
+		implbug("attempt to uiFree(NULL)");
+	p = BASE(p);
+	free(p);
+	[allocations removeObject:[NSValue valueWithPointer:p]];
+}
diff --git a/src/libui_sdl/libui/darwin/area.m b/src/libui_sdl/libui/darwin/area.m
new file mode 100644
index 0000000..23162e6
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/area.m
@@ -0,0 +1,475 @@
+// 9 september 2015
+#import "uipriv_darwin.h"
+
+// 10.8 fixups
+#define NSEventModifierFlags NSUInteger
+
+@interface areaView : NSView {
+	uiArea *libui_a;
+	NSTrackingArea *libui_ta;
+	NSSize libui_ss;
+	BOOL libui_enabled;
+}
+- (id)initWithFrame:(NSRect)r area:(uiArea *)a;
+- (uiModifiers)parseModifiers:(NSEvent *)e;
+- (void)doMouseEvent:(NSEvent *)e;
+- (int)sendKeyEvent:(uiAreaKeyEvent *)ke;
+- (int)doKeyDownUp:(NSEvent *)e up:(int)up;
+- (int)doKeyDown:(NSEvent *)e;
+- (int)doKeyUp:(NSEvent *)e;
+- (int)doFlagsChanged:(NSEvent *)e;
+- (void)setupNewTrackingArea;
+- (void)setScrollingSize:(NSSize)s;
+- (BOOL)isEnabled;
+- (void)setEnabled:(BOOL)e;
+@end
+
+struct uiArea {
+	uiDarwinControl c;
+	NSView *view;			// either sv or area depending on whether it is scrolling
+	NSScrollView *sv;
+	areaView *area;
+	struct scrollViewData *d;
+	uiAreaHandler *ah;
+	BOOL scrolling;
+	NSEvent *dragevent;
+};
+
+@implementation areaView
+
+- (id)initWithFrame:(NSRect)r area:(uiArea *)a
+{
+	self = [super initWithFrame:r];
+	if (self) {
+		self->libui_a = a;
+		[self setupNewTrackingArea];
+		self->libui_ss = r.size;
+		self->libui_enabled = YES;
+	}
+	return self;
+}
+
+- (void)drawRect:(NSRect)r
+{
+	uiArea *a = self->libui_a;
+	CGContextRef c;
+	uiAreaDrawParams dp;
+
+	c = (CGContextRef) [[NSGraphicsContext currentContext] graphicsPort];
+	// see draw.m under text for why we need the height
+	dp.Context = newContext(c, [self bounds].size.height);
+
+	dp.AreaWidth = 0;
+	dp.AreaHeight = 0;
+	if (!a->scrolling) {
+		dp.AreaWidth = [self frame].size.width;
+		dp.AreaHeight = [self frame].size.height;
+	}
+
+	dp.ClipX = r.origin.x;
+	dp.ClipY = r.origin.y;
+	dp.ClipWidth = r.size.width;
+	dp.ClipHeight = r.size.height;
+
+	// no need to save or restore the graphics state to reset transformations; Cocoa creates a brand-new context each time
+	(*(a->ah->Draw))(a->ah, a, &dp);
+
+	freeContext(dp.Context);
+}
+
+- (BOOL)isFlipped
+{
+	return YES;
+}
+
+- (BOOL)acceptsFirstResponder
+{
+	return YES;
+}
+
+- (uiModifiers)parseModifiers:(NSEvent *)e
+{
+	NSEventModifierFlags mods;
+	uiModifiers m;
+
+	m = 0;
+	mods = [e modifierFlags];
+	if ((mods & NSControlKeyMask) != 0)
+		m |= uiModifierCtrl;
+	if ((mods & NSAlternateKeyMask) != 0)
+		m |= uiModifierAlt;
+	if ((mods & NSShiftKeyMask) != 0)
+		m |= uiModifierShift;
+	if ((mods & NSCommandKeyMask) != 0)
+		m |= uiModifierSuper;
+	return m;
+}
+
+- (void)setupNewTrackingArea
+{
+	self->libui_ta = [[NSTrackingArea alloc] initWithRect:[self bounds]
+		options:(NSTrackingMouseEnteredAndExited |
+			NSTrackingMouseMoved |
+			NSTrackingActiveAlways |
+			NSTrackingInVisibleRect |
+			NSTrackingEnabledDuringMouseDrag)
+		owner:self
+		userInfo:nil];
+	[self addTrackingArea:self->libui_ta];
+}
+
+- (void)updateTrackingAreas
+{
+	[self removeTrackingArea:self->libui_ta];
+	[self->libui_ta release];
+	[self setupNewTrackingArea];
+}
+
+// capture on drag is done automatically on OS X
+- (void)doMouseEvent:(NSEvent *)e
+{
+	uiArea *a = self->libui_a;
+	uiAreaMouseEvent me;
+	NSPoint point;
+	int buttonNumber;
+	NSUInteger pmb;
+	unsigned int i, max;
+
+	// this will convert point to drawing space
+	// thanks swillits in irc.freenode.net/#macdev
+	point = [self convertPoint:[e locationInWindow] fromView:nil];
+	me.X = point.x;
+	me.Y = point.y;
+
+	me.AreaWidth = 0;
+	me.AreaHeight = 0;
+	if (!a->scrolling) {
+		me.AreaWidth = [self frame].size.width;
+		me.AreaHeight = [self frame].size.height;
+	}
+
+	buttonNumber = [e buttonNumber] + 1;
+	// swap button numbers 2 and 3 (right and middle)
+	if (buttonNumber == 2)
+		buttonNumber = 3;
+	else if (buttonNumber == 3)
+		buttonNumber = 2;
+
+	me.Down = 0;
+	me.Up = 0;
+	me.Count = 0;
+	switch ([e type]) {
+	case NSLeftMouseDown:
+	case NSRightMouseDown:
+	case NSOtherMouseDown:
+		me.Down = buttonNumber;
+		me.Count = [e clickCount];
+		break;
+	case NSLeftMouseUp:
+	case NSRightMouseUp:
+	case NSOtherMouseUp:
+		me.Up = buttonNumber;
+		break;
+	case NSLeftMouseDragged:
+	case NSRightMouseDragged:
+	case NSOtherMouseDragged:
+		// we include the button that triggered the dragged event in the Held fields
+		buttonNumber = 0;
+		break;
+	}
+
+	me.Modifiers = [self parseModifiers:e];
+
+	pmb = [NSEvent pressedMouseButtons];
+	me.Held1To64 = 0;
+	if (buttonNumber != 1 && (pmb & 1) != 0)
+		me.Held1To64 |= 1;
+	if (buttonNumber != 2 && (pmb & 4) != 0)
+		me.Held1To64 |= 2;
+	if (buttonNumber != 3 && (pmb & 2) != 0)
+		me.Held1To64 |= 4;
+	// buttons 4..32
+	// https://developer.apple.com/library/mac/documentation/Carbon/Reference/QuartzEventServicesRef/index.html#//apple_ref/c/tdef/CGMouseButton says Quartz only supports up to 32 buttons
+	max = 32;
+	for (i = 4; i <= max; i++) {
+		uint64_t j;
+
+		if (buttonNumber == i)
+			continue;
+		j = 1 << (i - 1);
+		if ((pmb & j) != 0)
+			me.Held1To64 |= j;
+	}
+
+	if (self->libui_enabled) {
+		// and allow dragging here
+		a->dragevent = e;
+		(*(a->ah->MouseEvent))(a->ah, a, &me);
+		a->dragevent = nil;
+	}
+}
+
+#define mouseEvent(name) \
+	- (void)name:(NSEvent *)e \
+	{ \
+		[self doMouseEvent:e]; \
+	}
+mouseEvent(mouseMoved)
+mouseEvent(mouseDragged)
+mouseEvent(rightMouseDragged)
+mouseEvent(otherMouseDragged)
+mouseEvent(mouseDown)
+mouseEvent(rightMouseDown)
+mouseEvent(otherMouseDown)
+mouseEvent(mouseUp)
+mouseEvent(rightMouseUp)
+mouseEvent(otherMouseUp)
+
+- (void)mouseEntered:(NSEvent *)e
+{
+	uiArea *a = self->libui_a;
+
+	if (self->libui_enabled)
+		(*(a->ah->MouseCrossed))(a->ah, a, 0);
+}
+
+- (void)mouseExited:(NSEvent *)e
+{
+	uiArea *a = self->libui_a;
+
+	if (self->libui_enabled)
+		(*(a->ah->MouseCrossed))(a->ah, a, 1);
+}
+
+// note: there is no equivalent to WM_CAPTURECHANGED on Mac OS X; there literally is no way to break a grab like that
+// even if I invoke the task switcher and switch processes, the mouse grab will still be held until I let go of all buttons
+// therefore, no DragBroken()
+
+- (int)sendKeyEvent:(uiAreaKeyEvent *)ke
+{
+	uiArea *a = self->libui_a;
+
+	return (*(a->ah->KeyEvent))(a->ah, a, ke);
+}
+
+- (int)doKeyDownUp:(NSEvent *)e up:(int)up
+{
+	uiAreaKeyEvent ke;
+
+	ke.Key = 0;
+	ke.ExtKey = 0;
+	ke.Modifier = 0;
+
+	ke.Modifiers = [self parseModifiers:e];
+
+	ke.Up = up;
+
+	if (!fromKeycode([e keyCode], &ke))
+		return 0;
+	return [self sendKeyEvent:&ke];
+}
+
+- (int)doKeyDown:(NSEvent *)e
+{
+	return [self doKeyDownUp:e up:0];
+}
+
+- (int)doKeyUp:(NSEvent *)e
+{
+	return [self doKeyDownUp:e up:1];
+}
+
+- (int)doFlagsChanged:(NSEvent *)e
+{
+	uiAreaKeyEvent ke;
+	uiModifiers whichmod;
+
+	ke.Key = 0;
+	ke.ExtKey = 0;
+
+	// Mac OS X sends this event on both key up and key down.
+	// Fortunately -[e keyCode] IS valid here, so we can simply map from key code to Modifiers, get the value of [e modifierFlags], and check if the respective bit is set or not — that will give us the up/down state
+	if (!keycodeModifier([e keyCode], &whichmod))
+		return 0;
+	ke.Modifier = whichmod;
+	ke.Modifiers = [self parseModifiers:e];
+	ke.Up = (ke.Modifiers & ke.Modifier) == 0;
+	// and then drop the current modifier from Modifiers
+	ke.Modifiers &= ~ke.Modifier;
+	return [self sendKeyEvent:&ke];
+}
+
+- (void)setFrameSize:(NSSize)size
+{
+	uiArea *a = self->libui_a;
+
+	[super setFrameSize:size];
+	if (!a->scrolling)
+		// we must redraw everything on resize because Windows requires it
+		[self setNeedsDisplay:YES];
+}
+
+// TODO does this update the frame?
+- (void)setScrollingSize:(NSSize)s
+{
+	self->libui_ss = s;
+	[self invalidateIntrinsicContentSize];
+}
+
+- (NSSize)intrinsicContentSize
+{
+	if (!self->libui_a->scrolling)
+		return [super intrinsicContentSize];
+	return self->libui_ss;
+}
+
+- (BOOL)becomeFirstResponder
+{
+	return [self isEnabled];
+}
+
+- (BOOL)isEnabled
+{
+	return self->libui_enabled;
+}
+
+- (void)setEnabled:(BOOL)e
+{
+	self->libui_enabled = e;
+	if (!self->libui_enabled && [self window] != nil)
+		if ([[self window] firstResponder] == self)
+			[[self window] makeFirstResponder:nil];
+}
+
+@end
+
+uiDarwinControlAllDefaultsExceptDestroy(uiArea, view)
+
+static void uiAreaDestroy(uiControl *c)
+{
+	uiArea *a = uiArea(c);
+
+	if (a->scrolling)
+		scrollViewFreeData(a->sv, a->d);
+	[a->area release];
+	if (a->scrolling)
+		[a->sv release];
+	uiFreeControl(uiControl(a));
+}
+
+// called by subclasses of -[NSApplication sendEvent:]
+// by default, NSApplication eats some key events
+// this prevents that from happening with uiArea
+// see http://stackoverflow.com/questions/24099063/how-do-i-detect-keyup-in-my-nsview-with-the-command-key-held and http://lists.apple.com/archives/cocoa-dev/2003/Oct/msg00442.html
+int sendAreaEvents(NSEvent *e)
+{
+	NSEventType type;
+	id focused;
+	areaView *view;
+
+	type = [e type];
+	if (type != NSKeyDown && type != NSKeyUp && type != NSFlagsChanged)
+		return 0;
+	focused = [[e window] firstResponder];
+	if (focused == nil)
+		return 0;
+	if (![focused isKindOfClass:[areaView class]])
+		return 0;
+	view = (areaView *) focused;
+	switch (type) {
+	case NSKeyDown:
+		return [view doKeyDown:e];
+	case NSKeyUp:
+		return [view doKeyUp:e];
+	case NSFlagsChanged:
+		return [view doFlagsChanged:e];
+	}
+	return 0;
+}
+
+void uiAreaSetSize(uiArea *a, int width, int height)
+{
+	if (!a->scrolling)
+		userbug("You cannot call uiAreaSetSize() on a non-scrolling uiArea. (area: %p)", a);
+	[a->area setScrollingSize:NSMakeSize(width, height)];
+}
+
+void uiAreaQueueRedrawAll(uiArea *a)
+{
+	[a->area setNeedsDisplay:YES];
+}
+
+void uiAreaScrollTo(uiArea *a, double x, double y, double width, double height)
+{
+	if (!a->scrolling)
+		userbug("You cannot call uiAreaScrollTo() on a non-scrolling uiArea. (area: %p)", a);
+	[a->area scrollRectToVisible:NSMakeRect(x, y, width, height)];
+	// don't worry about the return value; it just says whether scrolling was needed
+}
+
+void uiAreaBeginUserWindowMove(uiArea *a)
+{
+	libuiNSWindow *w;
+
+	w = (libuiNSWindow *) [a->area window];
+	if (w == nil)
+		return;		// TODO
+	if (a->dragevent == nil)
+		return;		// TODO
+	[w libui_doMove:a->dragevent];
+}
+
+void uiAreaBeginUserWindowResize(uiArea *a, uiWindowResizeEdge edge)
+{
+	libuiNSWindow *w;
+
+	w = (libuiNSWindow *) [a->area window];
+	if (w == nil)
+		return;		// TODO
+	if (a->dragevent == nil)
+		return;		// TODO
+	[w libui_doResize:a->dragevent on:edge];
+}
+
+uiArea *uiNewArea(uiAreaHandler *ah)
+{
+	uiArea *a;
+
+	uiDarwinNewControl(uiArea, a);
+
+	a->ah = ah;
+	a->scrolling = NO;
+
+	a->area = [[areaView alloc] initWithFrame:NSZeroRect area:a];
+
+	a->view = a->area;
+
+	return a;
+}
+
+uiArea *uiNewScrollingArea(uiAreaHandler *ah, int width, int height)
+{
+	uiArea *a;
+	struct scrollViewCreateParams p;
+
+	uiDarwinNewControl(uiArea, a);
+
+	a->ah = ah;
+	a->scrolling = YES;
+
+	a->area = [[areaView alloc] initWithFrame:NSMakeRect(0, 0, width, height)
+		area:a];
+
+	memset(&p, 0, sizeof (struct scrollViewCreateParams));
+	p.DocumentView = a->area;
+	p.BackgroundColor = [NSColor controlColor];
+	p.DrawsBackground = 1;
+	p.Bordered = NO;
+	p.HScroll = YES;
+	p.VScroll = YES;
+	a->sv = mkScrollView(&p, &(a->d));
+
+	a->view = a->sv;
+
+	return a;
+}
diff --git a/src/libui_sdl/libui/darwin/areaevents.m b/src/libui_sdl/libui/darwin/areaevents.m
new file mode 100644
index 0000000..d7ceaaa
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/areaevents.m
@@ -0,0 +1,159 @@
+// 30 march 2014
+#import "uipriv_darwin.h"
+
+/*
+Mac OS X uses its own set of hardware key codes that are different from PC keyboard scancodes, but are positional (like PC keyboard scancodes). These are defined in <HIToolbox/Events.h>, a Carbon header. As far as I can tell, there's no way to include this header without either using an absolute path or linking Carbon into the program, so the constant values are used here instead.
+
+The Cocoa docs do guarantee that -[NSEvent keyCode] results in key codes that are the same as those returned by Carbon; that is, these codes.
+*/
+
+// use uintptr_t to be safe
+static const struct {
+	uintptr_t keycode;
+	char equiv;
+} keycodeKeys[] = {
+	{ 0x00, 'a' },
+	{ 0x01, 's' },
+	{ 0x02, 'd' },
+	{ 0x03, 'f' },
+	{ 0x04, 'h' },
+	{ 0x05, 'g' },
+	{ 0x06, 'z' },
+	{ 0x07, 'x' },
+	{ 0x08, 'c' },
+	{ 0x09, 'v' },
+	{ 0x0B, 'b' },
+	{ 0x0C, 'q' },
+	{ 0x0D, 'w' },
+	{ 0x0E, 'e' },
+	{ 0x0F, 'r' },
+	{ 0x10, 'y' },
+	{ 0x11, 't' },
+	{ 0x12, '1' },
+	{ 0x13, '2' },
+	{ 0x14, '3' },
+	{ 0x15, '4' },
+	{ 0x16, '6' },
+	{ 0x17, '5' },
+	{ 0x18, '=' },
+	{ 0x19, '9' },
+	{ 0x1A, '7' },
+	{ 0x1B, '-' },
+	{ 0x1C, '8' },
+	{ 0x1D, '0' },
+	{ 0x1E, ']' },
+	{ 0x1F, 'o' },
+	{ 0x20, 'u' },
+	{ 0x21, '[' },
+	{ 0x22, 'i' },
+	{ 0x23, 'p' },
+	{ 0x25, 'l' },
+	{ 0x26, 'j' },
+	{ 0x27, '\'' },
+	{ 0x28, 'k' },
+	{ 0x29, ';' },
+	{ 0x2A, '\\' },
+	{ 0x2B, ',' },
+	{ 0x2C, '/' },
+	{ 0x2D, 'n' },
+	{ 0x2E, 'm' },
+	{ 0x2F, '.' },
+	{ 0x32, '`' },
+	{ 0x24, '\n' },
+	{ 0x30, '\t' },
+	{ 0x31, ' ' },
+	{ 0x33, '\b' },
+	{ 0xFFFF, 0 },
+};
+
+static const struct {
+	uintptr_t keycode;
+	uiExtKey equiv;
+} keycodeExtKeys[] = {
+	{ 0x41, uiExtKeyNDot },
+	{ 0x43, uiExtKeyNMultiply },
+	{ 0x45, uiExtKeyNAdd },
+	{ 0x4B, uiExtKeyNDivide },
+	{ 0x4C, uiExtKeyNEnter },
+	{ 0x4E, uiExtKeyNSubtract },
+	{ 0x52, uiExtKeyN0 },
+	{ 0x53, uiExtKeyN1 },
+	{ 0x54, uiExtKeyN2 },
+	{ 0x55, uiExtKeyN3 },
+	{ 0x56, uiExtKeyN4 },
+	{ 0x57, uiExtKeyN5 },
+	{ 0x58, uiExtKeyN6 },
+	{ 0x59, uiExtKeyN7 },
+	{ 0x5B, uiExtKeyN8 },
+	{ 0x5C, uiExtKeyN9 },
+	{ 0x35, uiExtKeyEscape },
+	{ 0x60, uiExtKeyF5 },
+	{ 0x61, uiExtKeyF6 },
+	{ 0x62, uiExtKeyF7 },
+	{ 0x63, uiExtKeyF3 },
+	{ 0x64, uiExtKeyF8 },
+	{ 0x65, uiExtKeyF9 },
+	{ 0x67, uiExtKeyF11 },
+	{ 0x6D, uiExtKeyF10 },
+	{ 0x6F, uiExtKeyF12 },
+	{ 0x72, uiExtKeyInsert },		// listed as the Help key but it's in the same position on an Apple keyboard as the Insert key on a Windows keyboard; thanks to SeanieB from irc.badnik.net and Psy in irc.freenode.net/#macdev for confirming they have the same code
+	{ 0x73, uiExtKeyHome },
+	{ 0x74, uiExtKeyPageUp },
+	{ 0x75, uiExtKeyDelete },
+	{ 0x76, uiExtKeyF4 },
+	{ 0x77, uiExtKeyEnd },
+	{ 0x78, uiExtKeyF2 },
+	{ 0x79, uiExtKeyPageDown },
+	{ 0x7A, uiExtKeyF1 },
+	{ 0x7B, uiExtKeyLeft },
+	{ 0x7C, uiExtKeyRight },
+	{ 0x7D, uiExtKeyDown },
+	{ 0x7E, uiExtKeyUp },
+	{ 0xFFFF, 0 },
+};
+
+static const struct {
+	uintptr_t keycode;
+	uiModifiers equiv;
+} keycodeModifiers[] = {
+	{ 0x37, uiModifierSuper },		// left command
+	{ 0x38, uiModifierShift },		// left shift
+	{ 0x3A, uiModifierAlt },		// left option
+	{ 0x3B, uiModifierCtrl },		// left control
+	{ 0x3C, uiModifierShift },		// right shift
+	{ 0x3D, uiModifierAlt },		// right alt
+	{ 0x3E, uiModifierCtrl },		// right control
+	// the following is not in Events.h for some reason
+	// thanks to Nicole and jedivulcan from irc.badnik.net
+	{ 0x36, uiModifierSuper },		// right command
+	{ 0xFFFF, 0 },
+};
+
+BOOL fromKeycode(unsigned short keycode, uiAreaKeyEvent *ke)
+{
+	int i;
+
+	for (i = 0; keycodeKeys[i].keycode != 0xFFFF; i++)
+		if (keycodeKeys[i].keycode == keycode) {
+			ke->Key = keycodeKeys[i].equiv;
+			return YES;
+		}
+	for (i = 0; keycodeExtKeys[i].keycode != 0xFFFF; i++)
+		if (keycodeExtKeys[i].keycode == keycode) {
+			ke->ExtKey = keycodeExtKeys[i].equiv;
+			return YES;
+		}
+	return NO;
+}
+
+BOOL keycodeModifier(unsigned short keycode, uiModifiers *mod)
+{
+	int i;
+
+	for (i = 0; keycodeModifiers[i].keycode != 0xFFFF; i++)
+		if (keycodeModifiers[i].keycode == keycode) {
+			*mod = keycodeModifiers[i].equiv;
+			return YES;
+		}
+	return NO;
+}
diff --git a/src/libui_sdl/libui/darwin/autolayout.m b/src/libui_sdl/libui/darwin/autolayout.m
new file mode 100644
index 0000000..9964155
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/autolayout.m
@@ -0,0 +1,161 @@
+// 15 august 2015
+#import "uipriv_darwin.h"
+
+NSLayoutConstraint *mkConstraint(id view1, NSLayoutAttribute attr1, NSLayoutRelation relation, id view2, NSLayoutAttribute attr2, CGFloat multiplier, CGFloat c, NSString *desc)
+{
+	NSLayoutConstraint *constraint;
+
+	constraint = [NSLayoutConstraint constraintWithItem:view1
+		attribute:attr1
+		relatedBy:relation
+		toItem:view2
+		attribute:attr2
+		multiplier:multiplier
+		constant:c];
+	// apparently only added in 10.9
+	if ([constraint respondsToSelector:@selector(setIdentifier:)])
+		[((id) constraint) setIdentifier:desc];
+	return constraint;
+}
+
+CGFloat uiDarwinMarginAmount(void *reserved)
+{
+	return 20.0;
+}
+
+CGFloat uiDarwinPaddingAmount(void *reserved)
+{
+	return 8.0;
+}
+
+// this is needed for NSSplitView to work properly; see http://stackoverflow.com/questions/34574478/how-can-i-set-the-position-of-a-nssplitview-nowadays-setpositionofdivideratind (stal in irc.freenode.net/#macdev came up with the exact combination)
+// turns out it also works on NSTabView and NSBox too, possibly others!
+// and for bonus points, it even seems to fix unsatisfiable-constraint-autoresizing-mask issues with NSTabView and NSBox too!!! this is nuts
+void jiggleViewLayout(NSView *view)
+{
+	[view setNeedsLayout:YES];
+	[view layoutSubtreeIfNeeded];
+}
+
+static CGFloat margins(int margined)
+{
+	if (!margined)
+		return 0.0;
+	return uiDarwinMarginAmount(NULL);
+}
+
+void singleChildConstraintsEstablish(struct singleChildConstraints *c, NSView *contentView, NSView *childView, BOOL hugsTrailing, BOOL hugsBottom, int margined, NSString *desc)
+{
+	CGFloat margin;
+
+	margin = margins(margined);
+
+	c->leadingConstraint = mkConstraint(contentView, NSLayoutAttributeLeading,
+		NSLayoutRelationEqual,
+		childView, NSLayoutAttributeLeading,
+		1, -margin,
+		[desc stringByAppendingString:@" leading constraint"]);
+	[contentView addConstraint:c->leadingConstraint];
+	[c->leadingConstraint retain];
+
+	c->topConstraint = mkConstraint(contentView, NSLayoutAttributeTop,
+		NSLayoutRelationEqual,
+		childView, NSLayoutAttributeTop,
+		1, -margin,
+		[desc stringByAppendingString:@" top constraint"]);
+	[contentView addConstraint:c->topConstraint];
+	[c->topConstraint retain];
+
+	c->trailingConstraintGreater = mkConstraint(contentView, NSLayoutAttributeTrailing,
+		NSLayoutRelationGreaterThanOrEqual,
+		childView, NSLayoutAttributeTrailing,
+		1, margin,
+		[desc stringByAppendingString:@" trailing >= constraint"]);
+	if (hugsTrailing)
+		[c->trailingConstraintGreater setPriority:NSLayoutPriorityDefaultLow];
+	[contentView addConstraint:c->trailingConstraintGreater];
+	[c->trailingConstraintGreater retain];
+
+	c->trailingConstraintEqual = mkConstraint(contentView, NSLayoutAttributeTrailing,
+		NSLayoutRelationEqual,
+		childView, NSLayoutAttributeTrailing,
+		1, margin,
+		[desc stringByAppendingString:@" trailing == constraint"]);
+	if (!hugsTrailing)
+		[c->trailingConstraintEqual setPriority:NSLayoutPriorityDefaultLow];
+	[contentView addConstraint:c->trailingConstraintEqual];
+	[c->trailingConstraintEqual retain];
+
+	c->bottomConstraintGreater = mkConstraint(contentView, NSLayoutAttributeBottom,
+		NSLayoutRelationGreaterThanOrEqual,
+		childView, NSLayoutAttributeBottom,
+		1, margin,
+		[desc stringByAppendingString:@" bottom >= constraint"]);
+	if (hugsBottom)
+		[c->bottomConstraintGreater setPriority:NSLayoutPriorityDefaultLow];
+	[contentView addConstraint:c->bottomConstraintGreater];
+	[c->bottomConstraintGreater retain];
+
+	c->bottomConstraintEqual = mkConstraint(contentView, NSLayoutAttributeBottom,
+		NSLayoutRelationEqual,
+		childView, NSLayoutAttributeBottom,
+		1, margin,
+		[desc stringByAppendingString:@" bottom == constraint"]);
+	if (!hugsBottom)
+		[c->bottomConstraintEqual setPriority:NSLayoutPriorityDefaultLow];
+	[contentView addConstraint:c->bottomConstraintEqual];
+	[c->bottomConstraintEqual retain];
+}
+
+void singleChildConstraintsRemove(struct singleChildConstraints *c, NSView *cv)
+{
+	if (c->leadingConstraint != nil) {
+		[cv removeConstraint:c->leadingConstraint];
+		[c->leadingConstraint release];
+		c->leadingConstraint = nil;
+	}
+	if (c->topConstraint != nil) {
+		[cv removeConstraint:c->topConstraint];
+		[c->topConstraint release];
+		c->topConstraint = nil;
+	}
+	if (c->trailingConstraintGreater != nil) {
+		[cv removeConstraint:c->trailingConstraintGreater];
+		[c->trailingConstraintGreater release];
+		c->trailingConstraintGreater = nil;
+	}
+	if (c->trailingConstraintEqual != nil) {
+		[cv removeConstraint:c->trailingConstraintEqual];
+		[c->trailingConstraintEqual release];
+		c->trailingConstraintEqual = nil;
+	}
+	if (c->bottomConstraintGreater != nil) {
+		[cv removeConstraint:c->bottomConstraintGreater];
+		[c->bottomConstraintGreater release];
+		c->bottomConstraintGreater = nil;
+	}
+	if (c->bottomConstraintEqual != nil) {
+		[cv removeConstraint:c->bottomConstraintEqual];
+		[c->bottomConstraintEqual release];
+		c->bottomConstraintEqual = nil;
+	}
+}
+
+void singleChildConstraintsSetMargined(struct singleChildConstraints *c, int margined)
+{
+	CGFloat margin;
+
+	margin = margins(margined);
+	if (c->leadingConstraint != nil)
+		[c->leadingConstraint setConstant:-margin];
+	if (c->topConstraint != nil)
+		[c->topConstraint setConstant:-margin];
+	if (c->trailingConstraintGreater != nil)
+		[c->trailingConstraintGreater setConstant:margin];
+	if (c->trailingConstraintEqual != nil)
+		[c->trailingConstraintEqual setConstant:margin];
+	if (c->bottomConstraintGreater != nil)
+		[c->bottomConstraintGreater setConstant:margin];
+	if (c->bottomConstraintEqual != nil)
+		[c->bottomConstraintEqual setConstant:margin];
+}
diff --git a/src/libui_sdl/libui/darwin/box.m b/src/libui_sdl/libui/darwin/box.m
new file mode 100644
index 0000000..18d536d
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/box.m
@@ -0,0 +1,469 @@
+// 15 august 2015
+#import "uipriv_darwin.h"
+
+// TODO hiding all stretchy controls still hugs trailing edge
+
+@interface boxChild : NSObject
+@property uiControl *c;
+@property BOOL stretchy;
+@property NSLayoutPriority oldPrimaryHuggingPri;
+@property NSLayoutPriority oldSecondaryHuggingPri;
+- (NSView *)view;
+@end
+
+@interface boxView : NSView {
+	uiBox *b;
+	NSMutableArray *children;
+	BOOL vertical;
+	int padded;
+
+	NSLayoutConstraint *first;
+	NSMutableArray *inBetweens;
+	NSLayoutConstraint *last;
+	NSMutableArray *otherConstraints;
+
+	NSLayoutAttribute primaryStart;
+	NSLayoutAttribute primaryEnd;
+	NSLayoutAttribute secondaryStart;
+	NSLayoutAttribute secondaryEnd;
+	NSLayoutAttribute primarySize;
+	NSLayoutConstraintOrientation primaryOrientation;
+	NSLayoutConstraintOrientation secondaryOrientation;
+}
+- (id)initWithVertical:(BOOL)vert b:(uiBox *)bb;
+- (void)onDestroy;
+- (void)removeOurConstraints;
+- (void)syncEnableStates:(int)enabled;
+- (CGFloat)paddingAmount;
+- (void)establishOurConstraints;
+- (void)append:(uiControl *)c stretchy:(int)stretchy;
+- (void)delete:(int)n;
+- (int)isPadded;
+- (void)setPadded:(int)p;
+- (BOOL)hugsTrailing;
+- (BOOL)hugsBottom;
+- (int)nStretchy;
+@end
+
+struct uiBox {
+	uiDarwinControl c;
+	boxView *view;
+};
+
+@implementation boxChild
+
+- (NSView *)view
+{
+	return (NSView *) uiControlHandle(self.c);
+}
+
+@end
+
+@implementation boxView
+
+- (id)initWithVertical:(BOOL)vert b:(uiBox *)bb
+{
+	self = [super initWithFrame:NSZeroRect];
+	if (self != nil) {
+		// the weird names vert and bb are to shut the compiler up about shadowing because implicit this/self is stupid
+		self->b = bb;
+		self->vertical = vert;
+		self->padded = 0;
+		self->children = [NSMutableArray new];
+
+		self->inBetweens = [NSMutableArray new];
+		self->otherConstraints = [NSMutableArray new];
+
+		if (self->vertical) {
+			self->primaryStart = NSLayoutAttributeTop;
+			self->primaryEnd = NSLayoutAttributeBottom;
+			self->secondaryStart = NSLayoutAttributeLeading;
+			self->secondaryEnd = NSLayoutAttributeTrailing;
+			self->primarySize = NSLayoutAttributeHeight;
+			self->primaryOrientation = NSLayoutConstraintOrientationVertical;
+			self->secondaryOrientation = NSLayoutConstraintOrientationHorizontal;
+		} else {
+			self->primaryStart = NSLayoutAttributeLeading;
+			self->primaryEnd = NSLayoutAttributeTrailing;
+			self->secondaryStart = NSLayoutAttributeTop;
+			self->secondaryEnd = NSLayoutAttributeBottom;
+			self->primarySize = NSLayoutAttributeWidth;
+			self->primaryOrientation = NSLayoutConstraintOrientationHorizontal;
+			self->secondaryOrientation = NSLayoutConstraintOrientationVertical;
+		}
+	}
+	return self;
+}
+
+- (void)onDestroy
+{
+	boxChild *bc;
+
+	[self removeOurConstraints];
+	[self->inBetweens release];
+	[self->otherConstraints release];
+
+	for (bc in self->children) {
+		uiControlSetParent(bc.c, NULL);
+		uiDarwinControlSetSuperview(uiDarwinControl(bc.c), nil);
+		uiControlDestroy(bc.c);
+	}
+	[self->children release];
+}
+
+- (void)removeOurConstraints
+{
+	if (self->first != nil) {
+		[self removeConstraint:self->first];
+		[self->first release];
+		self->first = nil;
+	}
+	if ([self->inBetweens count] != 0) {
+		[self removeConstraints:self->inBetweens];
+		[self->inBetweens removeAllObjects];
+	}
+	if (self->last != nil) {
+		[self removeConstraint:self->last];
+		[self->last release];
+		self->last = nil;
+	}
+	if ([self->otherConstraints count] != 0) {
+		[self removeConstraints:self->otherConstraints];
+		[self->otherConstraints removeAllObjects];
+	}
+}
+
+- (void)syncEnableStates:(int)enabled
+{
+	boxChild *bc;
+
+	for (bc in self->children)
+		uiDarwinControlSyncEnableState(uiDarwinControl(bc.c), enabled);
+}
+
+- (CGFloat)paddingAmount
+{
+	if (!self->padded)
+		return 0.0;
+	return uiDarwinPaddingAmount(NULL);
+}
+
+- (void)establishOurConstraints
+{
+	boxChild *bc;
+	CGFloat padding;
+	NSView *prev;
+	NSLayoutConstraint *c;
+	BOOL (*hugsSecondary)(uiDarwinControl *);
+
+	[self removeOurConstraints];
+	if ([self->children count] == 0)
+		return;
+	padding = [self paddingAmount];
+
+	// first arrange in the primary direction
+	prev = nil;
+	for (bc in self->children) {
+		if (!uiControlVisible(bc.c))
+			continue;
+		if (prev == nil) {			// first view
+			self->first = mkConstraint(self, self->primaryStart,
+				NSLayoutRelationEqual,
+				[bc view], self->primaryStart,
+				1, 0,
+				@"uiBox first primary constraint");
+			[self addConstraint:self->first];
+			[self->first retain];
+			prev = [bc view];
+			continue;
+		}
+		// not the first; link it
+		c = mkConstraint(prev, self->primaryEnd,
+			NSLayoutRelationEqual,
+			[bc view], self->primaryStart,
+			1, -padding,
+			@"uiBox in-between primary constraint");
+		[self addConstraint:c];
+		[self->inBetweens addObject:c];
+		prev = [bc view];
+	}
+	if (prev == nil)		// no control visible; act as if no controls
+		return;
+	self->last = mkConstraint(prev, self->primaryEnd,
+		NSLayoutRelationEqual,
+		self, self->primaryEnd,
+		1, 0,
+		@"uiBox last primary constraint");
+	[self addConstraint:self->last];
+	[self->last retain];
+
+	// then arrange in the secondary direction
+	hugsSecondary = uiDarwinControlHugsTrailingEdge;
+	if (!self->vertical)
+		hugsSecondary = uiDarwinControlHugsBottom;
+	for (bc in self->children) {
+		if (!uiControlVisible(bc.c))
+			continue;
+		c = mkConstraint(self, self->secondaryStart,
+			NSLayoutRelationEqual,
+			[bc view], self->secondaryStart,
+			1, 0,
+			@"uiBox secondary start constraint");
+		[self addConstraint:c];
+		[self->otherConstraints addObject:c];
+		c = mkConstraint([bc view], self->secondaryEnd,
+			NSLayoutRelationLessThanOrEqual,
+			self, self->secondaryEnd,
+			1, 0,
+			@"uiBox secondary end <= constraint");
+		if ((*hugsSecondary)(uiDarwinControl(bc.c)))
+			[c setPriority:NSLayoutPriorityDefaultLow];
+		[self addConstraint:c];
+		[self->otherConstraints addObject:c];
+		c = mkConstraint([bc view], self->secondaryEnd,
+			NSLayoutRelationEqual,
+			self, self->secondaryEnd,
+			1, 0,
+			@"uiBox secondary end == constraint");
+		if (!(*hugsSecondary)(uiDarwinControl(bc.c)))
+			[c setPriority:NSLayoutPriorityDefaultLow];
+		[self addConstraint:c];
+		[self->otherConstraints addObject:c];
+	}
+
+	// and make all stretchy controls the same size
+	if ([self nStretchy] == 0)
+		return;
+	prev = nil;		// first stretchy view
+	for (bc in self->children) {
+		if (!uiControlVisible(bc.c))
+			continue;
+		if (!bc.stretchy)
+			continue;
+		if (prev == nil) {
+			prev = [bc view];
+			continue;
+		}
+		c = mkConstraint(prev, self->primarySize,
+			NSLayoutRelationEqual,
+			[bc view], self->primarySize,
+			1, 0,
+			@"uiBox stretchy size constraint");
+		[self addConstraint:c];
+		[self->otherConstraints addObject:c];
+	}
+}
+
+- (void)append:(uiControl *)c stretchy:(int)stretchy
+{
+	boxChild *bc;
+	NSLayoutPriority priority;
+	int oldnStretchy;
+
+	bc = [boxChild new];
+	bc.c = c;
+	bc.stretchy = stretchy;
+	bc.oldPrimaryHuggingPri = uiDarwinControlHuggingPriority(uiDarwinControl(bc.c), self->primaryOrientation);
+	bc.oldSecondaryHuggingPri = uiDarwinControlHuggingPriority(uiDarwinControl(bc.c), self->secondaryOrientation);
+
+	uiControlSetParent(bc.c, uiControl(self->b));
+	uiDarwinControlSetSuperview(uiDarwinControl(bc.c), self);
+	uiDarwinControlSyncEnableState(uiDarwinControl(bc.c), uiControlEnabledToUser(uiControl(self->b)));
+
+	// if a control is stretchy, it should not hug in the primary direction
+	// otherwise, it should *forcibly* hug
+	if (bc.stretchy)
+		priority = NSLayoutPriorityDefaultLow;
+	else
+		// LONGTERM will default high work?
+		priority = NSLayoutPriorityRequired;
+	uiDarwinControlSetHuggingPriority(uiDarwinControl(bc.c), priority, self->primaryOrientation);
+	// make sure controls don't hug their secondary direction so they fill the width of the view
+	uiDarwinControlSetHuggingPriority(uiDarwinControl(bc.c), NSLayoutPriorityDefaultLow, self->secondaryOrientation);
+
+	oldnStretchy = [self nStretchy];
+	[self->children addObject:bc];
+
+	[self establishOurConstraints];
+	if (bc.stretchy)
+		if (oldnStretchy == 0)
+			uiDarwinNotifyEdgeHuggingChanged(uiDarwinControl(self->b));
+
+	[bc release];		// we don't need the initial reference now
+}
+
+- (void)delete:(int)n
+{
+	boxChild *bc;
+	int stretchy;
+
+	bc = (boxChild *) [self->children objectAtIndex:n];
+	stretchy = bc.stretchy;
+
+	uiControlSetParent(bc.c, NULL);
+	uiDarwinControlSetSuperview(uiDarwinControl(bc.c), nil);
+
+	uiDarwinControlSetHuggingPriority(uiDarwinControl(bc.c), bc.oldPrimaryHuggingPri, self->primaryOrientation);
+	uiDarwinControlSetHuggingPriority(uiDarwinControl(bc.c), bc.oldSecondaryHuggingPri, self->secondaryOrientation);
+
+	[self->children removeObjectAtIndex:n];
+
+	[self establishOurConstraints];
+	if (stretchy)
+		if ([self nStretchy] == 0)
+			uiDarwinNotifyEdgeHuggingChanged(uiDarwinControl(self->b));
+}
+
+- (int)isPadded
+{
+	return self->padded;
+}
+
+- (void)setPadded:(int)p
+{
+	CGFloat padding;
+	NSLayoutConstraint *c;
+
+	self->padded = p;
+	padding = [self paddingAmount];
+	for (c in self->inBetweens)
+		[c setConstant:-padding];
+}
+
+- (BOOL)hugsTrailing
+{
+	if (self->vertical)		// always hug if vertical
+		return YES;
+	return [self nStretchy] != 0;
+}
+
+- (BOOL)hugsBottom
+{
+	if (!self->vertical)		// always hug if horizontal
+		return YES;
+	return [self nStretchy] != 0;
+}
+
+- (int)nStretchy
+{
+	boxChild *bc;
+	int n;
+
+	n = 0;
+	for (bc in self->children) {
+		if (!uiControlVisible(bc.c))
+			continue;
+		if (bc.stretchy)
+			n++;
+	}
+	return n;
+}
+
+@end
+
+static void uiBoxDestroy(uiControl *c)
+{
+	uiBox *b = uiBox(c);
+
+	[b->view onDestroy];
+	[b->view release];
+	uiFreeControl(uiControl(b));
+}
+
+uiDarwinControlDefaultHandle(uiBox, view)
+uiDarwinControlDefaultParent(uiBox, view)
+uiDarwinControlDefaultSetParent(uiBox, view)
+uiDarwinControlDefaultToplevel(uiBox, view)
+uiDarwinControlDefaultVisible(uiBox, view)
+uiDarwinControlDefaultShow(uiBox, view)
+uiDarwinControlDefaultHide(uiBox, view)
+uiDarwinControlDefaultEnabled(uiBox, view)
+uiDarwinControlDefaultEnable(uiBox, view)
+uiDarwinControlDefaultDisable(uiBox, view)
+
+static void uiBoxSyncEnableState(uiDarwinControl *c, int enabled)
+{
+	uiBox *b = uiBox(c);
+
+	if (uiDarwinShouldStopSyncEnableState(uiDarwinControl(b), enabled))
+		return;
+	[b->view syncEnableStates:enabled];
+}
+
+uiDarwinControlDefaultSetSuperview(uiBox, view)
+
+static BOOL uiBoxHugsTrailingEdge(uiDarwinControl *c)
+{
+	uiBox *b = uiBox(c);
+
+	return [b->view hugsTrailing];
+}
+
+static BOOL uiBoxHugsBottom(uiDarwinControl *c)
+{
+	uiBox *b = uiBox(c);
+
+	return [b->view hugsBottom];
+}
+
+static void uiBoxChildEdgeHuggingChanged(uiDarwinControl *c)
+{
+	uiBox *b = uiBox(c);
+
+	[b->view establishOurConstraints];
+}
+
+uiDarwinControlDefaultHuggingPriority(uiBox, view)
+uiDarwinControlDefaultSetHuggingPriority(uiBox, view)
+
+static void uiBoxChildVisibilityChanged(uiDarwinControl *c)
+{
+	uiBox *b = uiBox(c);
+
+	[b->view establishOurConstraints];
+}
+
+void uiBoxAppend(uiBox *b, uiControl *c, int stretchy)
+{
+	// LONGTERM on other platforms
+	// or at leat allow this and implicitly turn it into a spacer
+	if (c == NULL)
+		userbug("You cannot add NULL to a uiBox.");
+	[b->view append:c stretchy:stretchy];
+}
+
+void uiBoxDelete(uiBox *b, int n)
+{
+	[b->view delete:n];
+}
+
+int uiBoxPadded(uiBox *b)
+{
+	return [b->view isPadded];
+}
+
+void uiBoxSetPadded(uiBox *b, int padded)
+{
+	[b->view setPadded:padded];
+}
+
+static uiBox *finishNewBox(BOOL vertical)
+{
+	uiBox *b;
+
+	uiDarwinNewControl(uiBox, b);
+
+	b->view = [[boxView alloc] initWithVertical:vertical b:b];
+
+	return b;
+}
+
+uiBox *uiNewHorizontalBox(void)
+{
+	return finishNewBox(NO);
+}
+
+uiBox *uiNewVerticalBox(void)
+{
+	return finishNewBox(YES);
+}
diff --git a/src/libui_sdl/libui/darwin/button.m b/src/libui_sdl/libui/darwin/button.m
new file mode 100644
index 0000000..baccabb
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/button.m
@@ -0,0 +1,113 @@
+// 13 august 2015
+#import "uipriv_darwin.h"
+
+struct uiButton {
+	uiDarwinControl c;
+	NSButton *button;
+	void (*onClicked)(uiButton *, void *);
+	void *onClickedData;
+};
+
+@interface buttonDelegateClass : NSObject {
+	struct mapTable *buttons;
+}
+- (IBAction)onClicked:(id)sender;
+- (void)registerButton:(uiButton *)b;
+- (void)unregisterButton:(uiButton *)b;
+@end
+
+@implementation buttonDelegateClass
+
+- (id)init
+{
+	self = [super init];
+	if (self)
+		self->buttons = newMap();
+	return self;
+}
+
+- (void)dealloc
+{
+	mapDestroy(self->buttons);
+	[super dealloc];
+}
+
+- (IBAction)onClicked:(id)sender
+{
+	uiButton *b;
+
+	b = (uiButton *) mapGet(self->buttons, sender);
+	(*(b->onClicked))(b, b->onClickedData);
+}
+
+- (void)registerButton:(uiButton *)b
+{
+	mapSet(self->buttons, b->button, b);
+	[b->button setTarget:self];
+	[b->button setAction:@selector(onClicked:)];
+}
+
+- (void)unregisterButton:(uiButton *)b
+{
+	[b->button setTarget:nil];
+	mapDelete(self->buttons, b->button);
+}
+
+@end
+
+static buttonDelegateClass *buttonDelegate = nil;
+
+uiDarwinControlAllDefaultsExceptDestroy(uiButton, button)
+
+static void uiButtonDestroy(uiControl *c)
+{
+	uiButton *b = uiButton(c);
+
+	[buttonDelegate unregisterButton:b];
+	[b->button release];
+	uiFreeControl(uiControl(b));
+}
+
+char *uiButtonText(uiButton *b)
+{
+	return uiDarwinNSStringToText([b->button title]);
+}
+
+void uiButtonSetText(uiButton *b, const char *text)
+{
+	[b->button setTitle:toNSString(text)];
+}
+
+void uiButtonOnClicked(uiButton *b, void (*f)(uiButton *, void *), void *data)
+{
+	b->onClicked = f;
+	b->onClickedData = data;
+}
+
+static void defaultOnClicked(uiButton *b, void *data)
+{
+	// do nothing
+}
+
+uiButton *uiNewButton(const char *text)
+{
+	uiButton *b;
+
+	uiDarwinNewControl(uiButton, b);
+
+	b->button = [[NSButton alloc] initWithFrame:NSZeroRect];
+	[b->button setTitle:toNSString(text)];
+	[b->button setButtonType:NSMomentaryPushInButton];
+	[b->button setBordered:YES];
+	[b->button setBezelStyle:NSRoundedBezelStyle];
+	uiDarwinSetControlFont(b->button, NSRegularControlSize);
+
+	if (buttonDelegate == nil) {
+		buttonDelegate = [[buttonDelegateClass new] autorelease];
+		[delegates addObject:buttonDelegate];
+	}
+	[buttonDelegate registerButton:b];
+	uiButtonOnClicked(b, defaultOnClicked, NULL);
+
+	return b;
+}
diff --git a/src/libui_sdl/libui/darwin/checkbox.m b/src/libui_sdl/libui/darwin/checkbox.m
new file mode 100644
index 0000000..dd1ce09
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/checkbox.m
@@ -0,0 +1,129 @@
+// 14 august 2015
+#import "uipriv_darwin.h"
+
+struct uiCheckbox {
+	uiDarwinControl c;
+	NSButton *button;
+	void (*onToggled)(uiCheckbox *, void *);
+	void *onToggledData;
+};
+
+@interface checkboxDelegateClass : NSObject {
+	struct mapTable *buttons;
+}
+- (IBAction)onToggled:(id)sender;
+- (void)registerCheckbox:(uiCheckbox *)c;
+- (void)unregisterCheckbox:(uiCheckbox *)c;
+@end
+
+@implementation checkboxDelegateClass
+
+- (id)init
+{
+	self = [super init];
+	if (self)
+		self->buttons = newMap();
+	return self;
+}
+
+- (void)dealloc
+{
+	mapDestroy(self->buttons);
+	[super dealloc];
+}
+
+- (IBAction)onToggled:(id)sender
+{
+	uiCheckbox *c;
+
+	c = (uiCheckbox *) mapGet(self->buttons, sender);
+	(*(c->onToggled))(c, c->onToggledData);
+}
+
+- (void)registerCheckbox:(uiCheckbox *)c
+{
+	mapSet(self->buttons, c->button, c);
+	[c->button setTarget:self];
+	[c->button setAction:@selector(onToggled:)];
+}
+
+- (void)unregisterCheckbox:(uiCheckbox *)c
+{
+	[c->button setTarget:nil];
+	mapDelete(self->buttons, c->button);
+}
+
+@end
+
+static checkboxDelegateClass *checkboxDelegate = nil;
+
+uiDarwinControlAllDefaultsExceptDestroy(uiCheckbox, button)
+
+static void uiCheckboxDestroy(uiControl *cc)
+{
+	uiCheckbox *c = uiCheckbox(cc);
+
+	[checkboxDelegate unregisterCheckbox:c];
+	[c->button release];
+	uiFreeControl(uiControl(c));
+}
+
+char *uiCheckboxText(uiCheckbox *c)
+{
+	return uiDarwinNSStringToText([c->button title]);
+}
+
+void uiCheckboxSetText(uiCheckbox *c, const char *text)
+{
+	[c->button setTitle:toNSString(text)];
+}
+
+void uiCheckboxOnToggled(uiCheckbox *c, void (*f)(uiCheckbox *, void *), void *data)
+{
+	c->onToggled = f;
+	c->onToggledData = data;
+}
+
+int uiCheckboxChecked(uiCheckbox *c)
+{
+	return [c->button state] == NSOnState;
+}
+
+void uiCheckboxSetChecked(uiCheckbox *c, int checked)
+{
+	NSInteger state;
+
+	state = NSOnState;
+	if (!checked)
+		state = NSOffState;
+	[c->button setState:state];
+}
+
+static void defaultOnToggled(uiCheckbox *c, void *data)
+{
+	// do nothing
+}
+
+uiCheckbox *uiNewCheckbox(const char *text)
+{
+	uiCheckbox *c;
+
+	uiDarwinNewControl(uiCheckbox, c);
+
+	c->button = [[NSButton alloc] initWithFrame:NSZeroRect];
+	[c->button setTitle:toNSString(text)];
+	[c->button setButtonType:NSSwitchButton];
+	// doesn't seem to have an associated bezel style
+	[c->button setBordered:NO];
+	[c->button setTransparent:NO];
+	uiDarwinSetControlFont(c->button, NSRegularControlSize);
+
+	if (checkboxDelegate == nil) {
+		checkboxDelegate = [[checkboxDelegateClass new] autorelease];
+		[delegates addObject:checkboxDelegate];
+	}
+	[checkboxDelegate registerCheckbox:c];
+	uiCheckboxOnToggled(c, defaultOnToggled, NULL);
+
+	return c;
+}
diff --git a/src/libui_sdl/libui/darwin/colorbutton.m b/src/libui_sdl/libui/darwin/colorbutton.m
new file mode 100644
index 0000000..83b6157
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/colorbutton.m
@@ -0,0 +1,159 @@
+// 15 may 2016
+#import "uipriv_darwin.h"
+
+// TODO no intrinsic height?
+
+@interface colorButton : NSColorWell {
+	uiColorButton *libui_b;
+	BOOL libui_changing;
+	BOOL libui_setting;
+}
+- (id)initWithFrame:(NSRect)frame libuiColorButton:(uiColorButton *)b;
+- (void)deactivateOnClose:(NSNotification *)note;
+- (void)libuiColor:(double *)r g:(double *)g b:(double *)b a:(double *)a;
+- (void)libuiSetColor:(double)r g:(double)g b:(double)b a:(double)a;
+@end
+
+// only one may be active at one time
+static colorButton *activeColorButton = nil;
+
+struct uiColorButton {
+	uiDarwinControl c;
+	colorButton *button;
+	void (*onChanged)(uiColorButton *, void *);
+	void *onChangedData;
+};
+
+@implementation colorButton
+
+- (id)initWithFrame:(NSRect)frame libuiColorButton:(uiColorButton *)b
+{
+	self = [super initWithFrame:frame];
+	if (self) {
+		// the default color is white; set it to black first (see -setColor: below for why we do it first)
+		[self libuiSetColor:0.0 g:0.0 b:0.0 a:1.0];
+
+		self->libui_b = b;
+		self->libui_changing = NO;
+	}
+	return self;
+}
+
+- (void)activate:(BOOL)exclusive
+{
+	if (activeColorButton != nil)
+		activeColorButton->libui_changing = YES;
+	[NSColorPanel setPickerMask:NSColorPanelAllModesMask];
+	[[NSColorPanel sharedColorPanel] setShowsAlpha:YES];
+	[super activate:YES];
+	activeColorButton = self;
+	// see stddialogs.m for details
+	[[NSColorPanel sharedColorPanel] setWorksWhenModal:NO];
+	[[NSNotificationCenter defaultCenter] addObserver:self
+		selector:@selector(deactivateOnClose:)
+		name:NSWindowWillCloseNotification
+		object:[NSColorPanel sharedColorPanel]];
+}
+
+- (void)deactivate
+{
+	[super deactivate];
+	activeColorButton = nil;
+	if (!self->libui_changing)
+		[[NSColorPanel sharedColorPanel] orderOut:nil];
+	[[NSNotificationCenter defaultCenter] removeObserver:self
+		name:NSWindowWillCloseNotification
+		object:[NSColorPanel sharedColorPanel]];
+	self->libui_changing = NO;
+}
+
+- (void)deactivateOnClose:(NSNotification *)note
+{
+	[self deactivate];
+}
+
+- (void)setColor:(NSColor *)color
+{
+	uiColorButton *b = self->libui_b;
+
+	[super setColor:color];
+	// this is called by NSColorWell's init, so we have to guard
+	// also don't signal during a programmatic change
+	if (b != nil && !self->libui_setting)
+		(*(b->onChanged))(b, b->onChangedData);
+}
+
+- (void)libuiColor:(double *)r g:(double *)g b:(double *)b a:(double *)a
+{
+	NSColor *rgba;
+	CGFloat cr, cg, cb, ca;
+
+	// the given color may not be an RGBA color, which will cause the -getRed:green:blue:alpha: call to throw an exception
+	rgba = [[self color] colorUsingColorSpace:[NSColorSpace sRGBColorSpace]];
+	[rgba getRed:&cr green:&cg blue:&cb alpha:&ca];
+	*r = cr;
+	*g = cg;
+	*b = cb;
+	*a = ca;
+	// rgba will be autoreleased since it isn't a new or init call
+}
+
+- (void)libuiSetColor:(double)r g:(double)g b:(double)b a:(double)a
+{
+	self->libui_setting = YES;
+	[self setColor:[NSColor colorWithSRGBRed:r green:g blue:b alpha:a]];
+	self->libui_setting = NO;
+}
+
+// NSColorWell has no intrinsic size by default; give it the default Interface Builder size.
+- (NSSize)intrinsicContentSize
+{
+	return NSMakeSize(44, 23);
+}
+
+@end
+
+uiDarwinControlAllDefaults(uiColorButton, button)
+
+// we do not want color change events to be sent to any controls other than the color buttons
+// see main.m for more details
+BOOL colorButtonInhibitSendAction(SEL sel, id from, id to)
+{
+	if (sel != @selector(changeColor:))
+		return NO;
+	return ![to isKindOfClass:[colorButton class]];
+}
+
+static void defaultOnChanged(uiColorButton *b, void *data)
+{
+	// do nothing
+}
+
+void uiColorButtonColor(uiColorButton *b, double *r, double *g, double *bl, double *a)
+{
+	[b->button libuiColor:r g:g b:bl a:a];
+}
+
+void uiColorButtonSetColor(uiColorButton *b, double r, double g, double bl, double a)
+{
+	[b->button libuiSetColor:r g:g b:bl a:a];
+}
+
+void uiColorButtonOnChanged(uiColorButton *b, void (*f)(uiColorButton *, void *), void *data)
+{
+	b->onChanged = f;
+	b->onChangedData = data;
+}
+
+uiColorButton *uiNewColorButton(void)
+{
+	uiColorButton *b;
+
+	uiDarwinNewControl(uiColorButton, b);
+
+	b->button = [[colorButton alloc] initWithFrame:NSZeroRect libuiColorButton:b];
+
+	uiColorButtonOnChanged(b, defaultOnChanged, NULL);
+
+	return b;
+}
diff --git a/src/libui_sdl/libui/darwin/combobox.m b/src/libui_sdl/libui/darwin/combobox.m
new file mode 100644
index 0000000..89a2e28
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/combobox.m
@@ -0,0 +1,145 @@
+// 14 august 2015
+#import "uipriv_darwin.h"
+
+// NSComboBoxes have no intrinsic width; we'll use the default Interface Builder width for them.
+// NSPopUpButton is fine.
+#define comboboxWidth 96
+
+struct uiCombobox {
+	uiDarwinControl c;
+	NSPopUpButton *pb;
+	NSArrayController *pbac;
+	void (*onSelected)(uiCombobox *, void *);
+	void *onSelectedData;
+};
+
+@interface comboboxDelegateClass : NSObject {
+	struct mapTable *comboboxes;
+}
+- (IBAction)onSelected:(id)sender;
+- (void)registerCombobox:(uiCombobox *)c;
+- (void)unregisterCombobox:(uiCombobox *)c;
+@end
+
+@implementation comboboxDelegateClass
+
+- (id)init
+{
+	self = [super init];
+	if (self)
+		self->comboboxes = newMap();
+	return self;
+}
+
+- (void)dealloc
+{
+	mapDestroy(self->comboboxes);
+	[super dealloc];
+}
+
+- (IBAction)onSelected:(id)sender
+{
+	uiCombobox *c;
+
+	c = uiCombobox(mapGet(self->comboboxes, sender));
+	(*(c->onSelected))(c, c->onSelectedData);
+}
+
+- (void)registerCombobox:(uiCombobox *)c
+{
+	mapSet(self->comboboxes, c->pb, c);
+	[c->pb setTarget:self];
+	[c->pb setAction:@selector(onSelected:)];
+}
+
+- (void)unregisterCombobox:(uiCombobox *)c
+{
+	[c->pb setTarget:nil];
+	mapDelete(self->comboboxes, c->pb);
+}
+
+@end
+
+static comboboxDelegateClass *comboboxDelegate = nil;
+
+uiDarwinControlAllDefaultsExceptDestroy(uiCombobox, pb)
+
+static void uiComboboxDestroy(uiControl *cc)
+{
+	uiCombobox *c = uiCombobox(cc);
+
+	[comboboxDelegate unregisterCombobox:c];
+	[c->pb unbind:@"contentObjects"];
+	[c->pb unbind:@"selectedIndex"];
+	[c->pbac release];
+	[c->pb release];
+	uiFreeControl(uiControl(c));
+}
+
+void uiComboboxAppend(uiCombobox *c, const char *text)
+{
+	[c->pbac addObject:toNSString(text)];
+}
+
+int uiComboboxSelected(uiCombobox *c)
+{
+	return [c->pb indexOfSelectedItem];
+}
+
+void uiComboboxSetSelected(uiCombobox *c, int n)
+{
+	[c->pb selectItemAtIndex:n];
+}
+
+void uiComboboxOnSelected(uiCombobox *c, void (*f)(uiCombobox *c, void *data), void *data)
+{
+	c->onSelected = f;
+	c->onSelectedData = data;
+}
+
+static void defaultOnSelected(uiCombobox *c, void *data)
+{
+	// do nothing
+}
+
+uiCombobox *uiNewCombobox(void)
+{
+	uiCombobox *c;
+	NSPopUpButtonCell *pbcell;
+
+	uiDarwinNewControl(uiCombobox, c);
+
+	c->pb = [[NSPopUpButton alloc] initWithFrame:NSZeroRect pullsDown:NO];
+	[c->pb setPreferredEdge:NSMinYEdge];
+	pbcell = (NSPopUpButtonCell *) [c->pb cell];
+	[pbcell setArrowPosition:NSPopUpArrowAtBottom];
+	// the font defined by Interface Builder is Menu 13, which is lol
+	// just use the regular control size for consistency
+	uiDarwinSetControlFont(c->pb, NSRegularControlSize);
+
+	// NSPopUpButton doesn't work like a combobox
+	// - it automatically selects the first item
+	// - it doesn't support duplicates
+	// but we can use a NSArrayController and Cocoa bindings to bypass these restrictions
+	c->pbac = [NSArrayController new];
+	[c->pbac setAvoidsEmptySelection:NO];
+	[c->pbac setSelectsInsertedObjects:NO];
+	[c->pbac setAutomaticallyRearrangesObjects:NO];
+	[c->pb bind:@"contentValues"
+		toObject:c->pbac
+		withKeyPath:@"arrangedObjects"
+		options:nil];
+	[c->pb bind:@"selectedIndex"
+		toObject:c->pbac
+		withKeyPath:@"selectionIndex"
+		options:nil];
+
+	if (comboboxDelegate == nil) {
+		comboboxDelegate = [[comboboxDelegateClass new] autorelease];
+		[delegates addObject:comboboxDelegate];
+	}
+	[comboboxDelegate registerCombobox:c];
+	uiComboboxOnSelected(c, defaultOnSelected, NULL);
+
+	return c;
+}
diff --git a/src/libui_sdl/libui/darwin/control.m b/src/libui_sdl/libui/darwin/control.m
new file mode 100644
index 0000000..9eaf47a
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/control.m
@@ -0,0 +1,84 @@
+// 16 august 2015
+#import "uipriv_darwin.h"
+
+void uiDarwinControlSyncEnableState(uiDarwinControl *c, int state)
+{
+	(*(c->SyncEnableState))(c, state);
+}
+
+void uiDarwinControlSetSuperview(uiDarwinControl *c, NSView *superview)
+{
+	(*(c->SetSuperview))(c, superview);
+}
+
+BOOL uiDarwinControlHugsTrailingEdge(uiDarwinControl *c)
+{
+	return (*(c->HugsTrailingEdge))(c);
+}
+
+BOOL uiDarwinControlHugsBottom(uiDarwinControl *c)
+{
+	return (*(c->HugsBottom))(c);
+}
+
+void uiDarwinControlChildEdgeHuggingChanged(uiDarwinControl *c)
+{
+	(*(c->ChildEdgeHuggingChanged))(c);
+}
+
+NSLayoutPriority uiDarwinControlHuggingPriority(uiDarwinControl *c, NSLayoutConstraintOrientation orientation)
+{
+	return (*(c->HuggingPriority))(c, orientation);
+}
+
+void uiDarwinControlSetHuggingPriority(uiDarwinControl *c, NSLayoutPriority priority, NSLayoutConstraintOrientation orientation)
+{
+	(*(c->SetHuggingPriority))(c, priority, orientation);
+}
+
+void uiDarwinControlChildVisibilityChanged(uiDarwinControl *c)
+{
+	(*(c->ChildVisibilityChanged))(c);
+}
+
+void uiDarwinSetControlFont(NSControl *c, NSControlSize size)
+{
+	[c setFont:[NSFont systemFontOfSize:[NSFont systemFontSizeForControlSize:size]]];
+}
+
+#define uiDarwinControlSignature 0x44617277
+
+uiDarwinControl *uiDarwinAllocControl(size_t n, uint32_t typesig, const char *typenamestr)
+{
+	return uiDarwinControl(uiAllocControl(n, uiDarwinControlSignature, typesig, typenamestr));
+}
+
+BOOL uiDarwinShouldStopSyncEnableState(uiDarwinControl *c, BOOL enabled)
+{
+	int ce;
+
+	ce = uiControlEnabled(uiControl(c));
+	// only stop if we're going from disabled back to enabled; don't stop under any other condition
+	// (if we stop when going from enabled to disabled then enabled children of a disabled control won't get disabled at the OS level)
+	if (!ce && enabled)
+		return YES;
+	return NO;
+}
+
+void uiDarwinNotifyEdgeHuggingChanged(uiDarwinControl *c)
+{
+	uiControl *parent;
+
+	parent = uiControlParent(uiControl(c));
+	if (parent != NULL)
+		uiDarwinControlChildEdgeHuggingChanged(uiDarwinControl(parent));
+}
+
+void uiDarwinNotifyVisibilityChanged(uiDarwinControl *c)
+{
+	uiControl *parent;
+
+	parent = uiControlParent(uiControl(c));
+	if (parent != NULL)
+		uiDarwinControlChildVisibilityChanged(uiDarwinControl(parent));
+}
diff --git a/src/libui_sdl/libui/darwin/datetimepicker.m b/src/libui_sdl/libui/darwin/datetimepicker.m
new file mode 100644
index 0000000..44364d9
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/datetimepicker.m
@@ -0,0 +1,42 @@
+// 14 august 2015
+#import "uipriv_darwin.h"
+
+struct uiDateTimePicker {
+	uiDarwinControl c;
+	NSDatePicker *dp;
+};
+
+uiDarwinControlAllDefaults(uiDateTimePicker, dp)
+
+static uiDateTimePicker *finishNewDateTimePicker(NSDatePickerElementFlags elements)
+{
+	uiDateTimePicker *d;
+
+	uiDarwinNewControl(uiDateTimePicker, d);
+
+	d->dp = [[NSDatePicker alloc] initWithFrame:NSZeroRect];
+	[d->dp setBordered:NO];
+	[d->dp setBezeled:YES];
+	[d->dp setDrawsBackground:YES];
+	[d->dp setDatePickerStyle:NSTextFieldAndStepperDatePickerStyle];
+	[d->dp setDatePickerElements:elements];
+	[d->dp setDatePickerMode:NSSingleDateMode];
+	uiDarwinSetControlFont(d->dp, NSRegularControlSize);
+
+	return d;
+}
+
+uiDateTimePicker *uiNewDateTimePicker(void)
+{
+	return finishNewDateTimePicker(NSYearMonthDayDatePickerElementFlag | NSHourMinuteSecondDatePickerElementFlag);
+}
+
+uiDateTimePicker *uiNewDatePicker(void)
+{
+	return finishNewDateTimePicker(NSYearMonthDayDatePickerElementFlag);
+}
+
+uiDateTimePicker *uiNewTimePicker(void)
+{
+	return finishNewDateTimePicker(NSHourMinuteSecondDatePickerElementFlag);
+}
diff --git a/src/libui_sdl/libui/darwin/debug.m b/src/libui_sdl/libui/darwin/debug.m
new file mode 100644
index 0000000..c91c6a7
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/debug.m
@@ -0,0 +1,19 @@
+// 13 may 2016
+#import "uipriv_darwin.h"
+
+// LONGTERM don't halt on release builds
+
+void realbug(const char *file, const char *line, const char *func, const char *prefix, const char *format, va_list ap)
+{
+	NSMutableString *str;
+	NSString *formatted;
+
+	str = [NSMutableString new];
+	[str appendString:[NSString stringWithFormat:@"[libui] %s:%s:%s() %s", file, line, func, prefix]];
+	formatted = [[NSString alloc] initWithFormat:[NSString stringWithUTF8String:format] arguments:ap];
+	[str appendString:formatted];
+	[formatted release];
+	NSLog(@"%@", str);
+	[str release];
+	__builtin_trap();
+}
diff --git a/src/libui_sdl/libui/darwin/draw.m b/src/libui_sdl/libui/darwin/draw.m
new file mode 100644
index 0000000..262ad3e
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/draw.m
@@ -0,0 +1,454 @@
+// 6 september 2015
+#import "uipriv_darwin.h"
+
+struct uiDrawPath {
+	CGMutablePathRef path;
+	uiDrawFillMode fillMode;
+	BOOL ended;
+};
+
+uiDrawPath *uiDrawNewPath(uiDrawFillMode mode)
+{
+	uiDrawPath *p;
+
+	p = uiNew(uiDrawPath);
+	p->path = CGPathCreateMutable();
+	p->fillMode = mode;
+	return p;
+}
+
+void uiDrawFreePath(uiDrawPath *p)
+{
+	CGPathRelease((CGPathRef) (p->path));
+	uiFree(p);
+}
+
+void uiDrawPathNewFigure(uiDrawPath *p, double x, double y)
+{
+	if (p->ended)
+		userbug("You cannot call uiDrawPathNewFigure() on a uiDrawPath that has already been ended. (path; %p)", p);
+	CGPathMoveToPoint(p->path, NULL, x, y);
+}
+
+void uiDrawPathNewFigureWithArc(uiDrawPath *p, double xCenter, double yCenter, double radius, double startAngle, double sweep, int negative)
+{
+	double sinStart, cosStart;
+	double startx, starty;
+
+	if (p->ended)
+		userbug("You cannot call uiDrawPathNewFigureWithArc() on a uiDrawPath that has already been ended. (path; %p)", p);
+	sinStart = sin(startAngle);
+	cosStart = cos(startAngle);
+	startx = xCenter + radius * cosStart;
+	starty = yCenter + radius * sinStart;
+	CGPathMoveToPoint(p->path, NULL, startx, starty);
+	uiDrawPathArcTo(p, xCenter, yCenter, radius, startAngle, sweep, negative);
+}
+
+void uiDrawPathLineTo(uiDrawPath *p, double x, double y)
+{
+	// TODO refine this to require being in a path
+	if (p->ended)
+		implbug("attempt to add line to ended path in uiDrawPathLineTo()");
+	CGPathAddLineToPoint(p->path, NULL, x, y);
+}
+
+void uiDrawPathArcTo(uiDrawPath *p, double xCenter, double yCenter, double radius, double startAngle, double sweep, int negative)
+{
+	bool cw;
+
+	// TODO likewise
+	if (p->ended)
+		implbug("attempt to add arc to ended path in uiDrawPathArcTo()");
+	if (sweep > 2 * uiPi)
+		sweep = 2 * uiPi;
+	cw = false;
+	if (negative)
+		cw = true;
+	CGPathAddArc(p->path, NULL,
+		xCenter, yCenter,
+		radius,
+		startAngle, startAngle + sweep,
+		cw);
+}
+
+void uiDrawPathBezierTo(uiDrawPath *p, double c1x, double c1y, double c2x, double c2y, double endX, double endY)
+{
+	// TODO likewise
+	if (p->ended)
+		implbug("attempt to add bezier to ended path in uiDrawPathBezierTo()");
+	CGPathAddCurveToPoint(p->path, NULL,
+		c1x, c1y,
+		c2x, c2y,
+		endX, endY);
+}
+
+void uiDrawPathCloseFigure(uiDrawPath *p)
+{
+	// TODO likewise
+	if (p->ended)
+		implbug("attempt to close figure of ended path in uiDrawPathCloseFigure()");
+	CGPathCloseSubpath(p->path);
+}
+
+void uiDrawPathAddRectangle(uiDrawPath *p, double x, double y, double width, double height)
+{
+	if (p->ended)
+		userbug("You cannot call uiDrawPathAddRectangle() on a uiDrawPath that has already been ended. (path; %p)", p);
+	CGPathAddRect(p->path, NULL, CGRectMake(x, y, width, height));
+}
+
+void uiDrawPathEnd(uiDrawPath *p)
+{
+	p->ended = TRUE;
+}
+
+struct uiDrawContext {
+	CGContextRef c;
+	CGFloat height;				// needed for text; see below
+};
+
+uiDrawContext *newContext(CGContextRef ctxt, CGFloat height)
+{
+	uiDrawContext *c;
+
+	c = uiNew(uiDrawContext);
+	c->c = ctxt;
+	c->height = height;
+	return c;
+}
+
+void freeContext(uiDrawContext *c)
+{
+	uiFree(c);
+}
+
+// a stroke is identical to a fill of a stroked path
+// we need to do this in order to stroke with a gradient; see http://stackoverflow.com/a/25034854/3408572
+// doing this for other brushes works too
+void uiDrawStroke(uiDrawContext *c, uiDrawPath *path, uiDrawBrush *b, uiDrawStrokeParams *p)
+{
+	CGLineCap cap;
+	CGLineJoin join;
+	CGPathRef dashPath;
+	CGFloat *dashes;
+	size_t i;
+	uiDrawPath p2;
+
+	if (!path->ended)
+		userbug("You cannot call uiDrawStroke() on a uiDrawPath that has not been ended. (path: %p)", path);
+
+	switch (p->Cap) {
+	case uiDrawLineCapFlat:
+		cap = kCGLineCapButt;
+		break;
+	case uiDrawLineCapRound:
+		cap = kCGLineCapRound;
+		break;
+	case uiDrawLineCapSquare:
+		cap = kCGLineCapSquare;
+		break;
+	}
+	switch (p->Join) {
+	case uiDrawLineJoinMiter:
+		join = kCGLineJoinMiter;
+		break;
+	case uiDrawLineJoinRound:
+		join = kCGLineJoinRound;
+		break;
+	case uiDrawLineJoinBevel:
+		join = kCGLineJoinBevel;
+		break;
+	}
+
+	// create a temporary path identical to the previous one
+	dashPath = (CGPathRef) path->path;
+	if (p->NumDashes != 0) {
+		dashes = (CGFloat *) uiAlloc(p->NumDashes * sizeof (CGFloat), "CGFloat[]");
+		for (i = 0; i < p->NumDashes; i++)
+			dashes[i] = p->Dashes[i];
+		dashPath = CGPathCreateCopyByDashingPath(path->path,
+			NULL,
+			p->DashPhase,
+			dashes,
+			p->NumDashes);
+		uiFree(dashes);
+	}
+	// the documentation is wrong: this produces a path suitable for calling CGPathCreateCopyByStrokingPath(), not for filling directly
+	// the cast is safe; we never modify the CGPathRef and always cast it back to a CGPathRef anyway
+	p2.path = (CGMutablePathRef) CGPathCreateCopyByStrokingPath(dashPath,
+		NULL,
+		p->Thickness,
+		cap,
+		join,
+		p->MiterLimit);
+	if (p->NumDashes != 0)
+		CGPathRelease(dashPath);
+
+	// always draw stroke fills using the winding rule
+	// otherwise intersecting figures won't draw correctly
+	p2.fillMode = uiDrawFillModeWinding;
+	p2.ended = path->ended;
+	uiDrawFill(c, &p2, b);
+	// and clean up
+	CGPathRelease((CGPathRef) (p2.path));
+}
+
+// for a solid fill, we can merely have Core Graphics fill directly
+static void fillSolid(CGContextRef ctxt, uiDrawPath *p, uiDrawBrush *b)
+{
+	// TODO this uses DeviceRGB; switch to sRGB
+	CGContextSetRGBFillColor(ctxt, b->R, b->G, b->B, b->A);
+	switch (p->fillMode) {
+	case uiDrawFillModeWinding:
+		CGContextFillPath(ctxt);
+		break;
+	case uiDrawFillModeAlternate:
+		CGContextEOFillPath(ctxt);
+		break;
+	}
+}
+
+// for a gradient fill, we need to clip to the path and then draw the gradient
+// see http://stackoverflow.com/a/25034854/3408572
+static void fillGradient(CGContextRef ctxt, uiDrawPath *p, uiDrawBrush *b)
+{
+	CGGradientRef gradient;
+	CGColorSpaceRef colorspace;
+	CGFloat *colors;
+	CGFloat *locations;
+	size_t i;
+
+	// gradients need a color space
+	// for consistency with windows, use sRGB
+	colorspace = CGColorSpaceCreateWithName(kCGColorSpaceSRGB);
+
+	// make the gradient
+	colors = uiAlloc(b->NumStops * 4 * sizeof (CGFloat), "CGFloat[]");
+	locations = uiAlloc(b->NumStops * sizeof (CGFloat), "CGFloat[]");
+	for (i = 0; i < b->NumStops; i++) {
+		colors[i * 4 + 0] = b->Stops[i].R;
+		colors[i * 4 + 1] = b->Stops[i].G;
+		colors[i * 4 + 2] = b->Stops[i].B;
+		colors[i * 4 + 3] = b->Stops[i].A;
+		locations[i] = b->Stops[i].Pos;
+	}
+	gradient = CGGradientCreateWithColorComponents(colorspace, colors, locations, b->NumStops);
+	uiFree(locations);
+	uiFree(colors);
+
+	// because we're mucking with clipping, we need to save the graphics state and restore it later
+	CGContextSaveGState(ctxt);
+
+	// clip
+	switch (p->fillMode) {
+	case uiDrawFillModeWinding:
+		CGContextClip(ctxt);
+		break;
+	case uiDrawFillModeAlternate:
+		CGContextEOClip(ctxt);
+		break;
+	}
+
+	// draw the gradient
+	switch (b->Type) {
+	case uiDrawBrushTypeLinearGradient:
+		CGContextDrawLinearGradient(ctxt,
+			gradient,
+			CGPointMake(b->X0, b->Y0),
+			CGPointMake(b->X1, b->Y1),
+			kCGGradientDrawsBeforeStartLocation | kCGGradientDrawsAfterEndLocation);
+		break;
+	case uiDrawBrushTypeRadialGradient:
+		CGContextDrawRadialGradient(ctxt,
+			gradient,
+			CGPointMake(b->X0, b->Y0),
+			// make the start circle radius 0 to make it a point
+			0,
+			CGPointMake(b->X1, b->Y1),
+			b->OuterRadius,
+			kCGGradientDrawsBeforeStartLocation | kCGGradientDrawsAfterEndLocation);
+		break;
+	}
+
+	// and clean up
+	CGContextRestoreGState(ctxt);
+	CGGradientRelease(gradient);
+	CGColorSpaceRelease(colorspace);
+}
+
+void uiDrawFill(uiDrawContext *c, uiDrawPath *path, uiDrawBrush *b)
+{
+	if (!path->ended)
+		userbug("You cannot call uiDrawStroke() on a uiDrawPath that has not been ended. (path: %p)", path);
+	CGContextAddPath(c->c, (CGPathRef) (path->path));
+	switch (b->Type) {
+	case uiDrawBrushTypeSolid:
+		fillSolid(c->c, path, b);
+		return;
+	case uiDrawBrushTypeLinearGradient:
+	case uiDrawBrushTypeRadialGradient:
+		fillGradient(c->c, path, b);
+		return;
+//	case uiDrawBrushTypeImage:
+		// TODO
+		return;
+	}
+	userbug("Unknown brush type %d passed to uiDrawFill().", b->Type);
+}
+
+static void m2c(uiDrawMatrix *m, CGAffineTransform *c)
+{
+	c->a = m->M11;
+	c->b = m->M12;
+	c->c = m->M21;
+	c->d = m->M22;
+	c->tx = m->M31;
+	c->ty = m->M32;
+}
+
+static void c2m(CGAffineTransform *c, uiDrawMatrix *m)
+{
+	m->M11 = c->a;
+	m->M12 = c->b;
+	m->M21 = c->c;
+	m->M22 = c->d;
+	m->M31 = c->tx;
+	m->M32 = c->ty;
+}
+
+void uiDrawMatrixTranslate(uiDrawMatrix *m, double x, double y)
+{
+	CGAffineTransform c;
+
+	m2c(m, &c);
+	c = CGAffineTransformTranslate(c, x, y);
+	c2m(&c, m);
+}
+
+void uiDrawMatrixScale(uiDrawMatrix *m, double xCenter, double yCenter, double x, double y)
+{
+	CGAffineTransform c;
+	double xt, yt;
+
+	m2c(m, &c);
+	xt = x;
+	yt = y;
+	scaleCenter(xCenter, yCenter, &xt, &yt);
+	c = CGAffineTransformTranslate(c, xt, yt);
+	c = CGAffineTransformScale(c, x, y);
+	c = CGAffineTransformTranslate(c, -xt, -yt);
+	c2m(&c, m);
+}
+
+void uiDrawMatrixRotate(uiDrawMatrix *m, double x, double y, double amount)
+{
+	CGAffineTransform c;
+
+	m2c(m, &c);
+	c = CGAffineTransformTranslate(c, x, y);
+	c = CGAffineTransformRotate(c, amount);
+	c = CGAffineTransformTranslate(c, -x, -y);
+	c2m(&c, m);
+}
+
+void uiDrawMatrixSkew(uiDrawMatrix *m, double x, double y, double xamount, double yamount)
+{
+	fallbackSkew(m, x, y, xamount, yamount);
+}
+
+void uiDrawMatrixMultiply(uiDrawMatrix *dest, uiDrawMatrix *src)
+{
+	CGAffineTransform c;
+	CGAffineTransform d;
+
+	m2c(dest, &c);
+	m2c(src, &d);
+	c = CGAffineTransformConcat(c, d);
+	c2m(&c, dest);
+}
+
+// there is no test for invertibility; CGAffineTransformInvert() is merely documented as returning the matrix unchanged if it isn't invertible
+// therefore, special care must be taken to catch matrices who are their own inverses
+// TODO figure out which matrices these are and do so
+int uiDrawMatrixInvertible(uiDrawMatrix *m)
+{
+	CGAffineTransform c, d;
+
+	m2c(m, &c);
+	d = CGAffineTransformInvert(c);
+	return CGAffineTransformEqualToTransform(c, d) == false;
+}
+
+int uiDrawMatrixInvert(uiDrawMatrix *m)
+{
+	CGAffineTransform c, d;
+
+	m2c(m, &c);
+	d = CGAffineTransformInvert(c);
+	if (CGAffineTransformEqualToTransform(c, d))
+		return 0;
+	c2m(&d, m);
+	return 1;
+}
+
+void uiDrawMatrixTransformPoint(uiDrawMatrix *m, double *x, double *y)
+{
+	CGAffineTransform c;
+	CGPoint p;
+
+	m2c(m, &c);
+	p = CGPointApplyAffineTransform(CGPointMake(*x, *y), c);
+	*x = p.x;
+	*y = p.y;
+}
+
+void uiDrawMatrixTransformSize(uiDrawMatrix *m, double *x, double *y)
+{
+	CGAffineTransform c;
+	CGSize s;
+
+	m2c(m, &c);
+	s = CGSizeApplyAffineTransform(CGSizeMake(*x, *y), c);
+	*x = s.width;
+	*y = s.height;
+}
+
+void uiDrawTransform(uiDrawContext *c, uiDrawMatrix *m)
+{
+	CGAffineTransform cm;
+
+	m2c(m, &cm);
+	CGContextConcatCTM(c->c, cm);
+}
+
+void uiDrawClip(uiDrawContext *c, uiDrawPath *path)
+{
+	if (!path->ended)
+		userbug("You cannot call uiDrawCilp() on a uiDrawPath that has not been ended. (path: %p)", path);
+	CGContextAddPath(c->c, (CGPathRef) (path->path));
+	switch (path->fillMode) {
+	case uiDrawFillModeWinding:
+		CGContextClip(c->c);
+		break;
+	case uiDrawFillModeAlternate:
+		CGContextEOClip(c->c);
+		break;
+	}
+}
+
+// TODO figure out what besides transforms these save/restore on all platforms
+void uiDrawSave(uiDrawContext *c)
+{
+	CGContextSaveGState(c->c);
+}
+
+void uiDrawRestore(uiDrawContext *c)
+{
+	CGContextRestoreGState(c->c);
+}
+
+void uiDrawText(uiDrawContext *c, double x, double y, uiDrawTextLayout *layout)
+{
+	doDrawText(c->c, c->height, x, y, layout);
+}
diff --git a/src/libui_sdl/libui/darwin/drawtext.m b/src/libui_sdl/libui/darwin/drawtext.m
new file mode 100644
index 0000000..c376536
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/drawtext.m
@@ -0,0 +1,655 @@
+// 6 september 2015
+#import "uipriv_darwin.h"
+
+// TODO
+#define complain(...) implbug(__VA_ARGS__)
+
+// TODO double-check that we are properly handling allocation failures (or just toll free bridge from cocoa)
+struct uiDrawFontFamilies {
+	CFArrayRef fonts;
+};
+
+uiDrawFontFamilies *uiDrawListFontFamilies(void)
+{
+	uiDrawFontFamilies *ff;
+
+	ff = uiNew(uiDrawFontFamilies);
+	ff->fonts = CTFontManagerCopyAvailableFontFamilyNames();
+	if (ff->fonts == NULL)
+		implbug("error getting available font names (no reason specified) (TODO)");
+	return ff;
+}
+
+int uiDrawFontFamiliesNumFamilies(uiDrawFontFamilies *ff)
+{
+	return CFArrayGetCount(ff->fonts);
+}
+
+char *uiDrawFontFamiliesFamily(uiDrawFontFamilies *ff, int n)
+{
+	CFStringRef familystr;
+	char *family;
+
+	familystr = (CFStringRef) CFArrayGetValueAtIndex(ff->fonts, n);
+	// toll-free bridge
+	family = uiDarwinNSStringToText((NSString *) familystr);
+	// Get Rule means we do not free familystr
+	return family;
+}
+
+void uiDrawFreeFontFamilies(uiDrawFontFamilies *ff)
+{
+	CFRelease(ff->fonts);
+	uiFree(ff);
+}
+
+struct uiDrawTextFont {
+	CTFontRef f;
+};
+
+uiDrawTextFont *mkTextFont(CTFontRef f, BOOL retain)
+{
+	uiDrawTextFont *font;
+
+	font = uiNew(uiDrawTextFont);
+	font->f = f;
+	if (retain)
+		CFRetain(font->f);
+	return font;
+}
+
+uiDrawTextFont *mkTextFontFromNSFont(NSFont *f)
+{
+	// toll-free bridging; we do retain, though
+	return mkTextFont((CTFontRef) f, YES);
+}
+
+static CFMutableDictionaryRef newAttrList(void)
+{
+	CFMutableDictionaryRef attr;
+
+	attr = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
+	if (attr == NULL)
+		complain("error creating attribute dictionary in newAttrList()()");
+	return attr;
+}
+
+static void addFontFamilyAttr(CFMutableDictionaryRef attr, const char *family)
+{
+	CFStringRef cfstr;
+
+	cfstr = CFStringCreateWithCString(NULL, family, kCFStringEncodingUTF8);
+	if (cfstr == NULL)
+		complain("error creating font family name CFStringRef in addFontFamilyAttr()");
+	CFDictionaryAddValue(attr, kCTFontFamilyNameAttribute, cfstr);
+	CFRelease(cfstr);			// dictionary holds its own reference
+}
+
+static void addFontSizeAttr(CFMutableDictionaryRef attr, double size)
+{
+	CFNumberRef n;
+
+	n = CFNumberCreate(NULL, kCFNumberDoubleType, &size);
+	CFDictionaryAddValue(attr, kCTFontSizeAttribute, n);
+	CFRelease(n);
+}
+
+#if 0
+TODO
+// See http://stackoverflow.com/questions/4810409/does-coretext-support-small-caps/4811371#4811371 and https://git.gnome.org/browse/pango/tree/pango/pangocoretext-fontmap.c for what these do
+// And fortunately, unlike the traits (see below), unmatched features are simply ignored without affecting the other features :D
+static void addFontSmallCapsAttr(CFMutableDictionaryRef attr)
+{
+	CFMutableArrayRef outerArray;
+	CFMutableDictionaryRef innerDict;
+	CFNumberRef numType, numSelector;
+	int num;
+
+	outerArray = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
+	if (outerArray == NULL)
+		complain("error creating outer CFArray for adding small caps attributes in addFontSmallCapsAttr()");
+
+	// Apple's headers say these are deprecated, but a few fonts still rely on them
+	num = kLetterCaseType;
+	numType = CFNumberCreate(NULL, kCFNumberIntType, &num);
+	num = kSmallCapsSelector;
+	numSelector = CFNumberCreate(NULL, kCFNumberIntType, &num);
+	innerDict = newAttrList();
+	CFDictionaryAddValue(innerDict, kCTFontFeatureTypeIdentifierKey, numType);
+	CFRelease(numType);
+	CFDictionaryAddValue(innerDict, kCTFontFeatureSelectorIdentifierKey, numSelector);
+	CFRelease(numSelector);
+	CFArrayAppendValue(outerArray, innerDict);
+	CFRelease(innerDict);		// and likewise for CFArray
+
+	// these are the non-deprecated versions of the above; some fonts have these instead
+	num = kLowerCaseType;
+	numType = CFNumberCreate(NULL, kCFNumberIntType, &num);
+	num = kLowerCaseSmallCapsSelector;
+	numSelector = CFNumberCreate(NULL, kCFNumberIntType, &num);
+	innerDict = newAttrList();
+	CFDictionaryAddValue(innerDict, kCTFontFeatureTypeIdentifierKey, numType);
+	CFRelease(numType);
+	CFDictionaryAddValue(innerDict, kCTFontFeatureSelectorIdentifierKey, numSelector);
+	CFRelease(numSelector);
+	CFArrayAppendValue(outerArray, innerDict);
+	CFRelease(innerDict);		// and likewise for CFArray
+
+	CFDictionaryAddValue(attr, kCTFontFeatureSettingsAttribute, outerArray);
+	CFRelease(outerArray);
+}
+#endif
+
+// Named constants for these were NOT added until 10.11, and even then they were added as external symbols instead of macros, so we can't use them directly :(
+// kode54 got these for me before I had access to El Capitan; thanks to him.
+#define ourNSFontWeightUltraLight -0.800000
+#define ourNSFontWeightThin -0.600000
+#define ourNSFontWeightLight -0.400000
+#define ourNSFontWeightRegular 0.000000
+#define ourNSFontWeightMedium 0.230000
+#define ourNSFontWeightSemibold 0.300000
+#define ourNSFontWeightBold 0.400000
+#define ourNSFontWeightHeavy 0.560000
+#define ourNSFontWeightBlack 0.620000
+static const CGFloat ctWeights[] = {
+	// yeah these two have their names swapped; blame Pango
+	[uiDrawTextWeightThin] = ourNSFontWeightUltraLight,
+	[uiDrawTextWeightUltraLight] = ourNSFontWeightThin,
+	[uiDrawTextWeightLight] = ourNSFontWeightLight,
+	// for this one let's go between Light and Regular
+	// we're doing nearest so if there happens to be an exact value hopefully it's close enough
+	[uiDrawTextWeightBook] = ourNSFontWeightLight + ((ourNSFontWeightRegular - ourNSFontWeightLight) / 2),
+	[uiDrawTextWeightNormal] = ourNSFontWeightRegular,
+	[uiDrawTextWeightMedium] = ourNSFontWeightMedium,
+	[uiDrawTextWeightSemiBold] = ourNSFontWeightSemibold,
+	[uiDrawTextWeightBold] = ourNSFontWeightBold,
+	// for this one let's go between Bold and Heavy
+	[uiDrawTextWeightUltraBold] = ourNSFontWeightBold + ((ourNSFontWeightHeavy - ourNSFontWeightBold) / 2),
+	[uiDrawTextWeightHeavy] = ourNSFontWeightHeavy,
+	[uiDrawTextWeightUltraHeavy] = ourNSFontWeightBlack,
+};
+
+// Unfortunately there are still no named constants for these.
+// Let's just use normalized widths.
+// As far as I can tell (OS X only ships with condensed fonts, not expanded fonts; TODO), regardless of condensed or expanded, negative means condensed and positive means expanded.
+// TODO verify this is correct
+static const CGFloat ctStretches[] = {
+	[uiDrawTextStretchUltraCondensed] = -1.0,
+	[uiDrawTextStretchExtraCondensed] = -0.75,
+	[uiDrawTextStretchCondensed] = -0.5,
+	[uiDrawTextStretchSemiCondensed] = -0.25,
+	[uiDrawTextStretchNormal] = 0.0,
+	[uiDrawTextStretchSemiExpanded] = 0.25,
+	[uiDrawTextStretchExpanded] = 0.5,
+	[uiDrawTextStretchExtraExpanded] = 0.75,
+	[uiDrawTextStretchUltraExpanded] = 1.0,
+};
+
+struct closeness {
+	CFIndex index;
+	CGFloat weight;
+	CGFloat italic;
+	CGFloat stretch;
+	CGFloat distance;
+};
+
+// Stupidity: CTFont requires an **exact match for the entire traits dictionary**, otherwise it will **drop ALL the traits**.
+// We have to implement the closest match ourselves.
+// Also we have to do this before adding the small caps flags, because the matching descriptors won't have those.
+CTFontDescriptorRef matchTraits(CTFontDescriptorRef against, uiDrawTextWeight weight, uiDrawTextItalic italic, uiDrawTextStretch stretch)
+{
+	CGFloat targetWeight;
+	CGFloat italicCloseness, obliqueCloseness, normalCloseness;
+	CGFloat targetStretch;
+	CFArrayRef matching;
+	CFIndex i, n;
+	struct closeness *closeness;
+	CTFontDescriptorRef current;
+	CTFontDescriptorRef out;
+
+	targetWeight = ctWeights[weight];
+	switch (italic) {
+	case uiDrawTextItalicNormal:
+		italicCloseness = 1;
+		obliqueCloseness = 1;
+		normalCloseness = 0;
+		break;
+	case uiDrawTextItalicOblique:
+		italicCloseness = 0.5;
+		obliqueCloseness = 0;
+		normalCloseness = 1;
+		break;
+	case uiDrawTextItalicItalic:
+		italicCloseness = 0;
+		obliqueCloseness = 0.5;
+		normalCloseness = 1;
+		break;
+	}
+	targetStretch = ctStretches[stretch];
+
+	matching = CTFontDescriptorCreateMatchingFontDescriptors(against, NULL);
+	if (matching == NULL)
+		// no matches; give the original back and hope for the best
+		return against;
+	n = CFArrayGetCount(matching);
+	if (n == 0) {
+		// likewise
+		CFRelease(matching);
+		return against;
+	}
+
+	closeness = (struct closeness *) uiAlloc(n * sizeof (struct closeness), "struct closeness[]");
+	for (i = 0; i < n; i++) {
+		CFDictionaryRef traits;
+		CFNumberRef cfnum;
+		CTFontSymbolicTraits symbolic;
+
+		closeness[i].index = i;
+
+		current = CFArrayGetValueAtIndex(matching, i);
+		traits = CTFontDescriptorCopyAttribute(current, kCTFontTraitsAttribute);
+		if (traits == NULL) {
+			// couldn't get traits; be safe by ranking it lowest
+			// LONGTERM figure out what the longest possible distances are
+			closeness[i].weight = 3;
+			closeness[i].italic = 2;
+			closeness[i].stretch = 3;
+			continue;
+		}
+
+		symbolic = 0;			// assume no symbolic traits if none are listed
+		cfnum = CFDictionaryGetValue(traits, kCTFontSymbolicTrait);
+		if (cfnum != NULL) {
+			SInt32 s;
+
+			if (CFNumberGetValue(cfnum, kCFNumberSInt32Type, &s) == false)
+				complain("error getting symbolic traits in matchTraits()");
+			symbolic = (CTFontSymbolicTraits) s;
+			// Get rule; do not release cfnum
+		}
+
+		// now try weight
+		cfnum = CFDictionaryGetValue(traits, kCTFontWeightTrait);
+		if (cfnum != NULL) {
+			CGFloat val;
+
+			// LONGTERM instead of complaining for this and width and possibly also symbolic traits above, should we just fall through to the default?
+			if (CFNumberGetValue(cfnum, kCFNumberCGFloatType, &val) == false)
+				complain("error getting weight value in matchTraits()");
+			closeness[i].weight = val - targetWeight;
+		} else
+			// okay there's no weight key; let's try the literal meaning of the symbolic constant
+			// LONGTERM is the weight key guaranteed?
+			if ((symbolic & kCTFontBoldTrait) != 0)
+				closeness[i].weight = ourNSFontWeightBold - targetWeight;
+			else
+				closeness[i].weight = ourNSFontWeightRegular - targetWeight;
+
+		// italics is a bit harder because Core Text doesn't expose a concept of obliqueness
+		// Pango just does a g_strrstr() (backwards case-sensitive search) for "Oblique" in the font's style name (see https://git.gnome.org/browse/pango/tree/pango/pangocoretext-fontmap.c); let's do that too I guess
+		if ((symbolic & kCTFontItalicTrait) != 0)
+			closeness[i].italic = italicCloseness;
+		else {
+			CFStringRef styleName;
+			BOOL isOblique;
+
+			isOblique = NO;		// default value
+			styleName = CTFontDescriptorCopyAttribute(current, kCTFontStyleNameAttribute);
+			if (styleName != NULL) {
+				CFRange range;
+
+				// note the use of the toll-free bridge for the string literal, since CFSTR() *can* return NULL
+				range = CFStringFind(styleName, (CFStringRef) @"Oblique", kCFCompareBackwards);
+				if (range.location != kCFNotFound)
+					isOblique = YES;
+				CFRelease(styleName);
+			}
+			if (isOblique)
+				closeness[i].italic = obliqueCloseness;
+			else
+				closeness[i].italic = normalCloseness;
+		}
+
+		// now try width
+		// TODO this does not seem to be enough for Skia's extended variants; the width trait is 0 but the Expanded flag is on
+		// TODO verify the rest of this matrix (what matrix?)
+		cfnum = CFDictionaryGetValue(traits, kCTFontWidthTrait);
+		if (cfnum != NULL) {
+			CGFloat val;
+
+			if (CFNumberGetValue(cfnum, kCFNumberCGFloatType, &val) == false)
+				complain("error getting width value in matchTraits()");
+			closeness[i].stretch = val - targetStretch;
+		} else
+			// okay there's no width key; let's try the literal meaning of the symbolic constant
+			// LONGTERM is the width key guaranteed?
+			if ((symbolic & kCTFontExpandedTrait) != 0)
+				closeness[i].stretch = 1.0 - targetStretch;
+			else if ((symbolic & kCTFontCondensedTrait) != 0)
+				closeness[i].stretch = -1.0 - targetStretch;
+			else
+				closeness[i].stretch = 0.0 - targetStretch;
+
+		CFRelease(traits);
+	}
+
+	// now figure out the 3-space difference between the three and sort by that
+	for (i = 0; i < n; i++) {
+		CGFloat weight, italic, stretch;
+
+		weight = closeness[i].weight;
+		weight *= weight;
+		italic = closeness[i].italic;
+		italic *= italic;
+		stretch = closeness[i].stretch;
+		stretch *= stretch;
+		closeness[i].distance = sqrt(weight + italic + stretch);
+	}
+	qsort_b(closeness, n, sizeof (struct closeness), ^(const void *aa, const void *bb) {
+		const struct closeness *a = (const struct closeness *) aa;
+		const struct closeness *b = (const struct closeness *) bb;
+
+		// via http://www.gnu.org/software/libc/manual/html_node/Comparison-Functions.html#Comparison-Functions
+		// LONGTERM is this really the best way? isn't it the same as if (*a < *b) return -1; if (*a > *b) return 1; return 0; ?
+		return (a->distance > b->distance) - (a->distance < b->distance);
+	});
+	// and the first element of the sorted array is what we want
+	out = CFArrayGetValueAtIndex(matching, closeness[0].index);
+	CFRetain(out);			// get rule
+
+	// release everything
+	uiFree(closeness);
+	CFRelease(matching);
+	// and release the original descriptor since we no longer need it
+	CFRelease(against);
+
+	return out;
+}
+
+// Now remember what I said earlier about having to add the small caps traits after calling the above? This gets a dictionary back so we can do so.
+CFMutableDictionaryRef extractAttributes(CTFontDescriptorRef desc)
+{
+	CFDictionaryRef dict;
+	CFMutableDictionaryRef mdict;
+
+	dict = CTFontDescriptorCopyAttributes(desc);
+	// this might not be mutable, so make a mutable copy
+	mdict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
+	CFRelease(dict);
+	return mdict;
+}
+
+uiDrawTextFont *uiDrawLoadClosestFont(const uiDrawTextFontDescriptor *desc)
+{
+	CTFontRef f;
+	CFMutableDictionaryRef attr;
+	CTFontDescriptorRef cfdesc;
+
+	attr = newAttrList();
+	addFontFamilyAttr(attr, desc->Family);
+	addFontSizeAttr(attr, desc->Size);
+
+	// now we have to do the traits matching, so create a descriptor, match the traits, and then get the attributes back
+	cfdesc = CTFontDescriptorCreateWithAttributes(attr);
+	// TODO release attr?
+	cfdesc = matchTraits(cfdesc, desc->Weight, desc->Italic, desc->Stretch);
+
+	// specify the initial size again just to be safe
+	f = CTFontCreateWithFontDescriptor(cfdesc, desc->Size, NULL);
+	// TODO release cfdesc?
+
+	return mkTextFont(f, NO);		// we hold the initial reference; no need to retain again
+}
+
+void uiDrawFreeTextFont(uiDrawTextFont *font)
+{
+	CFRelease(font->f);
+	uiFree(font);
+}
+
+uintptr_t uiDrawTextFontHandle(uiDrawTextFont *font)
+{
+	return (uintptr_t) (font->f);
+}
+
+void uiDrawTextFontDescribe(uiDrawTextFont *font, uiDrawTextFontDescriptor *desc)
+{
+	// TODO
+}
+
+// text sizes and user space points are identical:
+// - https://developer.apple.com/library/mac/documentation/TextFonts/Conceptual/CocoaTextArchitecture/TypoFeatures/TextSystemFeatures.html#//apple_ref/doc/uid/TP40009459-CH6-51627-BBCCHIFF text points are 72 per inch
+// - https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/CocoaDrawingGuide/Transforms/Transforms.html#//apple_ref/doc/uid/TP40003290-CH204-SW5 user space points are 72 per inch
+void uiDrawTextFontGetMetrics(uiDrawTextFont *font, uiDrawTextFontMetrics *metrics)
+{
+	metrics->Ascent = CTFontGetAscent(font->f);
+	metrics->Descent = CTFontGetDescent(font->f);
+	metrics->Leading = CTFontGetLeading(font->f);
+	metrics->UnderlinePos = CTFontGetUnderlinePosition(font->f);
+	metrics->UnderlineThickness = CTFontGetUnderlineThickness(font->f);
+}
+
+struct uiDrawTextLayout {
+	CFMutableAttributedStringRef mas;
+	CFRange *charsToRanges;
+	double width;
+};
+
+uiDrawTextLayout *uiDrawNewTextLayout(const char *str, uiDrawTextFont *defaultFont, double width)
+{
+	uiDrawTextLayout *layout;
+	CFAttributedStringRef immutable;
+	CFMutableDictionaryRef attr;
+	CFStringRef backing;
+	CFIndex i, j, n;
+
+	layout = uiNew(uiDrawTextLayout);
+
+	// TODO docs say we need to use a different set of key callbacks
+	// TODO see if the font attribute key callbacks need to be the same
+	attr = newAttrList();
+	// this will retain defaultFont->f; no need to worry
+	CFDictionaryAddValue(attr, kCTFontAttributeName, defaultFont->f);
+
+	immutable = CFAttributedStringCreate(NULL, (CFStringRef) [NSString stringWithUTF8String:str], attr);
+	if (immutable == NULL)
+		complain("error creating immutable attributed string in uiDrawNewTextLayout()");
+	CFRelease(attr);
+
+	layout->mas = CFAttributedStringCreateMutableCopy(NULL, 0, immutable);
+	if (layout->mas == NULL)
+		complain("error creating attributed string in uiDrawNewTextLayout()");
+	CFRelease(immutable);
+
+	uiDrawTextLayoutSetWidth(layout, width);
+
+	// unfortunately the CFRanges for attributes expect UTF-16 codepoints
+	// we want graphemes
+	// fortunately CFStringGetRangeOfComposedCharactersAtIndex() is here for us
+	// https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/Strings/Articles/stringsClusters.html says that this does work on all multi-codepoint graphemes (despite the name), and that this is the preferred function for this particular job anyway
+	backing = CFAttributedStringGetString(layout->mas);
+	n = CFStringGetLength(backing);
+	// allocate one extra, just to be safe
+	layout->charsToRanges = (CFRange *) uiAlloc((n + 1) * sizeof (CFRange), "CFRange[]");
+	i = 0;
+	j = 0;
+	while (i < n) {
+		CFRange range;
+
+		range = CFStringGetRangeOfComposedCharactersAtIndex(backing, i);
+		i = range.location + range.length;
+		layout->charsToRanges[j] = range;
+		j++;
+	}
+	// and set the last one
+	layout->charsToRanges[j].location = i;
+	layout->charsToRanges[j].length = 0;
+
+	return layout;
+}
+
+void uiDrawFreeTextLayout(uiDrawTextLayout *layout)
+{
+	uiFree(layout->charsToRanges);
+	CFRelease(layout->mas);
+	uiFree(layout);
+}
+
+void uiDrawTextLayoutSetWidth(uiDrawTextLayout *layout, double width)
+{
+	layout->width = width;
+}
+
+struct framesetter {
+	CTFramesetterRef fs;
+	CFMutableDictionaryRef frameAttrib;
+	CGSize extents;
+};
+
+// TODO CTFrameProgression for RTL/LTR
+// TODO kCTParagraphStyleSpecifierMaximumLineSpacing, kCTParagraphStyleSpecifierMinimumLineSpacing, kCTParagraphStyleSpecifierLineSpacingAdjustment for line spacing
+static void mkFramesetter(uiDrawTextLayout *layout, struct framesetter *fs)
+{
+	CFRange fitRange;
+	CGFloat width;
+
+	fs->fs = CTFramesetterCreateWithAttributedString(layout->mas);
+	if (fs->fs == NULL)
+		complain("error creating CTFramesetter object in mkFramesetter()");
+
+	// TODO kCTFramePathWidthAttributeName?
+	fs->frameAttrib = NULL;
+
+	width = layout->width;
+	if (layout->width < 0)
+		width = CGFLOAT_MAX;
+	// TODO these seem to be floor()'d or truncated?
+	fs->extents = CTFramesetterSuggestFrameSizeWithConstraints(fs->fs,
+		CFRangeMake(0, 0),
+		fs->frameAttrib,
+		CGSizeMake(width, CGFLOAT_MAX),
+		&fitRange);		// not documented as accepting NULL
+}
+
+static void freeFramesetter(struct framesetter *fs)
+{
+	if (fs->frameAttrib != NULL)
+		CFRelease(fs->frameAttrib);
+	CFRelease(fs->fs);
+}
+
+// LONGTERM allow line separation and leading to be factored into a wrapping text layout
+
+// TODO reconcile differences in character wrapping on platforms
+void uiDrawTextLayoutExtents(uiDrawTextLayout *layout, double *width, double *height)
+{
+	struct framesetter fs;
+
+	mkFramesetter(layout, &fs);
+	*width = fs.extents.width;
+	*height = fs.extents.height;
+	freeFramesetter(&fs);
+}
+
+// Core Text doesn't draw onto a flipped view correctly; we have to do this
+// see the iOS bits of the first example at https://developer.apple.com/library/mac/documentation/StringsTextFonts/Conceptual/CoreText_Programming/LayoutOperations/LayoutOperations.html#//apple_ref/doc/uid/TP40005533-CH12-SW1 (iOS is naturally flipped)
+// TODO how is this affected by the CTM?
+static void prepareContextForText(CGContextRef c, CGFloat cheight, double *y)
+{
+	CGContextSaveGState(c);
+	CGContextTranslateCTM(c, 0, cheight);
+	CGContextScaleCTM(c, 1.0, -1.0);
+	CGContextSetTextMatrix(c, CGAffineTransformIdentity);
+
+	// wait, that's not enough; we need to offset y values to account for our new flipping
+	*y = cheight - *y;
+}
+
+// TODO placement is incorrect for Helvetica
+void doDrawText(CGContextRef c, CGFloat cheight, double x, double y, uiDrawTextLayout *layout)
+{
+	struct framesetter fs;
+	CGRect rect;
+	CGPathRef path;
+	CTFrameRef frame;
+
+	prepareContextForText(c, cheight, &y);
+	mkFramesetter(layout, &fs);
+
+	// oh, and since we're flipped, y is the bottom-left coordinate of the rectangle, not the top-left
+	// since we are flipped, we subtract
+	y -= fs.extents.height;
+
+	rect.origin = CGPointMake(x, y);
+	rect.size = fs.extents;
+	path = CGPathCreateWithRect(rect, NULL);
+
+	frame = CTFramesetterCreateFrame(fs.fs,
+		CFRangeMake(0, 0),
+		path,
+		fs.frameAttrib);
+	if (frame == NULL)
+		complain("error creating CTFrame object in doDrawText()");
+	CTFrameDraw(frame, c);
+	CFRelease(frame);
+
+	CFRelease(path);
+
+	freeFramesetter(&fs);
+	CGContextRestoreGState(c);
+}
+
+// LONGTERM provide an equivalent to CTLineGetTypographicBounds() on uiDrawTextLayout?
+
+// LONGTERM keep this for later features and documentation purposes
+#if 0
+		w = CTLineGetTypographicBounds(line, &ascent, &descent, NULL);
+		// though CTLineGetTypographicBounds() returns 0 on error, it also returns 0 on an empty string, so we can't reasonably check for error
+		CFRelease(line);
+
+	// LONGTERM provide a way to get the image bounds as a separate function later
+	bounds = CTLineGetImageBounds(line, c);
+	// though CTLineGetImageBounds() returns CGRectNull on error, it also returns CGRectNull on an empty string, so we can't reasonably check for error
+
+	// CGContextSetTextPosition() positions at the baseline in the case of CTLineDraw(); we need the top-left corner instead
+	CTLineGetTypographicBounds(line, &yoff, NULL, NULL);
+	// remember that we're flipped, so we subtract
+	y -= yoff;
+	CGContextSetTextPosition(c, x, y);
+#endif
+
+static CFRange charsToRange(uiDrawTextLayout *layout, int startChar, int endChar)
+{
+	CFRange start, end;
+	CFRange out;
+
+	start = layout->charsToRanges[startChar];
+	end = layout->charsToRanges[endChar];
+	out.location = start.location;
+	out.length = end.location - start.location;
+	return out;
+}
+
+#define rangeToCFRange() charsToRange(layout, startChar, endChar)
+
+void uiDrawTextLayoutSetColor(uiDrawTextLayout *layout, int startChar, int endChar, double r, double g, double b, double a)
+{
+	CGColorSpaceRef colorspace;
+	CGFloat components[4];
+	CGColorRef color;
+
+	// for consistency with windows, use sRGB
+	colorspace = CGColorSpaceCreateWithName(kCGColorSpaceSRGB);
+	components[0] = r;
+	components[1] = g;
+	components[2] = b;
+	components[3] = a;
+	color = CGColorCreate(colorspace, components);
+	CGColorSpaceRelease(colorspace);
+
+	CFAttributedStringSetAttribute(layout->mas,
+		rangeToCFRange(),
+		kCTForegroundColorAttributeName,
+		color);
+	CGColorRelease(color);		// TODO safe?
+}
diff --git a/src/libui_sdl/libui/darwin/editablecombo.m b/src/libui_sdl/libui/darwin/editablecombo.m
new file mode 100644
index 0000000..434add7
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/editablecombo.m
@@ -0,0 +1,185 @@
+// 14 august 2015
+#import "uipriv_darwin.h"
+
+// So why did I split uiCombobox into uiCombobox and uiEditableCombobox? Here's (90% of the; the other 10% is GTK+ events) answer:
+// When you type a value into a NSComboBox that just happens to be in the list, it will autoselect that item!
+// I can't seem to find a workaround.
+// Fortunately, there's other weird behaviors that made this split worth it.
+// And besides, selected items make little sense with editable comboboxes... you either separate or combine them with the text entry :V
+
+// NSComboBoxes have no intrinsic width; we'll use the default Interface Builder width for them.
+#define comboboxWidth 96
+
+@interface libui_intrinsicWidthNSComboBox : NSComboBox
+@end
+
+@implementation libui_intrinsicWidthNSComboBox
+
+- (NSSize)intrinsicContentSize
+{
+	NSSize s;
+
+	s = [super intrinsicContentSize];
+	s.width = comboboxWidth;
+	return s;
+}
+
+@end
+
+struct uiEditableCombobox {
+	uiDarwinControl c;
+	NSComboBox *cb;
+	void (*onChanged)(uiEditableCombobox *, void *);
+	void *onChangedData;
+};
+
+@interface editableComboboxDelegateClass : NSObject<NSComboBoxDelegate> {
+	struct mapTable *comboboxes;
+}
+- (void)controlTextDidChange:(NSNotification *)note;
+- (void)comboBoxSelectionDidChange:(NSNotification *)note;
+- (void)registerCombobox:(uiEditableCombobox *)c;
+- (void)unregisterCombobox:(uiEditableCombobox *)c;
+@end
+
+@implementation editableComboboxDelegateClass
+
+- (id)init
+{
+	self = [super init];
+	if (self)
+		self->comboboxes = newMap();
+	return self;
+}
+
+- (void)dealloc
+{
+	mapDestroy(self->comboboxes);
+	[super dealloc];
+}
+
+- (void)controlTextDidChange:(NSNotification *)note
+{
+	uiEditableCombobox *c;
+
+	c = uiEditableCombobox(mapGet(self->comboboxes, [note object]));
+	(*(c->onChanged))(c, c->onChangedData);
+}
+
+// the above doesn't handle when an item is selected; this will
+- (void)comboBoxSelectionDidChange:(NSNotification *)note
+{
+	// except this is sent BEFORE the entry is changed, and that doesn't send the above, so
+	// this is via http://stackoverflow.com/a/21059819/3408572 - it avoids the need to manage selected items
+	// this still isn't perfect — I get residual changes to the same value while navigating the list — but it's good enough
+	[self performSelector:@selector(controlTextDidChange:)
+		withObject:note
+		afterDelay:0];
+}
+
+- (void)registerCombobox:(uiEditableCombobox *)c
+{
+	mapSet(self->comboboxes, c->cb, c);
+	[c->cb setDelegate:self];
+}
+
+- (void)unregisterCombobox:(uiEditableCombobox *)c
+{
+	[c->cb setDelegate:nil];
+	mapDelete(self->comboboxes, c->cb);
+}
+
+@end
+
+static editableComboboxDelegateClass *comboboxDelegate = nil;
+
+uiDarwinControlAllDefaultsExceptDestroy(uiEditableCombobox, cb)
+
+static void uiEditableComboboxDestroy(uiControl *cc)
+{
+	uiEditableCombobox *c = uiEditableCombobox(cc);
+
+	[comboboxDelegate unregisterCombobox:c];
+	[c->cb release];
+	uiFreeControl(uiControl(c));
+}
+
+void uiEditableComboboxAppend(uiEditableCombobox *c, const char *text)
+{
+	[c->cb addItemWithObjectValue:toNSString(text)];
+}
+
+char *uiEditableComboboxText(uiEditableCombobox *c)
+{
+	return uiDarwinNSStringToText([c->cb stringValue]);
+}
+
+void uiEditableComboboxSetText(uiEditableCombobox *c, const char *text)
+{
+	NSString *t;
+
+	t = toNSString(text);
+	[c->cb setStringValue:t];
+	// yes, let's imitate the behavior that caused uiEditableCombobox to be separate in the first place!
+	// just to avoid confusion when users see an option in the list in the text field but not selected in the list
+	[c->cb selectItemWithObjectValue:t];
+}
+
+#if 0
+// LONGTERM
+void uiEditableComboboxSetSelected(uiEditableCombobox *c, int n)
+{
+	if (c->editable) {
+		// see https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/ComboBox/Tasks/SettingComboBoxValue.html#//apple_ref/doc/uid/20000256
+		id delegate;
+
+		// this triggers the delegate; turn it off for now
+		delegate = [c->cb delegate];
+		[c->cb setDelegate:nil];
+
+		// this seems to work fine for -1 too
+		[c->cb selectItemAtIndex:n];
+		if (n == -1)
+			[c->cb setObjectValue:@""];
+		else
+			[c->cb setObjectValue:[c->cb objectValueOfSelectedItem]];
+
+		[c->cb setDelegate:delegate];
+		return;
+	}
+	[c->pb selectItemAtIndex:n];
+}
+#endif
+
+void uiEditableComboboxOnChanged(uiEditableCombobox *c, void (*f)(uiEditableCombobox *c, void *data), void *data)
+{
+	c->onChanged = f;
+	c->onChangedData = data;
+}
+
+static void defaultOnChanged(uiEditableCombobox *c, void *data)
+{
+	// do nothing
+}
+
+uiEditableCombobox *uiNewEditableCombobox(void)
+{
+	uiEditableCombobox *c;
+
+	uiDarwinNewControl(uiEditableCombobox, c);
+
+	c->cb = [[libui_intrinsicWidthNSComboBox alloc] initWithFrame:NSZeroRect];
+	[c->cb setUsesDataSource:NO];
+	[c->cb setButtonBordered:YES];
+	[c->cb setCompletes:NO];
+	uiDarwinSetControlFont(c->cb, NSRegularControlSize);
+
+	if (comboboxDelegate == nil) {
+		comboboxDelegate = [[editableComboboxDelegateClass new] autorelease];
+		[delegates addObject:comboboxDelegate];
+	}
+	[comboboxDelegate registerCombobox:c];
+	uiEditableComboboxOnChanged(c, defaultOnChanged, NULL);
+
+	return c;
+}
diff --git a/src/libui_sdl/libui/darwin/entry.m b/src/libui_sdl/libui/darwin/entry.m
new file mode 100644
index 0000000..219d080
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/entry.m
@@ -0,0 +1,251 @@
+// 14 august 2015
+#import "uipriv_darwin.h"
+
+// Text fields for entering text have no intrinsic width; we'll use the default Interface Builder width for them.
+#define textfieldWidth 96
+
+@interface libui_intrinsicWidthNSTextField : NSTextField
+@end
+
+@implementation libui_intrinsicWidthNSTextField
+
+- (NSSize)intrinsicContentSize
+{
+	NSSize s;
+
+	s = [super intrinsicContentSize];
+	s.width = textfieldWidth;
+	return s;
+}
+
+@end
+
+// TODO does this have one on its own?
+@interface libui_intrinsicWidthNSSecureTextField : NSSecureTextField
+@end
+
+@implementation libui_intrinsicWidthNSSecureTextField
+
+- (NSSize)intrinsicContentSize
+{
+	NSSize s;
+
+	s = [super intrinsicContentSize];
+	s.width = textfieldWidth;
+	return s;
+}
+
+@end
+
+// TODO does this have one on its own?
+@interface libui_intrinsicWidthNSSearchField : NSSearchField
+@end
+
+@implementation libui_intrinsicWidthNSSearchField
+
+- (NSSize)intrinsicContentSize
+{
+	NSSize s;
+
+	s = [super intrinsicContentSize];
+	s.width = textfieldWidth;
+	return s;
+}
+
+@end
+
+struct uiEntry {
+	uiDarwinControl c;
+	NSTextField *textfield;
+	void (*onChanged)(uiEntry *, void *);
+	void *onChangedData;
+};
+
+static BOOL isSearchField(NSTextField *tf)
+{
+	return [tf isKindOfClass:[NSSearchField class]];
+}
+
+@interface entryDelegateClass : NSObject<NSTextFieldDelegate> {
+	struct mapTable *entries;
+}
+- (void)controlTextDidChange:(NSNotification *)note;
+- (IBAction)onSearch:(id)sender;
+- (void)registerEntry:(uiEntry *)e;
+- (void)unregisterEntry:(uiEntry *)e;
+@end
+
+@implementation entryDelegateClass
+
+- (id)init
+{
+	self = [super init];
+	if (self)
+		self->entries = newMap();
+	return self;
+}
+
+- (void)dealloc
+{
+	mapDestroy(self->entries);
+	[super dealloc];
+}
+
+- (void)controlTextDidChange:(NSNotification *)note
+{
+	[self onSearch:[note object]];
+}
+
+- (IBAction)onSearch:(id)sender
+{
+	uiEntry *e;
+
+	e = (uiEntry *) mapGet(self->entries, sender);
+	(*(e->onChanged))(e, e->onChangedData);
+}
+
+- (void)registerEntry:(uiEntry *)e
+{
+	mapSet(self->entries, e->textfield, e);
+	if (isSearchField(e->textfield)) {
+		[e->textfield setTarget:self];
+		[e->textfield setAction:@selector(onSearch:)];
+	} else
+		[e->textfield setDelegate:self];
+}
+
+- (void)unregisterEntry:(uiEntry *)e
+{
+	if (isSearchField(e->textfield))
+		[e->textfield setTarget:nil];
+	else
+		[e->textfield setDelegate:nil];
+	mapDelete(self->entries, e->textfield);
+}
+
+@end
+
+static entryDelegateClass *entryDelegate = nil;
+
+uiDarwinControlAllDefaultsExceptDestroy(uiEntry, textfield)
+
+static void uiEntryDestroy(uiControl *c)
+{
+	uiEntry *e = uiEntry(c);
+
+	[entryDelegate unregisterEntry:e];
+	[e->textfield release];
+	uiFreeControl(uiControl(e));
+}
+
+char *uiEntryText(uiEntry *e)
+{
+	return uiDarwinNSStringToText([e->textfield stringValue]);
+}
+
+void uiEntrySetText(uiEntry *e, const char *text)
+{
+	[e->textfield setStringValue:toNSString(text)];
+	// don't queue the control for resize; entry sizes are independent of their contents
+}
+
+void uiEntryOnChanged(uiEntry *e, void (*f)(uiEntry *, void *), void *data)
+{
+	e->onChanged = f;
+	e->onChangedData = data;
+}
+
+int uiEntryReadOnly(uiEntry *e)
+{
+	return [e->textfield isEditable] == NO;
+}
+
+void uiEntrySetReadOnly(uiEntry *e, int readonly)
+{
+	BOOL editable;
+
+	editable = YES;
+	if (readonly)
+		editable = NO;
+	[e->textfield setEditable:editable];
+}
+
+static void defaultOnChanged(uiEntry *e, void *data)
+{
+	// do nothing
+}
+
+// these are based on interface builder defaults; my comments in the old code weren't very good so I don't really know what talked about what, sorry :/
+void finishNewTextField(NSTextField *t, BOOL isEntry)
+{
+	uiDarwinSetControlFont(t, NSRegularControlSize);
+
+	// THE ORDER OF THESE CALLS IS IMPORTANT; CHANGE IT AND THE BORDERS WILL DISAPPEAR
+	[t setBordered:NO];
+	[t setBezelStyle:NSTextFieldSquareBezel];
+	[t setBezeled:isEntry];
+
+	// we don't need to worry about substitutions/autocorrect here; see window_darwin.m for details
+
+	[[t cell] setLineBreakMode:NSLineBreakByClipping];
+	[[t cell] setScrollable:YES];
+}
+
+static NSTextField *realNewEditableTextField(Class class)
+{
+	NSTextField *tf;
+
+	tf = [[class alloc] initWithFrame:NSZeroRect];
+	[tf setSelectable:YES];		// otherwise the setting is masked by the editable default of YES
+	finishNewTextField(tf, YES);
+	return tf;
+}
+
+NSTextField *newEditableTextField(void)
+{
+	return realNewEditableTextField([libui_intrinsicWidthNSTextField class]);
+}
+
+static uiEntry *finishNewEntry(Class class)
+{
+	uiEntry *e;
+
+	uiDarwinNewControl(uiEntry, e);
+
+	e->textfield = realNewEditableTextField(class);
+
+	if (entryDelegate == nil) {
+		entryDelegate = [[entryDelegateClass new] autorelease];
+		[delegates addObject:entryDelegate];
+	}
+	[entryDelegate registerEntry:e];
+	uiEntryOnChanged(e, defaultOnChanged, NULL);
+
+	return e;
+}
+
+uiEntry *uiNewEntry(void)
+{
+	return finishNewEntry([libui_intrinsicWidthNSTextField class]);
+}
+
+uiEntry *uiNewPasswordEntry(void)
+{
+	return finishNewEntry([libui_intrinsicWidthNSSecureTextField class]);
+}
+
+uiEntry *uiNewSearchEntry(void)
+{
+	uiEntry *e;
+	NSSearchField *s;
+
+	e = finishNewEntry([libui_intrinsicWidthNSSearchField class]);
+	s = (NSSearchField *) (e->textfield);
+	// TODO these are only on 10.10
+//	[s setSendsSearchStringImmediately:NO];
+//	[s setSendsWholeSearchString:NO];
+	[s setBordered:NO];
+	[s setBezelStyle:NSTextFieldRoundedBezel];
+	[s setBezeled:YES];
+	return e;
+}
diff --git a/src/libui_sdl/libui/darwin/fontbutton.m b/src/libui_sdl/libui/darwin/fontbutton.m
new file mode 100644
index 0000000..22bc646
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/fontbutton.m
@@ -0,0 +1,218 @@
+// 14 april 2016
+#import "uipriv_darwin.h"
+
+@interface fontButton : NSButton {
+	uiFontButton *libui_b;
+	NSFont *libui_font;
+}
+- (id)initWithFrame:(NSRect)frame libuiFontButton:(uiFontButton *)b;
+- (void)updateFontButtonLabel;
+- (IBAction)fontButtonClicked:(id)sender;
+- (void)activateFontButton;
+- (void)deactivateFontButton:(BOOL)activatingAnother;
+- (void)deactivateOnClose:(NSNotification *)note;
+- (uiDrawTextFont *)libuiFont;
+@end
+
+// only one may be active at one time
+static fontButton *activeFontButton = nil;
+
+struct uiFontButton {
+	uiDarwinControl c;
+	fontButton *button;
+	void (*onChanged)(uiFontButton *, void *);
+	void *onChangedData;
+};
+
+@implementation fontButton
+
+- (id)initWithFrame:(NSRect)frame libuiFontButton:(uiFontButton *)b
+{
+	self = [super initWithFrame:frame];
+	if (self) {
+		self->libui_b = b;
+
+		// imitate a NSColorWell in appearance
+		[self setButtonType:NSPushOnPushOffButton];
+		[self setBordered:YES];
+		[self setBezelStyle:NSShadowlessSquareBezelStyle];
+
+		// default font values according to the CTFontDescriptor reference
+		// this is autoreleased (thanks swillits in irc.freenode.net/#macdev)
+		self->libui_font = [[NSFont fontWithName:@"Helvetica" size:12.0] retain];
+		[self updateFontButtonLabel];
+
+		// for when clicked
+		[self setTarget:self];
+		[self setAction:@selector(fontButtonClicked:)];
+	}
+	return self;
+}
+
+- (void)dealloc
+{
+	// clean up notifications
+	if (activeFontButton == self)
+		[self deactivateFontButton:NO];
+	[self->libui_font release];
+	[super dealloc];
+}
+
+- (void)updateFontButtonLabel
+{
+	NSString *title;
+
+	title = [NSString stringWithFormat:@"%@ %g",
+		[self->libui_font displayName],
+		[self->libui_font pointSize]];
+	[self setTitle:title];
+}
+
+- (IBAction)fontButtonClicked:(id)sender
+{
+	if ([self state] == NSOnState)
+		[self activateFontButton];
+	else
+		[self deactivateFontButton:NO];
+}
+
+- (void)activateFontButton
+{
+	NSFontManager *sfm;
+
+	sfm = [NSFontManager sharedFontManager];
+	if (activeFontButton != nil)
+		[activeFontButton deactivateFontButton:YES];
+	[sfm setTarget:self];
+	[sfm setSelectedFont:self->libui_font isMultiple:NO];
+	[sfm orderFrontFontPanel:self];
+	activeFontButton = self;
+	[[NSNotificationCenter defaultCenter] addObserver:self
+		selector:@selector(deactivateOnClose:)
+		name:NSWindowWillCloseNotification
+		object:[NSFontPanel sharedFontPanel]];
+	[self setState:NSOnState];
+}
+
+- (void)deactivateFontButton:(BOOL)activatingAnother
+{
+	NSFontManager *sfm;
+
+	sfm = [NSFontManager sharedFontManager];
+	[sfm setTarget:nil];
+	if (!activatingAnother)
+		[[NSFontPanel sharedFontPanel] orderOut:self];
+	activeFontButton = nil;
+	[[NSNotificationCenter defaultCenter] removeObserver:self
+		name:NSWindowWillCloseNotification
+		object:[NSFontPanel sharedFontPanel]];
+	[self setState:NSOffState];
+}
+
+- (void)deactivateOnClose:(NSNotification *)note
+{
+	[self deactivateFontButton:NO];
+}
+
+- (void)changeFont:(id)sender
+{
+	NSFontManager *fm;
+	NSFont *old;
+	uiFontButton *b = self->libui_b;
+
+	fm = (NSFontManager *) sender;
+	old = self->libui_font;
+	self->libui_font = [sender convertFont:self->libui_font];
+	// do this even if it returns the same; we don't own anything that isn't from a new or alloc/init
+	[self->libui_font retain];
+	// do this second just in case
+	[old release];
+	[self updateFontButtonLabel];
+	(*(b->onChanged))(b, b->onChangedData);
+}
+
+- (NSUInteger)validModesForFontPanel:(NSFontPanel *)panel
+{
+	return NSFontPanelFaceModeMask |
+		NSFontPanelSizeModeMask |
+		NSFontPanelCollectionModeMask;
+}
+
+- (uiDrawTextFont *)libuiFont
+{
+	return mkTextFontFromNSFont(self->libui_font);
+}
+
+@end
+
+uiDarwinControlAllDefaults(uiFontButton, button)
+
+// we do not want font change events to be sent to any controls other than the font buttons
+// see main.m for more details
+BOOL fontButtonInhibitSendAction(SEL sel, id from, id to)
+{
+	if (sel != @selector(changeFont:))
+		return NO;
+	return ![to isKindOfClass:[fontButton class]];
+}
+
+// we do not want NSFontPanelValidation messages to be sent to any controls other than the font buttons when a font button is active
+// see main.m for more details
+BOOL fontButtonOverrideTargetForAction(SEL sel, id from, id to, id *override)
+{
+	if (activeFontButton == nil)
+		return NO;
+	if (sel != @selector(validModesForFontPanel:))
+		return NO;
+	*override = activeFontButton;
+	return YES;
+}
+
+// we also don't want the panel to be usable when there's a dialog running; see stddialogs.m for more details on that
+// unfortunately the panel seems to ignore -setWorksWhenModal: so we'll have to do things ourselves
+@interface nonModalFontPanel : NSFontPanel
+@end
+
+@implementation nonModalFontPanel
+
+- (BOOL)worksWhenModal
+{
+	return NO;
+}
+
+@end
+
+void setupFontPanel(void)
+{
+	[NSFontManager setFontPanelFactory:[nonModalFontPanel class]];
+}
+
+static void defaultOnChanged(uiFontButton *b, void *data)
+{
+	// do nothing
+}
+
+uiDrawTextFont *uiFontButtonFont(uiFontButton *b)
+{
+	return [b->button libuiFont];
+}
+
+void uiFontButtonOnChanged(uiFontButton *b, void (*f)(uiFontButton *, void *), void *data)
+{
+	b->onChanged = f;
+	b->onChangedData = data;
+}
+
+uiFontButton *uiNewFontButton(void)
+{
+	uiFontButton *b;
+
+	uiDarwinNewControl(uiFontButton, b);
+
+	b->button = [[fontButton alloc] initWithFrame:NSZeroRect libuiFontButton:b];
+	uiDarwinSetControlFont(b->button, NSRegularControlSize);
+
+	uiFontButtonOnChanged(b, defaultOnChanged, NULL);
+
+	return b;
+}
diff --git a/src/libui_sdl/libui/darwin/form.m b/src/libui_sdl/libui/darwin/form.m
new file mode 100644
index 0000000..7cdb965
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/form.m
@@ -0,0 +1,561 @@
+// 7 june 2016
+#import "uipriv_darwin.h"
+
+// TODO in the test program, sometimes one of the radio buttons can disappear (try when spaced)
+
+@interface formChild : NSView
+@property uiControl *c;
+@property (strong) NSTextField *label;
+@property BOOL stretchy;
+@property NSLayoutPriority oldHorzHuggingPri;
+@property NSLayoutPriority oldVertHuggingPri;
+@property (strong) NSLayoutConstraint *baseline;
+@property (strong) NSLayoutConstraint *leading;
+@property (strong) NSLayoutConstraint *top;
+@property (strong) NSLayoutConstraint *trailing;
+@property (strong) NSLayoutConstraint *bottom;
+- (id)initWithLabel:(NSTextField *)l;
+- (void)onDestroy;
+- (NSView *)view;
+@end
+
+@interface formView : NSView {
+	uiForm *f;
+	NSMutableArray *children;
+	int padded;
+
+	NSLayoutConstraint *first;
+	NSMutableArray *inBetweens;
+	NSLayoutConstraint *last;
+	NSMutableArray *widths;
+	NSMutableArray *leadings;
+	NSMutableArray *middles;
+	NSMutableArray *trailings;
+}
+- (id)initWithF:(uiForm *)ff;
+- (void)onDestroy;
+- (void)removeOurConstraints;
+- (void)syncEnableStates:(int)enabled;
+- (CGFloat)paddingAmount;
+- (void)establishOurConstraints;
+- (void)append:(NSString *)label c:(uiControl *)c stretchy:(int)stretchy;
+- (void)delete:(int)n;
+- (int)isPadded;
+- (void)setPadded:(int)p;
+- (BOOL)hugsTrailing;
+- (BOOL)hugsBottom;
+- (int)nStretchy;
+@end
+
+struct uiForm {
+	uiDarwinControl c;
+	formView *view;
+};
+
+@implementation formChild
+
+- (id)initWithLabel:(NSTextField *)l
+{
+	self = [super initWithFrame:NSZeroRect];
+	if (self) {
+		self.label = l;
+		[self.label setTranslatesAutoresizingMaskIntoConstraints:NO];
+		[self.label setContentHuggingPriority:NSLayoutPriorityRequired forOrientation:NSLayoutConstraintOrientationHorizontal];
+		[self.label setContentHuggingPriority:NSLayoutPriorityRequired forOrientation:NSLayoutConstraintOrientationVertical];
+		[self.label setContentCompressionResistancePriority:NSLayoutPriorityRequired forOrientation:NSLayoutConstraintOrientationHorizontal];
+		[self.label setContentCompressionResistancePriority:NSLayoutPriorityRequired forOrientation:NSLayoutConstraintOrientationVertical];
+		[self addSubview:self.label];
+
+		self.leading = mkConstraint(self.label, NSLayoutAttributeLeading,
+			NSLayoutRelationGreaterThanOrEqual,
+			self, NSLayoutAttributeLeading,
+			1, 0,
+			@"uiForm label leading");
+		[self addConstraint:self.leading];
+		self.top = mkConstraint(self.label, NSLayoutAttributeTop,
+			NSLayoutRelationEqual,
+			self, NSLayoutAttributeTop,
+			1, 0,
+			@"uiForm label top");
+		[self addConstraint:self.top];
+		self.trailing = mkConstraint(self.label, NSLayoutAttributeTrailing,
+			NSLayoutRelationEqual,
+			self, NSLayoutAttributeTrailing,
+			1, 0,
+			@"uiForm label trailing");
+		[self addConstraint:self.trailing];
+		self.bottom = mkConstraint(self.label, NSLayoutAttributeBottom,
+			NSLayoutRelationEqual,
+			self, NSLayoutAttributeBottom,
+			1, 0,
+			@"uiForm label bottom");
+		[self addConstraint:self.bottom];
+	}
+	return self;
+}
+
+- (void)onDestroy
+{
+	[self removeConstraint:self.trailing];
+	self.trailing = nil;
+	[self removeConstraint:self.top];
+	self.top = nil;
+	[self removeConstraint:self.bottom];
+	self.bottom = nil;
+
+	[self.label removeFromSuperview];
+	self.label = nil;
+}
+
+- (NSView *)view
+{
+	return (NSView *) uiControlHandle(self.c);
+}
+
+@end
+
+@implementation formView
+
+- (id)initWithF:(uiForm *)ff
+{
+	self = [super initWithFrame:NSZeroRect];
+	if (self != nil) {
+		self->f = ff;
+		self->padded = 0;
+		self->children = [NSMutableArray new];
+
+		self->inBetweens = [NSMutableArray new];
+		self->widths = [NSMutableArray new];
+		self->leadings = [NSMutableArray new];
+		self->middles = [NSMutableArray new];
+		self->trailings = [NSMutableArray new];
+	}
+	return self;
+}
+
+- (void)onDestroy
+{
+	formChild *fc;
+
+	[self removeOurConstraints];
+	[self->inBetweens release];
+	[self->widths release];
+	[self->leadings release];
+	[self->middles release];
+	[self->trailings release];
+
+	for (fc in self->children) {
+		[self removeConstraint:fc.baseline];
+		fc.baseline = nil;
+		uiControlSetParent(fc.c, NULL);
+		uiDarwinControlSetSuperview(uiDarwinControl(fc.c), nil);
+		uiControlDestroy(fc.c);
+		[fc onDestroy];
+		[fc removeFromSuperview];
+	}
+	[self->children release];
+}
+
+- (void)removeOurConstraints
+{
+	if (self->first != nil) {
+		[self removeConstraint:self->first];
+		[self->first release];
+		self->first = nil;
+	}
+	if ([self->inBetweens count] != 0) {
+		[self removeConstraints:self->inBetweens];
+		[self->inBetweens removeAllObjects];
+	}
+	if (self->last != nil) {
+		[self removeConstraint:self->last];
+		[self->last release];
+		self->last = nil;
+	}
+	if ([self->widths count] != 0) {
+		[self removeConstraints:self->widths];
+		[self->widths removeAllObjects];
+	}
+	if ([self->leadings count] != 0) {
+		[self removeConstraints:self->leadings];
+		[self->leadings removeAllObjects];
+	}
+	if ([self->middles count] != 0) {
+		[self removeConstraints:self->middles];
+		[self->middles removeAllObjects];
+	}
+	if ([self->trailings count] != 0) {
+		[self removeConstraints:self->trailings];
+		[self->trailings removeAllObjects];
+	}
+}
+
+- (void)syncEnableStates:(int)enabled
+{
+	formChild *fc;
+
+	for (fc in self->children)
+		uiDarwinControlSyncEnableState(uiDarwinControl(fc.c), enabled);
+}
+
+- (CGFloat)paddingAmount
+{
+	if (!self->padded)
+		return 0.0;
+	return uiDarwinPaddingAmount(NULL);
+}
+
+- (void)establishOurConstraints
+{
+	formChild *fc;
+	CGFloat padding;
+	NSView *prev, *prevlabel;
+	NSLayoutConstraint *c;
+
+	[self removeOurConstraints];
+	if ([self->children count] == 0)
+		return;
+	padding = [self paddingAmount];
+
+	// first arrange the children vertically and make them the same width
+	prev = nil;
+	for (fc in self->children) {
+		[fc setHidden:!uiControlVisible(fc.c)];
+		if (!uiControlVisible(fc.c))
+			continue;
+		if (prev == nil) {			// first view
+			self->first = mkConstraint(self, NSLayoutAttributeTop,
+				NSLayoutRelationEqual,
+				[fc view], NSLayoutAttributeTop,
+				1, 0,
+				@"uiForm first vertical constraint");
+			[self addConstraint:self->first];
+			[self->first retain];
+			prev = [fc view];
+			prevlabel = fc;
+			continue;
+		}
+		// not the first; link it
+		c = mkConstraint(prev, NSLayoutAttributeBottom,
+			NSLayoutRelationEqual,
+			[fc view], NSLayoutAttributeTop,
+			1, -padding,
+			@"uiForm in-between vertical constraint");
+		[self addConstraint:c];
+		[self->inBetweens addObject:c];
+		// and make the same width
+		c = mkConstraint(prev, NSLayoutAttributeWidth,
+			NSLayoutRelationEqual,
+			[fc view], NSLayoutAttributeWidth,
+			1, 0,
+			@"uiForm control width constraint");
+		[self addConstraint:c];
+		[self->widths addObject:c];
+		c = mkConstraint(prevlabel, NSLayoutAttributeWidth,
+			NSLayoutRelationEqual,
+			fc, NSLayoutAttributeWidth,
+			1, 0,
+			@"uiForm label lwidth constraint");
+		[self addConstraint:c];
+		[self->widths addObject:c];
+		prev = [fc view];
+		prevlabel = fc;
+	}
+	if (prev == nil)		// all hidden; act as if nothing there
+		return;
+	self->last = mkConstraint(prev, NSLayoutAttributeBottom,
+		NSLayoutRelationEqual,
+		self, NSLayoutAttributeBottom,
+		1, 0,
+		@"uiForm last vertical constraint");
+	[self addConstraint:self->last];
+	[self->last retain];
+
+	// now arrange the controls horizontally
+	for (fc in self->children) {
+		if (!uiControlVisible(fc.c))
+			continue;
+		c = mkConstraint(self, NSLayoutAttributeLeading,
+			NSLayoutRelationEqual,
+			fc, NSLayoutAttributeLeading,
+			1, 0,
+			@"uiForm leading constraint");
+		[self addConstraint:c];
+		[self->leadings addObject:c];
+		// coerce the control to be as wide as possible
+		// see http://stackoverflow.com/questions/37710892/in-auto-layout-i-set-up-labels-that-shouldnt-grow-horizontally-and-controls-th
+		c = mkConstraint(self, NSLayoutAttributeLeading,
+			NSLayoutRelationEqual,
+			[fc view], NSLayoutAttributeLeading,
+			1, 0,
+			@"uiForm leading constraint");
+		[c setPriority:NSLayoutPriorityDefaultHigh];
+		[self addConstraint:c];
+		[self->leadings addObject:c];
+		c = mkConstraint(fc, NSLayoutAttributeTrailing,
+			NSLayoutRelationEqual,
+			[fc view], NSLayoutAttributeLeading,
+			1, -padding,
+			@"uiForm middle constraint");
+		[self addConstraint:c];
+		[self->middles addObject:c];
+		c = mkConstraint([fc view], NSLayoutAttributeTrailing,
+			NSLayoutRelationEqual,
+			self, NSLayoutAttributeTrailing,
+			1, 0,
+			@"uiForm trailing constraint");
+		[self addConstraint:c];
+		[self->trailings addObject:c];
+		// TODO
+		c = mkConstraint(fc, NSLayoutAttributeBottom,
+			NSLayoutRelationLessThanOrEqual,
+			self, NSLayoutAttributeBottom,
+			1, 0,
+			@"TODO");
+		[self addConstraint:c];
+		[self->trailings addObject:c];
+	}
+
+	// and make all stretchy controls have the same height
+	prev = nil;
+	for (fc in self->children) {
+		if (!uiControlVisible(fc.c))
+			continue;
+		if (!fc.stretchy)
+			continue;
+		if (prev == nil) {
+			prev = [fc view];
+			continue;
+		}
+		c = mkConstraint([fc view], NSLayoutAttributeHeight,
+			NSLayoutRelationEqual,
+			prev, NSLayoutAttributeHeight,
+			1, 0,
+			@"uiForm stretchy constraint");
+		[self addConstraint:c];
+		// TODO make a dedicated array for this
+		[self->leadings addObject:c];
+	}
+
+	// we don't arrange the labels vertically; that's done when we add the control since those constraints don't need to change (they just need to be at their baseline)
+}
+
+- (void)append:(NSString *)label c:(uiControl *)c stretchy:(int)stretchy
+{
+	formChild *fc;
+	NSLayoutPriority priority;
+	NSLayoutAttribute attribute;
+	int oldnStretchy;
+
+	fc = [[formChild alloc] initWithLabel:newLabel(label)];
+	fc.c = c;
+	fc.stretchy = stretchy;
+	fc.oldHorzHuggingPri = uiDarwinControlHuggingPriority(uiDarwinControl(fc.c), NSLayoutConstraintOrientationHorizontal);
+	fc.oldVertHuggingPri = uiDarwinControlHuggingPriority(uiDarwinControl(fc.c), NSLayoutConstraintOrientationVertical);
+	[fc setTranslatesAutoresizingMaskIntoConstraints:NO];
+	[self addSubview:fc];
+
+	uiControlSetParent(fc.c, uiControl(self->f));
+	uiDarwinControlSetSuperview(uiDarwinControl(fc.c), self);
+	uiDarwinControlSyncEnableState(uiDarwinControl(fc.c), uiControlEnabledToUser(uiControl(self->f)));
+
+	// if a control is stretchy, it should not hug vertically
+	// otherwise, it should *forcibly* hug
+	if (fc.stretchy)
+		priority = NSLayoutPriorityDefaultLow;
+	else
+		// LONGTERM will default high work?
+		priority = NSLayoutPriorityRequired;
+	uiDarwinControlSetHuggingPriority(uiDarwinControl(fc.c), priority, NSLayoutConstraintOrientationVertical);
+	// make sure controls don't hug their horizontal direction so they fill the width of the view
+	uiDarwinControlSetHuggingPriority(uiDarwinControl(fc.c), NSLayoutPriorityDefaultLow, NSLayoutConstraintOrientationHorizontal);
+
+	// and constrain the baselines to position the label vertically
+	// if the view is a scroll view, align tops, not baselines
+	// this is what Interface Builder does
+	attribute = NSLayoutAttributeBaseline;
+	if ([[fc view] isKindOfClass:[NSScrollView class]])
+		attribute = NSLayoutAttributeTop;
+	fc.baseline = mkConstraint(fc.label, attribute,
+		NSLayoutRelationEqual,
+		[fc view], attribute,
+		1, 0,
+		@"uiForm baseline constraint");
+	[self addConstraint:fc.baseline];
+
+	oldnStretchy = [self nStretchy];
+	[self->children addObject:fc];
+
+	[self establishOurConstraints];
+	if (fc.stretchy)
+		if (oldnStretchy == 0)
+			uiDarwinNotifyEdgeHuggingChanged(uiDarwinControl(self->f));
+
+	[fc release];		// we don't need the initial reference now
+}
+
+- (void)delete:(int)n
+{
+	formChild *fc;
+	int stretchy;
+
+	fc = (formChild *) [self->children objectAtIndex:n];
+	stretchy = fc.stretchy;
+
+	uiControlSetParent(fc.c, NULL);
+	uiDarwinControlSetSuperview(uiDarwinControl(fc.c), nil);
+
+	uiDarwinControlSetHuggingPriority(uiDarwinControl(fc.c), fc.oldHorzHuggingPri, NSLayoutConstraintOrientationHorizontal);
+	uiDarwinControlSetHuggingPriority(uiDarwinControl(fc.c), fc.oldVertHuggingPri, NSLayoutConstraintOrientationVertical);
+
+	[fc onDestroy];
+	[self->children removeObjectAtIndex:n];
+
+	[self establishOurConstraints];
+	if (stretchy)
+		if ([self nStretchy] == 0)
+			uiDarwinNotifyEdgeHuggingChanged(uiDarwinControl(self->f));
+}
+
+- (int)isPadded
+{
+	return self->padded;
+}
+
+- (void)setPadded:(int)p
+{
+	CGFloat padding;
+	NSLayoutConstraint *c;
+
+	self->padded = p;
+	padding = [self paddingAmount];
+	for (c in self->inBetweens)
+		[c setConstant:-padding];
+	for (c in self->middles)
+		[c setConstant:-padding];
+}
+
+- (BOOL)hugsTrailing
+{
+	return YES;			// always hug trailing
+}
+
+- (BOOL)hugsBottom
+{
+	// only hug if we have stretchy
+	return [self nStretchy] != 0;
+}
+
+- (int)nStretchy
+{
+	formChild *fc;
+	int n;
+
+	n = 0;
+	for (fc in self->children) {
+		if (!uiControlVisible(fc.c))
+			continue;
+		if (fc.stretchy)
+			n++;
+	}
+	return n;
+}
+
+@end
+
+static void uiFormDestroy(uiControl *c)
+{
+	uiForm *f = uiForm(c);
+
+	[f->view onDestroy];
+	[f->view release];
+	uiFreeControl(uiControl(f));
+}
+
+uiDarwinControlDefaultHandle(uiForm, view)
+uiDarwinControlDefaultParent(uiForm, view)
+uiDarwinControlDefaultSetParent(uiForm, view)
+uiDarwinControlDefaultToplevel(uiForm, view)
+uiDarwinControlDefaultVisible(uiForm, view)
+uiDarwinControlDefaultShow(uiForm, view)
+uiDarwinControlDefaultHide(uiForm, view)
+uiDarwinControlDefaultEnabled(uiForm, view)
+uiDarwinControlDefaultEnable(uiForm, view)
+uiDarwinControlDefaultDisable(uiForm, view)
+
+static void uiFormSyncEnableState(uiDarwinControl *c, int enabled)
+{
+	uiForm *f = uiForm(c);
+
+	if (uiDarwinShouldStopSyncEnableState(uiDarwinControl(f), enabled))
+		return;
+	[f->view syncEnableStates:enabled];
+}
+
+uiDarwinControlDefaultSetSuperview(uiForm, view)
+
+static BOOL uiFormHugsTrailingEdge(uiDarwinControl *c)
+{
+	uiForm *f = uiForm(c);
+
+	return [f->view hugsTrailing];
+}
+
+static BOOL uiFormHugsBottom(uiDarwinControl *c)
+{
+	uiForm *f = uiForm(c);
+
+	return [f->view hugsBottom];
+}
+
+static void uiFormChildEdgeHuggingChanged(uiDarwinControl *c)
+{
+	uiForm *f = uiForm(c);
+
+	[f->view establishOurConstraints];
+}
+
+uiDarwinControlDefaultHuggingPriority(uiForm, view)
+uiDarwinControlDefaultSetHuggingPriority(uiForm, view)
+
+static void uiFormChildVisibilityChanged(uiDarwinControl *c)
+{
+	uiForm *f = uiForm(c);
+
+	[f->view establishOurConstraints];
+}
+
+void uiFormAppend(uiForm *f, const char *label, uiControl *c, int stretchy)
+{
+	// LONGTERM on other platforms
+	// or at leat allow this and implicitly turn it into a spacer
+	if (c == NULL)
+		userbug("You cannot add NULL to a uiForm.");
+	[f->view append:toNSString(label) c:c stretchy:stretchy];
+}
+
+void uiFormDelete(uiForm *f, int n)
+{
+	[f->view delete:n];
+}
+
+int uiFormPadded(uiForm *f)
+{
+	return [f->view isPadded];
+}
+
+void uiFormSetPadded(uiForm *f, int padded)
+{
+	[f->view setPadded:padded];
+}
+
+uiForm *uiNewForm(void)
+{
+	uiForm *f;
+
+	uiDarwinNewControl(uiForm, f);
+
+	f->view = [[formView alloc] initWithF:f];
+
+	return f;
+}
diff --git a/src/libui_sdl/libui/darwin/grid.m b/src/libui_sdl/libui/darwin/grid.m
new file mode 100644
index 0000000..d5c5fb1
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/grid.m
@@ -0,0 +1,800 @@
+// 11 june 2016
+#import "uipriv_darwin.h"
+
+// TODO the assorted test doesn't work right at all
+
+@interface gridChild : NSView
+@property uiControl *c;
+@property int left;
+@property int top;
+@property int xspan;
+@property int yspan;
+@property int hexpand;
+@property uiAlign halign;
+@property int vexpand;
+@property uiAlign valign;
+
+@property (strong) NSLayoutConstraint *leadingc;
+@property (strong) NSLayoutConstraint *topc;
+@property (strong) NSLayoutConstraint *trailingc;
+@property (strong) NSLayoutConstraint *bottomc;
+@property (strong) NSLayoutConstraint *xcenterc;
+@property (strong) NSLayoutConstraint *ycenterc;
+
+@property NSLayoutPriority oldHorzHuggingPri;
+@property NSLayoutPriority oldVertHuggingPri;
+- (void)setC:(uiControl *)c grid:(uiGrid *)g;
+- (void)onDestroy;
+- (NSView *)view;
+@end
+
+@interface gridView : NSView {
+	uiGrid *g;
+	NSMutableArray *children;
+	int padded;
+
+	NSMutableArray *edges;
+	NSMutableArray *inBetweens;
+
+	NSMutableArray *emptyCellViews;
+}
+- (id)initWithG:(uiGrid *)gg;
+- (void)onDestroy;
+- (void)removeOurConstraints;
+- (void)syncEnableStates:(int)enabled;
+- (CGFloat)paddingAmount;
+- (void)establishOurConstraints;
+- (void)append:(gridChild *)gc;
+- (void)insert:(gridChild *)gc after:(uiControl *)c at:(uiAt)at;
+- (int)isPadded;
+- (void)setPadded:(int)p;
+- (BOOL)hugsTrailing;
+- (BOOL)hugsBottom;
+- (int)nhexpand;
+- (int)nvexpand;
+@end
+
+struct uiGrid {
+	uiDarwinControl c;
+	gridView *view;
+};
+
+@implementation gridChild
+
+- (void)setC:(uiControl *)c grid:(uiGrid *)g
+{
+	self.c = c;
+	self.oldHorzHuggingPri = uiDarwinControlHuggingPriority(uiDarwinControl(self.c), NSLayoutConstraintOrientationHorizontal);
+	self.oldVertHuggingPri = uiDarwinControlHuggingPriority(uiDarwinControl(self.c), NSLayoutConstraintOrientationVertical);
+
+	uiControlSetParent(self.c, uiControl(g));
+	uiDarwinControlSetSuperview(uiDarwinControl(self.c), self);
+	uiDarwinControlSyncEnableState(uiDarwinControl(self.c), uiControlEnabledToUser(uiControl(g)));
+
+	if (self.halign == uiAlignStart || self.halign == uiAlignFill) {
+		self.leadingc = mkConstraint(self, NSLayoutAttributeLeading,
+			NSLayoutRelationEqual,
+			[self view], NSLayoutAttributeLeading,
+			1, 0,
+			@"uiGrid child horizontal alignment start constraint");
+		[self addConstraint:self.leadingc];
+	}
+	if (self.halign == uiAlignCenter) {
+		self.xcenterc = mkConstraint(self, NSLayoutAttributeCenterX,
+			NSLayoutRelationEqual,
+			[self view], NSLayoutAttributeCenterX,
+			1, 0,
+			@"uiGrid child horizontal alignment center constraint");
+		[self addConstraint:self.xcenterc];
+	}
+	if (self.halign == uiAlignEnd || self.halign == uiAlignFill) {
+		self.trailingc = mkConstraint(self, NSLayoutAttributeTrailing,
+			NSLayoutRelationEqual,
+			[self view], NSLayoutAttributeTrailing,
+			1, 0,
+			@"uiGrid child horizontal alignment end constraint");
+		[self addConstraint:self.trailingc];
+	}
+
+	if (self.valign == uiAlignStart || self.valign == uiAlignFill) {
+		self.topc = mkConstraint(self, NSLayoutAttributeTop,
+			NSLayoutRelationEqual,
+			[self view], NSLayoutAttributeTop,
+			1, 0,
+			@"uiGrid child vertical alignment start constraint");
+		[self addConstraint:self.topc];
+	}
+	if (self.valign == uiAlignCenter) {
+		self.ycenterc = mkConstraint(self, NSLayoutAttributeCenterY,
+			NSLayoutRelationEqual,
+			[self view], NSLayoutAttributeCenterY,
+			1, 0,
+			@"uiGrid child vertical alignment center constraint");
+		[self addConstraint:self.ycenterc];
+	}
+	if (self.valign == uiAlignEnd || self.valign == uiAlignFill) {
+		self.bottomc = mkConstraint(self, NSLayoutAttributeBottom,
+			NSLayoutRelationEqual,
+			[self view], NSLayoutAttributeBottom,
+			1, 0,
+			@"uiGrid child vertical alignment end constraint");
+		[self addConstraint:self.bottomc];
+	}
+}
+
+- (void)onDestroy
+{
+	if (self.leadingc != nil) {
+		[self removeConstraint:self.leadingc];
+		self.leadingc = nil;
+	}
+	if (self.topc != nil) {
+		[self removeConstraint:self.topc];
+		self.topc = nil;
+	}
+	if (self.trailingc != nil) {
+		[self removeConstraint:self.trailingc];
+		self.trailingc = nil;
+	}
+	if (self.bottomc != nil) {
+		[self removeConstraint:self.bottomc];
+		self.bottomc = nil;
+	}
+	if (self.xcenterc != nil) {
+		[self removeConstraint:self.xcenterc];
+		self.xcenterc = nil;
+	}
+	if (self.ycenterc != nil) {
+		[self removeConstraint:self.ycenterc];
+		self.ycenterc = nil;
+	}
+
+	uiControlSetParent(self.c, NULL);
+	uiDarwinControlSetSuperview(uiDarwinControl(self.c), nil);
+	uiDarwinControlSetHuggingPriority(uiDarwinControl(self.c), self.oldHorzHuggingPri, NSLayoutConstraintOrientationHorizontal);
+	uiDarwinControlSetHuggingPriority(uiDarwinControl(self.c), self.oldVertHuggingPri, NSLayoutConstraintOrientationVertical);
+}
+
+- (NSView *)view
+{
+	return (NSView *) uiControlHandle(self.c);
+}
+
+@end
+
+@implementation gridView
+
+- (id)initWithG:(uiGrid *)gg
+{
+	self = [super initWithFrame:NSZeroRect];
+	if (self != nil) {
+		self->g = gg;
+		self->padded = 0;
+		self->children = [NSMutableArray new];
+
+		self->edges = [NSMutableArray new];
+		self->inBetweens = [NSMutableArray new];
+
+		self->emptyCellViews = [NSMutableArray new];
+	}
+	return self;
+}
+
+- (void)onDestroy
+{
+	gridChild *gc;
+
+	[self removeOurConstraints];
+	[self->edges release];
+	[self->inBetweens release];
+
+	[self->emptyCellViews release];
+
+	for (gc in self->children) {
+		[gc onDestroy];
+		uiControlDestroy(gc.c);
+		[gc removeFromSuperview];
+	}
+	[self->children release];
+}
+
+- (void)removeOurConstraints
+{
+	NSView *v;
+
+	if ([self->edges count] != 0) {
+		[self removeConstraints:self->edges];
+		[self->edges removeAllObjects];
+	}
+	if ([self->inBetweens count] != 0) {
+		[self removeConstraints:self->inBetweens];
+		[self->inBetweens removeAllObjects];
+	}
+
+	for (v in self->emptyCellViews)
+		[v removeFromSuperview];
+	[self->emptyCellViews removeAllObjects];
+}
+
+- (void)syncEnableStates:(int)enabled
+{
+	gridChild *gc;
+
+	for (gc in self->children)
+		uiDarwinControlSyncEnableState(uiDarwinControl(gc.c), enabled);
+}
+
+- (CGFloat)paddingAmount
+{
+	if (!self->padded)
+		return 0.0;
+	return uiDarwinPaddingAmount(NULL);
+}
+
+// LONGTERM stop early if all controls are hidden
+- (void)establishOurConstraints
+{
+	gridChild *gc;
+	CGFloat padding;
+	int xmin, ymin;
+	int xmax, ymax;
+	int xcount, ycount;
+	BOOL first;
+	int **gg;
+	NSView ***gv;
+	BOOL **gspan;
+	int x, y;
+	int i;
+	NSLayoutConstraint *c;
+	int firstx, firsty;
+	BOOL *hexpand, *vexpand;
+	BOOL doit;
+	BOOL onlyEmptyAndSpanning;
+
+	[self removeOurConstraints];
+	if ([self->children count] == 0)
+		return;
+	padding = [self paddingAmount];
+
+	// first, figure out the minimum and maximum row and column numbers
+	// ignore hidden controls
+	first = YES;
+	for (gc in self->children) {
+		// this bit is important: it ensures row ymin and column xmin have at least one cell to draw, so the onlyEmptyAndSpanning logic below will never run on those rows
+		if (!uiControlVisible(gc.c))
+			continue;
+		if (first) {
+			xmin = gc.left;
+			ymin = gc.top;
+			xmax = gc.left + gc.xspan;
+			ymax = gc.top + gc.yspan;
+			first = NO;
+			continue;
+		}
+		if (xmin > gc.left)
+			xmin = gc.left;
+		if (ymin > gc.top)
+			ymin = gc.top;
+		if (xmax < (gc.left + gc.xspan))
+			xmax = gc.left + gc.xspan;
+		if (ymax < (gc.top + gc.yspan))
+			ymax = gc.top + gc.yspan;
+	}
+	if (first != NO)		// the entire grid is hidden; do nothing
+		return;
+	xcount = xmax - xmin;
+	ycount = ymax - ymin;
+
+	// now build a topological map of the grid gg[y][x]
+	// also figure out which cells contain spanned views so they can be ignored later
+	// treat hidden controls by keeping the indices -1
+	gg = (int **) uiAlloc(ycount * sizeof (int *), "int[][]");
+	gspan = (BOOL **) uiAlloc(ycount * sizeof (BOOL *), "BOOL[][]");
+	for (y = 0; y < ycount; y++) {
+		gg[y] = (int *) uiAlloc(xcount * sizeof (int), "int[]");
+		gspan[y] = (BOOL *) uiAlloc(xcount * sizeof (BOOL), "BOOL[]");
+		for (x = 0; x < xcount; x++)
+			gg[y][x] = -1;		// empty
+	}
+	for (i = 0; i < [self->children count]; i++) {
+		gc = (gridChild *) [self->children objectAtIndex:i];
+		if (!uiControlVisible(gc.c))
+			continue;
+		for (y = gc.top; y < gc.top + gc.yspan; y++)
+			for (x = gc.left; x < gc.left + gc.xspan; x++) {
+				gg[y - ymin][x - xmin] = i;
+				if (x != gc.left || y != gc.top)
+					gspan[y - ymin][x - xmin] = YES;
+			}
+	}
+
+	// if a row or column only contains emptys and spanning cells of a opposite-direction spannings, remove it by duplicating the previous row or column
+	for (y = 0; y < ycount; y++) {
+		onlyEmptyAndSpanning = YES;
+		for (x = 0; x < xcount; x++)
+			if (gg[y][x] != -1) {
+				gc = (gridChild *) [self->children objectAtIndex:gg[y][x]];
+				if (gc.yspan == 1 || gc.top - ymin == y) {
+					onlyEmptyAndSpanning = NO;
+					break;
+				}
+			}
+		if (onlyEmptyAndSpanning)
+			for (x = 0; x < xcount; x++) {
+				gg[y][x] = gg[y - 1][x];
+				gspan[y][x] = YES;
+			}
+	}
+	for (x = 0; x < xcount; x++) {
+		onlyEmptyAndSpanning = YES;
+		for (y = 0; y < ycount; y++)
+			if (gg[y][x] != -1) {
+				gc = (gridChild *) [self->children objectAtIndex:gg[y][x]];
+				if (gc.xspan == 1 || gc.left - xmin == x) {
+					onlyEmptyAndSpanning = NO;
+					break;
+				}
+			}
+		if (onlyEmptyAndSpanning)
+			for (y = 0; y < ycount; y++) {
+				gg[y][x] = gg[y][x - 1];
+				gspan[y][x] = YES;
+			}
+	}
+
+	// now build a topological map of the grid's views gv[y][x]
+	// for any empty cell, create a dummy view
+	gv = (NSView ***) uiAlloc(ycount * sizeof (NSView **), "NSView *[][]");
+	for (y = 0; y < ycount; y++) {
+		gv[y] = (NSView **) uiAlloc(xcount * sizeof (NSView *), "NSView *[]");
+		for (x = 0; x < xcount; x++)
+			if (gg[y][x] == -1) {
+				gv[y][x] = [[NSView alloc] initWithFrame:NSZeroRect];
+				[gv[y][x] setTranslatesAutoresizingMaskIntoConstraints:NO];
+				[self addSubview:gv[y][x]];
+				[self->emptyCellViews addObject:gv[y][x]];
+			} else {
+				gc = (gridChild *) [self->children objectAtIndex:gg[y][x]];
+				gv[y][x] = gc;
+			}
+	}
+
+	// now figure out which rows and columns really expand
+	hexpand = (BOOL *) uiAlloc(xcount * sizeof (BOOL), "BOOL[]");
+	vexpand = (BOOL *) uiAlloc(ycount * sizeof (BOOL), "BOOL[]");
+	// first, which don't span
+	for (gc in self->children) {
+		if (!uiControlVisible(gc.c))
+			continue;
+		if (gc.hexpand && gc.xspan == 1)
+			hexpand[gc.left - xmin] = YES;
+		if (gc.vexpand && gc.yspan == 1)
+			vexpand[gc.top - ymin] = YES;
+	}
+	// second, which do span
+	// the way we handle this is simple: if none of the spanned rows/columns expand, make all rows/columns expand
+	for (gc in self->children) {
+		if (!uiControlVisible(gc.c))
+			continue;
+		if (gc.hexpand && gc.xspan != 1) {
+			doit = YES;
+			for (x = gc.left; x < gc.left + gc.xspan; x++)
+				if (hexpand[x - xmin]) {
+					doit = NO;
+					break;
+				}
+			if (doit)
+				for (x = gc.left; x < gc.left + gc.xspan; x++)
+					hexpand[x - xmin] = YES;
+		}
+		if (gc.vexpand && gc.yspan != 1) {
+			doit = YES;
+			for (y = gc.top; y < gc.top + gc.yspan; y++)
+				if (vexpand[y - ymin]) {
+					doit = NO;
+					break;
+				}
+			if (doit)
+				for (y = gc.top; y < gc.top + gc.yspan; y++)
+					vexpand[y - ymin] = YES;
+		}
+	}
+
+	// now establish all the edge constraints
+	// leading and trailing edges
+	for (y = 0; y < ycount; y++) {
+		c = mkConstraint(self, NSLayoutAttributeLeading,
+			NSLayoutRelationEqual,
+			gv[y][0], NSLayoutAttributeLeading,
+			1, 0,
+			@"uiGrid leading edge constraint");
+		[self addConstraint:c];
+		[self->edges addObject:c];
+		c = mkConstraint(self, NSLayoutAttributeTrailing,
+			NSLayoutRelationEqual,
+			gv[y][xcount - 1], NSLayoutAttributeTrailing,
+			1, 0,
+			@"uiGrid trailing edge constraint");
+		[self addConstraint:c];
+		[self->edges addObject:c];
+	}
+	// top and bottom edges
+	for (x = 0; x < xcount; x++) {
+		c = mkConstraint(self, NSLayoutAttributeTop,
+			NSLayoutRelationEqual,
+			gv[0][x], NSLayoutAttributeTop,
+			1, 0,
+			@"uiGrid top edge constraint");
+		[self addConstraint:c];
+		[self->edges addObject:c];
+		c = mkConstraint(self, NSLayoutAttributeBottom,
+			NSLayoutRelationEqual,
+			gv[ycount - 1][x], NSLayoutAttributeBottom,
+			1, 0,
+			@"uiGrid bottom edge constraint");
+		[self addConstraint:c];
+		[self->edges addObject:c];
+	}
+
+	// now align leading and top edges
+	// do NOT align spanning cells!
+	for (x = 0; x < xcount; x++) {
+		for (y = 0; y < ycount; y++)
+			if (!gspan[y][x])
+				break;
+		firsty = y;
+		for (y++; y < ycount; y++) {
+			if (gspan[y][x])
+				continue;
+			c = mkConstraint(gv[firsty][x], NSLayoutAttributeLeading,
+				NSLayoutRelationEqual,
+				gv[y][x], NSLayoutAttributeLeading,
+				1, 0,
+				@"uiGrid column leading constraint");
+			[self addConstraint:c];
+			[self->edges addObject:c];
+		}
+	}
+	for (y = 0; y < ycount; y++) {
+		for (x = 0; x < xcount; x++)
+			if (!gspan[y][x])
+				break;
+		firstx = x;
+		for (x++; x < xcount; x++) {
+			if (gspan[y][x])
+				continue;
+			c = mkConstraint(gv[y][firstx], NSLayoutAttributeTop,
+				NSLayoutRelationEqual,
+				gv[y][x], NSLayoutAttributeTop,
+				1, 0,
+				@"uiGrid row top constraint");
+			[self addConstraint:c];
+			[self->edges addObject:c];
+		}
+	}
+
+	// now string adjacent views together
+	for (y = 0; y < ycount; y++)
+		for (x = 1; x < xcount; x++)
+			if (gv[y][x - 1] != gv[y][x]) {
+				c = mkConstraint(gv[y][x - 1], NSLayoutAttributeTrailing,
+					NSLayoutRelationEqual,
+					gv[y][x], NSLayoutAttributeLeading,
+					1, -padding,
+					@"uiGrid internal horizontal constraint");
+				[self addConstraint:c];
+				[self->inBetweens addObject:c];
+			}
+	for (x = 0; x < xcount; x++)
+		for (y = 1; y < ycount; y++)
+			if (gv[y - 1][x] != gv[y][x]) {
+				c = mkConstraint(gv[y - 1][x], NSLayoutAttributeBottom,
+					NSLayoutRelationEqual,
+					gv[y][x], NSLayoutAttributeTop,
+					1, -padding,
+					@"uiGrid internal vertical constraint");
+				[self addConstraint:c];
+				[self->inBetweens addObject:c];
+			}
+
+	// now set priorities for all widgets that expand or not
+	// if a cell is in an expanding row, OR If it spans, then it must be willing to stretch
+	// otherwise, it tries not to
+	// note we don't use NSLayoutPriorityRequired as that will cause things to squish when they shouldn't
+	for (gc in self->children) {
+		NSLayoutPriority priority;
+
+		if (!uiControlVisible(gc.c))
+			continue;
+		if (hexpand[gc.left - xmin] || gc.xspan != 1)
+			priority = NSLayoutPriorityDefaultLow;
+		else
+			priority = NSLayoutPriorityDefaultHigh;
+		uiDarwinControlSetHuggingPriority(uiDarwinControl(gc.c), priority, NSLayoutConstraintOrientationHorizontal);
+		// same for vertical direction
+		if (vexpand[gc.top - ymin] || gc.yspan != 1)
+			priority = NSLayoutPriorityDefaultLow;
+		else
+			priority = NSLayoutPriorityDefaultHigh;
+		uiDarwinControlSetHuggingPriority(uiDarwinControl(gc.c), priority, NSLayoutConstraintOrientationVertical);
+	}
+
+	// TODO make all expanding rows/columns the same height/width
+
+	// and finally clean up
+	uiFree(hexpand);
+	uiFree(vexpand);
+	for (y = 0; y < ycount; y++) {
+		uiFree(gg[y]);
+		uiFree(gv[y]);
+		uiFree(gspan[y]);
+	}
+	uiFree(gg);
+	uiFree(gv);
+	uiFree(gspan);
+}
+
+- (void)append:(gridChild *)gc
+{
+	BOOL update;
+	int oldnh, oldnv;
+
+	[gc setTranslatesAutoresizingMaskIntoConstraints:NO];
+	[self addSubview:gc];
+
+	// no need to set priority here; that's done in establishOurConstraints
+
+	oldnh = [self nhexpand];
+	oldnv = [self nvexpand];
+	[self->children addObject:gc];
+
+	[self establishOurConstraints];
+	update = NO;
+	if (gc.hexpand)
+		if (oldnh == 0)
+			update = YES;
+	if (gc.vexpand)
+		if (oldnv == 0)
+			update = YES;
+	if (update)
+		uiDarwinNotifyEdgeHuggingChanged(uiDarwinControl(self->g));
+
+	[gc release];		// we don't need the initial reference now
+}
+
+- (void)insert:(gridChild *)gc after:(uiControl *)c at:(uiAt)at
+{
+	gridChild *other;
+	BOOL found;
+
+	found = NO;
+	for (other in self->children)
+		if (other.c == c) {
+			found = YES;
+			break;
+		}
+	if (!found)
+		userbug("Existing control %p is not in grid %p; you cannot add other controls next to it", c, self->g);
+
+	switch (at) {
+	case uiAtLeading:
+		gc.left = other.left - gc.xspan;
+		gc.top = other.top;
+		break;
+	case uiAtTop:
+		gc.left = other.left;
+		gc.top = other.top - gc.yspan;
+		break;
+	case uiAtTrailing:
+		gc.left = other.left + other.xspan;
+		gc.top = other.top;
+		break;
+	case uiAtBottom:
+		gc.left = other.left;
+		gc.top = other.top + other.yspan;
+		break;
+	// TODO add error checks to ALL enums
+	}
+
+	[self append:gc];
+}
+
+- (int)isPadded
+{
+	return self->padded;
+}
+
+- (void)setPadded:(int)p
+{
+	CGFloat padding;
+	NSLayoutConstraint *c;
+
+#if 0 /* TODO */
+dispatch_after(
+dispatch_time(DISPATCH_TIME_NOW, 3 * NSEC_PER_SEC),
+dispatch_get_main_queue(),
+^{ [[self window] visualizeConstraints:[self constraints]]; }
+);
+#endif
+	self->padded = p;
+	padding = [self paddingAmount];
+	for (c in self->inBetweens)
+		switch ([c firstAttribute]) {
+		case NSLayoutAttributeLeading:
+		case NSLayoutAttributeTop:
+			[c setConstant:padding];
+			break;
+		case NSLayoutAttributeTrailing:
+		case NSLayoutAttributeBottom:
+			[c setConstant:-padding];
+			break;
+		}
+}
+
+- (BOOL)hugsTrailing
+{
+	// only hug if we have horizontally expanding
+	return [self nhexpand] != 0;
+}
+
+- (BOOL)hugsBottom
+{
+	// only hug if we have vertically expanding
+	return [self nvexpand] != 0;
+}
+
+- (int)nhexpand
+{
+	gridChild *gc;
+	int n;
+
+	n = 0;
+	for (gc in self->children) {
+		if (!uiControlVisible(gc.c))
+			continue;
+		if (gc.hexpand)
+			n++;
+	}
+	return n;
+}
+
+- (int)nvexpand
+{
+	gridChild *gc;
+	int n;
+
+	n = 0;
+	for (gc in self->children) {
+		if (!uiControlVisible(gc.c))
+			continue;
+		if (gc.vexpand)
+			n++;
+	}
+	return n;
+}
+
+@end
+
+static void uiGridDestroy(uiControl *c)
+{
+	uiGrid *g = uiGrid(c);
+
+	[g->view onDestroy];
+	[g->view release];
+	uiFreeControl(uiControl(g));
+}
+
+uiDarwinControlDefaultHandle(uiGrid, view)
+uiDarwinControlDefaultParent(uiGrid, view)
+uiDarwinControlDefaultSetParent(uiGrid, view)
+uiDarwinControlDefaultToplevel(uiGrid, view)
+uiDarwinControlDefaultVisible(uiGrid, view)
+uiDarwinControlDefaultShow(uiGrid, view)
+uiDarwinControlDefaultHide(uiGrid, view)
+uiDarwinControlDefaultEnabled(uiGrid, view)
+uiDarwinControlDefaultEnable(uiGrid, view)
+uiDarwinControlDefaultDisable(uiGrid, view)
+
+static void uiGridSyncEnableState(uiDarwinControl *c, int enabled)
+{
+	uiGrid *g = uiGrid(c);
+
+	if (uiDarwinShouldStopSyncEnableState(uiDarwinControl(g), enabled))
+		return;
+	[g->view syncEnableStates:enabled];
+}
+
+uiDarwinControlDefaultSetSuperview(uiGrid, view)
+
+static BOOL uiGridHugsTrailingEdge(uiDarwinControl *c)
+{
+	uiGrid *g = uiGrid(c);
+
+	return [g->view hugsTrailing];
+}
+
+static BOOL uiGridHugsBottom(uiDarwinControl *c)
+{
+	uiGrid *g = uiGrid(c);
+
+	return [g->view hugsBottom];
+}
+
+static void uiGridChildEdgeHuggingChanged(uiDarwinControl *c)
+{
+	uiGrid *g = uiGrid(c);
+
+	[g->view establishOurConstraints];
+}
+
+uiDarwinControlDefaultHuggingPriority(uiGrid, view)
+uiDarwinControlDefaultSetHuggingPriority(uiGrid, view)
+
+static void uiGridChildVisibilityChanged(uiDarwinControl *c)
+{
+	uiGrid *g = uiGrid(c);
+
+	[g->view establishOurConstraints];
+}
+
+static gridChild *toChild(uiControl *c, int xspan, int yspan, int hexpand, uiAlign halign, int vexpand, uiAlign valign, uiGrid *g)
+{
+	gridChild *gc;
+
+	if (xspan < 0)
+		userbug("You cannot have a negative xspan in a uiGrid cell.");
+	if (yspan < 0)
+		userbug("You cannot have a negative yspan in a uiGrid cell.");
+	gc = [gridChild new];
+	gc.xspan = xspan;
+	gc.yspan = yspan;
+	gc.hexpand = hexpand;
+	gc.halign = halign;
+	gc.vexpand = vexpand;
+	gc.valign = valign;
+	[gc setC:c grid:g];
+	return gc;
+}
+
+void uiGridAppend(uiGrid *g, uiControl *c, int left, int top, int xspan, int yspan, int hexpand, uiAlign halign, int vexpand, uiAlign valign)
+{
+	gridChild *gc;
+
+	// LONGTERM on other platforms
+	// or at leat allow this and implicitly turn it into a spacer
+	if (c == NULL)
+		userbug("You cannot add NULL to a uiGrid.");
+	gc = toChild(c, xspan, yspan, hexpand, halign, vexpand, valign, g);
+	gc.left = left;
+	gc.top = top;
+	[g->view append:gc];
+}
+
+void uiGridInsertAt(uiGrid *g, uiControl *c, uiControl *existing, uiAt at, int xspan, int yspan, int hexpand, uiAlign halign, int vexpand, uiAlign valign)
+{
+	gridChild *gc;
+
+	gc = toChild(c, xspan, yspan, hexpand, halign, vexpand, valign, g);
+	[g->view insert:gc after:existing at:at];
+}
+
+int uiGridPadded(uiGrid *g)
+{
+	return [g->view isPadded];
+}
+
+void uiGridSetPadded(uiGrid *g, int padded)
+{
+	[g->view setPadded:padded];
+}
+
+uiGrid *uiNewGrid(void)
+{
+	uiGrid *g;
+
+	uiDarwinNewControl(uiGrid, g);
+
+	g->view = [[gridView alloc] initWithG:g];
+
+	return g;
+}
diff --git a/src/libui_sdl/libui/darwin/group.m b/src/libui_sdl/libui/darwin/group.m
new file mode 100644
index 0000000..0050bbd
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/group.m
@@ -0,0 +1,194 @@
+// 14 august 2015
+#import "uipriv_darwin.h"
+
+struct uiGroup {
+	uiDarwinControl c;
+	NSBox *box;
+	uiControl *child;
+	NSLayoutPriority oldHorzHuggingPri;
+	NSLayoutPriority oldVertHuggingPri;
+	int margined;
+	struct singleChildConstraints constraints;
+	NSLayoutPriority horzHuggingPri;
+	NSLayoutPriority vertHuggingPri;
+};
+
+static void removeConstraints(uiGroup *g)
+{
+	// set to contentView instead of to the box itself, otherwise we get clipping underneath the label
+	singleChildConstraintsRemove(&(g->constraints), [g->box contentView]);
+}
+
+static void uiGroupDestroy(uiControl *c)
+{
+	uiGroup *g = uiGroup(c);
+
+	removeConstraints(g);
+	if (g->child != NULL) {
+		uiControlSetParent(g->child, NULL);
+		uiDarwinControlSetSuperview(uiDarwinControl(g->child), nil);
+		uiControlDestroy(g->child);
+	}
+	[g->box release];
+	uiFreeControl(uiControl(g));
+}
+
+uiDarwinControlDefaultHandle(uiGroup, box)
+uiDarwinControlDefaultParent(uiGroup, box)
+uiDarwinControlDefaultSetParent(uiGroup, box)
+uiDarwinControlDefaultToplevel(uiGroup, box)
+uiDarwinControlDefaultVisible(uiGroup, box)
+uiDarwinControlDefaultShow(uiGroup, box)
+uiDarwinControlDefaultHide(uiGroup, box)
+uiDarwinControlDefaultEnabled(uiGroup, box)
+uiDarwinControlDefaultEnable(uiGroup, box)
+uiDarwinControlDefaultDisable(uiGroup, box)
+
+static void uiGroupSyncEnableState(uiDarwinControl *c, int enabled)
+{
+	uiGroup *g = uiGroup(c);
+
+	if (uiDarwinShouldStopSyncEnableState(uiDarwinControl(g), enabled))
+		return;
+	if (g->child != NULL)
+		uiDarwinControlSyncEnableState(uiDarwinControl(g->child), enabled);
+}
+
+uiDarwinControlDefaultSetSuperview(uiGroup, box)
+
+static void groupRelayout(uiGroup *g)
+{
+	NSView *childView;
+
+	removeConstraints(g);
+	if (g->child == NULL)
+		return;
+	childView = (NSView *) uiControlHandle(g->child);
+	singleChildConstraintsEstablish(&(g->constraints),
+		[g->box contentView], childView,
+		uiDarwinControlHugsTrailingEdge(uiDarwinControl(g->child)),
+		uiDarwinControlHugsBottom(uiDarwinControl(g->child)),
+		g->margined,
+		@"uiGroup");
+	// needed for some very rare drawing errors...
+	jiggleViewLayout(g->box);
+}
+
+// TODO rename these since I'm starting to get confused by what they mean by hugging
+BOOL uiGroupHugsTrailingEdge(uiDarwinControl *c)
+{
+	uiGroup *g = uiGroup(c);
+
+	// TODO make a function?
+	return g->horzHuggingPri < NSLayoutPriorityWindowSizeStayPut;
+}
+
+BOOL uiGroupHugsBottom(uiDarwinControl *c)
+{
+	uiGroup *g = uiGroup(c);
+
+	return g->vertHuggingPri < NSLayoutPriorityWindowSizeStayPut;
+}
+
+static void uiGroupChildEdgeHuggingChanged(uiDarwinControl *c)
+{
+	uiGroup *g = uiGroup(c);
+
+	groupRelayout(g);
+}
+
+static NSLayoutPriority uiGroupHuggingPriority(uiDarwinControl *c, NSLayoutConstraintOrientation orientation)
+{
+	uiGroup *g = uiGroup(c);
+
+	if (orientation == NSLayoutConstraintOrientationHorizontal)
+		return g->horzHuggingPri;
+	return g->vertHuggingPri;
+}
+
+static void uiGroupSetHuggingPriority(uiDarwinControl *c, NSLayoutPriority priority, NSLayoutConstraintOrientation orientation)
+{
+	uiGroup *g = uiGroup(c);
+
+	if (orientation == NSLayoutConstraintOrientationHorizontal)
+		g->horzHuggingPri = priority;
+	else
+		g->vertHuggingPri = priority;
+	uiDarwinNotifyEdgeHuggingChanged(uiDarwinControl(g));
+}
+
+static void uiGroupChildVisibilityChanged(uiDarwinControl *c)
+{
+	uiGroup *g = uiGroup(c);
+
+	groupRelayout(g);
+}
+
+char *uiGroupTitle(uiGroup *g)
+{
+	return uiDarwinNSStringToText([g->box title]);
+}
+
+void uiGroupSetTitle(uiGroup *g, const char *title)
+{
+	[g->box setTitle:toNSString(title)];
+}
+
+void uiGroupSetChild(uiGroup *g, uiControl *child)
+{
+	NSView *childView;
+
+	if (g->child != NULL) {
+		removeConstraints(g);
+		uiDarwinControlSetHuggingPriority(uiDarwinControl(g->child), g->oldHorzHuggingPri, NSLayoutConstraintOrientationHorizontal);
+		uiDarwinControlSetHuggingPriority(uiDarwinControl(g->child), g->oldVertHuggingPri, NSLayoutConstraintOrientationVertical);
+		uiControlSetParent(g->child, NULL);
+		uiDarwinControlSetSuperview(uiDarwinControl(g->child), nil);
+	}
+	g->child = child;
+	if (g->child != NULL) {
+		childView = (NSView *) uiControlHandle(g->child);
+		uiControlSetParent(g->child, uiControl(g));
+		uiDarwinControlSetSuperview(uiDarwinControl(g->child), [g->box contentView]);
+		uiDarwinControlSyncEnableState(uiDarwinControl(g->child), uiControlEnabledToUser(uiControl(g)));
+		// don't hug, just in case we're a stretchy group
+		g->oldHorzHuggingPri = uiDarwinControlHuggingPriority(uiDarwinControl(g->child), NSLayoutConstraintOrientationHorizontal);
+		g->oldVertHuggingPri = uiDarwinControlHuggingPriority(uiDarwinControl(g->child), NSLayoutConstraintOrientationVertical);
+		uiDarwinControlSetHuggingPriority(uiDarwinControl(g->child), NSLayoutPriorityDefaultLow, NSLayoutConstraintOrientationHorizontal);
+		uiDarwinControlSetHuggingPriority(uiDarwinControl(g->child), NSLayoutPriorityDefaultLow, NSLayoutConstraintOrientationVertical);
+	}
+	groupRelayout(g);
+}
+
+int uiGroupMargined(uiGroup *g)
+{
+	return g->margined;
+}
+
+void uiGroupSetMargined(uiGroup *g, int margined)
+{
+	g->margined = margined;
+	singleChildConstraintsSetMargined(&(g->constraints), g->margined);
+}
+
+uiGroup *uiNewGroup(const char *title)
+{
+	uiGroup *g;
+
+	uiDarwinNewControl(uiGroup, g);
+
+	g->box = [[NSBox alloc] initWithFrame:NSZeroRect];
+	[g->box setTitle:toNSString(title)];
+	[g->box setBoxType:NSBoxPrimary];
+	[g->box setBorderType:NSLineBorder];
+	[g->box setTransparent:NO];
+	[g->box setTitlePosition:NSAtTop];
+	// we can't use uiDarwinSetControlFont() because the selector is different
+	[g->box setTitleFont:[NSFont systemFontOfSize:[NSFont systemFontSizeForControlSize:NSSmallControlSize]]];
+
+	// default to low hugging to not hug edges
+	g->horzHuggingPri = NSLayoutPriorityDefaultLow;
+	g->vertHuggingPri = NSLayoutPriorityDefaultLow;
+
+	return g;
+}
diff --git a/src/libui_sdl/libui/darwin/image.m b/src/libui_sdl/libui/darwin/image.m
new file mode 100644
index 0000000..b62de31
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/image.m
@@ -0,0 +1,82 @@
+// 25 june 2016
+#import "uipriv_darwin.h"
+
+struct uiImage {
+	NSImage *i;
+	NSSize size;
+	NSMutableArray *swizzled;
+};
+
+uiImage *uiNewImage(double width, double height)
+{
+	uiImage *i;
+
+	i = uiNew(uiImage);
+	i->size = NSMakeSize(width, height);
+	i->i = [[NSImage alloc] initWithSize:i->size];
+	i->swizzled = [NSMutableArray new];
+	return i;
+}
+
+void uiFreeImage(uiImage *i)
+{
+	NSValue *v;
+
+	[i->i release];
+	// to be safe, do this after releasing the image
+	for (v in i->swizzled)
+		uiFree([v pointerValue]);
+	[i->swizzled release];
+	uiFree(i);
+}
+
+void uiImageAppend(uiImage *i, void *pixels, int pixelWidth, int pixelHeight, int pixelStride)
+{
+	NSBitmapImageRep *repCalibrated, *repsRGB;
+	uint8_t *swizzled, *bp, *sp;
+	int x, y;
+	unsigned char *pix[1];
+
+	// OS X demands that R and B are in the opposite order from what we expect
+	// we must swizzle :(
+	// LONGTERM test on a big-endian system
+	swizzled = (uint8_t *) uiAlloc((pixelStride * pixelHeight * 4) * sizeof (uint8_t), "uint8_t[]");
+	bp = (uint8_t *) pixels;
+	sp = swizzled;
+	for (y = 0; y < pixelHeight * pixelStride; y += pixelStride)
+		for (x = 0; x < pixelStride; x++) {
+			sp[0] = bp[2];
+			sp[1] = bp[1];
+			sp[2] = bp[0];
+			sp[3] = bp[3];
+			sp += 4;
+			bp += 4;
+		}
+
+	pix[0] = (unsigned char *) swizzled;
+	repCalibrated = [[NSBitmapImageRep alloc] initWithBitmapDataPlanes:pix
+		pixelsWide:pixelWidth
+		pixelsHigh:pixelHeight
+		bitsPerSample:8
+		samplesPerPixel:4
+		hasAlpha:YES
+		isPlanar:NO
+		colorSpaceName:NSCalibratedRGBColorSpace
+		bitmapFormat:0
+		bytesPerRow:pixelStride
+		bitsPerPixel:32];
+	repsRGB = [repCalibrated bitmapImageRepByRetaggingWithColorSpace:[NSColorSpace sRGBColorSpace]];
+	[repCalibrated release];
+
+	[i->i addRepresentation:repsRGB];
+	[repsRGB setSize:i->size];
+	[repsRGB release];
+
+	// we need to keep swizzled alive for NSBitmapImageRep
+	[i->swizzled addObject:[NSValue valueWithPointer:swizzled]];
+}
+
+NSImage *imageImage(uiImage *i)
+{
+	return i->i;
+}
diff --git a/src/libui_sdl/libui/darwin/label.m b/src/libui_sdl/libui/darwin/label.m
new file mode 100644
index 0000000..897bc3f
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/label.m
@@ -0,0 +1,43 @@
+// 14 august 2015
+#import "uipriv_darwin.h"
+
+struct uiLabel {
+	uiDarwinControl c;
+	NSTextField *textfield;
+};
+
+uiDarwinControlAllDefaults(uiLabel, textfield)
+
+char *uiLabelText(uiLabel *l)
+{
+	return uiDarwinNSStringToText([l->textfield stringValue]);
+}
+
+void uiLabelSetText(uiLabel *l, const char *text)
+{
+	[l->textfield setStringValue:toNSString(text)];
+}
+
+NSTextField *newLabel(NSString *str)
+{
+	NSTextField *tf;
+
+	tf = [[NSTextField alloc] initWithFrame:NSZeroRect];
+	[tf setStringValue:str];
+	[tf setEditable:NO];
+	[tf setSelectable:NO];
+	[tf setDrawsBackground:NO];
+	finishNewTextField(tf, NO);
+	return tf;
+}
+
+uiLabel *uiNewLabel(const char *text)
+{
+	uiLabel *l;
+
+	uiDarwinNewControl(uiLabel, l);
+
+	l->textfield = newLabel(toNSString(text));
+
+	return l;
+}
diff --git a/src/libui_sdl/libui/darwin/main.m b/src/libui_sdl/libui/darwin/main.m
new file mode 100644
index 0000000..59a8683
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/main.m
@@ -0,0 +1,239 @@
+// 6 april 2015
+#import "uipriv_darwin.h"
+
+static BOOL canQuit = NO;
+static NSAutoreleasePool *globalPool;
+static applicationClass *app;
+static appDelegate *delegate;
+
+static BOOL (^isRunning)(void);
+static BOOL stepsIsRunning;
+
+@implementation applicationClass
+
+- (void)sendEvent:(NSEvent *)e
+{
+	if (sendAreaEvents(e) != 0)
+		return;
+	[super sendEvent:e];
+}
+
+// NSColorPanel always sends changeColor: to the first responder regardless of whether there's a target set on it
+// we can override it here (see colorbutton.m)
+// thanks to mikeash in irc.freenode.net/#macdev for informing me this is how the first responder chain is initiated
+// it turns out NSFontManager also sends changeFont: through this; let's inhibit that here too (see fontbutton.m)
+- (BOOL)sendAction:(SEL)sel to:(id)to from:(id)from
+{
+	if (colorButtonInhibitSendAction(sel, from, to))
+		return NO;
+	if (fontButtonInhibitSendAction(sel, from, to))
+		return NO;
+	return [super sendAction:sel to:to from:from];
+}
+
+// likewise, NSFontManager also sends NSFontPanelValidation messages to the first responder, however it does NOT use sendAction:from:to:!
+// instead, it uses this one (thanks swillits in irc.freenode.net/#macdev)
+// we also need to override it (see fontbutton.m)
+- (id)targetForAction:(SEL)sel to:(id)to from:(id)from
+{
+	id override;
+
+	if (fontButtonOverrideTargetForAction(sel, from, to, &override))
+		return override;
+	return [super targetForAction:sel to:to from:from];
+}
+
+// hey look! we're overriding terminate:!
+// we're going to make sure we can go back to main() whether Cocoa likes it or not!
+// and just how are we going to do that, hm?
+// (note: this is called after applicationShouldTerminate:)
+- (void)terminate:(id)sender
+{
+	// yes that's right folks: DO ABSOLUTELY NOTHING.
+	// the magic is [NSApp run] will just... stop.
+
+	// well let's not do nothing; let's actually quit our graceful way
+	NSEvent *e;
+
+	if (!canQuit)
+		implbug("call to [NSApp terminate:] when not ready to terminate; definitely contact andlabs");
+
+	[realNSApp() stop:realNSApp()];
+	// stop: won't register until another event has passed; let's synthesize one
+	e = [NSEvent otherEventWithType:NSApplicationDefined
+		location:NSZeroPoint
+		modifierFlags:0
+		timestamp:[[NSProcessInfo processInfo] systemUptime]
+		windowNumber:0
+		context:[NSGraphicsContext currentContext]
+		subtype:0
+		data1:0
+		data2:0];
+	[realNSApp() postEvent:e atStart:NO];		// let pending events take priority (this is what PostQuitMessage() on Windows does so we have to do it here too for parity; thanks to mikeash in irc.freenode.net/#macdev for confirming that this parameter should indeed be NO)
+
+	// and in case uiMainSteps() was called
+	stepsIsRunning = NO;
+}
+
+@end
+
+@implementation appDelegate
+
+- (void)dealloc
+{
+	// Apple docs: "Don't Use Accessor Methods in Initializer Methods and dealloc"
+	[_menuManager release];
+	[super dealloc];
+}
+
+- (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)app
+{
+	// for debugging
+	NSLog(@"in applicationShouldTerminate:");
+	if (shouldQuit()) {
+		canQuit = YES;
+		// this will call terminate:, which is the same as uiQuit()
+		return NSTerminateNow;
+	}
+	return NSTerminateCancel;
+}
+
+- (BOOL)applicationShouldTerminateAfterLastWindowClosed:(NSApplication *)app
+{
+	return NO;
+}
+
+@end
+
+uiInitOptions options;
+
+const char *uiInit(uiInitOptions *o)
+{
+	@autoreleasepool {
+		options = *o;
+		app = [[applicationClass sharedApplication] retain];
+		// don't check for a NO return; something (launch services?) causes running from application bundles to always return NO when asking to change activation policy, even if the change is to the same activation policy!
+		// see https://github.com/andlabs/ui/issues/6
+		[realNSApp() setActivationPolicy:NSApplicationActivationPolicyRegular];
+		delegate = [appDelegate new];
+		[realNSApp() setDelegate:delegate];
+
+		initAlloc();
+
+		// always do this so we always have an application menu
+		appDelegate().menuManager = [[menuManager new] autorelease];
+		[realNSApp() setMainMenu:[appDelegate().menuManager makeMenubar]];
+
+		setupFontPanel();
+	}
+
+	globalPool = [[NSAutoreleasePool alloc] init];
+
+	return NULL;
+}
+
+void uiUninit(void)
+{
+	if (!globalPool) {
+		userbug("You must call uiInit() first!");
+	}
+	[globalPool release];
+
+	@autoreleasepool {
+		[delegate release];
+		[realNSApp() setDelegate:nil];
+		[app release];
+		uninitAlloc();
+	}
+}
+
+void uiFreeInitError(const char *err)
+{
+}
+
+void uiMain(void)
+{
+	isRunning = ^{
+		return [realNSApp() isRunning];
+	};
+	[realNSApp() run];
+}
+
+void uiMainSteps(void)
+{
+	// SDL does this and it seems to be necessary for the menubar to work (see #182)
+	[realNSApp() finishLaunching];
+	isRunning = ^{
+		return stepsIsRunning;
+	};
+	stepsIsRunning = YES;
+}
+
+int uiMainStep(int wait)
+{
+	struct nextEventArgs nea;
+
+	nea.mask = NSAnyEventMask;
+
+	// ProPuke did this in his original PR requesting this
+	// I'm not sure if this will work, but I assume it will...
+	nea.duration = [NSDate distantPast];
+	if (wait)		// but this is normal so it will work
+		nea.duration = [NSDate distantFuture];
+
+	nea.mode = NSDefaultRunLoopMode;
+	nea.dequeue = YES;
+
+	return mainStep(&nea, ^(NSEvent *e) {
+		return NO;
+	});
+}
+
+// see also:
+// - http://www.cocoawithlove.com/2009/01/demystifying-nsapplication-by.html
+// - https://github.com/gnustep/gui/blob/master/Source/NSApplication.m
+int mainStep(struct nextEventArgs *nea, BOOL (^interceptEvent)(NSEvent *e))
+{
+	NSDate *expire;
+	NSEvent *e;
+	NSEventType type;
+
+	@autoreleasepool {
+		if (!isRunning())
+			return 0;
+
+		e = [realNSApp() nextEventMatchingMask:nea->mask
+			untilDate:nea->duration
+			inMode:nea->mode
+			dequeue:nea->dequeue];
+		if (e == nil)
+			return 1;
+
+		type = [e type];
+		if (!interceptEvent(e))
+			[realNSApp() sendEvent:e];
+		[realNSApp() updateWindows];
+
+		// GNUstep does this
+		// it also updates the Services menu but there doesn't seem to be a public API for that so
+		if (type != NSPeriodic && type != NSMouseMoved)
+			[[realNSApp() mainMenu] update];
+
+		return 1;
+	}
+}
+
+void uiQuit(void)
+{
+	canQuit = YES;
+	[realNSApp() terminate:realNSApp()];
+}
+
+// thanks to mikeash in irc.freenode.net/#macdev for suggesting the use of Grand Central Dispatch for this
+// LONGTERM will dispatch_get_main_queue() break after _CFRunLoopSetCurrent()?
+void uiQueueMain(void (*f)(void *data), void *data)
+{
+	// dispatch_get_main_queue() is a serial queue so it will not execute multiple uiQueueMain() functions concurrently
+	// the signature of f matches dispatch_function_t
+	dispatch_async_f(dispatch_get_main_queue(), data, f);
+}
diff --git a/src/libui_sdl/libui/darwin/map.m b/src/libui_sdl/libui/darwin/map.m
new file mode 100644
index 0000000..46a7b8d
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/map.m
@@ -0,0 +1,59 @@
+// 17 august 2015
+#import "uipriv_darwin.h"
+
+// unfortunately NSMutableDictionary copies its keys, meaning we can't use it for pointers
+// hence, this file
+// we could expose a NSMapTable directly, but let's treat all pointers as opaque and hide the implementation, just to be safe and prevent even more rewrites later
+struct mapTable {
+	NSMapTable *m;
+};
+
+struct mapTable *newMap(void)
+{
+	struct mapTable *m;
+
+	m = uiNew(struct mapTable);
+	m->m = [[NSMapTable alloc] initWithKeyOptions:(NSPointerFunctionsOpaqueMemory | NSPointerFunctionsOpaquePersonality)
+		valueOptions:(NSPointerFunctionsOpaqueMemory | NSPointerFunctionsOpaquePersonality)
+		capacity:0];
+	return m;
+}
+
+void mapDestroy(struct mapTable *m)
+{
+	if ([m->m count] != 0)
+		implbug("attempt to destroy map with items inside");
+	[m->m release];
+	uiFree(m);
+}
+
+void *mapGet(struct mapTable *m, void *key)
+{
+	return NSMapGet(m->m, key);
+}
+
+void mapSet(struct mapTable *m, void *key, void *value)
+{
+	NSMapInsert(m->m, key, value);
+}
+
+void mapDelete(struct mapTable *m, void *key)
+{
+	NSMapRemove(m->m, key);
+}
+
+void mapWalk(struct mapTable *m, void (*f)(void *key, void *value))
+{
+	NSMapEnumerator e = NSEnumerateMapTable(m->m);
+	void *k = NULL;
+	void *v = NULL;
+	while (NSNextMapEnumeratorPair(&e, &k, &v)) {
+		f(k, v);
+	}
+	NSEndMapTableEnumeration(&e);
+}
+
+void mapReset(struct mapTable *m)
+{
+	NSResetMapTable(m->m);
+}
diff --git a/src/libui_sdl/libui/darwin/menu.m b/src/libui_sdl/libui/darwin/menu.m
new file mode 100644
index 0000000..735cac5
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/menu.m
@@ -0,0 +1,368 @@
+// 28 april 2015
+#import "uipriv_darwin.h"
+
+static NSMutableArray *menus = nil;
+static BOOL menusFinalized = NO;
+
+struct uiMenu {
+	NSMenu *menu;
+	NSMenuItem *item;
+	NSMutableArray *items;
+};
+
+struct uiMenuItem {
+	NSMenuItem *item;
+	int type;
+	BOOL disabled;
+	void (*onClicked)(uiMenuItem *, uiWindow *, void *);
+	void *onClickedData;
+};
+
+enum {
+	typeRegular,
+	typeCheckbox,
+	typeQuit,
+	typePreferences,
+	typeAbout,
+	typeSeparator,
+};
+
+static void mapItemReleaser(void *key, void *value)
+{
+	uiMenuItem *item;
+ 
+	item = (uiMenuItem *)value;
+	[item->item release];
+}
+
+@implementation menuManager
+
+- (id)init
+{
+	self = [super init];
+	if (self) {
+		self->items = newMap();
+		self->hasQuit = NO;
+		self->hasPreferences = NO;
+		self->hasAbout = NO;
+	}
+	return self;
+}
+
+- (void)dealloc
+{
+	mapWalk(self->items, mapItemReleaser);
+	mapReset(self->items);
+	mapDestroy(self->items);
+	uninitMenus();
+	[super dealloc];
+}
+
+- (IBAction)onClicked:(id)sender
+{
+	uiMenuItem *item;
+
+	item = (uiMenuItem *) mapGet(self->items, sender);
+	if (item->type == typeCheckbox)
+		uiMenuItemSetChecked(item, !uiMenuItemChecked(item));
+	// use the key window as the source of the menu event; it's the active window
+	(*(item->onClicked))(item, windowFromNSWindow([realNSApp() keyWindow]), item->onClickedData);
+}
+
+- (IBAction)onQuitClicked:(id)sender
+{
+	if (shouldQuit())
+		uiQuit();
+}
+
+- (void)register:(NSMenuItem *)item to:(uiMenuItem *)smi
+{
+	switch (smi->type) {
+	case typeQuit:
+		if (self->hasQuit)
+			userbug("You can't have multiple Quit menu items in one program.");
+		self->hasQuit = YES;
+		break;
+	case typePreferences:
+		if (self->hasPreferences)
+			userbug("You can't have multiple Preferences menu items in one program.");
+		self->hasPreferences = YES;
+		break;
+	case typeAbout:
+		if (self->hasAbout)
+			userbug("You can't have multiple About menu items in one program.");
+		self->hasAbout = YES;
+		break;
+	}
+	mapSet(self->items, item, smi);
+}
+
+// on OS X there are two ways to handle menu items being enabled or disabled: automatically and manually
+// unfortunately, the application menu requires automatic menu handling for the Hide, Hide Others, and Show All items to work correctly
+// therefore, we have to handle enabling of the other options ourselves
+- (BOOL)validateMenuItem:(NSMenuItem *)item
+{
+	uiMenuItem *smi;
+
+	// disable the special items if they aren't present
+	if (item == self.quitItem && !self->hasQuit)
+		return NO;
+	if (item == self.preferencesItem && !self->hasPreferences)
+		return NO;
+	if (item == self.aboutItem && !self->hasAbout)
+		return NO;
+	// then poll the item's enabled/disabled state
+	smi = (uiMenuItem *) mapGet(self->items, item);
+	return !smi->disabled;
+}
+
+// Cocoa constructs the default application menu by hand for each program; that's what MainMenu.[nx]ib does
+- (void)buildApplicationMenu:(NSMenu *)menubar
+{
+	NSString *appName;
+	NSMenuItem *appMenuItem;
+	NSMenu *appMenu;
+	NSMenuItem *item;
+	NSString *title;
+	NSMenu *servicesMenu;
+
+	// note: no need to call setAppleMenu: on this anymore; see https://developer.apple.com/library/mac/releasenotes/AppKit/RN-AppKitOlderNotes/#X10_6Notes
+	appName = [[NSProcessInfo processInfo] processName];
+	appMenuItem = [[[NSMenuItem alloc] initWithTitle:appName action:NULL keyEquivalent:@""] autorelease];
+	appMenu = [[[NSMenu alloc] initWithTitle:appName] autorelease];
+	[appMenuItem setSubmenu:appMenu];
+	[menubar addItem:appMenuItem];
+
+	// first is About
+	title = [@"About " stringByAppendingString:appName];
+	item = [[[NSMenuItem alloc] initWithTitle:title action:@selector(onClicked:) keyEquivalent:@""] autorelease];
+	[item setTarget:self];
+	[appMenu addItem:item];
+	self.aboutItem = item;
+
+	[appMenu addItem:[NSMenuItem separatorItem]];
+
+	// next is Preferences
+	item = [[[NSMenuItem alloc] initWithTitle:@"Preferences…" action:@selector(onClicked:) keyEquivalent:@","] autorelease];
+	[item setTarget:self];
+	[appMenu addItem:item];
+	self.preferencesItem = item;
+
+	[appMenu addItem:[NSMenuItem separatorItem]];
+
+	// next is Services
+	item = [[[NSMenuItem alloc] initWithTitle:@"Services" action:NULL keyEquivalent:@""] autorelease];
+	servicesMenu = [[[NSMenu alloc] initWithTitle:@"Services"] autorelease];
+	[item setSubmenu:servicesMenu];
+	[realNSApp() setServicesMenu:servicesMenu];
+	[appMenu addItem:item];
+
+	[appMenu addItem:[NSMenuItem separatorItem]];
+
+	// next are the three hiding options
+	title = [@"Hide " stringByAppendingString:appName];
+	item = [[[NSMenuItem alloc] initWithTitle:title action:@selector(hide:) keyEquivalent:@"h"] autorelease];
+	// the .xib file says they go to -1 ("First Responder", which sounds wrong...)
+	// to do that, we simply leave the target as nil
+	[appMenu addItem:item];
+	item = [[[NSMenuItem alloc] initWithTitle:@"Hide Others" action:@selector(hideOtherApplications:) keyEquivalent:@"h"] autorelease];
+	[item setKeyEquivalentModifierMask:(NSAlternateKeyMask | NSCommandKeyMask)];
+	[appMenu addItem:item];
+	item = [[[NSMenuItem alloc] initWithTitle:@"Show All" action:@selector(unhideAllApplications:) keyEquivalent:@""] autorelease];
+	[appMenu addItem:item];
+
+	[appMenu addItem:[NSMenuItem separatorItem]];
+
+	// and finally Quit
+	// DON'T use @selector(terminate:) as the action; we handle termination ourselves
+	title = [@"Quit " stringByAppendingString:appName];
+	item = [[[NSMenuItem alloc] initWithTitle:title action:@selector(onQuitClicked:) keyEquivalent:@"q"] autorelease];
+	[item setTarget:self];
+	[appMenu addItem:item];
+	self.quitItem = item;
+}
+
+- (NSMenu *)makeMenubar
+{
+	NSMenu *menubar;
+
+	menubar = [[[NSMenu alloc] initWithTitle:@""] autorelease];
+	[self buildApplicationMenu:menubar];
+	return menubar;
+}
+
+@end
+
+static void defaultOnClicked(uiMenuItem *item, uiWindow *w, void *data)
+{
+	// do nothing
+}
+
+void uiMenuItemEnable(uiMenuItem *item)
+{
+	item->disabled = NO;
+	// we don't need to explicitly update the menus here; they'll be updated the next time they're opened (thanks mikeash in irc.freenode.net/#macdev)
+}
+
+void uiMenuItemDisable(uiMenuItem *item)
+{
+	item->disabled = YES;
+}
+
+void uiMenuItemOnClicked(uiMenuItem *item, void (*f)(uiMenuItem *, uiWindow *, void *), void *data)
+{
+	if (item->type == typeQuit)
+		userbug("You can't call uiMenuItemOnClicked() on a Quit item; use uiOnShouldQuit() instead.");
+	item->onClicked = f;
+	item->onClickedData = data;
+}
+
+int uiMenuItemChecked(uiMenuItem *item)
+{
+	return [item->item state] != NSOffState;
+}
+
+void uiMenuItemSetChecked(uiMenuItem *item, int checked)
+{
+	NSInteger state;
+
+	state = NSOffState;
+	if ([item->item state] == NSOffState)
+		state = NSOnState;
+	[item->item setState:state];
+}
+
+static uiMenuItem *newItem(uiMenu *m, int type, const char *name)
+{
+	@autoreleasepool {
+
+	uiMenuItem *item;
+
+	if (menusFinalized)
+		userbug("You can't create a new menu item after menus have been finalized.");
+
+	item = uiNew(uiMenuItem);
+
+	item->type = type;
+	switch (item->type) {
+	case typeQuit:
+		item->item = [appDelegate().menuManager.quitItem retain];
+		break;
+	case typePreferences:
+		item->item = [appDelegate().menuManager.preferencesItem retain];
+		break;
+	case typeAbout:
+		item->item = [appDelegate().menuManager.aboutItem retain];
+		break;
+	case typeSeparator:
+		item->item = [[NSMenuItem separatorItem] retain];
+		[m->menu addItem:item->item];
+		break;
+	default:
+		item->item = [[NSMenuItem alloc] initWithTitle:toNSString(name) action:@selector(onClicked:) keyEquivalent:@""];
+		[item->item setTarget:appDelegate().menuManager];
+		[m->menu addItem:item->item];
+		break;
+	}
+
+	[appDelegate().menuManager register:item->item to:item];
+	item->onClicked = defaultOnClicked;
+
+	[m->items addObject:[NSValue valueWithPointer:item]];
+
+	return item;
+
+	} // @autoreleasepool
+}
+
+uiMenuItem *uiMenuAppendItem(uiMenu *m, const char *name)
+{
+	return newItem(m, typeRegular, name);
+}
+
+uiMenuItem *uiMenuAppendCheckItem(uiMenu *m, const char *name)
+{
+	return newItem(m, typeCheckbox, name);
+}
+
+uiMenuItem *uiMenuAppendQuitItem(uiMenu *m)
+{
+	// duplicate check is in the register:to: selector
+	return newItem(m, typeQuit, NULL);
+}
+
+uiMenuItem *uiMenuAppendPreferencesItem(uiMenu *m)
+{
+	// duplicate check is in the register:to: selector
+	return newItem(m, typePreferences, NULL);
+}
+
+uiMenuItem *uiMenuAppendAboutItem(uiMenu *m)
+{
+	// duplicate check is in the register:to: selector
+	return newItem(m, typeAbout, NULL);
+}
+
+void uiMenuAppendSeparator(uiMenu *m)
+{
+	newItem(m, typeSeparator, NULL);
+}
+
+uiMenu *uiNewMenu(const char *name)
+{
+	@autoreleasepool {
+
+	uiMenu *m;
+
+	if (menusFinalized)
+		userbug("You can't create a new menu after menus have been finalized.");
+	if (menus == nil)
+		menus = [NSMutableArray new];
+
+	m = uiNew(uiMenu);
+
+	m->menu = [[NSMenu alloc] initWithTitle:toNSString(name)];
+	// use automatic menu item enabling for all menus for consistency's sake
+
+	m->item = [[NSMenuItem alloc] initWithTitle:toNSString(name) action:NULL keyEquivalent:@""];
+	[m->item setSubmenu:m->menu];
+
+	m->items = [NSMutableArray new];
+
+	[[realNSApp() mainMenu] addItem:m->item];
+
+	[menus addObject:[NSValue valueWithPointer:m]];
+
+	return m;
+
+	} // @autoreleasepool
+}
+
+void finalizeMenus(void)
+{
+	menusFinalized = YES;
+}
+
+void uninitMenus(void)
+{
+	if (menus == NULL)
+		return;
+	[menus enumerateObjectsUsingBlock:^(id obj, NSUInteger index, BOOL *stop) {
+		NSValue *v;
+		uiMenu *m;
+
+		v = (NSValue *) obj;
+		m = (uiMenu *) [v pointerValue];
+		[m->items enumerateObjectsUsingBlock:^(id obj, NSUInteger index, BOOL *stop) {
+			NSValue *v;
+			uiMenuItem *mi;
+
+			v = (NSValue *) obj;
+			mi = (uiMenuItem *) [v pointerValue];
+			uiFree(mi);
+		}];
+		[m->items release];
+		uiFree(m);
+	}];
+	[menus release];
+}
diff --git a/src/libui_sdl/libui/darwin/multilineentry.m b/src/libui_sdl/libui/darwin/multilineentry.m
new file mode 100644
index 0000000..605e900
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/multilineentry.m
@@ -0,0 +1,233 @@
+// 8 december 2015
+#import "uipriv_darwin.h"
+
+// NSTextView has no intrinsic content size by default, which wreaks havoc on a pure-Auto Layout system
+// we'll have to take over to get it to work
+// see also http://stackoverflow.com/questions/24210153/nstextview-not-properly-resizing-with-auto-layout and http://stackoverflow.com/questions/11237622/using-autolayout-with-expanding-nstextviews
+@interface intrinsicSizeTextView : NSTextView {
+	uiMultilineEntry *libui_e;
+}
+- (id)initWithFrame:(NSRect)r e:(uiMultilineEntry *)e;
+@end
+
+struct uiMultilineEntry {
+	uiDarwinControl c;
+	NSScrollView *sv;
+	intrinsicSizeTextView *tv;
+	struct scrollViewData *d;
+	void (*onChanged)(uiMultilineEntry *, void *);
+	void *onChangedData;
+	BOOL changing;
+};
+
+@implementation intrinsicSizeTextView
+
+- (id)initWithFrame:(NSRect)r e:(uiMultilineEntry *)e
+{
+	self = [super initWithFrame:r];
+	if (self)
+		self->libui_e = e;
+	return self;
+}
+
+- (NSSize)intrinsicContentSize
+{
+	NSTextContainer *textContainer;
+	NSLayoutManager *layoutManager;
+	NSRect rect;
+
+	textContainer = [self textContainer];
+	layoutManager = [self layoutManager];
+	[layoutManager ensureLayoutForTextContainer:textContainer];
+	rect = [layoutManager usedRectForTextContainer:textContainer];
+	return rect.size;
+}
+
+- (void)didChangeText
+{
+	[super didChangeText];
+	[self invalidateIntrinsicContentSize];
+	if (!self->libui_e->changing)
+		(*(self->libui_e->onChanged))(self->libui_e, self->libui_e->onChangedData);
+}
+
+@end
+
+uiDarwinControlAllDefaultsExceptDestroy(uiMultilineEntry, sv)
+
+static void uiMultilineEntryDestroy(uiControl *c)
+{
+	uiMultilineEntry *e = uiMultilineEntry(c);
+
+	scrollViewFreeData(e->sv, e->d);
+	[e->tv release];
+	[e->sv release];
+	uiFreeControl(uiControl(e));
+}
+
+static void defaultOnChanged(uiMultilineEntry *e, void *data)
+{
+	// do nothing
+}
+
+char *uiMultilineEntryText(uiMultilineEntry *e)
+{
+	return uiDarwinNSStringToText([e->tv string]);
+}
+
+void uiMultilineEntrySetText(uiMultilineEntry *e, const char *text)
+{
+	[[e->tv textStorage] replaceCharactersInRange:NSMakeRange(0, [[e->tv string] length])
+		withString:toNSString(text)];
+	// must be called explicitly according to the documentation of shouldChangeTextInRange:replacementString:
+	e->changing = YES;
+	[e->tv didChangeText];
+	e->changing = NO;
+}
+
+// TODO scroll to end?
+void uiMultilineEntryAppend(uiMultilineEntry *e, const char *text)
+{
+	[[e->tv textStorage] replaceCharactersInRange:NSMakeRange([[e->tv string] length], 0)
+		withString:toNSString(text)];
+	e->changing = YES;
+	[e->tv didChangeText];
+	e->changing = NO;
+}
+
+void uiMultilineEntryOnChanged(uiMultilineEntry *e, void (*f)(uiMultilineEntry *e, void *data), void *data)
+{
+	e->onChanged = f;
+	e->onChangedData = data;
+}
+
+int uiMultilineEntryReadOnly(uiMultilineEntry *e)
+{
+	return [e->tv isEditable] == NO;
+}
+
+void uiMultilineEntrySetReadOnly(uiMultilineEntry *e, int readonly)
+{
+	BOOL editable;
+
+	editable = YES;
+	if (readonly)
+		editable = NO;
+	[e->tv setEditable:editable];
+}
+
+static uiMultilineEntry *finishMultilineEntry(BOOL hscroll)
+{
+	uiMultilineEntry *e;
+	NSFont *font;
+	struct scrollViewCreateParams p;
+
+	uiDarwinNewControl(uiMultilineEntry, e);
+
+	e->tv = [[intrinsicSizeTextView alloc] initWithFrame:NSZeroRect e:e];
+
+	// verified against Interface Builder for a sufficiently customized text view
+
+	// NSText properties:
+	// this is what Interface Builder sets the background color to
+	[e->tv setBackgroundColor:[NSColor colorWithCalibratedWhite:1.0 alpha:1.0]];
+	[e->tv setDrawsBackground:YES];
+	[e->tv setEditable:YES];
+	[e->tv setSelectable:YES];
+	[e->tv setFieldEditor:NO];
+	[e->tv setRichText:NO];
+	[e->tv setImportsGraphics:NO];
+	[e->tv setUsesFontPanel:NO];
+	[e->tv setRulerVisible:NO];
+	// we'll handle font last
+	// while setAlignment: has been around since 10.0, the named constant "NSTextAlignmentNatural" seems to have only been introduced in 10.11
+#define ourNSTextAlignmentNatural 4
+	[e->tv setAlignment:ourNSTextAlignmentNatural];
+	// textColor is set to nil, just keep the dfault
+	[e->tv setBaseWritingDirection:NSWritingDirectionNatural];
+	[e->tv setHorizontallyResizable:NO];
+	[e->tv setVerticallyResizable:YES];
+
+	// NSTextView properties:
+	[e->tv setAllowsDocumentBackgroundColorChange:NO];
+	[e->tv setAllowsUndo:YES];
+	// default paragraph style is nil; keep default
+	[e->tv setAllowsImageEditing:NO];
+	[e->tv setAutomaticQuoteSubstitutionEnabled:NO];
+	[e->tv setAutomaticLinkDetectionEnabled:NO];
+	[e->tv setDisplaysLinkToolTips:YES];
+	[e->tv setUsesRuler:NO];
+	[e->tv setUsesInspectorBar:NO];
+	[e->tv setSelectionGranularity:NSSelectByCharacter];
+	// there is a dedicated named insertion point color but oh well
+	[e->tv setInsertionPointColor:[NSColor controlTextColor]];
+	// typing attributes is nil; keep default (we change it below for fonts though)
+	[e->tv setSmartInsertDeleteEnabled:NO];
+	[e->tv setContinuousSpellCheckingEnabled:NO];
+	[e->tv setGrammarCheckingEnabled:NO];
+	[e->tv setUsesFindPanel:YES];
+	[e->tv setEnabledTextCheckingTypes:0];
+	[e->tv setAutomaticDashSubstitutionEnabled:NO];
+	[e->tv setAutomaticDataDetectionEnabled:NO];
+	[e->tv setAutomaticSpellingCorrectionEnabled:NO];
+	[e->tv setAutomaticTextReplacementEnabled:NO];
+	[e->tv setUsesFindBar:NO];
+	[e->tv setIncrementalSearchingEnabled:NO];
+
+	// NSTextContainer properties:
+	[[e->tv textContainer] setWidthTracksTextView:YES];
+	[[e->tv textContainer] setHeightTracksTextView:NO];
+
+	// NSLayoutManager properties:
+	[[e->tv layoutManager] setAllowsNonContiguousLayout:YES];
+
+	// now just to be safe; this will do some of the above but whatever
+	disableAutocorrect(e->tv);
+
+	// see https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/TextUILayer/Tasks/TextInScrollView.html
+	// notice we don't use the Auto Layout code; see scrollview.m for more details
+	[e->tv setMaxSize:NSMakeSize(CGFLOAT_MAX, CGFLOAT_MAX)];
+	[e->tv setVerticallyResizable:YES];
+	[e->tv setHorizontallyResizable:hscroll];
+	if (hscroll) {
+		[e->tv setAutoresizingMask:(NSViewWidthSizable | NSViewHeightSizable)];
+		[[e->tv textContainer] setWidthTracksTextView:NO];
+	} else {
+		[e->tv setAutoresizingMask:NSViewWidthSizable];
+		[[e->tv textContainer] setWidthTracksTextView:YES];
+	}
+	[[e->tv textContainer] setContainerSize:NSMakeSize(CGFLOAT_MAX, CGFLOAT_MAX)];
+
+	// don't use uiDarwinSetControlFont() directly; we have to do a little extra work to set the font
+	font = [NSFont systemFontOfSize:[NSFont systemFontSizeForControlSize:NSRegularControlSize]];
+	[e->tv setTypingAttributes:[NSDictionary
+		dictionaryWithObject:font
+		forKey:NSFontAttributeName]];
+	// e->tv font from Interface Builder is nil, but setFont:nil throws an exception
+	// let's just set it to the standard control font anyway, just to be safe
+	[e->tv setFont:font];
+
+	memset(&p, 0, sizeof (struct scrollViewCreateParams));
+	p.DocumentView = e->tv;
+	// this is what Interface Builder sets it to
+	p.BackgroundColor = [NSColor colorWithCalibratedWhite:1.0 alpha:1.0];
+	p.DrawsBackground = YES;
+	p.Bordered = YES;
+	p.HScroll = hscroll;
+	p.VScroll = YES;
+	e->sv = mkScrollView(&p, &(e->d));
+
+	uiMultilineEntryOnChanged(e, defaultOnChanged, NULL);
+
+	return e;
+}
+
+uiMultilineEntry *uiNewMultilineEntry(void)
+{
+	return finishMultilineEntry(NO);
+}
+
+uiMultilineEntry *uiNewNonWrappingMultilineEntry(void)
+{
+	return finishMultilineEntry(YES);
+}
diff --git a/src/libui_sdl/libui/darwin/progressbar.m b/src/libui_sdl/libui/darwin/progressbar.m
new file mode 100644
index 0000000..b538228
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/progressbar.m
@@ -0,0 +1,78 @@
+// 14 august 2015
+#import "uipriv_darwin.h"
+
+// NSProgressIndicator has no intrinsic width by default; use the default width in Interface Builder
+#define progressIndicatorWidth 100
+
+@interface intrinsicWidthNSProgressIndicator : NSProgressIndicator
+@end
+
+@implementation intrinsicWidthNSProgressIndicator
+
+- (NSSize)intrinsicContentSize
+{
+	NSSize s;
+
+	s = [super intrinsicContentSize];
+	s.width = progressIndicatorWidth;
+	return s;
+}
+
+@end
+
+struct uiProgressBar {
+	uiDarwinControl c;
+	NSProgressIndicator *pi;
+};
+
+uiDarwinControlAllDefaults(uiProgressBar, pi)
+
+int uiProgressBarValue(uiProgressBar *p)
+{
+	if ([p->pi isIndeterminate])
+		return -1;
+	return [p->pi doubleValue];
+}
+
+void uiProgressBarSetValue(uiProgressBar *p, int value)
+{
+	if (value == -1) {
+		[p->pi setIndeterminate:YES];
+		[p->pi startAnimation:p->pi];
+		return;
+	}
+
+	if ([p->pi isIndeterminate]) {
+		[p->pi setIndeterminate:NO];
+		[p->pi stopAnimation:p->pi];
+	}
+
+	if (value < 0 || value > 100)
+		userbug("Value %d out of range for a uiProgressBar.", value);
+
+	// on 10.8 there's an animation when the progress bar increases, just like with Aero
+	if (value == 100) {
+		[p->pi setMaxValue:101];
+		[p->pi setDoubleValue:101];
+		[p->pi setDoubleValue:100];
+		[p->pi setMaxValue:100];
+		return;
+	}
+	[p->pi setDoubleValue:((double) (value + 1))];
+	[p->pi setDoubleValue:((double) value)];
+}
+
+uiProgressBar *uiNewProgressBar(void)
+{
+	uiProgressBar *p;
+
+	uiDarwinNewControl(uiProgressBar, p);
+
+	p->pi = [[intrinsicWidthNSProgressIndicator alloc] initWithFrame:NSZeroRect];
+	[p->pi setControlSize:NSRegularControlSize];
+	[p->pi setBezeled:YES];
+	[p->pi setStyle:NSProgressIndicatorBarStyle];
+	[p->pi setIndeterminate:NO];
+
+	return p;
+}
diff --git a/src/libui_sdl/libui/darwin/radiobuttons.m b/src/libui_sdl/libui/darwin/radiobuttons.m
new file mode 100644
index 0000000..25d773c
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/radiobuttons.m
@@ -0,0 +1,207 @@
+// 14 august 2015
+#import "uipriv_darwin.h"
+
+// TODO resizing the controlgallery vertically causes the third button to still resize :|
+
+// In the old days you would use a NSMatrix for this; as of OS X 10.8 this was deprecated and now you need just a bunch of NSButtons with the same superview AND same action method.
+// This is documented on the NSMatrix page, but the rest of the OS X documentation says to still use NSMatrix.
+// NSMatrix has weird quirks anyway...
+
+// LONGTERM 6 units of spacing between buttons, as suggested by Interface Builder?
+
+@interface radioButtonsDelegate : NSObject {
+	uiRadioButtons *libui_r;
+}
+- (id)initWithR:(uiRadioButtons *)r;
+- (IBAction)onClicked:(id)sender;
+@end
+
+struct uiRadioButtons {
+	uiDarwinControl c;
+	NSView *view;
+	NSMutableArray *buttons;
+	NSMutableArray *constraints;
+	NSLayoutConstraint *lastv;
+	radioButtonsDelegate *delegate;
+	void (*onSelected)(uiRadioButtons *, void *);
+	void *onSelectedData;
+};
+
+@implementation radioButtonsDelegate
+
+- (id)initWithR:(uiRadioButtons *)r
+{
+	self = [super init];
+	if (self)
+		self->libui_r = r;
+	return self;
+}
+
+- (IBAction)onClicked:(id)sender
+{
+	uiRadioButtons *r = self->libui_r;
+
+	(*(r->onSelected))(r, r->onSelectedData);
+}
+
+@end
+
+uiDarwinControlAllDefaultsExceptDestroy(uiRadioButtons, view)
+
+static void defaultOnSelected(uiRadioButtons *r, void *data)
+{
+	// do nothing
+}
+
+static void uiRadioButtonsDestroy(uiControl *c)
+{
+	uiRadioButtons *r = uiRadioButtons(c);
+	NSButton *b;
+
+	// drop the constraints
+	[r->view removeConstraints:r->constraints];
+	[r->constraints release];
+	if (r->lastv != nil)
+		[r->lastv release];
+	// destroy the buttons
+	for (b in r->buttons) {
+		[b setTarget:nil];
+		[b removeFromSuperview];
+	}
+	[r->buttons release];
+	// destroy the delegate
+	[r->delegate release];
+	// and destroy ourselves
+	[r->view release];
+	uiFreeControl(uiControl(r));
+}
+
+static NSButton *buttonAt(uiRadioButtons *r, int n)
+{
+	return (NSButton *) [r->buttons objectAtIndex:n];
+}
+
+void uiRadioButtonsAppend(uiRadioButtons *r, const char *text)
+{
+	NSButton *b, *b2;
+	NSLayoutConstraint *constraint;
+
+	b = [[NSButton alloc] initWithFrame:NSZeroRect];
+	[b setTitle:toNSString(text)];
+	[b setButtonType:NSRadioButton];
+	// doesn't seem to have an associated bezel style
+	[b setBordered:NO];
+	[b setTransparent:NO];
+	uiDarwinSetControlFont(b, NSRegularControlSize);
+	[b setTranslatesAutoresizingMaskIntoConstraints:NO];
+
+	[b setTarget:r->delegate];
+	[b setAction:@selector(onClicked:)];
+
+	[r->buttons addObject:b];
+	[r->view addSubview:b];
+
+	// pin horizontally to the edges of the superview
+	constraint = mkConstraint(b, NSLayoutAttributeLeading,
+		NSLayoutRelationEqual,
+		r->view, NSLayoutAttributeLeading,
+		1, 0,
+		@"uiRadioButtons button leading constraint");
+	[r->view addConstraint:constraint];
+	[r->constraints addObject:constraint];
+	constraint = mkConstraint(b, NSLayoutAttributeTrailing,
+		NSLayoutRelationEqual,
+		r->view, NSLayoutAttributeTrailing,
+		1, 0,
+		@"uiRadioButtons button trailing constraint");
+	[r->view addConstraint:constraint];
+	[r->constraints addObject:constraint];
+
+	// if this is the first view, pin it to the top
+	// otherwise pin to the bottom of the last
+	if ([r->buttons count] == 1)
+		constraint = mkConstraint(b, NSLayoutAttributeTop,
+			NSLayoutRelationEqual,
+			r->view, NSLayoutAttributeTop,
+			1, 0,
+			@"uiRadioButtons first button top constraint");
+	else {
+		b2 = buttonAt(r, [r->buttons count] - 2);
+		constraint = mkConstraint(b, NSLayoutAttributeTop,
+			NSLayoutRelationEqual,
+			b2, NSLayoutAttributeBottom,
+			1, 0,
+			@"uiRadioButtons non-first button top constraint");
+	}
+	[r->view addConstraint:constraint];
+	[r->constraints addObject:constraint];
+
+	// if there is a previous bottom constraint, remove it
+	if (r->lastv != nil) {
+		[r->view removeConstraint:r->lastv];
+		[r->constraints removeObject:r->lastv];
+		[r->lastv release];
+	}
+
+	// and make the new bottom constraint
+	r->lastv = mkConstraint(b, NSLayoutAttributeBottom,
+		NSLayoutRelationEqual,
+		r->view, NSLayoutAttributeBottom,
+		1, 0,
+		@"uiRadioButtons last button bottom constraint");
+	[r->view addConstraint:r->lastv];
+	[r->constraints addObject:r->lastv];
+	[r->lastv retain];
+}
+
+int uiRadioButtonsSelected(uiRadioButtons *r)
+{
+	NSButton *b;
+	NSUInteger i;
+
+	for (i = 0; i < [r->buttons count]; i++) {
+		b = (NSButton *) [r->buttons objectAtIndex:i];
+		if ([b state] == NSOnState)
+			return i;
+	}
+	return -1;
+}
+
+void uiRadioButtonsSetSelected(uiRadioButtons *r, int n)
+{
+	NSButton *b;
+	NSInteger state;
+
+	state = NSOnState;
+	if (n == -1) {
+		n = uiRadioButtonsSelected(r);
+		if (n == -1)		// from nothing to nothing; do nothing
+			return;
+		state = NSOffState;
+	}
+	b = (NSButton *) [r->buttons objectAtIndex:n];
+	[b setState:state];
+}
+
+void uiRadioButtonsOnSelected(uiRadioButtons *r, void (*f)(uiRadioButtons *, void *), void *data)
+{
+	r->onSelected = f;
+	r->onSelectedData = data;
+}
+
+uiRadioButtons *uiNewRadioButtons(void)
+{
+	uiRadioButtons *r;
+
+	uiDarwinNewControl(uiRadioButtons, r);
+
+	r->view = [[NSView alloc] initWithFrame:NSZeroRect];
+	r->buttons = [NSMutableArray new];
+	r->constraints = [NSMutableArray new];
+
+	r->delegate = [[radioButtonsDelegate alloc] initWithR:r];
+
+	uiRadioButtonsOnSelected(r, defaultOnSelected, NULL);
+
+	return r;
+}
diff --git a/src/libui_sdl/libui/darwin/scrollview.m b/src/libui_sdl/libui/darwin/scrollview.m
new file mode 100644
index 0000000..b0b4040
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/scrollview.m
@@ -0,0 +1,61 @@
+// 27 may 2016
+#include "uipriv_darwin.h"
+
+// see http://stackoverflow.com/questions/37979445/how-do-i-properly-set-up-a-scrolling-nstableview-using-auto-layout-what-ive-tr for why we don't use auto layout
+// TODO do the same with uiGroup and uiTab?
+
+struct scrollViewData {
+	BOOL hscroll;
+	BOOL vscroll;
+};
+
+NSScrollView *mkScrollView(struct scrollViewCreateParams *p, struct scrollViewData **dout)
+{
+	NSScrollView *sv;
+	NSBorderType border;
+	struct scrollViewData *d;
+
+	sv = [[NSScrollView alloc] initWithFrame:NSZeroRect];
+	if (p->BackgroundColor != nil)
+		[sv setBackgroundColor:p->BackgroundColor];
+	[sv setDrawsBackground:p->DrawsBackground];
+	border = NSNoBorder;
+	if (p->Bordered)
+		border = NSBezelBorder;
+	// document view seems to set the cursor properly
+	[sv setBorderType:border];
+	[sv setAutohidesScrollers:YES];
+	[sv setHasHorizontalRuler:NO];
+	[sv setHasVerticalRuler:NO];
+	[sv setRulersVisible:NO];
+	[sv setScrollerKnobStyle:NSScrollerKnobStyleDefault];
+	// the scroller style is documented as being set by default for us
+	// LONGTERM verify line and page for programmatically created NSTableView
+	[sv setScrollsDynamically:YES];
+	[sv setFindBarPosition:NSScrollViewFindBarPositionAboveContent];
+	[sv setUsesPredominantAxisScrolling:NO];
+	[sv setHorizontalScrollElasticity:NSScrollElasticityAutomatic];
+	[sv setVerticalScrollElasticity:NSScrollElasticityAutomatic];
+	[sv setAllowsMagnification:NO];
+
+	[sv setDocumentView:p->DocumentView];
+	d = uiNew(struct scrollViewData);
+	scrollViewSetScrolling(sv, d, p->HScroll, p->VScroll);
+
+	*dout = d;
+	return sv;
+}
+
+// based on http://blog.bjhomer.com/2014/08/nsscrollview-and-autolayout.html because (as pointed out there) Apple's official guide is really only for iOS
+void scrollViewSetScrolling(NSScrollView *sv, struct scrollViewData *d, BOOL hscroll, BOOL vscroll)
+{
+	d->hscroll = hscroll;
+	[sv setHasHorizontalScroller:d->hscroll];
+	d->vscroll = vscroll;
+	[sv setHasVerticalScroller:d->vscroll];
+}
+
+void scrollViewFreeData(NSScrollView *sv, struct scrollViewData *d)
+{
+	uiFree(d);
+}
diff --git a/src/libui_sdl/libui/darwin/separator.m b/src/libui_sdl/libui/darwin/separator.m
new file mode 100644
index 0000000..a37a376
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/separator.m
@@ -0,0 +1,45 @@
+// 14 august 2015
+#import "uipriv_darwin.h"
+
+// TODO make this intrinsic
+#define separatorWidth 96
+#define separatorHeight 96
+
+struct uiSeparator {
+	uiDarwinControl c;
+	NSBox *box;
+};
+
+uiDarwinControlAllDefaults(uiSeparator, box)
+
+uiSeparator *uiNewHorizontalSeparator(void)
+{
+	uiSeparator *s;
+
+	uiDarwinNewControl(uiSeparator, s);
+
+	// make the initial width >= initial height to force horizontal
+	s->box = [[NSBox alloc] initWithFrame:NSMakeRect(0, 0, 100, 1)];
+	[s->box setBoxType:NSBoxSeparator];
+	[s->box setBorderType:NSGrooveBorder];
+	[s->box setTransparent:NO];
+	[s->box setTitlePosition:NSNoTitle];
+
+	return s;
+}
+
+uiSeparator *uiNewVerticalSeparator(void)
+{
+	uiSeparator *s;
+
+	uiDarwinNewControl(uiSeparator, s);
+
+	// make the initial height >= initial width to force vertical
+	s->box = [[NSBox alloc] initWithFrame:NSMakeRect(0, 0, 1, 100)];
+	[s->box setBoxType:NSBoxSeparator];
+	[s->box setBorderType:NSGrooveBorder];
+	[s->box setTransparent:NO];
+	[s->box setTitlePosition:NSNoTitle];
+
+	return s;
+}
diff --git a/src/libui_sdl/libui/darwin/slider.m b/src/libui_sdl/libui/darwin/slider.m
new file mode 100644
index 0000000..f00da50
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/slider.m
@@ -0,0 +1,147 @@
+// 14 august 2015
+#import "uipriv_darwin.h"
+
+// Horizontal sliders have no intrinsic width; we'll use the default Interface Builder width for them.
+// This will also be used for the initial frame size, to ensure the slider is always horizontal (see below).
+#define sliderWidth 92
+
+@interface libui_intrinsicWidthNSSlider : NSSlider
+@end
+
+@implementation libui_intrinsicWidthNSSlider
+
+- (NSSize)intrinsicContentSize
+{
+	NSSize s;
+
+	s = [super intrinsicContentSize];
+	s.width = sliderWidth;
+	return s;
+}
+
+@end
+
+struct uiSlider {
+	uiDarwinControl c;
+	NSSlider *slider;
+	void (*onChanged)(uiSlider *, void *);
+	void *onChangedData;
+};
+
+@interface sliderDelegateClass : NSObject {
+	struct mapTable *sliders;
+}
+- (IBAction)onChanged:(id)sender;
+- (void)registerSlider:(uiSlider *)b;
+- (void)unregisterSlider:(uiSlider *)b;
+@end
+
+@implementation sliderDelegateClass
+
+- (id)init
+{
+	self = [super init];
+	if (self)
+		self->sliders = newMap();
+	return self;
+}
+
+- (void)dealloc
+{
+	mapDestroy(self->sliders);
+	[super dealloc];
+}
+
+- (IBAction)onChanged:(id)sender
+{
+	uiSlider *s;
+
+	s = (uiSlider *) mapGet(self->sliders, sender);
+	(*(s->onChanged))(s, s->onChangedData);
+}
+
+- (void)registerSlider:(uiSlider *)s
+{
+	mapSet(self->sliders, s->slider, s);
+	[s->slider setTarget:self];
+	[s->slider setAction:@selector(onChanged:)];
+}
+
+- (void)unregisterSlider:(uiSlider *)s
+{
+	[s->slider setTarget:nil];
+	mapDelete(self->sliders, s->slider);
+}
+
+@end
+
+static sliderDelegateClass *sliderDelegate = nil;
+
+uiDarwinControlAllDefaultsExceptDestroy(uiSlider, slider)
+
+static void uiSliderDestroy(uiControl *c)
+{
+	uiSlider *s = uiSlider(c);
+
+	[sliderDelegate unregisterSlider:s];
+	[s->slider release];
+	uiFreeControl(uiControl(s));
+}
+
+int uiSliderValue(uiSlider *s)
+{
+	return [s->slider integerValue];
+}
+
+void uiSliderSetValue(uiSlider *s, int value)
+{
+	[s->slider setIntegerValue:value];
+}
+
+void uiSliderOnChanged(uiSlider *s, void (*f)(uiSlider *, void *), void *data)
+{
+	s->onChanged = f;
+	s->onChangedData = data;
+}
+
+static void defaultOnChanged(uiSlider *s, void *data)
+{
+	// do nothing
+}
+
+uiSlider *uiNewSlider(int min, int max)
+{
+	uiSlider *s;
+	NSSliderCell *cell;
+	int temp;
+
+	if (min >= max) {
+		temp = min;
+		min = max;
+		max = temp;
+	}
+
+	uiDarwinNewControl(uiSlider, s);
+
+	// a horizontal slider is defined as one where the width > height, not by a flag
+	// to be safe, don't use NSZeroRect, but make it horizontal from the get-go
+	s->slider = [[libui_intrinsicWidthNSSlider alloc]
+		initWithFrame:NSMakeRect(0, 0, sliderWidth, 2)];
+	[s->slider setMinValue:min];
+	[s->slider setMaxValue:max];
+	[s->slider setAllowsTickMarkValuesOnly:NO];
+	[s->slider setNumberOfTickMarks:0];
+	[s->slider setTickMarkPosition:NSTickMarkAbove];
+
+	cell = (NSSliderCell *) [s->slider cell];
+	[cell setSliderType:NSLinearSlider];
+
+	if (sliderDelegate == nil) {
+		sliderDelegate = [[sliderDelegateClass new] autorelease];
+		[delegates addObject:sliderDelegate];
+	}
+	[sliderDelegate registerSlider:s];
+	uiSliderOnChanged(s, defaultOnChanged, NULL);
+
+	return s;
+}
diff --git a/src/libui_sdl/libui/darwin/spinbox.m b/src/libui_sdl/libui/darwin/spinbox.m
new file mode 100644
index 0000000..73474d0
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/spinbox.m
@@ -0,0 +1,214 @@
+// 14 august 2015
+#import "uipriv_darwin.h"
+
+@interface libui_spinbox : NSView<NSTextFieldDelegate> {
+	NSTextField *tf;
+	NSNumberFormatter *formatter;
+	NSStepper *stepper;
+
+	NSInteger value;
+	NSInteger minimum;
+	NSInteger maximum;
+
+	uiSpinbox *spinbox;
+}
+- (id)initWithFrame:(NSRect)r spinbox:(uiSpinbox *)sb;
+// see https://github.com/andlabs/ui/issues/82
+- (NSInteger)libui_value;
+- (void)libui_setValue:(NSInteger)val;
+- (void)setMinimum:(NSInteger)min;
+- (void)setMaximum:(NSInteger)max;
+- (IBAction)stepperClicked:(id)sender;
+- (void)controlTextDidChange:(NSNotification *)note;
+@end
+
+struct uiSpinbox {
+	uiDarwinControl c;
+	libui_spinbox *spinbox;
+	void (*onChanged)(uiSpinbox *, void *);
+	void *onChangedData;
+};
+
+// yes folks, this varies by operating system! woo!
+// 10.10 started drawing the NSStepper one point too low, so we have to fix it up conditionally
+// TODO test this; we'll probably have to substitute 10_9
+static CGFloat stepperYDelta(void)
+{
+	// via https://developer.apple.com/library/mac/releasenotes/AppKit/RN-AppKit/
+	if (floor(NSAppKitVersionNumber) <= NSAppKitVersionNumber10_9)
+		return 0;
+	return -1;
+}
+
+@implementation libui_spinbox
+
+- (id)initWithFrame:(NSRect)r spinbox:(uiSpinbox *)sb
+{
+	self = [super initWithFrame:r];
+	if (self) {
+		self->tf = newEditableTextField();
+		[self->tf setTranslatesAutoresizingMaskIntoConstraints:NO];
+
+		self->formatter = [NSNumberFormatter new];
+		[self->formatter setFormatterBehavior:NSNumberFormatterBehavior10_4];
+		[self->formatter setLocalizesFormat:NO];
+		[self->formatter setUsesGroupingSeparator:NO];
+		[self->formatter setHasThousandSeparators:NO];
+		[self->formatter setAllowsFloats:NO];
+		[self->tf setFormatter:self->formatter];
+
+		self->stepper = [[NSStepper alloc] initWithFrame:NSZeroRect];
+		[self->stepper setIncrement:1];
+		[self->stepper setValueWraps:NO];
+		[self->stepper setAutorepeat:YES];              // hold mouse button to step repeatedly
+		[self->stepper setTranslatesAutoresizingMaskIntoConstraints:NO];
+
+		[self->tf setDelegate:self];
+		[self->stepper setTarget:self];
+		[self->stepper setAction:@selector(stepperClicked:)];
+
+		[self addSubview:self->tf];
+		[self addSubview:self->stepper];
+
+		[self addConstraint:mkConstraint(self->tf, NSLayoutAttributeLeading,
+			NSLayoutRelationEqual,
+			self, NSLayoutAttributeLeading,
+			1, 0,
+			@"uiSpinbox left edge")];
+		[self addConstraint:mkConstraint(self->stepper, NSLayoutAttributeTrailing,
+			NSLayoutRelationEqual,
+			self, NSLayoutAttributeTrailing,
+			1, 0,
+			@"uiSpinbox right edge")];
+		[self addConstraint:mkConstraint(self->tf, NSLayoutAttributeTop,
+			NSLayoutRelationEqual,
+			self, NSLayoutAttributeTop,
+			1, 0,
+			@"uiSpinbox top edge text field")];
+		[self addConstraint:mkConstraint(self->tf, NSLayoutAttributeBottom,
+			NSLayoutRelationEqual,
+			self, NSLayoutAttributeBottom,
+			1, 0,
+			@"uiSpinbox bottom edge text field")];
+		[self addConstraint:mkConstraint(self->stepper, NSLayoutAttributeTop,
+			NSLayoutRelationEqual,
+			self, NSLayoutAttributeTop,
+			1, stepperYDelta(),
+			@"uiSpinbox top edge stepper")];
+		[self addConstraint:mkConstraint(self->stepper, NSLayoutAttributeBottom,
+			NSLayoutRelationEqual,
+			self, NSLayoutAttributeBottom,
+			1, stepperYDelta(),
+			@"uiSpinbox bottom edge stepper")];
+		[self addConstraint:mkConstraint(self->tf, NSLayoutAttributeTrailing,
+			NSLayoutRelationEqual,
+			self->stepper, NSLayoutAttributeLeading,
+			1, -3,		// arbitrary amount; good enough visually (and it seems to match NSDatePicker too, at least on 10.11, which is even better)
+			@"uiSpinbox space between text field and stepper")];
+
+		self->spinbox = sb;
+	}
+	return self;
+}
+
+- (void)dealloc
+{
+	[self->tf setDelegate:nil];
+	[self->tf removeFromSuperview];
+	[self->tf release];
+	[self->formatter release];
+	[self->stepper setTarget:nil];
+	[self->stepper removeFromSuperview];
+	[self->stepper release];
+	[super dealloc];
+}
+
+- (NSInteger)libui_value
+{
+	return self->value;
+}
+
+- (void)libui_setValue:(NSInteger)val
+{
+	self->value = val;
+	if (self->value < self->minimum)
+		self->value = self->minimum;
+	if (self->value > self->maximum)
+		self->value = self->maximum;
+	[self->tf setIntegerValue:self->value];
+	[self->stepper setIntegerValue:self->value];
+}
+
+- (void)setMinimum:(NSInteger)min
+{
+	self->minimum = min;
+	[self->formatter setMinimum:[NSNumber numberWithInteger:self->minimum]];
+	[self->stepper setMinValue:((double) (self->minimum))];
+}
+
+- (void)setMaximum:(NSInteger)max
+{
+	self->maximum = max;
+	[self->formatter setMaximum:[NSNumber numberWithInteger:self->maximum]];
+	[self->stepper setMaxValue:((double) (self->maximum))];
+}
+
+- (IBAction)stepperClicked:(id)sender
+{
+	[self libui_setValue:[self->stepper integerValue]];
+	(*(self->spinbox->onChanged))(self->spinbox, self->spinbox->onChangedData);
+}
+
+- (void)controlTextDidChange:(NSNotification *)note
+{
+	[self libui_setValue:[self->tf integerValue]];
+	(*(self->spinbox->onChanged))(self->spinbox, self->spinbox->onChangedData);
+}
+
+@end
+
+uiDarwinControlAllDefaults(uiSpinbox, spinbox)
+
+int uiSpinboxValue(uiSpinbox *s)
+{
+	return [s->spinbox libui_value];
+}
+
+void uiSpinboxSetValue(uiSpinbox *s, int value)
+{
+	[s->spinbox libui_setValue:value];
+}
+
+void uiSpinboxOnChanged(uiSpinbox *s, void (*f)(uiSpinbox *, void *), void *data)
+{
+	s->onChanged = f;
+	s->onChangedData = data;
+}
+
+static void defaultOnChanged(uiSpinbox *s, void *data)
+{
+	// do nothing
+}
+
+uiSpinbox *uiNewSpinbox(int min, int max)
+{
+	uiSpinbox *s;
+	int temp;
+
+	if (min >= max) {
+		temp = min;
+		min = max;
+		max = temp;
+	}
+
+	uiDarwinNewControl(uiSpinbox, s);
+
+	s->spinbox = [[libui_spinbox alloc] initWithFrame:NSZeroRect spinbox:s];
+	[s->spinbox setMinimum:min];
+	[s->spinbox setMaximum:max];
+	[s->spinbox libui_setValue:min];
+
+	uiSpinboxOnChanged(s, defaultOnChanged, NULL);
+
+	return s;
+}
diff --git a/src/libui_sdl/libui/darwin/stddialogs.m b/src/libui_sdl/libui/darwin/stddialogs.m
new file mode 100644
index 0000000..57ce959
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/stddialogs.m
@@ -0,0 +1,123 @@
+// 26 june 2015
+#import "uipriv_darwin.h"
+
+// LONGTERM restructure this whole file
+// LONGTERM explicitly document this works as we want
+// LONGTERM note that font and color buttons also do this
+
+#define windowWindow(w) ((NSWindow *) uiControlHandle(uiControl(w)))
+
+// source of code modal logic: http://stackoverflow.com/questions/604768/wait-for-nsalert-beginsheetmodalforwindow
+
+// note: whether extensions are actually shown depends on a user setting in Finder; we can't control it here
+static void setupSavePanel(NSSavePanel *s)
+{
+	[s setCanCreateDirectories:YES];
+	[s setShowsHiddenFiles:YES];
+	[s setExtensionHidden:NO];
+	[s setCanSelectHiddenExtension:NO];
+	[s setTreatsFilePackagesAsDirectories:YES];
+}
+
+static char *runSavePanel(NSWindow *parent, NSSavePanel *s)
+{
+	char *filename;
+
+	[s beginSheetModalForWindow:parent completionHandler:^(NSInteger result) {
+		[realNSApp() stopModalWithCode:result];
+	}];
+	if ([realNSApp() runModalForWindow:s] != NSFileHandlingPanelOKButton)
+		return NULL;
+	filename = uiDarwinNSStringToText([[s URL] path]);
+	return filename;
+}
+
+char *uiOpenFile(uiWindow *parent)
+{
+	NSOpenPanel *o;
+
+	o = [NSOpenPanel openPanel];
+	[o setCanChooseFiles:YES];
+	[o setCanChooseDirectories:NO];
+	[o setResolvesAliases:NO];
+	[o setAllowsMultipleSelection:NO];
+	setupSavePanel(o);
+	// panel is autoreleased
+	return runSavePanel(windowWindow(parent), o);
+}
+
+char *uiSaveFile(uiWindow *parent)
+{
+	NSSavePanel *s;
+
+	s = [NSSavePanel savePanel];
+	setupSavePanel(s);
+	// panel is autoreleased
+	return runSavePanel(windowWindow(parent), s);
+}
+
+// I would use a completion handler for NSAlert as well, but alas NSAlert's are 10.9 and higher only
+@interface libuiCodeModalAlertPanel : NSObject {
+	NSAlert *panel;
+	NSWindow *parent;
+}
+- (id)initWithPanel:(NSAlert *)p parent:(NSWindow *)w;
+- (NSInteger)run;
+- (void)panelEnded:(NSAlert *)panel result:(NSInteger)result data:(void *)data;
+@end
+
+@implementation libuiCodeModalAlertPanel
+
+- (id)initWithPanel:(NSAlert *)p parent:(NSWindow *)w
+{
+	self = [super init];
+	if (self) {
+		self->panel = p;
+		self->parent = w;
+	}
+	return self;
+}
+
+- (NSInteger)run
+{
+	[self->panel beginSheetModalForWindow:self->parent
+		modalDelegate:self
+		didEndSelector:@selector(panelEnded:result:data:)
+		contextInfo:NULL];
+	return [realNSApp() runModalForWindow:[self->panel window]];
+}
+
+- (void)panelEnded:(NSAlert *)panel result:(NSInteger)result data:(void *)data
+{
+	[realNSApp() stopModalWithCode:result];
+}
+
+@end
+
+static void msgbox(NSWindow *parent, const char *title, const char *description, NSAlertStyle style)
+{
+	NSAlert *a;
+	libuiCodeModalAlertPanel *cm;
+
+	a = [NSAlert new];
+	[a setAlertStyle:style];
+	[a setShowsHelp:NO];
+	[a setShowsSuppressionButton:NO];
+	[a setMessageText:toNSString(title)];
+	[a setInformativeText:toNSString(description)];
+	[a addButtonWithTitle:@"OK"];
+	cm = [[libuiCodeModalAlertPanel alloc] initWithPanel:a parent:parent];
+	[cm run];
+	[cm release];
+	[a release];
+}
+
+void uiMsgBox(uiWindow *parent, const char *title, const char *description)
+{
+	msgbox(windowWindow(parent), title, description, NSInformationalAlertStyle);
+}
+
+void uiMsgBoxError(uiWindow *parent, const char *title, const char *description)
+{
+	msgbox(windowWindow(parent), title, description, NSCriticalAlertStyle);
+}
diff --git a/src/libui_sdl/libui/darwin/tab.m b/src/libui_sdl/libui/darwin/tab.m
new file mode 100644
index 0000000..3d2ca9f
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/tab.m
@@ -0,0 +1,292 @@
+// 15 august 2015
+#import "uipriv_darwin.h"
+
+// TODO need to jiggle on tab change too (second page disabled tab label initially ambiguous)
+
+@interface tabPage : NSObject {
+	struct singleChildConstraints constraints;
+	int margined;
+	NSView *view;		// the NSTabViewItem view itself
+	NSObject *pageID;
+}
+@property uiControl *c;
+@property NSLayoutPriority oldHorzHuggingPri;
+@property NSLayoutPriority oldVertHuggingPri;
+- (id)initWithView:(NSView *)v pageID:(NSObject *)o;
+- (NSView *)childView;
+- (void)establishChildConstraints;
+- (void)removeChildConstraints;
+- (int)isMargined;
+- (void)setMargined:(int)m;
+@end
+
+struct uiTab {
+	uiDarwinControl c;
+	NSTabView *tabview;
+	NSMutableArray *pages;
+	NSLayoutPriority horzHuggingPri;
+	NSLayoutPriority vertHuggingPri;
+};
+
+@implementation tabPage
+
+- (id)initWithView:(NSView *)v pageID:(NSObject *)o
+{
+	self = [super init];
+	if (self != nil) {
+		self->view = [v retain];
+		self->pageID = [o retain];
+	}
+	return self;
+}
+
+- (void)dealloc
+{
+	[self removeChildConstraints];
+	[self->view release];
+	[self->pageID release];
+	[super dealloc];
+}
+
+- (NSView *)childView
+{
+	return (NSView *) uiControlHandle(self.c);
+}
+
+- (void)establishChildConstraints
+{
+	[self removeChildConstraints];
+	if (self.c == NULL)
+		return;
+	singleChildConstraintsEstablish(&(self->constraints),
+		self->view, [self childView],
+		uiDarwinControlHugsTrailingEdge(uiDarwinControl(self.c)),
+		uiDarwinControlHugsBottom(uiDarwinControl(self.c)),
+		self->margined,
+		@"uiTab page");
+}
+
+- (void)removeChildConstraints
+{
+	singleChildConstraintsRemove(&(self->constraints), self->view);
+}
+
+- (int)isMargined
+{
+	return self->margined;
+}
+
+- (void)setMargined:(int)m
+{
+	self->margined = m;
+	singleChildConstraintsSetMargined(&(self->constraints), self->margined);
+}
+
+@end
+
+static void uiTabDestroy(uiControl *c)
+{
+	uiTab *t = uiTab(c);
+	tabPage *page;
+
+	// first remove all tab pages so we can destroy all the children
+	while ([t->tabview numberOfTabViewItems] != 0)
+		[t->tabview removeTabViewItem:[t->tabview tabViewItemAtIndex:0]];
+	// then destroy all the children
+	for (page in t->pages) {
+		[page removeChildConstraints];
+		uiControlSetParent(page.c, NULL);
+		uiDarwinControlSetSuperview(uiDarwinControl(page.c), nil);
+		uiControlDestroy(page.c);
+	}
+	// and finally destroy ourselves
+	[t->pages release];
+	[t->tabview release];
+	uiFreeControl(uiControl(t));
+}
+
+uiDarwinControlDefaultHandle(uiTab, tabview)
+uiDarwinControlDefaultParent(uiTab, tabview)
+uiDarwinControlDefaultSetParent(uiTab, tabview)
+uiDarwinControlDefaultToplevel(uiTab, tabview)
+uiDarwinControlDefaultVisible(uiTab, tabview)
+uiDarwinControlDefaultShow(uiTab, tabview)
+uiDarwinControlDefaultHide(uiTab, tabview)
+uiDarwinControlDefaultEnabled(uiTab, tabview)
+uiDarwinControlDefaultEnable(uiTab, tabview)
+uiDarwinControlDefaultDisable(uiTab, tabview)
+
+static void uiTabSyncEnableState(uiDarwinControl *c, int enabled)
+{
+	uiTab *t = uiTab(c);
+	tabPage *page;
+
+	if (uiDarwinShouldStopSyncEnableState(uiDarwinControl(t), enabled))
+		return;
+	for (page in t->pages)
+		uiDarwinControlSyncEnableState(uiDarwinControl(page.c), enabled);
+}
+
+uiDarwinControlDefaultSetSuperview(uiTab, tabview)
+
+static void tabRelayout(uiTab *t)
+{
+	tabPage *page;
+
+	for (page in t->pages)
+		[page establishChildConstraints];
+	// and this gets rid of some weird issues with regards to box alignment
+	jiggleViewLayout(t->tabview);
+}
+
+BOOL uiTabHugsTrailingEdge(uiDarwinControl *c)
+{
+	uiTab *t = uiTab(c);
+
+	return t->horzHuggingPri < NSLayoutPriorityWindowSizeStayPut;
+}
+
+BOOL uiTabHugsBottom(uiDarwinControl *c)
+{
+	uiTab *t = uiTab(c);
+
+	return t->vertHuggingPri < NSLayoutPriorityWindowSizeStayPut;
+}
+
+static void uiTabChildEdgeHuggingChanged(uiDarwinControl *c)
+{
+	uiTab *t = uiTab(c);
+
+	tabRelayout(t);
+}
+
+static NSLayoutPriority uiTabHuggingPriority(uiDarwinControl *c, NSLayoutConstraintOrientation orientation)
+{
+	uiTab *t = uiTab(c);
+
+	if (orientation == NSLayoutConstraintOrientationHorizontal)
+		return t->horzHuggingPri;
+	return t->vertHuggingPri;
+}
+
+static void uiTabSetHuggingPriority(uiDarwinControl *c, NSLayoutPriority priority, NSLayoutConstraintOrientation orientation)
+{
+	uiTab *t = uiTab(c);
+
+	if (orientation == NSLayoutConstraintOrientationHorizontal)
+		t->horzHuggingPri = priority;
+	else
+		t->vertHuggingPri = priority;
+	uiDarwinNotifyEdgeHuggingChanged(uiDarwinControl(t));
+}
+
+static void uiTabChildVisibilityChanged(uiDarwinControl *c)
+{
+	uiTab *t = uiTab(c);
+
+	tabRelayout(t);
+}
+
+void uiTabAppend(uiTab *t, const char *name, uiControl *child)
+{
+	uiTabInsertAt(t, name, [t->pages count], child);
+}
+
+void uiTabInsertAt(uiTab *t, const char *name, int n, uiControl *child)
+{
+	tabPage *page;
+	NSView *view;
+	NSTabViewItem *i;
+	NSObject *pageID;
+
+	uiControlSetParent(child, uiControl(t));
+
+	view = [[[NSView alloc] initWithFrame:NSZeroRect] autorelease];
+	// note: if we turn off the autoresizing mask, nothing shows up
+	uiDarwinControlSetSuperview(uiDarwinControl(child), view);
+	uiDarwinControlSyncEnableState(uiDarwinControl(child), uiControlEnabledToUser(uiControl(t)));
+
+	// the documentation says these can be nil but the headers say these must not be; let's be safe and make them non-nil anyway
+	pageID = [NSObject new];
+	page = [[[tabPage alloc] initWithView:view pageID:pageID] autorelease];
+	page.c = child;
+
+	// don't hug, just in case we're a stretchy tab
+	page.oldHorzHuggingPri = uiDarwinControlHuggingPriority(uiDarwinControl(page.c), NSLayoutConstraintOrientationHorizontal);
+	page.oldVertHuggingPri = uiDarwinControlHuggingPriority(uiDarwinControl(page.c), NSLayoutConstraintOrientationVertical);
+	uiDarwinControlSetHuggingPriority(uiDarwinControl(page.c), NSLayoutPriorityDefaultLow, NSLayoutConstraintOrientationHorizontal);
+	uiDarwinControlSetHuggingPriority(uiDarwinControl(page.c), NSLayoutPriorityDefaultLow, NSLayoutConstraintOrientationVertical);
+
+	[t->pages insertObject:page atIndex:n];
+
+	i = [[[NSTabViewItem alloc] initWithIdentifier:pageID] autorelease];
+	[i setLabel:toNSString(name)];
+	[i setView:view];
+	[t->tabview insertTabViewItem:i atIndex:n];
+
+	tabRelayout(t);
+}
+
+void uiTabDelete(uiTab *t, int n)
+{
+	tabPage *page;
+	uiControl *child;
+	NSTabViewItem *i;
+
+	page = (tabPage *) [t->pages objectAtIndex:n];
+
+	uiDarwinControlSetHuggingPriority(uiDarwinControl(page.c), page.oldHorzHuggingPri, NSLayoutConstraintOrientationHorizontal);
+	uiDarwinControlSetHuggingPriority(uiDarwinControl(page.c), page.oldVertHuggingPri, NSLayoutConstraintOrientationVertical);
+
+	child = page.c;
+	[page removeChildConstraints];
+	[t->pages removeObjectAtIndex:n];
+
+	uiControlSetParent(child, NULL);
+	uiDarwinControlSetSuperview(uiDarwinControl(child), nil);
+
+	i = [t->tabview tabViewItemAtIndex:n];
+	[t->tabview removeTabViewItem:i];
+
+	tabRelayout(t);
+}
+
+int uiTabNumPages(uiTab *t)
+{
+	return [t->pages count];
+}
+
+int uiTabMargined(uiTab *t, int n)
+{
+	tabPage *page;
+
+	page = (tabPage *) [t->pages objectAtIndex:n];
+	return [page isMargined];
+}
+
+void uiTabSetMargined(uiTab *t, int n, int margined)
+{
+	tabPage *page;
+
+	page = (tabPage *) [t->pages objectAtIndex:n];
+	[page setMargined:margined];
+}
+
+uiTab *uiNewTab(void)
+{
+	uiTab *t;
+
+	uiDarwinNewControl(uiTab, t);
+
+	t->tabview = [[NSTabView alloc] initWithFrame:NSZeroRect];
+	// also good for NSTabView (same selector and everything)
+	uiDarwinSetControlFont((NSControl *) (t->tabview), NSRegularControlSize);
+
+	t->pages = [NSMutableArray new];
+
+	// default to low hugging to not hug edges
+	t->horzHuggingPri = NSLayoutPriorityDefaultLow;
+	t->vertHuggingPri = NSLayoutPriorityDefaultLow;
+
+	return t;
+}
diff --git a/src/libui_sdl/libui/darwin/text.m b/src/libui_sdl/libui/darwin/text.m
new file mode 100644
index 0000000..f0d3dab
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/text.m
@@ -0,0 +1,19 @@
+// 10 april 2015
+#import "uipriv_darwin.h"
+
+char *uiDarwinNSStringToText(NSString *s)
+{
+	char *out;
+
+	out = strdup([s UTF8String]);
+	if (out == NULL) {
+		fprintf(stderr, "memory exhausted in uiDarwinNSStringToText()\n");
+		abort();
+	}
+	return out;
+}
+
+void uiFreeText(char *s)
+{
+	free(s);
+}
diff --git a/src/libui_sdl/libui/darwin/uipriv_darwin.h b/src/libui_sdl/libui/darwin/uipriv_darwin.h
new file mode 100644
index 0000000..6bca87b
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/uipriv_darwin.h
@@ -0,0 +1,146 @@
+// 6 january 2015
+#define MAC_OS_X_VERSION_MIN_REQUIRED MAC_OS_X_VERSION_10_8
+#define MAC_OS_X_VERSION_MAX_ALLOWED MAC_OS_X_VERSION_10_8
+#import <Cocoa/Cocoa.h>
+#import "../ui.h"
+#import "../ui_darwin.h"
+#import "../common/uipriv.h"
+
+#if __has_feature(objc_arc)
+#error Sorry, libui cannot be compiled with ARC.
+#endif
+
+#define toNSString(str) [NSString stringWithUTF8String:(str)]
+#define fromNSString(str) [(str) UTF8String]
+
+#ifndef NSAppKitVersionNumber10_9
+#define NSAppKitVersionNumber10_9 1265
+#endif
+
+/*TODO remove this*/typedef struct uiImage uiImage;
+
+// menu.m
+@interface menuManager : NSObject {
+	struct mapTable *items;
+	BOOL hasQuit;
+	BOOL hasPreferences;
+	BOOL hasAbout;
+}
+@property (strong) NSMenuItem *quitItem;
+@property (strong) NSMenuItem *preferencesItem;
+@property (strong) NSMenuItem *aboutItem;
+// NSMenuValidation is only informal
+- (BOOL)validateMenuItem:(NSMenuItem *)item;
+- (NSMenu *)makeMenubar;
+@end
+extern void finalizeMenus(void);
+extern void uninitMenus(void);
+
+// main.m
+@interface applicationClass : NSApplication
+@end
+// this is needed because NSApp is of type id, confusing clang
+#define realNSApp() ((applicationClass *) NSApp)
+@interface appDelegate : NSObject <NSApplicationDelegate>
+@property (strong) menuManager *menuManager;
+@end
+#define appDelegate() ((appDelegate *) [realNSApp() delegate])
+struct nextEventArgs {
+	NSEventMask mask;
+	NSDate *duration;
+	// LONGTERM no NSRunLoopMode?
+	NSString *mode;
+	BOOL dequeue;
+};
+extern int mainStep(struct nextEventArgs *nea, BOOL (^interceptEvent)(NSEvent *));
+
+// util.m
+extern void disableAutocorrect(NSTextView *);
+
+// entry.m
+extern void finishNewTextField(NSTextField *, BOOL);
+extern NSTextField *newEditableTextField(void);
+
+// window.m
+@interface libuiNSWindow : NSWindow
+- (void)libui_doMove:(NSEvent *)initialEvent;
+- (void)libui_doResize:(NSEvent *)initialEvent on:(uiWindowResizeEdge)edge;
+@end
+extern uiWindow *windowFromNSWindow(NSWindow *);
+
+// alloc.m
+extern NSMutableArray *delegates;
+extern void initAlloc(void);
+extern void uninitAlloc(void);
+
+// autolayout.m
+extern NSLayoutConstraint *mkConstraint(id view1, NSLayoutAttribute attr1, NSLayoutRelation relation, id view2, NSLayoutAttribute attr2, CGFloat multiplier, CGFloat c, NSString *desc);
+extern void jiggleViewLayout(NSView *view);
+struct singleChildConstraints {
+	NSLayoutConstraint *leadingConstraint;
+	NSLayoutConstraint *topConstraint;
+	NSLayoutConstraint *trailingConstraintGreater;
+	NSLayoutConstraint *trailingConstraintEqual;
+	NSLayoutConstraint *bottomConstraintGreater;
+	NSLayoutConstraint *bottomConstraintEqual;
+};
+extern void singleChildConstraintsEstablish(struct singleChildConstraints *c, NSView *contentView, NSView *childView, BOOL hugsTrailing, BOOL hugsBottom, int margined, NSString *desc);
+extern void singleChildConstraintsRemove(struct singleChildConstraints *c, NSView *cv);
+extern void singleChildConstraintsSetMargined(struct singleChildConstraints *c, int margined);
+
+// map.m
+extern struct mapTable *newMap(void);
+extern void mapDestroy(struct mapTable *m);
+extern void *mapGet(struct mapTable *m, void *key);
+extern void mapSet(struct mapTable *m, void *key, void *value);
+extern void mapDelete(struct mapTable *m, void *key);
+extern void mapWalk(struct mapTable *m, void (*f)(void *key, void *value));
+extern void mapReset(struct mapTable *m);
+
+// area.m
+extern int sendAreaEvents(NSEvent *);
+
+// areaevents.m
+extern BOOL fromKeycode(unsigned short keycode, uiAreaKeyEvent *ke);
+extern BOOL keycodeModifier(unsigned short keycode, uiModifiers *mod);
+
+// draw.m
+extern uiDrawContext *newContext(CGContextRef, CGFloat);
+extern void freeContext(uiDrawContext *);
+
+// drawtext.m
+extern uiDrawTextFont *mkTextFont(CTFontRef f, BOOL retain);
+extern uiDrawTextFont *mkTextFontFromNSFont(NSFont *f);
+extern void doDrawText(CGContextRef c, CGFloat cheight, double x, double y, uiDrawTextLayout *layout);
+
+// fontbutton.m
+extern BOOL fontButtonInhibitSendAction(SEL sel, id from, id to);
+extern BOOL fontButtonOverrideTargetForAction(SEL sel, id from, id to, id *override);
+extern void setupFontPanel(void);
+
+// colorbutton.m
+extern BOOL colorButtonInhibitSendAction(SEL sel, id from, id to);
+
+// scrollview.m
+struct scrollViewCreateParams {
+	NSView *DocumentView;
+	NSColor *BackgroundColor;
+	BOOL DrawsBackground;
+	BOOL Bordered;
+	BOOL HScroll;
+	BOOL VScroll;
+};
+struct scrollViewData;
+extern NSScrollView *mkScrollView(struct scrollViewCreateParams *p, struct scrollViewData **dout);
+extern void scrollViewSetScrolling(NSScrollView *sv, struct scrollViewData *d, BOOL hscroll, BOOL vscroll);
+extern void scrollViewFreeData(NSScrollView *sv, struct scrollViewData *d);
+
+// label.m
+extern NSTextField *newLabel(NSString *str);
+
+// image.m
+extern NSImage *imageImage(uiImage *);
+
+// winmoveresize.m
+extern void doManualMove(NSWindow *w, NSEvent *initialEvent);
+extern void doManualResize(NSWindow *w, NSEvent *initialEvent, uiWindowResizeEdge edge);
diff --git a/src/libui_sdl/libui/darwin/util.m b/src/libui_sdl/libui/darwin/util.m
new file mode 100644
index 0000000..ab87390
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/util.m
@@ -0,0 +1,15 @@
+// 7 april 2015
+#import "uipriv_darwin.h"
+
+// LONGTERM do we really want to do this? make it an option?
+void disableAutocorrect(NSTextView *tv)
+{
+	[tv setEnabledTextCheckingTypes:0];
+	[tv setAutomaticDashSubstitutionEnabled:NO];
+	// don't worry about automatic data detection; it won't change stringValue (thanks pretty_function in irc.freenode.net/#macdev)
+	[tv setAutomaticSpellingCorrectionEnabled:NO];
+	[tv setAutomaticTextReplacementEnabled:NO];
+	[tv setAutomaticQuoteSubstitutionEnabled:NO];
+	[tv setAutomaticLinkDetectionEnabled:NO];
+	[tv setSmartInsertDeleteEnabled:NO];
+}
diff --git a/src/libui_sdl/libui/darwin/window.m b/src/libui_sdl/libui/darwin/window.m
new file mode 100644
index 0000000..97c22e6
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/window.m
@@ -0,0 +1,407 @@
+// 15 august 2015
+#import "uipriv_darwin.h"
+
+#define defaultStyleMask (NSTitledWindowMask | NSClosableWindowMask | NSMiniaturizableWindowMask | NSResizableWindowMask)
+
+struct uiWindow {
+	uiDarwinControl c;
+	NSWindow *window;
+	uiControl *child;
+	int margined;
+	int (*onClosing)(uiWindow *, void *);
+	void *onClosingData;
+	struct singleChildConstraints constraints;
+	void (*onContentSizeChanged)(uiWindow *, void *);
+	void *onContentSizeChangedData;
+	BOOL suppressSizeChanged;
+	int fullscreen;
+	int borderless;
+};
+
+@implementation libuiNSWindow
+
+- (void)libui_doMove:(NSEvent *)initialEvent
+{
+	doManualMove(self, initialEvent);
+}
+
+- (void)libui_doResize:(NSEvent *)initialEvent on:(uiWindowResizeEdge)edge
+{
+	doManualResize(self, initialEvent, edge);
+}
+
+@end
+
+@interface windowDelegateClass : NSObject<NSWindowDelegate> {
+	struct mapTable *windows;
+}
+- (BOOL)windowShouldClose:(id)sender;
+- (void)windowDidResize:(NSNotification *)note;
+- (void)windowDidEnterFullScreen:(NSNotification *)note;
+- (void)windowDidExitFullScreen:(NSNotification *)note;
+- (void)registerWindow:(uiWindow *)w;
+- (void)unregisterWindow:(uiWindow *)w;
+- (uiWindow *)lookupWindow:(NSWindow *)w;
+@end
+
+@implementation windowDelegateClass
+
+- (id)init
+{
+	self = [super init];
+	if (self)
+		self->windows = newMap();
+	return self;
+}
+
+- (void)dealloc
+{
+	mapDestroy(self->windows);
+	[super dealloc];
+}
+
+- (BOOL)windowShouldClose:(id)sender
+{
+	uiWindow *w;
+
+	w = [self lookupWindow:((NSWindow *) sender)];
+	// w should not be NULL; we are only the delegate of registered windows
+	if ((*(w->onClosing))(w, w->onClosingData))
+		uiControlDestroy(uiControl(w));
+	return NO;
+}
+
+- (void)windowDidResize:(NSNotification *)note
+{
+	uiWindow *w;
+
+	w = [self lookupWindow:((NSWindow *) [note object])];
+	if (!w->suppressSizeChanged)
+		(*(w->onContentSizeChanged))(w, w->onContentSizeChangedData);
+}
+
+- (void)windowDidEnterFullScreen:(NSNotification *)note
+{
+	uiWindow *w;
+
+	w = [self lookupWindow:((NSWindow *) [note object])];
+	if (!w->suppressSizeChanged)
+		w->fullscreen = 1;
+}
+
+- (void)windowDidExitFullScreen:(NSNotification *)note
+{
+	uiWindow *w;
+
+	w = [self lookupWindow:((NSWindow *) [note object])];
+	if (!w->suppressSizeChanged)
+		w->fullscreen = 0;
+}
+
+- (void)registerWindow:(uiWindow *)w
+{
+	mapSet(self->windows, w->window, w);
+	[w->window setDelegate:self];
+}
+
+- (void)unregisterWindow:(uiWindow *)w
+{
+	[w->window setDelegate:nil];
+	mapDelete(self->windows, w->window);
+}
+
+- (uiWindow *)lookupWindow:(NSWindow *)w
+{
+	uiWindow *v;
+
+	v = uiWindow(mapGet(self->windows, w));
+	// this CAN (and IS ALLOWED TO) return NULL, just in case we're called with some OS X-provided window as the key window
+	return v;
+}
+
+@end
+
+static windowDelegateClass *windowDelegate = nil;
+
+static void removeConstraints(uiWindow *w)
+{
+	NSView *cv;
+
+	cv = [w->window contentView];
+	singleChildConstraintsRemove(&(w->constraints), cv);
+}
+
+static void uiWindowDestroy(uiControl *c)
+{
+	uiWindow *w = uiWindow(c);
+
+	// hide the window
+	[w->window orderOut:w->window];
+	removeConstraints(w);
+	if (w->child != NULL) {
+		uiControlSetParent(w->child, NULL);
+		uiDarwinControlSetSuperview(uiDarwinControl(w->child), nil);
+		uiControlDestroy(w->child);
+	}
+	[windowDelegate unregisterWindow:w];
+	[w->window release];
+	uiFreeControl(uiControl(w));
+}
+
+uiDarwinControlDefaultHandle(uiWindow, window)
+
+uiControl *uiWindowParent(uiControl *c)
+{
+	return NULL;
+}
+
+void uiWindowSetParent(uiControl *c, uiControl *parent)
+{
+	uiUserBugCannotSetParentOnToplevel("uiWindow");
+}
+
+static int uiWindowToplevel(uiControl *c)
+{
+	return 1;
+}
+
+static int uiWindowVisible(uiControl *c)
+{
+	uiWindow *w = uiWindow(c);
+
+	return [w->window isVisible];
+}
+
+static void uiWindowShow(uiControl *c)
+{
+	uiWindow *w = (uiWindow *) c;
+
+	[w->window makeKeyAndOrderFront:w->window];
+}
+
+static void uiWindowHide(uiControl *c)
+{
+	uiWindow *w = (uiWindow *) c;
+
+	[w->window orderOut:w->window];
+}
+
+uiDarwinControlDefaultEnabled(uiWindow, window)
+uiDarwinControlDefaultEnable(uiWindow, window)
+uiDarwinControlDefaultDisable(uiWindow, window)
+
+static void uiWindowSyncEnableState(uiDarwinControl *c, int enabled)
+{
+	uiWindow *w = uiWindow(c);
+
+	if (uiDarwinShouldStopSyncEnableState(uiDarwinControl(w), enabled))
+		return;
+	if (w->child != NULL)
+		uiDarwinControlSyncEnableState(uiDarwinControl(w->child), enabled);
+}
+
+static void uiWindowSetSuperview(uiDarwinControl *c, NSView *superview)
+{
+	// TODO
+}
+
+static void windowRelayout(uiWindow *w)
+{
+	NSView *childView;
+	NSView *contentView;
+
+	removeConstraints(w);
+	if (w->child == NULL)
+		return;
+	childView = (NSView *) uiControlHandle(w->child);
+	contentView = [w->window contentView];
+	singleChildConstraintsEstablish(&(w->constraints),
+		contentView, childView,
+		uiDarwinControlHugsTrailingEdge(uiDarwinControl(w->child)),
+		uiDarwinControlHugsBottom(uiDarwinControl(w->child)),
+		w->margined,
+		@"uiWindow");
+}
+
+uiDarwinControlDefaultHugsTrailingEdge(uiWindow, window)
+uiDarwinControlDefaultHugsBottom(uiWindow, window)
+
+static void uiWindowChildEdgeHuggingChanged(uiDarwinControl *c)
+{
+	uiWindow *w = uiWindow(c);
+
+	windowRelayout(w);
+}
+
+// TODO
+uiDarwinControlDefaultHuggingPriority(uiWindow, window)
+uiDarwinControlDefaultSetHuggingPriority(uiWindow, window)
+// end TODO
+
+static void uiWindowChildVisibilityChanged(uiDarwinControl *c)
+{
+	uiWindow *w = uiWindow(c);
+
+	windowRelayout(w);
+}
+
+char *uiWindowTitle(uiWindow *w)
+{
+	return uiDarwinNSStringToText([w->window title]);
+}
+
+void uiWindowSetTitle(uiWindow *w, const char *title)
+{
+	[w->window setTitle:toNSString(title)];
+}
+
+void uiWindowContentSize(uiWindow *w, int *width, int *height)
+{
+	NSRect r;
+
+	r = [w->window contentRectForFrameRect:[w->window frame]];
+	*width = r.size.width;
+	*height = r.size.height;
+}
+
+void uiWindowSetContentSize(uiWindow *w, int width, int height)
+{
+	w->suppressSizeChanged = YES;
+	[w->window setContentSize:NSMakeSize(width, height)];
+	w->suppressSizeChanged = NO;
+}
+
+int uiWindowFullscreen(uiWindow *w)
+{
+	return w->fullscreen;
+}
+
+void uiWindowSetFullscreen(uiWindow *w, int fullscreen)
+{
+	if (w->fullscreen && fullscreen)
+		return;
+	if (!w->fullscreen && !fullscreen)
+		return;
+	w->fullscreen = fullscreen;
+	if (w->fullscreen && w->borderless)		// borderless doesn't play nice with fullscreen; don't toggle while borderless
+		return;
+	w->suppressSizeChanged = YES;
+	[w->window toggleFullScreen:w->window];
+	w->suppressSizeChanged = NO;
+	if (!w->fullscreen && w->borderless)		// borderless doesn't play nice with fullscreen; restore borderless after removing
+		[w->window setStyleMask:NSBorderlessWindowMask];
+}
+
+void uiWindowOnContentSizeChanged(uiWindow *w, void (*f)(uiWindow *, void *), void *data)
+{
+	w->onContentSizeChanged = f;
+	w->onContentSizeChangedData = data;
+}
+
+void uiWindowOnClosing(uiWindow *w, int (*f)(uiWindow *, void *), void *data)
+{
+	w->onClosing = f;
+	w->onClosingData = data;
+}
+
+int uiWindowBorderless(uiWindow *w)
+{
+	return w->borderless;
+}
+
+void uiWindowSetBorderless(uiWindow *w, int borderless)
+{
+	w->borderless = borderless;
+	if (w->borderless) {
+		// borderless doesn't play nice with fullscreen; wait for later
+		if (!w->fullscreen)
+			[w->window setStyleMask:NSBorderlessWindowMask];
+	} else {
+		[w->window setStyleMask:defaultStyleMask];
+		// borderless doesn't play nice with fullscreen; restore state
+		if (w->fullscreen) {
+			w->suppressSizeChanged = YES;
+			[w->window toggleFullScreen:w->window];
+			w->suppressSizeChanged = NO;
+		}
+	}
+}
+
+void uiWindowSetChild(uiWindow *w, uiControl *child)
+{
+	NSView *childView;
+
+	if (w->child != NULL) {
+		childView = (NSView *) uiControlHandle(w->child);
+		[childView removeFromSuperview];
+		uiControlSetParent(w->child, NULL);
+	}
+	w->child = child;
+	if (w->child != NULL) {
+		uiControlSetParent(w->child, uiControl(w));
+		childView = (NSView *) uiControlHandle(w->child);
+		uiDarwinControlSetSuperview(uiDarwinControl(w->child), [w->window contentView]);
+		uiDarwinControlSyncEnableState(uiDarwinControl(w->child), uiControlEnabledToUser(uiControl(w)));
+	}
+	windowRelayout(w);
+}
+
+int uiWindowMargined(uiWindow *w)
+{
+	return w->margined;
+}
+
+void uiWindowSetMargined(uiWindow *w, int margined)
+{
+	w->margined = margined;
+	singleChildConstraintsSetMargined(&(w->constraints), w->margined);
+}
+
+static int defaultOnClosing(uiWindow *w, void *data)
+{
+	return 0;
+}
+
+static void defaultOnPositionContentSizeChanged(uiWindow *w, void *data)
+{
+	// do nothing
+}
+
+uiWindow *uiNewWindow(const char *title, int width, int height, int hasMenubar)
+{
+	uiWindow *w;
+
+	finalizeMenus();
+
+	uiDarwinNewControl(uiWindow, w);
+
+	w->window = [[libuiNSWindow alloc] initWithContentRect:NSMakeRect(0, 0, (CGFloat) width, (CGFloat) height)
+		styleMask:defaultStyleMask
+		backing:NSBackingStoreBuffered
+		defer:YES];
+	[w->window setTitle:toNSString(title)];
+
+	// do NOT release when closed
+	// we manually do this in uiWindowDestroy() above
+	[w->window setReleasedWhenClosed:NO];
+
+	if (windowDelegate == nil) {
+		windowDelegate = [[windowDelegateClass new] autorelease];
+		[delegates addObject:windowDelegate];
+	}
+	[windowDelegate registerWindow:w];
+	uiWindowOnClosing(w, defaultOnClosing, NULL);
+	uiWindowOnContentSizeChanged(w, defaultOnPositionContentSizeChanged, NULL);
+
+	return w;
+}
+
+// utility function for menus
+uiWindow *windowFromNSWindow(NSWindow *w)
+{
+	if (w == nil)
+		return NULL;
+	if (windowDelegate == nil)		// no windows were created yet; we're called with some OS X-provided window
+		return NULL;
+	return [windowDelegate lookupWindow:w];
+}
diff --git a/src/libui_sdl/libui/darwin/winmoveresize.m b/src/libui_sdl/libui/darwin/winmoveresize.m
new file mode 100644
index 0000000..9145b7b
--- /dev/null
+++ b/src/libui_sdl/libui/darwin/winmoveresize.m
@@ -0,0 +1,253 @@
+// 1 november 2016
+#import "uipriv_darwin.h"
+
+// because we are changing the window frame each time the mouse moves, the successive -[NSEvent locationInWindow]s cannot be meaningfully used together
+// make sure they are all following some sort of standard to avoid this problem; the screen is the most obvious possibility since it requires only one conversion (the only one that a NSWindow provides)
+static NSPoint makeIndependent(NSPoint p, NSWindow *w)
+{
+	NSRect r;
+
+	r.origin = p;
+	// mikeash in irc.freenode.net/#macdev confirms both that any size will do and that we can safely ignore the resultant size
+	r.size = NSZeroSize;
+	return [w convertRectToScreen:r].origin;
+}
+
+struct onMoveDragParams {
+	NSWindow *w;
+	// using the previous point causes weird issues like the mouse seeming to fall behind the window edge... so do this instead
+	// TODO will this make things like the menubar and dock easier too?
+	NSRect initialFrame;
+	NSPoint initialPoint;
+};
+
+void onMoveDrag(struct onMoveDragParams *p, NSEvent *e)
+{
+	NSPoint new;
+	NSRect frame;
+	CGFloat offx, offy;
+
+	new = makeIndependent([e locationInWindow], p->w);
+	frame = p->initialFrame;
+
+	offx = new.x - p->initialPoint.x;
+	offy = new.y - p->initialPoint.y;
+	frame.origin.x += offx;
+	frame.origin.y += offy;
+
+	// TODO handle the menubar
+	// TODO wait the system does this for us already?!
+
+	[p->w setFrameOrigin:frame.origin];
+}
+
+void doManualMove(NSWindow *w, NSEvent *initialEvent)
+{
+	__block struct onMoveDragParams mdp;
+	struct nextEventArgs nea;
+	BOOL (^handleEvent)(NSEvent *e);
+	__block BOOL done;
+
+	// this is only available on 10.11 and newer (LONGTERM FUTURE)
+	// but use it if available; this lets us use the real OS dragging code, which means we can take advantage of OS features like Spaces
+	if ([w respondsToSelector:@selector(performWindowDragWithEvent:)]) {
+		[((id) w) performWindowDragWithEvent:initialEvent];
+		return;
+	}
+
+	mdp.w = w;
+	mdp.initialFrame = [mdp.w frame];
+	mdp.initialPoint = makeIndependent([initialEvent locationInWindow], mdp.w);
+
+	nea.mask = NSLeftMouseDraggedMask | NSLeftMouseUpMask;
+	nea.duration = [NSDate distantFuture];
+	nea.mode = NSEventTrackingRunLoopMode;		// nextEventMatchingMask: docs suggest using this for manual mouse tracking
+	nea.dequeue = YES;
+	handleEvent = ^(NSEvent *e) {
+		if ([e type] == NSLeftMouseUp) {
+			done = YES;
+			return YES;	// do not send
+		}
+		onMoveDrag(&mdp, e);
+		return YES;		// do not send
+	};
+	done = NO;
+	while (mainStep(&nea, handleEvent))
+		if (done)
+			break;
+}
+
+// see http://stackoverflow.com/a/40352996/3408572
+static void minMaxAutoLayoutSizes(NSWindow *w, NSSize *min, NSSize *max)
+{
+	NSLayoutConstraint *cw, *ch;
+	NSView *contentView;
+	NSRect prevFrame;
+
+	// if adding these constraints causes the window to change size somehow, don't show it to the user and change it back afterwards
+	NSDisableScreenUpdates();
+	prevFrame = [w frame];
+
+	// minimum: encourage the window to be as small as possible
+	contentView = [w contentView];
+	cw = mkConstraint(contentView, NSLayoutAttributeWidth,
+		NSLayoutRelationEqual,
+		nil, NSLayoutAttributeNotAnAttribute,
+		0, 0,
+		@"window minimum width finding constraint");
+	[cw setPriority:NSLayoutPriorityDragThatCanResizeWindow];
+	[contentView addConstraint:cw];
+	ch = mkConstraint(contentView, NSLayoutAttributeHeight,
+		NSLayoutRelationEqual,
+		nil, NSLayoutAttributeNotAnAttribute,
+		0, 0,
+		@"window minimum height finding constraint");
+	[ch setPriority:NSLayoutPriorityDragThatCanResizeWindow];
+	[contentView addConstraint:ch];
+	*min = [contentView fittingSize];
+	[contentView removeConstraint:cw];
+	[contentView removeConstraint:ch];
+
+	// maximum: encourage the window to be as large as possible
+	contentView = [w contentView];
+	cw = mkConstraint(contentView, NSLayoutAttributeWidth,
+		NSLayoutRelationEqual,
+		nil, NSLayoutAttributeNotAnAttribute,
+		0, CGFLOAT_MAX,
+		@"window maximum width finding constraint");
+	[cw setPriority:NSLayoutPriorityDragThatCanResizeWindow];
+	[contentView addConstraint:cw];
+	ch = mkConstraint(contentView, NSLayoutAttributeHeight,
+		NSLayoutRelationEqual,
+		nil, NSLayoutAttributeNotAnAttribute,
+		0, CGFLOAT_MAX,
+		@"window maximum height finding constraint");
+	[ch setPriority:NSLayoutPriorityDragThatCanResizeWindow];
+	[contentView addConstraint:ch];
+	*max = [contentView fittingSize];
+	[contentView removeConstraint:cw];
+	[contentView removeConstraint:ch];
+
+	[w setFrame:prevFrame display:YES];		// TODO really YES?
+	NSEnableScreenUpdates();
+}
+
+static void handleResizeLeft(NSRect *frame, NSPoint old, NSPoint new)
+{
+	frame->origin.x += new.x - old.x;
+	frame->size.width -= new.x - old.x;
+}
+
+// TODO properly handle the menubar
+// TODO wait, OS X does it for us?!
+static void handleResizeTop(NSRect *frame, NSPoint old, NSPoint new)
+{
+	frame->size.height += new.y - old.y;
+}
+
+static void handleResizeRight(NSRect *frame, NSPoint old, NSPoint new)
+{
+	frame->size.width += new.x - old.x;
+}
+
+
+// TODO properly handle the menubar
+static void handleResizeBottom(NSRect *frame, NSPoint old, NSPoint new)
+{
+	frame->origin.y += new.y - old.y;
+	frame->size.height -= new.y - old.y;
+}
+
+struct onResizeDragParams {
+	NSWindow *w;
+	// using the previous point causes weird issues like the mouse seeming to fall behind the window edge... so do this instead
+	// TODO will this make things like the menubar and dock easier too?
+	NSRect initialFrame;
+	NSPoint initialPoint;
+	uiWindowResizeEdge edge;
+	NSSize min;
+	NSSize max;
+};
+
+static void onResizeDrag(struct onResizeDragParams *p, NSEvent *e)
+{
+	NSPoint new;
+	NSRect frame;
+
+	new = makeIndependent([e locationInWindow], p->w);
+	frame = p->initialFrame;
+
+	// horizontal
+	switch (p->edge) {
+	case uiWindowResizeEdgeLeft:
+	case uiWindowResizeEdgeTopLeft:
+	case uiWindowResizeEdgeBottomLeft:
+		handleResizeLeft(&frame, p->initialPoint, new);
+		break;
+	case uiWindowResizeEdgeRight:
+	case uiWindowResizeEdgeTopRight:
+	case uiWindowResizeEdgeBottomRight:
+		handleResizeRight(&frame, p->initialPoint, new);
+		break;
+	}
+	// vertical
+	switch (p->edge) {
+	case uiWindowResizeEdgeTop:
+	case uiWindowResizeEdgeTopLeft:
+	case uiWindowResizeEdgeTopRight:
+		handleResizeTop(&frame, p->initialPoint, new);
+		break;
+	case uiWindowResizeEdgeBottom:
+	case uiWindowResizeEdgeBottomLeft:
+	case uiWindowResizeEdgeBottomRight:
+		handleResizeBottom(&frame, p->initialPoint, new);
+		break;
+	}
+
+	// constrain
+	// TODO should we constrain against anything else as well? minMaxAutoLayoutSizes() already gives us nonnegative sizes, but...
+	if (frame.size.width < p->min.width)
+		frame.size.width = p->min.width;
+	if (frame.size.height < p->min.height)
+		frame.size.height = p->min.height;
+	// TODO > or >= ?
+	if (frame.size.width > p->max.width)
+		frame.size.width = p->max.width;
+	if (frame.size.height > p->max.height)
+		frame.size.height = p->max.height;
+
+	[p->w setFrame:frame display:YES];			// and do reflect the new frame immediately
+}
+
+// TODO do our events get fired with this? *should* they?
+void doManualResize(NSWindow *w, NSEvent *initialEvent, uiWindowResizeEdge edge)
+{
+	__block struct onResizeDragParams rdp;
+	struct nextEventArgs nea;
+	BOOL (^handleEvent)(NSEvent *e);
+	__block BOOL done;
+
+	rdp.w = w;
+	rdp.initialFrame = [rdp.w frame];
+	rdp.initialPoint = makeIndependent([initialEvent locationInWindow], rdp.w);
+	rdp.edge = edge;
+	// TODO what happens if these change during the loop?
+	minMaxAutoLayoutSizes(rdp.w, &(rdp.min), &(rdp.max));
+
+	nea.mask = NSLeftMouseDraggedMask | NSLeftMouseUpMask;
+	nea.duration = [NSDate distantFuture];
+	nea.mode = NSEventTrackingRunLoopMode;		// nextEventMatchingMask: docs suggest using this for manual mouse tracking
+	nea.dequeue = YES;
+	handleEvent = ^(NSEvent *e) {
+		if ([e type] == NSLeftMouseUp) {
+			done = YES;
+			return YES;	// do not send
+		}
+		onResizeDrag(&rdp, e);
+		return YES;		// do not send
+	};
+	done = NO;
+	while (mainStep(&nea, handleEvent))
+		if (done)
+			break;
+}
diff --git a/src/libui_sdl/libui/doc/area.md b/src/libui_sdl/libui/doc/area.md
new file mode 100644
index 0000000..d14be9c
--- /dev/null
+++ b/src/libui_sdl/libui/doc/area.md
@@ -0,0 +1,53 @@
+# uiArea
+
+uiArea is a uiControl that provides a canvas you can draw on. It receives keyboard and mouse events, supports scrolling, is DPI aware, and has several other useful features. A uiArea consists of the drawing area itself and horizontal and vertical scrollbars.
+
+## The Area Handler
+
+A uiArea is driven by an *area handler*. An area handler is an object with several methods that uiArea calls to do certain tasks. To create an area handler, simply have a structure whose first member is of type `uiAreaHandler`:
+
+```c
+struct uiAreaHandler {
+	void (*Draw)(uiAreaHandler *h, uiArea *a, uiAreaDrawParams *p);
+	void (*HScrollConfig)(uiAreaHandler *h, uiArea *a, uiAreaScrollConfig *c);
+	void (*VScrollConfig)(uiAreaHandler *h, uiArea *a, uiAreaScrollConfig *c);
+}
+```
+
+## Drawing
+
+Unlike drawing canvas controls in other toolkits, uiArea does **not** have a fixed size. The coordinate (0, 0) is always the top-left corner of the drawing area, regardless of how big the uiArea is in the current window or where the scrollbars presently are. Instead, you simulate a size by setting the scrollbar bounds, and you are given the current scrolling positions to base your drawing with.
+
+The visible drawing area is called the *content area* by the drawing machinery.
+
+TODO have a diagram.
+
+When a part of the uiArea needs to be redrawn, the area handler's `Draw()` method is called. It receives the area handler, the uiArea, and a structure of parameters necessary for drawing.
+
+```c
+struct uiAreaDrawParams {
+	uiDrawContext *context;
+
+	intmax_t contentWidth;
+	intmax_t contentHeight;
+
+	intmax_t hscrollpos;
+	intmax_t vscrollpos;
+
+	intmax_t clipX;
+	intmax_t cilpY;
+	intmax_t clipWidth;
+	intmax_t clipHeight;
+
+	TODO dpiX;
+	TODO dpiY;
+};
+```
+
+`context` is the drawing context; see drawing.md for details.
+
+`contentWidth` and `contentHeight` is the current width and height of the content area. `hscrollpos` and `vscrollpos` are the current horizontal and vertical positions of the scrollbars, in units defined by the scrollbar configurations; see below.
+
+`clipX`, `clipY`, `clipWidth`, and `clipHeight` define a rectangle, in content area coordinates, that the OS has requested to be redrawn. You can use this to optimize your drawing by only drawing where drawing is needed; the OS may choose to drop any drawing done outside the clip rectangle.
+
+`dpiX` and `dpiY` are the uiArea's current DPI in the X and Y directions, respectively. Do not save these values; they are not guaranteed to stay the same once `Draw()` returns.
diff --git a/src/libui_sdl/libui/doc/areahandler b/src/libui_sdl/libui/doc/areahandler
new file mode 100644
index 0000000..4c559db
--- /dev/null
+++ b/src/libui_sdl/libui/doc/areahandler
@@ -0,0 +1 @@
+Yes, you keep ownership of the uiAreaHandler. libui only cares about the address you give uiNewArea(); it doesn't copy anything. You can even use the same uiAreaHandler on multiple uiAreas, which is why you get the uiArea as a parameter in each function.
diff --git a/src/libui_sdl/libui/doc/draw.md b/src/libui_sdl/libui/doc/draw.md
new file mode 100644
index 0000000..ef849fd
--- /dev/null
+++ b/src/libui_sdl/libui/doc/draw.md
@@ -0,0 +1,42 @@
+# The Drawing Model
+
+> Note: This model is not exclusive to libui; it is also applicable to many 2D graphics libraries, such as Direct2D, cairo, and Core Graphics.
+
+## The Coordinate System and Points
+
+In the traditional way we think of drawing, we think of rendering onto a plane of pixels. The pixels have a fixed size, and coordinates refer to the entire space that a pixel occupies.
+
+For instance, in the traditional model, the coordinate system looks like
+
+TODO image
+
+and when we say "draw a line from (0, 0) to (5, 5) exclusive", we mean "fill the spaces that are occupied by the pixels at (0, 0), (1, 1), (2, 2), (3, 3), and (4, 4)":
+
+TODO image
+
+Ugh. With pixels as big as the ones TODO.
+
+But now let's pretend we're working in a coordinate system where the point at (x, y) corresponds strictly to the top-left corner of the area that a pixel occupies.
+
+TODO image
+
+In this model, when we say "draw a line from (0, 0) to (5, 5)", we mean "draw a straight line filling every pixel that we cross if we traced a line from the top-left corner of what we used to call the pixel at (0, 0 to the top-left corner of what we used to call the pixel at (5, 5)":
+
+TODO image
+
+TODO.
+
+There are both technical and non-technical reasons for following this model. The technical reason is that implementing certain drawing operations, such as filling shapes, is much easier if we do things this way. The [cairo FAQ](http://www.cairographics.org/FAQ/#sharp_lines) explains in more detail. The non-technical reason has to do with DPI independence.
+
+## DPI Independence vs. DPI Awareness
+
+An upcoming trend in computing is the high-resolution display. These displays fit more dots in the same area that older screens could. The conventional term for the number of dots that fit in a given area is the "dots per inch", or DPI, measure.
+
+A naive approach to writing programs for these new displays is to think "well, if I just take the DPI and only use it in calculations where I need to deal with real-world measurements such as inches, rendering pure pixels as I always have, I should be fine". This kind of design is centered around *DPI awareness*. I know, I used to believe this too. But here's a little secret: this is wrong! A common myth about high-resolution monitors among non-technical people is that it makes the stuff on screen smaller. The mindset I just described causes this: TODO
+
+Instead, what we want out of a high-resolution display is *to show a more detailed view of the same image in the same space*. [The first image on Apple''s discussion of the topic](https://developer.apple.com/library/mac/documentation/GraphicsAnimation/Conceptual/HighResolutionOSX/Art/backing_store_2x.png) is the perfect example. On the left, you see a low-resolution monitor. Notice how big chunks of the shapes go into the boxes. When the code that maps points to pixels runs, it can't have two colors in one square, so it has to decide what color to use. TODO
+
+TODO
+- talk about how this relates to the OpenGL unit cube
+- talk about the various names (point, user space coordinate, device-independent pixel)
+- talk about "scaling"
diff --git a/src/libui_sdl/libui/doc/drawtext b/src/libui_sdl/libui/doc/drawtext
new file mode 100644
index 0000000..9d37713
--- /dev/null
+++ b/src/libui_sdl/libui/doc/drawtext
@@ -0,0 +1,13 @@
+on some unix systems, alpha blending fonts may not be available; this depends on your installed version of pango and is determined at runtime by libui
+
+uiDrawTextLayoutExtents: document that the extent width can be greater than the requested width if the requested width is small enough that only one character can fit
+
+
+font matching is closest match but the search method is OS defined
+
+
+weight names in libui do not necessarily line up with their OS names
+
+
+uiDrawFontHandle() may not return a unique handle per instance
+
diff --git a/src/libui_sdl/libui/doc/export/coretext b/src/libui_sdl/libui/doc/export/coretext
new file mode 100644
index 0000000..0888383
--- /dev/null
+++ b/src/libui_sdl/libui/doc/export/coretext
@@ -0,0 +1,5 @@
+font features are not provided by the collection and have to be added when asking for a font
+it does preserve when going from CTFont to CTFontDescriptor
+feature 17 has no flags in the header but can also hold small caps info
+if a feature is present, it is ignored; other features will still show up
+	at least in the case of kLetterCaseTrait and kLowerCaseTrait
diff --git a/src/libui_sdl/libui/doc/form b/src/libui_sdl/libui/doc/form
new file mode 100644
index 0000000..f24a94d
--- /dev/null
+++ b/src/libui_sdl/libui/doc/form
@@ -0,0 +1 @@
+hiding a control also hides its label
diff --git a/src/libui_sdl/libui/doc/main b/src/libui_sdl/libui/doc/main
new file mode 100644
index 0000000..9fa9c36
--- /dev/null
+++ b/src/libui_sdl/libui/doc/main
@@ -0,0 +1 @@
+after uiQuit or if uiShouldQuit returns nonzero, uiQueueMain's effect is undefined
diff --git a/src/libui_sdl/libui/doc/mainsteps b/src/libui_sdl/libui/doc/mainsteps
new file mode 100644
index 0000000..f572b21
--- /dev/null
+++ b/src/libui_sdl/libui/doc/mainsteps
@@ -0,0 +1 @@
+the function passed to mainsteps must not return until uiQuit itself has been called; otherwise the results are undefined
diff --git a/src/libui_sdl/libui/doc/slider b/src/libui_sdl/libui/doc/slider
new file mode 100644
index 0000000..5a6ac04
--- /dev/null
+++ b/src/libui_sdl/libui/doc/slider
@@ -0,0 +1 @@
+if min >= max then they are swapped
diff --git a/src/libui_sdl/libui/doc/spinbox b/src/libui_sdl/libui/doc/spinbox
new file mode 100644
index 0000000..5a6ac04
--- /dev/null
+++ b/src/libui_sdl/libui/doc/spinbox
@@ -0,0 +1 @@
+if min >= max then they are swapped
diff --git a/src/libui_sdl/libui/doc/static b/src/libui_sdl/libui/doc/static
new file mode 100644
index 0000000..fe1a09c
--- /dev/null
+++ b/src/libui_sdl/libui/doc/static
@@ -0,0 +1,2 @@
+comctl6
+libui.res
diff --git a/src/libui_sdl/libui/doc/windowmovesize b/src/libui_sdl/libui/doc/windowmovesize
new file mode 100644
index 0000000..ec8bd96
--- /dev/null
+++ b/src/libui_sdl/libui/doc/windowmovesize
@@ -0,0 +1,3 @@
+you should never need to use these functions
+they are provided only for the cases when ABSOLUTELY NECESSARY
+the operating system may ignore your requests, for instance, if you are giving it invalid numbers or a size too small to fit; this is all system-defined
diff --git a/src/libui_sdl/libui/doc/winstatic b/src/libui_sdl/libui/doc/winstatic
new file mode 100644
index 0000000..5f163cf
--- /dev/null
+++ b/src/libui_sdl/libui/doc/winstatic
@@ -0,0 +1 @@
+libui uses resources starting at 29000
diff --git a/src/libui_sdl/libui/examples/CMakeLists.txt b/src/libui_sdl/libui/examples/CMakeLists.txt
new file mode 100644
index 0000000..3a9ec4c
--- /dev/null
+++ b/src/libui_sdl/libui/examples/CMakeLists.txt
@@ -0,0 +1,38 @@
+# 3 june 2016
+
+if(WIN32)
+	set(_EXAMPLE_RESOURCES_RC resources.rc)
+endif()
+
+macro(_add_example _name)
+	_add_exec(${_name} ${ARGN})
+	# because Microsoft's toolchain is dumb
+	if(MSVC)
+		set_property(TARGET ${_name} APPEND_STRING PROPERTY
+			LINK_FLAGS " /ENTRY:mainCRTStartup")
+	endif()
+endmacro()
+
+_add_example(controlgallery
+	controlgallery/main.c
+	${_EXAMPLE_RESOURCES_RC}
+)
+
+_add_example(histogram
+	histogram/main.c
+	${_EXAMPLE_RESOURCES_RC}
+)
+
+_add_example(cpp-multithread
+	cpp-multithread/main.cpp
+	${_EXAMPLE_RESOURCES_RC}
+)
+if(NOT WIN32)
+	target_link_libraries(cpp-multithread pthread)
+endif()
+
+add_custom_target(examples
+	DEPENDS
+		controlgallery
+		histogram
+		cpp-multithread)
diff --git a/src/libui_sdl/libui/examples/controlgallery/darwin.png b/src/libui_sdl/libui/examples/controlgallery/darwin.png
new file mode 100644
index 0000000..f61b54b
--- /dev/null
+++ b/src/libui_sdl/libui/examples/controlgallery/darwin.png
diff --git a/src/libui_sdl/libui/examples/controlgallery/main.c b/src/libui_sdl/libui/examples/controlgallery/main.c
new file mode 100644
index 0000000..c0d536c
--- /dev/null
+++ b/src/libui_sdl/libui/examples/controlgallery/main.c
@@ -0,0 +1,540 @@
+// 2 september 2015
+#include <stdio.h>
+#include <string.h>
+#include "../../ui.h"
+
+static int onClosing(uiWindow *w, void *data)
+{
+	uiQuit();
+	return 1;
+}
+
+static int onShouldQuit(void *data)
+{
+	uiWindow *mainwin = uiWindow(data);
+
+	uiControlDestroy(uiControl(mainwin));
+	return 1;
+}
+
+static uiControl *makeBasicControlsPage(void)
+{
+	uiBox *vbox;
+	uiBox *hbox;
+	uiGroup *group;
+	uiForm *entryForm;
+
+	vbox = uiNewVerticalBox();
+	uiBoxSetPadded(vbox, 1);
+
+	hbox = uiNewHorizontalBox();
+	uiBoxSetPadded(hbox, 1);
+	uiBoxAppend(vbox, uiControl(hbox), 0);
+
+	uiBoxAppend(hbox,
+		uiControl(uiNewButton("Button")),
+		0);
+	uiBoxAppend(hbox,
+		uiControl(uiNewCheckbox("Checkbox")),
+		0);
+
+	uiBoxAppend(vbox,
+		uiControl(uiNewLabel("This is a label. Right now, labels can only span one line.")),
+		0);
+
+	uiBoxAppend(vbox,
+		uiControl(uiNewHorizontalSeparator()),
+		0);
+
+	group = uiNewGroup("Entries");
+	uiGroupSetMargined(group, 1);
+	uiBoxAppend(vbox, uiControl(group), 1);
+
+	entryForm = uiNewForm();
+	uiFormSetPadded(entryForm, 1);
+	uiGroupSetChild(group, uiControl(entryForm));
+
+	uiFormAppend(entryForm,
+		"Entry",
+		uiControl(uiNewEntry()),
+		0);
+	uiFormAppend(entryForm,
+		"Password Entry",
+		uiControl(uiNewPasswordEntry()),
+		0);
+	uiFormAppend(entryForm,
+		"Search Entry",
+		uiControl(uiNewSearchEntry()),
+		0);
+	uiFormAppend(entryForm,
+		"Multiline Entry",
+		uiControl(uiNewMultilineEntry()),
+		1);
+	uiFormAppend(entryForm,
+		"Multiline Entry No Wrap",
+		uiControl(uiNewNonWrappingMultilineEntry()),
+		1);
+
+	return uiControl(vbox);
+}
+
+// TODO make these not global
+static uiSpinbox *spinbox;
+static uiSlider *slider;
+static uiProgressBar *pbar;
+
+static void onSpinboxChanged(uiSpinbox *s, void *data)
+{
+	uiSliderSetValue(slider, uiSpinboxValue(s));
+	uiProgressBarSetValue(pbar, uiSpinboxValue(s));
+}
+
+static void onSliderChanged(uiSlider *s, void *data)
+{
+	uiSpinboxSetValue(spinbox, uiSliderValue(s));
+	uiProgressBarSetValue(pbar, uiSliderValue(s));
+}
+
+static uiControl *makeNumbersPage()
+{
+	uiBox *hbox;
+	uiGroup *group;
+	uiBox *vbox;
+	uiProgressBar *ip;
+	uiCombobox *cbox;
+	uiEditableCombobox *ecbox;
+	uiRadioButtons *rb;
+
+	hbox = uiNewHorizontalBox();
+	uiBoxSetPadded(hbox, 1);
+
+	group = uiNewGroup("Numbers");
+	uiGroupSetMargined(group, 1);
+	uiBoxAppend(hbox, uiControl(group), 1);
+
+	vbox = uiNewVerticalBox();
+	uiBoxSetPadded(vbox, 1);
+	uiGroupSetChild(group, uiControl(vbox));
+
+	spinbox = uiNewSpinbox(0, 100);
+	slider = uiNewSlider(0, 100);
+	pbar = uiNewProgressBar();
+	uiSpinboxOnChanged(spinbox, onSpinboxChanged, NULL);
+	uiSliderOnChanged(slider, onSliderChanged, NULL);
+	uiBoxAppend(vbox, uiControl(spinbox), 0);
+	uiBoxAppend(vbox, uiControl(slider), 0);
+	uiBoxAppend(vbox, uiControl(pbar), 0);
+
+	ip = uiNewProgressBar();
+	uiProgressBarSetValue(ip, -1);
+	uiBoxAppend(vbox, uiControl(ip), 0);
+
+	group = uiNewGroup("Lists");
+	uiGroupSetMargined(group, 1);
+	uiBoxAppend(hbox, uiControl(group), 1);
+
+	vbox = uiNewVerticalBox();
+	uiBoxSetPadded(vbox, 1);
+	uiGroupSetChild(group, uiControl(vbox));
+
+	cbox = uiNewCombobox();
+	uiComboboxAppend(cbox, "Combobox Item 1");
+	uiComboboxAppend(cbox, "Combobox Item 2");
+	uiComboboxAppend(cbox, "Combobox Item 3");
+	uiBoxAppend(vbox, uiControl(cbox), 0);
+
+	ecbox = uiNewEditableCombobox();
+	uiEditableComboboxAppend(ecbox, "Editable Item 1");
+	uiEditableComboboxAppend(ecbox, "Editable Item 2");
+	uiEditableComboboxAppend(ecbox, "Editable Item 3");
+	uiBoxAppend(vbox, uiControl(ecbox), 0);
+
+	rb = uiNewRadioButtons();
+	uiRadioButtonsAppend(rb, "Radio Button 1");
+	uiRadioButtonsAppend(rb, "Radio Button 2");
+	uiRadioButtonsAppend(rb, "Radio Button 3");
+	uiBoxAppend(vbox, uiControl(rb), 0);
+
+	return uiControl(hbox);
+}
+
+// TODO make this not global
+static uiWindow *mainwin;
+
+static void onOpenFileClicked(uiButton *b, void *data)
+{
+	uiEntry *entry = uiEntry(data);
+	char *filename;
+
+	filename = uiOpenFile(mainwin);
+	if (filename == NULL) {
+		uiEntrySetText(entry, "(cancelled)");
+		return;
+	}
+	uiEntrySetText(entry, filename);
+	uiFreeText(filename);
+}
+
+static void onSaveFileClicked(uiButton *b, void *data)
+{
+	uiEntry *entry = uiEntry(data);
+	char *filename;
+
+	filename = uiSaveFile(mainwin);
+	if (filename == NULL) {
+		uiEntrySetText(entry, "(cancelled)");
+		return;
+	}
+	uiEntrySetText(entry, filename);
+	uiFreeText(filename);
+}
+
+static void onMsgBoxClicked(uiButton *b, void *data)
+{
+	uiMsgBox(mainwin,
+		"This is a normal message box.",
+		"More detailed information can be shown here.");
+}
+
+static void onMsgBoxErrorClicked(uiButton *b, void *data)
+{
+	uiMsgBoxError(mainwin,
+		"This message box describes an error.",
+		"More detailed information can be shown here.");
+}
+
+static uiControl *makeDataChoosersPage(void)
+{
+	uiBox *hbox;
+	uiBox *vbox;
+	uiGrid *grid;
+	uiButton *button;
+	uiEntry *entry;
+	uiGrid *msggrid;
+
+	hbox = uiNewHorizontalBox();
+	uiBoxSetPadded(hbox, 1);
+
+	vbox = uiNewVerticalBox();
+	uiBoxSetPadded(vbox, 1);
+	uiBoxAppend(hbox, uiControl(vbox), 0);
+
+	uiBoxAppend(vbox,
+		uiControl(uiNewDatePicker()),
+		0);
+	uiBoxAppend(vbox,
+		uiControl(uiNewTimePicker()),
+		0);
+	uiBoxAppend(vbox,
+		uiControl(uiNewDateTimePicker()),
+		0);
+
+	uiBoxAppend(vbox,
+		uiControl(uiNewFontButton()),
+		0);
+	uiBoxAppend(vbox,
+		uiControl(uiNewColorButton()),
+		0);
+
+	uiBoxAppend(hbox,
+		uiControl(uiNewVerticalSeparator()),
+		0);
+
+	vbox = uiNewVerticalBox();
+	uiBoxSetPadded(vbox, 1);
+	uiBoxAppend(hbox, uiControl(vbox), 1);
+
+	grid = uiNewGrid();
+	uiGridSetPadded(grid, 1);
+	uiBoxAppend(vbox, uiControl(grid), 0);
+
+	button = uiNewButton("Open File");
+	entry = uiNewEntry();
+	uiEntrySetReadOnly(entry, 1);
+	uiButtonOnClicked(button, onOpenFileClicked, entry);
+	uiGridAppend(grid, uiControl(button),
+		0, 0, 1, 1,
+		0, uiAlignFill, 0, uiAlignFill);
+	uiGridAppend(grid, uiControl(entry),
+		1, 0, 1, 1,
+		1, uiAlignFill, 0, uiAlignFill);
+
+	button = uiNewButton("Save File");
+	entry = uiNewEntry();
+	uiEntrySetReadOnly(entry, 1);
+	uiButtonOnClicked(button, onSaveFileClicked, entry);
+	uiGridAppend(grid, uiControl(button),
+		0, 1, 1, 1,
+		0, uiAlignFill, 0, uiAlignFill);
+	uiGridAppend(grid, uiControl(entry),
+		1, 1, 1, 1,
+		1, uiAlignFill, 0, uiAlignFill);
+
+	msggrid = uiNewGrid();
+	uiGridSetPadded(msggrid, 1);
+	uiGridAppend(grid, uiControl(msggrid),
+		0, 2, 2, 1,
+		0, uiAlignCenter, 0, uiAlignStart);
+
+	button = uiNewButton("Message Box");
+	uiButtonOnClicked(button, onMsgBoxClicked, NULL);
+	uiGridAppend(msggrid, uiControl(button),
+		0, 0, 1, 1,
+		0, uiAlignFill, 0, uiAlignFill);
+	button = uiNewButton("Error Box");
+	uiButtonOnClicked(button, onMsgBoxErrorClicked, NULL);
+	uiGridAppend(msggrid, uiControl(button),
+		1, 0, 1, 1,
+		0, uiAlignFill, 0, uiAlignFill);
+
+	return uiControl(hbox);
+}
+
+int main(void)
+{
+	uiInitOptions options;
+	const char *err;
+	uiTab *tab;
+
+	memset(&options, 0, sizeof (uiInitOptions));
+	err = uiInit(&options);
+	if (err != NULL) {
+		fprintf(stderr, "error initializing libui: %s", err);
+		uiFreeInitError(err);
+		return 1;
+	}
+
+	mainwin = uiNewWindow("libui Control Gallery", 640, 480, 1);
+	uiWindowOnClosing(mainwin, onClosing, NULL);
+	uiOnShouldQuit(onShouldQuit, mainwin);
+
+	tab = uiNewTab();
+	uiWindowSetChild(mainwin, uiControl(tab));
+	uiWindowSetMargined(mainwin, 1);
+
+	uiTabAppend(tab, "Basic Controls", makeBasicControlsPage());
+	uiTabSetMargined(tab, 0, 1);
+
+	uiTabAppend(tab, "Numbers and Lists", makeNumbersPage());
+	uiTabSetMargined(tab, 1, 1);
+
+	uiTabAppend(tab, "Data Choosers", makeDataChoosersPage());
+	uiTabSetMargined(tab, 2, 1);
+
+	uiControlShow(uiControl(mainwin));
+	uiMain();
+	return 0;
+}
+
+#if 0
+
+static void openClicked(uiMenuItem *item, uiWindow *w, void *data)
+{
+	char *filename;
+
+	filename = uiOpenFile(mainwin);
+	if (filename == NULL) {
+		uiMsgBoxError(mainwin, "No file selected", "Don't be alarmed!");
+		return;
+	}
+	uiMsgBox(mainwin, "File selected", filename);
+	uiFreeText(filename);
+}
+
+static void saveClicked(uiMenuItem *item, uiWindow *w, void *data)
+{
+	char *filename;
+
+	filename = uiSaveFile(mainwin);
+	if (filename == NULL) {
+		uiMsgBoxError(mainwin, "No file selected", "Don't be alarmed!");
+		return;
+	}
+	uiMsgBox(mainwin, "File selected (don't worry, it's still there)", filename);
+	uiFreeText(filename);
+}
+
+static uiSpinbox *spinbox;
+static uiSlider *slider;
+static uiProgressBar *progressbar;
+
+static void update(int value)
+{
+	uiSpinboxSetValue(spinbox, value);
+	uiSliderSetValue(slider, value);
+	uiProgressBarSetValue(progressbar, value);
+}
+
+static void onSpinboxChanged(uiSpinbox *s, void *data)
+{
+	update(uiSpinboxValue(spinbox));
+}
+
+static void onSliderChanged(uiSlider *s, void *data)
+{
+	update(uiSliderValue(slider));
+}
+
+int main(void)
+{
+	uiInitOptions o;
+	const char *err;
+	uiMenu *menu;
+	uiMenuItem *item;
+	uiBox *box;
+	uiBox *hbox;
+	uiGroup *group;
+	uiBox *inner;
+	uiBox *inner2;
+	uiEntry *entry;
+	uiCombobox *cbox;
+	uiEditableCombobox *ecbox;
+	uiRadioButtons *rb;
+	uiTab *tab;
+
+	memset(&o, 0, sizeof (uiInitOptions));
+	err = uiInit(&o);
+	if (err != NULL) {
+		fprintf(stderr, "error initializing ui: %s\n", err);
+		uiFreeInitError(err);
+		return 1;
+	}
+
+	menu = uiNewMenu("File");
+	item = uiMenuAppendItem(menu, "Open");
+	uiMenuItemOnClicked(item, openClicked, NULL);
+	item = uiMenuAppendItem(menu, "Save");
+	uiMenuItemOnClicked(item, saveClicked, NULL);
+	item = uiMenuAppendQuitItem(menu);
+	uiOnShouldQuit(shouldQuit, NULL);
+
+	menu = uiNewMenu("Edit");
+	item = uiMenuAppendCheckItem(menu, "Checkable Item");
+	uiMenuAppendSeparator(menu);
+	item = uiMenuAppendItem(menu, "Disabled Item");
+	uiMenuItemDisable(item);
+	item = uiMenuAppendPreferencesItem(menu);
+
+	menu = uiNewMenu("Help");
+	item = uiMenuAppendItem(menu, "Help");
+	item = uiMenuAppendAboutItem(menu);
+
+	mainwin = uiNewWindow("libui Control Gallery", 640, 480, 1);
+	uiWindowSetMargined(mainwin, 1);
+	uiWindowOnClosing(mainwin, onClosing, NULL);
+
+	box = uiNewVerticalBox();
+	uiBoxSetPadded(box, 1);
+	uiWindowSetChild(mainwin, uiControl(box));
+
+	hbox = uiNewHorizontalBox();
+	uiBoxSetPadded(hbox, 1);
+	uiBoxAppend(box, uiControl(hbox), 1);
+
+	group = uiNewGroup("Basic Controls");
+	uiGroupSetMargined(group, 1);
+	uiBoxAppend(hbox, uiControl(group), 0);
+
+	inner = uiNewVerticalBox();
+	uiBoxSetPadded(inner, 1);
+	uiGroupSetChild(group, uiControl(inner));
+
+	uiBoxAppend(inner,
+		uiControl(uiNewButton("Button")),
+		0);
+	uiBoxAppend(inner,
+		uiControl(uiNewCheckbox("Checkbox")),
+		0);
+	entry = uiNewEntry();
+	uiEntrySetText(entry, "Entry");
+	uiBoxAppend(inner,
+		uiControl(entry),
+		0);
+	uiBoxAppend(inner,
+		uiControl(uiNewLabel("Label")),
+		0);
+
+	uiBoxAppend(inner,
+		uiControl(uiNewHorizontalSeparator()),
+		0);
+
+	uiBoxAppend(inner,
+		uiControl(uiNewDatePicker()),
+		0);
+	uiBoxAppend(inner,
+		uiControl(uiNewTimePicker()),
+		0);
+	uiBoxAppend(inner,
+		uiControl(uiNewDateTimePicker()),
+		0);
+
+	uiBoxAppend(inner,
+		uiControl(uiNewFontButton()),
+		0);
+
+	uiBoxAppend(inner,
+		uiControl(uiNewColorButton()),
+		0);
+
+	inner2 = uiNewVerticalBox();
+	uiBoxSetPadded(inner2, 1);
+	uiBoxAppend(hbox, uiControl(inner2), 1);
+
+	group = uiNewGroup("Numbers");
+	uiGroupSetMargined(group, 1);
+	uiBoxAppend(inner2, uiControl(group), 0);
+
+	inner = uiNewVerticalBox();
+	uiBoxSetPadded(inner, 1);
+	uiGroupSetChild(group, uiControl(inner));
+
+	spinbox = uiNewSpinbox(0, 100);
+	uiSpinboxOnChanged(spinbox, onSpinboxChanged, NULL);
+	uiBoxAppend(inner, uiControl(spinbox), 0);
+
+	slider = uiNewSlider(0, 100);
+	uiSliderOnChanged(slider, onSliderChanged, NULL);
+	uiBoxAppend(inner, uiControl(slider), 0);
+
+	progressbar = uiNewProgressBar();
+	uiBoxAppend(inner, uiControl(progressbar), 0);
+
+	group = uiNewGroup("Lists");
+	uiGroupSetMargined(group, 1);
+	uiBoxAppend(inner2, uiControl(group), 0);
+
+	inner = uiNewVerticalBox();
+	uiBoxSetPadded(inner, 1);
+	uiGroupSetChild(group, uiControl(inner));
+
+	cbox = uiNewCombobox();
+	uiComboboxAppend(cbox, "Combobox Item 1");
+	uiComboboxAppend(cbox, "Combobox Item 2");
+	uiComboboxAppend(cbox, "Combobox Item 3");
+	uiBoxAppend(inner, uiControl(cbox), 0);
+
+	ecbox = uiNewEditableCombobox();
+	uiEditableComboboxAppend(ecbox, "Editable Item 1");
+	uiEditableComboboxAppend(ecbox, "Editable Item 2");
+	uiEditableComboboxAppend(ecbox, "Editable Item 3");
+	uiBoxAppend(inner, uiControl(ecbox), 0);
+
+	rb = uiNewRadioButtons();
+	uiRadioButtonsAppend(rb, "Radio Button 1");
+	uiRadioButtonsAppend(rb, "Radio Button 2");
+	uiRadioButtonsAppend(rb, "Radio Button 3");
+	uiBoxAppend(inner, uiControl(rb), 1);
+
+	tab = uiNewTab();
+	uiTabAppend(tab, "Page 1", uiControl(uiNewHorizontalBox()));
+	uiTabAppend(tab, "Page 2", uiControl(uiNewHorizontalBox()));
+	uiTabAppend(tab, "Page 3", uiControl(uiNewHorizontalBox()));
+	uiBoxAppend(inner2, uiControl(tab), 1);
+
+	uiControlShow(uiControl(mainwin));
+	uiMain();
+	uiUninit();
+	return 0;
+}
+
+#endif
diff --git a/src/libui_sdl/libui/examples/controlgallery/unix.png b/src/libui_sdl/libui/examples/controlgallery/unix.png
new file mode 100644
index 0000000..0c58d09
--- /dev/null
+++ b/src/libui_sdl/libui/examples/controlgallery/unix.png
diff --git a/src/libui_sdl/libui/examples/controlgallery/windows.png b/src/libui_sdl/libui/examples/controlgallery/windows.png
new file mode 100644
index 0000000..4be832f
--- /dev/null
+++ b/src/libui_sdl/libui/examples/controlgallery/windows.png
diff --git a/src/libui_sdl/libui/examples/cpp-multithread/main.cpp b/src/libui_sdl/libui/examples/cpp-multithread/main.cpp
new file mode 100644
index 0000000..f97bc6f
--- /dev/null
+++ b/src/libui_sdl/libui/examples/cpp-multithread/main.cpp
@@ -0,0 +1,92 @@
+// 6 december 2015
+#include <thread>
+#include <chrono>
+#include <mutex>
+#include <condition_variable>
+#include <string.h>
+#include <stdlib.h>
+#include <time.h>
+#include "../../ui.h"
+using namespace std;
+
+uiMultilineEntry *e;
+condition_variable cv;
+mutex m;
+unique_lock<mutex> ourlock(m);
+thread *timeThread;
+
+void sayTime(void *data)
+{
+	char *s = (char *) data;
+
+	uiMultilineEntryAppend(e, s);
+	delete s;
+}
+
+void threadproc(void)
+{
+	ourlock.lock();
+	while (cv.wait_for(ourlock, chrono::seconds(1)) == cv_status::timeout) {
+		time_t t;
+		char *base;
+		char *s;
+
+		t = time(NULL);
+		base = ctime(&t);
+		s = new char[strlen(base) + 1];
+		strcpy(s, base);
+		uiQueueMain(sayTime, s);
+	}
+}
+
+int onClosing(uiWindow *w, void *data)
+{
+	cv.notify_all();
+	// C++ throws a hissy fit if you don't do this
+	// we might as well, to ensure no uiQueueMain() gets in after uiQuit()
+	timeThread->join();
+	uiQuit();
+	return 1;
+}
+
+void saySomething(uiButton *b, void *data)
+{
+	uiMultilineEntryAppend(e, "Saying something\n");
+}
+
+int main(void)
+{
+	uiInitOptions o;
+	uiWindow *w;
+	uiBox *b;
+	uiButton *btn;
+
+	memset(&o, 0, sizeof (uiInitOptions));
+	if (uiInit(&o) != NULL)
+		abort();
+
+	w = uiNewWindow("Hello", 320, 240, 0);
+	uiWindowSetMargined(w, 1);
+
+	b = uiNewVerticalBox();
+	uiBoxSetPadded(b, 1);
+	uiWindowSetChild(w, uiControl(b));
+
+	e = uiNewMultilineEntry();
+	uiMultilineEntrySetReadOnly(e, 1);
+
+	btn = uiNewButton("Say Something");
+	uiButtonOnClicked(btn, saySomething, NULL);
+	uiBoxAppend(b, uiControl(btn), 0);
+
+	uiBoxAppend(b, uiControl(e), 1);
+
+	// timeThread needs to lock ourlock itself - see http://stackoverflow.com/a/34121629/3408572
+	ourlock.unlock();
+	timeThread = new thread(threadproc);
+
+	uiWindowOnClosing(w, onClosing, NULL);
+	uiControlShow(uiControl(w));
+	uiMain();
+	return 0;
+}
diff --git a/src/libui_sdl/libui/examples/example.manifest b/src/libui_sdl/libui/examples/example.manifest
new file mode 100644
index 0000000..41e7c9c
--- /dev/null
+++ b/src/libui_sdl/libui/examples/example.manifest
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+<assemblyIdentity
+    version="1.0.0.0"
+    processorArchitecture="*"
+    name="CompanyName.ProductName.YourApplication"
+    type="win32"
+/>
+<description>Your application description here.</description>
+<!-- do NOT include the comctl6 dependency here; this lets us find bugs related to theming -->
+<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
+    <application>
+        <!--The ID below indicates application support for Windows Vista -->
+        <supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/>
+        <!--The ID below indicates application support for Windows 7 -->
+        <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
+    </application>
+</compatibility>
+</assembly>
+
diff --git a/src/libui_sdl/libui/examples/example.static.manifest b/src/libui_sdl/libui/examples/example.static.manifest
new file mode 100644
index 0000000..d8e83a8
--- /dev/null
+++ b/src/libui_sdl/libui/examples/example.static.manifest
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+<assemblyIdentity
+    version="1.0.0.0"
+    processorArchitecture="*"
+    name="CompanyName.ProductName.YourApplication"
+    type="win32"
+/>
+<description>Your application description here.</description>
+<!-- we DO need comctl6 in the static case -->
+<dependency>
+    <dependentAssembly>
+        <assemblyIdentity
+            type="win32"
+            name="Microsoft.Windows.Common-Controls"
+            version="6.0.0.0"
+            processorArchitecture="*"
+            publicKeyToken="6595b64144ccf1df"
+            language="*"
+        />
+    </dependentAssembly>
+</dependency>
+<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
+    <application>
+        <!--The ID below indicates application support for Windows Vista -->
+        <supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/>
+        <!--The ID below indicates application support for Windows 7 -->
+        <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
+    </application>
+</compatibility>
+</assembly>
+
diff --git a/src/libui_sdl/libui/examples/histogram/main.c b/src/libui_sdl/libui/examples/histogram/main.c
new file mode 100644
index 0000000..f2b0e79
--- /dev/null
+++ b/src/libui_sdl/libui/examples/histogram/main.c
@@ -0,0 +1,309 @@
+// 13 october 2015
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <time.h>
+#include "../../ui.h"
+
+uiWindow *mainwin;
+uiArea *histogram;
+uiAreaHandler handler;
+uiSpinbox *datapoints[10];
+uiColorButton *colorButton;
+int currentPoint = -1;
+
+// some metrics
+#define xoffLeft 20			/* histogram margins */
+#define yoffTop 20
+#define xoffRight 20
+#define yoffBottom 20
+#define pointRadius 5
+
+// helper to quickly set a brush color
+static void setSolidBrush(uiDrawBrush *brush, uint32_t color, double alpha)
+{
+	uint8_t component;
+
+	brush->Type = uiDrawBrushTypeSolid;
+	component = (uint8_t) ((color >> 16) & 0xFF);
+	brush->R = ((double) component) / 255;
+	component = (uint8_t) ((color >> 8) & 0xFF);
+	brush->G = ((double) component) / 255;
+	component = (uint8_t) (color & 0xFF);
+	brush->B = ((double) component) / 255;
+	brush->A = alpha;
+}
+
+// and some colors
+// names and values from https://msdn.microsoft.com/en-us/library/windows/desktop/dd370907%28v=vs.85%29.aspx
+#define colorWhite 0xFFFFFF
+#define colorBlack 0x000000
+#define colorDodgerBlue 0x1E90FF
+
+static void pointLocations(double width, double height, double *xs, double *ys)
+{
+	double xincr, yincr;
+	int i, n;
+
+	xincr = width / 9;		// 10 - 1 to make the last point be at the end
+	yincr = height / 100;
+
+	for (i = 0; i < 10; i++) {
+		// get the value of the point
+		n = uiSpinboxValue(datapoints[i]);
+		// because y=0 is the top but n=0 is the bottom, we need to flip
+		n = 100 - n;
+		xs[i] = xincr * i;
+		ys[i] = yincr * n;
+	}
+}
+
+static uiDrawPath *constructGraph(double width, double height, int extend)
+{
+	uiDrawPath *path;
+	double xs[10], ys[10];
+	int i;
+
+	pointLocations(width, height, xs, ys);
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+
+	uiDrawPathNewFigure(path, xs[0], ys[0]);
+	for (i = 1; i < 10; i++)
+		uiDrawPathLineTo(path, xs[i], ys[i]);
+
+	if (extend) {
+		uiDrawPathLineTo(path, width, height);
+		uiDrawPathLineTo(path, 0, height);
+		uiDrawPathCloseFigure(path);
+	}
+
+	uiDrawPathEnd(path);
+	return path;
+}
+
+static void graphSize(double clientWidth, double clientHeight, double *graphWidth, double *graphHeight)
+{
+	*graphWidth = clientWidth - xoffLeft - xoffRight;
+	*graphHeight = clientHeight - yoffTop - yoffBottom;
+}
+
+static void handlerDraw(uiAreaHandler *a, uiArea *area, uiAreaDrawParams *p)
+{
+	uiDrawPath *path;
+	uiDrawBrush brush;
+	uiDrawStrokeParams sp;
+	uiDrawMatrix m;
+	double graphWidth, graphHeight;
+	double graphR, graphG, graphB, graphA;
+
+	// fill the area with white
+	setSolidBrush(&brush, colorWhite, 1.0);
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathAddRectangle(path, 0, 0, p->AreaWidth, p->AreaHeight);
+	uiDrawPathEnd(path);
+	uiDrawFill(p->Context, path, &brush);
+	uiDrawFreePath(path);
+
+	// figure out dimensions
+	graphSize(p->AreaWidth, p->AreaHeight, &graphWidth, &graphHeight);
+
+	// clear sp to avoid passing garbage to uiDrawStroke()
+	// for example, we don't use dashing
+	memset(&sp, 0, sizeof (uiDrawStrokeParams));
+
+	// make a stroke for both the axes and the histogram line
+	sp.Cap = uiDrawLineCapFlat;
+	sp.Join = uiDrawLineJoinMiter;
+	sp.Thickness = 2;
+	sp.MiterLimit = uiDrawDefaultMiterLimit;
+
+	// draw the axes
+	setSolidBrush(&brush, colorBlack, 1.0);
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigure(path,
+		xoffLeft, yoffTop);
+	uiDrawPathLineTo(path,
+		xoffLeft, yoffTop + graphHeight);
+	uiDrawPathLineTo(path,
+		xoffLeft + graphWidth, yoffTop + graphHeight);
+	uiDrawPathEnd(path);
+	uiDrawStroke(p->Context, path, &brush, &sp);
+	uiDrawFreePath(path);
+
+	// now transform the coordinate space so (0, 0) is the top-left corner of the graph
+	uiDrawMatrixSetIdentity(&m);
+	uiDrawMatrixTranslate(&m, xoffLeft, yoffTop);
+	uiDrawTransform(p->Context, &m);
+
+	// now get the color for the graph itself and set up the brush
+	uiColorButtonColor(colorButton, &graphR, &graphG, &graphB, &graphA);
+	brush.Type = uiDrawBrushTypeSolid;
+	brush.R = graphR;
+	brush.G = graphG;
+	brush.B = graphB;
+	// we set brush->A below to different values for the fill and stroke
+
+	// now create the fill for the graph below the graph line
+	path = constructGraph(graphWidth, graphHeight, 1);
+	brush.A = graphA / 2;
+	uiDrawFill(p->Context, path, &brush);
+	uiDrawFreePath(path);
+
+	// now draw the histogram line
+	path = constructGraph(graphWidth, graphHeight, 0);
+	brush.A = graphA;
+	uiDrawStroke(p->Context, path, &brush, &sp);
+	uiDrawFreePath(path);
+
+	// now draw the point being hovered over
+	if (currentPoint != -1) {
+		double xs[10], ys[10];
+
+		pointLocations(graphWidth, graphHeight, xs, ys);
+		path = uiDrawNewPath(uiDrawFillModeWinding);
+		uiDrawPathNewFigureWithArc(path,
+			xs[currentPoint], ys[currentPoint],
+			pointRadius,
+			0, 6.23,		// TODO pi
+			0);
+		uiDrawPathEnd(path);
+		// use the same brush as for the histogram lines
+		uiDrawFill(p->Context, path, &brush);
+		uiDrawFreePath(path);
+	}
+}
+
+static int inPoint(double x, double y, double xtest, double ytest)
+{
+	// TODO switch to using a matrix
+	x -= xoffLeft;
+	y -= yoffTop;
+	return (x >= xtest - pointRadius) &&
+		(x <= xtest + pointRadius) &&
+		(y >= ytest - pointRadius) &&
+		(y <= ytest + pointRadius);
+}
+
+static void handlerMouseEvent(uiAreaHandler *a, uiArea *area, uiAreaMouseEvent *e)
+{
+	double graphWidth, graphHeight;
+	double xs[10], ys[10];
+	int i;
+
+	graphSize(e->AreaWidth, e->AreaHeight, &graphWidth, &graphHeight);
+	pointLocations(graphWidth, graphHeight, xs, ys);
+
+	for (i = 0; i < 10; i++)
+		if (inPoint(e->X, e->Y, xs[i], ys[i]))
+			break;
+	if (i == 10)		// not in a point
+		i = -1;
+
+	currentPoint = i;
+	// TODO only redraw the relevant area
+	uiAreaQueueRedrawAll(histogram);
+}
+
+static void handlerMouseCrossed(uiAreaHandler *ah, uiArea *a, int left)
+{
+	// do nothing
+}
+
+static void handlerDragBroken(uiAreaHandler *ah, uiArea *a)
+{
+	// do nothing
+}
+
+static int handlerKeyEvent(uiAreaHandler *ah, uiArea *a, uiAreaKeyEvent *e)
+{
+	// reject all keys
+	return 0;
+}
+
+static void onDatapointChanged(uiSpinbox *s, void *data)
+{
+	uiAreaQueueRedrawAll(histogram);
+}
+
+static void onColorChanged(uiColorButton *b, void *data)
+{
+	uiAreaQueueRedrawAll(histogram);
+}
+
+static int onClosing(uiWindow *w, void *data)
+{
+	uiControlDestroy(uiControl(mainwin));
+	uiQuit();
+	return 0;
+}
+
+static int shouldQuit(void *data)
+{
+	uiControlDestroy(uiControl(mainwin));
+	return 1;
+}
+
+int main(void)
+{
+	uiInitOptions o;
+	const char *err;
+	uiBox *hbox, *vbox;
+	int i;
+	uiDrawBrush brush;
+
+	handler.Draw = handlerDraw;
+	handler.MouseEvent = handlerMouseEvent;
+	handler.MouseCrossed = handlerMouseCrossed;
+	handler.DragBroken = handlerDragBroken;
+	handler.KeyEvent = handlerKeyEvent;
+
+	memset(&o, 0, sizeof (uiInitOptions));
+	err = uiInit(&o);
+	if (err != NULL) {
+		fprintf(stderr, "error initializing ui: %s\n", err);
+		uiFreeInitError(err);
+		return 1;
+	}
+
+	uiOnShouldQuit(shouldQuit, NULL);
+
+	mainwin = uiNewWindow("libui Histogram Example", 640, 480, 1);
+	uiWindowSetMargined(mainwin, 1);
+	uiWindowOnClosing(mainwin, onClosing, NULL);
+
+	hbox = uiNewHorizontalBox();
+	uiBoxSetPadded(hbox, 1);
+	uiWindowSetChild(mainwin, uiControl(hbox));
+
+	vbox = uiNewVerticalBox();
+	uiBoxSetPadded(vbox, 1);
+	uiBoxAppend(hbox, uiControl(vbox), 0);
+
+	srand(time(NULL));
+	for (i = 0; i < 10; i++) {
+		datapoints[i] = uiNewSpinbox(0, 100);
+		uiSpinboxSetValue(datapoints[i], rand() % 101);
+		uiSpinboxOnChanged(datapoints[i], onDatapointChanged, NULL);
+		uiBoxAppend(vbox, uiControl(datapoints[i]), 0);
+	}
+
+	colorButton = uiNewColorButton();
+	// TODO inline these
+	setSolidBrush(&brush, colorDodgerBlue, 1.0);
+	uiColorButtonSetColor(colorButton,
+		brush.R,
+		brush.G,
+		brush.B,
+		brush.A);
+	uiColorButtonOnChanged(colorButton, onColorChanged, NULL);
+	uiBoxAppend(vbox, uiControl(colorButton), 0);
+
+	histogram = uiNewArea(&handler);
+	uiBoxAppend(hbox, uiControl(histogram), 1);
+
+	uiControlShow(uiControl(mainwin));
+	uiMain();
+	uiUninit();
+	return 0;
+}
diff --git a/src/libui_sdl/libui/examples/resources.rc b/src/libui_sdl/libui/examples/resources.rc
new file mode 100644
index 0000000..49f486c
--- /dev/null
+++ b/src/libui_sdl/libui/examples/resources.rc
@@ -0,0 +1,13 @@
+// 30 may 2015
+
+// this is a UTF-8 file
+#pragma code_page(65001)
+
+// this is the Common Controls 6 manifest
+// TODO set up the string values here
+// 1 is the value of CREATEPROCESS_MANIFEST_RESOURCE_ID and 24 is the value of RT_MANIFEST; we use it directly to avoid needing to share winapi.h with the tests and examples
+#ifndef _UI_STATIC
+1 24 "example.manifest"
+#else
+1 24 "example.static.manifest"
+#endif
diff --git a/src/libui_sdl/libui/nowintable.diff b/src/libui_sdl/libui/nowintable.diff
new file mode 100644
index 0000000..cfbab07
--- /dev/null
+++ b/src/libui_sdl/libui/nowintable.diff
@@ -0,0 +1,50 @@
+diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt
+index 7f70403..e909569 100644
+--- a/common/CMakeLists.txt
++++ b/common/CMakeLists.txt
+@@ -6,7 +6,7 @@ list(APPEND _LIBUI_SOURCES
+ 	common/debug.c
+ 	common/matrix.c
+ 	common/shouldquit.c
+-	common/table.c
++#	common/table.c
+ 	common/userbugs.c
+ )
+ set(_LIBUI_SOURCES ${_LIBUI_SOURCES} PARENT_SCOPE)
+diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
+index b753a7d..a648c64 100644
+--- a/test/CMakeLists.txt
++++ b/test/CMakeLists.txt
+@@ -6,7 +6,7 @@ endif()
+ 
+ _add_exec(tester
+ 	drawtests.c
+-	images.c
++#	images.c
+ 	main.c
+ 	menus.c
+ 	page1.c
+@@ -27,7 +27,7 @@ _add_exec(tester
+ 	page13.c
+ 	page14.c
+ 	page15.c
+-	page16.c
++#	page16.c
+ 	spaced.c
+ 	${_TEST_RESOURCES_RC}
+ )
+diff --git a/test/main.c b/test/main.c
+index f33f30a..18774dc 100644
+--- a/test/main.c
++++ b/test/main.c
+@@ -159,8 +159,8 @@ int main(int argc, char *argv[])
+ 	innerTab = newTab();
+ 	uiTabAppend(outerTab, "Pages 16-?", uiControl(innerTab));
+ 
+-	page16 = makePage16();
+-	uiTabAppend(innerTab, "Page 16", uiControl(page16));
++//	page16 = makePage16();
++//	uiTabAppend(innerTab, "Page 16", uiControl(page16));
+ 
+ 	if (startspaced)
+ 		setSpaced(1);
diff --git a/src/libui_sdl/libui/oldhaiku.tgz b/src/libui_sdl/libui/oldhaiku.tgz
new file mode 100644
index 0000000..a3b9dd7
--- /dev/null
+++ b/src/libui_sdl/libui/oldhaiku.tgz
diff --git a/src/libui_sdl/libui/test/CMakeLists.txt b/src/libui_sdl/libui/test/CMakeLists.txt
new file mode 100644
index 0000000..e4924bb
--- /dev/null
+++ b/src/libui_sdl/libui/test/CMakeLists.txt
@@ -0,0 +1,38 @@
+# 3 june 2016
+
+if(WIN32)
+	set(_TEST_RESOURCES_RC resources.rc)
+endif()
+
+_add_exec(tester
+	drawtests.c
+	main.c
+	menus.c
+	page1.c
+	page2.c
+	page3.c
+	page4.c
+	page5.c
+	page6.c
+	page7.c
+	page7a.c
+	page7b.c
+	page7c.c
+	page8.c
+	page9.c
+	page10.c
+	page11.c
+	page12.c
+	page13.c
+	page14.c
+	page15.c
+	spaced.c
+	${_TEST_RESOURCES_RC}
+)
+target_include_directories(tester
+	PRIVATE test
+)
+set_target_properties(tester PROPERTIES
+	OUTPUT_NAME test
+	WIN32_EXECUTABLE FALSE
+)
diff --git a/src/libui_sdl/libui/test/drawtests.c b/src/libui_sdl/libui/test/drawtests.c
new file mode 100644
index 0000000..b6de753
--- /dev/null
+++ b/src/libui_sdl/libui/test/drawtests.c
@@ -0,0 +1,1978 @@
+// 9 october 2015
+#include "test.h"
+
+// TODO
+// - test multiple clips
+// - test saving and restoring clips
+
+struct drawtest {
+	const char *name;
+	void (*draw)(uiAreaDrawParams *p);
+	// TODO mouse event
+};
+
+static void drawOriginal(uiAreaDrawParams *p)
+{
+	uiDrawPath *path;
+	uiDrawBrush brush;
+	uiDrawStrokeParams sp;
+
+	sp.Dashes = NULL;
+	sp.NumDashes = 0;
+	sp.DashPhase = 0;
+
+	brush.Type = uiDrawBrushTypeSolid;
+	brush.A = 1;
+
+	brush.R = 1;
+	brush.G = 0;
+	brush.B = 0;
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigure(path, p->ClipX + 5, p->ClipY + 5);
+	uiDrawPathLineTo(path, (p->ClipX + p->ClipWidth) - 5, (p->ClipY + p->ClipHeight) - 5);
+	uiDrawPathEnd(path);
+	sp.Cap = uiDrawLineCapFlat;
+	sp.Join = uiDrawLineJoinMiter;
+	sp.Thickness = 1;
+	sp.MiterLimit = uiDrawDefaultMiterLimit;
+	uiDrawStroke(p->Context, path, &brush, &sp);
+	uiDrawFreePath(path);
+
+	brush.R = 0;
+	brush.G = 0;
+	brush.B = 0.75;
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigure(path, p->ClipX, p->ClipY);
+	uiDrawPathLineTo(path, p->ClipX + p->ClipWidth, p->ClipY);
+	uiDrawPathLineTo(path, 50, 150);
+	uiDrawPathLineTo(path, 50, 50);
+	uiDrawPathCloseFigure(path);
+	uiDrawPathEnd(path);
+	sp.Cap = uiDrawLineCapFlat;
+	sp.Join = uiDrawLineJoinRound;
+	sp.Thickness = 5;
+	uiDrawStroke(p->Context, path, &brush, &sp);
+	uiDrawFreePath(path);
+
+	brush.R = 0;
+	brush.G = 0.75;
+	brush.B = 0;
+	brush.A = 0.5;
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathAddRectangle(path, 120, 80, 50, 50);
+	uiDrawPathEnd(path);
+	uiDrawFill(p->Context, path, &brush);
+	uiDrawFreePath(path);
+	brush.A = 1;
+
+	brush.R = 0;
+	brush.G = 0.5;
+	brush.B = 0;
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigure(path, 5.5, 10.5);
+	uiDrawPathLineTo(path, 5.5, 50.5);
+	uiDrawPathEnd(path);
+	sp.Cap = uiDrawLineCapFlat;
+	sp.Join = uiDrawLineJoinMiter;
+	sp.Thickness = 1;
+	sp.MiterLimit = uiDrawDefaultMiterLimit;
+	uiDrawStroke(p->Context, path, &brush, &sp);
+	uiDrawFreePath(path);
+
+	brush.R = 0.5;
+	brush.G = 0.75;
+	brush.B = 0;
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigure(path, 400, 100);
+	uiDrawPathArcTo(path,
+		400, 100,
+		50,
+		30. * (uiPi / 180.),
+		300. * (uiPi / 180.),
+		0);
+	// the sweep test below doubles as a clockwise test so a checkbox isn't needed anymore
+	uiDrawPathLineTo(path, 400, 100);
+	uiDrawPathNewFigureWithArc(path,
+		510, 100,
+		50,
+		30. * (uiPi / 180.),
+		300. * (uiPi / 180.),
+		0);
+	uiDrawPathCloseFigure(path);
+	// and now with 330 to make sure sweeps work properly
+	uiDrawPathNewFigure(path, 400, 210);
+	uiDrawPathArcTo(path,
+		400, 210,
+		50,
+		30. * (uiPi / 180.),
+		330. * (uiPi / 180.),
+		0);
+	uiDrawPathLineTo(path, 400, 210);
+	uiDrawPathNewFigureWithArc(path,
+		510, 210,
+		50,
+		30. * (uiPi / 180.),
+		330. * (uiPi / 180.),
+		0);
+	uiDrawPathCloseFigure(path);
+	uiDrawPathEnd(path);
+	sp.Cap = uiDrawLineCapFlat;
+	sp.Join = uiDrawLineJoinMiter;
+	sp.Thickness = 1;
+	sp.MiterLimit = uiDrawDefaultMiterLimit;
+	uiDrawStroke(p->Context, path, &brush, &sp);
+	uiDrawFreePath(path);
+
+	brush.R = 0;
+	brush.G = 0.5;
+	brush.B = 0.75;
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigure(path, 300, 300);
+	uiDrawPathBezierTo(path,
+		350, 320,
+		310, 390,
+		435, 372);
+	uiDrawPathEnd(path);
+	sp.Cap = uiDrawLineCapFlat;
+	sp.Join = uiDrawLineJoinMiter;
+	sp.Thickness = 1;
+	sp.MiterLimit = uiDrawDefaultMiterLimit;
+	uiDrawStroke(p->Context, path, &brush, &sp);
+	uiDrawFreePath(path);
+}
+
+static void drawArcs(uiAreaDrawParams *p)
+{
+	uiDrawPath *path;
+	int start = 20;
+	int step = 20;
+	int rad = 25;
+	int x, y;
+	double angle;
+	double add;
+	int i;
+	uiDrawBrush brush;
+	uiDrawStrokeParams sp;
+
+	sp.Dashes = NULL;
+	sp.NumDashes = 0;
+	sp.DashPhase = 0;
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+
+	add = (2.0 * uiPi) / 12;
+
+	x = start + rad;
+	y = start + rad;
+	angle = 0;
+	for (i = 0; i < 13; i++) {
+		uiDrawPathNewFigureWithArc(path,
+			x, y,
+			rad,
+			0, angle,
+			0);
+		angle += add;
+		x += 2 * rad + step;
+	}
+
+	y += 2 * rad + step;
+	x = start + rad;
+	angle = 0;
+	for (i = 0; i < 13; i++) {
+		uiDrawPathNewFigure(path, x, y);
+		uiDrawPathArcTo(path,
+			x, y,
+			rad,
+			0, angle,
+			0);
+		angle += add;
+		x += 2 * rad + step;
+	}
+
+	y += 2 * rad + step;
+	x = start + rad;
+	angle = 0;
+	for (i = 0; i < 13; i++) {
+		uiDrawPathNewFigureWithArc(path,
+			x, y,
+			rad,
+			(uiPi / 4), angle,
+			0);
+		angle += add;
+		x += 2 * rad + step;
+	}
+
+	y += 2 * rad + step;
+	x = start + rad;
+	angle = 0;
+	for (i = 0; i < 13; i++) {
+		uiDrawPathNewFigure(path, x, y);
+		uiDrawPathArcTo(path,
+			x, y,
+			rad,
+			(uiPi / 4), angle,
+			0);
+		angle += add;
+		x += 2 * rad + step;
+	}
+
+	y += 2 * rad + step;
+	x = start + rad;
+	angle = 0;
+	for (i = 0; i < 13; i++) {
+		uiDrawPathNewFigureWithArc(path,
+			x, y,
+			rad,
+			uiPi + (uiPi / 5), angle,
+			0);
+		angle += add;
+		x += 2 * rad + step;
+	}
+
+	y += 2 * rad + step;
+	x = start + rad;
+	angle = 0;
+	for (i = 0; i < 13; i++) {
+		uiDrawPathNewFigure(path, x, y);
+		uiDrawPathArcTo(path,
+			x, y,
+			rad,
+			uiPi + (uiPi / 5), angle,
+			0);
+		angle += add;
+		x += 2 * rad + step;
+	}
+
+	uiDrawPathEnd(path);
+
+	brush.Type = uiDrawBrushTypeSolid;
+	brush.R = 0;
+	brush.G = 0;
+	brush.B = 0;
+	brush.A = 1;
+	sp.Cap = uiDrawLineCapFlat;
+	sp.Join = uiDrawLineJoinMiter;
+	sp.Thickness = 1;
+	sp.MiterLimit = uiDrawDefaultMiterLimit;
+	uiDrawStroke(p->Context, path, &brush, &sp);
+
+	uiDrawFreePath(path);
+}
+
+// Direct2D Documentation Code
+
+static void d2dColorToRGB(uint32_t color, double *r, double *g, double *b)
+{
+	uint8_t rr, gg, bb;
+
+	rr = (color & 0xFF0000) >> 16;
+	gg = (color & 0x00FF00) >> 8;
+	bb = color & 0x0000FF;
+	*r = ((double) rr) / 255.0;
+	*g = ((double) gg) / 255.0;
+	*b = ((double) bb) / 255.0;
+}
+#define d2dBlack 0x000000
+#define d2dLightSlateGray 0x778899
+#define d2dCornflowerBlue 0x6495ED
+#define d2dWhite 0xFFFFFF
+#define d2dYellowGreen 0x9ACD32
+#define d2dYellow 0xFFFF00
+#define d2dForestGreen 0x228B22
+#define d2dOliveDrab 0x6B8E23
+#define d2dLightSkyBlue 0x87CEFA
+
+static void d2dSolidBrush(uiDrawBrush *brush, uint32_t color, double alpha)
+{
+	brush->Type = uiDrawBrushTypeSolid;
+	d2dColorToRGB(color, &(brush->R), &(brush->G), &(brush->B));
+	brush->A = alpha;
+}
+
+static void d2dClear(uiAreaDrawParams *p, uint32_t color, double alpha)
+{
+	uiDrawPath *path;
+	uiDrawBrush brush;
+
+	d2dSolidBrush(&brush, color, alpha);
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathAddRectangle(path, 0, 0, p->AreaWidth, p->AreaHeight);
+	uiDrawPathEnd(path);
+	uiDrawFill(p->Context, path, &brush);
+	uiDrawFreePath(path);
+}
+
+// from https://msdn.microsoft.com/en-us/library/windows/desktop/hh780340%28v=vs.85%29.aspx
+// also at https://msdn.microsoft.com/en-us/library/windows/desktop/dd535473%28v=vs.85%29.aspx
+static void drawD2DW8QS(uiAreaDrawParams *p)
+{
+	uiDrawPath *path;
+	uiDrawBrush brush;
+
+	d2dSolidBrush(&brush, d2dBlack, 1.0);
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathAddRectangle(path,
+		100,
+		100,
+		(p->AreaWidth - 100) - 100,
+		(p->AreaHeight - 100) - 100);
+	uiDrawPathEnd(path);
+	uiDrawFill(p->Context, path, &brush);
+	uiDrawFreePath(path);
+}
+
+// from https://msdn.microsoft.com/en-us/library/windows/desktop/dd370994%28v=vs.85%29.aspx
+static void drawD2DSimpleApp(uiAreaDrawParams *p)
+{
+	uiDrawPath *path;
+	uiDrawBrush lightSlateGray;
+	uiDrawBrush cornflowerBlue;
+	uiDrawStrokeParams sp;
+	int x, y;
+
+	sp.Dashes = NULL;
+	sp.NumDashes = 0;
+	sp.DashPhase = 0;
+
+	d2dSolidBrush(&lightSlateGray, d2dLightSlateGray, 1.0);
+	d2dSolidBrush(&cornflowerBlue, d2dCornflowerBlue, 1.0);
+
+	d2dClear(p, d2dWhite, 1.0);
+
+	sp.Thickness = 0.5;
+	sp.Cap = uiDrawLineCapFlat;
+	sp.Join = uiDrawLineJoinMiter;
+	sp.MiterLimit = uiDrawDefaultMiterLimit;
+
+	for (x = 0; x < p->AreaWidth; x += 10) {
+		path = uiDrawNewPath(uiDrawFillModeWinding);
+		uiDrawPathNewFigure(path, x, 0);
+		uiDrawPathLineTo(path, x, p->AreaHeight);
+		uiDrawPathEnd(path);
+		uiDrawStroke(p->Context, path, &lightSlateGray, &sp);
+		uiDrawFreePath(path);
+	}
+
+	for (y = 0; y < p->AreaHeight; y += 10) {
+		path = uiDrawNewPath(uiDrawFillModeWinding);
+		uiDrawPathNewFigure(path, 0, y);
+		uiDrawPathLineTo(path, p->AreaWidth, y);
+		uiDrawPathEnd(path);
+		uiDrawStroke(p->Context, path, &lightSlateGray, &sp);
+		uiDrawFreePath(path);
+	}
+
+	double left, top, right, bottom;
+
+	left = p->AreaWidth / 2.0 - 50.0;
+	right = p->AreaWidth / 2.0 + 50.0;
+	top = p->AreaHeight / 2.0 - 50.0;
+	bottom = p->AreaHeight / 2.0 + 50.0;
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathAddRectangle(path, left, top, right - left, bottom - top);
+	uiDrawPathEnd(path);
+	uiDrawFill(p->Context, path, &lightSlateGray);
+	uiDrawFreePath(path);
+
+	left = p->AreaWidth / 2.0 - 100.0;
+	right = p->AreaWidth / 2.0 + 100.0;
+	top = p->AreaHeight / 2.0 - 100.0;
+	bottom = p->AreaHeight / 2.0 + 100.0;
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathAddRectangle(path, left, top, right - left, bottom - top);
+	uiDrawPathEnd(path);
+	sp.Thickness = 1.0;
+	uiDrawStroke(p->Context, path, &cornflowerBlue, &sp);
+	uiDrawFreePath(path);
+}
+
+// TODO? https://msdn.microsoft.com/en-us/library/windows/desktop/dd372260(v=vs.85).aspx
+
+// TODO https://msdn.microsoft.com/en-us/library/windows/desktop/dd756654%28v=vs.85%29.aspx
+
+// TODO? all subsections too? https://msdn.microsoft.com/en-us/library/windows/desktop/hh973240%28v=vs.85%29.aspx
+
+// TODO differing examples of? https://msdn.microsoft.com/en-us/library/windows/desktop/dd756651%28v=vs.85%29.aspx
+
+// from https://msdn.microsoft.com/en-us/library/windows/desktop/dd756680%28v=vs.85%29.aspx
+static void drawD2DSolidBrush(uiAreaDrawParams *p)
+{
+	uiDrawPath *path;
+	uiDrawBrush black;
+	uiDrawBrush yellowGreen;
+	uiDrawStrokeParams sp;
+
+	sp.Dashes = NULL;
+	sp.NumDashes = 0;
+	sp.DashPhase = 0;
+
+	d2dSolidBrush(&black, d2dBlack, 1.0);
+	d2dSolidBrush(&yellowGreen, d2dYellowGreen, 1.0);
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	// the example doesn't define a rectangle
+	// 150x150 seems to be right given the other examples though
+	uiDrawPathAddRectangle(path, 25, 25, 150, 150);
+	uiDrawPathEnd(path);
+
+	uiDrawFill(p->Context, path, &yellowGreen);
+	sp.Thickness = 1.0;
+	sp.Cap = uiDrawLineCapFlat;
+	sp.Join = uiDrawLineJoinMiter;
+	sp.MiterLimit = uiDrawDefaultMiterLimit;
+	uiDrawStroke(p->Context, path, &black, &sp);
+
+	uiDrawFreePath(path);
+}
+
+// from https://msdn.microsoft.com/en-us/library/windows/desktop/dd756678%28v=vs.85%29.aspx
+static void drawD2DLinearBrush(uiAreaDrawParams *p)
+{
+	uiDrawPath *path;
+	uiDrawBrush black;
+	uiDrawBrush gradient;
+	uiDrawBrushGradientStop stops[2];
+	uiDrawStrokeParams sp;
+
+	uiDrawMatrix m;
+
+	sp.Dashes = NULL;
+	sp.NumDashes = 0;
+	sp.DashPhase = 0;
+
+	// leave some room
+	uiDrawMatrixSetIdentity(&m);
+	uiDrawMatrixTranslate(&m, 25, 25);
+	uiDrawTransform(p->Context, &m);
+
+	gradient.Type = uiDrawBrushTypeLinearGradient;
+	gradient.X0 = 0;
+	gradient.Y0 = 0;
+	gradient.X1 = 150;
+	gradient.Y1 = 150;
+	stops[0].Pos = 0.0;
+	d2dColorToRGB(d2dYellow, &(stops[0].R), &(stops[0].G), &(stops[0].B));
+	stops[0].A = 1.0;
+	stops[1].Pos = 1.0;
+	d2dColorToRGB(d2dForestGreen, &(stops[1].R), &(stops[1].G), &(stops[1].B));
+	stops[1].A = 1.0;
+	gradient.Stops = stops;
+	gradient.NumStops = 2;
+
+	d2dSolidBrush(&black, d2dBlack, 1.0);
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathAddRectangle(path, 0, 0, 150, 150);
+	uiDrawPathEnd(path);
+
+	uiDrawFill(p->Context, path, &gradient);
+	sp.Thickness = 1.0;
+	sp.Cap = uiDrawLineCapFlat;
+	sp.Join = uiDrawLineJoinMiter;
+	sp.MiterLimit = uiDrawDefaultMiterLimit;
+	uiDrawStroke(p->Context, path, &black, &sp);
+
+	uiDrawFreePath(path);
+}
+
+// from https://msdn.microsoft.com/en-us/library/windows/desktop/dd756679%28v=vs.85%29.aspx
+// TODO expand this to change the origin point with a mouse click (not in the original but useful to have)
+static void drawD2DRadialBrush(uiAreaDrawParams *p)
+{
+	uiDrawPath *path;
+	uiDrawBrush black;
+	uiDrawBrush gradient;
+	uiDrawBrushGradientStop stops[2];
+	uiDrawStrokeParams sp;
+
+	uiDrawMatrix m;
+
+	sp.Dashes = NULL;
+	sp.NumDashes = 0;
+	sp.DashPhase = 0;
+
+	// leave some room
+	uiDrawMatrixSetIdentity(&m);
+	uiDrawMatrixTranslate(&m, 25, 25);
+	uiDrawTransform(p->Context, &m);
+
+	gradient.Type = uiDrawBrushTypeRadialGradient;
+	gradient.X0 = 75;
+	gradient.Y0 = 75;
+	gradient.X1 = 75;
+	gradient.Y1 = 75;
+	gradient.OuterRadius = 75;
+	stops[0].Pos = 0.0;
+	d2dColorToRGB(d2dYellow, &(stops[0].R), &(stops[0].G), &(stops[0].B));
+	stops[0].A = 1.0;
+	stops[1].Pos = 1.0;
+	d2dColorToRGB(d2dForestGreen, &(stops[1].R), &(stops[1].G), &(stops[1].B));
+	stops[1].A = 1.0;
+	gradient.Stops = stops;
+	gradient.NumStops = 2;
+
+	d2dSolidBrush(&black, d2dBlack, 1.0);
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigure(path, 150, 75);
+	uiDrawPathArcTo(path,
+		75, 75,
+		75,
+		0,
+		2 * uiPi,
+		0);
+	uiDrawPathEnd(path);
+
+	uiDrawFill(p->Context, path, &gradient);
+	sp.Thickness = 1.0;
+	sp.Cap = uiDrawLineCapFlat;
+	sp.Join = uiDrawLineJoinMiter;
+	sp.MiterLimit = uiDrawDefaultMiterLimit;
+	uiDrawStroke(p->Context, path, &black, &sp);
+
+	uiDrawFreePath(path);
+}
+
+// TODO https://msdn.microsoft.com/en-us/library/windows/desktop/dd756677%28v=vs.85%29.aspx
+
+// TODO? other pages have some of these https://msdn.microsoft.com/en-us/library/windows/desktop/dd756653%28v=vs.85%29.aspx
+
+// from https://msdn.microsoft.com/en-us/library/windows/desktop/ee264309%28v=vs.85%29.aspx
+static void drawD2DPathGeometries(uiAreaDrawParams *p)
+{
+	uiDrawPath *leftMountain;
+	uiDrawPath *rightMountain;
+	uiDrawPath *sun;
+	uiDrawPath *sunRays;
+	uiDrawPath *river;
+	uiDrawBrush radial;
+	uiDrawBrush scene;
+	uiDrawStrokeParams sp;
+	uiDrawBrushGradientStop stops[2];
+
+	sp.Dashes = NULL;
+	sp.NumDashes = 0;
+	sp.DashPhase = 0;
+
+	// TODO this is definitely wrong but the example doesn't have the right brush in it
+	radial.Type = uiDrawBrushTypeRadialGradient;
+	radial.X0 = 75;
+	radial.Y0 = 75;
+	radial.X1 = 75;
+	radial.Y1 = 75;
+	radial.OuterRadius = 75;
+	stops[0].Pos = 0.0;
+	d2dColorToRGB(d2dYellow, &(stops[0].R), &(stops[0].G), &(stops[0].B));
+	stops[0].A = 1.0;
+	stops[1].Pos = 1.0;
+	d2dColorToRGB(d2dForestGreen, &(stops[1].R), &(stops[1].G), &(stops[1].B));
+	stops[1].A = 1.0;
+	radial.Stops = stops;
+	radial.NumStops = 2;
+
+	leftMountain = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigure(leftMountain, 346, 255);
+	uiDrawPathLineTo(leftMountain, 267, 177);
+	uiDrawPathLineTo(leftMountain, 236, 192);
+	uiDrawPathLineTo(leftMountain, 212, 160);
+	uiDrawPathLineTo(leftMountain, 156, 255);
+	uiDrawPathLineTo(leftMountain, 346, 255);
+	uiDrawPathCloseFigure(leftMountain);
+	uiDrawPathEnd(leftMountain);
+
+	rightMountain = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigure(rightMountain, 575, 263);
+	uiDrawPathLineTo(rightMountain, 481, 146);
+	uiDrawPathLineTo(rightMountain, 449, 181);
+	uiDrawPathLineTo(rightMountain, 433, 159);
+	uiDrawPathLineTo(rightMountain, 401, 214);
+	uiDrawPathLineTo(rightMountain, 381, 199);
+	uiDrawPathLineTo(rightMountain, 323, 263);
+	uiDrawPathLineTo(rightMountain, 575, 263);
+	uiDrawPathCloseFigure(rightMountain);
+	uiDrawPathEnd(rightMountain);
+
+	sun = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigureWithArc(sun,
+		(440.0 - 270.0) / 2 + 270.0, 255,
+		85,
+		uiPi, uiPi,
+		0);
+	uiDrawPathCloseFigure(sun);
+	uiDrawPathEnd(sun);
+
+	// the original examples had these as hollow figures
+	// we don't support them, so we'll have to stroke it separately
+	sunRays = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigure(sunRays, 299, 182);
+	uiDrawPathBezierTo(sunRays,
+		299, 182,
+		294, 176,
+		285, 178);
+	uiDrawPathBezierTo(sunRays,
+		276, 179,
+		272, 173,
+		272, 173);
+	uiDrawPathNewFigure(sunRays, 354, 156);
+	uiDrawPathBezierTo(sunRays,
+		354, 156,
+		358, 149,
+		354, 142);
+	uiDrawPathBezierTo(sunRays,
+		349, 134,
+		354, 127,
+		354, 127);
+	uiDrawPathNewFigure(sunRays, 322, 164);
+	uiDrawPathBezierTo(sunRays,
+		322, 164,
+		322, 156,
+		314, 152);
+	uiDrawPathBezierTo(sunRays,
+		306, 149,
+		305, 141,
+		305, 141);
+	uiDrawPathNewFigure(sunRays, 385, 164);
+	uiDrawPathBezierTo(sunRays,
+		385, 164,
+		392, 161,
+		394, 152);
+	uiDrawPathBezierTo(sunRays,
+		395, 144,
+		402, 141,
+		402, 142);
+	uiDrawPathNewFigure(sunRays, 408, 182);
+	uiDrawPathBezierTo(sunRays,
+		408, 182,
+		416, 184,
+		422, 178);
+	uiDrawPathBezierTo(sunRays,
+		428, 171,
+		435, 173,
+		435, 173);
+	uiDrawPathEnd(sunRays);
+
+	river = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigure(river, 183, 392);
+	uiDrawPathBezierTo(river,
+		238, 284,
+		472, 345,
+		356, 303);
+	uiDrawPathBezierTo(river,
+		237, 261,
+		333, 256,
+		333, 256);
+	uiDrawPathBezierTo(river,
+		335, 257,
+		241, 261,
+		411, 306);
+	uiDrawPathBezierTo(river,
+		574, 350,
+		288, 324,
+		296, 392);
+	uiDrawPathEnd(river);
+
+	d2dClear(p, d2dWhite, 1.0);
+
+	// TODO draw the grid
+
+	uiDrawFill(p->Context, sun, &radial);
+
+	d2dSolidBrush(&scene, d2dBlack, 1.0);
+	sp.Thickness = 1.0;
+	sp.Cap = uiDrawLineCapFlat;
+	sp.Join = uiDrawLineJoinMiter;
+	sp.MiterLimit = uiDrawDefaultMiterLimit;
+	uiDrawStroke(p->Context, sun, &scene, &sp);
+	uiDrawStroke(p->Context, sunRays, &scene, &sp);
+
+	d2dSolidBrush(&scene, d2dOliveDrab, 1.0);
+	uiDrawFill(p->Context, leftMountain, &scene);
+
+	d2dSolidBrush(&scene, d2dBlack, 1.0);
+	uiDrawStroke(p->Context, leftMountain, &scene, &sp);
+
+	d2dSolidBrush(&scene, d2dLightSkyBlue, 1.0);
+	uiDrawFill(p->Context, river, &scene);
+
+	d2dSolidBrush(&scene, d2dBlack, 1.0);
+	uiDrawStroke(p->Context, river, &scene, &sp);
+
+	d2dSolidBrush(&scene, d2dYellowGreen, 1.0);
+	uiDrawFill(p->Context, rightMountain, &scene);
+
+	d2dSolidBrush(&scene, d2dBlack, 1.0);
+	uiDrawStroke(p->Context, rightMountain, &scene, &sp);
+
+	uiDrawFreePath(leftMountain);
+	uiDrawFreePath(rightMountain);
+	uiDrawFreePath(sun);
+	uiDrawFreePath(sunRays);
+	uiDrawFreePath(river);
+}
+
+// TODO https://msdn.microsoft.com/en-us/library/windows/desktop/dd756690%28v=vs.85%29.aspx
+
+// from https://msdn.microsoft.com/en-us/library/windows/desktop/dd756681%28v=vs.85%29.aspx
+static void drawD2DGeometryGroup(uiAreaDrawParams *p)
+{
+	uiDrawPath *alternate;
+	uiDrawPath *winding;
+	uiDrawBrush fill;
+	uiDrawBrush stroke;
+	uiDrawStrokeParams sp;
+	uiDrawMatrix m;
+
+	sp.Dashes = NULL;
+	sp.NumDashes = 0;
+	sp.DashPhase = 0;
+
+	alternate = uiDrawNewPath(uiDrawFillModeAlternate);
+	uiDrawPathNewFigureWithArc(alternate,
+		105, 105,
+		25,
+		0, 2 * uiPi,
+		0);
+	uiDrawPathNewFigureWithArc(alternate,
+		105, 105,
+		50,
+		0, 2 * uiPi,
+		0);
+	uiDrawPathNewFigureWithArc(alternate,
+		105, 105,
+		75,
+		0, 2 * uiPi,
+		0);
+	uiDrawPathNewFigureWithArc(alternate,
+		105, 105,
+		100,
+		0, 2 * uiPi,
+		0);
+	uiDrawPathEnd(alternate);
+
+	winding = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigureWithArc(winding,
+		105, 105,
+		25,
+		0, 2 * uiPi,
+		0);
+	uiDrawPathNewFigureWithArc(winding,
+		105, 105,
+		50,
+		0, 2 * uiPi,
+		0);
+	uiDrawPathNewFigureWithArc(winding,
+		105, 105,
+		75,
+		0, 2 * uiPi,
+		0);
+	uiDrawPathNewFigureWithArc(winding,
+		105, 105,
+		100,
+		0, 2 * uiPi,
+		0);
+	uiDrawPathEnd(winding);
+
+	d2dClear(p, d2dWhite, 1.0);
+
+	// TODO grid
+
+	// TODO the example doesn't provide these
+	d2dSolidBrush(&fill, d2dForestGreen, 1.0);
+	d2dSolidBrush(&stroke, d2dCornflowerBlue, 1.0);
+
+	sp.Thickness = 1.0;
+	sp.Cap = uiDrawLineCapFlat;
+	sp.Join = uiDrawLineJoinMiter;
+	sp.MiterLimit = uiDrawDefaultMiterLimit;
+
+	uiDrawFill(p->Context, alternate, &fill);
+	uiDrawStroke(p->Context, alternate, &stroke, &sp);
+	// TODO text
+
+	uiDrawMatrixSetIdentity(&m);
+	uiDrawMatrixTranslate(&m, 300, 0);
+	uiDrawTransform(p->Context, &m);
+	uiDrawFill(p->Context, winding, &fill);
+	uiDrawStroke(p->Context, winding, &stroke, &sp);
+//	// TODO text
+
+	uiDrawFreePath(winding);
+	uiDrawFreePath(alternate);
+}
+
+// TODO https://msdn.microsoft.com/en-us/library/windows/desktop/dd756676%28v=vs.85%29.aspx
+
+// TODO? https://msdn.microsoft.com/en-us/library/windows/desktop/dd370971%28v=vs.85%29.aspx
+
+// TODO are there even examples here? https://msdn.microsoft.com/en-us/library/windows/desktop/dd370966%28v=vs.85%29.aspx
+
+// from https://msdn.microsoft.com/en-us/library/windows/desktop/dd756687%28v=vs.85%29.aspx
+static void drawD2DRotate(uiAreaDrawParams *p)
+{
+	uiDrawPath *path;
+	uiDrawBrush original;
+	uiDrawBrush fill;
+	uiDrawBrush transform;
+	uiDrawStrokeParams originalsp;
+	uiDrawStrokeParams transformsp;
+	uiDrawMatrix m;
+
+	originalsp.Dashes = NULL;
+	originalsp.NumDashes = 0;
+	originalsp.DashPhase = 0;
+	transformsp.Dashes = NULL;
+	transformsp.NumDashes = 0;
+	transformsp.DashPhase = 0;
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathAddRectangle(path, 438.0, 301.5, 498.0 - 438.0, 361.5 - 301.5);
+	uiDrawPathEnd(path);
+
+	// TODO the example doesn't specify what these should be
+	d2dSolidBrush(&original, d2dBlack, 1.0);
+	d2dSolidBrush(&fill, d2dWhite, 0.5);
+	d2dSolidBrush(&transform, d2dForestGreen, 1.0);
+	// TODO this needs to be dashed
+	originalsp.Thickness = 1.0;
+	originalsp.Cap = uiDrawLineCapFlat;
+	originalsp.Join = uiDrawLineJoinMiter;
+	originalsp.MiterLimit = uiDrawDefaultMiterLimit;
+	transformsp.Thickness = 1.0;
+	transformsp.Cap = uiDrawLineCapFlat;
+	transformsp.Join = uiDrawLineJoinMiter;
+	transformsp.MiterLimit = uiDrawDefaultMiterLimit;
+
+	// save for when we do the translated one
+	uiDrawSave(p->Context);
+
+	uiDrawStroke(p->Context, path, &original, &originalsp);
+
+	uiDrawMatrixSetIdentity(&m);
+	uiDrawMatrixRotate(&m,
+		468.0, 331.5,
+		45.0 * (uiPi / 180));
+	uiDrawTransform(p->Context, &m);
+
+	uiDrawFill(p->Context, path, &fill);
+	uiDrawStroke(p->Context, path, &transform, &transformsp);
+
+	uiDrawRestore(p->Context);
+
+	// translate to test the corner axis
+	uiDrawMatrixSetIdentity(&m);
+	uiDrawMatrixTranslate(&m, -200, -200);
+	uiDrawTransform(p->Context, &m);
+
+	uiDrawStroke(p->Context, path, &original, &originalsp);
+
+	uiDrawMatrixSetIdentity(&m);
+	uiDrawMatrixRotate(&m,
+		438.0, 301.5,
+		45.0 * (uiPi / 180));
+	uiDrawTransform(p->Context, &m);
+
+	uiDrawFill(p->Context, path, &fill);
+	uiDrawStroke(p->Context, path, &transform, &transformsp);
+
+	uiDrawFreePath(path);
+}
+
+// from https://msdn.microsoft.com/en-us/library/windows/desktop/dd756688%28v=vs.85%29.aspx
+static void drawD2DScale(uiAreaDrawParams *p)
+{
+	uiDrawPath *path;
+	uiDrawBrush original;
+	uiDrawBrush fill;
+	uiDrawBrush transform;
+	uiDrawStrokeParams originalsp;
+	uiDrawStrokeParams transformsp;
+	uiDrawMatrix m;
+
+	originalsp.Dashes = NULL;
+	originalsp.NumDashes = 0;
+	originalsp.DashPhase = 0;
+	transformsp.Dashes = NULL;
+	transformsp.NumDashes = 0;
+	transformsp.DashPhase = 0;
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathAddRectangle(path, 438.0, 80.5, 498.0 - 438.0, 140.5 - 80.5);
+	uiDrawPathEnd(path);
+
+	// TODO the example doesn't specify what these should be
+	d2dSolidBrush(&original, d2dBlack, 1.0);
+	d2dSolidBrush(&fill, d2dWhite, 0.5);
+	d2dSolidBrush(&transform, d2dForestGreen, 1.0);
+	// TODO this needs to be dashed
+	originalsp.Thickness = 1.0;
+	originalsp.Cap = uiDrawLineCapFlat;
+	originalsp.Join = uiDrawLineJoinMiter;
+	originalsp.MiterLimit = uiDrawDefaultMiterLimit;
+	transformsp.Thickness = 1.0;
+	transformsp.Cap = uiDrawLineCapFlat;
+	transformsp.Join = uiDrawLineJoinMiter;
+	transformsp.MiterLimit = uiDrawDefaultMiterLimit;
+
+	// save for when we do the translated one
+	uiDrawSave(p->Context);
+
+	uiDrawStroke(p->Context, path, &original, &originalsp);
+
+	uiDrawMatrixSetIdentity(&m);
+	uiDrawMatrixScale(&m,
+		438.0, 80.5,
+		1.3, 1.3);
+	uiDrawTransform(p->Context, &m);
+
+	uiDrawFill(p->Context, path, &fill);
+	uiDrawStroke(p->Context, path, &transform, &transformsp);
+
+	uiDrawRestore(p->Context);
+
+	// for testing purposes, show what happens if we scale about (0, 0)
+	uiDrawMatrixSetIdentity(&m);
+	uiDrawMatrixTranslate(&m, -300, 50);
+	uiDrawTransform(p->Context, &m);
+
+	uiDrawStroke(p->Context, path, &original, &originalsp);
+
+	uiDrawMatrixSetIdentity(&m);
+	uiDrawMatrixScale(&m,
+		0, 0,
+		1.3, 1.3);
+	uiDrawTransform(p->Context, &m);
+
+	uiDrawFill(p->Context, path, &fill);
+	uiDrawStroke(p->Context, path, &transform, &transformsp);
+
+	uiDrawFreePath(path);
+}
+
+// from https://msdn.microsoft.com/en-us/library/windows/desktop/dd756689%28v=vs.85%29.aspx
+// TODO counterclockwise?!
+void drawD2DSkew(uiAreaDrawParams *p)
+{
+	uiDrawPath *path;
+	uiDrawBrush original;
+	uiDrawBrush fill;
+	uiDrawBrush transform;
+	uiDrawStrokeParams originalsp;
+	uiDrawStrokeParams transformsp;
+	uiDrawMatrix m;
+
+	originalsp.Dashes = NULL;
+	originalsp.NumDashes = 0;
+	originalsp.DashPhase = 0;
+	transformsp.Dashes = NULL;
+	transformsp.NumDashes = 0;
+	transformsp.DashPhase = 0;
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathAddRectangle(path, 126.0, 301.5, 186.0 - 126.0, 361.5 - 301.5);
+	uiDrawPathEnd(path);
+
+	// TODO the example doesn't specify what these should be
+	d2dSolidBrush(&original, d2dBlack, 1.0);
+	d2dSolidBrush(&fill, d2dWhite, 0.5);
+	d2dSolidBrush(&transform, d2dForestGreen, 1.0);
+	// TODO this needs to be dashed
+	originalsp.Thickness = 1.0;
+	originalsp.Cap = uiDrawLineCapFlat;
+	originalsp.Join = uiDrawLineJoinMiter;
+	originalsp.MiterLimit = uiDrawDefaultMiterLimit;
+	transformsp.Thickness = 1.0;
+	transformsp.Cap = uiDrawLineCapFlat;
+	transformsp.Join = uiDrawLineJoinMiter;
+	transformsp.MiterLimit = uiDrawDefaultMiterLimit;
+
+	// save for when we do the translated one
+	uiDrawSave(p->Context);
+
+	uiDrawStroke(p->Context, path, &original, &originalsp);
+
+	uiDrawMatrixSetIdentity(&m);
+	uiDrawMatrixSkew(&m,
+		126.0, 301.5,
+		45.0 * (uiPi / 180), 0);
+	uiDrawTransform(p->Context, &m);
+
+	uiDrawFill(p->Context, path, &fill);
+	uiDrawStroke(p->Context, path, &transform, &transformsp);
+
+	uiDrawRestore(p->Context);
+
+	// for testing purposes, show what happens if we skew about (0, 0)
+	uiDrawMatrixSetIdentity(&m);
+	uiDrawMatrixTranslate(&m, 0, -200);
+	uiDrawTransform(p->Context, &m);
+
+	uiDrawStroke(p->Context, path, &original, &originalsp);
+
+	uiDrawMatrixSetIdentity(&m);
+	uiDrawMatrixSkew(&m,
+		0, 0,
+		45.0 * (uiPi / 180), 0);
+	uiDrawTransform(p->Context, &m);
+
+	uiDrawFill(p->Context, path, &fill);
+	uiDrawStroke(p->Context, path, &transform, &transformsp);
+
+	uiDrawFreePath(path);
+}
+
+// from https://msdn.microsoft.com/en-us/library/windows/desktop/dd756691%28v=vs.85%29.aspx
+static void drawD2DTranslate(uiAreaDrawParams *p)
+{
+	uiDrawPath *path;
+	uiDrawBrush original;
+	uiDrawBrush fill;
+	uiDrawBrush transform;
+	uiDrawStrokeParams originalsp;
+	uiDrawStrokeParams transformsp;
+	uiDrawMatrix m;
+
+	originalsp.Dashes = NULL;
+	originalsp.NumDashes = 0;
+	originalsp.DashPhase = 0;
+	transformsp.Dashes = NULL;
+	transformsp.NumDashes = 0;
+	transformsp.DashPhase = 0;
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathAddRectangle(path, 126.0, 80.5, 186.0 - 126.0, 140.5 - 80.5);
+	uiDrawPathEnd(path);
+
+	// TODO the example doesn't specify what these should be
+	d2dSolidBrush(&original, d2dBlack, 1.0);
+	d2dSolidBrush(&fill, d2dWhite, 0.5);
+	d2dSolidBrush(&transform, d2dForestGreen, 1.0);
+	// TODO this needs to be dashed
+	originalsp.Thickness = 1.0;
+	originalsp.Cap = uiDrawLineCapFlat;
+	originalsp.Join = uiDrawLineJoinMiter;
+	originalsp.MiterLimit = uiDrawDefaultMiterLimit;
+	transformsp.Thickness = 1.0;
+	transformsp.Cap = uiDrawLineCapFlat;
+	transformsp.Join = uiDrawLineJoinMiter;
+	transformsp.MiterLimit = uiDrawDefaultMiterLimit;
+
+	uiDrawStroke(p->Context, path, &original, &originalsp);
+
+	uiDrawMatrixSetIdentity(&m);
+	uiDrawMatrixTranslate(&m, 20, 10);
+	uiDrawTransform(p->Context, &m);
+
+	uiDrawFill(p->Context, path, &fill);
+	uiDrawStroke(p->Context, path, &transform, &transformsp);
+
+	uiDrawFreePath(path);
+}
+
+// from https://msdn.microsoft.com/en-us/library/windows/desktop/dd756672%28v=vs.85%29.aspx
+// TODO the points seem off
+static void drawD2DMultiTransforms(uiAreaDrawParams *p)
+{
+	uiDrawPath *path;
+	uiDrawBrush original;
+	uiDrawBrush fill;
+	uiDrawBrush transform;
+	uiDrawStrokeParams originalsp;
+	uiDrawStrokeParams transformsp;
+	uiDrawMatrix mtranslate;
+	uiDrawMatrix mrotate;
+
+	originalsp.Dashes = NULL;
+	originalsp.NumDashes = 0;
+	originalsp.DashPhase = 0;
+	transformsp.Dashes = NULL;
+	transformsp.NumDashes = 0;
+	transformsp.DashPhase = 0;
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathAddRectangle(path, 300.0, 40.0, 360.0 - 300.0, 100.0 - 40.0);
+	uiDrawPathEnd(path);
+
+	// TODO the example doesn't specify what these should be
+	d2dSolidBrush(&original, d2dBlack, 1.0);
+	d2dSolidBrush(&fill, d2dWhite, 0.5);
+	d2dSolidBrush(&transform, d2dForestGreen, 1.0);
+	// TODO this needs to be dashed
+	originalsp.Thickness = 1.0;
+	originalsp.Cap = uiDrawLineCapFlat;
+	originalsp.Join = uiDrawLineJoinMiter;
+	originalsp.MiterLimit = uiDrawDefaultMiterLimit;
+	transformsp.Thickness = 1.0;
+	transformsp.Cap = uiDrawLineCapFlat;
+	transformsp.Join = uiDrawLineJoinMiter;
+	transformsp.MiterLimit = uiDrawDefaultMiterLimit;
+
+	uiDrawMatrixSetIdentity(&mtranslate);
+	uiDrawMatrixTranslate(&mtranslate, 20.0, 10.0);
+	uiDrawMatrixSetIdentity(&mrotate);
+	uiDrawMatrixRotate(&mrotate,
+		330.0, 70.0,
+		45.0 * (uiPi / 180));
+
+	// save for when we do the opposite one
+	uiDrawSave(p->Context);
+
+	uiDrawStroke(p->Context, path, &original, &originalsp);
+
+	uiDrawTransform(p->Context, &mrotate);
+	uiDrawTransform(p->Context, &mtranslate);
+
+	uiDrawFill(p->Context, path, &fill);
+	uiDrawStroke(p->Context, path, &transform, &transformsp);
+
+	uiDrawRestore(p->Context);
+	uiDrawFreePath(path);
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathAddRectangle(path, 40.0, 40.0, 100.0 - 40.0, 100.0 - 40.0);
+	uiDrawPathEnd(path);
+
+	uiDrawMatrixSetIdentity(&mtranslate);
+	uiDrawMatrixTranslate(&mtranslate, 20.0, 10.0);
+	uiDrawMatrixSetIdentity(&mrotate);
+	uiDrawMatrixRotate(&mrotate,
+		70.0, 70.0,
+		45.0 * (uiPi / 180));
+
+	uiDrawStroke(p->Context, path, &original, &originalsp);
+
+	uiDrawTransform(p->Context, &mtranslate);
+	uiDrawTransform(p->Context, &mrotate);
+
+	uiDrawFill(p->Context, path, &fill);
+	uiDrawStroke(p->Context, path, &transform, &transformsp);
+
+	uiDrawFreePath(path);
+}
+
+// TODO https://msdn.microsoft.com/en-us/library/windows/desktop/dd756675%28v=vs.85%29.aspx
+
+// TODO https://msdn.microsoft.com/en-us/library/windows/desktop/dd756673%28v=vs.85%29.aspx
+
+// TODO https://msdn.microsoft.com/en-us/library/windows/desktop/dd756684%28v=vs.85%29.aspx
+
+// TODO dashing https://msdn.microsoft.com/en-us/library/windows/desktop/dd756683%28v=vs.85%29.aspx
+
+// from https://msdn.microsoft.com/en-us/library/windows/desktop/dd756682%28v=vs.85%29.aspx
+static void drawD2DComplexShape(uiAreaDrawParams *p)
+{
+	uiDrawPath *path;
+	uiDrawBrush black;
+	uiDrawBrush gradient;
+	uiDrawBrushGradientStop stops[2];
+	uiDrawStrokeParams sp;
+	uiDrawMatrix m;
+
+	sp.Dashes = NULL;
+	sp.NumDashes = 0;
+	sp.DashPhase = 0;
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigure(path, 0, 0);
+	uiDrawPathLineTo(path, 200, 0);
+	uiDrawPathBezierTo(path,
+		150, 50,
+		150, 150,
+		200, 200);
+	uiDrawPathLineTo(path, 0, 200);
+	uiDrawPathBezierTo(path,
+		50, 150,
+		50, 50,
+		0, 0);
+	uiDrawPathCloseFigure(path);
+	uiDrawPathEnd(path);
+
+	d2dSolidBrush(&black, d2dBlack, 1.0);
+
+	stops[0].Pos =0.0;
+	stops[0].R = 0.0;
+	stops[0].G = 1.0;
+	stops[0].B = 1.0;
+	stops[0].A = 0.25;
+	stops[1].Pos = 1.0;
+	stops[1].R = 0.0;
+	stops[1].G = 0.0;
+	stops[1].B = 1.0;
+	stops[1].A = 1.0;
+	gradient.Type = uiDrawBrushTypeLinearGradient;
+	gradient.X0 = 100;
+	gradient.Y0 = 0;
+	gradient.X1 = 100;
+	gradient.Y1 = 200;
+	gradient.Stops = stops;
+	gradient.NumStops = 2;
+
+	uiDrawMatrixSetIdentity(&m);
+	uiDrawMatrixTranslate(&m, 20, 20);
+	uiDrawTransform(p->Context, &m);
+
+	sp.Thickness = 10.0;
+	sp.Cap = uiDrawLineCapFlat;
+	sp.Join = uiDrawLineJoinMiter;
+	sp.MiterLimit = uiDrawDefaultMiterLimit;
+
+	uiDrawStroke(p->Context, path, &black, &sp);
+	uiDrawFill(p->Context, path, &gradient);
+
+	uiDrawFreePath(path);
+}
+
+// TODO https://msdn.microsoft.com/en-us/library/windows/desktop/dd756692%28v=vs.85%29.aspx
+
+// TODO https://msdn.microsoft.com/en-us/library/windows/desktop/dd756686%28v=vs.85%29.aspx
+
+// TODO https://msdn.microsoft.com/en-us/library/windows/desktop/dd756685%28v=vs.85%29.aspx
+
+// TODO https://msdn.microsoft.com/en-us/library/windows/desktop/dd756674%28v=vs.85%29.aspx
+
+// TODO? https://msdn.microsoft.com/en-us/library/windows/desktop/ee329947%28v=vs.85%29.aspx
+
+// TODO https://msdn.microsoft.com/en-us/library/windows/desktop/ff485857%28v=vs.85%29.aspx
+
+// TODO? https://msdn.microsoft.com/en-us/library/windows/desktop/dd756755%28v=vs.85%29.aspx
+
+// TODO go through the API reference and spot examples that aren't listed
+
+// TODO all of these https://msdn.microsoft.com/en-us/library/windows/desktop/dd368187%28v=vs.85%29.aspx
+
+// cairo Samples Page (http://cairographics.org/samples/)
+
+static void crsourcergba(uiDrawBrush *brush, double r, double g, double b, double a)
+{
+	brush->Type = uiDrawBrushTypeSolid;
+	brush->R = r;
+	brush->G = g;
+	brush->B = b;
+	brush->A = a;
+}
+
+// arc
+static void drawCSArc(uiAreaDrawParams *p)
+{
+	double xc = 128.0;
+	double yc = 128.0;
+	double radius = 100.0;
+	double angle1 = 45.0  * (uiPi / 180.0);
+	double angle2 = 180.0 * (uiPi / 180.0);
+	uiDrawBrush source;
+	uiDrawStrokeParams sp;
+	uiDrawPath *path;
+
+	crsourcergba(&source, 0, 0, 0, 1);
+	sp.Cap = uiDrawLineCapFlat;
+	sp.Join = uiDrawLineJoinMiter;
+	sp.MiterLimit = uiDrawDefaultMiterLimit;
+	sp.Dashes = NULL;
+	sp.NumDashes = 0;
+	sp.DashPhase = 0;
+
+	sp.Thickness = 10.0;
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigureWithArc(path,
+		xc, yc,
+		radius,
+		angle1,
+		angle2 - angle1,
+		0);
+	uiDrawPathEnd(path);
+	uiDrawStroke(p->Context, path, &source, &sp);
+	uiDrawFreePath(path);
+
+	crsourcergba(&source, 1, 0.2, 0.2, 0.6);
+	sp.Thickness = 6.0;
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigureWithArc(path,
+		xc, yc,
+		10.0,
+		0, 2 * uiPi,
+		0);
+	uiDrawPathEnd(path);
+	uiDrawFill(p->Context, path, &source);
+	uiDrawFreePath(path);
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigureWithArc(path,
+		xc, yc,
+		radius,
+		angle1, 0,
+		0);
+	uiDrawPathLineTo(path, xc, yc);
+	uiDrawPathNewFigureWithArc(path,
+		xc, yc,
+		radius,
+		angle2, 0,
+		0);
+	uiDrawPathLineTo(path, xc, yc);
+	uiDrawPathEnd(path);
+	uiDrawStroke(p->Context, path, &source, &sp);
+	uiDrawFreePath(path);
+}
+
+// arc negative
+static void drawCSArcNegative(uiAreaDrawParams *p)
+{
+	double xc = 128.0;
+	double yc = 128.0;
+	double radius = 100.0;
+	double angle1 = 45.0  * (uiPi / 180.0);
+	double angle2 = 180.0 * (uiPi / 180.0);
+	uiDrawBrush source;
+	uiDrawStrokeParams sp;
+	uiDrawPath *path;
+
+	crsourcergba(&source, 0, 0, 0, 1);
+	sp.Cap = uiDrawLineCapFlat;
+	sp.Join = uiDrawLineJoinMiter;
+	sp.MiterLimit = uiDrawDefaultMiterLimit;
+	sp.Dashes = NULL;
+	sp.NumDashes = 0;
+	sp.DashPhase = 0;
+
+	sp.Thickness = 10.0;
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigureWithArc(path,
+		xc, yc,
+		radius,
+		angle1,
+		angle2 - angle1,
+		1);
+	uiDrawPathEnd(path);
+	uiDrawStroke(p->Context, path, &source, &sp);
+	uiDrawFreePath(path);
+
+	crsourcergba(&source, 1, 0.2, 0.2, 0.6);
+	sp.Thickness = 6.0;
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigureWithArc(path,
+		xc, yc,
+		10.0,
+		0, 2 * uiPi,
+		0);
+	uiDrawPathEnd(path);
+	uiDrawFill(p->Context, path, &source);
+	uiDrawFreePath(path);
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigureWithArc(path,
+		xc, yc,
+		radius,
+		angle1, 0,
+		0);
+	uiDrawPathLineTo(path, xc, yc);
+	uiDrawPathNewFigureWithArc(path,
+		xc, yc,
+		radius,
+		angle2, 0,
+		0);
+	uiDrawPathLineTo(path, xc, yc);
+	uiDrawPathEnd(path);
+	uiDrawStroke(p->Context, path, &source, &sp);
+	uiDrawFreePath(path);
+}
+
+// clip
+static void drawCSClip(uiAreaDrawParams *p)
+{
+	uiDrawBrush source;
+	uiDrawStrokeParams sp;
+	uiDrawPath *path;
+
+	crsourcergba(&source, 0, 0, 0, 1);
+	sp.Cap = uiDrawLineCapFlat;
+	sp.Join = uiDrawLineJoinMiter;
+	sp.MiterLimit = uiDrawDefaultMiterLimit;
+	sp.Dashes = NULL;
+	sp.NumDashes = 0;
+	sp.DashPhase = 0;
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+
+	uiDrawPathNewFigureWithArc(path,
+		128.0, 128.0,
+		76.8,
+		0, 2 * uiPi,
+		0);
+	uiDrawPathEnd(path);
+	uiDrawClip(p->Context, path);
+	uiDrawFreePath(path);
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathAddRectangle(path, 0, 0, 256, 256);
+	uiDrawPathEnd(path);
+	uiDrawFill(p->Context, path, &source);
+	uiDrawFreePath(path);
+
+	crsourcergba(&source, 0, 1, 0, 1);
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigure(path, 0, 0);
+	uiDrawPathLineTo(path, 256, 256);
+	uiDrawPathNewFigure(path, 256, 0);
+	uiDrawPathLineTo(path, 0, 256);
+	uiDrawPathEnd(path);
+	sp.Thickness = 10.0;
+	uiDrawStroke(p->Context, path, &source, &sp);
+	uiDrawFreePath(path);
+}
+
+// TODO clip image
+
+// curve rectangle
+static void drawCSCurveRectangle(uiAreaDrawParams *p)
+{
+	double x0      = 25.6,   /* parameters like cairo_rectangle */
+		y0      = 25.6,
+		rect_width  = 204.8,
+		rect_height = 204.8,
+		radius = 102.4;   /* and an approximate curvature radius */
+
+	double x1,y1;
+
+	uiDrawBrush source;
+	uiDrawStrokeParams sp;
+	uiDrawPath *path;
+
+	crsourcergba(&source, 0, 0, 0, 1);
+	sp.Cap = uiDrawLineCapFlat;
+	sp.Join = uiDrawLineJoinMiter;
+	sp.MiterLimit = uiDrawDefaultMiterLimit;
+	sp.Dashes = NULL;
+	sp.NumDashes = 0;
+	sp.DashPhase = 0;
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+
+	x1=x0+rect_width;
+	y1=y0+rect_height;
+	if (!rect_width || !rect_height)
+		return;
+	if (rect_width/2 < radius) {
+		if (rect_height/2<radius) {
+			uiDrawPathNewFigure(path, x0, (y0 + y1)/2);
+			uiDrawPathBezierTo(path, x0 ,y0, x0, y0, (x0 + x1)/2, y0);
+			uiDrawPathBezierTo(path, x1, y0, x1, y0, x1, (y0 + y1)/2);
+			uiDrawPathBezierTo(path, x1, y1, x1, y1, (x1 + x0)/2, y1);
+			uiDrawPathBezierTo(path, x0, y1, x0, y1, x0, (y0 + y1)/2);
+		} else {
+			uiDrawPathNewFigure(path, x0, y0 + radius);
+			uiDrawPathBezierTo(path, x0 ,y0, x0, y0, (x0 + x1)/2, y0);
+			uiDrawPathBezierTo(path, x1, y0, x1, y0, x1, y0 + radius);
+			uiDrawPathLineTo(path, x1 , y1 - radius);
+			uiDrawPathBezierTo(path, x1, y1, x1, y1, (x1 + x0)/2, y1);
+			uiDrawPathBezierTo(path, x0, y1, x0, y1, x0, y1- radius);
+		}
+	} else {
+		if (rect_height / 2 < radius) {
+			uiDrawPathNewFigure(path, x0, (y0 + y1)/2);
+			uiDrawPathBezierTo(path, x0 , y0, x0 , y0, x0 + radius, y0);
+			uiDrawPathLineTo(path, x1 - radius, y0);
+			uiDrawPathBezierTo(path, x1, y0, x1, y0, x1, (y0 + y1)/2);
+			uiDrawPathBezierTo(path, x1, y1, x1, y1, x1 - radius, y1);
+			uiDrawPathLineTo(path, x0 + radius, y1);
+			uiDrawPathBezierTo(path, x0, y1, x0, y1, x0, (y0 + y1)/2);
+		} else {
+			uiDrawPathNewFigure(path, x0, y0 + radius);
+			uiDrawPathBezierTo(path, x0 , y0, x0 , y0, x0 + radius, y0);
+			uiDrawPathLineTo(path, x1 - radius, y0);
+			uiDrawPathBezierTo(path, x1, y0, x1, y0, x1, y0 + radius);
+			uiDrawPathLineTo(path, x1 , y1 - radius);
+			uiDrawPathBezierTo(path, x1, y1, x1, y1, x1 - radius, y1);
+			uiDrawPathLineTo(path, x0 + radius, y1);
+			uiDrawPathBezierTo(path, x0, y1, x0, y1, x0, y1- radius);
+		}
+	}
+	uiDrawPathCloseFigure(path);
+	uiDrawPathEnd(path);
+
+	crsourcergba(&source, 0.5, 0.5, 1, 1.0);
+	uiDrawFill(p->Context, path, &source);
+	crsourcergba(&source, 0.5, 0, 0, 0.5);
+	sp.Thickness = 10.0;
+	uiDrawStroke(p->Context, path, &source, &sp);
+
+	uiDrawFreePath(path);
+}
+
+// curve to
+static void drawCSCurveTo(uiAreaDrawParams *p)
+{
+	double x=25.6,  y=128.0;
+	double x1=102.4, y1=230.4,
+		x2=153.6, y2=25.6,
+		x3=230.4, y3=128.0;
+	uiDrawBrush source;
+	uiDrawStrokeParams sp;
+	uiDrawPath *path;
+
+	crsourcergba(&source, 0, 0, 0, 1);
+	sp.Cap = uiDrawLineCapFlat;
+	sp.Join = uiDrawLineJoinMiter;
+	sp.MiterLimit = uiDrawDefaultMiterLimit;
+	sp.Dashes = NULL;
+	sp.NumDashes = 0;
+	sp.DashPhase = 0;
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+
+	uiDrawPathNewFigure(path, x, y);
+	uiDrawPathBezierTo(path, x1, y1, x2, y2, x3, y3);
+	uiDrawPathEnd(path);
+	sp.Thickness = 10.0;
+	uiDrawStroke(p->Context, path, &source, &sp);
+	uiDrawFreePath(path);
+
+	crsourcergba(&source, 1, 0.2, 0.2, 0.6);
+	sp.Thickness = 6.0;
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigure(path, x, y);
+	uiDrawPathLineTo(path, x1, y1);
+	uiDrawPathNewFigure(path, x2, y2);
+	uiDrawPathLineTo(path, x3, y3);
+	uiDrawPathEnd(path);
+	uiDrawStroke(p->Context, path, &source, &sp);
+	uiDrawFreePath(path);
+}
+
+// dash
+static void drawCSDash(uiAreaDrawParams *p)
+{
+	double dashes[] = {
+		50.0,  /* ink */
+		10.0,  /* skip */
+		10.0,  /* ink */
+		10.0   /* skip*/
+	};
+	int    ndash  = sizeof (dashes)/sizeof(dashes[0]);
+	double offset = -50.0;
+
+	uiDrawBrush source;
+	uiDrawStrokeParams sp;
+	uiDrawPath *path;
+
+	crsourcergba(&source, 0, 0, 0, 1);
+	sp.Cap = uiDrawLineCapFlat;
+	sp.Join = uiDrawLineJoinMiter;
+	sp.MiterLimit = uiDrawDefaultMiterLimit;
+	sp.Dashes = dashes;
+	sp.NumDashes = ndash;
+	sp.DashPhase = offset;
+	sp.Thickness = 10.0;
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigure(path, 128.0, 25.6);
+	uiDrawPathLineTo(path, 230.4, 230.4);
+	uiDrawPathLineTo(path, 230.4 -102.4, 230.4 + 0.0);
+	uiDrawPathBezierTo(path,
+		51.2, 230.4,
+		51.2, 128.0,
+		128.0, 128.0);
+	uiDrawPathEnd(path);
+
+	uiDrawStroke(p->Context, path, &source, &sp);
+	uiDrawFreePath(path);
+}
+
+// fill and stroke2
+static void drawCSFillAndStroke2(uiAreaDrawParams *p)
+{
+	uiDrawBrush source;
+	uiDrawStrokeParams sp;
+	uiDrawPath *path;
+
+	crsourcergba(&source, 0, 0, 0, 1);
+	sp.Cap = uiDrawLineCapFlat;
+	sp.Join = uiDrawLineJoinMiter;
+	sp.MiterLimit = uiDrawDefaultMiterLimit;
+	sp.Dashes = NULL;
+	sp.NumDashes = 0;
+	sp.DashPhase = 0;
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+
+	uiDrawPathNewFigure(path, 128.0, 25.6);
+	uiDrawPathLineTo(path, 230.4, 230.4);
+	uiDrawPathLineTo(path, 230.4 - 102.4, 230.4 + 0.0);
+	uiDrawPathBezierTo(path, 51.2, 230.4, 51.2, 128.0, 128.0, 128.0);
+	uiDrawPathCloseFigure(path);
+
+	uiDrawPathNewFigure(path, 64.0, 25.6);
+	uiDrawPathLineTo(path, 64.0 + 51.2, 25.6 + 51.2);
+	uiDrawPathLineTo(path, 64.0 + 51.2 -51.2, 25.6 + 51.2 + 51.2);
+	uiDrawPathLineTo(path, 64.0 + 51.2 -51.2 -51.2, 25.6 + 51.2 + 51.2 -51.2);
+	uiDrawPathCloseFigure(path);
+
+	uiDrawPathEnd(path);
+
+	sp.Thickness = 10.0;
+	crsourcergba(&source, 0, 0, 1, 1);
+	uiDrawFill(p->Context, path, &source);
+	crsourcergba(&source, 0, 0, 0, 1);
+	uiDrawStroke(p->Context, path, &source, &sp);
+	uiDrawFreePath(path);
+}
+
+// fill style
+static void drawCSFillStyle(uiAreaDrawParams *p)
+{
+	uiDrawBrush source;
+	uiDrawStrokeParams sp;
+	uiDrawPath *path;
+	uiDrawMatrix m;
+
+	crsourcergba(&source, 0, 0, 0, 1);
+	sp.Cap = uiDrawLineCapFlat;
+	sp.Join = uiDrawLineJoinMiter;
+	sp.MiterLimit = uiDrawDefaultMiterLimit;
+	sp.Dashes = NULL;
+	sp.NumDashes = 0;
+	sp.DashPhase = 0;
+
+	sp.Thickness = 6;
+
+	path = uiDrawNewPath(uiDrawFillModeAlternate);
+	uiDrawPathAddRectangle(path, 12, 12, 232, 70);
+	uiDrawPathNewFigureWithArc(path,
+		64, 64,
+		40,
+		0, 2*uiPi,
+		0);
+	uiDrawPathNewFigureWithArc(path,
+		192, 64,
+		40,
+		0, -2*uiPi,
+		1);
+	uiDrawPathEnd(path);
+
+	crsourcergba(&source, 0, 0.7, 0, 1);
+	uiDrawFill(p->Context, path, &source);
+	crsourcergba(&source, 0, 0, 0, 1);
+	uiDrawStroke(p->Context, path, &source, &sp);
+	uiDrawFreePath(path);
+
+	uiDrawMatrixSetIdentity(&m);
+	uiDrawMatrixTranslate(&m, 0, 128);
+	uiDrawTransform(p->Context, &m);
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathAddRectangle(path, 12, 12, 232, 70);
+	uiDrawPathNewFigureWithArc(path,
+		64, 64,
+		40,
+		0, 2*uiPi,
+		0);
+	uiDrawPathNewFigureWithArc(path,
+		192, 64,
+		40,
+		0, -2*uiPi,
+		1);
+	uiDrawPathEnd(path);
+
+	crsourcergba(&source, 0, 0, 0.9, 1);
+	uiDrawFill(p->Context, path, &source);
+	crsourcergba(&source, 0, 0, 0, 1);
+	uiDrawStroke(p->Context, path, &source, &sp);
+	uiDrawFreePath(path);
+}
+
+// TOOD gradient (radial gradient with two circles)
+
+// TODO image
+
+// TODO imagepattern
+
+// multi segment caps
+static void drawCSMultiCaps(uiAreaDrawParams *p)
+{
+	uiDrawBrush source;
+	uiDrawStrokeParams sp;
+	uiDrawPath *path;
+
+	crsourcergba(&source, 0, 0, 0, 1);
+	sp.Join = uiDrawLineJoinMiter;
+	sp.MiterLimit = uiDrawDefaultMiterLimit;
+	sp.Dashes = NULL;
+	sp.NumDashes = 0;
+	sp.DashPhase = 0;
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+
+	uiDrawPathNewFigure(path, 50.0, 75.0);
+	uiDrawPathLineTo(path, 200.0, 75.0);
+
+	uiDrawPathNewFigure(path, 50.0, 125.0);
+	uiDrawPathLineTo(path, 200.0, 125.0);
+
+	uiDrawPathNewFigure(path, 50.0, 175.0);
+	uiDrawPathLineTo(path, 200.0, 175.0);
+	uiDrawPathEnd(path);
+
+	sp.Thickness = 30.0;
+	sp.Cap = uiDrawLineCapRound;
+	uiDrawStroke(p->Context, path, &source, &sp);
+	uiDrawFreePath(path);
+}
+
+// rounded rectangle
+static void drawCSRoundRect(uiAreaDrawParams *p)
+{
+	double x         = 25.6,        /* parameters like cairo_rectangle */
+		y         = 25.6,
+		width         = 204.8,
+		height        = 204.8,
+		aspect        = 1.0,     /* aspect ratio */
+		corner_radius = height / 10.0;   /* and corner curvature radius */
+
+	double radius = corner_radius / aspect;
+	double degrees = uiPi / 180.0;
+
+	uiDrawBrush source;
+	uiDrawStrokeParams sp;
+	uiDrawPath *path;
+
+	crsourcergba(&source, 0, 0, 0, 1);
+	sp.Cap = uiDrawLineCapFlat;
+	sp.Join = uiDrawLineJoinMiter;
+	sp.MiterLimit = uiDrawDefaultMiterLimit;
+	sp.Dashes = NULL;
+	sp.NumDashes = 0;
+	sp.DashPhase = 0;
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+
+	// top right corner
+	uiDrawPathNewFigureWithArc(path,
+		x + width - radius, y + radius,
+		radius,
+		-90 * degrees, uiPi / 2,
+		0);
+	// bottom right corner
+	uiDrawPathArcTo(path,
+		x + width - radius, y + height - radius,
+		radius,
+		0 * degrees, uiPi / 2,
+		0);
+	// bottom left corner
+	uiDrawPathArcTo(path,
+		x + radius, y + height - radius,
+		radius,
+		90 * degrees, uiPi / 2,
+		0);
+	// top left corner
+	uiDrawPathArcTo(path,
+		x + radius, y + radius,
+		radius,
+		180 * degrees, uiPi / 2,
+		0);
+	uiDrawPathCloseFigure(path);
+	uiDrawPathEnd(path);
+
+	crsourcergba(&source, 0.5, 0.5, 1, 1);
+	uiDrawFill(p->Context, path, &source);
+	crsourcergba(&source, 0.5, 0, 0, 0.5);
+	sp.Thickness = 10.0;
+	uiDrawStroke(p->Context, path, &source, &sp);
+	uiDrawFreePath(path);
+}
+
+// set line cap
+static void drawCSSetLineCap(uiAreaDrawParams *p)
+{
+	uiDrawBrush source;
+	uiDrawStrokeParams sp;
+	uiDrawPath *path;
+
+	crsourcergba(&source, 0, 0, 0, 1);
+	sp.Cap = uiDrawLineCapFlat;
+	sp.Join = uiDrawLineJoinMiter;
+	sp.MiterLimit = uiDrawDefaultMiterLimit;
+	sp.Dashes = NULL;
+	sp.NumDashes = 0;
+	sp.DashPhase = 0;
+
+	sp.Thickness = 30.0;
+
+	sp.Cap = uiDrawLineCapFlat;
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigure(path, 64.0, 50.0);
+	uiDrawPathLineTo(path, 64.0, 200.0);
+	uiDrawPathEnd(path);
+	uiDrawStroke(p->Context, path, &source, &sp);
+	uiDrawFreePath(path);
+
+	sp.Cap = uiDrawLineCapRound;
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigure(path, 128.0, 50.0);
+	uiDrawPathLineTo(path, 128.0, 200.0);
+	uiDrawPathEnd(path);
+	uiDrawStroke(p->Context, path, &source, &sp);
+	uiDrawFreePath(path);
+
+	sp.Cap = uiDrawLineCapSquare;
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigure(path, 192.0, 50.0);
+	uiDrawPathLineTo(path, 192.0, 200.0);
+	uiDrawPathEnd(path);
+	uiDrawStroke(p->Context, path, &source, &sp);
+	uiDrawFreePath(path);
+
+	// draw helping lines
+	// keep the square cap to match the reference picture on the cairo website
+	crsourcergba(&source, 1, 0.2, 0.2, 1);
+	sp.Thickness = 2.56;
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigure(path, 64.0, 50.0);
+	uiDrawPathLineTo(path, 64.0, 200.0);
+	uiDrawPathNewFigure(path, 128.0, 50.0);
+	uiDrawPathLineTo(path, 128.0, 200.0);
+	uiDrawPathNewFigure(path, 192.0, 50.0);
+	uiDrawPathLineTo(path, 192.0, 200.0);
+	uiDrawPathEnd(path);
+	uiDrawStroke(p->Context, path, &source, &sp);
+	uiDrawFreePath(path);
+}
+
+// set line join
+static void drawCSSetLineJoin(uiAreaDrawParams *p)
+{
+	uiDrawBrush source;
+	uiDrawStrokeParams sp;
+	uiDrawPath *path;
+
+	crsourcergba(&source, 0, 0, 0, 1);
+	sp.Cap = uiDrawLineCapFlat;
+	sp.Join = uiDrawLineJoinMiter;
+	sp.MiterLimit = uiDrawDefaultMiterLimit;
+	sp.Dashes = NULL;
+	sp.NumDashes = 0;
+	sp.DashPhase = 0;
+
+	sp.Thickness = 40.96;
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigure(path, 76.8, 84.48);
+	uiDrawPathLineTo(path, 76.8 + 51.2, 84.48 -51.2);
+	uiDrawPathLineTo(path, 76.8 + 51.2 + 51.2, 84.48 - 51.2 + 51.2);
+	uiDrawPathEnd(path);
+	sp.Join = uiDrawLineJoinMiter;
+	uiDrawStroke(p->Context, path, &source, &sp);
+	uiDrawFreePath(path);
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigure(path, 76.8, 161.28);
+	uiDrawPathLineTo(path, 76.8 + 51.2, 161.28 -51.2);
+	uiDrawPathLineTo(path, 76.8 + 51.2 + 51.2, 161.28 - 51.2 + 51.2);
+	uiDrawPathEnd(path);
+	sp.Join = uiDrawLineJoinBevel;
+	uiDrawStroke(p->Context, path, &source, &sp);
+	uiDrawFreePath(path);
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigure(path, 76.8, 238.08);
+	uiDrawPathLineTo(path, 76.8 + 51.2, 238.08 -51.2);
+	uiDrawPathLineTo(path, 76.8 + 51.2 + 51.2, 238.08 - 51.2 + 51.2);
+	uiDrawPathEnd(path);
+	sp.Join = uiDrawLineJoinRound;
+	uiDrawStroke(p->Context, path, &source, &sp);
+	uiDrawFreePath(path);
+}
+
+// TODO text
+
+// TODO text align center
+
+// TODO text extents
+
+// Quartz 2D Programming Guide
+
+static void cgaddrect(uiDrawPath *path, uiAreaDrawParams *p, double x, double y, double width, double height)
+{
+	uiDrawPathAddRectangle(path,
+		x, p->AreaHeight - y - height,
+		width, height);
+}
+
+// Graphics Contexts > Creating a Window Graphics Context in Mac OS X
+static void drawQ2DCreateWindowGC(uiAreaDrawParams *p)
+{
+	uiDrawPath *path;
+	uiDrawBrush brush;
+
+	crsourcergba(&brush, 1, 0, 0, 1);
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	cgaddrect(path, p, 0, 0, 200, 100);
+	uiDrawPathEnd(path);
+	uiDrawFill(p->Context, path, &brush);
+	uiDrawFreePath(path);
+
+	crsourcergba(&brush, 0, 0, 1, .5);
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	cgaddrect(path, p, 0, 0, 100, 200);
+	uiDrawPathEnd(path);
+	uiDrawFill(p->Context, path, &brush);
+	uiDrawFreePath(path);
+}
+
+// TODO Patterns page?
+
+// TODO Shadows page?
+
+// TODO Gradients page (includes some circle-circle radial gradients)
+
+// TODO Transparency Layers page?
+
+// TODO Core Graphics Layer Drawing page?
+
+// Cocoa Drawing Guide
+
+// TODO Advanced Drawing Techniques page?
+
+// TODO Text page, if any?
+
+static const struct drawtest tests[] = {
+	{ "Original uiArea test", drawOriginal },
+	{ "Arc test", drawArcs },
+	{ "Direct2D: Direct2D Quickstart for Windows 8", drawD2DW8QS },
+	{ "Direct2D: Creating a Simple Direct2D Application", drawD2DSimpleApp },
+	{ "Direct2D: How to Create a Solid Color Brush", drawD2DSolidBrush },
+	{ "Direct2D: How to Create a Linear Gradient Brush", drawD2DLinearBrush },
+	{ "Direct2D: How to Create a Radial Gradient Brush", drawD2DRadialBrush },
+	{ "Direct2D: Path Geometries Overview", drawD2DPathGeometries },
+	{ "Direct2D: How to Create Geometry Groups", drawD2DGeometryGroup },
+	{ "Direct2D: How to Rotate an Object", drawD2DRotate },
+	{ "Direct2D: How to Scale an Object", drawD2DScale },
+	{ "Direct2D: How to Skew an Object", drawD2DSkew },
+	{ "Direct2D: How to Translate an Object", drawD2DTranslate },
+	{ "Direct2D: How to Apply Multiple Transforms to an Object", drawD2DMultiTransforms },
+	{ "Direct2D: How to Draw and Fill a Complex Shape", drawD2DComplexShape },
+	{ "cairo samples: arc", drawCSArc },
+	{ "cairo samples: arc negative", drawCSArcNegative },
+	{ "cairo samples: clip", drawCSClip },
+	{ "cairo samples: curve rectangle", drawCSCurveRectangle },
+	{ "cairo samples: curve to", drawCSCurveTo },
+	{ "cairo samples: dash", drawCSDash },
+	{ "cairo samples: fill and stroke2", drawCSFillAndStroke2 },
+	{ "cairo samples: fill style", drawCSFillStyle },
+	{ "cairo samples: multi segment caps", drawCSMultiCaps },
+	{ "cairo samples: rounded rectangle", drawCSRoundRect },
+	{ "cairo samples: set line cap", drawCSSetLineCap },
+	{ "cairo samples: set line join", drawCSSetLineJoin },
+	{ "Quartz 2D PG: Creating a Window Graphics Context in Mac OS X", drawQ2DCreateWindowGC },
+	{ NULL, NULL },
+};
+
+void runDrawTest(int n, uiAreaDrawParams *p)
+{
+	(*(tests[n].draw))(p);
+}
+
+void populateComboboxWithTests(uiCombobox *c)
+{
+	size_t i;
+
+	for (i = 0; tests[i].name != NULL; i++)
+		uiComboboxAppend(c, tests[i].name);
+}
diff --git a/src/libui_sdl/libui/test/images/andlabs_16x16test_24june2016.png b/src/libui_sdl/libui/test/images/andlabs_16x16test_24june2016.png
new file mode 100644
index 0000000..a4c27d9
--- /dev/null
+++ b/src/libui_sdl/libui/test/images/andlabs_16x16test_24june2016.png
diff --git a/src/libui_sdl/libui/test/images/andlabs_32x32test_24june2016.png b/src/libui_sdl/libui/test/images/andlabs_32x32test_24june2016.png
new file mode 100644
index 0000000..e1c33fc
--- /dev/null
+++ b/src/libui_sdl/libui/test/images/andlabs_32x32test_24june2016.png
diff --git a/src/libui_sdl/libui/test/images/gen.go b/src/libui_sdl/libui/test/images/gen.go
new file mode 100644
index 0000000..910abc7
--- /dev/null
+++ b/src/libui_sdl/libui/test/images/gen.go
@@ -0,0 +1,98 @@
+// 25 june 2016
+package main
+
+import (
+	"fmt"
+	"os"
+	"image"
+	"image/draw"
+	_ "image/png"
+)
+
+type img struct {
+	filename	string
+	data		[]byte
+	width	int
+	height	int
+	stride	int
+}
+
+func main() {
+	if len(os.Args[1:]) == 0 {
+		panic("no files specified")
+	}
+
+	images := make([]*img, 0, len(os.Args[1:]))
+	for _, fn := range os.Args[1:] {
+		f, err := os.Open(fn)
+		if err != nil {
+			panic(err)
+		}
+		ii, _, err := image.Decode(f)
+		if err != nil {
+			panic(err)
+		}
+		f.Close()
+
+		i := image.NewRGBA(ii.Bounds())
+		draw.Draw(i, i.Rect, ii, ii.Bounds().Min, draw.Src)
+
+		im := &img{
+			filename:		fn,
+			data:			i.Pix,
+			width:		i.Rect.Dx(),
+			height:		i.Rect.Dy(),
+			stride:		i.Stride,
+		}
+		images = append(images, im)
+	}
+
+	fmt.Println("// auto-generated by images/gen.go")
+	fmt.Println("#include \"test.h\"")
+	fmt.Println()
+	for i, im := range images {
+		fmt.Printf("static const uint32_t dat%d[] = {", i)
+		for j := 0; j < len(im.data); j += 4 {
+			if (j % (16 * 4)) == 0 {
+				fmt.Printf("\n\t")
+			} else {
+				fmt.Printf(" ")
+			}
+			d := uint32(im.data[j + 0]) << 16
+			d |= uint32(im.data[j + 1]) << 8
+			d |= uint32(im.data[j + 2])
+			d |= uint32(im.data[j + 3]) << 24
+			fmt.Printf("0x%08X,", d)
+
+		}
+		fmt.Println("\n};")
+		fmt.Println()
+	}
+	fmt.Println("static const struct {")
+	fmt.Println("	const char *name;")
+	fmt.Println("	void *data;")
+	fmt.Println("	int width;")
+	fmt.Println("	int height;")
+	fmt.Println("	int stride;")
+	fmt.Println("} files[] = {")
+	for i, im := range images {
+		fmt.Printf("	{ %q, dat%d, %d, %d, %d },\n",
+			im.filename, i, im.width, im.height, im.stride)
+	}
+	fmt.Println("};")
+	fmt.Println()
+	fmt.Println("void appendImageNamed(uiImage *img, const char *name)")
+	fmt.Println("{")
+	fmt.Println("	int i;")
+	fmt.Println("")
+	fmt.Println("	i = 0;")
+	fmt.Println("	for (;;) {")
+	fmt.Println("		if (strcmp(name, files[i].name) == 0) {")
+	fmt.Println("			uiImageAppend(img, files[i].data, files[i].width, files[i].height, files[i].stride);")
+	fmt.Println("			return;")
+	fmt.Println("		}")
+	fmt.Println("		i++;")
+	fmt.Println("	}")
+	fmt.Println("}")
+	fmt.Println()
+}
diff --git a/src/libui_sdl/libui/test/images/tango-icon-theme-0.8.90_16x16_x-office-spreadsheet.png b/src/libui_sdl/libui/test/images/tango-icon-theme-0.8.90_16x16_x-office-spreadsheet.png
new file mode 100644
index 0000000..a6b1268
--- /dev/null
+++ b/src/libui_sdl/libui/test/images/tango-icon-theme-0.8.90_16x16_x-office-spreadsheet.png
diff --git a/src/libui_sdl/libui/test/images/tango-icon-theme-0.8.90_32x32_x-office-spreadsheet.png b/src/libui_sdl/libui/test/images/tango-icon-theme-0.8.90_32x32_x-office-spreadsheet.png
new file mode 100644
index 0000000..c0ccb7a
--- /dev/null
+++ b/src/libui_sdl/libui/test/images/tango-icon-theme-0.8.90_32x32_x-office-spreadsheet.png
diff --git a/src/libui_sdl/libui/test/main.c b/src/libui_sdl/libui/test/main.c
new file mode 100644
index 0000000..18774dc
--- /dev/null
+++ b/src/libui_sdl/libui/test/main.c
@@ -0,0 +1,180 @@
+// 22 april 2015
+#include "test.h"
+
+// TODOs
+// - blank page affects menus negatively on Windows
+
+void die(const char *fmt, ...)
+{
+	va_list ap;
+
+	va_start(ap, fmt);
+	fprintf(stderr, "[test program] ");
+	vfprintf(stderr, fmt, ap);
+	fprintf(stderr, "\n");
+	va_end(ap);
+	abort();
+}
+
+int onClosing(uiWindow *w, void *data)
+{
+	printf("in onClosing()\n");
+	uiQuit();
+	return 1;
+}
+
+int onShouldQuit(void *data)
+{
+	printf("in onShouldQuit()\n");
+	if (uiMenuItemChecked(shouldQuitItem)) {
+		uiControlDestroy(uiControl(data));
+		return 1;
+	}
+	return 0;
+}
+
+uiBox *mainBox;
+uiTab *mainTab;
+
+uiBox *(*newhbox)(void);
+uiBox *(*newvbox)(void);
+
+int main(int argc, char *argv[])
+{
+	uiInitOptions o;
+	int i;
+	const char *err;
+	uiWindow *w;
+	uiBox *page2, *page3, *page4, *page5;
+	uiBox *page6, *page7, *page8, *page9, *page10;
+	uiBox *page11, *page12, *page13;
+	uiTab *page14;
+	uiBox *page15;
+	uiBox *page16;
+	uiTab *outerTab;
+	uiTab *innerTab;
+	int nomenus = 0;
+	int startspaced = 0;
+	int steps = 0;
+
+	newhbox = uiNewHorizontalBox;
+	newvbox = uiNewVerticalBox;
+
+	memset(&o, 0, sizeof (uiInitOptions));
+	for (i = 1; i < argc; i++)
+		if (strcmp(argv[i], "nomenus") == 0)
+			nomenus = 1;
+		else if (strcmp(argv[i], "startspaced") == 0)
+			startspaced = 1;
+		else if (strcmp(argv[i], "swaphv") == 0) {
+			newhbox = uiNewVerticalBox;
+			newvbox = uiNewHorizontalBox;
+		} else if (strcmp(argv[i], "steps") == 0)
+			steps = 1;
+		else {
+			fprintf(stderr, "%s: unrecognized option %s\n", argv[0], argv[i]);
+			return 1;
+		}
+
+	err = uiInit(&o);
+	if (err != NULL) {
+		fprintf(stderr, "error initializing ui: %s\n", err);
+		uiFreeInitError(err);
+		return 1;
+	}
+
+	if (!nomenus)
+		initMenus();
+
+	w = newWindow("Main Window", 320, 240, 1);
+	uiWindowOnClosing(w, onClosing, NULL);
+	printf("main window %p\n", (void *) w);
+
+	uiOnShouldQuit(onShouldQuit, w);
+
+	mainBox = newHorizontalBox();
+	uiWindowSetChild(w, uiControl(mainBox));
+
+	outerTab = newTab();
+	uiBoxAppend(mainBox, uiControl(outerTab), 1);
+
+	mainTab = newTab();
+	uiTabAppend(outerTab, "Pages 1-5", uiControl(mainTab));
+
+	// page 1 uses page 2's uiGroup
+	page2 = makePage2();
+
+	makePage1(w);
+	uiTabAppend(mainTab, "Page 1", uiControl(page1));
+
+	uiTabAppend(mainTab, "Page 2", uiControl(page2));
+
+	uiTabAppend(mainTab, "Empty Page", uiControl(uiNewHorizontalBox()));
+
+	page3 = makePage3();
+	uiTabAppend(mainTab, "Page 3", uiControl(page3));
+
+	page4 = makePage4();
+	uiTabAppend(mainTab, "Page 4", uiControl(page4));
+
+	page5 = makePage5(w);
+	uiTabAppend(mainTab, "Page 5", uiControl(page5));
+
+	innerTab = newTab();
+	uiTabAppend(outerTab, "Pages 6-10", uiControl(innerTab));
+
+	page6 = makePage6();
+	uiTabAppend(innerTab, "Page 6", uiControl(page6));
+
+	page7 = makePage7();
+	uiTabAppend(innerTab, "Page 7", uiControl(page7));
+
+	page8 = makePage8();
+	uiTabAppend(innerTab, "Page 8", uiControl(page8));
+
+	page9 = makePage9();
+	uiTabAppend(innerTab, "Page 9", uiControl(page9));
+
+	page10 = makePage10();
+	uiTabAppend(innerTab, "Page 10", uiControl(page10));
+
+	innerTab = newTab();
+	uiTabAppend(outerTab, "Pages 11-15", uiControl(innerTab));
+
+//	page11 = makePage11();
+//	uiTabAppend(innerTab, "Page 11", uiControl(page11));
+
+	page12 = makePage12();
+	uiTabAppend(innerTab, "Page 12", uiControl(page12));
+
+	page13 = makePage13();
+	uiTabAppend(innerTab, "Page 13", uiControl(page13));
+
+	page14 = makePage14();
+	uiTabAppend(innerTab, "Page 14", uiControl(page14));
+
+	page15 = makePage15(w);
+	uiTabAppend(innerTab, "Page 15", uiControl(page15));
+
+	innerTab = newTab();
+	uiTabAppend(outerTab, "Pages 16-?", uiControl(innerTab));
+
+//	page16 = makePage16();
+//	uiTabAppend(innerTab, "Page 16", uiControl(page16));
+
+	if (startspaced)
+		setSpaced(1);
+
+	uiControlShow(uiControl(w));
+	if (!steps)
+		uiMain();
+	else {
+		uiMainSteps();
+		while (uiMainStep(1))
+			;
+	}
+	printf("after uiMain()\n");
+	uiUninit();
+	printf("after uiUninit()\n");
+	return 0;
+}
diff --git a/src/libui_sdl/libui/test/menus.c b/src/libui_sdl/libui/test/menus.c
new file mode 100644
index 0000000..87ff80a
--- /dev/null
+++ b/src/libui_sdl/libui/test/menus.c
@@ -0,0 +1,112 @@
+// 23 april 2015
+#include "test.h"
+
+uiMenu *fileMenu;
+uiMenuItem *newItem;
+uiMenuItem *openItem;
+uiMenuItem *shouldQuitItem;
+uiMenuItem *quitItem;
+uiMenu *editMenu;
+uiMenuItem *undoItem;
+uiMenuItem *checkItem;
+uiMenuItem *accelItem;
+uiMenuItem *prefsItem;
+uiMenu *testMenu;
+uiMenuItem *enabledItem;
+uiMenuItem *enableThisItem;
+uiMenuItem *forceCheckedItem;
+uiMenuItem *forceUncheckedItem;
+uiMenuItem *whatWindowItem;
+uiMenu *moreTestsMenu;
+uiMenuItem *quitEnabledItem;
+uiMenuItem *prefsEnabledItem;
+uiMenuItem *aboutEnabledItem;
+uiMenuItem *checkEnabledItem;
+uiMenu *multiMenu;
+uiMenu *helpMenu;
+uiMenuItem *helpItem;
+uiMenuItem *aboutItem;
+
+static void enableItemTest(uiMenuItem *item, uiWindow *w, void *data)
+{
+	if (uiMenuItemChecked(item))
+		uiMenuItemEnable(uiMenuItem(data));
+	else
+		uiMenuItemDisable(uiMenuItem(data));
+}
+
+static void forceOn(uiMenuItem *item, uiWindow *w, void *data)
+{
+	uiMenuItemSetChecked(enabledItem, 1);
+}
+
+static void forceOff(uiMenuItem *item, uiWindow *w, void *data)
+{
+	uiMenuItemSetChecked(enabledItem, 0);
+}
+
+static void whatWindow(uiMenuItem *item, uiWindow *w, void *data)
+{
+	printf("menu item clicked on window %p\n", (void *) w);
+}
+
+void initMenus(void)
+{
+	fileMenu = uiNewMenu("File");
+	newItem = uiMenuAppendItem(fileMenu, "New");
+	openItem = uiMenuAppendItem(fileMenu, "Open");
+	uiMenuAppendSeparator(fileMenu);
+	shouldQuitItem = uiMenuAppendCheckItem(fileMenu, "Should Quit");
+	quitItem = uiMenuAppendQuitItem(fileMenu);
+
+	editMenu = uiNewMenu("Edit");
+	undoItem = uiMenuAppendItem(editMenu, "Undo");
+	uiMenuItemDisable(undoItem);
+	uiMenuAppendSeparator(editMenu);
+	checkItem = uiMenuAppendCheckItem(editMenu, "Check Me\tTest");
+	accelItem = uiMenuAppendItem(editMenu, "A&ccele&&rator T_es__t");
+	prefsItem = uiMenuAppendPreferencesItem(editMenu);
+
+	testMenu = uiNewMenu("Test");
+	enabledItem = uiMenuAppendCheckItem(testMenu, "Enable Below Item");
+	uiMenuItemSetChecked(enabledItem, 1);
+	enableThisItem = uiMenuAppendItem(testMenu, "This Will Be Enabled");
+	uiMenuItemOnClicked(enabledItem, enableItemTest, enableThisItem);
+	forceCheckedItem = uiMenuAppendItem(testMenu, "Force Above Checked");
+	uiMenuItemOnClicked(forceCheckedItem, forceOn, NULL);
+	forceUncheckedItem = uiMenuAppendItem(testMenu, "Force Above Unchecked");
+	uiMenuItemOnClicked(forceUncheckedItem, forceOff, NULL);
+	uiMenuAppendSeparator(testMenu);
+	whatWindowItem = uiMenuAppendItem(testMenu, "What Window?");
+	uiMenuItemOnClicked(whatWindowItem, whatWindow, NULL);
+
+	moreTestsMenu = uiNewMenu("More Tests");
+	quitEnabledItem = uiMenuAppendCheckItem(moreTestsMenu, "Quit Item Enabled");
+	uiMenuItemSetChecked(quitEnabledItem, 1);
+	prefsEnabledItem = uiMenuAppendCheckItem(moreTestsMenu, "Preferences Item Enabled");
+	uiMenuItemSetChecked(prefsEnabledItem, 1);
+	aboutEnabledItem = uiMenuAppendCheckItem(moreTestsMenu, "About Item Enabled");
+	uiMenuItemSetChecked(aboutEnabledItem, 1);
+	uiMenuAppendSeparator(moreTestsMenu);
+	checkEnabledItem = uiMenuAppendCheckItem(moreTestsMenu, "Check Me Item Enabled");
+	uiMenuItemSetChecked(checkEnabledItem, 1);
+
+	multiMenu = uiNewMenu("Multi");
+	uiMenuAppendSeparator(multiMenu);
+	uiMenuAppendSeparator(multiMenu);
+	uiMenuAppendItem(multiMenu, "Item && Item && Item");
+	uiMenuAppendSeparator(multiMenu);
+	uiMenuAppendSeparator(multiMenu);
+	uiMenuAppendItem(multiMenu, "Item __ Item __ Item");
+	uiMenuAppendSeparator(multiMenu);
+	uiMenuAppendSeparator(multiMenu);
+
+	helpMenu = uiNewMenu("Help");
+	helpItem = uiMenuAppendItem(helpMenu, "Help");
+	aboutItem = uiMenuAppendAboutItem(helpMenu);
+
+	uiMenuItemOnClicked(quitEnabledItem, enableItemTest, quitItem);
+	uiMenuItemOnClicked(prefsEnabledItem, enableItemTest, prefsItem);
+	uiMenuItemOnClicked(aboutEnabledItem, enableItemTest, aboutItem);
+	uiMenuItemOnClicked(checkEnabledItem, enableItemTest, checkItem);
+}
diff --git a/src/libui_sdl/libui/test/page1.c b/src/libui_sdl/libui/test/page1.c
new file mode 100644
index 0000000..2115ba2
--- /dev/null
+++ b/src/libui_sdl/libui/test/page1.c
@@ -0,0 +1,171 @@
+// 29 april 2015
+#include "test.h"
+
+static uiEntry *entry;
+static uiCheckbox *spaced;
+
+#define TEXT(name, type, getter, setter) \
+	static void get ## name ## Text(uiButton *b, void *data) \
+	{ \
+		char *text; \
+		text = getter(type(data)); \
+		uiEntrySetText(entry, text); \
+		uiFreeText(text); \
+	} \
+	static void set ## name ## Text(uiButton *b, void *data) \
+	{ \
+		char *text; \
+		text = uiEntryText(entry); \
+		setter(type(data), text); \
+		uiFreeText(text); \
+	}
+TEXT(Window, uiWindow, uiWindowTitle, uiWindowSetTitle)
+TEXT(Button, uiButton, uiButtonText, uiButtonSetText)
+TEXT(Checkbox, uiCheckbox, uiCheckboxText, uiCheckboxSetText)
+TEXT(Label, uiLabel, uiLabelText, uiLabelSetText)
+TEXT(Group, uiGroup, uiGroupTitle, uiGroupSetTitle)
+
+static void onChanged(uiEntry *e, void *data)
+{
+	printf("onChanged()\n");
+}
+
+static void toggleSpaced(uiCheckbox *c, void *data)
+{
+	setSpaced(uiCheckboxChecked(spaced));
+}
+
+static void forceSpaced(uiButton *b, void *data)
+{
+	uiCheckboxSetChecked(spaced, data != NULL);
+}
+
+static void showSpaced(uiButton *b, void *data)
+{
+	char s[12];
+
+	querySpaced(s);
+	uiEntrySetText(entry, s);
+}
+
+#define SHED(method, Method) \
+	static void method ## Control(uiButton *b, void *data) \
+	{ \
+		uiControl ## Method(uiControl(data)); \
+	}
+SHED(show, Show)
+SHED(hide, Hide)
+SHED(enable, Enable)
+SHED(disable, Disable)
+
+uiBox *page1;
+
+void makePage1(uiWindow *w)
+{
+	uiButton *getButton, *setButton;
+	uiBox *hbox;
+	uiBox *testBox;
+	uiLabel *label;
+
+	page1 = newVerticalBox();
+
+	entry = uiNewEntry();
+	uiEntryOnChanged(entry, onChanged, NULL);
+	uiBoxAppend(page1, uiControl(entry), 0);
+
+	spaced = uiNewCheckbox("Spaced");
+	uiCheckboxOnToggled(spaced, toggleSpaced, NULL);
+	label = uiNewLabel("Label");
+
+	hbox = newHorizontalBox();
+	getButton = uiNewButton("Get Window Text");
+	uiButtonOnClicked(getButton, getWindowText, w);
+	setButton = uiNewButton("Set Window Text");
+	uiButtonOnClicked(setButton, setWindowText, w);
+	uiBoxAppend(hbox, uiControl(getButton), 1);
+	uiBoxAppend(hbox, uiControl(setButton), 1);
+	uiBoxAppend(page1, uiControl(hbox), 0);
+
+	hbox = newHorizontalBox();
+	getButton = uiNewButton("Get Button Text");
+	uiButtonOnClicked(getButton, getButtonText, getButton);
+	setButton = uiNewButton("Set Button Text");
+	uiButtonOnClicked(setButton, setButtonText, getButton);
+	uiBoxAppend(hbox, uiControl(getButton), 1);
+	uiBoxAppend(hbox, uiControl(setButton), 1);
+	uiBoxAppend(page1, uiControl(hbox), 0);
+
+	hbox = newHorizontalBox();
+	getButton = uiNewButton("Get Checkbox Text");
+	uiButtonOnClicked(getButton, getCheckboxText, spaced);
+	setButton = uiNewButton("Set Checkbox Text");
+	uiButtonOnClicked(setButton, setCheckboxText, spaced);
+	uiBoxAppend(hbox, uiControl(getButton), 1);
+	uiBoxAppend(hbox, uiControl(setButton), 1);
+	uiBoxAppend(page1, uiControl(hbox), 0);
+
+	hbox = newHorizontalBox();
+	getButton = uiNewButton("Get Label Text");
+	uiButtonOnClicked(getButton, getLabelText, label);
+	setButton = uiNewButton("Set Label Text");
+	uiButtonOnClicked(setButton, setLabelText, label);
+	uiBoxAppend(hbox, uiControl(getButton), 1);
+	uiBoxAppend(hbox, uiControl(setButton), 1);
+	uiBoxAppend(page1, uiControl(hbox), 0);
+
+	hbox = newHorizontalBox();
+	getButton = uiNewButton("Get Group Text");
+	uiButtonOnClicked(getButton, getGroupText, page2group);
+	setButton = uiNewButton("Set Group Text");
+	uiButtonOnClicked(setButton, setGroupText, page2group);
+	uiBoxAppend(hbox, uiControl(getButton), 1);
+	uiBoxAppend(hbox, uiControl(setButton), 1);
+	uiBoxAppend(page1, uiControl(hbox), 0);
+
+	hbox = newHorizontalBox();
+	uiBoxAppend(hbox, uiControl(spaced), 1);
+	getButton = uiNewButton("On");
+	uiButtonOnClicked(getButton, forceSpaced, getButton);
+	uiBoxAppend(hbox, uiControl(getButton), 0);
+	getButton = uiNewButton("Off");
+	uiButtonOnClicked(getButton, forceSpaced, NULL);
+	uiBoxAppend(hbox, uiControl(getButton), 0);
+	getButton = uiNewButton("Show");
+	uiButtonOnClicked(getButton, showSpaced, NULL);
+	uiBoxAppend(hbox, uiControl(getButton), 0);
+	uiBoxAppend(page1, uiControl(hbox), 0);
+
+	testBox = newHorizontalBox();
+	setButton = uiNewButton("Button");
+	uiBoxAppend(testBox, uiControl(setButton), 1);
+	getButton = uiNewButton("Show");
+	uiButtonOnClicked(getButton, showControl, setButton);
+	uiBoxAppend(testBox, uiControl(getButton), 0);
+	getButton = uiNewButton("Hide");
+	uiButtonOnClicked(getButton, hideControl, setButton);
+	uiBoxAppend(testBox, uiControl(getButton), 0);
+	getButton = uiNewButton("Enable");
+	uiButtonOnClicked(getButton, enableControl, setButton);
+	uiBoxAppend(testBox, uiControl(getButton), 0);
+	getButton = uiNewButton("Disable");
+	uiButtonOnClicked(getButton, disableControl, setButton);
+	uiBoxAppend(testBox, uiControl(getButton), 0);
+	uiBoxAppend(page1, uiControl(testBox), 0);
+
+	hbox = newHorizontalBox();
+	getButton = uiNewButton("Show Box");
+	uiButtonOnClicked(getButton, showControl, testBox);
+	uiBoxAppend(hbox, uiControl(getButton), 1);
+	getButton = uiNewButton("Hide Box");
+	uiButtonOnClicked(getButton, hideControl, testBox);
+	uiBoxAppend(hbox, uiControl(getButton), 1);
+	getButton = uiNewButton("Enable Box");
+	uiButtonOnClicked(getButton, enableControl, testBox);
+	uiBoxAppend(hbox, uiControl(getButton), 1);
+	getButton = uiNewButton("Disable Box");
+	uiButtonOnClicked(getButton, disableControl, testBox);
+	uiBoxAppend(hbox, uiControl(getButton), 1);
+	uiBoxAppend(page1, uiControl(hbox), 0);
+
+	uiBoxAppend(page1, uiControl(label), 0);
+}
diff --git a/src/libui_sdl/libui/test/page10.c b/src/libui_sdl/libui/test/page10.c
new file mode 100644
index 0000000..d7f26a7
--- /dev/null
+++ b/src/libui_sdl/libui/test/page10.c
@@ -0,0 +1,185 @@
+// 22 december 2015
+#include "test.h"
+
+static uiEntry *textString;
+static uiFontButton *textFontButton;
+static uiColorButton *textColorButton;
+static uiEntry *textWidth;
+static uiButton *textApply;
+static uiCheckbox *noZ;
+static uiArea *textArea;
+static uiAreaHandler textAreaHandler;
+
+static double entryDouble(uiEntry *e)
+{
+	char *s;
+	double d;
+
+	s = uiEntryText(e);
+	d = atof(s);
+	uiFreeText(s);
+	return d;
+}
+
+static void handlerDraw(uiAreaHandler *a, uiArea *area, uiAreaDrawParams *dp)
+{
+	uiDrawTextFont *font;
+	uiDrawTextLayout *layout;
+	double r, g, b, al;
+	char surrogates[1 + 4 + 1 + 1];
+	char composed[2 + 2 + 2 + 3 + 2 + 1];
+	double width, height;
+
+	font = uiFontButtonFont(textFontButton);
+
+	layout = uiDrawNewTextLayout("One two three four", font, -1);
+	uiDrawTextLayoutSetColor(layout,
+		4, 7,
+		1, 0, 0, 1);
+	uiDrawTextLayoutSetColor(layout,
+		8, 14,
+		1, 0, 0.5, 0.5);
+	uiColorButtonColor(textColorButton, &r, &g, &b, &al);
+	uiDrawTextLayoutSetColor(layout,
+		14, 18,
+		r, g, b, al);
+	uiDrawText(dp->Context, 10, 10, layout);
+	uiDrawTextLayoutExtents(layout, &width, &height);
+	uiDrawFreeTextLayout(layout);
+
+	surrogates[0] = 'x';
+	surrogates[1] = 0xF0;		// surrogates D800 DF08
+	surrogates[2] = 0x90;
+	surrogates[3] = 0x8C;
+	surrogates[4] = 0x88;
+	surrogates[5] = 'y';
+	surrogates[6] = '\0';
+
+	layout = uiDrawNewTextLayout(surrogates, font, -1);
+	uiDrawTextLayoutSetColor(layout,
+		1, 2,
+		1, 0, 0.5, 0.5);
+	uiDrawText(dp->Context, 10, 10 + height, layout);
+	uiDrawFreeTextLayout(layout);
+
+	composed[0] = 'z';
+	composed[1] = 'z';
+	composed[2] = 0xC3;		// 2
+	composed[3] = 0xA9;
+	composed[4] = 'z';
+	composed[5] = 'z';
+	composed[6] = 0x65;		// 5
+	composed[7] = 0xCC;
+	composed[8] = 0x81;
+	composed[9] = 'z';
+	composed[10] = 'z';
+	composed[11] = '\0';
+
+	layout = uiDrawNewTextLayout(composed, font, -1);
+	uiDrawTextLayoutSetColor(layout,
+		2, 3,
+		1, 0, 0.5, 0.5);
+	uiDrawTextLayoutSetColor(layout,
+		5, 6,
+		1, 0, 0.5, 0.5);
+	if (!uiCheckboxChecked(noZ))
+		uiDrawTextLayoutSetColor(layout,
+			6, 7,
+			0.5, 0, 1, 0.5);
+	uiDrawText(dp->Context, 10, 10 + height + height, layout);
+	uiDrawFreeTextLayout(layout);
+
+	uiDrawFreeTextFont(font);
+}
+
+static void handlerMouseEvent(uiAreaHandler *a, uiArea *area, uiAreaMouseEvent *e)
+{
+	// do nothing
+}
+
+static void handlerMouseCrossed(uiAreaHandler *ah, uiArea *a, int left)
+{
+	// do nothing
+}
+
+static void handlerDragBroken(uiAreaHandler *ah, uiArea *a)
+{
+	// do nothing
+}
+
+static int handlerKeyEvent(uiAreaHandler *ah, uiArea *a, uiAreaKeyEvent *e)
+{
+	// do nothing
+	return 0;
+}
+
+static void onFontChanged(uiFontButton *b, void *data)
+{
+	uiAreaQueueRedrawAll(textArea);
+}
+
+static void onColorChanged(uiColorButton *b, void *data)
+{
+	uiAreaQueueRedrawAll(textArea);
+}
+
+static void onNoZ(uiCheckbox *b, void *data)
+{
+	uiAreaQueueRedrawAll(textArea);
+}
+
+uiBox *makePage10(void)
+{
+	uiBox *page10;
+	uiBox *vbox;
+	uiBox *hbox;
+
+	page10 = newVerticalBox();
+	vbox = page10;
+
+	hbox = newHorizontalBox();
+	uiBoxAppend(vbox, uiControl(hbox), 0);
+
+	textString = uiNewEntry();
+	// TODO make it placeholder
+	uiEntrySetText(textString, "Enter text here");
+	uiBoxAppend(hbox, uiControl(textString), 1);
+
+	textFontButton = uiNewFontButton();
+	uiFontButtonOnChanged(textFontButton, onFontChanged, NULL);
+	uiBoxAppend(hbox, uiControl(textFontButton), 1);
+
+	textColorButton = uiNewColorButton();
+	uiColorButtonOnChanged(textColorButton, onColorChanged, NULL);
+	uiBoxAppend(hbox, uiControl(textColorButton), 1);
+
+	hbox = newHorizontalBox();
+	uiBoxAppend(vbox, uiControl(hbox), 0);
+
+	textApply = uiNewButton("Apply");
+	uiBoxAppend(hbox, uiControl(textApply), 1);
+
+	textWidth = uiNewEntry();
+	uiEntrySetText(textWidth, "-1");
+	uiBoxAppend(hbox, uiControl(textWidth), 1);
+
+	noZ = uiNewCheckbox("No Z Color");
+	uiCheckboxOnToggled(noZ, onNoZ, NULL);
+	uiBoxAppend(hbox, uiControl(noZ), 0);
+
+	textAreaHandler.Draw = handlerDraw;
+	textAreaHandler.MouseEvent = handlerMouseEvent;
+	textAreaHandler.MouseCrossed = handlerMouseCrossed;
+	textAreaHandler.DragBroken = handlerDragBroken;
+	textAreaHandler.KeyEvent = handlerKeyEvent;
+	textArea = uiNewArea(&textAreaHandler);
+	uiBoxAppend(vbox, uiControl(textArea), 1);
+
+	// dummy objects to test single-activation
+	hbox = newHorizontalBox();
+	uiBoxAppend(vbox, uiControl(hbox), 0);
+	uiBoxAppend(hbox, uiControl(uiNewFontButton()), 1);
+	uiBoxAppend(hbox, uiControl(uiNewColorButton()), 1);
+
+	return page10;
+}
diff --git a/src/libui_sdl/libui/test/page11.c b/src/libui_sdl/libui/test/page11.c
new file mode 100644
index 0000000..02ad213
--- /dev/null
+++ b/src/libui_sdl/libui/test/page11.c
@@ -0,0 +1,54 @@
+// 14 may 2016
+#include "test.h"
+
+// TODO add a test for childless windows
+// TODO add tests for contianers with all controls hidden
+
+static uiGroup *newg(const char *n, int s)
+{
+	uiGroup *g;
+
+	g = uiNewGroup(n);
+	if (s)
+		uiGroupSetChild(g, NULL);
+	return g;
+}
+
+static uiTab *newt(int tt)
+{
+	uiTab *t;
+
+	t = uiNewTab();
+	if (tt)
+		uiTabAppend(t, "Test", NULL);
+	return t;
+}
+
+uiBox *makePage11(void)
+{
+	uiBox *page11;
+	uiBox *ns;
+	uiBox *s;
+
+	page11 = newHorizontalBox();
+
+	ns = newVerticalBox();
+	uiBoxAppend(ns, uiControl(newg("", 0)), 0);
+	uiBoxAppend(ns, uiControl(newg("", 1)), 0);
+	uiBoxAppend(ns, uiControl(newg("Group", 0)), 0);
+	uiBoxAppend(ns, uiControl(newg("Group", 1)), 0);
+	uiBoxAppend(ns, uiControl(newt(0)), 0);
+	uiBoxAppend(ns, uiControl(newt(1)), 0);
+	uiBoxAppend(page11, uiControl(ns), 1);
+
+	s = newVerticalBox();
+	uiBoxAppend(s, uiControl(newg("", 0)), 1);
+	uiBoxAppend(s, uiControl(newg("", 1)), 1);
+	uiBoxAppend(s, uiControl(newg("Group", 0)), 1);
+	uiBoxAppend(s, uiControl(newg("Group", 1)), 1);
+	uiBoxAppend(s, uiControl(newt(0)), 1);
+	uiBoxAppend(s, uiControl(newt(1)), 1);
+	uiBoxAppend(page11, uiControl(s), 1);
+
+	return page11;
+}
diff --git a/src/libui_sdl/libui/test/page12.c b/src/libui_sdl/libui/test/page12.c
new file mode 100644
index 0000000..5a8e963
--- /dev/null
+++ b/src/libui_sdl/libui/test/page12.c
@@ -0,0 +1,60 @@
+// 22 may 2016
+#include "test.h"
+
+// TODO OS X: if the hboxes are empty, the text views don't show up
+
+static void meChanged(uiMultilineEntry *e, void *data)
+{
+	printf("%s changed\n", (char *) data);
+}
+
+static void setClicked(uiButton *b, void *data)
+{
+	uiMultilineEntrySetText(uiMultilineEntry(data), "set");
+}
+
+static void appendClicked(uiButton *b, void *data)
+{
+	uiMultilineEntryAppend(uiMultilineEntry(data), "append\n");
+}
+
+static uiBox *half(uiMultilineEntry *(*mk)(void), const char *which)
+{
+	uiBox *vbox, *hbox;
+	uiMultilineEntry *me;
+	uiButton *button;
+
+	vbox = newVerticalBox();
+
+	me = (*mk)();
+	uiMultilineEntryOnChanged(me, meChanged, (void *) which);
+	uiBoxAppend(vbox, uiControl(me), 1);
+
+	hbox = newHorizontalBox();
+	uiBoxAppend(vbox, uiControl(hbox), 0);
+
+	button = uiNewButton("Set");
+	uiButtonOnClicked(button, setClicked, me);
+	uiBoxAppend(hbox, uiControl(button), 0);
+
+	button = uiNewButton("Append");
+	uiButtonOnClicked(button, appendClicked, me);
+	uiBoxAppend(hbox, uiControl(button), 0);
+
+	return vbox;
+}
+
+uiBox *makePage12(void)
+{
+	uiBox *page12;
+	uiBox *b;
+
+	page12 = newHorizontalBox();
+
+	b = half(uiNewMultilineEntry, "wrap");
+	uiBoxAppend(page12, uiControl(b), 1);
+	b = half(uiNewNonWrappingMultilineEntry, "no wrap");
+	uiBoxAppend(page12, uiControl(b), 1);
+
+	return page12;
+}
diff --git a/src/libui_sdl/libui/test/page13.c b/src/libui_sdl/libui/test/page13.c
new file mode 100644
index 0000000..5e6fd52
--- /dev/null
+++ b/src/libui_sdl/libui/test/page13.c
@@ -0,0 +1,157 @@
+// 28 may 2016
+#include "test.h"
+
+static int winClose(uiWindow *w, void *data)
+{
+	return 1;
+}
+
+static void openTestWindow(uiBox *(*mkf)(void))
+{
+	uiWindow *w;
+	uiBox *b;
+	uiCombobox *c;
+	uiEditableCombobox *e;
+	uiRadioButtons *r;
+
+	w = uiNewWindow("Test", 100, 100, 0);
+	uiWindowOnClosing(w, winClose, NULL);
+	uiWindowSetMargined(w, 1);
+	b = (*mkf)();
+	uiWindowSetChild(w, uiControl(b));
+
+#define BA(x) uiBoxAppend(b, uiControl(x), 0)
+	BA(uiNewButton(""));
+	BA(uiNewCheckbox(""));
+	BA(uiNewEntry());
+	BA(uiNewLabel(""));
+	BA(uiNewSpinbox(0, 100));
+	BA(uiNewProgressBar());
+	BA(uiNewSlider(0, 100));
+	BA(uiNewHorizontalSeparator());
+	c = uiNewCombobox();
+	uiComboboxAppend(c, "");
+	BA(c);
+	e = uiNewEditableCombobox();
+	uiEditableComboboxAppend(e, "");
+	BA(e);
+	r = uiNewRadioButtons();
+	uiRadioButtonsAppend(r, "");
+	BA(r);
+	BA(uiNewDateTimePicker());
+	BA(uiNewDatePicker());
+	BA(uiNewTimePicker());
+	BA(uiNewMultilineEntry());
+	// TODO nonscrolling and scrolling areas?
+	BA(uiNewFontButton());
+	BA(uiNewColorButton());
+	BA(uiNewPasswordEntry());
+	BA(uiNewSearchEntry());
+	BA(uiNewVerticalSeparator());
+
+	uiControlShow(uiControl(w));
+}
+
+static void buttonClicked(uiButton *b, void *data)
+{
+	openTestWindow((uiBox *(*)(void)) data);
+}
+
+static void entryChanged(uiEntry *e, void *data)
+{
+	char *text;
+
+	text = uiEntryText(e);
+	printf("%s entry changed: %s\n", (const char *) data, text);
+	uiFreeText(text);
+}
+
+static void showHide(uiButton *b, void *data)
+{
+	uiControl *c = uiControl(data);
+
+	if (uiControlVisible(c))
+		uiControlHide(c);
+	else
+		uiControlShow(c);
+}
+
+static void setIndeterminate(uiButton *b, void *data)
+{
+	uiProgressBar *p = uiProgressBar(data);
+	int value;
+
+	value = uiProgressBarValue(p);
+	if (value == -1)
+		value = 50;
+	else
+		value = -1;
+	uiProgressBarSetValue(p, value);
+}
+
+static void deleteFirst(uiButton *b, void *data)
+{
+	uiForm *f = uiForm(data);
+
+	uiFormDelete(f, 0);
+}
+
+uiBox *makePage13(void)
+{
+	uiBox *page13;
+	uiRadioButtons *rb;
+	uiButton *b;
+	uiForm *f;
+	uiEntry *e;
+	uiProgressBar *p;
+
+	page13 = newVerticalBox();
+
+	rb = uiNewRadioButtons();
+	uiRadioButtonsAppend(rb, "Item 1");
+	uiRadioButtonsAppend(rb, "Item 2");
+	uiRadioButtonsAppend(rb, "Item 3");
+	uiBoxAppend(page13, uiControl(rb), 0);
+
+	rb = uiNewRadioButtons();
+	uiRadioButtonsAppend(rb, "Item A");
+	uiRadioButtonsAppend(rb, "Item B");
+	uiBoxAppend(page13, uiControl(rb), 0);
+
+	b = uiNewButton("Horizontal");
+	uiButtonOnClicked(b, buttonClicked, uiNewHorizontalBox);
+	uiBoxAppend(page13, uiControl(b), 0);
+
+	b = uiNewButton("Vertical");
+	uiButtonOnClicked(b, buttonClicked, uiNewVerticalBox);
+	uiBoxAppend(page13, uiControl(b), 0);
+
+	f = newForm();
+
+	e = uiNewPasswordEntry();
+	uiEntryOnChanged(e, entryChanged, "password");
+	uiFormAppend(f, "Password Entry", uiControl(e), 0);
+
+	e = uiNewSearchEntry();
+	uiEntryOnChanged(e, entryChanged, "search");
+	uiFormAppend(f, "Search Box", uiControl(e), 0);
+
+	uiFormAppend(f, "MLE", uiControl(uiNewMultilineEntry()), 1);
+
+	p = uiNewProgressBar();
+	uiProgressBarSetValue(p, 50);
+	uiBoxAppend(page13, uiControl(p), 0);
+	b = uiNewButton("Toggle Indeterminate");
+	uiButtonOnClicked(b, setIndeterminate, p);
+	uiBoxAppend(page13, uiControl(b), 0);
+
+	b = uiNewButton("Show/Hide");
+	uiButtonOnClicked(b, showHide, e);
+	uiBoxAppend(page13, uiControl(b), 0);
+	b = uiNewButton("Delete First");
+	uiButtonOnClicked(b, deleteFirst, f);
+	uiBoxAppend(page13, uiControl(b), 0);
+	uiBoxAppend(page13, uiControl(f), 1);
+
+	return page13;
+}
diff --git a/src/libui_sdl/libui/test/page14.c b/src/libui_sdl/libui/test/page14.c
new file mode 100644
index 0000000..880534c
--- /dev/null
+++ b/src/libui_sdl/libui/test/page14.c
@@ -0,0 +1,350 @@
+// 9 june 2016
+#include "test.h"
+
+// TODOs:
+// - GTK+ - make all expanding controls the same size, to match the other OSs? will they match the other OSs?
+
+enum {
+	red,
+	green,
+	blue,
+	yellow,
+	white,
+	magenta,
+	orange,
+	purple,
+	cyan,
+};
+
+static const struct {
+	double r;
+	double g;
+	double b;
+} colors[] = {
+	{ 1, 0, 0 },
+	{ 0, 0.5, 0 },
+	{ 0, 0, 1 },
+	{ 1, 1, 0 },
+	{ 1, 1, 1 },
+	{ 1, 0, 1 },
+	{ 1, 0.65, 0 },
+	{ 0.5, 0, 0.5 },
+	{ 0, 1, 1 },
+};
+
+static uiControl *testControl(const char *label, int color)
+{
+	uiColorButton *b;
+
+	b = uiNewColorButton();
+	uiColorButtonSetColor(b, colors[color].r, colors[color].g, colors[color].b, 1.0);
+	return uiControl(b);
+}
+
+static uiControl *simpleGrid(void)
+{
+	uiGrid *g;
+	uiControl *t4;
+
+	g = newGrid();
+	uiGridAppend(g, testControl("1", red),
+		0, 0, 1, 1,
+		0, uiAlignFill, 0, uiAlignFill);
+	uiGridAppend(g, testControl("2", green),
+		1, 0, 1, 1,
+		0, uiAlignFill, 0, uiAlignFill);
+	uiGridAppend(g, testControl("3", blue),
+		2, 0, 1, 1,
+		0, uiAlignFill, 0, uiAlignFill);
+	t4 = testControl("4", green);
+	uiGridAppend(g, t4,
+		0, 1, 1, 1,
+		0, uiAlignFill, 1, uiAlignFill);
+	uiGridInsertAt(g, testControl("5", blue),
+		t4, uiAtTrailing, 2, 1,
+		0, uiAlignFill, 0, uiAlignFill);
+	uiGridAppend(g, testControl("6", yellow),
+		-1, 0, 1, 2,
+		1, uiAlignFill, 0, uiAlignFill);
+	return uiControl(g);
+}
+
+static uiControl *boxComparison(void)
+{
+	uiBox *vbox;
+	uiGrid *g;
+	uiBox *hbox;
+
+	vbox = newVerticalBox();
+	uiBoxAppend(vbox, uiControl(uiNewLabel("Above")), 0);
+	uiBoxAppend(vbox, uiControl(uiNewHorizontalSeparator()), 0);
+
+	hbox = newHorizontalBox();
+	uiBoxAppend(vbox, uiControl(hbox), 0);
+	uiBoxAppend(hbox, testControl("1", white), 0);
+	uiBoxAppend(hbox, uiControl(uiNewLabel("A label")), 1);
+	uiBoxAppend(hbox, testControl("2", green), 0);
+	uiBoxAppend(hbox, uiControl(uiNewLabel("Another label")), 1);
+	uiBoxAppend(hbox, testControl("3", red), 0);
+
+	uiBoxAppend(vbox, uiControl(uiNewHorizontalSeparator()), 0);
+
+	g = newGrid();
+	uiBoxAppend(vbox, uiControl(g), 0);
+	uiGridAppend(g, testControl("1", white),
+		0, 0, 1, 1,
+		0, uiAlignFill, 0, uiAlignFill);
+	uiGridAppend(g, uiControl(uiNewLabel("A label")),
+		1, 0, 1, 1,
+		1, uiAlignFill, 0, uiAlignFill);
+	uiGridAppend(g, testControl("2", green),
+		2, 0, 1, 1,
+		0, uiAlignFill, 0, uiAlignFill);
+	uiGridAppend(g, uiControl(uiNewLabel("Another label")),
+		3, 0, 1, 1,
+		1, uiAlignFill, 0, uiAlignFill);
+	uiGridAppend(g, testControl("3", red),
+		4, 0, 1, 1,
+		0, uiAlignFill, 0, uiAlignFill);
+
+	uiBoxAppend(vbox, uiControl(uiNewHorizontalSeparator()), 0);
+	uiBoxAppend(vbox, uiControl(uiNewLabel("Below")), 0);
+	return uiControl(vbox);
+}
+
+static uiControl *emptyLine(void)
+{
+	uiGrid *g;
+
+	g = newGrid();
+	uiGridAppend(g, testControl("(0, 0)", red),
+		0, 0, 1, 1,
+		1, uiAlignFill, 1, uiAlignFill);
+	uiGridAppend(g, testControl("(0, 1)", blue),
+		0, 1, 1, 1,
+		0, uiAlignFill, 0, uiAlignFill);
+	uiGridAppend(g, testControl("(10, 0)", green),
+		10, 0, 1, 1,
+		0, uiAlignFill, 0, uiAlignFill);
+	uiGridAppend(g, testControl("(10, 1)", magenta),
+		10, 1, 1, 1,
+		0, uiAlignFill, 0, uiAlignFill);
+	return uiControl(g);
+}
+
+static uiControl *emptyGrid(void)
+{
+	uiGrid *g;
+	uiControl *t;
+
+	g = newGrid();
+	t = testControl("(0, 0)", red);
+	uiGridAppend(g, t,
+		0, 0, 1, 1,
+		1, uiAlignFill, 1, uiAlignFill);
+	uiControlHide(t);
+	return uiControl(g);
+}
+
+// TODO insert (need specialized insert/delete)
+
+static uiControl *spanningGrid(void)
+{
+	uiGrid *g;
+
+	g = newGrid();
+	uiGridAppend(g, testControl("0", blue),
+		0, 4, 4, 1,
+		1, uiAlignFill, 0, uiAlignFill);
+	uiGridAppend(g, testControl("1", green),
+		4, 0, 1, 4,
+		0, uiAlignFill, 1, uiAlignFill);
+	uiGridAppend(g, testControl("2", red),
+		3, 3, 1, 1,
+		1, uiAlignFill, 1, uiAlignFill);
+	uiGridAppend(g, testControl("3", yellow),
+		0, 3, 2, 1,
+		0, uiAlignFill, 0, uiAlignFill);
+	uiGridAppend(g, testControl("4", orange),
+		3, 0, 1, 2,
+		0, uiAlignFill, 0, uiAlignFill);
+	uiGridAppend(g, testControl("5", purple),
+		1, 1, 1, 1,
+		0, uiAlignFill, 0, uiAlignFill);
+	uiGridAppend(g, testControl("6", white),
+		0, 1, 1, 1,
+		0, uiAlignFill, 0, uiAlignFill);
+	uiGridAppend(g, testControl("7", cyan),
+		1, 0, 1, 1,
+		0, uiAlignFill, 0, uiAlignFill);
+	return uiControl(g);
+}
+
+// TODO make non-global
+static uiButton *hideOne, *one, *showOne;
+
+static void onHideOne(uiButton *b, void *data)
+{
+	uiControlHide(uiControl(one));
+}
+
+static void onShowOne(uiButton *b, void *data)
+{
+	uiControlShow(uiControl(one));
+}
+
+static void onHideAll(uiButton *b, void *data)
+{
+	uiControlHide(uiControl(hideOne));
+	uiControlHide(uiControl(one));
+	uiControlHide(uiControl(showOne));
+}
+
+static void onShowAll(uiButton *b, void *data)
+{
+	uiControlShow(uiControl(hideOne));
+	uiControlShow(uiControl(one));
+	uiControlShow(uiControl(showOne));
+}
+
+#define AT(x) static void onInsert ## x(uiButton *b, void *data) \
+	{ \
+		uiGrid *g = uiGrid(data); \
+		uiGridInsertAt(g, uiControl(uiNewButton("Button")), \
+			uiControl(b), uiAt ## x, 1, 1, \
+			0, uiAlignFill, 0, uiAlignFill); \
+	}
+AT(Leading)
+AT(Top)
+AT(Trailing)
+AT(Bottom)
+
+static uiControl *assorted(void)
+{
+	uiGrid *outergrid;
+	uiGrid *innergrid;
+	uiButton *b;
+
+	outergrid = newGrid();
+
+	innergrid = newGrid();
+	one = uiNewButton("Test");
+	uiGridAppend(innergrid, uiControl(one),
+		1, 1, 1, 1,
+		0, uiAlignFill, 0, uiAlignFill);
+	hideOne = uiNewButton("Hide One");
+	uiButtonOnClicked(hideOne, onHideOne, NULL);
+	uiGridAppend(innergrid, uiControl(hideOne),
+		0, 1, 1, 1,
+		0, uiAlignFill, 0, uiAlignFill);
+	showOne = uiNewButton("Show One");
+	uiButtonOnClicked(showOne, onShowOne, NULL);
+	uiGridAppend(innergrid, uiControl(showOne),
+		2, 1, 1, 1,
+		0, uiAlignFill, 0, uiAlignFill);
+	b = uiNewButton("Hide All");
+	uiButtonOnClicked(b, onHideAll, NULL);
+	uiGridAppend(innergrid, uiControl(b),
+		1, 0, 1, 1,
+		0, uiAlignFill, 0, uiAlignFill);
+	b = uiNewButton("Show All");
+	uiButtonOnClicked(b, onShowAll, NULL);
+	uiGridAppend(innergrid, uiControl(b),
+		1, 2, 1, 1,
+		0, uiAlignFill, 0, uiAlignFill);
+	uiGridAppend(outergrid, uiControl(innergrid),
+		0, 0, 1, 1,
+		1, uiAlignFill, 1, uiAlignFill);
+
+	innergrid = newGrid();
+	b = uiNewButton("Insert Trailing");
+	uiButtonOnClicked(b, onInsertTrailing, innergrid);
+	uiGridAppend(innergrid, uiControl(b),
+		0, 0, 1, 1,
+		1, uiAlignFill, 0, uiAlignFill);
+	b = uiNewButton("Insert Bottom");
+	uiButtonOnClicked(b, onInsertBottom, innergrid);
+	uiGridAppend(innergrid, uiControl(b),
+		1, 0, 1, 1,
+		1, uiAlignFill, 0, uiAlignFill);
+	b = uiNewButton("Insert Leading");
+	uiButtonOnClicked(b, onInsertLeading, innergrid);
+	uiGridAppend(innergrid, uiControl(b),
+		1, 1, 1, 1,
+		1, uiAlignFill, 0, uiAlignFill);
+	b = uiNewButton("Insert Top");
+	uiButtonOnClicked(b, onInsertTop, innergrid);
+	uiGridAppend(innergrid, uiControl(b),
+		0, 1, 1, 1,
+		1, uiAlignFill, 0, uiAlignFill);
+	uiGridAppend(outergrid, uiControl(innergrid),
+		1, 0, 1, 1,
+		1, uiAlignFill, 1, uiAlignFill);
+
+	innergrid = newGrid();
+	uiGridAppend(innergrid, uiControl(uiNewColorButton()),
+		0, 0, 1, 1,
+		1, uiAlignFill, 0, uiAlignFill);
+	uiGridAppend(innergrid, uiControl(uiNewColorButton()),
+		0, 1, 1, 1,
+		1, uiAlignStart, 0, uiAlignFill);
+	uiGridAppend(innergrid, uiControl(uiNewColorButton()),
+		0, 2, 1, 1,
+		1, uiAlignCenter, 0, uiAlignFill);
+	uiGridAppend(innergrid, uiControl(uiNewColorButton()),
+		0, 3, 1, 1,
+		1, uiAlignEnd, 0, uiAlignFill);
+	uiGridAppend(outergrid, uiControl(innergrid),
+		0, 1, 1, 1,
+		1, uiAlignFill, 1, uiAlignFill);
+
+	// TODO with only this, wrong size on OS X — expand sizing thing?
+	innergrid = newGrid();
+	uiGridAppend(innergrid, uiControl(uiNewColorButton()),
+		0, 0, 1, 1,
+		0, uiAlignFill, 1, uiAlignFill);
+	uiGridAppend(innergrid, uiControl(uiNewColorButton()),
+		1, 0, 1, 1,
+		0, uiAlignFill, 1, uiAlignStart);
+	uiGridAppend(innergrid, uiControl(uiNewColorButton()),
+		2, 0, 1, 1,
+		0, uiAlignFill, 1, uiAlignCenter);
+	uiGridAppend(innergrid, uiControl(uiNewColorButton()),
+		3, 0, 1, 1,
+		0, uiAlignFill, 1, uiAlignEnd);
+	uiGridAppend(outergrid, uiControl(innergrid),
+		1, 1, 1, 1,
+		1, uiAlignFill, 1, uiAlignFill);
+
+	return uiControl(outergrid);
+}
+
+static const struct {
+	const char *name;
+	uiControl *(*f)(void);
+} pages[] = {
+	// based on GTK+ test/testgrid.c
+	{ "Simple Grid", simpleGrid },
+	{ "Box Comparison", boxComparison },
+	{ "Empty Line", emptyLine },
+	{ "Empty Grid", emptyGrid },
+	{ "Spanning Grid", spanningGrid },
+	// my own
+	{ "Assorted", assorted },
+	{ NULL, NULL },
+};
+
+uiTab *makePage14(void)
+{
+	uiTab *page14;
+	int i;
+
+	page14 = newTab();
+
+	for (i = 0; pages[i].name != NULL; i++)
+		uiTabAppend(page14,
+			pages[i].name,
+			(*(pages[i].f))());
+
+	return page14;
+}
diff --git a/src/libui_sdl/libui/test/page15.c b/src/libui_sdl/libui/test/page15.c
new file mode 100644
index 0000000..e703bee
--- /dev/null
+++ b/src/libui_sdl/libui/test/page15.c
@@ -0,0 +1,260 @@
+// 15 june 2016
+#include "test.h"
+
+static uiAreaHandler borderAH;
+static int borderAHInit = 0;
+static double lastx = -1, lasty = -1;
+
+struct trect {
+	double left;
+	double top;
+	double right;
+	double bottom;
+	int in;
+};
+
+#define tsetrect(re, l, t, r, b) re.left = l; re.top = t; re.right = r; re.bottom = b; re.in = lastx >= re.left && lastx < re.right && lasty >= re.top && lasty < re.bottom
+
+struct tareas {
+	struct trect move;
+	struct trect alsomove;
+	struct trect leftresize;
+	struct trect topresize;
+	struct trect rightresize;
+	struct trect bottomresize; 
+	struct trect topleftresize;
+	struct trect toprightresize;
+	struct trect bottomleftresize;
+	struct trect bottomrightresize;
+	struct trect close;
+};
+
+static void filltareas(double awid, double aht, struct tareas *ta)
+{
+	tsetrect(ta->move, 20, 20, awid - 20, 20 + 30);
+	tsetrect(ta->alsomove, 30, 200, 100, 270);
+	tsetrect(ta->leftresize, 5, 20, 15, aht - 20);
+	tsetrect(ta->topresize, 20, 5, awid - 20, 15);
+	tsetrect(ta->rightresize, awid - 15, 20, awid - 5, aht - 20);
+	tsetrect(ta->bottomresize, 20, aht - 15, awid - 20, aht - 5);
+	tsetrect(ta->topleftresize, 5, 5, 15, 15);
+	tsetrect(ta->toprightresize, awid - 15, 5, awid - 5, 15);
+	tsetrect(ta->bottomleftresize, 5, aht - 15, 15, aht - 5);
+	tsetrect(ta->bottomrightresize, awid - 15, aht - 15, awid - 5, aht - 5);
+	tsetrect(ta->close, 130, 200, 200, 270);
+}
+
+static void drawtrect(uiDrawContext *c, struct trect tr, double r, double g, double bl)
+{
+	uiDrawPath *p;
+	uiDrawBrush b;
+
+	memset(&b, 0, sizeof (uiDrawBrush));
+	b.Type = uiDrawBrushTypeSolid;
+	b.R = r;
+	b.G = g;
+	b.B = bl;
+	b.A = 1.0;
+	if (tr.in) {
+		b.R += b.R * 0.75;
+		b.G += b.G * 0.75;
+		b.B += b.B * 0.75;
+	}
+	p = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathAddRectangle(p,
+		tr.left,
+		tr.top,
+		tr.right - tr.left,
+		tr.bottom - tr.top);
+	uiDrawPathEnd(p);
+	uiDrawFill(c, p, &b);
+	uiDrawFreePath(p);
+}
+
+static void handlerDraw(uiAreaHandler *a, uiArea *area, uiAreaDrawParams *p)
+{
+	struct tareas ta;
+
+	filltareas(p->AreaWidth, p->AreaHeight, &ta);
+	drawtrect(p->Context, ta.move, 0, 0.5, 0);
+	drawtrect(p->Context, ta.alsomove, 0, 0.5, 0);
+	drawtrect(p->Context, ta.leftresize, 0, 0, 0.5);
+	drawtrect(p->Context, ta.topresize, 0, 0, 0.5);
+	drawtrect(p->Context, ta.rightresize, 0, 0, 0.5);
+	drawtrect(p->Context, ta.bottomresize, 0, 0, 0.5);
+	drawtrect(p->Context, ta.topleftresize, 0, 0.5, 0.5);
+	drawtrect(p->Context, ta.toprightresize, 0, 0.5, 0.5);
+	drawtrect(p->Context, ta.bottomleftresize, 0, 0.5, 0.5);
+	drawtrect(p->Context, ta.bottomrightresize, 0, 0.5, 0.5);
+	drawtrect(p->Context, ta.close, 0.5, 0, 0);
+
+	// TODO add current position prints here
+}
+
+static void handlerMouseEvent(uiAreaHandler *a, uiArea *area, uiAreaMouseEvent *e)
+{
+	struct tareas ta;
+
+	lastx = e->X;
+	lasty = e->Y;
+	filltareas(e->AreaWidth, e->AreaHeight, &ta);
+	// redraw our highlighted rect
+	uiAreaQueueRedrawAll(area);
+	if (e->Down != 1)
+		return;
+	if (ta.move.in || ta.alsomove.in) {
+		uiAreaBeginUserWindowMove(area);
+		return;
+	}
+#define resize(cond, edge) if (cond) { uiAreaBeginUserWindowResize(area, edge); return; }
+	resize(ta.leftresize.in, uiWindowResizeEdgeLeft)
+	resize(ta.topresize.in, uiWindowResizeEdgeTop)
+	resize(ta.rightresize.in, uiWindowResizeEdgeRight)
+	resize(ta.bottomresize.in, uiWindowResizeEdgeBottom)
+	resize(ta.topleftresize.in, uiWindowResizeEdgeTopLeft)
+	resize(ta.toprightresize.in, uiWindowResizeEdgeTopRight)
+	resize(ta.bottomleftresize.in, uiWindowResizeEdgeBottomLeft)
+	resize(ta.bottomrightresize.in, uiWindowResizeEdgeBottomRight)
+	if (ta.close.in) {
+		// TODO
+		return;
+	}
+}
+
+static void handlerMouseCrossed(uiAreaHandler *ah, uiArea *a, int left)
+{
+}
+
+static void handlerDragBroken(uiAreaHandler *ah, uiArea *a)
+{
+}
+
+static int handlerKeyEvent(uiAreaHandler *ah, uiArea *a, uiAreaKeyEvent *e)
+{
+	return 0;
+}
+
+static void borderWindowOpen(uiButton *b, void *data)
+{
+	uiWindow *w;
+	uiArea *a;
+
+	if (!borderAHInit) {
+		borderAH.Draw = handlerDraw;
+		borderAH.MouseEvent = handlerMouseEvent;
+		borderAH.MouseCrossed = handlerMouseCrossed;
+		borderAH.DragBroken = handlerDragBroken;
+		borderAH.KeyEvent = handlerKeyEvent;
+		borderAHInit = 1;
+	}
+
+	w = uiNewWindow("Border Resize Test", 300, 500, 0);
+	uiWindowSetBorderless(w, 1);
+
+	a = uiNewArea(&borderAH);
+//	uiWindowSetChild(w, uiControl(a));
+{uiBox *b;
+b=uiNewHorizontalBox();
+uiBoxAppend(b,uiControl(a),1);
+uiWindowSetChild(w,uiControl(b));}
+//TODO why is this hack needed? GTK+ issue
+
+	uiControlShow(uiControl(w));
+}
+
+static uiSpinbox *width, *height;
+static uiCheckbox *fullscreen;
+
+static void sizeWidth(uiSpinbox *s, void *data)
+{
+	uiWindow *w = uiWindow(data);
+	int xp, yp;
+
+	uiWindowContentSize(w, &xp, &yp);
+	xp = uiSpinboxValue(width);
+	uiWindowSetContentSize(w, xp, yp);
+}
+
+static void sizeHeight(uiSpinbox *s, void *data)
+{
+	uiWindow *w = uiWindow(data);
+	int xp, yp;
+
+	uiWindowContentSize(w, &xp, &yp);
+	yp = uiSpinboxValue(height);
+	uiWindowSetContentSize(w, xp, yp);
+}
+
+static void updatesize(uiWindow *w)
+{
+	int xp, yp;
+
+	uiWindowContentSize(w, &xp, &yp);
+	uiSpinboxSetValue(width, xp);
+	uiSpinboxSetValue(height, yp);
+	// TODO on OS X this is updated AFTER sending the size change, not before
+	uiCheckboxSetChecked(fullscreen, uiWindowFullscreen(w));
+}
+
+void onSize(uiWindow *w, void *data)
+{
+	printf("size\n");
+	updatesize(w);
+}
+
+void setFullscreen(uiCheckbox *cb, void *data)
+{
+	uiWindow *w = uiWindow(data);
+
+	uiWindowSetFullscreen(w, uiCheckboxChecked(fullscreen));
+	updatesize(w);
+}
+
+static void borderless(uiCheckbox *c, void *data)
+{
+	uiWindow *w = uiWindow(data);
+
+	uiWindowSetBorderless(w, uiCheckboxChecked(c));
+}
+
+uiBox *makePage15(uiWindow *w)
+{
+	uiBox *page15;
+	uiBox *hbox;
+	uiButton *button;
+	uiCheckbox *checkbox;
+
+	page15 = newVerticalBox();
+
+	hbox = newHorizontalBox();
+	uiBoxAppend(page15, uiControl(hbox), 0);
+
+	uiBoxAppend(hbox, uiControl(uiNewLabel("Size")), 0);
+	width = uiNewSpinbox(INT_MIN, INT_MAX);
+	uiBoxAppend(hbox, uiControl(width), 1);
+	height = uiNewSpinbox(INT_MIN, INT_MAX);
+	uiBoxAppend(hbox, uiControl(height), 1);
+	fullscreen = uiNewCheckbox("Fullscreen");
+	uiBoxAppend(hbox, uiControl(fullscreen), 0);
+
+	uiSpinboxOnChanged(width, sizeWidth, w);
+	uiSpinboxOnChanged(height, sizeHeight, w);
+	uiCheckboxOnToggled(fullscreen, setFullscreen, w);
+	uiWindowOnContentSizeChanged(w, onSize, NULL);
+	updatesize(w);
+
+	checkbox = uiNewCheckbox("Borderless");
+	uiCheckboxOnToggled(checkbox, borderless, w);
+	uiBoxAppend(page15, uiControl(checkbox), 0);
+
+	button = uiNewButton("Borderless Resizes");
+	uiButtonOnClicked(button, borderWindowOpen, NULL);
+	uiBoxAppend(page15, uiControl(button), 0);
+
+	hbox = newHorizontalBox();
+	uiBoxAppend(page15, uiControl(hbox), 1);
+
+	uiBoxAppend(hbox, uiControl(uiNewVerticalSeparator()), 0);
+
+	return page15;
+}
diff --git a/src/libui_sdl/libui/test/page2.c b/src/libui_sdl/libui/test/page2.c
new file mode 100644
index 0000000..abb0648
--- /dev/null
+++ b/src/libui_sdl/libui/test/page2.c
@@ -0,0 +1,215 @@
+// 29 april 2015
+#include "test.h"
+
+uiGroup *page2group;
+
+static uiLabel *movingLabel;
+static uiBox *movingBoxes[2];
+static int movingCurrent;
+
+static void moveLabel(uiButton *b, void *data)
+{
+	int from, to;
+
+	from = movingCurrent;
+	to = 0;
+	if (from == 0)
+		to = 1;
+	uiBoxDelete(movingBoxes[from], 0);
+	uiBoxAppend(movingBoxes[to], uiControl(movingLabel), 0);
+	movingCurrent = to;
+}
+
+static int moveBack;
+#define moveOutText "Move Page 1 Out"
+#define moveBackText "Move Page 1 Back"
+
+static void movePage1(uiButton *b, void *data)
+{
+	if (moveBack) {
+		uiBoxDelete(mainBox, 1);
+		uiTabInsertAt(mainTab, "Page 1", 0, uiControl(page1));
+		uiButtonSetText(b, moveOutText);
+		moveBack = 0;
+		return;
+	}
+	uiTabDelete(mainTab, 0);
+	uiBoxAppend(mainBox, uiControl(page1), 1);
+	uiButtonSetText(b, moveBackText);
+	moveBack = 1;
+}
+
+static void openAnotherWindow(uiButton *bb, void *data)
+{
+	uiWindow *w;
+	uiBox *b;
+
+	w = uiNewWindow("Another Window", 100, 100, data != NULL);
+	if (data != NULL) {
+		b = uiNewVerticalBox();
+		uiBoxAppend(b, uiControl(uiNewEntry()), 0);
+		uiBoxAppend(b, uiControl(uiNewButton("Button")), 0);
+		uiBoxSetPadded(b, 1);
+		uiWindowSetChild(w, uiControl(b));
+	} else
+		uiWindowSetChild(w, uiControl(makePage6()));
+	uiWindowSetMargined(w, 1);
+	uiControlShow(uiControl(w));
+}
+
+static void openAnotherDisabledWindow(uiButton *b, void *data)
+{
+	uiWindow *w;
+
+	w = uiNewWindow("Another Window", 100, 100, data != NULL);
+	uiControlDisable(uiControl(w));
+	uiControlShow(uiControl(w));
+}
+
+#define SHED(method, Method) \
+	static void method ## Control(uiButton *b, void *data) \
+	{ \
+		uiControl ## Method(uiControl(data)); \
+	}
+SHED(show, Show)
+SHED(enable, Enable)
+SHED(disable, Disable)
+
+static void echoReadOnlyText(uiEntry *e, void *data)
+{
+	char *text;
+
+	text = uiEntryText(e);
+	uiEntrySetText(uiEntry(data), text);
+	uiFreeText(text);
+}
+
+uiBox *makePage2(void)
+{
+	uiBox *page2;
+	uiBox *hbox;
+	uiGroup *group;
+	uiBox *vbox;
+	uiButton *button;
+	uiBox *nestedBox;
+	uiBox *innerhbox;
+	uiBox *innerhbox2;
+	uiBox *innerhbox3;
+	uiTab *disabledTab;
+	uiEntry *entry;
+	uiEntry *readonly;
+	uiButton *button2;
+
+	page2 = newVerticalBox();
+
+	group = newGroup("Moving Label");
+	page2group = group;
+	uiBoxAppend(page2, uiControl(group), 0);
+	vbox = newVerticalBox();
+	uiGroupSetChild(group, uiControl(vbox));
+
+	hbox = newHorizontalBox();
+	button = uiNewButton("Move the Label!");
+	uiButtonOnClicked(button, moveLabel, NULL);
+	uiBoxAppend(hbox, uiControl(button), 1);
+	// have a blank label for space
+	uiBoxAppend(hbox, uiControl(uiNewLabel("")), 1);
+	uiBoxAppend(vbox, uiControl(hbox), 0);
+
+	hbox = newHorizontalBox();
+	movingBoxes[0] = newVerticalBox();
+	uiBoxAppend(hbox, uiControl(movingBoxes[0]), 1);
+	movingBoxes[1] = newVerticalBox();
+	uiBoxAppend(hbox, uiControl(movingBoxes[1]), 1);
+	uiBoxAppend(vbox, uiControl(hbox), 0);
+
+	movingCurrent = 0;
+	movingLabel = uiNewLabel("This label moves!");
+	uiBoxAppend(movingBoxes[movingCurrent], uiControl(movingLabel), 0);
+
+	hbox = newHorizontalBox();
+	button = uiNewButton(moveOutText);
+	uiButtonOnClicked(button, movePage1, NULL);
+	uiBoxAppend(hbox, uiControl(button), 0);
+	uiBoxAppend(page2, uiControl(hbox), 0);
+	moveBack = 0;
+
+	hbox = newHorizontalBox();
+	uiBoxAppend(hbox, uiControl(uiNewLabel("Label Alignment Test")), 0);
+	button = uiNewButton("Open Menued Window");
+	uiButtonOnClicked(button, openAnotherWindow, button);
+	uiBoxAppend(hbox, uiControl(button), 0);
+	button = uiNewButton("Open Menuless Window");
+	uiButtonOnClicked(button, openAnotherWindow, NULL);
+	uiBoxAppend(hbox, uiControl(button), 0);
+	button = uiNewButton("Disabled Menued");
+	uiButtonOnClicked(button, openAnotherDisabledWindow, button);
+	uiBoxAppend(hbox, uiControl(button), 0);
+	button = uiNewButton("Disabled Menuless");
+	uiButtonOnClicked(button, openAnotherDisabledWindow, NULL);
+	uiBoxAppend(hbox, uiControl(button), 0);
+	uiBoxAppend(page2, uiControl(hbox), 0);
+
+	nestedBox = newHorizontalBox();
+	innerhbox = newHorizontalBox();
+	uiBoxAppend(innerhbox, uiControl(uiNewButton("These")), 0);
+	button = uiNewButton("buttons");
+	uiControlDisable(uiControl(button));
+	uiBoxAppend(innerhbox, uiControl(button), 0);
+	uiBoxAppend(nestedBox, uiControl(innerhbox), 0);
+	innerhbox = newHorizontalBox();
+	uiBoxAppend(innerhbox, uiControl(uiNewButton("are")), 0);
+	innerhbox2 = newHorizontalBox();
+	button = uiNewButton("in");
+	uiControlDisable(uiControl(button));
+	uiBoxAppend(innerhbox2, uiControl(button), 0);
+	uiBoxAppend(innerhbox, uiControl(innerhbox2), 0);
+	uiBoxAppend(nestedBox, uiControl(innerhbox), 0);
+	innerhbox = newHorizontalBox();
+	innerhbox2 = newHorizontalBox();
+	uiBoxAppend(innerhbox2, uiControl(uiNewButton("nested")), 0);
+	innerhbox3 = newHorizontalBox();
+	button = uiNewButton("boxes");
+	uiControlDisable(uiControl(button));
+	uiBoxAppend(innerhbox3, uiControl(button), 0);
+	uiBoxAppend(innerhbox2, uiControl(innerhbox3), 0);
+	uiBoxAppend(innerhbox, uiControl(innerhbox2), 0);
+	uiBoxAppend(nestedBox, uiControl(innerhbox), 0);
+	uiBoxAppend(page2, uiControl(nestedBox), 0);
+
+	hbox = newHorizontalBox();
+	button = uiNewButton("Enable Nested Box");
+	uiButtonOnClicked(button, enableControl, nestedBox);
+	uiBoxAppend(hbox, uiControl(button), 0);
+	button = uiNewButton("Disable Nested Box");
+	uiButtonOnClicked(button, disableControl, nestedBox);
+	uiBoxAppend(hbox, uiControl(button), 0);
+	uiBoxAppend(page2, uiControl(hbox), 0);
+
+	disabledTab = newTab();
+	uiTabAppend(disabledTab, "Disabled", uiControl(uiNewButton("Button")));
+	uiTabAppend(disabledTab, "Tab", uiControl(uiNewLabel("Label")));
+	uiControlDisable(uiControl(disabledTab));
+	uiBoxAppend(page2, uiControl(disabledTab), 1);
+
+	entry = uiNewEntry();
+	readonly = uiNewEntry();
+	uiEntryOnChanged(entry, echoReadOnlyText, readonly);
+	uiEntrySetText(readonly, "If you can see this, uiEntryReadOnly() isn't working properly.");
+	uiEntrySetReadOnly(readonly, 1);
+	if (uiEntryReadOnly(readonly))
+		uiEntrySetText(readonly, "");
+	uiBoxAppend(page2, uiControl(entry), 0);
+	uiBoxAppend(page2, uiControl(readonly), 0);
+
+	hbox = newHorizontalBox();
+	button = uiNewButton("Show Button 2");
+	button2 = uiNewButton("Button 2");
+	uiButtonOnClicked(button, showControl, button2);
+	uiControlHide(uiControl(button2));
+	uiBoxAppend(hbox, uiControl(button), 1);
+	uiBoxAppend(hbox, uiControl(button2), 0);
+	uiBoxAppend(page2, uiControl(hbox), 0);
+
+	return page2;
+}
diff --git a/src/libui_sdl/libui/test/page3.c b/src/libui_sdl/libui/test/page3.c
new file mode 100644
index 0000000..1f229e9
--- /dev/null
+++ b/src/libui_sdl/libui/test/page3.c
@@ -0,0 +1,69 @@
+// 7 may 2015
+#include "test.h"
+
+static uiBox *makeSet(int omit, int hidden, int stretch)
+{
+	uiBox *hbox;
+	uiButton *buttons[4];
+
+	// don't use newHorizontalBox()
+	// the point of this test is to test hidden controls and padded
+	hbox = (*newhbox)();
+	uiBoxSetPadded(hbox, 1);
+	if (omit != 0) {
+		buttons[0] = uiNewButton("First");
+		uiBoxAppend(hbox, uiControl(buttons[0]), stretch);
+	}
+	if (omit != 1) {
+		buttons[1] = uiNewButton("Second");
+		uiBoxAppend(hbox, uiControl(buttons[1]), stretch);
+	}
+	if (omit != 2) {
+		buttons[2] = uiNewButton("Third");
+		uiBoxAppend(hbox, uiControl(buttons[2]), stretch);
+	}
+	if (omit != 3) {
+		buttons[3] = uiNewButton("Fourth");
+		uiBoxAppend(hbox, uiControl(buttons[3]), stretch);
+	}
+	if (hidden != -1)
+		uiControlHide(uiControl(buttons[hidden]));
+	return hbox;
+}
+
+uiBox *makePage3(void)
+{
+	uiBox *page3;
+	uiBox *hbox;
+	uiBox *hbox2;
+	uiBox *vbox;
+	int hidden;
+
+	page3 = newVerticalBox();
+
+	// first the non-stretchy type
+	for (hidden = 0; hidden < 4; hidden++) {
+		// these two must stay unpadded as well, otherwise the test isn't meaningful
+		hbox2 = (*newhbox)();
+		vbox = (*newvbox)();
+		// reference set
+		hbox = makeSet(hidden, -1, 0);
+		uiBoxAppend(vbox, uiControl(hbox), 0);
+		// real thing
+		hbox = makeSet(-1, hidden, 0);
+		uiBoxAppend(vbox, uiControl(hbox), 0);
+		// pack vbox in
+		uiBoxAppend(hbox2, uiControl(vbox), 0);
+		// and have a button in there for showing right margins
+		uiBoxAppend(hbox2, uiControl(uiNewButton("Right Margin Test")), 1);
+		uiBoxAppend(page3, uiControl(hbox2), 0);
+	}
+
+	// then the stretchy type
+	for (hidden = 0; hidden < 4; hidden++) {
+		hbox = makeSet(-1, hidden, 1);
+		uiBoxAppend(page3, uiControl(hbox), 0);
+	}
+
+	return page3;
+}
diff --git a/src/libui_sdl/libui/test/page4.c b/src/libui_sdl/libui/test/page4.c
new file mode 100644
index 0000000..ce4a6af
--- /dev/null
+++ b/src/libui_sdl/libui/test/page4.c
@@ -0,0 +1,165 @@
+// 19 may 2015
+#include "test.h"
+
+static uiSpinbox *spinbox;
+static uiSlider *slider;
+static uiProgressBar *pbar;
+
+#define CHANGED(what) \
+	static void on ## what ## Changed(ui ## what *this, void *data) \
+	{ \
+		int value; \
+		printf("on %s changed\n", #what); \
+		value = ui ## what ## Value(this); \
+		uiSpinboxSetValue(spinbox, value); \
+		uiSliderSetValue(slider, value); \
+		uiProgressBarSetValue(pbar, value); \
+	}
+CHANGED(Spinbox)
+CHANGED(Slider)
+
+#define SETTOO(what, name, n) \
+	static void set ## what ## Too ## name(uiButton *this, void *data) \
+	{ \
+		ui ## what ## SetValue(ui ## what(data), n); \
+	}
+SETTOO(Spinbox, Low, -80)
+SETTOO(Spinbox, High, 80)
+SETTOO(Slider, Low, -80)
+SETTOO(Slider, High, 80)
+
+static uiCombobox *cbox;
+static uiEditableCombobox *editable;
+static uiRadioButtons *rb;
+
+static void appendCBRB(uiButton *b, void *data)
+{
+	uiComboboxAppend(cbox, "New Item");
+	uiEditableComboboxAppend(editable, "New Item");
+	uiRadioButtonsAppend(rb, "New Item");
+}
+
+static void onCBChanged(uiCombobox *c, void *data)
+{
+	printf("%s combobox changed to %d\n",
+		(char *) data,
+		(int) uiComboboxSelected(c));
+	uiEditableComboboxSetText(editable, "changed");
+}
+
+static void onECBChanged(uiEditableCombobox *c, void *data)
+{
+	char *t;
+
+	t = uiEditableComboboxText(c);
+	printf("%s combobox changed to %s\n",
+		(char *) data,
+		t);
+	uiFreeText(t);
+}
+
+static void onRBSelected(uiRadioButtons *r, void *data)
+{
+	printf("radio buttons %d\n", uiRadioButtonsSelected(r));
+}
+
+static void selectSecond(uiButton *b, void *data)
+{
+	// TODO combobox, editable
+	uiRadioButtonsSetSelected(rb, 1);
+}
+
+static void selectNone(uiButton *b, void *data)
+{
+	// TODO combobox, editable
+	uiRadioButtonsSetSelected(rb, -1);
+}
+
+uiBox *makePage4(void)
+{
+	uiBox *page4;
+	uiBox *hbox;
+	uiSpinbox *xsb;
+	uiButton *b;
+	uiSlider *xsl;
+
+	page4 = newVerticalBox();
+
+	spinbox = uiNewSpinbox(0, 100);
+	uiSpinboxOnChanged(spinbox, onSpinboxChanged, NULL);
+	uiBoxAppend(page4, uiControl(spinbox), 0);
+
+	slider = uiNewSlider(0, 100);
+	uiSliderOnChanged(slider, onSliderChanged, NULL);
+	uiBoxAppend(page4, uiControl(slider), 0);
+
+	pbar = uiNewProgressBar();
+	uiBoxAppend(page4, uiControl(pbar), 0);
+
+	uiBoxAppend(page4, uiControl(uiNewHorizontalSeparator()), 0);
+
+	hbox = newHorizontalBox();
+	xsb = uiNewSpinbox(-40, 40);
+	uiBoxAppend(hbox, uiControl(xsb), 0);
+	b = uiNewButton("Bad Low");
+	uiButtonOnClicked(b, setSpinboxTooLow, xsb);
+	uiBoxAppend(hbox, uiControl(b), 0);
+	b = uiNewButton("Bad High");
+	uiButtonOnClicked(b, setSpinboxTooHigh, xsb);
+	uiBoxAppend(hbox, uiControl(b), 0);
+	uiBoxAppend(page4, uiControl(hbox), 0);
+
+	hbox = newHorizontalBox();
+	xsl = uiNewSlider(-40, 40);
+	uiBoxAppend(hbox, uiControl(xsl), 0);
+	b = uiNewButton("Bad Low");
+	uiButtonOnClicked(b, setSliderTooLow, xsl);
+	uiBoxAppend(hbox, uiControl(b), 0);
+	b = uiNewButton("Bad High");
+	uiButtonOnClicked(b, setSliderTooHigh, xsl);
+	uiBoxAppend(hbox, uiControl(b), 0);
+	uiBoxAppend(page4, uiControl(hbox), 0);
+
+	uiBoxAppend(page4, uiControl(uiNewHorizontalSeparator()), 0);
+
+	cbox = uiNewCombobox();
+	uiComboboxAppend(cbox, "Item 1");
+	uiComboboxAppend(cbox, "Item 2");
+	uiComboboxAppend(cbox, "Item 3");
+	uiComboboxOnSelected(cbox, onCBChanged, "noneditable");
+	uiBoxAppend(page4, uiControl(cbox), 0);
+
+	editable = uiNewEditableCombobox();
+	uiEditableComboboxAppend(editable, "Editable Item 1");
+	uiEditableComboboxAppend(editable, "Editable Item 2");
+	uiEditableComboboxAppend(editable, "Editable Item 3");
+	uiEditableComboboxOnChanged(editable, onECBChanged, "editable");
+	uiBoxAppend(page4, uiControl(editable), 0);
+
+	rb = uiNewRadioButtons();
+	uiRadioButtonsAppend(rb, "Item 1");
+	uiRadioButtonsAppend(rb, "Item 2");
+	uiRadioButtonsAppend(rb, "Item 3");
+	uiRadioButtonsOnSelected(rb, onRBSelected, NULL);
+	uiBoxAppend(page4, uiControl(rb), 0);
+
+	hbox = newHorizontalBox();
+	b = uiNewButton("Append");
+	uiButtonOnClicked(b, appendCBRB, NULL);
+	uiBoxAppend(hbox, uiControl(b), 0);
+	b = uiNewButton("Second");
+	uiButtonOnClicked(b, selectSecond, NULL);
+	uiBoxAppend(hbox, uiControl(b), 0);
+	b = uiNewButton("None");
+	uiButtonOnClicked(b, selectNone, NULL);
+	uiBoxAppend(hbox, uiControl(b), 0);
+	uiBoxAppend(page4, uiControl(hbox), 0);
+
+	uiBoxAppend(page4, uiControl(uiNewHorizontalSeparator()), 0);
+
+	uiBoxAppend(page4, uiControl(uiNewDateTimePicker()), 0);
+	uiBoxAppend(page4, uiControl(uiNewDatePicker()), 0);
+	uiBoxAppend(page4, uiControl(uiNewTimePicker()), 0);
+
+	return page4;
+}
diff --git a/src/libui_sdl/libui/test/page5.c b/src/libui_sdl/libui/test/page5.c
new file mode 100644
index 0000000..9bc1105
--- /dev/null
+++ b/src/libui_sdl/libui/test/page5.c
@@ -0,0 +1,99 @@
+// 22 may 2015
+#include "test.h"
+
+static uiWindow *parent;
+
+static void openFile(uiButton *b, void *data)
+{
+	char *fn;
+
+	fn = uiOpenFile(parent);
+	if (fn == NULL)
+		uiLabelSetText(uiLabel(data), "(cancelled)");
+	else {
+		uiLabelSetText(uiLabel(data), fn);
+		uiFreeText(fn);
+	}
+}
+
+static void saveFile(uiButton *b, void *data)
+{
+	char *fn;
+
+	fn = uiSaveFile(parent);
+	if (fn == NULL)
+		uiLabelSetText(uiLabel(data), "(cancelled)");
+	else {
+		uiLabelSetText(uiLabel(data), fn);
+		uiFreeText(fn);
+	}
+}
+
+static uiEntry *title, *description;
+
+static void msgBox(uiButton *b, void *data)
+{
+	char *t, *d;
+
+	t = uiEntryText(title);
+	d = uiEntryText(description);
+	uiMsgBox(parent, t, d);
+	uiFreeText(d);
+	uiFreeText(t);
+}
+
+static void msgBoxError(uiButton *b, void *data)
+{
+	char *t, *d;
+
+	t = uiEntryText(title);
+	d = uiEntryText(description);
+	uiMsgBoxError(parent, t, d);
+	uiFreeText(d);
+	uiFreeText(t);
+}
+
+uiBox *makePage5(uiWindow *pw)
+{
+	uiBox *page5;
+	uiBox *hbox;
+	uiButton *button;
+	uiLabel *label;
+
+	parent = pw;
+
+	page5 = newVerticalBox();
+
+#define D(n, f) \
+	hbox = newHorizontalBox(); \
+	button = uiNewButton(n); \
+	label = uiNewLabel(""); \
+	uiButtonOnClicked(button, f, label); \
+	uiBoxAppend(hbox, uiControl(button), 0); \
+	uiBoxAppend(hbox, uiControl(label), 0); \
+	uiBoxAppend(page5, uiControl(hbox), 0);
+
+	D("Open File", openFile);
+	D("Save File", saveFile);
+
+	title = uiNewEntry();
+	uiEntrySetText(title, "Title");
+	description = uiNewEntry();
+	uiEntrySetText(description, "Description");
+
+	hbox = newHorizontalBox();
+	button = uiNewButton("Message Box");
+	uiButtonOnClicked(button, msgBox, NULL);
+	uiBoxAppend(hbox, uiControl(button), 0);
+	uiBoxAppend(hbox, uiControl(title), 0);
+	uiBoxAppend(page5, uiControl(hbox), 0);
+
+	hbox = newHorizontalBox();
+	button = uiNewButton("Error Box");
+	uiButtonOnClicked(button, msgBoxError, NULL);
+	uiBoxAppend(hbox, uiControl(button), 0);
+	uiBoxAppend(hbox, uiControl(description), 0);
+	uiBoxAppend(page5, uiControl(hbox), 0);
+
+	return page5;
+}
diff --git a/src/libui_sdl/libui/test/page6.c b/src/libui_sdl/libui/test/page6.c
new file mode 100644
index 0000000..896b3d5
--- /dev/null
+++ b/src/libui_sdl/libui/test/page6.c
@@ -0,0 +1,126 @@
+// 8 october 2015
+#include <inttypes.h>
+#include "test.h"
+
+static uiArea *area;
+static uiCombobox *which;
+static uiCheckbox *swallowKeys;
+
+struct handler {
+	uiAreaHandler ah;
+};
+
+static struct handler handler;
+
+static void handlerDraw(uiAreaHandler *a, uiArea *area, uiAreaDrawParams *p)
+{
+	runDrawTest(uiComboboxSelected(which), p);
+}
+
+static void handlerMouseEvent(uiAreaHandler *a, uiArea *area, uiAreaMouseEvent *e)
+{
+	printf("mouse (%g,%g):(%g,%g) down:%d up:%d count:%d mods:%x held:0x%" PRIX64 "\n",
+		e->X,
+		e->Y,
+		e->AreaWidth,
+		e->AreaHeight,
+		(int) e->Down,
+		(int) e->Up,
+		(int) e->Count,
+		(uint32_t) e->Modifiers,
+		e->Held1To64);
+}
+
+static void handlerMouseCrossed(uiAreaHandler *ah, uiArea *a, int left)
+{
+	printf("mouse crossed %d\n", left);
+}
+
+static void handlerDragBroken(uiAreaHandler *ah, uiArea *a)
+{
+	printf("drag broken\n");
+}
+
+static int handlerKeyEvent(uiAreaHandler *ah, uiArea *a, uiAreaKeyEvent *e)
+{
+	char k[4];
+
+	k[0] = '\'';
+	k[1] = e->Key;
+	k[2] = '\'';
+	k[3] = '\0';
+	if (e->Key == 0) {
+		k[0] = '0';
+		k[1] = '\0';
+	}
+	printf("key key:%s extkey:%d mod:%d mods:%d up:%d\n",
+		k,
+		(int) e->ExtKey,
+		(int) e->Modifier,
+		(int) e->Modifiers,
+		e->Up);
+	return uiCheckboxChecked(swallowKeys);
+}
+
+static void shouldntHappen(uiCombobox *c, void *data)
+{
+	fprintf(stderr, "YOU SHOULD NOT SEE THIS. If you do, uiComboboxSetSelected() is triggering uiComboboxOnSelected(), which it should not.\n");
+}
+
+static void redraw(uiCombobox *c, void *data)
+{
+	uiAreaQueueRedrawAll(area);
+}
+
+static void enableArea(uiButton *b, void *data)
+{
+	if (data != NULL)
+		uiControlEnable(uiControl(area));
+	else
+		uiControlDisable(uiControl(area));
+}
+
+uiBox *makePage6(void)
+{
+	uiBox *page6;
+	uiBox *hbox;
+	uiButton *button;
+
+	handler.ah.Draw = handlerDraw;
+	handler.ah.MouseEvent = handlerMouseEvent;
+	handler.ah.MouseCrossed = handlerMouseCrossed;
+	handler.ah.DragBroken = handlerDragBroken;
+	handler.ah.KeyEvent = handlerKeyEvent;
+
+	page6 = newVerticalBox();
+
+	hbox = newHorizontalBox();
+	uiBoxAppend(page6, uiControl(hbox), 0);
+
+	which = uiNewCombobox();
+	populateComboboxWithTests(which);
+	// this is to make sure that uiComboboxOnSelected() doesn't trigger with uiComboboxSetSelected()
+	uiComboboxOnSelected(which, shouldntHappen, NULL);
+	uiComboboxSetSelected(which, 0);
+	uiComboboxOnSelected(which, redraw, NULL);
+	uiBoxAppend(hbox, uiControl(which), 0);
+
+	area = uiNewArea((uiAreaHandler *) (&handler));
+	uiBoxAppend(page6, uiControl(area), 1);
+
+	hbox = newHorizontalBox();
+	uiBoxAppend(page6, uiControl(hbox), 0);
+
+	swallowKeys = uiNewCheckbox("Consider key events handled");
+	uiBoxAppend(hbox, uiControl(swallowKeys), 1);
+
+	button = uiNewButton("Enable");
+	uiButtonOnClicked(button, enableArea, button);
+	uiBoxAppend(hbox, uiControl(button), 0);
+
+	button = uiNewButton("Disable");
+	uiButtonOnClicked(button, enableArea, NULL);
+	uiBoxAppend(hbox, uiControl(button), 0);
+
+	return page6;
+}
diff --git a/src/libui_sdl/libui/test/page7.c b/src/libui_sdl/libui/test/page7.c
new file mode 100644
index 0000000..5cc9114
--- /dev/null
+++ b/src/libui_sdl/libui/test/page7.c
@@ -0,0 +1,25 @@
+// 13 october 2015
+#include "test.h"
+
+uiBox *makePage7(void)
+{
+	uiBox *page7;
+	uiGroup *group;
+	uiBox *box2;
+
+	page7 = newHorizontalBox();
+
+	group = makePage7a();
+	uiBoxAppend(page7, uiControl(group), 1);
+
+	box2 = newVerticalBox();
+	uiBoxAppend(page7, uiControl(box2), 1);
+
+	group = makePage7b();
+	uiBoxAppend(box2, uiControl(group), 1);
+
+	group = makePage7c();
+	uiBoxAppend(box2, uiControl(group), 1);
+
+	return page7;
+}
diff --git a/src/libui_sdl/libui/test/page7a.c b/src/libui_sdl/libui/test/page7a.c
new file mode 100644
index 0000000..72e0321
--- /dev/null
+++ b/src/libui_sdl/libui/test/page7a.c
@@ -0,0 +1,139 @@
+// 13 october 2015
+#include "test.h"
+
+static uiArea *area;
+static uiEntry *startAngle;
+static uiEntry *sweep;
+static uiCheckbox *negative;
+static uiCheckbox *radians;
+
+struct handler {
+	uiAreaHandler ah;
+};
+
+static struct handler handler;
+
+// based on the cairo arc sample
+static void handlerDraw(uiAreaHandler *a, uiArea *area, uiAreaDrawParams *p)
+{
+	double xc = 128.0;
+	double yc = 128.0;
+	double radius = 100.0;
+	uiDrawBrush source;
+	uiDrawStrokeParams sp;
+	uiDrawPath *path;
+	char *startText;
+	char *sweepText;
+	double factor;
+
+	source.Type = uiDrawBrushTypeSolid;
+	source.R = 0;
+	source.G = 0;
+	source.B = 0;
+	source.A = 1;
+	sp.Cap = uiDrawLineCapFlat;
+	sp.Join = uiDrawLineJoinMiter;
+	sp.MiterLimit = uiDrawDefaultMiterLimit;
+	sp.Dashes = NULL;
+	sp.NumDashes = 0;
+	sp.DashPhase = 0;
+
+	startText = uiEntryText(startAngle);
+	sweepText = uiEntryText(sweep);
+
+	factor = uiPi / 180;
+	if (uiCheckboxChecked(radians))
+		factor = 1;
+
+	sp.Thickness = 10.0;
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigure(path, xc, yc);
+	uiDrawPathArcTo(path,
+		xc, yc,
+		radius,
+		atof(startText) * factor,
+		atof(sweepText) * factor,
+		uiCheckboxChecked(negative));
+	uiDrawPathEnd(path);
+	uiDrawStroke(p->Context, path, &source, &sp);
+	uiDrawFreePath(path);
+
+	uiFreeText(startText);
+	uiFreeText(sweepText);
+}
+
+static void handlerMouseEvent(uiAreaHandler *a, uiArea *area, uiAreaMouseEvent *e)
+{
+	// do nothing
+}
+
+static void handlerMouseCrossed(uiAreaHandler *ah, uiArea *a, int left)
+{
+	// do nothing
+}
+
+static void handlerDragBroken(uiAreaHandler *ah, uiArea *a)
+{
+	// do nothing
+}
+
+static int handlerKeyEvent(uiAreaHandler *ah, uiArea *a, uiAreaKeyEvent *e)
+{
+	return 0;
+}
+
+static void entryChanged(uiEntry *e, void *data)
+{
+	uiAreaQueueRedrawAll(area);
+}
+
+static void checkboxToggled(uiCheckbox *c, void *data)
+{
+	uiAreaQueueRedrawAll(area);
+}
+
+uiGroup *makePage7a(void)
+{
+	uiGroup *group;
+	uiBox *box, *box2;
+
+	handler.ah.Draw = handlerDraw;
+	handler.ah.MouseEvent = handlerMouseEvent;
+	handler.ah.MouseCrossed = handlerMouseCrossed;
+	handler.ah.DragBroken = handlerDragBroken;
+	handler.ah.KeyEvent = handlerKeyEvent;
+
+	group = newGroup("Arc Test");
+
+	box = newVerticalBox();
+	uiGroupSetChild(group, uiControl(box));
+
+	area = uiNewArea((uiAreaHandler *) (&handler));
+	uiBoxAppend(box, uiControl(area), 1);
+
+	box2 = newHorizontalBox();
+	uiBoxAppend(box, uiControl(box2), 0);
+
+	uiBoxAppend(box2, uiControl(uiNewLabel("Start Angle")), 0);
+	startAngle = uiNewEntry();
+	uiEntryOnChanged(startAngle, entryChanged, NULL);
+	uiBoxAppend(box2, uiControl(startAngle), 1);
+
+	box2 = newHorizontalBox();
+	uiBoxAppend(box, uiControl(box2), 0);
+
+	uiBoxAppend(box2, uiControl(uiNewLabel("Sweep")), 0);
+	sweep = uiNewEntry();
+	uiEntryOnChanged(sweep, entryChanged, NULL);
+	uiBoxAppend(box2, uiControl(sweep), 1);
+
+	negative = uiNewCheckbox("Negative");
+	uiCheckboxOnToggled(negative, checkboxToggled, NULL);
+	uiBoxAppend(box, uiControl(negative), 0);
+
+	radians = uiNewCheckbox("Radians");
+	uiCheckboxOnToggled(radians, checkboxToggled, NULL);
+	uiBoxAppend(box, uiControl(radians), 0);
+
+	return group;
+}
diff --git a/src/libui_sdl/libui/test/page7b.c b/src/libui_sdl/libui/test/page7b.c
new file mode 100644
index 0000000..d1f98a7
--- /dev/null
+++ b/src/libui_sdl/libui/test/page7b.c
@@ -0,0 +1,71 @@
+// 13 october 2015
+#include "test.h"
+
+static uiArea *area;
+static uiCheckbox *label;
+
+struct handler {
+	uiAreaHandler ah;
+};
+
+static struct handler handler;
+
+static void handlerDraw(uiAreaHandler *a, uiArea *area, uiAreaDrawParams *p)
+{
+	// do nothing
+}
+
+static void handlerMouseEvent(uiAreaHandler *a, uiArea *area, uiAreaMouseEvent *e)
+{
+	char pos[128];
+
+	// wonderful, vanilla snprintf() isn't in visual studio 2013 - http://blogs.msdn.com/b/vcblog/archive/2013/07/19/c99-library-support-in-visual-studio-2013.aspx
+	// we can't use _snprintf() in the test suite because that's msvc-only, so oops. sprintf() it is.
+	sprintf(pos, "X %g Y %g", e->X, e->Y);
+	uiCheckboxSetText(label, pos);
+}
+
+static void handlerMouseCrossed(uiAreaHandler *ah, uiArea *a, int left)
+{
+printf("%d %d\n", left, !left);
+	uiCheckboxSetChecked(label, !left);
+}
+
+static void handlerDragBroken(uiAreaHandler *ah, uiArea *a)
+{
+	// do nothing
+}
+
+static int handlerKeyEvent(uiAreaHandler *ah, uiArea *a, uiAreaKeyEvent *e)
+{
+	if (e->Key == 'h' && !e->Up) {
+		// TODO hide the widget momentarily on the h key
+		return 1;
+	}
+	return 0;
+}
+
+uiGroup *makePage7b(void)
+{
+	uiGroup *group;
+	uiBox *box;
+
+	handler.ah.Draw = handlerDraw;
+	handler.ah.MouseEvent = handlerMouseEvent;
+	handler.ah.MouseCrossed = handlerMouseCrossed;
+	handler.ah.DragBroken = handlerDragBroken;
+	handler.ah.KeyEvent = handlerKeyEvent;
+
+	group = newGroup("Scrolling Mouse Test");
+
+	box = newVerticalBox();
+	uiGroupSetChild(group, uiControl(box));
+
+	area = uiNewScrollingArea((uiAreaHandler *) (&handler), 5000, 5000);
+	uiBoxAppend(box, uiControl(area), 1);
+
+	label = uiNewCheckbox("");
+	uiBoxAppend(box, uiControl(label), 0);
+
+	return group;
+}
diff --git a/src/libui_sdl/libui/test/page7c.c b/src/libui_sdl/libui/test/page7c.c
new file mode 100644
index 0000000..ac6a316
--- /dev/null
+++ b/src/libui_sdl/libui/test/page7c.c
@@ -0,0 +1,133 @@
+// 13 october 2015
+#include "test.h"
+
+static uiArea *area;
+
+struct handler {
+	uiAreaHandler ah;
+};
+
+static struct handler handler;
+
+#define areaSize 250
+#define borderThickness 1
+#define padding 30
+#define circleRadius ((areaSize - padding) / 2)
+
+static void handlerDraw(uiAreaHandler *a, uiArea *area, uiAreaDrawParams *dp)
+{
+	uiDrawPath *path;
+	uiDrawBrush brush;
+	uiDrawStrokeParams sp;
+	uiDrawBrushGradientStop stops[2];
+
+	memset(&brush, 0, sizeof (uiDrawBrush));
+	memset(&sp, 0, sizeof (uiDrawStrokeParams));
+
+	// add some buffering to detect scrolls that aren't on the dot and draws that are outside the scroll area on Windows
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathAddRectangle(path,
+		-50, -50,
+		areaSize + 100, areaSize + 100);
+	uiDrawPathEnd(path);
+	brush.Type = uiDrawBrushTypeSolid;
+	brush.R = 0;
+	brush.G = 1;
+	brush.B = 0;
+	brush.A = 1;
+	uiDrawFill(dp->Context, path, &brush);
+	uiDrawFreePath(path);
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathAddRectangle(path,
+		0, 0,
+		areaSize, areaSize);
+	uiDrawPathEnd(path);
+	brush.Type = uiDrawBrushTypeSolid;
+	brush.R = 1;
+	brush.G = 1;
+	brush.B = 1;
+	brush.A = 1;
+	uiDrawFill(dp->Context, path, &brush);
+	brush.Type = uiDrawBrushTypeSolid;
+	brush.R = 1;
+	brush.G = 0;
+	brush.B = 0;
+	brush.A = 1;
+	sp.Cap = uiDrawLineCapFlat;
+	sp.Join = uiDrawLineJoinMiter;
+	sp.Thickness = 1;
+	sp.MiterLimit = uiDrawDefaultMiterLimit;
+	uiDrawStroke(dp->Context, path, &brush, &sp);
+	uiDrawFreePath(path);
+
+	path = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigureWithArc(path,
+		areaSize / 2, areaSize / 2,
+		circleRadius,
+		0, 2 * uiPi,
+		0);
+	uiDrawPathEnd(path);
+	stops[0].Pos =0.0;
+	stops[0].R = 0.0;
+	stops[0].G = 1.0;
+	stops[0].B = 1.0;
+	stops[0].A = 1.0;
+	stops[1].Pos = 1.0;
+	stops[1].R = 0.0;
+	stops[1].G = 0.0;
+	stops[1].B = 1.0;
+	stops[1].A = 1.0;
+	brush.Type = uiDrawBrushTypeLinearGradient;
+	brush.X0 = areaSize / 2;
+	brush.Y0 = padding;
+	brush.X1 = areaSize / 2;
+	brush.Y1 = areaSize - padding;
+	brush.Stops = stops;
+	brush.NumStops = 2;
+	uiDrawFill(dp->Context, path, &brush);
+	uiDrawFreePath(path);
+}
+
+static void handlerMouseEvent(uiAreaHandler *a, uiArea *area, uiAreaMouseEvent *e)
+{
+	// do nothing
+}
+
+static void handlerMouseCrossed(uiAreaHandler *ah, uiArea *a, int left)
+{
+	// do nothing
+}
+
+static void handlerDragBroken(uiAreaHandler *ah, uiArea *a)
+{
+	// do nothing
+}
+
+static int handlerKeyEvent(uiAreaHandler *ah, uiArea *a, uiAreaKeyEvent *e)
+{
+	if (e->Key == 'h' && !e->Up) {
+		// TODO hide the widget momentarily on the h key
+		return 1;
+	}
+	return 0;
+}
+
+uiGroup *makePage7c(void)
+{
+	uiGroup *group;
+
+	handler.ah.Draw = handlerDraw;
+	handler.ah.MouseEvent = handlerMouseEvent;
+	handler.ah.MouseCrossed = handlerMouseCrossed;
+	handler.ah.DragBroken = handlerDragBroken;
+	handler.ah.KeyEvent = handlerKeyEvent;
+
+	group = newGroup("Scrolling Drawing Test");
+
+	area = uiNewScrollingArea((uiAreaHandler *) (&handler),
+		areaSize, areaSize);
+	uiGroupSetChild(group, uiControl(area));
+
+	return group;
+}
diff --git a/src/libui_sdl/libui/test/page8.c b/src/libui_sdl/libui/test/page8.c
new file mode 100644
index 0000000..7d85556
--- /dev/null
+++ b/src/libui_sdl/libui/test/page8.c
@@ -0,0 +1,46 @@
+// 22 december 2015
+#include "test.h"
+
+static void onListFonts(uiButton *b, void *data)
+{
+	uiDrawFontFamilies *ff;
+	char *this;
+	int i, n;
+
+	uiMultilineEntrySetText(uiMultilineEntry(data), "");
+	ff = uiDrawListFontFamilies();
+	n = uiDrawFontFamiliesNumFamilies(ff);
+	for (i = 0; i < n; i++) {
+		this = uiDrawFontFamiliesFamily(ff, i);
+		uiMultilineEntryAppend(uiMultilineEntry(data), this);
+		uiMultilineEntryAppend(uiMultilineEntry(data), "\n");
+		uiFreeText(this);
+	}
+	uiDrawFreeFontFamilies(ff);
+}
+
+uiBox *makePage8(void)
+{
+	uiBox *page8;
+	uiGroup *group;
+	uiBox *vbox;
+	uiMultilineEntry *me;
+	uiButton *button;
+
+	page8 = newHorizontalBox();
+
+	group = newGroup("Font Families");
+	uiBoxAppend(page8, uiControl(group), 1);
+
+	vbox = newVerticalBox();
+	uiGroupSetChild(group, uiControl(vbox));
+
+	me = uiNewMultilineEntry();
+	uiBoxAppend(vbox, uiControl(me), 1);
+
+	button = uiNewButton("List Font Families");
+	uiButtonOnClicked(button, onListFonts, me);
+	uiBoxAppend(vbox, uiControl(button), 0);
+
+	return page8;
+}
diff --git a/src/libui_sdl/libui/test/page9.c b/src/libui_sdl/libui/test/page9.c
new file mode 100644
index 0000000..65b2d3a
--- /dev/null
+++ b/src/libui_sdl/libui/test/page9.c
@@ -0,0 +1,289 @@
+// 22 december 2015
+#include "test.h"
+
+static uiEntry *textString;
+static uiEntry *textFont;
+static uiEntry *textSize;
+static uiCombobox *textWeight;
+static uiCombobox *textItalic;
+static uiCheckbox *textSmallCaps;
+static uiCombobox *textStretch;
+static uiEntry *textWidth;
+static uiButton *textApply;
+static uiCheckbox *addLeading;
+static uiArea *textArea;
+static uiAreaHandler textAreaHandler;
+
+static double entryDouble(uiEntry *e)
+{
+	char *s;
+	double d;
+
+	s = uiEntryText(e);
+	d = atof(s);
+	uiFreeText(s);
+	return d;
+}
+
+static void drawGuides(uiDrawContext *c, uiDrawTextFontMetrics *m)
+{
+	uiDrawPath *p;
+	uiDrawBrush b;
+	uiDrawStrokeParams sp;
+	double leading;
+	double y;
+
+	leading = 0;
+	if (uiCheckboxChecked(addLeading))
+		leading = m->Leading;
+
+	memset(&b, 0, sizeof (uiDrawBrush));
+	b.Type = uiDrawBrushTypeSolid;
+	memset(&sp, 0, sizeof (uiDrawStrokeParams));
+	sp.Cap = uiDrawLineCapFlat;
+	sp.Join = uiDrawLineJoinMiter;
+	sp.MiterLimit = uiDrawDefaultMiterLimit;
+	sp.Thickness = 2;
+
+	uiDrawSave(c);
+
+	p = uiDrawNewPath(uiDrawFillModeWinding);
+	y = 10;
+	uiDrawPathNewFigure(p, 8, y);
+	y += m->Ascent;
+	uiDrawPathLineTo(p, 8, y);
+	uiDrawPathEnd(p);
+	b.R = 0.94;
+	b.G = 0.5;
+	b.B = 0.5;
+	b.A = 1.0;
+	uiDrawStroke(c, p, &b, &sp);
+	uiDrawFreePath(p);
+
+	p = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigure(p, 8, y);
+	y += m->Descent;
+	uiDrawPathLineTo(p, 8, y);
+	uiDrawPathEnd(p);
+	b.R = 0.12;
+	b.G = 0.56;
+	b.B = 1.0;
+	b.A = 1.0;
+	uiDrawStroke(c, p, &b, &sp);
+	uiDrawFreePath(p);
+
+	// and again for the second line
+	p = uiDrawNewPath(uiDrawFillModeWinding);
+	y += leading;
+	uiDrawPathNewFigure(p, 8, y);
+	y += m->Ascent;
+	uiDrawPathLineTo(p, 8, y);
+	uiDrawPathEnd(p);
+	b.R = 0.94;
+	b.G = 0.5;
+	b.B = 0.5;
+	b.A = 0.75;
+	uiDrawStroke(c, p, &b, &sp);
+	uiDrawFreePath(p);
+
+	p = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathNewFigure(p, 8, y);
+	y += m->Descent;
+	uiDrawPathLineTo(p, 8, y);
+	uiDrawPathEnd(p);
+	b.R = 0.12;
+	b.G = 0.56;
+	b.B = 1.0;
+	b.A = 0.75;
+	uiDrawStroke(c, p, &b, &sp);
+	uiDrawFreePath(p);
+
+	// and a box to text layout top-left corners
+	p = uiDrawNewPath(uiDrawFillModeWinding);
+	uiDrawPathAddRectangle(p, 0, 0, 10, 10);
+	uiDrawPathEnd(p);
+	uiDrawClip(c, p);
+	b.R = 0.85;
+	b.G = 0.65;
+	b.B = 0.13;
+	b.A = 1.0;
+	uiDrawStroke(c, p, &b, &sp);
+	uiDrawFreePath(p);
+
+	uiDrawRestore(c);
+}
+
+static void handlerDraw(uiAreaHandler *a, uiArea *area, uiAreaDrawParams *dp)
+{
+	uiDrawTextFontDescriptor desc;
+	uiDrawTextFont *font;
+	char *s;
+	char *family;		// make compiler happy
+	uiDrawTextLayout *layout;
+	uiDrawTextFontMetrics metrics;
+	double ypos;
+	double width;
+	double height;
+
+	memset(&desc, 0, sizeof (uiDrawTextFontDescriptor));
+	family = uiEntryText(textFont);
+	desc.Family = family;
+	desc.Size = entryDouble(textSize);
+	desc.Weight = uiComboboxSelected(textWeight);
+	desc.Italic = uiComboboxSelected(textItalic);
+	desc.Stretch = uiComboboxSelected(textStretch);
+	font = uiDrawLoadClosestFont(&desc);
+	uiFreeText(family);
+	uiDrawTextFontGetMetrics(font, &metrics);
+
+	width = entryDouble(textWidth);
+
+	drawGuides(dp->Context, &metrics);
+
+	s = uiEntryText(textString);
+	layout = uiDrawNewTextLayout(s, font, width);
+	uiFreeText(s);
+	if (uiCheckboxChecked(textSmallCaps))
+		;	// TODO
+	ypos = 10;
+	uiDrawText(dp->Context, 10, ypos, layout);
+	// TODO make these optional?
+	uiDrawTextLayoutExtents(layout, &width, &height);
+	uiDrawFreeTextLayout(layout);
+
+	layout = uiDrawNewTextLayout("This is a second line", font, -1);
+	if (/*TODO reuse width*/entryDouble(textWidth) < 0) {
+		double ad;
+
+		ad = metrics.Ascent + metrics.Descent;
+		printf("ad:%g extent:%g\n", ad, height);
+	}
+	ypos += height;
+	if (uiCheckboxChecked(addLeading))
+		ypos += metrics.Leading;
+	uiDrawText(dp->Context, 10, ypos, layout);
+	uiDrawFreeTextLayout(layout);
+
+	uiDrawFreeTextFont(font);
+}
+
+static void handlerMouseEvent(uiAreaHandler *a, uiArea *area, uiAreaMouseEvent *e)
+{
+	// do nothing
+}
+
+static void handlerMouseCrossed(uiAreaHandler *ah, uiArea *a, int left)
+{
+	// do nothing
+}
+
+static void handlerDragBroken(uiAreaHandler *ah, uiArea *a)
+{
+	// do nothing
+}
+
+static int handlerKeyEvent(uiAreaHandler *ah, uiArea *a, uiAreaKeyEvent *e)
+{
+	// do nothing
+	return 0;
+}
+
+static void onTextApply(uiButton *b, void *data)
+{
+	uiAreaQueueRedrawAll(textArea);
+}
+
+uiBox *makePage9(void)
+{
+	uiBox *page9;
+	uiBox *vbox;
+	uiBox *hbox;
+
+	page9 = newVerticalBox();
+	vbox = page9;
+
+	hbox = newHorizontalBox();
+	uiBoxAppend(vbox, uiControl(hbox), 0);
+
+	textString = uiNewEntry();
+	// TODO make it placeholder
+	uiEntrySetText(textString, "Enter text here");
+	uiBoxAppend(hbox, uiControl(textString), 1);
+
+	textFont = uiNewEntry();
+	uiEntrySetText(textFont, "Arial");
+	uiBoxAppend(hbox, uiControl(textFont), 1);
+
+	textSize = uiNewEntry();
+	uiEntrySetText(textSize, "10");
+	uiBoxAppend(hbox, uiControl(textSize), 1);
+
+	hbox = newHorizontalBox();
+	uiBoxAppend(vbox, uiControl(hbox), 0);
+
+	textWeight = uiNewCombobox();
+	uiComboboxAppend(textWeight, "Thin");
+	uiComboboxAppend(textWeight, "Ultra Light");
+	uiComboboxAppend(textWeight, "Light");
+	uiComboboxAppend(textWeight, "Book");
+	uiComboboxAppend(textWeight, "Normal");
+	uiComboboxAppend(textWeight, "Medium");
+	uiComboboxAppend(textWeight, "Semi Bold");
+	uiComboboxAppend(textWeight, "Bold");
+	uiComboboxAppend(textWeight, "Ultra Bold");
+	uiComboboxAppend(textWeight, "Heavy");
+	uiComboboxAppend(textWeight, "Ultra Heavy");
+	uiComboboxSetSelected(textWeight, uiDrawTextWeightNormal);
+	uiBoxAppend(hbox, uiControl(textWeight), 1);
+
+	textItalic = uiNewCombobox();
+	uiComboboxAppend(textItalic, "Normal");
+	uiComboboxAppend(textItalic, "Oblique");
+	uiComboboxAppend(textItalic, "Italic");
+	uiComboboxSetSelected(textItalic, uiDrawTextItalicNormal);
+	uiBoxAppend(hbox, uiControl(textItalic), 1);
+
+	textSmallCaps = uiNewCheckbox("Small Caps");
+	uiBoxAppend(hbox, uiControl(textSmallCaps), 1);
+
+	hbox = newHorizontalBox();
+	uiBoxAppend(vbox, uiControl(hbox), 0);
+
+	textStretch = uiNewCombobox();
+	uiComboboxAppend(textStretch, "Ultra Condensed");
+	uiComboboxAppend(textStretch, "Extra Condensed");
+	uiComboboxAppend(textStretch, "Condensed");
+	uiComboboxAppend(textStretch, "Semi Condensed");
+	uiComboboxAppend(textStretch, "Normal");
+	uiComboboxAppend(textStretch, "Semi Expanded");
+	uiComboboxAppend(textStretch, "Expanded");
+	uiComboboxAppend(textStretch, "Extra Expanded");
+	uiComboboxAppend(textStretch, "Ultra Expanded");
+	uiComboboxSetSelected(textStretch, uiDrawTextStretchNormal);
+	uiBoxAppend(hbox, uiControl(textStretch), 1);
+
+	textWidth = uiNewEntry();
+	uiEntrySetText(textWidth, "-1");
+	uiBoxAppend(hbox, uiControl(textWidth), 1);
+
+	hbox = newHorizontalBox();
+	uiBoxAppend(vbox, uiControl(hbox), 0);
+
+	textApply = uiNewButton("Apply");
+	uiButtonOnClicked(textApply, onTextApply, NULL);
+	uiBoxAppend(hbox, uiControl(textApply), 1);
+
+	addLeading = uiNewCheckbox("Add Leading");
+	uiCheckboxSetChecked(addLeading, 1);
+	uiBoxAppend(hbox, uiControl(addLeading), 0);
+
+	textAreaHandler.Draw = handlerDraw;
+	textAreaHandler.MouseEvent = handlerMouseEvent;
+	textAreaHandler.MouseCrossed = handlerMouseCrossed;
+	textAreaHandler.DragBroken = handlerDragBroken;
+	textAreaHandler.KeyEvent = handlerKeyEvent;
+	textArea = uiNewArea(&textAreaHandler);
+	uiBoxAppend(vbox, uiControl(textArea), 1);
+
+	return page9;
+}
diff --git a/src/libui_sdl/libui/test/resources.rc b/src/libui_sdl/libui/test/resources.rc
new file mode 100644
index 0000000..ebc5d6e
--- /dev/null
+++ b/src/libui_sdl/libui/test/resources.rc
@@ -0,0 +1,13 @@
+// 30 may 2015
+
+// this is a UTF-8 file
+#pragma code_page(65001)
+
+// this is the Common Controls 6 manifest
+// TODO set up the string values here
+// 1 is the value of CREATEPROCESS_MANIFEST_RESOURCE_ID and 24 is the value of RT_MANIFEST; we use it directly to avoid needing to share winapi.h with the tests and examples
+#ifndef _UI_STATIC
+1 24 "test.manifest"
+#else
+1 24 "test.static.manifest"
+#endif
diff --git a/src/libui_sdl/libui/test/spaced.c b/src/libui_sdl/libui/test/spaced.c
new file mode 100644
index 0000000..02db99a
--- /dev/null
+++ b/src/libui_sdl/libui/test/spaced.c
@@ -0,0 +1,177 @@
+// 22 april 2015
+#include "test.h"
+
+struct thing {
+	void *ptr;
+	int type;
+};
+
+static struct thing *things = NULL;
+static size_t len = 0;
+static size_t cap = 0;
+
+#define grow 32
+
+static void *append(void *thing, int type)
+{
+	if (len >= cap) {
+		cap += grow;
+		things = (struct thing *) realloc(things, cap * sizeof (struct thing));
+		if (things == NULL)
+			die("reallocating things array in test/spaced.c append()");
+	}
+	things[len].ptr = thing;
+	things[len].type = type;
+	len++;
+	return things[len - 1].ptr;
+}
+
+enum types {
+	window,
+	box,
+	tab,
+	group,
+	form,
+	grid,
+};
+
+void setSpaced(int spaced)
+{
+	size_t i;
+	void *p;
+	size_t j, n;
+
+	for (i = 0; i < len; i++) {
+		p = things[i].ptr;
+		switch (things[i].type) {
+		case window:
+			uiWindowSetMargined(uiWindow(p), spaced);
+			break;
+		case box:
+			uiBoxSetPadded(uiBox(p), spaced);
+			break;
+		case tab:
+			n = uiTabNumPages(uiTab(p));
+			for (j = 0; j < n; j++)
+				uiTabSetMargined(uiTab(p), j, spaced);
+			break;
+		case group:
+			uiGroupSetMargined(uiGroup(p), spaced);
+			break;
+		case form:
+			uiFormSetPadded(uiForm(p), spaced);
+			break;
+		case grid:
+			uiGridSetPadded(uiGrid(p), spaced);
+			break;
+		}
+	}
+}
+
+void querySpaced(char out[12])		// more than enough
+{
+	int m = 0;
+	int p = 0;
+	size_t i;
+	void *pp;
+	size_t j, n;
+
+	for (i = 0; i < len; i++) {
+		pp = things[i].ptr;
+		switch (things[i].type) {
+		case window:
+			if (uiWindowMargined(uiWindow(pp)))
+				m++;
+			break;
+		case box:
+			p = uiBoxPadded(uiBox(pp));
+			break;
+		case tab:
+			n = uiTabNumPages(uiTab(pp));
+			for (j = 0; j < n; j++)
+				if (uiTabMargined(uiTab(pp), j))
+					m++;
+			break;
+		case group:
+			if (uiGroupMargined(uiGroup(pp)))
+				m++;
+			break;
+		// TODO form
+		// TODO grid
+		}
+	}
+
+	out[0] = 'm';
+	out[1] = ' ';
+	out[2] = '0' + m;
+	out[3] = ' ';
+	out[4] = 'p';
+	out[5] = ' ';
+	out[6] = '0';
+	if (p)
+		out[6] = '1';
+	out[7] = '\0';
+}
+
+uiWindow *newWindow(const char *title, int width, int height, int hasMenubar)
+{
+	uiWindow *w;
+
+	w = uiNewWindow(title, width, height, hasMenubar);
+	append(w, window);
+	return w;
+}
+
+uiBox *newHorizontalBox(void)
+{
+	uiBox *b;
+
+	b = (*newhbox)();
+	append(b, box);
+	return b;
+}
+
+uiBox *newVerticalBox(void)
+{
+	uiBox *b;
+
+	b = (*newvbox)();
+	append(b, box);
+	return b;
+}
+
+uiTab *newTab(void)
+{
+	uiTab *t;
+
+	t = uiNewTab();
+	append(t, tab);
+	return t;
+}
+
+uiGroup *newGroup(const char *text)
+{
+	uiGroup *g;
+
+	g = uiNewGroup(text);
+	append(g, group);
+	return g;
+}
+
+uiForm *newForm(void)
+{
+	uiForm *f;
+
+	f = uiNewForm();
+	append(f, form);
+	return f;
+}
+
+uiGrid *newGrid(void)
+{
+	uiGrid *g;
+
+	g = uiNewGrid();
+	append(g, grid);
+	return g;
+}
diff --git a/src/libui_sdl/libui/test/test.h b/src/libui_sdl/libui/test/test.h
new file mode 100644
index 0000000..66b1baa
--- /dev/null
+++ b/src/libui_sdl/libui/test/test.h
@@ -0,0 +1,91 @@
+// 22 april 2015
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdarg.h>
+#include <string.h>
+#include <math.h>
+#include <limits.h>
+#include "../ui.h"
+
+// main.c
+extern void die(const char *, ...);
+extern uiBox *mainBox;
+extern uiTab *mainTab;
+extern uiBox *(*newhbox)(void);
+extern uiBox *(*newvbox)(void);
+
+// spaced.c
+extern void setSpaced(int);
+extern void querySpaced(char[12]);
+extern uiWindow *newWindow(const char *title, int width, int height, int hasMenubar);
+extern uiBox *newHorizontalBox(void);
+extern uiBox *newVerticalBox(void);
+extern uiTab *newTab(void);
+extern uiGroup *newGroup(const char *);
+extern uiForm *newForm(void);
+extern uiGrid *newGrid(void);
+
+// menus.c
+extern uiMenuItem *shouldQuitItem;
+extern void initMenus(void);
+
+// page1.c
+extern uiBox *page1;
+extern void makePage1(uiWindow *);
+
+// page2.c
+extern uiGroup *page2group;
+extern uiBox *makePage2(void);
+
+// page3.c
+extern uiBox *makePage3(void);
+
+// page4.c
+extern uiBox *makePage4(void);
+
+// page5.c
+extern uiBox *makePage5(uiWindow *);
+
+// page6.c
+extern uiBox *makePage6(void);
+
+// drawtests.c
+extern void runDrawTest(int, uiAreaDrawParams *);
+extern void populateComboboxWithTests(uiCombobox *);
+
+// page7.c
+extern uiBox *makePage7(void);
+
+// page7a.c
+extern uiGroup *makePage7a(void);
+
+// page7b.c
+extern uiGroup *makePage7b(void);
+
+// page7c.c
+extern uiGroup *makePage7c(void);
+
+// page8.c
+extern uiBox *makePage8(void);
+
+// page9.c
+extern uiBox *makePage9(void);
+
+// page10.c
+extern uiBox *makePage10(void);
+
+// page11.c
+extern uiBox *makePage11(void);
+
+// page12.c
+extern uiBox *makePage12(void);
+
+// page13.c
+extern uiBox *makePage13(void);
+
+// page14.c
+extern uiTab *makePage14(void);
+
+// page15.c
+extern uiBox *makePage15(uiWindow *);
diff --git a/src/libui_sdl/libui/test/test.manifest b/src/libui_sdl/libui/test/test.manifest
new file mode 100644
index 0000000..41e7c9c
--- /dev/null
+++ b/src/libui_sdl/libui/test/test.manifest
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+<assemblyIdentity
+    version="1.0.0.0"
+    processorArchitecture="*"
+    name="CompanyName.ProductName.YourApplication"
+    type="win32"
+/>
+<description>Your application description here.</description>
+<!-- do NOT include the comctl6 dependency here; this lets us find bugs related to theming -->
+<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
+    <application>
+        <!--The ID below indicates application support for Windows Vista -->
+        <supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/>
+        <!--The ID below indicates application support for Windows 7 -->
+        <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
+    </application>
+</compatibility>
+</assembly>
+
diff --git a/src/libui_sdl/libui/test/test.static.manifest b/src/libui_sdl/libui/test/test.static.manifest
new file mode 100644
index 0000000..d8e83a8
--- /dev/null
+++ b/src/libui_sdl/libui/test/test.static.manifest
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+<assemblyIdentity
+    version="1.0.0.0"
+    processorArchitecture="*"
+    name="CompanyName.ProductName.YourApplication"
+    type="win32"
+/>
+<description>Your application description here.</description>
+<!-- we DO need comctl6 in the static case -->
+<dependency>
+    <dependentAssembly>
+        <assemblyIdentity
+            type="win32"
+            name="Microsoft.Windows.Common-Controls"
+            version="6.0.0.0"
+            processorArchitecture="*"
+            publicKeyToken="6595b64144ccf1df"
+            language="*"
+        />
+    </dependentAssembly>
+</dependency>
+<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
+    <application>
+        <!--The ID below indicates application support for Windows Vista -->
+        <supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/>
+        <!--The ID below indicates application support for Windows 7 -->
+        <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
+    </application>
+</compatibility>
+</assembly>
+
diff --git a/src/libui_sdl/libui/ui.h b/src/libui_sdl/libui/ui.h
new file mode 100644
index 0000000..5a2069e
--- /dev/null
+++ b/src/libui_sdl/libui/ui.h
@@ -0,0 +1,691 @@
+// 6 april 2015
+
+// TODO add a uiVerifyControlType() function that can be used by control implementations to verify controls
+
+#ifndef __LIBUI_UI_H__
+#define __LIBUI_UI_H__
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// this macro is generated by cmake
+#ifdef libui_EXPORTS
+#ifdef _WIN32
+#define _UI_EXTERN __declspec(dllexport) extern
+#else
+#define _UI_EXTERN __attribute__((visibility("default"))) extern
+#endif
+#else
+// TODO add __declspec(dllimport) on windows, but only if not static
+#define _UI_EXTERN extern
+#endif
+
+// C++ is really really really really really really dumb about enums, so screw that and just make them anonymous
+// This has the advantage of being ABI-able should we ever need an ABI...
+#define _UI_ENUM(s) typedef unsigned int s; enum
+
+// This constant is provided because M_PI is nonstandard.
+// This comes from Go's math.Pi, which in turn comes from http://oeis.org/A000796.
+#define uiPi 3.14159265358979323846264338327950288419716939937510582097494459
+
+// TODO uiBool?
+
+typedef struct uiInitOptions uiInitOptions;
+
+struct uiInitOptions {
+	size_t Size;
+};
+
+_UI_EXTERN const char *uiInit(uiInitOptions *options);
+_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);
+
+_UI_EXTERN void uiOnShouldQuit(int (*f)(void *data), void *data);
+
+_UI_EXTERN void uiFreeText(char *text);
+
+typedef struct uiControl uiControl;
+
+struct uiControl {
+	uint32_t Signature;
+	uint32_t OSSignature;
+	uint32_t TypeSignature;
+	void (*Destroy)(uiControl *);
+	uintptr_t (*Handle)(uiControl *);
+	uiControl *(*Parent)(uiControl *);
+	void (*SetParent)(uiControl *, uiControl *);
+	int (*Toplevel)(uiControl *);
+	int (*Visible)(uiControl *);
+	void (*Show)(uiControl *);
+	void (*Hide)(uiControl *);
+	int (*Enabled)(uiControl *);
+	void (*Enable)(uiControl *);
+	void (*Disable)(uiControl *);
+};
+// TOOD add argument names to all arguments
+#define uiControl(this) ((uiControl *) (this))
+_UI_EXTERN void uiControlDestroy(uiControl *);
+_UI_EXTERN uintptr_t uiControlHandle(uiControl *);
+_UI_EXTERN uiControl *uiControlParent(uiControl *);
+_UI_EXTERN void uiControlSetParent(uiControl *, uiControl *);
+_UI_EXTERN int uiControlToplevel(uiControl *);
+_UI_EXTERN int uiControlVisible(uiControl *);
+_UI_EXTERN void uiControlShow(uiControl *);
+_UI_EXTERN void uiControlHide(uiControl *);
+_UI_EXTERN int uiControlEnabled(uiControl *);
+_UI_EXTERN void uiControlEnable(uiControl *);
+_UI_EXTERN void uiControlDisable(uiControl *);
+
+_UI_EXTERN uiControl *uiAllocControl(size_t n, uint32_t OSsig, uint32_t typesig, const char *typenamestr);
+_UI_EXTERN void uiFreeControl(uiControl *);
+
+// TODO make sure all controls have these
+_UI_EXTERN void uiControlVerifySetParent(uiControl *, uiControl *);
+_UI_EXTERN int uiControlEnabledToUser(uiControl *);
+
+_UI_EXTERN void uiUserBugCannotSetParentOnToplevel(const char *type);
+
+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);
+_UI_EXTERN uiWindow *uiNewWindow(const char *title, int width, int height, int hasMenubar);
+
+typedef struct uiButton uiButton;
+#define uiButton(this) ((uiButton *) (this))
+_UI_EXTERN char *uiButtonText(uiButton *b);
+_UI_EXTERN void uiButtonSetText(uiButton *b, const char *text);
+_UI_EXTERN void uiButtonOnClicked(uiButton *b, void (*f)(uiButton *b, void *data), void *data);
+_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, int index);
+_UI_EXTERN int uiBoxPadded(uiBox *b);
+_UI_EXTERN void uiBoxSetPadded(uiBox *b, int padded);
+_UI_EXTERN uiBox *uiNewHorizontalBox(void);
+_UI_EXTERN uiBox *uiNewVerticalBox(void);
+
+typedef struct uiCheckbox uiCheckbox;
+#define uiCheckbox(this) ((uiCheckbox *) (this))
+_UI_EXTERN char *uiCheckboxText(uiCheckbox *c);
+_UI_EXTERN void uiCheckboxSetText(uiCheckbox *c, const char *text);
+_UI_EXTERN void uiCheckboxOnToggled(uiCheckbox *c, void (*f)(uiCheckbox *c, void *data), void *data);
+_UI_EXTERN int uiCheckboxChecked(uiCheckbox *c);
+_UI_EXTERN void uiCheckboxSetChecked(uiCheckbox *c, int checked);
+_UI_EXTERN uiCheckbox *uiNewCheckbox(const char *text);
+
+typedef struct uiEntry uiEntry;
+#define uiEntry(this) ((uiEntry *) (this))
+_UI_EXTERN char *uiEntryText(uiEntry *e);
+_UI_EXTERN void uiEntrySetText(uiEntry *e, const char *text);
+_UI_EXTERN void uiEntryOnChanged(uiEntry *e, void (*f)(uiEntry *e, void *data), 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))
+_UI_EXTERN char *uiLabelText(uiLabel *l);
+_UI_EXTERN void uiLabelSetText(uiLabel *l, const char *text);
+_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, 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;
+#define uiGroup(this) ((uiGroup *) (this))
+_UI_EXTERN char *uiGroupTitle(uiGroup *g);
+_UI_EXTERN void uiGroupSetTitle(uiGroup *g, const char *title);
+_UI_EXTERN void uiGroupSetChild(uiGroup *g, uiControl *c);
+_UI_EXTERN int uiGroupMargined(uiGroup *g);
+_UI_EXTERN void uiGroupSetMargined(uiGroup *g, int margined);
+_UI_EXTERN uiGroup *uiNewGroup(const char *title);
+
+// spinbox/slider rules:
+// setting value outside of range will automatically clamp
+// initial value is minimum
+// complaint if min >= max?
+
+typedef struct uiSpinbox uiSpinbox;
+#define uiSpinbox(this) ((uiSpinbox *) (this))
+_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(int min, int max);
+
+typedef struct uiSlider uiSlider;
+#define uiSlider(this) ((uiSlider *) (this))
+_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(int min, int max);
+
+typedef struct uiProgressBar uiProgressBar;
+#define uiProgressBar(this) ((uiProgressBar *) (this))
+_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 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);
+
+typedef struct uiEditableCombobox uiEditableCombobox;
+#define uiEditableCombobox(this) ((uiEditableCombobox *) (this))
+_UI_EXTERN void uiEditableComboboxAppend(uiEditableCombobox *c, const char *text);
+_UI_EXTERN char *uiEditableComboboxText(uiEditableCombobox *c);
+_UI_EXTERN void uiEditableComboboxSetText(uiEditableCombobox *c, const char *text);
+// TODO what do we call a function that sets the currently selected item and fills the text field with it? editable comboboxes have no consistent concept of selected item
+_UI_EXTERN void uiEditableComboboxOnChanged(uiEditableCombobox *c, void (*f)(uiEditableCombobox *c, void *data), void *data);
+_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);
+
+typedef struct uiDateTimePicker uiDateTimePicker;
+#define uiDateTimePicker(this) ((uiDateTimePicker *) (this))
+_UI_EXTERN uiDateTimePicker *uiNewDateTimePicker(void);
+_UI_EXTERN uiDateTimePicker *uiNewDatePicker(void);
+_UI_EXTERN uiDateTimePicker *uiNewTimePicker(void);
+
+// TODO provide a facility for entering tab stops?
+typedef struct uiMultilineEntry uiMultilineEntry;
+#define uiMultilineEntry(this) ((uiMultilineEntry *) (this))
+_UI_EXTERN char *uiMultilineEntryText(uiMultilineEntry *e);
+_UI_EXTERN void uiMultilineEntrySetText(uiMultilineEntry *e, const char *text);
+_UI_EXTERN void uiMultilineEntryAppend(uiMultilineEntry *e, const char *text);
+_UI_EXTERN void uiMultilineEntryOnChanged(uiMultilineEntry *e, void (*f)(uiMultilineEntry *e, void *data), void *data);
+_UI_EXTERN int uiMultilineEntryReadOnly(uiMultilineEntry *e);
+_UI_EXTERN void uiMultilineEntrySetReadOnly(uiMultilineEntry *e, int readonly);
+_UI_EXTERN uiMultilineEntry *uiNewMultilineEntry(void);
+_UI_EXTERN uiMultilineEntry *uiNewNonWrappingMultilineEntry(void);
+
+typedef struct uiMenuItem uiMenuItem;
+#define uiMenuItem(this) ((uiMenuItem *) (this))
+_UI_EXTERN void uiMenuItemEnable(uiMenuItem *m);
+_UI_EXTERN void uiMenuItemDisable(uiMenuItem *m);
+_UI_EXTERN void uiMenuItemOnClicked(uiMenuItem *m, void (*f)(uiMenuItem *sender, uiWindow *window, void *data), void *data);
+_UI_EXTERN int uiMenuItemChecked(uiMenuItem *m);
+_UI_EXTERN void uiMenuItemSetChecked(uiMenuItem *m, int checked);
+
+typedef struct uiMenu uiMenu;
+#define uiMenu(this) ((uiMenu *) (this))
+_UI_EXTERN uiMenuItem *uiMenuAppendItem(uiMenu *m, const char *name);
+_UI_EXTERN uiMenuItem *uiMenuAppendCheckItem(uiMenu *m, const char *name);
+_UI_EXTERN uiMenuItem *uiMenuAppendQuitItem(uiMenu *m);
+_UI_EXTERN uiMenuItem *uiMenuAppendPreferencesItem(uiMenu *m);
+_UI_EXTERN uiMenuItem *uiMenuAppendAboutItem(uiMenu *m);
+_UI_EXTERN void uiMenuAppendSeparator(uiMenu *m);
+_UI_EXTERN uiMenu *uiNewMenu(const char *name);
+
+_UI_EXTERN char *uiOpenFile(uiWindow *parent);
+_UI_EXTERN char *uiSaveFile(uiWindow *parent);
+_UI_EXTERN void uiMsgBox(uiWindow *parent, const char *title, const char *description);
+_UI_EXTERN void uiMsgBoxError(uiWindow *parent, const char *title, const char *description);
+
+typedef struct uiArea uiArea;
+typedef struct uiAreaHandler uiAreaHandler;
+typedef struct uiAreaDrawParams uiAreaDrawParams;
+typedef struct uiAreaMouseEvent uiAreaMouseEvent;
+typedef struct uiAreaKeyEvent uiAreaKeyEvent;
+
+typedef struct uiDrawContext uiDrawContext;
+
+struct uiAreaHandler {
+	void (*Draw)(uiAreaHandler *, uiArea *, uiAreaDrawParams *);
+	// TODO document that resizes cause a full redraw for non-scrolling areas; implementation-defined for scrolling areas
+	void (*MouseEvent)(uiAreaHandler *, uiArea *, uiAreaMouseEvent *);
+	// TODO document that on first show if the mouse is already in the uiArea then one gets sent with left=0
+	// TODO what about when the area is hidden and then shown again?
+	void (*MouseCrossed)(uiAreaHandler *, uiArea *, int left);
+	void (*DragBroken)(uiAreaHandler *, uiArea *);
+	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, 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, int width, int height);
+
+struct uiAreaDrawParams {
+	uiDrawContext *Context;
+
+	// TODO document that this is only defined for nonscrolling areas
+	double AreaWidth;
+	double AreaHeight;
+
+	double ClipX;
+	double ClipY;
+	double ClipWidth;
+	double ClipHeight;
+};
+
+typedef struct uiDrawPath uiDrawPath;
+typedef struct uiDrawBrush uiDrawBrush;
+typedef struct uiDrawStrokeParams uiDrawStrokeParams;
+typedef struct uiDrawMatrix uiDrawMatrix;
+
+typedef struct uiDrawBrushGradientStop uiDrawBrushGradientStop;
+
+_UI_ENUM(uiDrawBrushType) {
+	uiDrawBrushTypeSolid,
+	uiDrawBrushTypeLinearGradient,
+	uiDrawBrushTypeRadialGradient,
+	uiDrawBrushTypeImage,
+};
+
+_UI_ENUM(uiDrawLineCap) {
+	uiDrawLineCapFlat,
+	uiDrawLineCapRound,
+	uiDrawLineCapSquare,
+};
+
+_UI_ENUM(uiDrawLineJoin) {
+	uiDrawLineJoinMiter,
+	uiDrawLineJoinRound,
+	uiDrawLineJoinBevel,
+};
+
+// this is the default for botoh cairo and Direct2D (in the latter case, from the C++ helper functions)
+// Core Graphics doesn't explicitly specify a default, but NSBezierPath allows you to choose one, and this is the initial value
+// so we're good to use it too!
+#define uiDrawDefaultMiterLimit 10.0
+
+_UI_ENUM(uiDrawFillMode) {
+	uiDrawFillModeWinding,
+	uiDrawFillModeAlternate,
+};
+
+struct uiDrawMatrix {
+	double M11;
+	double M12;
+	double M21;
+	double M22;
+	double M31;
+	double M32;
+};
+
+struct uiDrawBrush {
+	uiDrawBrushType Type;
+
+	// solid brushes
+	double R;
+	double G;
+	double B;
+	double A;
+
+	// gradient brushes
+	double X0;		// linear: start X, radial: start X
+	double Y0;		// linear: start Y, radial: start Y
+	double X1;		// linear: end X, radial: outer circle center X
+	double Y1;		// linear: end Y, radial: outer circle center Y
+	double OuterRadius;		// radial gradients only
+	uiDrawBrushGradientStop *Stops;
+	size_t NumStops;
+	// TODO extend mode
+	// cairo: none, repeat, reflect, pad; no individual control
+	// Direct2D: repeat, reflect, pad; no individual control
+	// Core Graphics: none, pad; before and after individually
+	// TODO cairo documentation is inconsistent about pad
+
+	// TODO images
+
+	// TODO transforms
+};
+
+struct uiDrawBrushGradientStop {
+	double Pos;
+	double R;
+	double G;
+	double B;
+	double A;
+};
+
+struct uiDrawStrokeParams {
+	uiDrawLineCap Cap;
+	uiDrawLineJoin Join;
+	// TODO what if this is 0? on windows there will be a crash with dashing
+	double Thickness;
+	double MiterLimit;
+	double *Dashes;
+	// TOOD what if this is 1 on Direct2D?
+	// TODO what if a dash is 0 on Cairo or Quartz?
+	size_t NumDashes;
+	double DashPhase;
+};
+
+_UI_EXTERN uiDrawPath *uiDrawNewPath(uiDrawFillMode fillMode);
+_UI_EXTERN void uiDrawFreePath(uiDrawPath *p);
+
+_UI_EXTERN void uiDrawPathNewFigure(uiDrawPath *p, double x, double y);
+_UI_EXTERN void uiDrawPathNewFigureWithArc(uiDrawPath *p, double xCenter, double yCenter, double radius, double startAngle, double sweep, int negative);
+_UI_EXTERN void uiDrawPathLineTo(uiDrawPath *p, double x, double y);
+// notes: angles are both relative to 0 and go counterclockwise
+// TODO is the initial line segment on cairo and OS X a proper join?
+// TODO what if sweep < 0?
+_UI_EXTERN void uiDrawPathArcTo(uiDrawPath *p, double xCenter, double yCenter, double radius, double startAngle, double sweep, int negative);
+_UI_EXTERN void uiDrawPathBezierTo(uiDrawPath *p, double c1x, double c1y, double c2x, double c2y, double endX, double endY);
+// TODO quadratic bezier
+_UI_EXTERN void uiDrawPathCloseFigure(uiDrawPath *p);
+
+// TODO effect of these when a figure is already started
+_UI_EXTERN void uiDrawPathAddRectangle(uiDrawPath *p, double x, double y, double width, double height);
+
+_UI_EXTERN void uiDrawPathEnd(uiDrawPath *p);
+
+_UI_EXTERN void uiDrawStroke(uiDrawContext *c, uiDrawPath *path, uiDrawBrush *b, uiDrawStrokeParams *p);
+_UI_EXTERN void uiDrawFill(uiDrawContext *c, uiDrawPath *path, uiDrawBrush *b);
+
+// TODO primitives:
+// - rounded rectangles
+// - elliptical arcs
+// - quadratic bezier curves
+
+_UI_EXTERN void uiDrawMatrixSetIdentity(uiDrawMatrix *m);
+_UI_EXTERN void uiDrawMatrixTranslate(uiDrawMatrix *m, double x, double y);
+_UI_EXTERN void uiDrawMatrixScale(uiDrawMatrix *m, double xCenter, double yCenter, double x, double y);
+_UI_EXTERN void uiDrawMatrixRotate(uiDrawMatrix *m, double x, double y, double amount);
+_UI_EXTERN void uiDrawMatrixSkew(uiDrawMatrix *m, double x, double y, double xamount, double yamount);
+_UI_EXTERN void uiDrawMatrixMultiply(uiDrawMatrix *dest, uiDrawMatrix *src);
+_UI_EXTERN int uiDrawMatrixInvertible(uiDrawMatrix *m);
+_UI_EXTERN int uiDrawMatrixInvert(uiDrawMatrix *m);
+_UI_EXTERN void uiDrawMatrixTransformPoint(uiDrawMatrix *m, double *x, double *y);
+_UI_EXTERN void uiDrawMatrixTransformSize(uiDrawMatrix *m, double *x, double *y);
+
+_UI_EXTERN void uiDrawTransform(uiDrawContext *c, uiDrawMatrix *m);
+
+// TODO add a uiDrawPathStrokeToFill() or something like that
+_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
+
+///// TODO reconsider this
+typedef struct uiDrawFontFamilies uiDrawFontFamilies;
+
+_UI_EXTERN uiDrawFontFamilies *uiDrawListFontFamilies(void);
+_UI_EXTERN int uiDrawFontFamiliesNumFamilies(uiDrawFontFamilies *ff);
+_UI_EXTERN char *uiDrawFontFamiliesFamily(uiDrawFontFamilies *ff, int n);
+_UI_EXTERN void uiDrawFreeFontFamilies(uiDrawFontFamilies *ff);
+///// END TODO
+
+typedef struct uiDrawTextLayout uiDrawTextLayout;
+typedef struct uiDrawTextFont uiDrawTextFont;
+typedef struct uiDrawTextFontDescriptor uiDrawTextFontDescriptor;
+typedef struct uiDrawTextFontMetrics uiDrawTextFontMetrics;
+
+_UI_ENUM(uiDrawTextWeight) {
+	uiDrawTextWeightThin,
+	uiDrawTextWeightUltraLight,
+	uiDrawTextWeightLight,
+	uiDrawTextWeightBook,
+	uiDrawTextWeightNormal,
+	uiDrawTextWeightMedium,
+	uiDrawTextWeightSemiBold,
+	uiDrawTextWeightBold,
+	uiDrawTextWeightUltraBold,
+	uiDrawTextWeightHeavy,
+	uiDrawTextWeightUltraHeavy,
+};
+
+_UI_ENUM(uiDrawTextItalic) {
+	uiDrawTextItalicNormal,
+	uiDrawTextItalicOblique,
+	uiDrawTextItalicItalic,
+};
+
+_UI_ENUM(uiDrawTextStretch) {
+	uiDrawTextStretchUltraCondensed,
+	uiDrawTextStretchExtraCondensed,
+	uiDrawTextStretchCondensed,
+	uiDrawTextStretchSemiCondensed,
+	uiDrawTextStretchNormal,
+	uiDrawTextStretchSemiExpanded,
+	uiDrawTextStretchExpanded,
+	uiDrawTextStretchExtraExpanded,
+	uiDrawTextStretchUltraExpanded,
+};
+
+struct uiDrawTextFontDescriptor {
+	const char *Family;
+	double Size;
+	uiDrawTextWeight Weight;
+	uiDrawTextItalic Italic;
+	uiDrawTextStretch Stretch;
+};
+
+struct uiDrawTextFontMetrics {
+	double Ascent;
+	double Descent;
+	double Leading;
+	// TODO do these two mean the same across all platforms?
+	double UnderlinePos;
+	double UnderlineThickness;
+};
+
+_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);
+
+// 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);
+
+// and the attributes that you can set on a text layout
+_UI_EXTERN void uiDrawTextLayoutSetColor(uiDrawTextLayout *layout, int startChar, int endChar, double r, double g, double b, double a);
+
+_UI_EXTERN void uiDrawText(uiDrawContext *c, double x, double y, uiDrawTextLayout *layout);
+
+_UI_ENUM(uiModifiers) {
+	uiModifierCtrl = 1 << 0,
+	uiModifierAlt = 1 << 1,
+	uiModifierShift = 1 << 2,
+	uiModifierSuper = 1 << 3,
+};
+
+// TODO document drag captures
+struct uiAreaMouseEvent {
+	// TODO document what these mean for scrolling areas
+	double X;
+	double Y;
+
+	// TODO see draw above
+	double AreaWidth;
+	double AreaHeight;
+
+	int Down;
+	int Up;
+
+	int Count;
+
+	uiModifiers Modifiers;
+
+	uint64_t Held1To64;
+};
+
+_UI_ENUM(uiExtKey) {
+	uiExtKeyEscape = 1,
+	uiExtKeyInsert,			// equivalent to "Help" on Apple keyboards
+	uiExtKeyDelete,
+	uiExtKeyHome,
+	uiExtKeyEnd,
+	uiExtKeyPageUp,
+	uiExtKeyPageDown,
+	uiExtKeyUp,
+	uiExtKeyDown,
+	uiExtKeyLeft,
+	uiExtKeyRight,
+	uiExtKeyF1,			// F1..F12 are guaranteed to be consecutive
+	uiExtKeyF2,
+	uiExtKeyF3,
+	uiExtKeyF4,
+	uiExtKeyF5,
+	uiExtKeyF6,
+	uiExtKeyF7,
+	uiExtKeyF8,
+	uiExtKeyF9,
+	uiExtKeyF10,
+	uiExtKeyF11,
+	uiExtKeyF12,
+	uiExtKeyN0,			// numpad keys; independent of Num Lock state
+	uiExtKeyN1,			// N0..N9 are guaranteed to be consecutive
+	uiExtKeyN2,
+	uiExtKeyN3,
+	uiExtKeyN4,
+	uiExtKeyN5,
+	uiExtKeyN6,
+	uiExtKeyN7,
+	uiExtKeyN8,
+	uiExtKeyN9,
+	uiExtKeyNDot,
+	uiExtKeyNEnter,
+	uiExtKeyNAdd,
+	uiExtKeyNSubtract,
+	uiExtKeyNMultiply,
+	uiExtKeyNDivide,
+};
+
+struct uiAreaKeyEvent {
+	char Key;
+	uiExtKey ExtKey;
+	uiModifiers Modifier;
+
+	uiModifiers Modifiers;
+
+	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);
+_UI_EXTERN void uiColorButtonSetColor(uiColorButton *b, double r, double g, double bl, double a);
+_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);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/libui_sdl/libui/ui_darwin.h b/src/libui_sdl/libui/ui_darwin.h
new file mode 100644
index 0000000..c9c6ad5
--- /dev/null
+++ b/src/libui_sdl/libui/ui_darwin.h
@@ -0,0 +1,224 @@
+// 7 april 2015
+
+/*
+This file assumes that you have imported <Cocoa/Cocoa.h> and "ui.h" beforehand. It provides API-specific functions for interfacing with foreign controls on Mac OS X.
+*/
+
+#ifndef __LIBUI_UI_DARWIN_H__
+#define __LIBUI_UI_DARWIN_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct uiDarwinControl uiDarwinControl;
+struct uiDarwinControl {
+	uiControl c;
+	uiControl *parent;
+	BOOL enabled;
+	BOOL visible;
+	void (*SyncEnableState)(uiDarwinControl *, int);
+	void (*SetSuperview)(uiDarwinControl *, NSView *);
+	BOOL (*HugsTrailingEdge)(uiDarwinControl *);
+	BOOL (*HugsBottom)(uiDarwinControl *);
+	void (*ChildEdgeHuggingChanged)(uiDarwinControl *);
+	NSLayoutPriority (*HuggingPriority)(uiDarwinControl *, NSLayoutConstraintOrientation);
+	void (*SetHuggingPriority)(uiDarwinControl *, NSLayoutPriority, NSLayoutConstraintOrientation);
+	void (*ChildVisibilityChanged)(uiDarwinControl *);
+};
+#define uiDarwinControl(this) ((uiDarwinControl *) (this))
+// TODO document
+_UI_EXTERN void uiDarwinControlSyncEnableState(uiDarwinControl *, int);
+_UI_EXTERN void uiDarwinControlSetSuperview(uiDarwinControl *, NSView *);
+_UI_EXTERN BOOL uiDarwinControlHugsTrailingEdge(uiDarwinControl *);
+_UI_EXTERN BOOL uiDarwinControlHugsBottom(uiDarwinControl *);
+_UI_EXTERN void uiDarwinControlChildEdgeHuggingChanged(uiDarwinControl *);
+_UI_EXTERN NSLayoutPriority uiDarwinControlHuggingPriority(uiDarwinControl *, NSLayoutConstraintOrientation);
+_UI_EXTERN void uiDarwinControlSetHuggingPriority(uiDarwinControl *, NSLayoutPriority, NSLayoutConstraintOrientation);
+_UI_EXTERN void uiDarwinControlChildVisibilityChanged(uiDarwinControl *);
+
+#define uiDarwinControlDefaultDestroy(type, handlefield) \
+	static void type ## Destroy(uiControl *c) \
+	{ \
+		[type(c)->handlefield release]; \
+		uiFreeControl(c); \
+	}
+#define uiDarwinControlDefaultHandle(type, handlefield) \
+	static uintptr_t type ## Handle(uiControl *c) \
+	{ \
+		return (uintptr_t) (type(c)->handlefield); \
+	}
+#define uiDarwinControlDefaultParent(type, handlefield) \
+	static uiControl *type ## Parent(uiControl *c) \
+	{ \
+		return uiDarwinControl(c)->parent; \
+	}
+#define uiDarwinControlDefaultSetParent(type, handlefield) \
+	static void type ## SetParent(uiControl *c, uiControl *parent) \
+	{ \
+		uiControlVerifySetParent(c, parent); \
+		uiDarwinControl(c)->parent = parent; \
+	}
+#define uiDarwinControlDefaultToplevel(type, handlefield) \
+	static int type ## Toplevel(uiControl *c) \
+	{ \
+		return 0; \
+	}
+#define uiDarwinControlDefaultVisible(type, handlefield) \
+	static int type ## Visible(uiControl *c) \
+	{ \
+		return uiDarwinControl(c)->visible; \
+	}
+#define uiDarwinControlDefaultShow(type, handlefield) \
+	static void type ## Show(uiControl *c) \
+	{ \
+		uiDarwinControl(c)->visible = YES; \
+		[type(c)->handlefield setHidden:NO]; \
+		uiDarwinNotifyVisibilityChanged(uiDarwinControl(c)); \
+	}
+#define uiDarwinControlDefaultHide(type, handlefield) \
+	static void type ## Hide(uiControl *c) \
+	{ \
+		uiDarwinControl(c)->visible = NO; \
+		[type(c)->handlefield setHidden:YES]; \
+		uiDarwinNotifyVisibilityChanged(uiDarwinControl(c)); \
+	}
+#define uiDarwinControlDefaultEnabled(type, handlefield) \
+	static int type ## Enabled(uiControl *c) \
+	{ \
+		return uiDarwinControl(c)->enabled; \
+	}
+#define uiDarwinControlDefaultEnable(type, handlefield) \
+	static void type ## Enable(uiControl *c) \
+	{ \
+		uiDarwinControl(c)->enabled = YES; \
+		uiDarwinControlSyncEnableState(uiDarwinControl(c), uiControlEnabledToUser(c)); \
+	}
+#define uiDarwinControlDefaultDisable(type, handlefield) \
+	static void type ## Disable(uiControl *c) \
+	{ \
+		uiDarwinControl(c)->enabled = NO; \
+		uiDarwinControlSyncEnableState(uiDarwinControl(c), uiControlEnabledToUser(c)); \
+	}
+#define uiDarwinControlDefaultSyncEnableState(type, handlefield) \
+	static void type ## SyncEnableState(uiDarwinControl *c, int enabled) \
+	{ \
+		if (uiDarwinShouldStopSyncEnableState(c, enabled)) \
+			return; \
+		if ([type(c)->handlefield respondsToSelector:@selector(setEnabled:)]) \
+			[((id) (type(c)->handlefield)) setEnabled:enabled]; /* id cast to make compiler happy; thanks mikeash in irc.freenode.net/#macdev */ \
+	}
+#define uiDarwinControlDefaultSetSuperview(type, handlefield) \
+	static void type ## SetSuperview(uiDarwinControl *c, NSView *superview) \
+	{ \
+		[type(c)->handlefield setTranslatesAutoresizingMaskIntoConstraints:NO]; \
+		if (superview == nil) \
+			[type(c)->handlefield removeFromSuperview]; \
+		else \
+			[superview addSubview:type(c)->handlefield]; \
+	}
+#define uiDarwinControlDefaultHugsTrailingEdge(type, handlefield) \
+	static BOOL type ## HugsTrailingEdge(uiDarwinControl *c) \
+	{ \
+		return YES; /* always hug by default */ \
+	}
+#define uiDarwinControlDefaultHugsBottom(type, handlefield) \
+	static BOOL type ## HugsBottom(uiDarwinControl *c) \
+	{ \
+		return YES; /* always hug by default */ \
+	}
+#define uiDarwinControlDefaultChildEdgeHuggingChanged(type, handlefield) \
+	static void type ## ChildEdgeHuggingChanged(uiDarwinControl *c) \
+	{ \
+		/* do nothing */ \
+	}
+#define uiDarwinControlDefaultHuggingPriority(type, handlefield) \
+	static NSLayoutPriority type ## HuggingPriority(uiDarwinControl *c, NSLayoutConstraintOrientation orientation) \
+	{ \
+		return [type(c)->handlefield contentHuggingPriorityForOrientation:orientation]; \
+	}
+#define uiDarwinControlDefaultSetHuggingPriority(type, handlefield) \
+	static void type ## SetHuggingPriority(uiDarwinControl *c, NSLayoutPriority priority, NSLayoutConstraintOrientation orientation) \
+	{ \
+		[type(c)->handlefield setContentHuggingPriority:priority forOrientation:orientation]; \
+	}
+#define uiDarwinControlDefaultChildVisibilityChanged(type, handlefield) \
+	static void type ## ChildVisibilityChanged(uiDarwinControl *c) \
+	{ \
+		/* do nothing */ \
+	}
+
+#define uiDarwinControlAllDefaultsExceptDestroy(type, handlefield) \
+	uiDarwinControlDefaultHandle(type, handlefield) \
+	uiDarwinControlDefaultParent(type, handlefield) \
+	uiDarwinControlDefaultSetParent(type, handlefield) \
+	uiDarwinControlDefaultToplevel(type, handlefield) \
+	uiDarwinControlDefaultVisible(type, handlefield) \
+	uiDarwinControlDefaultShow(type, handlefield) \
+	uiDarwinControlDefaultHide(type, handlefield) \
+	uiDarwinControlDefaultEnabled(type, handlefield) \
+	uiDarwinControlDefaultEnable(type, handlefield) \
+	uiDarwinControlDefaultDisable(type, handlefield) \
+	uiDarwinControlDefaultSyncEnableState(type, handlefield) \
+	uiDarwinControlDefaultSetSuperview(type, handlefield) \
+	uiDarwinControlDefaultHugsTrailingEdge(type, handlefield) \
+	uiDarwinControlDefaultHugsBottom(type, handlefield) \
+	uiDarwinControlDefaultChildEdgeHuggingChanged(type, handlefield) \
+	uiDarwinControlDefaultHuggingPriority(type, handlefield) \
+	uiDarwinControlDefaultSetHuggingPriority(type, handlefield) \
+	uiDarwinControlDefaultChildVisibilityChanged(type, handlefield)
+
+#define uiDarwinControlAllDefaults(type, handlefield) \
+	uiDarwinControlDefaultDestroy(type, handlefield) \
+	uiDarwinControlAllDefaultsExceptDestroy(type, handlefield)
+
+// TODO document
+#define uiDarwinNewControl(type, var) \
+	var = type(uiDarwinAllocControl(sizeof (type), type ## Signature, #type)); \
+	uiControl(var)->Destroy = type ## Destroy; \
+	uiControl(var)->Handle = type ## Handle; \
+	uiControl(var)->Parent = type ## Parent; \
+	uiControl(var)->SetParent = type ## SetParent; \
+	uiControl(var)->Toplevel = type ## Toplevel; \
+	uiControl(var)->Visible = type ## Visible; \
+	uiControl(var)->Show = type ## Show; \
+	uiControl(var)->Hide = type ## Hide; \
+	uiControl(var)->Enabled = type ## Enabled; \
+	uiControl(var)->Enable = type ## Enable; \
+	uiControl(var)->Disable = type ## Disable; \
+	uiDarwinControl(var)->SyncEnableState = type ## SyncEnableState; \
+	uiDarwinControl(var)->SetSuperview = type ## SetSuperview; \
+	uiDarwinControl(var)->HugsTrailingEdge = type ## HugsTrailingEdge; \
+	uiDarwinControl(var)->HugsBottom = type ## HugsBottom; \
+	uiDarwinControl(var)->ChildEdgeHuggingChanged = type ## ChildEdgeHuggingChanged; \
+	uiDarwinControl(var)->HuggingPriority = type ## HuggingPriority; \
+	uiDarwinControl(var)->SetHuggingPriority = type ## SetHuggingPriority; \
+	uiDarwinControl(var)->ChildVisibilityChanged = type ## ChildVisibilityChanged; \
+	uiDarwinControl(var)->visible = YES; \
+	uiDarwinControl(var)->enabled = YES;
+// TODO document
+_UI_EXTERN uiDarwinControl *uiDarwinAllocControl(size_t n, uint32_t typesig, const char *typenamestr);
+
+// Use this function as a shorthand for setting control fonts.
+_UI_EXTERN void uiDarwinSetControlFont(NSControl *c, NSControlSize size);
+
+// You can use this function from within your control implementations to return text strings that can be freed with uiFreeText().
+_UI_EXTERN char *uiDarwinNSStringToText(NSString *);
+
+// TODO document
+_UI_EXTERN BOOL uiDarwinShouldStopSyncEnableState(uiDarwinControl *, BOOL);
+
+// TODO document
+_UI_EXTERN void uiDarwinNotifyEdgeHuggingChanged(uiDarwinControl *);
+_UI_EXTERN void uiDarwinNotifyVisibilityChanged(uiDarwinControl *c);
+
+// TODO document
+// TODO document that values should not be cached
+_UI_EXTERN CGFloat uiDarwinMarginAmount(void *reserved);
+_UI_EXTERN CGFloat uiDarwinPaddingAmount(void *reserved);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/libui_sdl/libui/ui_unix.h b/src/libui_sdl/libui/ui_unix.h
new file mode 100644
index 0000000..5a91257
--- /dev/null
+++ b/src/libui_sdl/libui/ui_unix.h
@@ -0,0 +1,140 @@
+// 7 april 2015
+
+/*
+This file assumes that you have included <gtk/gtk.h> and "ui.h" beforehand. It provides API-specific functions for interfacing with foreign controls on Unix systems that use GTK+ to provide their UI (currently all except Mac OS X).
+*/
+
+#ifndef __LIBUI_UI_UNIX_H__
+#define __LIBUI_UI_UNIX_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct uiUnixControl uiUnixControl;
+struct uiUnixControl {
+	uiControl c;
+	uiControl *parent;
+	gboolean addedBefore;
+	void (*SetContainer)(uiUnixControl *, GtkContainer *, gboolean);
+};
+#define uiUnixControl(this) ((uiUnixControl *) (this))
+// TODO document
+_UI_EXTERN void uiUnixControlSetContainer(uiUnixControl *, GtkContainer *, gboolean);
+
+#define uiUnixControlDefaultDestroy(type) \
+	static void type ## Destroy(uiControl *c) \
+	{ \
+		/* TODO is this safe on floating refs? */ \
+		g_object_unref(type(c)->widget); \
+		uiFreeControl(c); \
+	}
+#define uiUnixControlDefaultHandle(type) \
+	static uintptr_t type ## Handle(uiControl *c) \
+	{ \
+		return (uintptr_t) (type(c)->widget); \
+	}
+#define uiUnixControlDefaultParent(type) \
+	static uiControl *type ## Parent(uiControl *c) \
+	{ \
+		return uiUnixControl(c)->parent; \
+	}
+#define uiUnixControlDefaultSetParent(type) \
+	static void type ## SetParent(uiControl *c, uiControl *parent) \
+	{ \
+		uiControlVerifySetParent(c, parent); \
+		uiUnixControl(c)->parent = parent; \
+	}
+#define uiUnixControlDefaultToplevel(type) \
+	static int type ## Toplevel(uiControl *c) \
+	{ \
+		return 0; \
+	}
+#define uiUnixControlDefaultVisible(type) \
+	static int type ## Visible(uiControl *c) \
+	{ \
+		return gtk_widget_get_visible(type(c)->widget); \
+	}
+#define uiUnixControlDefaultShow(type) \
+	static void type ## Show(uiControl *c) \
+	{ \
+		gtk_widget_show(type(c)->widget); \
+	}
+#define uiUnixControlDefaultHide(type) \
+	static void type ## Hide(uiControl *c) \
+	{ \
+		gtk_widget_hide(type(c)->widget); \
+	}
+#define uiUnixControlDefaultEnabled(type) \
+	static int type ## Enabled(uiControl *c) \
+	{ \
+		return gtk_widget_get_sensitive(type(c)->widget); \
+	}
+#define uiUnixControlDefaultEnable(type) \
+	static void type ## Enable(uiControl *c) \
+	{ \
+		gtk_widget_set_sensitive(type(c)->widget, TRUE); \
+	}
+#define uiUnixControlDefaultDisable(type) \
+	static void type ## Disable(uiControl *c) \
+	{ \
+		gtk_widget_set_sensitive(type(c)->widget, FALSE); \
+	}
+// TODO this whole addedBefore stuff is a MASSIVE HACK.
+#define uiUnixControlDefaultSetContainer(type) \
+	static void type ## SetContainer(uiUnixControl *c, GtkContainer *container, gboolean remove) \
+	{ \
+		if (!uiUnixControl(c)->addedBefore) { \
+			g_object_ref_sink(type(c)->widget); /* our own reference, which we release in Destroy() */ \
+			gtk_widget_show(type(c)->widget); \
+			uiUnixControl(c)->addedBefore = TRUE; \
+		} \
+		if (remove) \
+			gtk_container_remove(container, type(c)->widget); \
+		else \
+			gtk_container_add(container, type(c)->widget); \
+	}
+
+#define uiUnixControlAllDefaultsExceptDestroy(type) \
+	uiUnixControlDefaultHandle(type) \
+	uiUnixControlDefaultParent(type) \
+	uiUnixControlDefaultSetParent(type) \
+	uiUnixControlDefaultToplevel(type) \
+	uiUnixControlDefaultVisible(type) \
+	uiUnixControlDefaultShow(type) \
+	uiUnixControlDefaultHide(type) \
+	uiUnixControlDefaultEnabled(type) \
+	uiUnixControlDefaultEnable(type) \
+	uiUnixControlDefaultDisable(type) \
+	uiUnixControlDefaultSetContainer(type)
+
+#define uiUnixControlAllDefaults(type) \
+	uiUnixControlDefaultDestroy(type) \
+	uiUnixControlAllDefaultsExceptDestroy(type)
+
+// TODO document
+#define uiUnixNewControl(type, var) \
+	var = type(uiUnixAllocControl(sizeof (type), type ## Signature, #type)); \
+	uiControl(var)->Destroy = type ## Destroy; \
+	uiControl(var)->Handle = type ## Handle; \
+	uiControl(var)->Parent = type ## Parent; \
+	uiControl(var)->SetParent = type ## SetParent; \
+	uiControl(var)->Toplevel = type ## Toplevel; \
+	uiControl(var)->Visible = type ## Visible; \
+	uiControl(var)->Show = type ## Show; \
+	uiControl(var)->Hide = type ## Hide; \
+	uiControl(var)->Enabled = type ## Enabled; \
+	uiControl(var)->Enable = type ## Enable; \
+	uiControl(var)->Disable = type ## Disable; \
+	uiUnixControl(var)->SetContainer = type ## SetContainer;
+// TODO document
+_UI_EXTERN uiUnixControl *uiUnixAllocControl(size_t n, uint32_t typesig, const char *typenamestr);
+
+// uiUnixStrdupText() takes the given string and produces a copy of it suitable for being freed by uiFreeText().
+_UI_EXTERN char *uiUnixStrdupText(const char *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/libui_sdl/libui/ui_windows.h b/src/libui_sdl/libui/ui_windows.h
new file mode 100644
index 0000000..69dda36
--- /dev/null
+++ b/src/libui_sdl/libui/ui_windows.h
@@ -0,0 +1,267 @@
+// 21 april 2016
+
+/*
+This file assumes that you have included <windows.h> and "ui.h" beforehand. It provides API-specific functions for interfacing with foreign controls in Windows.
+*/
+
+#ifndef __LIBUI_UI_WINDOWS_H__
+#define __LIBUI_UI_WINDOWS_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct uiWindowsSizing uiWindowsSizing;
+
+typedef struct uiWindowsControl uiWindowsControl;
+struct uiWindowsControl {
+	uiControl c;
+	uiControl *parent;
+	// TODO this should be int on both os x and windows
+	BOOL enabled;
+	BOOL visible;
+	void (*SyncEnableState)(uiWindowsControl *, int);
+	void (*SetParentHWND)(uiWindowsControl *, HWND);
+	void (*MinimumSize)(uiWindowsControl *, int *, int *);
+	void (*MinimumSizeChanged)(uiWindowsControl *);
+	void (*LayoutRect)(uiWindowsControl *c, RECT *r);
+	void (*AssignControlIDZOrder)(uiWindowsControl *, LONG_PTR *, HWND *);
+	void (*ChildVisibilityChanged)(uiWindowsControl *);
+};
+#define uiWindowsControl(this) ((uiWindowsControl *) (this))
+// TODO document
+_UI_EXTERN void uiWindowsControlSyncEnableState(uiWindowsControl *, int);
+_UI_EXTERN void uiWindowsControlSetParentHWND(uiWindowsControl *, HWND);
+_UI_EXTERN void uiWindowsControlMinimumSize(uiWindowsControl *, int *, int *);
+_UI_EXTERN void uiWindowsControlMinimumSizeChanged(uiWindowsControl *);
+_UI_EXTERN void uiWindowsControlLayoutRect(uiWindowsControl *, RECT *);
+_UI_EXTERN void uiWindowsControlAssignControlIDZOrder(uiWindowsControl *, LONG_PTR *, HWND *);
+_UI_EXTERN void uiWindowsControlChildVisibilityChanged(uiWindowsControl *);
+
+// TODO document
+#define uiWindowsControlDefaultDestroy(type) \
+	static void type ## Destroy(uiControl *c) \
+	{ \
+		uiWindowsEnsureDestroyWindow(type(c)->hwnd); \
+		uiFreeControl(c); \
+	}
+#define uiWindowsControlDefaultHandle(type) \
+	static uintptr_t type ## Handle(uiControl *c) \
+	{ \
+		return (uintptr_t) (type(c)->hwnd); \
+	}
+#define uiWindowsControlDefaultParent(type) \
+	static uiControl *type ## Parent(uiControl *c) \
+	{ \
+		return uiWindowsControl(c)->parent; \
+	}
+#define uiWindowsControlDefaultSetParent(type) \
+	static void type ## SetParent(uiControl *c, uiControl *parent) \
+	{ \
+		uiControlVerifySetParent(c, parent); \
+		uiWindowsControl(c)->parent = parent; \
+	}
+#define uiWindowsControlDefaultToplevel(type) \
+	static int type ## Toplevel(uiControl *c) \
+	{ \
+		return 0; \
+	}
+#define uiWindowsControlDefaultVisible(type) \
+	static int type ## Visible(uiControl *c) \
+	{ \
+		return uiWindowsControl(c)->visible; \
+	}
+#define uiWindowsControlDefaultShow(type) \
+	static void type ## Show(uiControl *c) \
+	{ \
+		uiWindowsControl(c)->visible = 1; \
+		ShowWindow(type(c)->hwnd, SW_SHOW); \
+		uiWindowsControlNotifyVisibilityChanged(uiWindowsControl(c)); \
+	}
+#define uiWindowsControlDefaultHide(type) \
+	static void type ## Hide(uiControl *c) \
+	{ \
+		uiWindowsControl(c)->visible = 0; \
+		ShowWindow(type(c)->hwnd, SW_HIDE); \
+		uiWindowsControlNotifyVisibilityChanged(uiWindowsControl(c)); \
+	}
+#define uiWindowsControlDefaultEnabled(type) \
+	static int type ## Enabled(uiControl *c) \
+	{ \
+		return uiWindowsControl(c)->enabled; \
+	}
+#define uiWindowsControlDefaultEnable(type) \
+	static void type ## Enable(uiControl *c) \
+	{ \
+		uiWindowsControl(c)->enabled = 1; \
+		uiWindowsControlSyncEnableState(uiWindowsControl(c), uiControlEnabledToUser(c)); \
+	}
+#define uiWindowsControlDefaultDisable(type) \
+	static void type ## Disable(uiControl *c) \
+	{ \
+		uiWindowsControl(c)->enabled = 0; \
+		uiWindowsControlSyncEnableState(uiWindowsControl(c), uiControlEnabledToUser(c)); \
+	}
+#define uiWindowsControlDefaultSyncEnableState(type) \
+	static void type ## SyncEnableState(uiWindowsControl *c, int enabled) \
+	{ \
+		if (uiWindowsShouldStopSyncEnableState(c, enabled)) \
+			return; \
+		EnableWindow(type(c)->hwnd, enabled); \
+	}
+#define uiWindowsControlDefaultSetParentHWND(type) \
+	static void type ## SetParentHWND(uiWindowsControl *c, HWND parent) \
+	{ \
+		uiWindowsEnsureSetParentHWND(type(c)->hwnd, parent); \
+	}
+// note that there is no uiWindowsControlDefaultMinimumSize(); you MUST define this yourself!
+#define uiWindowsControlDefaultMinimumSizeChanged(type) \
+	static void type ## MinimumSizeChanged(uiWindowsControl *c) \
+	{ \
+		if (uiWindowsControlTooSmall(c)) { \
+			uiWindowsControlContinueMinimumSizeChanged(c); \
+			return; \
+		} \
+		/* otherwise do nothing; we have no children */ \
+	}
+#define uiWindowsControlDefaultLayoutRect(type) \
+	static void type ## LayoutRect(uiWindowsControl *c, RECT *r) \
+	{ \
+		/* use the window rect as we include the non-client area in the sizes */ \
+		uiWindowsEnsureGetWindowRect(type(c)->hwnd, r); \
+	}
+#define uiWindowsControlDefaultAssignControlIDZOrder(type) \
+	static void type ## AssignControlIDZOrder(uiWindowsControl *c, LONG_PTR *controlID, HWND *insertAfter) \
+	{ \
+		uiWindowsEnsureAssignControlIDZOrder(type(c)->hwnd, controlID, insertAfter); \
+	}
+#define uiWindowsControlDefaultChildVisibilityChanged(type) \
+	static void type ## ChildVisibilityChanged(uiWindowsControl *c) \
+	{ \
+		/* do nothing */ \
+	}
+
+#define uiWindowsControlAllDefaultsExceptDestroy(type) \
+	uiWindowsControlDefaultHandle(type) \
+	uiWindowsControlDefaultParent(type) \
+	uiWindowsControlDefaultSetParent(type) \
+	uiWindowsControlDefaultToplevel(type) \
+	uiWindowsControlDefaultVisible(type) \
+	uiWindowsControlDefaultShow(type) \
+	uiWindowsControlDefaultHide(type) \
+	uiWindowsControlDefaultEnabled(type) \
+	uiWindowsControlDefaultEnable(type) \
+	uiWindowsControlDefaultDisable(type) \
+	uiWindowsControlDefaultSyncEnableState(type) \
+	uiWindowsControlDefaultSetParentHWND(type) \
+	uiWindowsControlDefaultMinimumSizeChanged(type) \
+	uiWindowsControlDefaultLayoutRect(type) \
+	uiWindowsControlDefaultAssignControlIDZOrder(type) \
+	uiWindowsControlDefaultChildVisibilityChanged(type)
+
+#define uiWindowsControlAllDefaults(type) \
+	uiWindowsControlDefaultDestroy(type) \
+	uiWindowsControlAllDefaultsExceptDestroy(type)
+
+// TODO document
+#define uiWindowsNewControl(type, var) \
+	var = type(uiWindowsAllocControl(sizeof (type), type ## Signature, #type)); \
+	uiControl(var)->Destroy = type ## Destroy; \
+	uiControl(var)->Handle = type ## Handle; \
+	uiControl(var)->Parent = type ## Parent; \
+	uiControl(var)->SetParent = type ## SetParent; \
+	uiControl(var)->Toplevel = type ## Toplevel; \
+	uiControl(var)->Visible = type ## Visible; \
+	uiControl(var)->Show = type ## Show; \
+	uiControl(var)->Hide = type ## Hide; \
+	uiControl(var)->Enabled = type ## Enabled; \
+	uiControl(var)->Enable = type ## Enable; \
+	uiControl(var)->Disable = type ## Disable; \
+	uiWindowsControl(var)->SyncEnableState = type ## SyncEnableState; \
+	uiWindowsControl(var)->SetParentHWND = type ## SetParentHWND; \
+	uiWindowsControl(var)->MinimumSize = type ## MinimumSize; \
+	uiWindowsControl(var)->MinimumSizeChanged = type ## MinimumSizeChanged; \
+	uiWindowsControl(var)->LayoutRect = type ## LayoutRect; \
+	uiWindowsControl(var)->AssignControlIDZOrder = type ## AssignControlIDZOrder; \
+	uiWindowsControl(var)->ChildVisibilityChanged = type ## ChildVisibilityChanged; \
+	uiWindowsControl(var)->visible = 1; \
+	uiWindowsControl(var)->enabled = 1;
+// TODO document
+_UI_EXTERN uiWindowsControl *uiWindowsAllocControl(size_t n, uint32_t typesig, const char *typenamestr);
+
+// TODO document
+_UI_EXTERN HWND uiWindowsEnsureCreateControlHWND(DWORD dwExStyle, LPCWSTR lpClassName, LPCWSTR lpWindowName, DWORD dwStyle, HINSTANCE hInstance, LPVOID lpParam, BOOL useStandardControlFont);
+
+// TODO document
+_UI_EXTERN void uiWindowsEnsureDestroyWindow(HWND hwnd);
+
+// TODO document
+// TODO document that this should only be used in SetParentHWND() implementations
+_UI_EXTERN void uiWindowsEnsureSetParentHWND(HWND hwnd, HWND parent);
+
+// TODO document
+_UI_EXTERN void uiWindowsEnsureAssignControlIDZOrder(HWND hwnd, LONG_PTR *controlID, HWND *insertAfter);
+
+// TODO document
+_UI_EXTERN void uiWindowsEnsureGetClientRect(HWND hwnd, RECT *r);
+_UI_EXTERN void uiWindowsEnsureGetWindowRect(HWND hwnd, RECT *r);
+
+// TODO document
+_UI_EXTERN char *uiWindowsWindowText(HWND hwnd);
+_UI_EXTERN void uiWindowsSetWindowText(HWND hwnd, const char *text);
+
+// TODO document
+_UI_EXTERN int uiWindowsWindowTextWidth(HWND hwnd);
+
+// TODO document
+// TODO point out this should only be used in a resize cycle
+_UI_EXTERN void uiWindowsEnsureMoveWindowDuringResize(HWND hwnd, int x, int y, int width, int height);
+
+// TODO document
+_UI_EXTERN void uiWindowsRegisterWM_COMMANDHandler(HWND hwnd, BOOL (*handler)(uiControl *, HWND, WORD, LRESULT *), uiControl *c);
+_UI_EXTERN void uiWindowsUnregisterWM_COMMANDHandler(HWND hwnd);
+
+// TODO document
+_UI_EXTERN void uiWindowsRegisterWM_NOTIFYHandler(HWND hwnd, BOOL (*handler)(uiControl *, HWND, NMHDR *, LRESULT *), uiControl *c);
+_UI_EXTERN void uiWindowsUnregisterWM_NOTIFYHandler(HWND hwnd);
+
+// TODO document
+_UI_EXTERN void uiWindowsRegisterWM_HSCROLLHandler(HWND hwnd, BOOL (*handler)(uiControl *, HWND, WORD, LRESULT *), uiControl *c);
+_UI_EXTERN void uiWindowsUnregisterWM_HSCROLLHandler(HWND hwnd);
+
+// TODO document
+_UI_EXTERN void uiWindowsRegisterReceiveWM_WININICHANGE(HWND hwnd);
+_UI_EXTERN void uiWindowsUnregisterReceiveWM_WININICHANGE(HWND hwnd);
+
+// TODO document
+typedef struct uiWindowsSizing uiWindowsSizing;
+struct uiWindowsSizing {
+	int BaseX;
+	int BaseY;
+	LONG InternalLeading;
+};
+_UI_EXTERN void uiWindowsGetSizing(HWND hwnd, uiWindowsSizing *sizing);
+_UI_EXTERN void uiWindowsSizingDlgUnitsToPixels(uiWindowsSizing *sizing, int *x, int *y);
+_UI_EXTERN void uiWindowsSizingStandardPadding(uiWindowsSizing *sizing, int *x, int *y);
+
+// TODO document
+_UI_EXTERN HWND uiWindowsMakeContainer(uiWindowsControl *c, void (*onResize)(uiWindowsControl *));
+
+// TODO document
+_UI_EXTERN BOOL uiWindowsControlTooSmall(uiWindowsControl *c);
+_UI_EXTERN void uiWindowsControlContinueMinimumSizeChanged(uiWindowsControl *c);
+
+// TODO document
+_UI_EXTERN void uiWindowsControlAssignSoleControlIDZOrder(uiWindowsControl *);
+
+// TODO document
+_UI_EXTERN BOOL uiWindowsShouldStopSyncEnableState(uiWindowsControl *c, int enabled);
+
+// TODO document
+_UI_EXTERN void uiWindowsControlNotifyVisibilityChanged(uiWindowsControl *c);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/libui_sdl/libui/unix/CMakeLists.txt b/src/libui_sdl/libui/unix/CMakeLists.txt
new file mode 100644
index 0000000..9300bcb
--- /dev/null
+++ b/src/libui_sdl/libui/unix/CMakeLists.txt
@@ -0,0 +1,85 @@
+# 3 june 2016
+
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(GTK REQUIRED gtk+-3.0)
+
+list(APPEND _LIBUI_SOURCES
+	unix/alloc.c
+	unix/area.c
+	unix/box.c
+	unix/button.c
+	unix/cellrendererbutton.c
+	unix/checkbox.c
+	unix/child.c
+	unix/colorbutton.c
+	unix/combobox.c
+	unix/control.c
+	unix/datetimepicker.c
+	unix/debug.c
+	unix/draw.c
+	unix/drawmatrix.c
+	unix/drawpath.c
+	unix/drawtext.c
+	unix/editablecombo.c
+	unix/entry.c
+	unix/fontbutton.c
+	unix/form.c
+	unix/future.c
+	unix/graphemes.c
+	unix/grid.c
+	unix/group.c
+	unix/image.c
+	unix/label.c
+	unix/main.c
+	unix/menu.c
+	unix/multilineentry.c
+	unix/progressbar.c
+	unix/radiobuttons.c
+	unix/separator.c
+	unix/slider.c
+	unix/spinbox.c
+	unix/stddialogs.c
+	unix/tab.c
+	unix/text.c
+	unix/util.c
+	unix/window.c
+)
+set(_LIBUI_SOURCES ${_LIBUI_SOURCES} PARENT_SCOPE)
+
+list(APPEND _LIBUI_INCLUDEDIRS
+	unix
+)
+set(_LIBUI_INCLUDEDIRS _LIBUI_INCLUDEDIRS PARENT_SCOPE)
+
+set(_LIBUINAME libui PARENT_SCOPE)
+if(NOT BUILD_SHARED_LIBS)
+	set(_LIBUINAME libui-temporary PARENT_SCOPE)
+endif()
+macro(_handle_static)
+	set_target_properties(${_LIBUINAME} PROPERTIES
+		ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}")
+	set(_aname $<TARGET_FILE:${_LIBUINAME}>)
+	set(_oname libui-combined.o)
+	add_custom_command(
+		OUTPUT ${_oname}
+		COMMAND
+			ld -r --whole-archive ${_aname} -o ${_oname}
+		COMMAND
+			objcopy --localize-hidden ${_oname}
+		COMMENT "Removing hidden symbols")
+	add_library(libui STATIC ${_oname})
+	# otherwise cmake won't know which linker to use
+	set_target_properties(libui PROPERTIES
+		LINKER_LANGUAGE C)
+	set(_aname)
+	set(_oname)
+endmacro()
+
+# TODO the other variables don't work?
+set(_LIBUI_CFLAGS
+	${GTK_CFLAGS}
+PARENT_SCOPE)
+
+set(_LIBUI_LIBS
+	${GTK_LDFLAGS} m ${CMAKE_DL_LIBS}
+PARENT_SCOPE)
diff --git a/src/libui_sdl/libui/unix/alloc.c b/src/libui_sdl/libui/unix/alloc.c
new file mode 100644
index 0000000..2561efa
--- /dev/null
+++ b/src/libui_sdl/libui/unix/alloc.c
@@ -0,0 +1,84 @@
+// 7 april 2015
+#include <string.h>
+#include "uipriv_unix.h"
+
+static GPtrArray *allocations;
+
+#define UINT8(p) ((uint8_t *) (p))
+#define PVOID(p) ((void *) (p))
+#define EXTRA (sizeof (size_t) + sizeof (const char **))
+#define DATA(p) PVOID(UINT8(p) + EXTRA)
+#define BASE(p) PVOID(UINT8(p) - EXTRA)
+#define SIZE(p) ((size_t *) (p))
+#define CCHAR(p) ((const char **) (p))
+#define TYPE(p) CCHAR(UINT8(p) + sizeof (size_t))
+
+void initAlloc(void)
+{
+	allocations = g_ptr_array_new();
+}
+
+static void uninitComplain(gpointer ptr, gpointer data)
+{
+	char **str = (char **) data;
+	char *str2;
+
+	if (*str == NULL)
+		*str = g_strdup_printf("");
+	str2 = g_strdup_printf("%s%p %s\n", *str, ptr, *TYPE(ptr));
+	g_free(*str);
+	*str = str2;
+}
+
+void uninitAlloc(void)
+{
+	char *str = NULL;
+
+	if (allocations->len == 0) {
+		g_ptr_array_free(allocations, TRUE);
+		return;
+	}
+	g_ptr_array_foreach(allocations, uninitComplain, &str);
+	userbug("Some data was leaked; either you left a uiControl lying around or there's a bug in libui itself. Leaked data:\n%s", str);
+	g_free(str);
+}
+
+void *uiAlloc(size_t size, const char *type)
+{
+	void *out;
+
+	out = g_malloc0(EXTRA + size);
+	*SIZE(out) = size;
+	*TYPE(out) = type;
+	g_ptr_array_add(allocations, out);
+	return DATA(out);
+}
+
+void *uiRealloc(void *p, size_t new, const char *type)
+{
+	void *out;
+	size_t *s;
+
+	if (p == NULL)
+		return uiAlloc(new, type);
+	p = BASE(p);
+	out = g_realloc(p, EXTRA + new);
+	s = SIZE(out);
+	if (new <= *s)
+		memset(((uint8_t *) DATA(out)) + *s, 0, new - *s);
+	*s = new;
+	if (g_ptr_array_remove(allocations, p) == FALSE)
+		implbug("%p not found in allocations array in uiRealloc()", p);
+	g_ptr_array_add(allocations, out);
+	return DATA(out);
+}
+
+void uiFree(void *p)
+{
+	if (p == NULL)
+		implbug("attempt to uiFree(NULL)");
+	p = BASE(p);
+	g_free(p);
+	if (g_ptr_array_remove(allocations, p) == FALSE)
+		implbug("%p not found in allocations array in uiFree()", p);
+}
diff --git a/src/libui_sdl/libui/unix/area.c b/src/libui_sdl/libui/unix/area.c
new file mode 100644
index 0000000..c46447c
--- /dev/null
+++ b/src/libui_sdl/libui/unix/area.c
@@ -0,0 +1,633 @@
+// 4 september 2015
+#include "uipriv_unix.h"
+
+// notes:
+// - G_DECLARE_DERIVABLE/FINAL_INTERFACE() requires glib 2.44 and that's starting with debian stretch (testing) (GTK+ 3.18) and ubuntu 15.04 (GTK+ 3.14) - debian jessie has 2.42 (GTK+ 3.14)
+#define areaWidgetType (areaWidget_get_type())
+#define areaWidget(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), areaWidgetType, areaWidget))
+#define isAreaWidget(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), areaWidgetType))
+#define areaWidgetClass(class) (G_TYPE_CHECK_CLASS_CAST((class), areaWidgetType, areaWidgetClass))
+#define isAreaWidgetClass(class) (G_TYPE_CHECK_CLASS_TYPE((class), areaWidget))
+#define getAreaWidgetClass(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), areaWidgetType, areaWidgetClass))
+
+typedef struct areaWidget areaWidget;
+typedef struct areaWidgetClass areaWidgetClass;
+
+struct areaWidget {
+	GtkDrawingArea parent_instance;
+	uiArea *a;
+	// construct-only parameters aare not set until after the init() function has returned
+	// we need this particular object available during init(), so put it here instead of in uiArea
+	// keep a pointer in uiArea for convenience, though
+	clickCounter cc;
+};
+
+struct areaWidgetClass {
+	GtkDrawingAreaClass parent_class;
+};
+
+struct uiArea {
+	uiUnixControl c;
+	GtkWidget *widget;		// either swidget or areaWidget depending on whether it is scrolling
+
+	GtkWidget *swidget;
+	GtkContainer *scontainer;
+	GtkScrolledWindow *sw;
+
+	GtkWidget *areaWidget;
+	GtkDrawingArea *drawingArea;
+	areaWidget *area;
+
+	uiAreaHandler *ah;
+
+	gboolean scrolling;
+	int scrollWidth;
+	int scrollHeight;
+
+	// note that this is a pointer; see above
+	clickCounter *cc;
+
+	// for user window drags
+	GdkEventButton *dragevent;
+};
+
+G_DEFINE_TYPE(areaWidget, areaWidget, GTK_TYPE_DRAWING_AREA)
+
+static void areaWidget_init(areaWidget *aw)
+{
+	// for events
+	gtk_widget_add_events(GTK_WIDGET(aw),
+		GDK_POINTER_MOTION_MASK |
+		GDK_BUTTON_MOTION_MASK |
+		GDK_BUTTON_PRESS_MASK |
+		GDK_BUTTON_RELEASE_MASK |
+		GDK_KEY_PRESS_MASK |
+		GDK_KEY_RELEASE_MASK |
+		GDK_ENTER_NOTIFY_MASK |
+		GDK_LEAVE_NOTIFY_MASK);
+
+	gtk_widget_set_can_focus(GTK_WIDGET(aw), TRUE);
+
+	clickCounterReset(&(aw->cc));
+}
+
+static void areaWidget_dispose(GObject *obj)
+{
+	G_OBJECT_CLASS(areaWidget_parent_class)->dispose(obj);
+}
+
+static void areaWidget_finalize(GObject *obj)
+{
+	G_OBJECT_CLASS(areaWidget_parent_class)->finalize(obj);
+}
+
+static void areaWidget_size_allocate(GtkWidget *w, GtkAllocation *allocation)
+{
+	areaWidget *aw = areaWidget(w);
+	uiArea *a = aw->a;
+
+	// GtkDrawingArea has a size_allocate() implementation; we need to call it
+	// this will call gtk_widget_set_allocation() for us
+	GTK_WIDGET_CLASS(areaWidget_parent_class)->size_allocate(w, allocation);
+
+	if (!a->scrolling)
+		// we must redraw everything on resize because Windows requires it
+		gtk_widget_queue_resize(w);
+}
+
+static void loadAreaSize(uiArea *a, double *width, double *height)
+{
+	GtkAllocation allocation;
+
+	*width = 0;
+	*height = 0;
+	// don't provide size information for scrolling areas
+	if (!a->scrolling) {
+		gtk_widget_get_allocation(a->areaWidget, &allocation);
+		// these are already in drawing space coordinates
+		// for drawing, the size of drawing space has the same value as the widget allocation
+		// thanks to tristan in irc.gimp.net/#gtk+
+		*width = allocation.width;
+		*height = allocation.height;
+	}
+}
+
+static gboolean areaWidget_draw(GtkWidget *w, cairo_t *cr)
+{
+	areaWidget *aw = areaWidget(w);
+	uiArea *a = aw->a;
+	uiAreaDrawParams dp;
+	double clipX0, clipY0, clipX1, clipY1;
+
+	dp.Context = newContext(cr);
+
+	loadAreaSize(a, &(dp.AreaWidth), &(dp.AreaHeight));
+
+	cairo_clip_extents(cr, &clipX0, &clipY0, &clipX1, &clipY1);
+	dp.ClipX = clipX0;
+	dp.ClipY = clipY0;
+	dp.ClipWidth = clipX1 - clipX0;
+	dp.ClipHeight = clipY1 - clipY0;
+
+	// no need to save or restore the graphics state to reset transformations; GTK+ does that for us
+	(*(a->ah->Draw))(a->ah, a, &dp);
+
+	freeContext(dp.Context);
+	return FALSE;
+}
+
+// to do this properly for scrolling areas, we need to
+// - return the same value for min and nat
+// - call gtk_widget_queue_resize() when the size changes
+// thanks to Company in irc.gimp.net/#gtk+
+static void areaWidget_get_preferred_height(GtkWidget *w, gint *min, gint *nat)
+{
+	areaWidget *aw = areaWidget(w);
+	uiArea *a = aw->a;
+
+	// always chain up just in case
+	GTK_WIDGET_CLASS(areaWidget_parent_class)->get_preferred_height(w, min, nat);
+	if (a->scrolling) {
+		*min = a->scrollHeight;
+		*nat = a->scrollHeight;
+	}
+}
+
+static void areaWidget_get_preferred_width(GtkWidget *w, gint *min, gint *nat)
+{
+	areaWidget *aw = areaWidget(w);
+	uiArea *a = aw->a;
+
+	// always chain up just in case
+	GTK_WIDGET_CLASS(areaWidget_parent_class)->get_preferred_width(w, min, nat);
+	if (a->scrolling) {
+		*min = a->scrollWidth;
+		*nat = a->scrollWidth;
+	}
+}
+
+static guint translateModifiers(guint state, GdkWindow *window)
+{
+	GdkModifierType statetype;
+
+	// GDK doesn't initialize the modifier flags fully; we have to explicitly tell it to (thanks to Daniel_S and daniels (two different people) in irc.gimp.net/#gtk+)
+	statetype = state;
+	gdk_keymap_add_virtual_modifiers(
+		gdk_keymap_get_for_display(gdk_window_get_display(window)),
+		&statetype);
+	return statetype;
+}
+
+static uiModifiers toModifiers(guint state)
+{
+	uiModifiers m;
+
+	m = 0;
+	if ((state & GDK_CONTROL_MASK) != 0)
+		m |= uiModifierCtrl;
+	if ((state & GDK_META_MASK) != 0)
+		m |= uiModifierAlt;
+	if ((state & GDK_MOD1_MASK) != 0)		// GTK+ itself requires this to be Alt (just read through gtkaccelgroup.c)
+		m |= uiModifierAlt;
+	if ((state & GDK_SHIFT_MASK) != 0)
+		m |= uiModifierShift;
+	if ((state & GDK_SUPER_MASK) != 0)
+		m |= uiModifierSuper;
+	return m;
+}
+
+// capture on drag is done automatically on GTK+
+static void finishMouseEvent(uiArea *a, uiAreaMouseEvent *me, guint mb, gdouble x, gdouble y, guint state, GdkWindow *window)
+{
+	// on GTK+, mouse buttons 4-7 are for scrolling; if we got here, that's a mistake
+	if (mb >= 4 && mb <= 7)
+		return;
+	// if the button ID >= 8, continue counting from 4, as in the MouseEvent spec
+	if (me->Down >= 8)
+		me->Down -= 4;
+	if (me->Up >= 8)
+		me->Up -= 4;
+
+	state = translateModifiers(state, window);
+	me->Modifiers = toModifiers(state);
+
+	// the mb != # checks exclude the Up/Down button from Held
+	me->Held1To64 = 0;
+	if (mb != 1 && (state & GDK_BUTTON1_MASK) != 0)
+		me->Held1To64 |= 1 << 0;
+	if (mb != 2 && (state & GDK_BUTTON2_MASK) != 0)
+		me->Held1To64 |= 1 << 1;
+	if (mb != 3 && (state & GDK_BUTTON3_MASK) != 0)
+		me->Held1To64 |= 1 << 2;
+	// don't check GDK_BUTTON4_MASK or GDK_BUTTON5_MASK because those are for the scrolling buttons mentioned above
+	// GDK expressly does not support any more buttons in the GdkModifierType; see https://git.gnome.org/browse/gtk+/tree/gdk/x11/gdkdevice-xi2.c#n763 (thanks mclasen in irc.gimp.net/#gtk+)
+
+	// these are already in drawing space coordinates
+	// the size of drawing space has the same value as the widget allocation
+	// thanks to tristan in irc.gimp.net/#gtk+
+	me->X = x;
+	me->Y = y;
+
+	loadAreaSize(a, &(me->AreaWidth), &(me->AreaHeight));
+
+	(*(a->ah->MouseEvent))(a->ah, a, me);
+}
+
+static gboolean areaWidget_button_press_event(GtkWidget *w, GdkEventButton *e)
+{
+	areaWidget *aw = areaWidget(w);
+	uiArea *a = aw->a;
+	gint maxTime, maxDistance;
+	GtkSettings *settings;
+	uiAreaMouseEvent me;
+
+	// clicking doesn't automatically transfer keyboard focus; we must do so manually (thanks tristan in irc.gimp.net/#gtk+)
+	gtk_widget_grab_focus(w);
+
+	// we handle multiple clicks ourselves here, in the same way as we do on Windows
+	if (e->type != GDK_BUTTON_PRESS)
+		// ignore GDK's generated double-clicks and beyond
+		return GDK_EVENT_PROPAGATE;
+	settings = gtk_widget_get_settings(w);
+	g_object_get(settings,
+		"gtk-double-click-time", &maxTime,
+		"gtk-double-click-distance", &maxDistance,
+		NULL);
+	// don't unref settings; it's transfer-none (thanks gregier in irc.gimp.net/#gtk+)
+	// e->time is guint32
+	// e->x and e->y are floating-point; just make them 32-bit integers
+	// maxTime and maxDistance... are gint, which *should* fit, hopefully...
+	me.Count = clickCounterClick(a->cc, me.Down,
+		e->x, e->y,
+		e->time, maxTime,
+		maxDistance, maxDistance);
+
+	me.Down = e->button;
+	me.Up = 0;
+
+	// and set things up for window drags
+	a->dragevent = e;
+	finishMouseEvent(a, &me, e->button, e->x, e->y, e->state, e->window);
+	a->dragevent = NULL;
+	return GDK_EVENT_PROPAGATE;
+}
+
+static gboolean areaWidget_button_release_event(GtkWidget *w, GdkEventButton *e)
+{
+	areaWidget *aw = areaWidget(w);
+	uiArea *a = aw->a;
+	uiAreaMouseEvent me;
+
+	me.Down = 0;
+	me.Up = e->button;
+	me.Count = 0;
+	finishMouseEvent(a, &me, e->button, e->x, e->y, e->state, e->window);
+	return GDK_EVENT_PROPAGATE;
+}
+
+static gboolean areaWidget_motion_notify_event(GtkWidget *w, GdkEventMotion *e)
+{
+	areaWidget *aw = areaWidget(w);
+	uiArea *a = aw->a;
+	uiAreaMouseEvent me;
+
+	me.Down = 0;
+	me.Up = 0;
+	me.Count = 0;
+	finishMouseEvent(a, &me, 0, e->x, e->y, e->state, e->window);
+	return GDK_EVENT_PROPAGATE;
+}
+
+// we want switching away from the control to reset the double-click counter, like with WM_ACTIVATE on Windows
+// according to tristan in irc.gimp.net/#gtk+, doing this on both enter-notify-event and leave-notify-event is correct (and it seems to be true in my own tests; plus the events DO get sent when switching programs with the keyboard (just pointing that out))
+static gboolean onCrossing(areaWidget *aw, int left)
+{
+	uiArea *a = aw->a;
+
+	(*(a->ah->MouseCrossed))(a->ah, a, left);
+	clickCounterReset(a->cc);
+	return GDK_EVENT_PROPAGATE;
+}
+
+static gboolean areaWidget_enter_notify_event(GtkWidget *w, GdkEventCrossing *e)
+{
+	return onCrossing(areaWidget(w), 0);
+}
+
+static gboolean areaWidget_leave_notify_event(GtkWidget *w, GdkEventCrossing *e)
+{
+	return onCrossing(areaWidget(w), 1);
+}
+
+// note: there is no equivalent to WM_CAPTURECHANGED on GTK+; there literally is no way to break a grab like that (at least not on X11 and Wayland)
+// even if I invoke the task switcher and switch processes, the mouse grab will still be held until I let go of all buttons
+// therefore, no DragBroken()
+
+// we use GDK_KEY_Print as a sentinel because libui will never support the print screen key; that key belongs to the user
+
+static const struct {
+	guint keyval;
+	uiExtKey extkey;
+} extKeys[] = {
+	{ GDK_KEY_Escape, uiExtKeyEscape },
+	{ GDK_KEY_Insert, uiExtKeyInsert },
+	{ GDK_KEY_Delete, uiExtKeyDelete },
+	{ GDK_KEY_Home, uiExtKeyHome },
+	{ GDK_KEY_End, uiExtKeyEnd },
+	{ GDK_KEY_Page_Up, uiExtKeyPageUp },
+	{ GDK_KEY_Page_Down, uiExtKeyPageDown },
+	{ GDK_KEY_Up, uiExtKeyUp },
+	{ GDK_KEY_Down, uiExtKeyDown },
+	{ GDK_KEY_Left, uiExtKeyLeft },
+	{ GDK_KEY_Right, uiExtKeyRight },
+	{ GDK_KEY_F1, uiExtKeyF1 },
+	{ GDK_KEY_F2, uiExtKeyF2 },
+	{ GDK_KEY_F3, uiExtKeyF3 },
+	{ GDK_KEY_F4, uiExtKeyF4 },
+	{ GDK_KEY_F5, uiExtKeyF5 },
+	{ GDK_KEY_F6, uiExtKeyF6 },
+	{ GDK_KEY_F7, uiExtKeyF7 },
+	{ GDK_KEY_F8, uiExtKeyF8 },
+	{ GDK_KEY_F9, uiExtKeyF9 },
+	{ GDK_KEY_F10, uiExtKeyF10 },
+	{ GDK_KEY_F11, uiExtKeyF11 },
+	{ GDK_KEY_F12, uiExtKeyF12 },
+	// numpad numeric keys and . are handled in events.c
+	{ GDK_KEY_KP_Enter, uiExtKeyNEnter },
+	{ GDK_KEY_KP_Add, uiExtKeyNAdd },
+	{ GDK_KEY_KP_Subtract, uiExtKeyNSubtract },
+	{ GDK_KEY_KP_Multiply, uiExtKeyNMultiply },
+	{ GDK_KEY_KP_Divide, uiExtKeyNDivide },
+	{ GDK_KEY_Print, 0 },
+};
+
+static const struct {
+	guint keyval;
+	uiModifiers mod;
+} modKeys[] = {
+	{ GDK_KEY_Control_L, uiModifierCtrl },
+	{ GDK_KEY_Control_R, uiModifierCtrl },
+	{ GDK_KEY_Alt_L, uiModifierAlt },
+	{ GDK_KEY_Alt_R, uiModifierAlt },
+	{ GDK_KEY_Meta_L, uiModifierAlt },
+	{ GDK_KEY_Meta_R, uiModifierAlt },
+	{ GDK_KEY_Shift_L, uiModifierShift },
+	{ GDK_KEY_Shift_R, uiModifierShift },
+	{ GDK_KEY_Super_L, uiModifierSuper },
+	{ GDK_KEY_Super_R, uiModifierSuper },
+	{ GDK_KEY_Print, 0 },
+};
+
+static int areaKeyEvent(uiArea *a, int up, GdkEventKey *e)
+{
+	uiAreaKeyEvent ke;
+	guint state;
+	int i;
+
+	ke.Key = 0;
+	ke.ExtKey = 0;
+	ke.Modifier = 0;
+
+	state = translateModifiers(e->state, e->window);
+	ke.Modifiers = toModifiers(state);
+
+	ke.Up = up;
+
+	for (i = 0; extKeys[i].keyval != GDK_KEY_Print; i++)
+		if (extKeys[i].keyval == e->keyval) {
+			ke.ExtKey = extKeys[i].extkey;
+			goto keyFound;
+		}
+
+	for (i = 0; modKeys[i].keyval != GDK_KEY_Print; i++)
+		if (modKeys[i].keyval == e->keyval) {
+			ke.Modifier = modKeys[i].mod;
+			// don't include the modifier in ke.Modifiers
+			ke.Modifiers &= ~ke.Modifier;
+			goto keyFound;
+		}
+
+	if (fromScancode(e->hardware_keycode - 8, &ke))
+		goto keyFound;
+
+	// no supported key found; treat as unhandled
+	return 0;
+
+keyFound:
+	return (*(a->ah->KeyEvent))(a->ah, a, &ke);
+}
+
+static gboolean areaWidget_key_press_event(GtkWidget *w, GdkEventKey *e)
+{
+	areaWidget *aw = areaWidget(w);
+	uiArea *a = aw->a;
+
+	if (areaKeyEvent(a, 0, e))
+		return GDK_EVENT_STOP;
+	return GDK_EVENT_PROPAGATE;
+}
+
+static gboolean areaWidget_key_release_event(GtkWidget *w, GdkEventKey *e)
+{
+	areaWidget *aw = areaWidget(w);
+	uiArea *a = aw->a;
+
+	if (areaKeyEvent(a, 1, e))
+		return GDK_EVENT_STOP;
+	return GDK_EVENT_PROPAGATE;
+}
+
+enum {
+	pArea = 1,
+	nProps,
+};
+
+static GParamSpec *pspecArea;
+
+static void areaWidget_set_property(GObject *obj, guint prop, const GValue *value, GParamSpec *pspec)
+{
+	areaWidget *aw = areaWidget(obj);
+
+	switch (prop) {
+	case pArea:
+		aw->a = (uiArea *) g_value_get_pointer(value);
+		aw->a->cc = &(aw->cc);
+		return;
+	}
+	G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, prop, pspec);
+}
+
+static void areaWidget_get_property(GObject *obj, guint prop, GValue *value, GParamSpec *pspec)
+{
+	G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, prop, pspec);
+}
+
+static void areaWidget_class_init(areaWidgetClass *class)
+{
+	G_OBJECT_CLASS(class)->dispose = areaWidget_dispose;
+	G_OBJECT_CLASS(class)->finalize = areaWidget_finalize;
+	G_OBJECT_CLASS(class)->set_property = areaWidget_set_property;
+	G_OBJECT_CLASS(class)->get_property = areaWidget_get_property;
+
+	GTK_WIDGET_CLASS(class)->size_allocate = areaWidget_size_allocate;
+	GTK_WIDGET_CLASS(class)->draw = areaWidget_draw;
+	GTK_WIDGET_CLASS(class)->get_preferred_height = areaWidget_get_preferred_height;
+	GTK_WIDGET_CLASS(class)->get_preferred_width = areaWidget_get_preferred_width;
+	GTK_WIDGET_CLASS(class)->button_press_event = areaWidget_button_press_event;
+	GTK_WIDGET_CLASS(class)->button_release_event = areaWidget_button_release_event;
+	GTK_WIDGET_CLASS(class)->motion_notify_event = areaWidget_motion_notify_event;
+	GTK_WIDGET_CLASS(class)->enter_notify_event = areaWidget_enter_notify_event;
+	GTK_WIDGET_CLASS(class)->leave_notify_event = areaWidget_leave_notify_event;
+	GTK_WIDGET_CLASS(class)->key_press_event = areaWidget_key_press_event;
+	GTK_WIDGET_CLASS(class)->key_release_event = areaWidget_key_release_event;
+
+	pspecArea = g_param_spec_pointer("libui-area",
+		"libui-area",
+		"uiArea.",
+		G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
+	g_object_class_install_property(G_OBJECT_CLASS(class), pArea, pspecArea);
+}
+
+// control implementation
+
+uiUnixControlAllDefaults(uiArea)
+
+void uiAreaSetSize(uiArea *a, int width, int height)
+{
+	if (!a->scrolling)
+		userbug("You cannot call uiAreaSetSize() on a non-scrolling uiArea. (area: %p)", a);
+	a->scrollWidth = width;
+	a->scrollHeight = height;
+	gtk_widget_queue_resize(a->areaWidget);
+}
+
+void uiAreaQueueRedrawAll(uiArea *a)
+{
+	gtk_widget_queue_draw(a->areaWidget);
+}
+
+void uiAreaScrollTo(uiArea *a, double x, double y, double width, double height)
+{
+	// TODO
+	// TODO adjust adjustments and find source for that
+}
+
+void uiAreaBeginUserWindowMove(uiArea *a)
+{
+	GtkWidget *toplevel;
+
+	if (a->dragevent == NULL)
+		userbug("cannot call uiAreaBeginUserWindowMove() outside of a Mouse() with Down != 0");
+	// TODO don't we have a libui function for this? did I scrap it?
+	// TODO widget or areaWidget?
+	toplevel = gtk_widget_get_toplevel(a->widget);
+	if (toplevel == NULL) {
+		// TODO
+		return;
+	}
+	// the docs say to do this
+	if (!gtk_widget_is_toplevel(toplevel)) {
+		// TODO
+		return;
+	}
+	if (!GTK_IS_WINDOW(toplevel)) {
+		// TODO
+		return;
+	}
+	gtk_window_begin_move_drag(GTK_WINDOW(toplevel),
+		a->dragevent->button,
+		a->dragevent->x_root,		// TODO are these correct?
+		a->dragevent->y_root,
+		a->dragevent->time);
+}
+
+static const GdkWindowEdge edges[] = {
+	[uiWindowResizeEdgeLeft] = GDK_WINDOW_EDGE_WEST,
+	[uiWindowResizeEdgeTop] = GDK_WINDOW_EDGE_NORTH,
+	[uiWindowResizeEdgeRight] = GDK_WINDOW_EDGE_EAST,
+	[uiWindowResizeEdgeBottom] = GDK_WINDOW_EDGE_SOUTH,
+	[uiWindowResizeEdgeTopLeft] = GDK_WINDOW_EDGE_NORTH_WEST,
+	[uiWindowResizeEdgeTopRight] = GDK_WINDOW_EDGE_NORTH_EAST,
+	[uiWindowResizeEdgeBottomLeft] = GDK_WINDOW_EDGE_SOUTH_WEST,
+	[uiWindowResizeEdgeBottomRight] = GDK_WINDOW_EDGE_SOUTH_EAST,
+};
+
+void uiAreaBeginUserWindowResize(uiArea *a, uiWindowResizeEdge edge)
+{
+	GtkWidget *toplevel;
+
+	if (a->dragevent == NULL)
+		userbug("cannot call uiAreaBeginUserWindowResize() outside of a Mouse() with Down != 0");
+	// TODO don't we have a libui function for this? did I scrap it?
+	// TODO widget or areaWidget?
+	toplevel = gtk_widget_get_toplevel(a->widget);
+	if (toplevel == NULL) {
+		// TODO
+		return;
+	}
+	// the docs say to do this
+	if (!gtk_widget_is_toplevel(toplevel)) {
+		// TODO
+		return;
+	}
+	if (!GTK_IS_WINDOW(toplevel)) {
+		// TODO
+		return;
+	}
+	gtk_window_begin_resize_drag(GTK_WINDOW(toplevel),
+		edges[edge],
+		a->dragevent->button,
+		a->dragevent->x_root,		// TODO are these correct?
+		a->dragevent->y_root,
+		a->dragevent->time);
+}
+
+uiArea *uiNewArea(uiAreaHandler *ah)
+{
+	uiArea *a;
+
+	uiUnixNewControl(uiArea, a);
+
+	a->ah = ah;
+	a->scrolling = FALSE;
+
+	a->areaWidget = GTK_WIDGET(g_object_new(areaWidgetType,
+		"libui-area", a,
+		NULL));
+	a->drawingArea = GTK_DRAWING_AREA(a->areaWidget);
+	a->area = areaWidget(a->areaWidget);
+
+	a->widget = a->areaWidget;
+
+	return a;
+}
+
+uiArea *uiNewScrollingArea(uiAreaHandler *ah, int width, int height)
+{
+	uiArea *a;
+
+	uiUnixNewControl(uiArea, a);
+
+	a->ah = ah;
+	a->scrolling = TRUE;
+	a->scrollWidth = width;
+	a->scrollHeight = height;
+
+	a->swidget = gtk_scrolled_window_new(NULL, NULL);
+	a->scontainer = GTK_CONTAINER(a->swidget);
+	a->sw = GTK_SCROLLED_WINDOW(a->swidget);
+
+	a->areaWidget = GTK_WIDGET(g_object_new(areaWidgetType,
+		"libui-area", a,
+		NULL));
+	a->drawingArea = GTK_DRAWING_AREA(a->areaWidget);
+	a->area = areaWidget(a->areaWidget);
+
+	a->widget = a->swidget;
+
+	gtk_container_add(a->scontainer, a->areaWidget);
+	// and make the area visible; only the scrolled window's visibility is controlled by libui
+	gtk_widget_show(a->areaWidget);
+
+	return a;
+}
diff --git a/src/libui_sdl/libui/unix/box.c b/src/libui_sdl/libui/unix/box.c
new file mode 100644
index 0000000..23fb7f7
--- /dev/null
+++ b/src/libui_sdl/libui/unix/box.c
@@ -0,0 +1,159 @@
+// 7 april 2015
+#include "uipriv_unix.h"
+
+struct boxChild {
+	uiControl *c;
+	int stretchy;
+	gboolean oldhexpand;
+	GtkAlign oldhalign;
+	gboolean oldvexpand;
+	GtkAlign oldvalign;
+};
+
+struct uiBox {
+	uiUnixControl c;
+	GtkWidget *widget;
+	GtkContainer *container;
+	GtkBox *box;
+	GArray *controls;
+	int vertical;
+	int padded;
+	GtkSizeGroup *stretchygroup;		// ensures all stretchy controls have the same size
+};
+
+uiUnixControlAllDefaultsExceptDestroy(uiBox)
+
+#define ctrl(b, i) &g_array_index(b->controls, struct boxChild, i)
+
+static void uiBoxDestroy(uiControl *c)
+{
+	uiBox *b = uiBox(c);
+	struct boxChild *bc;
+	guint i;
+
+	// kill the size group
+	g_object_unref(b->stretchygroup);
+	// free all controls
+	for (i = 0; i < b->controls->len; i++) {
+		bc = ctrl(b, i);
+		uiControlSetParent(bc->c, NULL);
+		// and make sure the widget itself stays alive
+		uiUnixControlSetContainer(uiUnixControl(bc->c), b->container, TRUE);
+		uiControlDestroy(bc->c);
+	}
+	g_array_free(b->controls, TRUE);
+	// and then ourselves
+	g_object_unref(b->widget);
+	uiFreeControl(uiControl(b));
+}
+
+void uiBoxAppend(uiBox *b, uiControl *c, int stretchy)
+{
+	struct boxChild bc;
+	GtkWidget *widget;
+
+	bc.c = c;
+	bc.stretchy = stretchy;
+	widget = GTK_WIDGET(uiControlHandle(bc.c));
+	bc.oldhexpand = gtk_widget_get_hexpand(widget);
+	bc.oldhalign = gtk_widget_get_halign(widget);
+	bc.oldvexpand = gtk_widget_get_vexpand(widget);
+	bc.oldvalign = gtk_widget_get_valign(widget);
+
+	if (bc.stretchy) {
+		if (b->vertical) {
+			gtk_widget_set_vexpand(widget, TRUE);
+			gtk_widget_set_valign(widget, GTK_ALIGN_FILL);
+		} else {
+			gtk_widget_set_hexpand(widget, TRUE);
+			gtk_widget_set_halign(widget, GTK_ALIGN_FILL);
+		}
+		gtk_size_group_add_widget(b->stretchygroup, widget);
+	} else
+		if (b->vertical)
+			gtk_widget_set_vexpand(widget, FALSE);
+		else
+			gtk_widget_set_hexpand(widget, FALSE);
+	// and make them fill the opposite direction
+	if (b->vertical) {
+		gtk_widget_set_hexpand(widget, TRUE);
+		gtk_widget_set_halign(widget, GTK_ALIGN_FILL);
+	} else {
+		gtk_widget_set_vexpand(widget, TRUE);
+		gtk_widget_set_valign(widget, GTK_ALIGN_FILL);
+	}
+
+	uiControlSetParent(bc.c, uiControl(b));
+	uiUnixControlSetContainer(uiUnixControl(bc.c), b->container, FALSE);
+	g_array_append_val(b->controls, bc);
+}
+
+void uiBoxDelete(uiBox *b, int index)
+{
+	struct boxChild *bc;
+	GtkWidget *widget;
+
+	bc = ctrl(b, index);
+	widget = GTK_WIDGET(uiControlHandle(bc->c));
+
+	uiControlSetParent(bc->c, NULL);
+	uiUnixControlSetContainer(uiUnixControl(bc->c), b->container, TRUE);
+
+	if (bc->stretchy)
+		gtk_size_group_remove_widget(b->stretchygroup, widget);
+	gtk_widget_set_hexpand(widget, bc->oldhexpand);
+	gtk_widget_set_halign(widget, bc->oldhalign);
+	gtk_widget_set_vexpand(widget, bc->oldvexpand);
+	gtk_widget_set_valign(widget, bc->oldvalign);
+
+	g_array_remove_index(b->controls, index);
+}
+
+int uiBoxPadded(uiBox *b)
+{
+	return b->padded;
+}
+
+void uiBoxSetPadded(uiBox *b, int padded)
+{
+	b->padded = padded;
+	if (b->padded)
+		if (b->vertical)
+			gtk_box_set_spacing(b->box, gtkYPadding);
+		else
+			gtk_box_set_spacing(b->box, gtkXPadding);
+	else
+		gtk_box_set_spacing(b->box, 0);
+}
+
+static uiBox *finishNewBox(GtkOrientation orientation)
+{
+	uiBox *b;
+
+	uiUnixNewControl(uiBox, b);
+
+	b->widget = gtk_box_new(orientation, 0);
+	b->container = GTK_CONTAINER(b->widget);
+	b->box = GTK_BOX(b->widget);
+
+	b->vertical = orientation == GTK_ORIENTATION_VERTICAL;
+
+	if (b->vertical)
+		b->stretchygroup = gtk_size_group_new(GTK_SIZE_GROUP_VERTICAL);
+	else
+		b->stretchygroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
+
+	b->controls = g_array_new(FALSE, TRUE, sizeof (struct boxChild));
+
+	return b;
+}
+
+uiBox *uiNewHorizontalBox(void)
+{
+	return finishNewBox(GTK_ORIENTATION_HORIZONTAL);
+}
+
+uiBox *uiNewVerticalBox(void)
+{
+	return finishNewBox(GTK_ORIENTATION_VERTICAL);
+}
diff --git a/src/libui_sdl/libui/unix/button.c b/src/libui_sdl/libui/unix/button.c
new file mode 100644
index 0000000..00a87f4
--- /dev/null
+++ b/src/libui_sdl/libui/unix/button.c
@@ -0,0 +1,55 @@
+// 10 june 2015
+#include "uipriv_unix.h"
+
+struct uiButton {
+	uiUnixControl c;
+	GtkWidget *widget;
+	GtkButton *button;
+	void (*onClicked)(uiButton *, void *);
+	void *onClickedData;
+};
+
+uiUnixControlAllDefaults(uiButton)
+
+static void onClicked(GtkButton *button, gpointer data)
+{
+	uiButton *b = uiButton(data);
+
+	(*(b->onClicked))(b, b->onClickedData);
+}
+
+static void defaultOnClicked(uiButton *b, void *data)
+{
+	// do nothing
+}
+
+char *uiButtonText(uiButton *b)
+{
+	return uiUnixStrdupText(gtk_button_get_label(b->button));
+}
+
+void uiButtonSetText(uiButton *b, const char *text)
+{
+	gtk_button_set_label(b->button, text);
+}
+
+void uiButtonOnClicked(uiButton *b, void (*f)(uiButton *, void *), void *data)
+{
+	b->onClicked = f;
+	b->onClickedData = data;
+}
+
+uiButton *uiNewButton(const char *text)
+{
+	uiButton *b;
+
+	uiUnixNewControl(uiButton, b);
+
+	b->widget = gtk_button_new_with_label(text);
+	b->button = GTK_BUTTON(b->widget);
+
+	g_signal_connect(b->widget, "clicked", G_CALLBACK(onClicked), b);
+	uiButtonOnClicked(b, defaultOnClicked, NULL);
+
+	return b;
+}
diff --git a/src/libui_sdl/libui/unix/cellrendererbutton.c b/src/libui_sdl/libui/unix/cellrendererbutton.c
new file mode 100644
index 0000000..e3bbf48
--- /dev/null
+++ b/src/libui_sdl/libui/unix/cellrendererbutton.c
@@ -0,0 +1,299 @@
+// 28 june 2016
+#include "uipriv_unix.h"
+
+// TODOs
+// - it's a rather tight fit
+// - selected row text color is white
+// - resizing a column with a button in it crashes the program
+// - accessibility
+// - right side too big?
+
+#define cellRendererButtonType (cellRendererButton_get_type())
+#define cellRendererButton(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), cellRendererButtonType, cellRendererButton))
+#define isCellRendererButton(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), cellRendererButtonType))
+#define cellRendererButtonClass(class) (G_TYPE_CHECK_CLASS_CAST((class), cellRendererButtonType, cellRendererButtonClass))
+#define isCellRendererButtonClass(class) (G_TYPE_CHECK_CLASS_TYPE((class), cellRendererButton))
+#define getCellRendererButtonClass(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), cellRendererButtonType, cellRendererButtonClass))
+
+typedef struct cellRendererButton cellRendererButton;
+typedef struct cellRendererButtonClass cellRendererButtonClass;
+
+struct cellRendererButton {
+	GtkCellRenderer parent_instance;
+	char *text;
+};
+
+struct cellRendererButtonClass {
+	GtkCellRendererClass parent_class;
+};
+
+G_DEFINE_TYPE(cellRendererButton, cellRendererButton, GTK_TYPE_CELL_RENDERER)
+
+static void cellRendererButton_init(cellRendererButton *c)
+{
+	g_object_set(c, "mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE, NULL);
+	// the standard cell renderers all do this
+	gtk_cell_renderer_set_padding(GTK_CELL_RENDERER(c), 2, 2);
+}
+
+static void cellRendererButton_dispose(GObject *obj)
+{
+	G_OBJECT_CLASS(cellRendererButton_parent_class)->dispose(obj);
+}
+
+static void cellRendererButton_finalize(GObject *obj)
+{
+	cellRendererButton *c = cellRendererButton(obj);
+
+	if (c->text != NULL) {
+		g_free(c->text);
+		c->text = NULL;
+	}
+	G_OBJECT_CLASS(cellRendererButton_parent_class)->finalize(obj);
+}
+
+static GtkSizeRequestMode cellRendererButton_get_request_mode(GtkCellRenderer *r)
+{
+	return GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH;
+}
+
+// this is basically what GtkCellRendererToggle did in 3.10 and does in 3.20, as well as what the Foreign Drawing gtk3-demo demo does
+static GtkStyleContext *setButtonStyle(GtkWidget *widget)
+{
+	GtkStyleContext *base, *context;
+	GtkWidgetPath *path;
+
+	base = gtk_widget_get_style_context(widget);
+	context = gtk_style_context_new();
+
+	path = gtk_widget_path_copy(gtk_style_context_get_path(base));
+	gtk_widget_path_append_type(path, G_TYPE_NONE);
+	if (!FUTURE_gtk_widget_path_iter_set_object_name(path, -1, "button"))
+		// not on 3.20; try the type
+		gtk_widget_path_iter_set_object_type(path, -1, GTK_TYPE_BUTTON);
+
+	gtk_style_context_set_path(context, path);
+	gtk_style_context_set_parent(context, base);
+	// the gtk3-demo example (which says we need to do this) uses gtk_widget_path_iter_get_state(path, -1) but that's not available until 3.14
+	// TODO make a future for that too
+	gtk_style_context_set_state(context, gtk_style_context_get_state(base));
+	gtk_widget_path_unref(path);
+
+	// and if the above widget path screwery stil doesn't work, this will
+	gtk_style_context_add_class(context, GTK_STYLE_CLASS_BUTTON);
+
+	return context;
+}
+
+void unsetButtonStyle(GtkStyleContext *context)
+{
+	g_object_unref(context);
+}
+
+// this is based on what GtkCellRendererText does
+static void cellRendererButton_get_preferred_width(GtkCellRenderer *r, GtkWidget *widget, gint *minimum, gint *natural)
+{
+	cellRendererButton *c = cellRendererButton(r);
+	gint xpad;
+	PangoLayout *layout;
+	PangoRectangle rect;
+	gint out;
+
+	gtk_cell_renderer_get_padding(GTK_CELL_RENDERER(c), &xpad, NULL);
+
+	layout = gtk_widget_create_pango_layout(widget, c->text);
+	pango_layout_set_width(layout, -1);
+	pango_layout_get_extents(layout, NULL, &rect);
+	g_object_unref(layout);
+
+	out = 2 * xpad + PANGO_PIXELS_CEIL(rect.width);
+	if (minimum != NULL)
+		*minimum = out;
+	if (natural != NULL)
+		*natural = out;
+}
+
+// this is based on what GtkCellRendererText does
+static void cellRendererButton_get_preferred_height_for_width(GtkCellRenderer *r, GtkWidget *widget, gint width, gint *minimum, gint *natural)
+{
+	cellRendererButton *c = cellRendererButton(r);
+	gint xpad, ypad;
+	PangoLayout *layout;
+	gint height;
+	gint out;
+
+	gtk_cell_renderer_get_padding(GTK_CELL_RENDERER(c), &xpad, &ypad);
+
+	layout = gtk_widget_create_pango_layout(widget, c->text);
+	pango_layout_set_width(layout, ((2 * xpad + width) * PANGO_SCALE));
+	pango_layout_get_pixel_size(layout, NULL, &height);
+	g_object_unref(layout);
+
+	out = 2 * ypad + height;
+	if (minimum != NULL)
+		*minimum = out;
+	if (natural != NULL)
+		*natural = out;
+}
+
+// this is basically what GtkCellRendererText does
+static void cellRendererButton_get_preferred_height(GtkCellRenderer *r, GtkWidget *widget, gint *minimum, gint *natural)
+{
+	gint width;
+
+	gtk_cell_renderer_get_preferred_width(r, widget, &width, NULL);
+	gtk_cell_renderer_get_preferred_height_for_width(r, widget, width, minimum, natural);
+}
+
+// this is based on what GtkCellRendererText does
+static void cellRendererButton_get_aligned_area(GtkCellRenderer *r, GtkWidget *widget, GtkCellRendererState flags, const GdkRectangle *cell_area, GdkRectangle *aligned_area)
+{
+	cellRendererButton *c = cellRendererButton(r);
+	gint xpad, ypad;
+	PangoLayout *layout;
+	PangoRectangle rect;
+	gfloat xalign, yalign;
+	gint xoffset, yoffset;
+
+	gtk_cell_renderer_get_padding(GTK_CELL_RENDERER(c), &xpad, &ypad);
+
+	layout = gtk_widget_create_pango_layout(widget, c->text);
+	pango_layout_set_width(layout, -1);
+	pango_layout_get_pixel_extents(layout, NULL, &rect);
+
+	xoffset = 0;
+	yoffset = 0;
+	if (cell_area != NULL) {
+		gtk_cell_renderer_get_alignment(GTK_CELL_RENDERER(c), &xalign, &yalign);
+		xoffset = cell_area->width - (2 * xpad + rect.width);
+		// use explicit casts just to be safe
+		if (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL)
+			xoffset = ((gdouble) xoffset) * (1.0 - xalign);
+		else
+			xoffset *= ((gdouble) xoffset) * xalign;
+		yoffset = yalign * (cell_area->height - (2 * ypad + rect.height));
+		yoffset = MAX(yoffset, 0);
+	}
+
+	aligned_area->x = cell_area->x + xoffset;
+	aligned_area->y = cell_area->y + yoffset;
+	aligned_area->width = 2 * xpad + rect.width;
+	aligned_area->height = 2 * ypad + rect.height;
+
+	g_object_unref(layout);
+}
+
+// this is based on both what GtkCellRendererText does and what GtkCellRendererToggle does
+static void cellRendererButton_render(GtkCellRenderer *r, cairo_t *cr, GtkWidget *widget, const GdkRectangle *background_area, const GdkRectangle *cell_area, GtkCellRendererState flags)
+{
+	cellRendererButton *c = cellRendererButton(r);
+	gint xpad, ypad;
+	GdkRectangle alignedArea;
+	gint xoffset, yoffset;
+	GtkStyleContext *context;
+	PangoLayout *layout;
+	PangoRectangle rect;
+
+	gtk_cell_renderer_get_padding(GTK_CELL_RENDERER(c), &xpad, &ypad);
+	gtk_cell_renderer_get_aligned_area(GTK_CELL_RENDERER(c), widget, flags, cell_area, &alignedArea);
+	xoffset = alignedArea.x - cell_area->x;
+	yoffset = alignedArea.y - cell_area->y;
+
+	context = setButtonStyle(widget);
+	layout = gtk_widget_create_pango_layout(widget, c->text);
+
+	gtk_render_background(context, cr,
+		background_area->x + xoffset + xpad,
+		background_area->y + yoffset + ypad,
+		background_area->width - 2 * xpad,
+		background_area->height - 2 * ypad);
+	gtk_render_frame(context, cr,
+		background_area->x + xoffset + xpad,
+		background_area->y + yoffset + ypad,
+		background_area->width - 2 * xpad,
+		background_area->height - 2 * ypad);
+
+	pango_layout_set_width(layout, -1);
+	pango_layout_get_pixel_extents(layout, NULL, &rect);
+	xoffset -= rect.x;
+	gtk_render_layout(context, cr,
+		cell_area->x + xoffset + xpad,
+		cell_area->y + yoffset + ypad,
+		layout);
+
+	g_object_unref(layout);
+	unsetButtonStyle(context);
+}
+
+static guint clickedSignal;
+
+static gboolean cellRendererButton_activate(GtkCellRenderer *r, GdkEvent *e, GtkWidget *widget, const gchar *path, const GdkRectangle *background_area, const GdkRectangle *cell_area, GtkCellRendererState flags)
+{
+	g_signal_emit(r, clickedSignal, 0, path);
+	return TRUE;
+}
+
+static GParamSpec *props[2] = { NULL, NULL };
+
+static void cellRendererButton_set_property(GObject *object, guint prop, const GValue *value, GParamSpec *pspec)
+{
+	cellRendererButton *c = cellRendererButton(object);
+
+	if (prop != 1) {
+		G_OBJECT_WARN_INVALID_PROPERTY_ID(c, prop, pspec);
+		return;
+	}
+	if (c->text != NULL)
+		g_free(c->text);
+	c->text = g_value_dup_string(value);
+	// GtkCellRendererText doesn't queue a redraw; we won't either
+}
+
+static void cellRendererButton_get_property(GObject *object, guint prop, GValue *value, GParamSpec *pspec)
+{
+	cellRendererButton *c = cellRendererButton(object);
+
+	if (prop != 1) {
+		G_OBJECT_WARN_INVALID_PROPERTY_ID(c, prop, pspec);
+		return;
+	}
+	g_value_set_string(value, c->text);
+}
+
+static void cellRendererButton_class_init(cellRendererButtonClass *class)
+{
+	G_OBJECT_CLASS(class)->dispose = cellRendererButton_dispose;
+	G_OBJECT_CLASS(class)->finalize = cellRendererButton_finalize;
+	G_OBJECT_CLASS(class)->set_property = cellRendererButton_set_property;
+	G_OBJECT_CLASS(class)->get_property = cellRendererButton_get_property;
+	GTK_CELL_RENDERER_CLASS(class)->get_request_mode = cellRendererButton_get_request_mode;
+	GTK_CELL_RENDERER_CLASS(class)->get_preferred_width = cellRendererButton_get_preferred_width;
+	GTK_CELL_RENDERER_CLASS(class)->get_preferred_height_for_width = cellRendererButton_get_preferred_height_for_width;
+	GTK_CELL_RENDERER_CLASS(class)->get_preferred_height = cellRendererButton_get_preferred_height;
+	// don't provide a get_preferred_width_for_height()
+	GTK_CELL_RENDERER_CLASS(class)->get_aligned_area = cellRendererButton_get_aligned_area;
+	// don't provide a get_size()
+	GTK_CELL_RENDERER_CLASS(class)->render = cellRendererButton_render;
+	GTK_CELL_RENDERER_CLASS(class)->activate = cellRendererButton_activate;
+	// don't provide a start_editing()
+
+	props[1] = g_param_spec_string("text",
+		"Text",
+		"Button text",
+		"",
+		G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS);
+	g_object_class_install_properties(G_OBJECT_CLASS(class), 2, props);
+
+	clickedSignal = g_signal_new("clicked",
+		G_TYPE_FROM_CLASS(class),
+		G_SIGNAL_RUN_LAST,
+		0,
+		NULL, NULL, NULL,
+		G_TYPE_NONE,
+		1, G_TYPE_STRING);
+}
+
+GtkCellRenderer *newCellRendererButton(void)
+{
+	return GTK_CELL_RENDERER(g_object_new(cellRendererButtonType, NULL));
+}
diff --git a/src/libui_sdl/libui/unix/checkbox.c b/src/libui_sdl/libui/unix/checkbox.c
new file mode 100644
index 0000000..47f8514
--- /dev/null
+++ b/src/libui_sdl/libui/unix/checkbox.c
@@ -0,0 +1,78 @@
+// 10 june 2015
+#include "uipriv_unix.h"
+
+struct uiCheckbox {
+	uiUnixControl c;
+	GtkWidget *widget;
+	GtkButton *button;
+	GtkToggleButton *toggleButton;
+	GtkCheckButton *checkButton;
+	void (*onToggled)(uiCheckbox *, void *);
+	void *onToggledData;
+	gulong onToggledSignal;
+};
+
+uiUnixControlAllDefaults(uiCheckbox)
+
+static void onToggled(GtkToggleButton *b, gpointer data)
+{
+	uiCheckbox *c = uiCheckbox(data);
+
+	(*(c->onToggled))(c, c->onToggledData);
+}
+
+static void defaultOnToggled(uiCheckbox *c, void *data)
+{
+	// do nothing
+}
+
+char *uiCheckboxText(uiCheckbox *c)
+{
+	return uiUnixStrdupText(gtk_button_get_label(c->button));
+}
+
+void uiCheckboxSetText(uiCheckbox *c, const char *text)
+{
+	gtk_button_set_label(GTK_BUTTON(c->button), text);
+}
+
+void uiCheckboxOnToggled(uiCheckbox *c, void (*f)(uiCheckbox *, void *), void *data)
+{
+	c->onToggled = f;
+	c->onToggledData = data;
+}
+
+int uiCheckboxChecked(uiCheckbox *c)
+{
+	return gtk_toggle_button_get_active(c->toggleButton) != FALSE;
+}
+
+void uiCheckboxSetChecked(uiCheckbox *c, int checked)
+{
+	gboolean active;
+
+	active = FALSE;
+	if (checked)
+		active = TRUE;
+	// we need to inhibit sending of ::toggled because this WILL send a ::toggled otherwise
+	g_signal_handler_block(c->toggleButton, c->onToggledSignal);
+	gtk_toggle_button_set_active(c->toggleButton, active);
+	g_signal_handler_unblock(c->toggleButton, c->onToggledSignal);
+}
+
+uiCheckbox *uiNewCheckbox(const char *text)
+{
+	uiCheckbox *c;
+
+	uiUnixNewControl(uiCheckbox, c);
+
+	c->widget = gtk_check_button_new_with_label(text);
+	c->button = GTK_BUTTON(c->widget);
+	c->toggleButton = GTK_TOGGLE_BUTTON(c->widget);
+	c->checkButton = GTK_CHECK_BUTTON(c->widget);
+
+	c->onToggledSignal = g_signal_connect(c->widget, "toggled", G_CALLBACK(onToggled), c);
+	uiCheckboxOnToggled(c, defaultOnToggled, NULL);
+
+	return c;
+}
diff --git a/src/libui_sdl/libui/unix/child.c b/src/libui_sdl/libui/unix/child.c
new file mode 100644
index 0000000..b4a0967
--- /dev/null
+++ b/src/libui_sdl/libui/unix/child.c
@@ -0,0 +1,120 @@
+// 28 august 2015
+#include "uipriv_unix.h"
+
+// This file contains helpers for managing child controls.
+
+struct child {
+	uiControl *c;
+	GtkWidget *widget;
+
+	gboolean oldhexpand;
+	GtkAlign oldhalign;
+	gboolean oldvexpand;
+	GtkAlign oldvalign;
+
+	// Some children can be boxed; that is, they can have an optionally-margined box around them.
+	// uiGroup, uiTab, and uiWindow all do this.
+	GtkWidget *box;
+
+	// If the child is not boxed, this is its parent.
+	// If the child is boxed, this is the box.
+	GtkContainer *parent;
+
+	// This flag is for users of these functions.
+	// For uiBox, this is "spaced".
+	// For uiTab, this is "margined". (uiGroup and uiWindow have to maintain their margined state themselves, since the margined state is independent of whether there is a child for those two.)
+	int flag;
+};
+
+struct child *newChild(uiControl *child, uiControl *parent, GtkContainer *parentContainer)
+{
+	struct child *c;
+
+	if (child == NULL)
+		return NULL;
+
+	c = uiNew(struct child);
+	c->c = child;
+	c->widget = GTK_WIDGET(uiControlHandle(c->c));
+
+	c->oldhexpand = gtk_widget_get_hexpand(c->widget);
+	c->oldhalign = gtk_widget_get_halign(c->widget);
+	c->oldvexpand = gtk_widget_get_vexpand(c->widget);
+	c->oldvalign = gtk_widget_get_valign(c->widget);
+
+	uiControlSetParent(c->c, parent);
+	uiUnixControlSetContainer(uiUnixControl(c->c), parentContainer, FALSE);
+	c->parent = parentContainer;
+
+	return c;
+}
+
+struct child *newChildWithBox(uiControl *child, uiControl *parent, GtkContainer *parentContainer, int margined)
+{
+	struct child *c;
+	GtkWidget *box;
+
+	if (child == NULL)
+		return NULL;
+	box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+	gtk_widget_show(box);
+	c = newChild(child, parent, GTK_CONTAINER(box));
+	gtk_widget_set_hexpand(c->widget, TRUE);
+	gtk_widget_set_halign(c->widget, GTK_ALIGN_FILL);
+	gtk_widget_set_vexpand(c->widget, TRUE);
+	gtk_widget_set_valign(c->widget, GTK_ALIGN_FILL);
+	c->box = box;
+	gtk_container_add(parentContainer, c->box);
+	childSetMargined(c, margined);
+	return c;
+}
+
+void childRemove(struct child *c)
+{
+	uiControlSetParent(c->c, NULL);
+	uiUnixControlSetContainer(uiUnixControl(c->c), c->parent, TRUE);
+
+	gtk_widget_set_hexpand(c->widget, c->oldhexpand);
+	gtk_widget_set_halign(c->widget, c->oldhalign);
+	gtk_widget_set_vexpand(c->widget, c->oldvexpand);
+	gtk_widget_set_valign(c->widget, c->oldvalign);
+
+	if (c->box != NULL)
+		gtk_widget_destroy(c->box);
+
+	uiFree(c);
+}
+
+void childDestroy(struct child *c)
+{
+	uiControl *child;
+
+	child = c->c;
+	childRemove(c);
+	uiControlDestroy(child);
+}
+
+GtkWidget *childWidget(struct child *c)
+{
+	return c->widget;
+}
+
+int childFlag(struct child *c)
+{
+	return c->flag;
+}
+
+void childSetFlag(struct child *c, int flag)
+{
+	c->flag = flag;
+}
+
+GtkWidget *childBox(struct child *c)
+{
+	return c->box;
+}
+
+void childSetMargined(struct child *c, int margined)
+{
+	setMargined(GTK_CONTAINER(c->box), margined);
+}
diff --git a/src/libui_sdl/libui/unix/colorbutton.c b/src/libui_sdl/libui/unix/colorbutton.c
new file mode 100644
index 0000000..393b16f
--- /dev/null
+++ b/src/libui_sdl/libui/unix/colorbutton.c
@@ -0,0 +1,80 @@
+// 15 may 2016
+#include "uipriv_unix.h"
+
+struct uiColorButton {
+	uiUnixControl c;
+	GtkWidget *widget;
+	GtkButton *button;
+	GtkColorButton *cb;
+	GtkColorChooser *cc;
+	void (*onChanged)(uiColorButton *, void *);
+	void *onChangedData;
+};
+
+uiUnixControlAllDefaults(uiColorButton)
+
+static void onColorSet(GtkColorButton *button, gpointer data)
+{
+	uiColorButton *b = uiColorButton(data);
+
+	(*(b->onChanged))(b, b->onChangedData);
+}
+
+static void defaultOnChanged(uiColorButton *b, void *data)
+{
+	// do nothing
+}
+
+void uiColorButtonColor(uiColorButton *b, double *r, double *g, double *bl, double *a)
+{
+	GdkRGBA rgba;
+
+	gtk_color_chooser_get_rgba(b->cc, &rgba);
+	*r = rgba.red;
+	*g = rgba.green;
+	*bl = rgba.blue;
+	*a = rgba.alpha;
+}
+
+void uiColorButtonSetColor(uiColorButton *b, double r, double g, double bl, double a)
+{
+	GdkRGBA rgba;
+
+	rgba.red = r;
+	rgba.green = g;
+	rgba.blue = bl;
+	rgba.alpha = a;
+	// no need to inhibit the signal; color-set is documented as only being sent when the user changes the color
+	gtk_color_chooser_set_rgba(b->cc, &rgba);
+}
+
+void uiColorButtonOnChanged(uiColorButton *b, void (*f)(uiColorButton *, void *), void *data)
+{
+	b->onChanged = f;
+	b->onChangedData = data;
+}
+
+uiColorButton *uiNewColorButton(void)
+{
+	uiColorButton *b;
+	GdkRGBA black;
+
+	uiUnixNewControl(uiColorButton, b);
+
+	// I'm not sure what the initial color is; set up a real one
+	black.red = 0.0;
+	black.green = 0.0;
+	black.blue = 0.0;
+	black.alpha = 1.0;
+	b->widget = gtk_color_button_new_with_rgba(&black);
+	b->button = GTK_BUTTON(b->widget);
+	b->cb = GTK_COLOR_BUTTON(b->widget);
+	b->cc = GTK_COLOR_CHOOSER(b->widget);
+
+	gtk_color_chooser_set_use_alpha(b->cc, TRUE);
+
+	g_signal_connect(b->widget, "color-set", G_CALLBACK(onColorSet), b);
+	uiColorButtonOnChanged(b, defaultOnChanged, NULL);
+
+	return b;
+}
diff --git a/src/libui_sdl/libui/unix/combobox.c b/src/libui_sdl/libui/unix/combobox.c
new file mode 100644
index 0000000..6fed804
--- /dev/null
+++ b/src/libui_sdl/libui/unix/combobox.c
@@ -0,0 +1,66 @@
+// 11 june 2015
+#include "uipriv_unix.h"
+
+struct uiCombobox {
+	uiUnixControl c;
+	GtkWidget *widget;
+	GtkComboBox *combobox;
+	GtkComboBoxText *comboboxText;
+	void (*onSelected)(uiCombobox *, void *);
+	void *onSelectedData;
+	gulong onSelectedSignal;
+};
+
+uiUnixControlAllDefaults(uiCombobox)
+
+static void onChanged(GtkComboBox *cbox, gpointer data)
+{
+	uiCombobox *c = uiCombobox(data);
+
+	(*(c->onSelected))(c, c->onSelectedData);
+}
+
+static void defaultOnSelected(uiCombobox *c, void *data)
+{
+	// do nothing
+}
+
+void uiComboboxAppend(uiCombobox *c, const char *text)
+{
+	gtk_combo_box_text_append(c->comboboxText, NULL, text);
+}
+
+int uiComboboxSelected(uiCombobox *c)
+{
+	return gtk_combo_box_get_active(c->combobox);
+}
+
+void uiComboboxSetSelected(uiCombobox *c, int n)
+{
+	// we need to inhibit sending of ::changed because this WILL send a ::changed otherwise
+	g_signal_handler_block(c->combobox, c->onSelectedSignal);
+	gtk_combo_box_set_active(c->combobox, n);
+	g_signal_handler_unblock(c->combobox, c->onSelectedSignal);
+}
+
+void uiComboboxOnSelected(uiCombobox *c, void (*f)(uiCombobox *c, void *data), void *data)
+{
+	c->onSelected = f;
+	c->onSelectedData = data;
+}
+
+uiCombobox *uiNewCombobox(void)
+{
+	uiCombobox *c;
+
+	uiUnixNewControl(uiCombobox, c);
+
+	c->widget = gtk_combo_box_text_new();
+	c->combobox = GTK_COMBO_BOX(c->widget);
+	c->comboboxText = GTK_COMBO_BOX_TEXT(c->widget);
+
+	c->onSelectedSignal = g_signal_connect(c->widget, "changed", G_CALLBACK(onChanged), c);
+	uiComboboxOnSelected(c, defaultOnSelected, NULL);
+
+	return c;
+}
diff --git a/src/libui_sdl/libui/unix/control.c b/src/libui_sdl/libui/unix/control.c
new file mode 100644
index 0000000..f6fdcea
--- /dev/null
+++ b/src/libui_sdl/libui/unix/control.c
@@ -0,0 +1,14 @@
+// 16 august 2015
+#include "uipriv_unix.h"
+
+void uiUnixControlSetContainer(uiUnixControl *c, GtkContainer *container, gboolean remove)
+{
+	(*(c->SetContainer))(c, container, remove);
+}
+
+#define uiUnixControlSignature 0x556E6978
+
+uiUnixControl *uiUnixAllocControl(size_t n, uint32_t typesig, const char *typenamestr)
+{
+	return uiUnixControl(uiAllocControl(n, uiUnixControlSignature, typesig, typenamestr));
+}
diff --git a/src/libui_sdl/libui/unix/datetimepicker.c b/src/libui_sdl/libui/unix/datetimepicker.c
new file mode 100644
index 0000000..19689a2
--- /dev/null
+++ b/src/libui_sdl/libui/unix/datetimepicker.c
@@ -0,0 +1,599 @@
+// 4 september 2015
+#include "uipriv_unix.h"
+
+// LONGTERM imitate gnome-calendar's day/month/year entries above the calendar
+// LONGTERM allow entering a 24-hour hour in the hour spinbutton and adjust accordingly
+
+#define dateTimePickerWidgetType (dateTimePickerWidget_get_type())
+#define dateTimePickerWidget(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), dateTimePickerWidgetType, dateTimePickerWidget))
+#define isDateTimePickerWidget(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), dateTimePickerWidgetType))
+#define dateTimePickerWidgetClass(class) (G_TYPE_CHECK_CLASS_CAST((class), dateTimePickerWidgetType, dateTimePickerWidgetClass))
+#define isDateTimePickerWidgetClass(class) (G_TYPE_CHECK_CLASS_TYPE((class), dateTimePickerWidget))
+#define getDateTimePickerWidgetClass(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), dateTimePickerWidgetType, dateTimePickerWidgetClass))
+
+typedef struct dateTimePickerWidget dateTimePickerWidget;
+typedef struct dateTimePickerWidgetClass dateTimePickerWidgetClass;
+
+struct dateTimePickerWidget {
+	GtkToggleButton parent_instance;
+
+	gulong toggledSignal;
+
+	gboolean hasTime;
+	gboolean hasDate;
+
+	GtkWidget *window;
+	GtkWidget *box;
+	GtkWidget *calendar;
+	GtkWidget *timebox;
+	GtkWidget *hours;
+	GtkWidget *minutes;
+	GtkWidget *seconds;
+	GtkWidget *ampm;
+
+	gulong hoursBlock;
+	gulong minutesBlock;
+	gulong secondsBlock;
+	gulong ampmBlock;
+
+	GdkDevice *keyboard;
+	GdkDevice *mouse;
+};
+
+struct dateTimePickerWidgetClass {
+	GtkToggleButtonClass parent_class;
+};
+
+G_DEFINE_TYPE(dateTimePickerWidget, dateTimePickerWidget, GTK_TYPE_TOGGLE_BUTTON)
+
+static int realSpinValue(GtkSpinButton *spinButton)
+{
+	GtkAdjustment *adj;
+
+	adj = gtk_spin_button_get_adjustment(spinButton);
+	return (int) gtk_adjustment_get_value(adj);
+}
+
+static void setRealSpinValue(GtkSpinButton *spinButton, int value, gulong block)
+{
+	GtkAdjustment *adj;
+
+	g_signal_handler_block(spinButton, block);
+	adj = gtk_spin_button_get_adjustment(spinButton);
+	gtk_adjustment_set_value(adj, value);
+	g_signal_handler_unblock(spinButton, block);
+}
+
+static GDateTime *selected(dateTimePickerWidget *d)
+{
+	// choose a day for which all times are likely to be valid for the default date in case we're only dealing with time
+	guint year = 1970, month = 1, day = 1;
+	guint hour = 0, minute = 0, second = 0;
+
+	if (d->hasDate) {
+		gtk_calendar_get_date(GTK_CALENDAR(d->calendar), &year, &month, &day);
+		month++;		// GtkCalendar/GDateTime differences
+	}
+	if (d->hasTime) {
+		hour = realSpinValue(GTK_SPIN_BUTTON(d->hours));
+		if (realSpinValue(GTK_SPIN_BUTTON(d->ampm)) != 0)
+			hour += 12;
+		minute = realSpinValue(GTK_SPIN_BUTTON(d->minutes));
+		second = realSpinValue(GTK_SPIN_BUTTON(d->seconds));
+	}
+	return g_date_time_new_local(year, month, day, hour, minute, second);
+}
+
+static void setLabel(dateTimePickerWidget *d)
+{
+	GDateTime *dt;
+	char *fmt;
+	char *msg;
+	gboolean free;
+
+	dt = selected(d);
+	free = FALSE;
+	if (d->hasDate && d->hasTime) {
+		// don't use D_T_FMT; that's too verbose
+		fmt = g_strdup_printf("%s %s", nl_langinfo(D_FMT), nl_langinfo(T_FMT));
+		free = TRUE;
+	} else if (d->hasDate)
+		fmt = nl_langinfo(D_FMT);
+	else
+		fmt = nl_langinfo(T_FMT);
+	msg = g_date_time_format(dt, fmt);
+	gtk_button_set_label(GTK_BUTTON(d), msg);
+	g_free(msg);
+	if (free)
+		g_free(fmt);
+	g_date_time_unref(dt);
+}
+
+static void dateTimeChanged(dateTimePickerWidget *d)
+{
+	setLabel(d);
+	// TODO fire event here
+}
+
+// we don't want ::toggled to be sent again
+static void setActive(dateTimePickerWidget *d, gboolean active)
+{
+	g_signal_handler_block(d, d->toggledSignal);
+	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d), active);
+	g_signal_handler_unblock(d, d->toggledSignal);
+}
+
+// like startGrab() below, a lot of this is in the order that GtkComboBox does it
+static void endGrab(dateTimePickerWidget *d)
+{
+	if (d->keyboard != NULL)
+		gdk_device_ungrab(d->keyboard, GDK_CURRENT_TIME);
+	gdk_device_ungrab(d->mouse, GDK_CURRENT_TIME);
+	gtk_device_grab_remove(d->window, d->mouse);
+	d->keyboard = NULL;
+	d->mouse = NULL;
+}
+
+static void hidePopup(dateTimePickerWidget *d)
+{
+	endGrab(d);
+	gtk_widget_hide(d->window);
+	setActive(d, FALSE);
+}
+
+// this consolidates a good chunk of what GtkComboBox does
+static gboolean startGrab(dateTimePickerWidget *d)
+{
+	GdkDevice *dev;
+	guint32 time;
+	GdkWindow *window;
+	GdkDevice *keyboard, *mouse;
+
+	dev = gtk_get_current_event_device();
+	if (dev == NULL) {
+		// this is what GtkComboBox does
+		// since no device was set, just use the first available "master device"
+		GdkDisplay *disp;
+		GdkDeviceManager *dm;
+		GList *list;
+
+		disp = gtk_widget_get_display(GTK_WIDGET(d));
+		dm = gdk_display_get_device_manager(disp);
+		list = gdk_device_manager_list_devices(dm, GDK_DEVICE_TYPE_MASTER);
+		dev = (GdkDevice *) (list->data);
+		g_list_free(list);
+	}
+
+	time = gtk_get_current_event_time();
+	keyboard = dev;
+	mouse = gdk_device_get_associated_device(dev);
+	if (gdk_device_get_source(dev) != GDK_SOURCE_KEYBOARD) {
+		dev = mouse;
+		mouse = keyboard;
+		keyboard = dev;
+	}
+
+	window = gtk_widget_get_window(d->window);
+	if (keyboard != NULL)
+		if (gdk_device_grab(keyboard, window,
+			GDK_OWNERSHIP_WINDOW, TRUE,
+			GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK,
+			NULL, time) != GDK_GRAB_SUCCESS)
+			return FALSE;
+	if (mouse != NULL)
+		if (gdk_device_grab(mouse, window,
+			GDK_OWNERSHIP_WINDOW, TRUE,
+			GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK,
+			NULL, time) != GDK_GRAB_SUCCESS) {
+			if (keyboard != NULL)
+				gdk_device_ungrab(keyboard, time);
+			return FALSE;
+		}
+
+	gtk_device_grab_add(d->window, mouse, TRUE);
+	d->keyboard = keyboard;
+	d->mouse = mouse;
+	return TRUE;
+}
+
+// based on gtk_combo_box_list_position() in the GTK+ source code
+static void allocationToScreen(dateTimePickerWidget *d, gint *x, gint *y)
+{
+	GdkWindow *window;
+	GtkAllocation a;
+	GtkRequisition aWin;
+	GdkScreen *screen;
+	GdkRectangle workarea;
+	int otherY;
+
+	gtk_widget_get_allocation(GTK_WIDGET(d), &a);
+	gtk_widget_get_preferred_size(d->window, &aWin, NULL);
+	*x = 0;
+	*y = 0;
+	if (!gtk_widget_get_has_window(GTK_WIDGET(d))) {
+		*x = a.x;
+		*y = a.y;
+	}
+	window = gtk_widget_get_window(GTK_WIDGET(d));
+	gdk_window_get_root_coords(window, *x, *y, x, y);
+	if (gtk_widget_get_direction(GTK_WIDGET(d)) == GTK_TEXT_DIR_RTL)
+		*x += a.width - aWin.width;
+
+	// now adjust to prevent the box from going offscreen
+	screen = gtk_widget_get_screen(GTK_WIDGET(d));
+	gdk_screen_get_monitor_workarea(screen,
+		gdk_screen_get_monitor_at_window(screen, window),
+		&workarea);
+	if (*x < workarea.x)					// too far to the left?
+		*x = workarea.x;
+	else if (*x + aWin.width > (workarea.x + workarea.width))	// too far to the right?
+		*x = (workarea.x + workarea.width) - aWin.width;
+	// this isn't the same algorithm used by GtkComboBox
+	// first, get our two choices; *y for down and otherY for up
+	otherY = *y - aWin.height;
+	*y += a.height;
+	// and use otherY if we're too low
+	if (*y + aWin.height >= workarea.y + workarea.height)
+		*y = otherY;
+}
+
+static void showPopup(dateTimePickerWidget *d)
+{
+	GtkWidget *toplevel;
+	gint x, y;
+
+	// GtkComboBox does it
+	toplevel = gtk_widget_get_toplevel(GTK_WIDGET(d));
+	if (GTK_IS_WINDOW(toplevel))
+		gtk_window_group_add_window(gtk_window_get_group(GTK_WINDOW(toplevel)), GTK_WINDOW(d->window));
+
+	allocationToScreen(d, &x, &y);
+	gtk_window_move(GTK_WINDOW(d->window), x, y);
+
+	gtk_widget_show(d->window);
+	setActive(d, TRUE);
+
+	if (!startGrab(d))
+		hidePopup(d);
+}
+
+static void onToggled(GtkToggleButton *b, gpointer data)
+{
+	dateTimePickerWidget *d = dateTimePickerWidget(b);
+
+	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(d)))
+		showPopup(d);
+	else
+		hidePopup(d);
+}
+
+static gboolean grabBroken(GtkWidget *w, GdkEventGrabBroken *e, gpointer data)
+{
+	dateTimePickerWidget *d = dateTimePickerWidget(data);
+
+	hidePopup(d);
+	return TRUE;		// this is what GtkComboBox does
+}
+
+static gboolean buttonReleased(GtkWidget *w, GdkEventButton *e, gpointer data)
+{
+	dateTimePickerWidget *d = dateTimePickerWidget(data);
+	int winx, winy;
+	GtkAllocation wina;
+	gboolean in;
+
+	gtk_widget_get_allocation(d->window, &wina);
+	winx = 0;
+	winy = 0;
+	if (!gtk_widget_get_has_window(d->window)) {
+		winx = wina.x;
+		winy = wina.y;
+	}
+	gdk_window_get_root_coords(gtk_widget_get_window(d->window), winx, winy, &winx, &winy);
+	in = TRUE;
+	if (e->x_root < winx)
+		in = FALSE;
+	if (e->x_root >= (winx + wina.width))
+		in = FALSE;
+	if (e->y_root < winy)
+		in = FALSE;
+	if (e->y_root >= (winy + wina.height))
+		in = FALSE;
+	if (!in)
+		hidePopup(d);
+	return TRUE;		// this is what GtkComboBox does
+}
+
+static gint hoursSpinboxInput(GtkSpinButton *sb, gpointer ptr, gpointer data)
+{
+	double *out = (double *) ptr;
+	const gchar *text;
+	int value;
+
+	text = gtk_entry_get_text(GTK_ENTRY(sb));
+	value = (int) g_strtod(text, NULL);
+	if (value < 0 || value > 12)
+		return GTK_INPUT_ERROR;
+	if (value == 12)		// 12 to the user is 0 internally
+		value = 0;
+	*out = (double) value;
+	return TRUE;
+}
+
+static gboolean hoursSpinboxOutput(GtkSpinButton *sb, gpointer data)
+{
+	gchar *text;
+	int value;
+
+	value = realSpinValue(sb);
+	if (value == 0)		// 0 internally is 12 to the user
+		value = 12;
+	text = g_strdup_printf("%d", value);
+	gtk_entry_set_text(GTK_ENTRY(sb), text);
+	g_free(text);
+	return TRUE;
+}
+
+static gboolean zeroPadSpinbox(GtkSpinButton *sb, gpointer data)
+{
+	gchar *text;
+	int value;
+
+	value = realSpinValue(sb);
+	text = g_strdup_printf("%02d", value);
+	gtk_entry_set_text(GTK_ENTRY(sb), text);
+	g_free(text);
+	return TRUE;
+}
+
+// this is really hacky but we can't use GtkCombobox here :(
+static gint ampmSpinboxInput(GtkSpinButton *sb, gpointer ptr, gpointer data)
+{
+	double *out = (double *) ptr;
+	const gchar *text;
+	char firstAM, firstPM;
+
+	text = gtk_entry_get_text(GTK_ENTRY(sb));
+	// LONGTERM don't use ASCII here for case insensitivity
+	firstAM = g_ascii_tolower(nl_langinfo(AM_STR)[0]);
+	firstPM = g_ascii_tolower(nl_langinfo(PM_STR)[0]);
+	for (; *text != '\0'; text++)
+		if (g_ascii_tolower(*text) == firstAM) {
+			*out = 0;
+			return TRUE;
+		} else if (g_ascii_tolower(*text) == firstPM) {
+			*out = 1;
+			return TRUE;
+		}
+	return GTK_INPUT_ERROR;
+}
+
+static gboolean ampmSpinboxOutput(GtkSpinButton *sb, gpointer data)
+{
+	int value;
+
+	value = gtk_spin_button_get_value_as_int(sb);
+	if (value == 0)
+		gtk_entry_set_text(GTK_ENTRY(sb), nl_langinfo(AM_STR));
+	else
+		gtk_entry_set_text(GTK_ENTRY(sb), nl_langinfo(PM_STR));
+	return TRUE;
+}
+
+static void spinboxChanged(GtkSpinButton *sb, gpointer data)
+{
+	dateTimePickerWidget *d = dateTimePickerWidget(data);
+
+	dateTimeChanged(d);
+}
+
+static GtkWidget *newSpinbox(dateTimePickerWidget *d, int min, int max, gint (*input)(GtkSpinButton *, gpointer, gpointer), gboolean (*output)(GtkSpinButton *, gpointer), gulong *block)
+{
+	GtkWidget *sb;
+
+	sb = gtk_spin_button_new_with_range(min, max, 1);
+	gtk_spin_button_set_digits(GTK_SPIN_BUTTON(sb), 0);
+	gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(sb), TRUE);
+	gtk_orientable_set_orientation(GTK_ORIENTABLE(sb), GTK_ORIENTATION_VERTICAL);
+	*block = g_signal_connect(sb, "value-changed", G_CALLBACK(spinboxChanged), d);
+	if (input != NULL)
+		g_signal_connect(sb, "input", G_CALLBACK(input), NULL);
+	if (output != NULL)
+		g_signal_connect(sb, "output", G_CALLBACK(output), NULL);
+	return sb;
+}
+
+static void dateChanged(GtkCalendar *c, gpointer data)
+{
+	dateTimePickerWidget *d = dateTimePickerWidget(data);
+
+	dateTimeChanged(d);
+}
+
+static void setDateOnly(dateTimePickerWidget *d)
+{
+	d->hasTime = FALSE;
+	gtk_container_remove(GTK_CONTAINER(d->box), d->timebox);
+}
+
+static void setTimeOnly(dateTimePickerWidget *d)
+{
+	d->hasDate = FALSE;
+	gtk_container_remove(GTK_CONTAINER(d->box), d->calendar);
+}
+
+static void dateTimePickerWidget_init(dateTimePickerWidget *d)
+{
+	GDateTime *dt;
+	gint year, month, day;
+	gint hour;
+	gulong calendarBlock;
+
+	d->window = gtk_window_new(GTK_WINDOW_POPUP);
+	gtk_window_set_resizable(GTK_WINDOW(d->window), FALSE);
+	gtk_window_set_attached_to(GTK_WINDOW(d->window), GTK_WIDGET(d));
+	gtk_window_set_decorated(GTK_WINDOW(d->window), FALSE);
+	gtk_window_set_deletable(GTK_WINDOW(d->window), FALSE);
+	gtk_window_set_type_hint(GTK_WINDOW(d->window), GDK_WINDOW_TYPE_HINT_COMBO);
+	gtk_window_set_skip_taskbar_hint(GTK_WINDOW(d->window), TRUE);
+	gtk_window_set_skip_pager_hint(GTK_WINDOW(d->window), TRUE);
+	gtk_window_set_has_resize_grip(GTK_WINDOW(d->window), FALSE);
+	gtk_container_set_border_width(GTK_CONTAINER(d->window), 12);
+	// and make it stand out a bit
+	gtk_style_context_add_class(gtk_widget_get_style_context(d->window), "frame");
+
+	d->box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6);
+	gtk_container_add(GTK_CONTAINER(d->window), d->box);
+
+	d->calendar = gtk_calendar_new();
+	calendarBlock = g_signal_connect(d->calendar, "day-selected", G_CALLBACK(dateChanged), d);
+	gtk_container_add(GTK_CONTAINER(d->box), d->calendar);
+
+	d->timebox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
+	gtk_widget_set_valign(d->timebox, GTK_ALIGN_CENTER);
+	gtk_container_add(GTK_CONTAINER(d->box), d->timebox);
+
+	d->hours = newSpinbox(d, 0, 11, hoursSpinboxInput, hoursSpinboxOutput, &(d->hoursBlock));
+	gtk_container_add(GTK_CONTAINER(d->timebox), d->hours);
+
+	gtk_container_add(GTK_CONTAINER(d->timebox),
+		gtk_label_new(":"));
+
+	d->minutes = newSpinbox(d, 0, 59, NULL, zeroPadSpinbox, &(d->minutesBlock));
+	gtk_container_add(GTK_CONTAINER(d->timebox), d->minutes);
+
+	gtk_container_add(GTK_CONTAINER(d->timebox),
+		gtk_label_new(":"));
+
+	d->seconds = newSpinbox(d, 0, 59, NULL, zeroPadSpinbox, &(d->secondsBlock));
+	gtk_container_add(GTK_CONTAINER(d->timebox), d->seconds);
+
+	// LONGTERM this should be the case, but that interferes with grabs
+	// switch to it when we can drop GTK+ 3.10 and use popovers
+#if 0
+	d->ampm = gtk_combo_box_text_new();
+	gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(d->ampm), NULL, "AM");
+	gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(d->ampm), NULL, "PM");
+#endif
+	d->ampm = newSpinbox(d, 0, 1, ampmSpinboxInput, ampmSpinboxOutput, &(d->ampmBlock));
+	gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(d->ampm), FALSE);
+	gtk_widget_set_valign(d->ampm, GTK_ALIGN_CENTER);
+	gtk_container_add(GTK_CONTAINER(d->timebox), d->ampm);
+
+	gtk_widget_show_all(d->box);
+
+	g_signal_connect(d->window, "grab-broken-event", G_CALLBACK(grabBroken), d);
+	g_signal_connect(d->window, "button-release-event", G_CALLBACK(buttonReleased), d);
+
+	d->toggledSignal = g_signal_connect(d, "toggled", G_CALLBACK(onToggled), NULL);
+	d->keyboard = NULL;
+	d->mouse = NULL;
+
+	d->hasTime = TRUE;
+	d->hasDate = TRUE;
+
+	// set the current date/time
+	// notice how we block signals from firing
+	dt = g_date_time_new_now_local();
+	g_date_time_get_ymd(dt, &year, &month, &day);
+	month--;			// GDateTime/GtkCalendar differences
+	g_signal_handler_block(d->calendar, calendarBlock);
+	gtk_calendar_select_month(GTK_CALENDAR(d->calendar), month, year);
+	gtk_calendar_select_day(GTK_CALENDAR(d->calendar), day);
+	g_signal_handler_unblock(d->calendar, calendarBlock);
+	hour = g_date_time_get_hour(dt);
+	if (hour >= 12) {
+		hour -= 12;
+		setRealSpinValue(GTK_SPIN_BUTTON(d->ampm), 1, d->ampmBlock);
+	}
+	setRealSpinValue(GTK_SPIN_BUTTON(d->hours), hour, d->hoursBlock);
+	setRealSpinValue(GTK_SPIN_BUTTON(d->minutes), g_date_time_get_minute(dt), d->minutesBlock);
+	setRealSpinValue(GTK_SPIN_BUTTON(d->seconds), g_date_time_get_seconds(dt), d->secondsBlock);
+	g_date_time_unref(dt);
+}
+
+static void dateTimePickerWidget_dispose(GObject *obj)
+{
+	dateTimePickerWidget *d = dateTimePickerWidget(obj);
+
+	if (d->window != NULL) {
+		gtk_widget_destroy(d->window);
+		d->window = NULL;
+	}
+	G_OBJECT_CLASS(dateTimePickerWidget_parent_class)->dispose(obj);
+}
+
+static void dateTimePickerWidget_finalize(GObject *obj)
+{
+	G_OBJECT_CLASS(dateTimePickerWidget_parent_class)->finalize(obj);
+}
+
+static void dateTimePickerWidget_class_init(dateTimePickerWidgetClass *class)
+{
+	G_OBJECT_CLASS(class)->dispose = dateTimePickerWidget_dispose;
+	G_OBJECT_CLASS(class)->finalize = dateTimePickerWidget_finalize;
+}
+
+static GtkWidget *newDTP(void)
+{
+	GtkWidget *w;
+
+	w = GTK_WIDGET(g_object_new(dateTimePickerWidgetType, "label", "", NULL));
+	setLabel(dateTimePickerWidget(w));
+	return w;
+}
+
+static GtkWidget *newDP(void)
+{
+	GtkWidget *w;
+
+	w = GTK_WIDGET(g_object_new(dateTimePickerWidgetType, "label", "", NULL));
+	setDateOnly(dateTimePickerWidget(w));
+	setLabel(dateTimePickerWidget(w));
+	return w;
+}
+
+static GtkWidget *newTP(void)
+{
+	GtkWidget *w;
+
+	w = GTK_WIDGET(g_object_new(dateTimePickerWidgetType, "label", "", NULL));
+	setTimeOnly(dateTimePickerWidget(w));
+	setLabel(dateTimePickerWidget(w));
+	return w;
+}
+
+struct uiDateTimePicker {
+	uiUnixControl c;
+	GtkWidget *widget;
+	dateTimePickerWidget *d;
+};
+
+uiUnixControlAllDefaults(uiDateTimePicker)
+
+uiDateTimePicker *finishNewDateTimePicker(GtkWidget *(*fn)(void))
+{
+	uiDateTimePicker *d;
+
+	uiUnixNewControl(uiDateTimePicker, d);
+
+	d->widget = (*fn)();
+	d->d = dateTimePickerWidget(d->widget);
+
+	return d;
+}
+
+uiDateTimePicker *uiNewDateTimePicker(void)
+{
+	return finishNewDateTimePicker(newDTP);
+}
+
+uiDateTimePicker *uiNewDatePicker(void)
+{
+	return finishNewDateTimePicker(newDP);
+}
+
+uiDateTimePicker *uiNewTimePicker(void)
+{
+	return finishNewDateTimePicker(newTP);
+}
diff --git a/src/libui_sdl/libui/unix/debug.c b/src/libui_sdl/libui/unix/debug.c
new file mode 100644
index 0000000..c948db6
--- /dev/null
+++ b/src/libui_sdl/libui/unix/debug.c
@@ -0,0 +1,14 @@
+// 13 may 2016
+#include "uipriv_unix.h"
+
+// LONGTERM don't halt on release builds
+
+void realbug(const char *file, const char *line, const char *func, const char *prefix, const char *format, va_list ap)
+{
+	char *a, *b;
+
+	a = g_strdup_printf("[libui] %s:%s:%s() %s", file, line, func, prefix);
+	b = g_strdup_vprintf(format, ap);
+	g_critical("%s%s", a, b);
+	G_BREAKPOINT();
+}
diff --git a/src/libui_sdl/libui/unix/draw.c b/src/libui_sdl/libui/unix/draw.c
new file mode 100644
index 0000000..2d7a636
--- /dev/null
+++ b/src/libui_sdl/libui/unix/draw.c
@@ -0,0 +1,141 @@
+// 6 september 2015
+#include "uipriv_unix.h"
+#include "draw.h"
+
+uiDrawContext *newContext(cairo_t *cr)
+{
+	uiDrawContext *c;
+
+	c = uiNew(uiDrawContext);
+	c->cr = cr;
+	return c;
+}
+
+void freeContext(uiDrawContext *c)
+{
+	uiFree(c);
+}
+
+static cairo_pattern_t *mkbrush(uiDrawBrush *b)
+{
+	cairo_pattern_t *pat;
+	size_t i;
+
+	switch (b->Type) {
+	case uiDrawBrushTypeSolid:
+		pat = cairo_pattern_create_rgba(b->R, b->G, b->B, b->A);
+		break;
+	case uiDrawBrushTypeLinearGradient:
+		pat = cairo_pattern_create_linear(b->X0, b->Y0, b->X1, b->Y1);
+		break;
+	case uiDrawBrushTypeRadialGradient:
+		// make the start circle radius 0 to make it a point
+		pat = cairo_pattern_create_radial(
+			b->X0, b->Y0, 0,
+			b->X1, b->Y1, b->OuterRadius);
+		break;
+//	case uiDrawBrushTypeImage:
+	}
+	if (cairo_pattern_status(pat) != CAIRO_STATUS_SUCCESS)
+		implbug("error creating pattern in mkbrush(): %s",
+			cairo_status_to_string(cairo_pattern_status(pat)));
+	switch (b->Type) {
+	case uiDrawBrushTypeLinearGradient:
+	case uiDrawBrushTypeRadialGradient:
+		for (i = 0; i < b->NumStops; i++)
+			cairo_pattern_add_color_stop_rgba(pat,
+				b->Stops[i].Pos,
+				b->Stops[i].R,
+				b->Stops[i].G,
+				b->Stops[i].B,
+				b->Stops[i].A);
+	}
+	return pat;
+}
+
+void uiDrawStroke(uiDrawContext *c, uiDrawPath *path, uiDrawBrush *b, uiDrawStrokeParams *p)
+{
+	cairo_pattern_t *pat;
+
+	runPath(path, c->cr);
+	pat = mkbrush(b);
+	cairo_set_source(c->cr, pat);
+	switch (p->Cap) {
+	case uiDrawLineCapFlat:
+		cairo_set_line_cap(c->cr, CAIRO_LINE_CAP_BUTT);
+		break;
+	case uiDrawLineCapRound:
+		cairo_set_line_cap(c->cr, CAIRO_LINE_CAP_ROUND);
+		break;
+	case uiDrawLineCapSquare:
+		cairo_set_line_cap(c->cr, CAIRO_LINE_CAP_SQUARE);
+		break;
+	}
+	switch (p->Join) {
+	case uiDrawLineJoinMiter:
+		cairo_set_line_join(c->cr, CAIRO_LINE_JOIN_MITER);
+		cairo_set_miter_limit(c->cr, p->MiterLimit);
+		break;
+	case uiDrawLineJoinRound:
+		cairo_set_line_join(c->cr, CAIRO_LINE_JOIN_ROUND);
+		break;
+	case uiDrawLineJoinBevel:
+		cairo_set_line_join(c->cr, CAIRO_LINE_JOIN_BEVEL);
+		break;
+	}
+	cairo_set_line_width(c->cr, p->Thickness);
+	cairo_set_dash(c->cr, p->Dashes, p->NumDashes, p->DashPhase);
+	cairo_stroke(c->cr);
+	cairo_pattern_destroy(pat);
+}
+
+void uiDrawFill(uiDrawContext *c, uiDrawPath *path, uiDrawBrush *b)
+{
+	cairo_pattern_t *pat;
+
+	runPath(path, c->cr);
+	pat = mkbrush(b);
+	cairo_set_source(c->cr, pat);
+	switch (pathFillMode(path)) {
+	case uiDrawFillModeWinding:
+		cairo_set_fill_rule(c->cr, CAIRO_FILL_RULE_WINDING);
+		break;
+	case uiDrawFillModeAlternate:
+		cairo_set_fill_rule(c->cr, CAIRO_FILL_RULE_EVEN_ODD);
+		break;
+	}
+	cairo_fill(c->cr);
+	cairo_pattern_destroy(pat);
+}
+
+void uiDrawTransform(uiDrawContext *c, uiDrawMatrix *m)
+{
+	cairo_matrix_t cm;
+
+	m2c(m, &cm);
+	cairo_transform(c->cr, &cm);
+}
+
+void uiDrawClip(uiDrawContext *c, uiDrawPath *path)
+{
+	runPath(path, c->cr);
+	switch (pathFillMode(path)) {
+	case uiDrawFillModeWinding:
+		cairo_set_fill_rule(c->cr, CAIRO_FILL_RULE_WINDING);
+		break;
+	case uiDrawFillModeAlternate:
+		cairo_set_fill_rule(c->cr, CAIRO_FILL_RULE_EVEN_ODD);
+		break;
+	}
+	cairo_clip(c->cr);
+}
+
+void uiDrawSave(uiDrawContext *c)
+{
+	cairo_save(c->cr);
+}
+
+void uiDrawRestore(uiDrawContext *c)
+{
+	cairo_restore(c->cr);
+}
diff --git a/src/libui_sdl/libui/unix/draw.h b/src/libui_sdl/libui/unix/draw.h
new file mode 100644
index 0000000..dbd82ff
--- /dev/null
+++ b/src/libui_sdl/libui/unix/draw.h
@@ -0,0 +1,13 @@
+// 5 may 2016
+
+// draw.c
+struct uiDrawContext {
+	cairo_t *cr;
+};
+
+// drawpath.c
+extern void runPath(uiDrawPath *p, cairo_t *cr);
+extern uiDrawFillMode pathFillMode(uiDrawPath *path);
+
+// drawmatrix.c
+extern void m2c(uiDrawMatrix *m, cairo_matrix_t *c);
diff --git a/src/libui_sdl/libui/unix/drawmatrix.c b/src/libui_sdl/libui/unix/drawmatrix.c
new file mode 100644
index 0000000..ac7ac57
--- /dev/null
+++ b/src/libui_sdl/libui/unix/drawmatrix.c
@@ -0,0 +1,109 @@
+// 6 september 2015
+#include "uipriv_unix.h"
+#include "draw.h"
+
+void m2c(uiDrawMatrix *m, cairo_matrix_t *c)
+{
+	c->xx = m->M11;
+	c->yx = m->M12;
+	c->xy = m->M21;
+	c->yy = m->M22;
+	c->x0 = m->M31;
+	c->y0 = m->M32;
+}
+
+static void c2m(cairo_matrix_t *c, uiDrawMatrix *m)
+{
+	m->M11 = c->xx;
+	m->M12 = c->yx;
+	m->M21 = c->xy;
+	m->M22 = c->yy;
+	m->M31 = c->x0;
+	m->M32 = c->y0;
+}
+
+void uiDrawMatrixTranslate(uiDrawMatrix *m, double x, double y)
+{
+	cairo_matrix_t c;
+
+	m2c(m, &c);
+	cairo_matrix_translate(&c, x, y);
+	c2m(&c, m);
+}
+
+void uiDrawMatrixScale(uiDrawMatrix *m, double xCenter, double yCenter, double x, double y)
+{
+	cairo_matrix_t c;
+	double xt, yt;
+
+	m2c(m, &c);
+	xt = x;
+	yt = y;
+	scaleCenter(xCenter, yCenter, &xt, &yt);
+	cairo_matrix_translate(&c, xt, yt);
+	cairo_matrix_scale(&c, x, y);
+	cairo_matrix_translate(&c, -xt, -yt);
+	c2m(&c, m);
+}
+
+void uiDrawMatrixRotate(uiDrawMatrix *m, double x, double y, double amount)
+{
+	cairo_matrix_t c;
+
+	m2c(m, &c);
+	cairo_matrix_translate(&c, x, y);
+	cairo_matrix_rotate(&c, amount);
+	cairo_matrix_translate(&c, -x, -y);
+	c2m(&c, m);
+}
+
+void uiDrawMatrixSkew(uiDrawMatrix *m, double x, double y, double xamount, double yamount)
+{
+	fallbackSkew(m, x, y, xamount, yamount);
+}
+
+void uiDrawMatrixMultiply(uiDrawMatrix *dest, uiDrawMatrix *src)
+{
+	cairo_matrix_t c;
+	cairo_matrix_t d;
+
+	m2c(dest, &c);
+	m2c(src, &d);
+	cairo_matrix_multiply(&c, &c, &d);
+	c2m(&c, dest);
+}
+
+int uiDrawMatrixInvertible(uiDrawMatrix *m)
+{
+	cairo_matrix_t c;
+
+	m2c(m, &c);
+	return cairo_matrix_invert(&c) == CAIRO_STATUS_SUCCESS;
+}
+
+int uiDrawMatrixInvert(uiDrawMatrix *m)
+{
+	cairo_matrix_t c;
+
+	m2c(m, &c);
+	if (cairo_matrix_invert(&c) != CAIRO_STATUS_SUCCESS)
+		return 0;
+	c2m(&c, m);
+	return 1;
+}
+
+void uiDrawMatrixTransformPoint(uiDrawMatrix *m, double *x, double *y)
+{
+	cairo_matrix_t c;
+
+	m2c(m, &c);
+	cairo_matrix_transform_point(&c, x, y);
+}
+
+void uiDrawMatrixTransformSize(uiDrawMatrix *m, double *x, double *y)
+{
+	cairo_matrix_t c;
+
+	m2c(m, &c);
+	cairo_matrix_transform_distance(&c, x, y);
+}
diff --git a/src/libui_sdl/libui/unix/drawpath.c b/src/libui_sdl/libui/unix/drawpath.c
new file mode 100644
index 0000000..a0165fb
--- /dev/null
+++ b/src/libui_sdl/libui/unix/drawpath.c
@@ -0,0 +1,199 @@
+// 6 september 2015
+#include "uipriv_unix.h"
+#include "draw.h"
+
+struct uiDrawPath {
+	GArray *pieces;
+	uiDrawFillMode fillMode;
+	gboolean ended;
+};
+
+struct piece {
+	int type;
+	double d[8];
+	int b;
+};
+
+enum {
+	newFigure,
+	newFigureArc,
+	lineTo,
+	arcTo,
+	bezierTo,
+	closeFigure,
+	addRect,
+};
+
+uiDrawPath *uiDrawNewPath(uiDrawFillMode mode)
+{
+	uiDrawPath *p;
+
+	p = uiNew(uiDrawPath);
+	p->pieces = g_array_new(FALSE, TRUE, sizeof (struct piece));
+	p->fillMode = mode;
+	return p;
+}
+
+void uiDrawFreePath(uiDrawPath *p)
+{
+	g_array_free(p->pieces, TRUE);
+	uiFree(p);
+}
+
+static void add(uiDrawPath *p, struct piece *piece)
+{
+	if (p->ended)
+		userbug("You cannot modify a uiDrawPath that has been ended. (path: %p)", p);
+	g_array_append_vals(p->pieces, piece, 1);
+}
+
+void uiDrawPathNewFigure(uiDrawPath *p, double x, double y)
+{
+	struct piece piece;
+
+	piece.type = newFigure;
+	piece.d[0] = x;
+	piece.d[1] = y;
+	add(p, &piece);
+}
+
+void uiDrawPathNewFigureWithArc(uiDrawPath *p, double xCenter, double yCenter, double radius, double startAngle, double sweep, int negative)
+{
+	struct piece piece;
+
+	if (sweep > 2 * uiPi)
+		sweep = 2 * uiPi;
+	piece.type = newFigureArc;
+	piece.d[0] = xCenter;
+	piece.d[1] = yCenter;
+	piece.d[2] = radius;
+	piece.d[3] = startAngle;
+	piece.d[4] = sweep;
+	piece.b = negative;
+	add(p, &piece);
+}
+
+void uiDrawPathLineTo(uiDrawPath *p, double x, double y)
+{
+	struct piece piece;
+
+	piece.type = lineTo;
+	piece.d[0] = x;
+	piece.d[1] = y;
+	add(p, &piece);
+}
+
+void uiDrawPathArcTo(uiDrawPath *p, double xCenter, double yCenter, double radius, double startAngle, double sweep, int negative)
+{
+	struct piece piece;
+
+	if (sweep > 2 * uiPi)
+		sweep = 2 * uiPi;
+	piece.type = arcTo;
+	piece.d[0] = xCenter;
+	piece.d[1] = yCenter;
+	piece.d[2] = radius;
+	piece.d[3] = startAngle;
+	piece.d[4] = sweep;
+	piece.b = negative;
+	add(p, &piece);
+}
+
+void uiDrawPathBezierTo(uiDrawPath *p, double c1x, double c1y, double c2x, double c2y, double endX, double endY)
+{
+	struct piece piece;
+
+	piece.type = bezierTo;
+	piece.d[0] = c1x;
+	piece.d[1] = c1y;
+	piece.d[2] = c2x;
+	piece.d[3] = c2y;
+	piece.d[4] = endX;
+	piece.d[5] = endY;
+	add(p, &piece);
+}
+
+void uiDrawPathCloseFigure(uiDrawPath *p)
+{
+	struct piece piece;
+
+	piece.type = closeFigure;
+	add(p, &piece);
+}
+
+void uiDrawPathAddRectangle(uiDrawPath *p, double x, double y, double width, double height)
+{
+	struct piece piece;
+
+	piece.type = addRect;
+	piece.d[0] = x;
+	piece.d[1] = y;
+	piece.d[2] = width;
+	piece.d[3] = height;
+	add(p, &piece);
+}
+
+void uiDrawPathEnd(uiDrawPath *p)
+{
+	p->ended = TRUE;
+}
+
+void runPath(uiDrawPath *p, cairo_t *cr)
+{
+	guint i;
+	struct piece *piece;
+	void (*arc)(cairo_t *, double, double, double, double, double);
+
+	if (!p->ended)
+		userbug("You cannot draw with a uiDrawPath that has not been ended. (path: %p)", p);
+	cairo_new_path(cr);
+	for (i = 0; i < p->pieces->len; i++) {
+		piece = &g_array_index(p->pieces, struct piece, i);
+		switch (piece->type) {
+		case newFigure:
+			cairo_move_to(cr, piece->d[0], piece->d[1]);
+			break;
+		case newFigureArc:
+			cairo_new_sub_path(cr);
+			// fall through
+		case arcTo:
+			arc = cairo_arc;
+			if (piece->b)
+				arc = cairo_arc_negative;
+			(*arc)(cr,
+				piece->d[0],
+				piece->d[1],
+				piece->d[2],
+				piece->d[3],
+				piece->d[3] + piece->d[4]);
+			break;
+		case lineTo:
+			cairo_line_to(cr, piece->d[0], piece->d[1]);
+			break;
+		case bezierTo:
+			cairo_curve_to(cr,
+				piece->d[0],
+				piece->d[1],
+				piece->d[2],
+				piece->d[3],
+				piece->d[4],
+				piece->d[5]);
+			break;
+		case closeFigure:
+			cairo_close_path(cr);
+			break;
+		case addRect:
+			cairo_rectangle(cr,
+				piece->d[0],
+				piece->d[1],
+				piece->d[2],
+				piece->d[3]);
+			break;
+		}
+	}
+}
+
+uiDrawFillMode pathFillMode(uiDrawPath *path)
+{
+	return path->fillMode;
+}
diff --git a/src/libui_sdl/libui/unix/drawtext.c b/src/libui_sdl/libui/unix/drawtext.c
new file mode 100644
index 0000000..7078e1a
--- /dev/null
+++ b/src/libui_sdl/libui/unix/drawtext.c
@@ -0,0 +1,293 @@
+// 6 september 2015
+#include "uipriv_unix.h"
+#include "draw.h"
+
+struct uiDrawFontFamilies {
+	PangoFontFamily **f;
+	int n;
+};
+
+uiDrawFontFamilies *uiDrawListFontFamilies(void)
+{
+	uiDrawFontFamilies *ff;
+	PangoFontMap *map;
+
+	ff = uiNew(uiDrawFontFamilies);
+	map = pango_cairo_font_map_get_default();
+	pango_font_map_list_families(map, &(ff->f), &(ff->n));
+	// do not free map; it's a shared resource
+	return ff;
+}
+
+int uiDrawFontFamiliesNumFamilies(uiDrawFontFamilies *ff)
+{
+	return ff->n;
+}
+
+char *uiDrawFontFamiliesFamily(uiDrawFontFamilies *ff, int n)
+{
+	PangoFontFamily *f;
+
+	f = ff->f[n];
+	return uiUnixStrdupText(pango_font_family_get_name(f));
+}
+
+void uiDrawFreeFontFamilies(uiDrawFontFamilies *ff)
+{
+	g_free(ff->f);
+	uiFree(ff);
+}
+
+struct uiDrawTextFont {
+	PangoFont *f;
+};
+
+uiDrawTextFont *mkTextFont(PangoFont *f, gboolean ref)
+{
+	uiDrawTextFont *font;
+
+	font = uiNew(uiDrawTextFont);
+	font->f = f;
+	if (ref)
+		g_object_ref(font->f);
+	return font;
+}
+
+static const PangoWeight pangoWeights[] = {
+	[uiDrawTextWeightThin] = PANGO_WEIGHT_THIN,
+	[uiDrawTextWeightUltraLight] = PANGO_WEIGHT_ULTRALIGHT,
+	[uiDrawTextWeightLight] = PANGO_WEIGHT_LIGHT,
+	[uiDrawTextWeightBook] = PANGO_WEIGHT_BOOK,
+	[uiDrawTextWeightNormal] = PANGO_WEIGHT_NORMAL,
+	[uiDrawTextWeightMedium] = PANGO_WEIGHT_MEDIUM,
+	[uiDrawTextWeightSemiBold] = PANGO_WEIGHT_SEMIBOLD,
+	[uiDrawTextWeightBold] = PANGO_WEIGHT_BOLD,
+	[uiDrawTextWeightUltraBold] = PANGO_WEIGHT_ULTRABOLD,
+	[uiDrawTextWeightHeavy] = PANGO_WEIGHT_HEAVY,
+	[uiDrawTextWeightUltraHeavy] = PANGO_WEIGHT_ULTRAHEAVY,
+};
+
+static const PangoStyle pangoItalics[] = {
+	[uiDrawTextItalicNormal] = PANGO_STYLE_NORMAL,
+	[uiDrawTextItalicOblique] = PANGO_STYLE_OBLIQUE,
+	[uiDrawTextItalicItalic] = PANGO_STYLE_ITALIC,
+};
+
+static const PangoStretch pangoStretches[] = {
+	[uiDrawTextStretchUltraCondensed] = PANGO_STRETCH_ULTRA_CONDENSED,
+	[uiDrawTextStretchExtraCondensed] = PANGO_STRETCH_EXTRA_CONDENSED,
+	[uiDrawTextStretchCondensed] = PANGO_STRETCH_CONDENSED,
+	[uiDrawTextStretchSemiCondensed] = PANGO_STRETCH_SEMI_CONDENSED,
+	[uiDrawTextStretchNormal] = PANGO_STRETCH_NORMAL,
+	[uiDrawTextStretchSemiExpanded] = PANGO_STRETCH_SEMI_EXPANDED,
+	[uiDrawTextStretchExpanded] = PANGO_STRETCH_EXPANDED,
+	[uiDrawTextStretchExtraExpanded] = PANGO_STRETCH_EXTRA_EXPANDED,
+	[uiDrawTextStretchUltraExpanded] = PANGO_STRETCH_ULTRA_EXPANDED,
+};
+
+// we need a context for a few things
+// the documentation suggests creating cairo_t-specific, GdkScreen-specific, or even GtkWidget-specific contexts, but we can't really do that because we want our uiDrawTextFonts and uiDrawTextLayouts to be context-independent
+// we could use pango_font_map_create_context(pango_cairo_font_map_get_default()) but that will ignore GDK-specific settings
+// so let's use gdk_pango_context_get() instead; even though it's for the default screen only, it's good enough for us
+#define mkGenericPangoCairoContext() (gdk_pango_context_get())
+
+PangoFont *pangoDescToPangoFont(PangoFontDescription *pdesc)
+{
+	PangoFont *f;
+	PangoContext *context;
+
+	// in this case, the context is necessary for the metrics to be correct
+	context = mkGenericPangoCairoContext();
+	f = pango_font_map_load_font(pango_cairo_font_map_get_default(), context, pdesc);
+	if (f == NULL) {
+		// LONGTERM
+		g_error("[libui] no match in pangoDescToPangoFont(); report to andlabs");
+	}
+	g_object_unref(context);
+	return f;
+}
+
+uiDrawTextFont *uiDrawLoadClosestFont(const uiDrawTextFontDescriptor *desc)
+{
+	PangoFont *f;
+	PangoFontDescription *pdesc;
+
+	pdesc = pango_font_description_new();
+	pango_font_description_set_family(pdesc,
+		desc->Family);
+	pango_font_description_set_size(pdesc,
+		(gint) (desc->Size * PANGO_SCALE));
+	pango_font_description_set_weight(pdesc,
+		pangoWeights[desc->Weight]);
+	pango_font_description_set_style(pdesc,
+		pangoItalics[desc->Italic]);
+	pango_font_description_set_stretch(pdesc,
+		pangoStretches[desc->Stretch]);
+	f = pangoDescToPangoFont(pdesc);
+	pango_font_description_free(pdesc);
+	return mkTextFont(f, FALSE);			// we hold the initial reference; no need to ref
+}
+
+void uiDrawFreeTextFont(uiDrawTextFont *font)
+{
+	g_object_unref(font->f);
+	uiFree(font);
+}
+
+uintptr_t uiDrawTextFontHandle(uiDrawTextFont *font)
+{
+	return (uintptr_t) (font->f);
+}
+
+void uiDrawTextFontDescribe(uiDrawTextFont *font, uiDrawTextFontDescriptor *desc)
+{
+	PangoFontDescription *pdesc;
+
+	// this creates a copy; we free it later
+	pdesc = pango_font_describe(font->f);
+
+	// TODO
+
+	pango_font_description_free(pdesc);
+}
+
+// See https://developer.gnome.org/pango/1.30/pango-Cairo-Rendering.html#pango-Cairo-Rendering.description
+// Note that we convert to double before dividing to make sure the floating-point stuff is right
+#define pangoToCairo(pango) (((double) (pango)) / PANGO_SCALE)
+#define cairoToPango(cairo) ((gint) ((cairo) * PANGO_SCALE))
+
+void uiDrawTextFontGetMetrics(uiDrawTextFont *font, uiDrawTextFontMetrics *metrics)
+{
+	PangoFontMetrics *pm;
+
+	pm = pango_font_get_metrics(font->f, NULL);
+	metrics->Ascent = pangoToCairo(pango_font_metrics_get_ascent(pm));
+	metrics->Descent = pangoToCairo(pango_font_metrics_get_descent(pm));
+	// Pango doesn't seem to expose this :( Use 0 and hope for the best.
+	metrics->Leading = 0;
+	metrics->UnderlinePos = pangoToCairo(pango_font_metrics_get_underline_position(pm));
+	metrics->UnderlineThickness = pangoToCairo(pango_font_metrics_get_underline_thickness(pm));
+	pango_font_metrics_unref(pm);
+}
+
+// note: PangoCairoLayouts are tied to a given cairo_t, so we can't store one in this device-independent structure
+struct uiDrawTextLayout {
+	char *s;
+	ptrdiff_t *graphemes;
+	PangoFont *defaultFont;
+	double width;
+	PangoAttrList *attrs;
+};
+
+uiDrawTextLayout *uiDrawNewTextLayout(const char *text, uiDrawTextFont *defaultFont, double width)
+{
+	uiDrawTextLayout *layout;
+	PangoContext *context;
+
+	layout = uiNew(uiDrawTextLayout);
+	layout->s = g_strdup(text);
+	context = mkGenericPangoCairoContext();
+	layout->graphemes = graphemes(layout->s, context);
+	g_object_unref(context);
+	layout->defaultFont = defaultFont->f;
+	g_object_ref(layout->defaultFont);		// retain a copy
+	uiDrawTextLayoutSetWidth(layout, width);
+	layout->attrs = pango_attr_list_new();
+	return layout;
+}
+
+void uiDrawFreeTextLayout(uiDrawTextLayout *layout)
+{
+	pango_attr_list_unref(layout->attrs);
+	g_object_unref(layout->defaultFont);
+	uiFree(layout->graphemes);
+	g_free(layout->s);
+	uiFree(layout);
+}
+
+void uiDrawTextLayoutSetWidth(uiDrawTextLayout *layout, double width)
+{
+	layout->width = width;
+}
+
+static void prepareLayout(uiDrawTextLayout *layout, PangoLayout *pl)
+{
+	PangoFontDescription *desc;
+	int width;
+
+	pango_layout_set_text(pl, layout->s, -1);
+
+	// again, this makes a copy
+	desc = pango_font_describe(layout->defaultFont);
+	// this is safe; the description is copied
+	pango_layout_set_font_description(pl, desc);
+	pango_font_description_free(desc);
+
+	width = cairoToPango(layout->width);
+	if (layout->width < 0)
+		width = -1;
+	pango_layout_set_width(pl, width);
+
+	pango_layout_set_attributes(pl, layout->attrs);
+}
+
+void uiDrawTextLayoutExtents(uiDrawTextLayout *layout, double *width, double *height)
+{
+	PangoContext *context;
+	PangoLayout *pl;
+	PangoRectangle logical;
+
+	// in this case, the context is necessary to create the layout
+	// the layout takes a ref on the context so we can unref it afterward
+	context = mkGenericPangoCairoContext();
+	pl = pango_layout_new(context);
+	g_object_unref(context);
+	prepareLayout(layout, pl);
+
+	pango_layout_get_extents(pl, NULL, &logical);
+
+	g_object_unref(pl);
+
+	*width = pangoToCairo(logical.width);
+	*height = pangoToCairo(logical.height);
+}
+
+void uiDrawText(uiDrawContext *c, double x, double y, uiDrawTextLayout *layout)
+{
+	PangoLayout *pl;
+
+	pl = pango_cairo_create_layout(c->cr);
+	prepareLayout(layout, pl);
+
+	cairo_move_to(c->cr, x, y);
+	pango_cairo_show_layout(c->cr, pl);
+
+	g_object_unref(pl);
+}
+
+static void addAttr(uiDrawTextLayout *layout, PangoAttribute *attr, int startChar, int endChar)
+{
+	attr->start_index = layout->graphemes[startChar];
+	attr->end_index = layout->graphemes[endChar];
+	pango_attr_list_insert(layout->attrs, attr);
+	// pango_attr_list_insert() takes attr; we don't free it
+}
+
+void uiDrawTextLayoutSetColor(uiDrawTextLayout *layout, int startChar, int endChar, double r, double g, double b, double a)
+{
+	PangoAttribute *attr;
+	guint16 rr, gg, bb, aa;
+
+	rr = (guint16) (r * 65535);
+	gg = (guint16) (g * 65535);
+	bb = (guint16) (b * 65535);
+	aa = (guint16) (a * 65535);
+
+	attr = pango_attr_foreground_new(rr, gg, bb);
+	addAttr(layout, attr, startChar, endChar);
+
+	// TODO what if aa == 0?
+	attr = FUTURE_pango_attr_foreground_alpha_new(aa);
+	if (attr != NULL)
+		addAttr(layout, attr, startChar, endChar);
+}
diff --git a/src/libui_sdl/libui/unix/editablecombo.c b/src/libui_sdl/libui/unix/editablecombo.c
new file mode 100644
index 0000000..7ee3829
--- /dev/null
+++ b/src/libui_sdl/libui/unix/editablecombo.c
@@ -0,0 +1,79 @@
+// 11 june 2015
+#include "uipriv_unix.h"
+
+struct uiEditableCombobox {
+	uiUnixControl c;
+	GtkWidget *widget;
+	GtkBin *bin;
+	GtkComboBox *combobox;
+	GtkComboBoxText *comboboxText;
+	void (*onChanged)(uiEditableCombobox *, void *);
+	void *onChangedData;
+	gulong onChangedSignal;
+};
+
+uiUnixControlAllDefaults(uiEditableCombobox)
+
+static void onChanged(GtkComboBox *cbox, gpointer data)
+{
+	uiEditableCombobox *c = uiEditableCombobox(data);
+
+	(*(c->onChanged))(c, c->onChangedData);
+}
+
+static void defaultOnChanged(uiEditableCombobox *c, void *data)
+{
+	// do nothing
+}
+
+void uiEditableComboboxAppend(uiEditableCombobox *c, const char *text)
+{
+	gtk_combo_box_text_append(c->comboboxText, NULL, text);
+}
+
+char *uiEditableComboboxText(uiEditableCombobox *c)
+{
+	char *s;
+	char *out;
+
+	s = gtk_combo_box_text_get_active_text(c->comboboxText);
+	// s will always be non-NULL in the case of a combobox with an entry (according to the source code)
+	out = uiUnixStrdupText(s);
+	g_free(s);
+	return out;
+}
+
+void uiEditableComboboxSetText(uiEditableCombobox *c, const char *text)
+{
+	GtkEntry *e;
+
+	// we need to inhibit sending of ::changed because this WILL send a ::changed otherwise
+	g_signal_handler_block(c->combobox, c->onChangedSignal);
+	// since there isn't a gtk_combo_box_text_set_active_text()...
+	e = GTK_ENTRY(gtk_bin_get_child(c->bin));
+	gtk_entry_set_text(e, text);
+	g_signal_handler_unblock(c->combobox, c->onChangedSignal);
+}
+
+void uiEditableComboboxOnChanged(uiEditableCombobox *c, void (*f)(uiEditableCombobox *c, void *data), void *data)
+{
+	c->onChanged = f;
+	c->onChangedData = data;
+}
+
+uiEditableCombobox *uiNewEditableCombobox(void)
+{
+	uiEditableCombobox *c;
+
+	uiUnixNewControl(uiEditableCombobox, c);
+
+	c->widget = gtk_combo_box_text_new_with_entry();
+	c->bin = GTK_BIN(c->widget);
+	c->combobox = GTK_COMBO_BOX(c->widget);
+	c->comboboxText = GTK_COMBO_BOX_TEXT(c->widget);
+
+	c->onChangedSignal = g_signal_connect(c->widget, "changed", G_CALLBACK(onChanged), c);
+	uiEditableComboboxOnChanged(c, defaultOnChanged, NULL);
+
+	return c;
+}
diff --git a/src/libui_sdl/libui/unix/entry.c b/src/libui_sdl/libui/unix/entry.c
new file mode 100644
index 0000000..4a9a1d0
--- /dev/null
+++ b/src/libui_sdl/libui/unix/entry.c
@@ -0,0 +1,97 @@
+// 11 june 2015
+#include "uipriv_unix.h"
+
+struct uiEntry {
+	uiUnixControl c;
+	GtkWidget *widget;
+	GtkEntry *entry;
+	GtkEditable *editable;
+	void (*onChanged)(uiEntry *, void *);
+	void *onChangedData;
+	gulong onChangedSignal;
+};
+
+uiUnixControlAllDefaults(uiEntry)
+
+static void onChanged(GtkEditable *editable, gpointer data)
+{
+	uiEntry *e = uiEntry(data);
+
+	(*(e->onChanged))(e, e->onChangedData);
+}
+
+static void defaultOnChanged(uiEntry *e, void *data)
+{
+	// do nothing
+}
+
+char *uiEntryText(uiEntry *e)
+{
+	return uiUnixStrdupText(gtk_entry_get_text(e->entry));
+}
+
+void uiEntrySetText(uiEntry *e, const char *text)
+{
+	// we need to inhibit sending of ::changed because this WILL send a ::changed otherwise
+	g_signal_handler_block(e->editable, e->onChangedSignal);
+	gtk_entry_set_text(e->entry, text);
+	g_signal_handler_unblock(e->editable, e->onChangedSignal);
+	// don't queue the control for resize; entry sizes are independent of their contents
+}
+
+void uiEntryOnChanged(uiEntry *e, void (*f)(uiEntry *, void *), void *data)
+{
+	e->onChanged = f;
+	e->onChangedData = data;
+}
+
+int uiEntryReadOnly(uiEntry *e)
+{
+	return gtk_editable_get_editable(e->editable) == FALSE;
+}
+
+void uiEntrySetReadOnly(uiEntry *e, int readonly)
+{
+	gboolean editable;
+
+	editable = TRUE;
+	if (readonly)
+		editable = FALSE;
+	gtk_editable_set_editable(e->editable, editable);
+}
+
+static uiEntry *finishNewEntry(GtkWidget *w, const gchar *signal)
+{
+	uiEntry *e;
+
+	uiUnixNewControl(uiEntry, e);
+
+	e->widget = w;
+	e->entry = GTK_ENTRY(e->widget);
+	e->editable = GTK_EDITABLE(e->widget);
+
+	e->onChangedSignal = g_signal_connect(e->widget, signal, G_CALLBACK(onChanged), e);
+	uiEntryOnChanged(e, defaultOnChanged, NULL);
+
+	return e;
+}
+
+uiEntry *uiNewEntry(void)
+{
+	return finishNewEntry(gtk_entry_new(), "changed");
+}
+
+uiEntry *uiNewPasswordEntry(void)
+{
+	GtkWidget *e;
+
+	e = gtk_entry_new();
+	gtk_entry_set_visibility(GTK_ENTRY(e), FALSE);
+	return finishNewEntry(e, "changed");
+}
+
+// TODO make it use a separate function to be type-safe
+uiEntry *uiNewSearchEntry(void)
+{
+	return finishNewEntry(gtk_search_entry_new(), "search-changed");
+}
diff --git a/src/libui_sdl/libui/unix/fontbutton.c b/src/libui_sdl/libui/unix/fontbutton.c
new file mode 100644
index 0000000..f8047e0
--- /dev/null
+++ b/src/libui_sdl/libui/unix/fontbutton.c
@@ -0,0 +1,70 @@
+// 14 april 2016
+#include "uipriv_unix.h"
+
+struct uiFontButton {
+	uiUnixControl c;
+	GtkWidget *widget;
+	GtkButton *button;
+	GtkFontButton *fb;
+	GtkFontChooser *fc;
+	void (*onChanged)(uiFontButton *, void *);
+	void *onChangedData;
+};
+
+uiUnixControlAllDefaults(uiFontButton)
+
+// TODO NOTE no need to inhibit the signal; font-set is documented as only being sent when the user changes the font
+static void onFontSet(GtkFontButton *button, gpointer data)
+{
+	uiFontButton *b = uiFontButton(data);
+
+	(*(b->onChanged))(b, b->onChangedData);
+}
+
+static void defaultOnChanged(uiFontButton *b, void *data)
+{
+	// do nothing
+}
+
+uiDrawTextFont *uiFontButtonFont(uiFontButton *b)
+{
+	PangoFont *f;
+	PangoFontDescription *desc;
+
+	desc = gtk_font_chooser_get_font_desc(b->fc);
+	f = pangoDescToPangoFont(desc);
+	// desc is transfer-full and thus is a copy
+	pango_font_description_free(desc);
+	return mkTextFont(f, FALSE);			// we hold the initial reference; no need to ref
+}
+
+void uiFontButtonOnChanged(uiFontButton *b, void (*f)(uiFontButton *, void *), void *data)
+{
+	b->onChanged = f;
+	b->onChangedData = data;
+}
+
+uiFontButton *uiNewFontButton(void)
+{
+	uiFontButton *b;
+
+	uiUnixNewControl(uiFontButton, b);
+
+	b->widget = gtk_font_button_new();
+	b->button = GTK_BUTTON(b->widget);
+	b->fb = GTK_FONT_BUTTON(b->widget);
+	b->fc = GTK_FONT_CHOOSER(b->widget);
+
+	// match behavior on other platforms
+	gtk_font_button_set_show_style(b->fb, TRUE);
+	gtk_font_button_set_show_size(b->fb, TRUE);
+	gtk_font_button_set_use_font(b->fb, FALSE);
+	gtk_font_button_set_use_size(b->fb, FALSE);
+	// other customizations
+	gtk_font_chooser_set_show_preview_entry(b->fc, TRUE);
+
+	g_signal_connect(b->widget, "font-set", G_CALLBACK(onFontSet), b);
+	uiFontButtonOnChanged(b, defaultOnChanged, NULL);
+
+	return b;
+}
diff --git a/src/libui_sdl/libui/unix/form.c b/src/libui_sdl/libui/unix/form.c
new file mode 100644
index 0000000..54422b3
--- /dev/null
+++ b/src/libui_sdl/libui/unix/form.c
@@ -0,0 +1,159 @@
+// 8 june 2016
+#include "uipriv_unix.h"
+
+struct formChild {
+	uiControl *c;
+	int stretchy;
+	GtkWidget *label;
+	gboolean oldhexpand;
+	GtkAlign oldhalign;
+	gboolean oldvexpand;
+	GtkAlign oldvalign;
+	GBinding *labelBinding;
+};
+
+struct uiForm {
+	uiUnixControl c;
+	GtkWidget *widget;
+	GtkContainer *container;
+	GtkGrid *grid;
+	GArray *children;
+	int padded;
+	GtkSizeGroup *stretchygroup;		// ensures all stretchy controls have the same size
+};
+
+uiUnixControlAllDefaultsExceptDestroy(uiForm)
+
+#define ctrl(f, i) &g_array_index(f->children, struct formChild, i)
+
+static void uiFormDestroy(uiControl *c)
+{
+	uiForm *f = uiForm(c);
+	struct formChild *fc;
+	guint i;
+
+	// kill the size group
+	g_object_unref(f->stretchygroup);
+	// free all controls
+	for (i = 0; i < f->children->len; i++) {
+		fc = ctrl(f, i);
+		uiControlSetParent(fc->c, NULL);
+		uiUnixControlSetContainer(uiUnixControl(fc->c), f->container, TRUE);
+		uiControlDestroy(fc->c);
+		gtk_widget_destroy(fc->label);
+	}
+	g_array_free(f->children, TRUE);
+	// and then ourselves
+	g_object_unref(f->widget);
+	uiFreeControl(uiControl(f));
+}
+
+void uiFormAppend(uiForm *f, const char *label, uiControl *c, int stretchy)
+{
+	struct formChild fc;
+	GtkWidget *widget;
+	guint row;
+
+	fc.c = c;
+	widget = GTK_WIDGET(uiControlHandle(fc.c));
+	fc.stretchy = stretchy;
+	fc.oldhexpand = gtk_widget_get_hexpand(widget);
+	fc.oldhalign = gtk_widget_get_halign(widget);
+	fc.oldvexpand = gtk_widget_get_vexpand(widget);
+	fc.oldvalign = gtk_widget_get_valign(widget);
+
+	if (stretchy) {
+		gtk_widget_set_vexpand(widget, TRUE);
+		gtk_widget_set_valign(widget, GTK_ALIGN_FILL);
+		gtk_size_group_add_widget(f->stretchygroup, widget);
+	} else
+		gtk_widget_set_vexpand(widget, FALSE);
+	// and make them fill horizontally
+	gtk_widget_set_hexpand(widget, TRUE);
+	gtk_widget_set_halign(widget, GTK_ALIGN_FILL);
+
+	fc.label = gtk_label_new(label);
+	gtk_widget_set_hexpand(fc.label, FALSE);
+	gtk_widget_set_halign(fc.label, GTK_ALIGN_END);
+	gtk_widget_set_vexpand(fc.label, FALSE);
+	if (GTK_IS_SCROLLED_WINDOW(widget))
+		gtk_widget_set_valign(fc.label, GTK_ALIGN_START);
+	else
+		gtk_widget_set_valign(fc.label, GTK_ALIGN_CENTER);
+	gtk_style_context_add_class(gtk_widget_get_style_context(fc.label), "dim-label");
+	row = f->children->len;
+	gtk_grid_attach(f->grid, fc.label,
+		0, row,
+		1, 1);
+	// and make them share visibility so if the control is hidden, so is its label
+	fc.labelBinding = g_object_bind_property(GTK_WIDGET(uiControlHandle(fc.c)), "visible",
+		fc.label, "visible",
+		G_BINDING_SYNC_CREATE);
+
+	uiControlSetParent(fc.c, uiControl(f));
+	uiUnixControlSetContainer(uiUnixControl(fc.c), f->container, FALSE);
+	g_array_append_val(f->children, fc);
+
+	// move the widget to the correct place
+	gtk_container_child_set(f->container, widget,
+		"left-attach", 1,
+		"top-attach", row,
+		NULL);
+}
+
+void uiFormDelete(uiForm *f, int index)
+{
+	struct formChild *fc;
+	GtkWidget *widget;
+
+	fc = ctrl(f, index);
+	widget = GTK_WIDGET(uiControlHandle(fc->c));
+
+	gtk_widget_destroy(fc->label);
+
+	uiControlSetParent(fc->c, NULL);
+	uiUnixControlSetContainer(uiUnixControl(fc->c), f->container, TRUE);
+
+	if (fc->stretchy)
+		gtk_size_group_remove_widget(f->stretchygroup, widget);
+	gtk_widget_set_hexpand(widget, fc->oldhexpand);
+	gtk_widget_set_halign(widget, fc->oldhalign);
+	gtk_widget_set_vexpand(widget, fc->oldvexpand);
+	gtk_widget_set_valign(widget, fc->oldvalign);
+
+	g_array_remove_index(f->children, index);
+}
+
+int uiFormPadded(uiForm *f)
+{
+	return f->padded;
+}
+
+void uiFormSetPadded(uiForm *f, int padded)
+{
+	f->padded = padded;
+	if (f->padded) {
+		gtk_grid_set_row_spacing(f->grid, gtkYPadding);
+		gtk_grid_set_column_spacing(f->grid, gtkXPadding);
+	} else {
+		gtk_grid_set_row_spacing(f->grid, 0);
+		gtk_grid_set_column_spacing(f->grid, 0);
+	}
+}
+
+uiForm *uiNewForm(void)
+{
+	uiForm *f;
+
+	uiUnixNewControl(uiForm, f);
+
+	f->widget = gtk_grid_new();
+	f->container = GTK_CONTAINER(f->widget);
+	f->grid = GTK_GRID(f->widget);
+
+	f->stretchygroup = gtk_size_group_new(GTK_SIZE_GROUP_VERTICAL);
+
+	f->children = g_array_new(FALSE, TRUE, sizeof (struct formChild));
+
+	return f;
+}
diff --git a/src/libui_sdl/libui/unix/future.c b/src/libui_sdl/libui/unix/future.c
new file mode 100644
index 0000000..1f9f532
--- /dev/null
+++ b/src/libui_sdl/libui/unix/future.c
@@ -0,0 +1,42 @@
+// 29 june 2016
+#include "uipriv_unix.h"
+
+// functions FROM THE FUTURE!
+// in some cases, because being held back by LTS releases sucks :/
+// in others, because parts of GTK+ being unstable until recently also sucks :/
+
+// added in pango 1.38; we need 1.36
+static PangoAttribute *(*newFGAlphaAttr)(guint16 alpha) = NULL;
+
+// added in GTK+ 3.20; we need 3.10
+static void (*gwpIterSetObjectName)(GtkWidgetPath *path, gint pos, const char *name) = NULL;
+
+// note that we treat any error as "the symbols aren't there" (and don't care if dlclose() failed)
+void loadFutures(void)
+{
+	void *handle;
+
+	// dlsym() walks the dependency chain, so opening the current process should be sufficient
+	handle = dlopen(NULL, RTLD_LAZY);
+	if (handle == NULL)
+		return;
+#define GET(var, fn) *((void **) (&var)) = dlsym(handle, #fn)
+	GET(newFGAlphaAttr, pango_attr_foreground_alpha_new);
+	GET(gwpIterSetObjectName, gtk_widget_path_iter_set_object_name);
+	dlclose(handle);
+}
+
+PangoAttribute *FUTURE_pango_attr_foreground_alpha_new(guint16 alpha)
+{
+	if (newFGAlphaAttr == NULL)
+		return NULL;
+	return (*newFGAlphaAttr)(alpha);
+}
+
+gboolean FUTURE_gtk_widget_path_iter_set_object_name(GtkWidgetPath *path, gint pos, const char *name)
+{
+	if (gwpIterSetObjectName == NULL)
+		return FALSE;
+	(*gwpIterSetObjectName)(path, pos, name);
+	return TRUE;
+}
diff --git a/src/libui_sdl/libui/unix/graphemes.c b/src/libui_sdl/libui/unix/graphemes.c
new file mode 100644
index 0000000..a2c47b7
--- /dev/null
+++ b/src/libui_sdl/libui/unix/graphemes.c
@@ -0,0 +1,31 @@
+// 25 may 2016
+#include "uipriv_unix.h"
+
+ptrdiff_t *graphemes(const char *text, PangoContext *context)
+{
+	size_t len, lenchars;
+	PangoLogAttr *logattrs;
+	ptrdiff_t *out;
+	ptrdiff_t *op;
+	size_t i;
+
+	len = strlen(text);
+	lenchars = g_utf8_strlen(text, -1);
+	logattrs = (PangoLogAttr *) uiAlloc((lenchars + 1) * sizeof (PangoLogAttr), "PangoLogAttr[]");
+	pango_get_log_attrs(text, len,
+		-1, NULL,
+		logattrs, lenchars + 1);
+
+	// should be more than enough
+	out = (ptrdiff_t *) uiAlloc((lenchars + 2) * sizeof (ptrdiff_t), "ptrdiff_t[]");
+	op = out;
+	for (i = 0; i < lenchars; i++)
+		if (logattrs[i].is_cursor_position != 0)
+			// TODO optimize this
+			*op++ = g_utf8_offset_to_pointer(text, i) - text;
+	// and do the last one
+	*op++ = len;
+
+	uiFree(logattrs);
+	return out;
+}
diff --git a/src/libui_sdl/libui/unix/grid.c b/src/libui_sdl/libui/unix/grid.c
new file mode 100644
index 0000000..6d9813b
--- /dev/null
+++ b/src/libui_sdl/libui/unix/grid.c
@@ -0,0 +1,141 @@
+// 9 june 2016
+#include "uipriv_unix.h"
+
+struct gridChild {
+	uiControl *c;
+	GtkWidget *label;
+	gboolean oldhexpand;
+	GtkAlign oldhalign;
+	gboolean oldvexpand;
+	GtkAlign oldvalign;
+};
+
+struct uiGrid {
+	uiUnixControl c;
+	GtkWidget *widget;
+	GtkContainer *container;
+	GtkGrid *grid;
+	GArray *children;
+	int padded;
+};
+
+uiUnixControlAllDefaultsExceptDestroy(uiGrid)
+
+#define ctrl(g, i) &g_array_index(g->children, struct gridChild, i)
+
+static void uiGridDestroy(uiControl *c)
+{
+	uiGrid *g = uiGrid(c);
+	struct gridChild *gc;
+	guint i;
+
+	// free all controls
+	for (i = 0; i < g->children->len; i++) {
+		gc = ctrl(g, i);
+		uiControlSetParent(gc->c, NULL);
+		uiUnixControlSetContainer(uiUnixControl(gc->c), g->container, TRUE);
+		uiControlDestroy(gc->c);
+	}
+	g_array_free(g->children, TRUE);
+	// and then ourselves
+	g_object_unref(g->widget);
+	uiFreeControl(uiControl(g));
+}
+
+#define TODO_MASSIVE_HACK(c) \
+	if (!uiUnixControl(c)->addedBefore) { \
+		g_object_ref_sink(GTK_WIDGET(uiControlHandle(uiControl(c)))); \
+		gtk_widget_show(GTK_WIDGET(uiControlHandle(uiControl(c)))); \
+		uiUnixControl(c)->addedBefore = TRUE; \
+	}
+
+static const GtkAlign gtkAligns[] = {
+	[uiAlignFill] = GTK_ALIGN_FILL,
+	[uiAlignStart] = GTK_ALIGN_START,
+	[uiAlignCenter] = GTK_ALIGN_CENTER,
+	[uiAlignEnd] = GTK_ALIGN_END,
+};
+
+static const GtkPositionType gtkPositions[] = {
+	[uiAtLeading] = GTK_POS_LEFT,
+	[uiAtTop] = GTK_POS_TOP,
+	[uiAtTrailing] = GTK_POS_RIGHT,
+	[uiAtBottom] = GTK_POS_BOTTOM,
+};
+
+static GtkWidget *prepare(struct gridChild *gc, uiControl *c, int hexpand, uiAlign halign, int vexpand, uiAlign valign)
+{
+	GtkWidget *widget;
+
+	gc->c = c;
+	widget = GTK_WIDGET(uiControlHandle(gc->c));
+	gc->oldhexpand = gtk_widget_get_hexpand(widget);
+	gc->oldhalign = gtk_widget_get_halign(widget);
+	gc->oldvexpand = gtk_widget_get_vexpand(widget);
+	gc->oldvalign = gtk_widget_get_valign(widget);
+	gtk_widget_set_hexpand(widget, hexpand != 0);
+	gtk_widget_set_halign(widget, gtkAligns[halign]);
+	gtk_widget_set_vexpand(widget, vexpand != 0);
+	gtk_widget_set_valign(widget, gtkAligns[valign]);
+	return widget;
+}
+
+void uiGridAppend(uiGrid *g, uiControl *c, int left, int top, int xspan, int yspan, int hexpand, uiAlign halign, int vexpand, uiAlign valign)
+{
+	struct gridChild gc;
+	GtkWidget *widget;
+
+	widget = prepare(&gc, c, hexpand, halign, vexpand, valign);
+	uiControlSetParent(gc.c, uiControl(g));
+	TODO_MASSIVE_HACK(uiUnixControl(gc.c));
+	gtk_grid_attach(g->grid, widget,
+		left, top,
+		xspan, yspan);
+	g_array_append_val(g->children, gc);
+}
+
+void uiGridInsertAt(uiGrid *g, uiControl *c, uiControl *existing, uiAt at, int xspan, int yspan, int hexpand, uiAlign halign, int vexpand, uiAlign valign)
+{
+	struct gridChild gc;
+	GtkWidget *widget;
+
+	widget = prepare(&gc, c, hexpand, halign, vexpand, valign);
+	uiControlSetParent(gc.c, uiControl(g));
+	TODO_MASSIVE_HACK(uiUnixControl(gc.c));
+	gtk_grid_attach_next_to(g->grid, widget,
+		GTK_WIDGET(uiControlHandle(existing)), gtkPositions[at],
+		xspan, yspan);
+	g_array_append_val(g->children, gc);
+}
+
+int uiGridPadded(uiGrid *g)
+{
+	return g->padded;
+}
+
+void uiGridSetPadded(uiGrid *g, int padded)
+{
+	g->padded = padded;
+	if (g->padded) {
+		gtk_grid_set_row_spacing(g->grid, gtkYPadding);
+		gtk_grid_set_column_spacing(g->grid, gtkXPadding);
+	} else {
+		gtk_grid_set_row_spacing(g->grid, 0);
+		gtk_grid_set_column_spacing(g->grid, 0);
+	}
+}
+
+uiGrid *uiNewGrid(void)
+{
+	uiGrid *g;
+
+	uiUnixNewControl(uiGrid, g);
+
+	g->widget = gtk_grid_new();
+	g->container = GTK_CONTAINER(g->widget);
+	g->grid = GTK_GRID(g->widget);
+
+	g->children = g_array_new(FALSE, TRUE, sizeof (struct gridChild));
+
+	return g;
+}
diff --git a/src/libui_sdl/libui/unix/group.c b/src/libui_sdl/libui/unix/group.c
new file mode 100644
index 0000000..6238a1b
--- /dev/null
+++ b/src/libui_sdl/libui/unix/group.c
@@ -0,0 +1,89 @@
+// 11 june 2015
+#include "uipriv_unix.h"
+
+struct uiGroup {
+	uiUnixControl c;
+	GtkWidget *widget;
+	GtkContainer *container;
+	GtkBin *bin;
+	GtkFrame *frame;
+
+	// unfortunately, even though a GtkFrame is a GtkBin, calling gtk_container_set_border_width() on it /includes/ the GtkFrame's label; we don't want tht
+	struct child *child;
+
+	int margined;
+};
+
+uiUnixControlAllDefaultsExceptDestroy(uiGroup)
+
+static void uiGroupDestroy(uiControl *c)
+{
+	uiGroup *g = uiGroup(c);
+
+	if (g->child != NULL)
+		childDestroy(g->child);
+	g_object_unref(g->widget);
+	uiFreeControl(uiControl(g));
+}
+
+char *uiGroupTitle(uiGroup *g)
+{
+	return uiUnixStrdupText(gtk_frame_get_label(g->frame));
+}
+
+void uiGroupSetTitle(uiGroup *g, const char *text)
+{
+	gtk_frame_set_label(g->frame, text);
+}
+
+void uiGroupSetChild(uiGroup *g, uiControl *child)
+{
+	if (g->child != NULL)
+		childRemove(g->child);
+	g->child = newChildWithBox(child, uiControl(g), g->container, g->margined);
+}
+
+int uiGroupMargined(uiGroup *g)
+{
+	return g->margined;
+}
+
+void uiGroupSetMargined(uiGroup *g, int margined)
+{
+	g->margined = margined;
+	if (g->child != NULL)
+		childSetMargined(g->child, g->margined);
+}
+
+uiGroup *uiNewGroup(const char *text)
+{
+	uiGroup *g;
+	gfloat yalign;
+	GtkLabel *label;
+	PangoAttribute *bold;
+	PangoAttrList *boldlist;
+
+	uiUnixNewControl(uiGroup, g);
+
+	g->widget = gtk_frame_new(text);
+	g->container = GTK_CONTAINER(g->widget);
+	g->bin = GTK_BIN(g->widget);
+	g->frame = GTK_FRAME(g->widget);
+
+	// with GTK+, groupboxes by default have frames and slightly x-offset regular text
+	// they should have no frame and fully left-justified, bold text
+	// preserve default y-alignment
+	gtk_frame_get_label_align(g->frame, NULL, &yalign);
+	gtk_frame_set_label_align(g->frame, 0, yalign);
+	gtk_frame_set_shadow_type(g->frame, GTK_SHADOW_NONE);
+	label = GTK_LABEL(gtk_frame_get_label_widget(g->frame));
+	// this is the boldness level used by GtkPrintUnixDialog
+	// (it technically uses "bold" but see pango's pango-enum-types.c for the name conversion; GType is weird)
+	bold = pango_attr_weight_new(PANGO_WEIGHT_BOLD);
+	boldlist = pango_attr_list_new();
+	pango_attr_list_insert(boldlist, bold);
+	gtk_label_set_attributes(label, boldlist);
+	pango_attr_list_unref(boldlist);		// thanks baedert in irc.gimp.net/#gtk+
+
+	return g;
+}
diff --git a/src/libui_sdl/libui/unix/image.c b/src/libui_sdl/libui/unix/image.c
new file mode 100644
index 0000000..a79e550
--- /dev/null
+++ b/src/libui_sdl/libui/unix/image.c
@@ -0,0 +1,120 @@
+// 27 june 2016
+#include "uipriv_unix.h"
+
+struct uiImage {
+	double width;
+	double height;
+	GPtrArray *images;
+};
+
+static void freeImageRep(gpointer item)
+{
+	cairo_surface_t *cs = (cairo_surface_t *) item;
+	unsigned char *buf;
+
+	buf = cairo_image_surface_get_data(cs);
+	cairo_surface_destroy(cs);
+	uiFree(buf);
+}
+
+uiImage *uiNewImage(double width, double height)
+{
+	uiImage *i;
+
+	i = uiNew(uiImage);
+	i->width = width;
+	i->height = height;
+	i->images = g_ptr_array_new_with_free_func(freeImageRep);
+	return i;
+}
+
+void uiFreeImage(uiImage *i)
+{
+	g_ptr_array_free(i->images, TRUE);
+	uiFree(i);
+}
+
+void uiImageAppend(uiImage *i, void *pixels, int pixelWidth, int pixelHeight, int pixelStride)
+{
+	cairo_surface_t *cs;
+	unsigned char *buf, *p;
+	uint8_t *src = (uint8_t *) pixels;
+	int cstride;
+	int y;
+
+	cstride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, pixelWidth);
+	buf = (unsigned char *) uiAlloc((cstride * pixelHeight * 4) * sizeof (unsigned char), "unsigned char[]");
+	p = buf;
+	for (y = 0; y < pixelStride * pixelHeight; y += pixelStride) {
+		memmove(p, src + y, cstride);
+		p += cstride;
+	}
+	cs = cairo_image_surface_create_for_data(buf, CAIRO_FORMAT_ARGB32,
+		pixelWidth, pixelHeight,
+		cstride);
+	if (cairo_surface_status(cs) != CAIRO_STATUS_SUCCESS)
+		/* TODO */;
+	cairo_surface_flush(cs);
+	g_ptr_array_add(i->images, cs);
+}
+
+struct matcher {
+	cairo_surface_t *best;
+	int distX;
+	int distY;
+	int targetX;
+	int targetY;
+	gboolean foundLarger;
+};
+
+// TODO is this the right algorithm?
+static void match(gpointer surface, gpointer data)
+{
+	cairo_surface_t *cs = (cairo_surface_t *) surface;
+	struct matcher *m = (struct matcher *) data;
+	int x, y;
+	int x2, y2;
+
+	x = cairo_image_surface_get_width(cs);
+	y = cairo_image_surface_get_height(cs);
+	if (m->best == NULL)
+		goto writeMatch;
+
+	if (x < m->targetX && y < m->targetY)
+		if (m->foundLarger)
+			// always prefer larger ones
+			return;
+	if (x >= m->targetX && y >= m->targetY && !m->foundLarger)
+		// we set foundLarger below
+		goto writeMatch;
+
+	x2 = abs(m->targetX - x);
+	y2 = abs(m->targetY - y);
+	if (x2 < m->distX && y2 < m->distY)
+		goto writeMatch;
+
+	// TODO weight one dimension? threshhold?
+	return;
+
+writeMatch:
+	// must set this here too; otherwise the first image will never have ths set
+	if (x >= m->targetX && y >= m->targetY && !m->foundLarger)
+		m->foundLarger = TRUE;
+	m->best = cs;
+	m->distX = abs(m->targetX - x);
+	m->distY = abs(m->targetY - y);
+}
+
+cairo_surface_t *imageAppropriateSurface(uiImage *i, GtkWidget *w)
+{
+	struct matcher m;
+
+	m.best = NULL;
+	m.distX = G_MAXINT;
+	m.distY = G_MAXINT;
+	m.targetX = i->width * gtk_widget_get_scale_factor(w);
+	m.targetY = i->height * gtk_widget_get_scale_factor(w);
+	m.foundLarger = FALSE;
+	g_ptr_array_foreach(i->images, match, &m);
+	return m.best;
+}
diff --git a/src/libui_sdl/libui/unix/label.c b/src/libui_sdl/libui/unix/label.c
new file mode 100644
index 0000000..b39fc7c
--- /dev/null
+++ b/src/libui_sdl/libui/unix/label.c
@@ -0,0 +1,36 @@
+// 11 june 2015
+#include "uipriv_unix.h"
+
+struct uiLabel {
+	uiUnixControl c;
+	GtkWidget *widget;
+	GtkMisc *misc;
+	GtkLabel *label;
+};
+
+uiUnixControlAllDefaults(uiLabel)
+
+char *uiLabelText(uiLabel *l)
+{
+	return uiUnixStrdupText(gtk_label_get_text(l->label));
+}
+
+void uiLabelSetText(uiLabel *l, const char *text)
+{
+	gtk_label_set_text(l->label, text);
+}
+
+uiLabel *uiNewLabel(const char *text)
+{
+	uiLabel *l;
+
+	uiUnixNewControl(uiLabel, l);
+
+	l->widget = gtk_label_new(text);
+	l->misc = GTK_MISC(l->widget);
+	l->label = GTK_LABEL(l->widget);
+
+	gtk_misc_set_alignment(l->misc, 0, 0);
+
+	return l;
+}
diff --git a/src/libui_sdl/libui/unix/main.c b/src/libui_sdl/libui/unix/main.c
new file mode 100644
index 0000000..2998bf3
--- /dev/null
+++ b/src/libui_sdl/libui/unix/main.c
@@ -0,0 +1,108 @@
+// 6 april 2015
+#include "uipriv_unix.h"
+
+uiInitOptions options;
+
+const char *uiInit(uiInitOptions *o)
+{
+	GError *err = NULL;
+	const char *msg;
+
+	options = *o;
+	if (gtk_init_with_args(NULL, NULL, NULL, NULL, NULL, &err) == FALSE) {
+		msg = g_strdup(err->message);
+		g_error_free(err);
+		return msg;
+	}
+	initAlloc();
+	loadFutures();
+	return NULL;
+}
+
+void uiUninit(void)
+{
+	uninitMenus();
+	uninitAlloc();
+}
+
+void uiFreeInitError(const char *err)
+{
+	g_free((gpointer) err);
+}
+
+static gboolean (*iteration)(gboolean) = NULL;
+
+void uiMain(void)
+{
+	iteration = gtk_main_iteration_do;
+	gtk_main();
+}
+
+static gboolean stepsQuit = FALSE;
+
+// the only difference is we ignore the return value from gtk_main_iteration_do(), since it will always be TRUE if gtk_main() was never called
+// gtk_main_iteration_do() will still run the main loop regardless
+static gboolean stepsIteration(gboolean block)
+{
+	gtk_main_iteration_do(block);
+	return stepsQuit;
+}
+
+void uiMainSteps(void)
+{
+	iteration = stepsIteration;
+}
+
+int uiMainStep(int wait)
+{
+	gboolean block;
+
+	block = FALSE;
+	if (wait)
+		block = TRUE;
+	return (*iteration)(block) == FALSE;
+}
+
+// gtk_main_quit() may run immediately, or it may wait for other pending events; "it depends" (thanks mclasen in irc.gimp.net/#gtk+)
+// PostQuitMessage() on Windows always waits, so we must do so too
+// we'll do it by using an idle callback
+static gboolean quit(gpointer data)
+{
+	if (iteration == stepsIteration)
+		stepsQuit = TRUE;
+		// TODO run a gtk_main() here just to do the cleanup steps of syncing the clipboard and other stuff gtk_main() does before it returns
+	else
+		gtk_main_quit();
+	return FALSE;
+}
+
+void uiQuit(void)
+{
+	gdk_threads_add_idle(quit, NULL);
+}
+
+struct queued {
+	void (*f)(void *);
+	void *data;
+};
+
+static gboolean doqueued(gpointer data)
+{
+	struct queued *q = (struct queued *) data;
+
+	(*(q->f))(q->data);
+	g_free(q);
+	return FALSE;
+}
+
+void uiQueueMain(void (*f)(void *data), void *data)
+{
+	struct queued *q;
+
+	// we have to use g_new0()/g_free() because uiAlloc() is only safe to call on the main thread
+	// for some reason it didn't affect me, but it did affect krakjoe
+	q = g_new0(struct queued, 1);
+	q->f = f;
+	q->data = data;
+	gdk_threads_add_idle(doqueued, q);
+}
diff --git a/src/libui_sdl/libui/unix/menu.c b/src/libui_sdl/libui/unix/menu.c
new file mode 100644
index 0000000..5ccb4a5
--- /dev/null
+++ b/src/libui_sdl/libui/unix/menu.c
@@ -0,0 +1,366 @@
+// 23 april 2015
+#include "uipriv_unix.h"
+
+static GArray *menus = NULL;
+static gboolean menusFinalized = FALSE;
+static gboolean hasQuit = FALSE;
+static gboolean hasPreferences = FALSE;
+static gboolean hasAbout = FALSE;
+
+struct uiMenu {
+	char *name;
+	GArray *items;					// []*uiMenuItem
+};
+
+struct uiMenuItem {
+	char *name;
+	int type;
+	void (*onClicked)(uiMenuItem *, uiWindow *, void *);
+	void *onClickedData;
+	GType gtype;					// template for new instances; kept in sync with everything else
+	gboolean disabled;
+	gboolean checked;
+	GHashTable *windows;			// map[GtkMenuItem]*menuItemWindow
+};
+
+struct menuItemWindow {
+	uiWindow *w;
+	gulong signal;
+};
+
+enum {
+	typeRegular,
+	typeCheckbox,
+	typeQuit,
+	typePreferences,
+	typeAbout,
+	typeSeparator,
+};
+
+// we do NOT want programmatic updates to raise an ::activated signal
+static void singleSetChecked(GtkCheckMenuItem *menuitem, gboolean checked, gulong signal)
+{
+	g_signal_handler_block(menuitem, signal);
+	gtk_check_menu_item_set_active(menuitem, checked);
+	g_signal_handler_unblock(menuitem, signal);
+}
+
+static void setChecked(uiMenuItem *item, gboolean checked)
+{
+	GHashTableIter iter;
+	gpointer widget;
+	gpointer ww;
+	struct menuItemWindow *w;
+
+	item->checked = checked;
+	g_hash_table_iter_init(&iter, item->windows);
+	while (g_hash_table_iter_next(&iter, &widget, &ww)) {
+		w = (struct menuItemWindow *) ww;
+		singleSetChecked(GTK_CHECK_MENU_ITEM(widget), item->checked, w->signal);
+	}
+}
+
+static void onClicked(GtkMenuItem *menuitem, gpointer data)
+{
+	uiMenuItem *item = uiMenuItem(data);
+	struct menuItemWindow *w;
+
+	// we need to manually update the checked states of all menu items if one changes
+	// notice that this is getting the checked state of the menu item that this signal is sent from
+	if (item->type == typeCheckbox)
+		setChecked(item, gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menuitem)));
+
+	w = (struct menuItemWindow *) g_hash_table_lookup(item->windows, menuitem);
+	(*(item->onClicked))(item, w->w, item->onClickedData);
+}
+
+static void defaultOnClicked(uiMenuItem *item, uiWindow *w, void *data)
+{
+	// do nothing
+}
+
+static void onQuitClicked(uiMenuItem *item, uiWindow *w, void *data)
+{
+	if (shouldQuit())
+		uiQuit();
+}
+
+static void menuItemEnableDisable(uiMenuItem *item, gboolean enabled)
+{
+	GHashTableIter iter;
+	gpointer widget;
+
+	item->disabled = !enabled;
+	g_hash_table_iter_init(&iter, item->windows);
+	while (g_hash_table_iter_next(&iter, &widget, NULL))
+		gtk_widget_set_sensitive(GTK_WIDGET(widget), enabled);
+}
+
+void uiMenuItemEnable(uiMenuItem *item)
+{
+	menuItemEnableDisable(item, TRUE);
+}
+
+void uiMenuItemDisable(uiMenuItem *item)
+{
+	menuItemEnableDisable(item, FALSE);
+}
+
+void uiMenuItemOnClicked(uiMenuItem *item, void (*f)(uiMenuItem *, uiWindow *, void *), void *data)
+{
+	if (item->type == typeQuit)
+		userbug("You cannot call uiMenuItemOnClicked() on a Quit item; use uiOnShouldQuit() instead.");
+	item->onClicked = f;
+	item->onClickedData = data;
+}
+
+int uiMenuItemChecked(uiMenuItem *item)
+{
+	return item->checked != FALSE;
+}
+
+void uiMenuItemSetChecked(uiMenuItem *item, int checked)
+{
+	gboolean c;
+
+	// use explicit values
+	c = FALSE;
+	if (checked)
+		c = TRUE;
+	setChecked(item, c);
+}
+
+static uiMenuItem *newItem(uiMenu *m, int type, const char *name)
+{
+	uiMenuItem *item;
+
+	if (menusFinalized)
+		userbug("You cannot create a new menu item after menus have been finalized.");
+
+	item = uiNew(uiMenuItem);
+
+	g_array_append_val(m->items, item);
+
+	item->type = type;
+	switch (item->type) {
+	case typeQuit:
+		item->name = g_strdup("Quit");
+		break;
+	case typePreferences:
+		item->name = g_strdup("Preferences...");
+		break;
+	case typeAbout:
+		item->name = g_strdup("About");
+		break;
+	case typeSeparator:
+		break;
+	default:
+		item->name = g_strdup(name);
+		break;
+	}
+
+	if (item->type == typeQuit) {
+		// can't call uiMenuItemOnClicked() here
+		item->onClicked = onQuitClicked;
+		item->onClickedData = NULL;
+	} else
+		uiMenuItemOnClicked(item, defaultOnClicked, NULL);
+
+	switch (item->type) {
+	case typeCheckbox:
+		item->gtype = GTK_TYPE_CHECK_MENU_ITEM;
+		break;
+	case typeSeparator:
+		item->gtype = GTK_TYPE_SEPARATOR_MENU_ITEM;
+		break;
+	default:
+		item->gtype = GTK_TYPE_MENU_ITEM;
+		break;
+	}
+
+	item->windows = g_hash_table_new(g_direct_hash, g_direct_equal);
+
+	return item;
+}
+
+uiMenuItem *uiMenuAppendItem(uiMenu *m, const char *name)
+{
+	return newItem(m, typeRegular, name);
+}
+
+uiMenuItem *uiMenuAppendCheckItem(uiMenu *m, const char *name)
+{
+	return newItem(m, typeCheckbox, name);
+}
+
+uiMenuItem *uiMenuAppendQuitItem(uiMenu *m)
+{
+	if (hasQuit)
+		userbug("You cannot have multiple Quit menu items in the same program.");
+	hasQuit = TRUE;
+	newItem(m, typeSeparator, NULL);
+	return newItem(m, typeQuit, NULL);
+}
+
+uiMenuItem *uiMenuAppendPreferencesItem(uiMenu *m)
+{
+	if (hasPreferences)
+		userbug("You cannot have multiple Preferences menu items in the same program.");
+	hasPreferences = TRUE;
+	newItem(m, typeSeparator, NULL);
+	return newItem(m, typePreferences, NULL);
+}
+
+uiMenuItem *uiMenuAppendAboutItem(uiMenu *m)
+{
+	if (hasAbout)
+		userbug("You cannot have multiple About menu items in the same program.");
+	hasAbout = TRUE;
+	newItem(m, typeSeparator, NULL);
+	return newItem(m, typeAbout, NULL);
+}
+
+void uiMenuAppendSeparator(uiMenu *m)
+{
+	newItem(m, typeSeparator, NULL);
+}
+
+uiMenu *uiNewMenu(const char *name)
+{
+	uiMenu *m;
+
+	if (menusFinalized)
+		userbug("You cannot create a new menu after menus have been finalized.");
+	if (menus == NULL)
+		menus = g_array_new(FALSE, TRUE, sizeof (uiMenu *));
+
+	m = uiNew(uiMenu);
+
+	g_array_append_val(menus, m);
+
+	m->name = g_strdup(name);
+	m->items = g_array_new(FALSE, TRUE, sizeof (uiMenuItem *));
+
+	return m;
+}
+
+static void appendMenuItem(GtkMenuShell *submenu, uiMenuItem *item, uiWindow *w)
+{
+	GtkWidget *menuitem;
+	gulong signal;
+	struct menuItemWindow *ww;
+
+	menuitem = g_object_new(item->gtype, NULL);
+	if (item->name != NULL)
+		gtk_menu_item_set_label(GTK_MENU_ITEM(menuitem), item->name);
+	if (item->type != typeSeparator) {
+		signal = g_signal_connect(menuitem, "activate", G_CALLBACK(onClicked), item);
+		gtk_widget_set_sensitive(menuitem, !item->disabled);
+		if (item->type == typeCheckbox)
+			singleSetChecked(GTK_CHECK_MENU_ITEM(menuitem), item->checked, signal);
+	}
+	gtk_menu_shell_append(submenu, menuitem);
+	ww = uiNew(struct menuItemWindow);
+	ww->w = w;
+	ww->signal = signal;
+	g_hash_table_insert(item->windows, menuitem, ww);
+}
+
+GtkWidget *makeMenubar(uiWindow *w)
+{
+	GtkWidget *menubar;
+	guint i, j;
+	uiMenu *m;
+	GtkWidget *menuitem;
+	GtkWidget *submenu;
+
+	menusFinalized = TRUE;
+
+	menubar = gtk_menu_bar_new();
+
+	if (menus != NULL)
+		for (i = 0; i < menus->len; i++) {
+			m = g_array_index(menus, uiMenu *, i);
+			menuitem = gtk_menu_item_new_with_label(m->name);
+			submenu = gtk_menu_new();
+			gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu);
+			for (j = 0; j < m->items->len; j++)
+				appendMenuItem(GTK_MENU_SHELL(submenu), g_array_index(m->items, uiMenuItem *, j), w);
+			gtk_menu_shell_append(GTK_MENU_SHELL(menubar), menuitem);
+		}
+
+	gtk_widget_set_hexpand(menubar, TRUE);
+	gtk_widget_set_halign(menubar, GTK_ALIGN_FILL);
+	return menubar;
+}
+
+struct freeMenuItemData {
+	GArray *items;
+	guint i;
+};
+
+static void freeMenuItem(GtkWidget *widget, gpointer data)
+{
+	struct freeMenuItemData *fmi = (struct freeMenuItemData *) data;
+	uiMenuItem *item;
+	struct menuItemWindow *w;
+
+	item = g_array_index(fmi->items, uiMenuItem *, fmi->i);
+	w = (struct menuItemWindow *) g_hash_table_lookup(item->windows, widget);
+	if (g_hash_table_remove(item->windows, widget) == FALSE)
+		implbug("GtkMenuItem %p not in menu item's item/window map", widget);
+	uiFree(w);
+	fmi->i++;
+}
+
+static void freeMenu(GtkWidget *widget, gpointer data)
+{
+	guint *i = (guint *) data;
+	uiMenu *m;
+	GtkMenuItem *item;
+	GtkWidget *submenu;
+	struct freeMenuItemData fmi;
+
+	m = g_array_index(menus, uiMenu *, *i);
+	item = GTK_MENU_ITEM(widget);
+	submenu = gtk_menu_item_get_submenu(item);
+	fmi.items = m->items;
+	fmi.i = 0;
+	gtk_container_foreach(GTK_CONTAINER(submenu), freeMenuItem, &fmi);
+	(*i)++;
+}
+
+void freeMenubar(GtkWidget *mb)
+{
+	guint i;
+
+	i = 0;
+	gtk_container_foreach(GTK_CONTAINER(mb), freeMenu, &i);
+	// no need to worry about destroying any widgets; destruction of the window they're in will do it for us
+}
+
+void uninitMenus(void)
+{
+	uiMenu *m;
+	uiMenuItem *item;
+	guint i, j;
+
+	if (menus == NULL)
+		return;
+	for (i = 0; i < menus->len; i++) {
+		m = g_array_index(menus, uiMenu *, i);
+		g_free(m->name);
+		for (j = 0; j < m->items->len; j++) {
+			item = g_array_index(m->items, uiMenuItem *, j);
+			if (g_hash_table_size(item->windows) != 0)
+				// TODO is this really a userbug()?
+				implbug("menu item %p (%s) still has uiWindows attached; did you forget to destroy some windows?", item, item->name);
+			g_free(item->name);
+			g_hash_table_destroy(item->windows);
+			uiFree(item);
+		}
+		g_array_free(m->items, TRUE);
+		uiFree(m);
+	}
+	g_array_free(menus, TRUE);
+}
diff --git a/src/libui_sdl/libui/unix/multilineentry.c b/src/libui_sdl/libui/unix/multilineentry.c
new file mode 100644
index 0000000..09ffd46
--- /dev/null
+++ b/src/libui_sdl/libui/unix/multilineentry.c
@@ -0,0 +1,124 @@
+// 6 december 2015
+#include "uipriv_unix.h"
+
+struct uiMultilineEntry {
+	uiUnixControl c;
+	GtkWidget *widget;
+	GtkContainer *scontainer;
+	GtkScrolledWindow *sw;
+	GtkWidget *textviewWidget;
+	GtkTextView *textview;
+	GtkTextBuffer *textbuf;
+	void (*onChanged)(uiMultilineEntry *, void *);
+	void *onChangedData;
+	gulong onChangedSignal;
+};
+
+uiUnixControlAllDefaults(uiMultilineEntry)
+
+static void onChanged(GtkTextBuffer *textbuf, gpointer data)
+{
+	uiMultilineEntry *e = uiMultilineEntry(data);
+
+	(*(e->onChanged))(e, e->onChangedData);
+}
+
+static void defaultOnChanged(uiMultilineEntry *e, void *data)
+{
+	// do nothing
+}
+
+char *uiMultilineEntryText(uiMultilineEntry *e)
+{
+	GtkTextIter start, end;
+	char *tret, *out;
+
+	gtk_text_buffer_get_start_iter(e->textbuf, &start);
+	gtk_text_buffer_get_end_iter(e->textbuf, &end);
+	tret = gtk_text_buffer_get_text(e->textbuf, &start, &end, TRUE);
+	// theoretically we could just return tret because uiUnixStrdupText() is just g_strdup(), but if that ever changes we can't, so let's do it this way to be safe
+	out = uiUnixStrdupText(tret);
+	g_free(tret);
+	return out;
+}
+
+void uiMultilineEntrySetText(uiMultilineEntry *e, const char *text)
+{
+	// we need to inhibit sending of ::changed because this WILL send a ::changed otherwise
+	g_signal_handler_block(e->textbuf, e->onChangedSignal);
+	gtk_text_buffer_set_text(e->textbuf, text, -1);
+	g_signal_handler_unblock(e->textbuf, e->onChangedSignal);
+}
+
+// TODO scroll to end?
+void uiMultilineEntryAppend(uiMultilineEntry *e, const char *text)
+{
+	GtkTextIter end;
+
+	gtk_text_buffer_get_end_iter(e->textbuf, &end);
+	// we need to inhibit sending of ::changed because this WILL send a ::changed otherwise
+	g_signal_handler_block(e->textbuf, e->onChangedSignal);
+	gtk_text_buffer_insert(e->textbuf, &end, text, -1);
+	g_signal_handler_unblock(e->textbuf, e->onChangedSignal);
+}
+
+void uiMultilineEntryOnChanged(uiMultilineEntry *e, void (*f)(uiMultilineEntry *e, void *data), void *data)
+{
+	e->onChanged = f;
+	e->onChangedData = data;
+}
+
+int uiMultilineEntryReadOnly(uiMultilineEntry *e)
+{
+	return gtk_text_view_get_editable(e->textview) == FALSE;
+}
+
+void uiMultilineEntrySetReadOnly(uiMultilineEntry *e, int readonly)
+{
+	gboolean editable;
+
+	editable = TRUE;
+	if (readonly)
+		editable = FALSE;
+	gtk_text_view_set_editable(e->textview, editable);
+}
+
+static uiMultilineEntry *finishMultilineEntry(GtkPolicyType hpolicy, GtkWrapMode wrapMode)
+{
+	uiMultilineEntry *e;
+
+	uiUnixNewControl(uiMultilineEntry, e);
+
+	e->widget = gtk_scrolled_window_new(NULL, NULL);
+	e->scontainer = GTK_CONTAINER(e->widget);
+	e->sw = GTK_SCROLLED_WINDOW(e->widget);
+	gtk_scrolled_window_set_policy(e->sw,
+		hpolicy,
+		GTK_POLICY_AUTOMATIC);
+	gtk_scrolled_window_set_shadow_type(e->sw, GTK_SHADOW_IN);
+
+	e->textviewWidget = gtk_text_view_new();
+	e->textview = GTK_TEXT_VIEW(e->textviewWidget);
+	gtk_text_view_set_wrap_mode(e->textview, wrapMode);
+
+	gtk_container_add(e->scontainer, e->textviewWidget);
+	// and make the text view visible; only the scrolled window's visibility is controlled by libui
+	gtk_widget_show(e->textviewWidget);
+
+	e->textbuf = gtk_text_view_get_buffer(e->textview);
+
+	e->onChangedSignal = g_signal_connect(e->textbuf, "changed", G_CALLBACK(onChanged), e);
+	uiMultilineEntryOnChanged(e, defaultOnChanged, NULL);
+
+	return e;
+}
+
+uiMultilineEntry *uiNewMultilineEntry(void)
+{
+	return finishMultilineEntry(GTK_POLICY_NEVER, GTK_WRAP_WORD);
+}
+
+uiMultilineEntry *uiNewNonWrappingMultilineEntry(void)
+{
+	return finishMultilineEntry(GTK_POLICY_AUTOMATIC, GTK_WRAP_NONE);
+}
diff --git a/src/libui_sdl/libui/unix/progressbar.c b/src/libui_sdl/libui/unix/progressbar.c
new file mode 100644
index 0000000..9b543b0
--- /dev/null
+++ b/src/libui_sdl/libui/unix/progressbar.c
@@ -0,0 +1,71 @@
+// 11 june 2015
+#include "uipriv_unix.h"
+
+struct uiProgressBar {
+	uiUnixControl c;
+	GtkWidget *widget;
+	GtkProgressBar *pbar;
+	gboolean indeterminate;
+	guint pulser;
+};
+
+uiUnixControlAllDefaultsExceptDestroy(uiProgressBar)
+
+static void uiProgressBarDestroy(uiControl *c)
+{
+	uiProgressBar *p = uiProgressBar(c);
+
+	// be sure to stop the timeout now
+	if (p->indeterminate)
+		g_source_remove(p->pulser);
+	g_object_unref(p->widget);
+	uiFreeControl(uiControl(p));
+}
+
+int uiProgressBarValue(uiProgressBar *p)
+{
+	if (p->indeterminate)
+		return -1;
+	return (int) (gtk_progress_bar_get_fraction(p->pbar) * 100);
+}
+
+static gboolean pulse(void* data)
+{
+	uiProgressBar *p = uiProgressBar(data);
+
+	gtk_progress_bar_pulse(p->pbar);
+	return TRUE;
+}
+
+void uiProgressBarSetValue(uiProgressBar *p, int value)
+{
+	if (value == -1) {
+		if (!p->indeterminate) {
+			p->indeterminate = TRUE;
+			// TODO verify the timeout
+			p->pulser = g_timeout_add(100, pulse, p);
+		}
+		return;
+	}
+	if (p->indeterminate) {
+		p->indeterminate = FALSE;
+		g_source_remove(p->pulser);
+	}
+
+	if (value < 0 || value > 100)
+		userbug("Value %d is out of range for a uiProgressBar.", value);
+
+	gtk_progress_bar_set_fraction(p->pbar, ((gdouble) value) / 100);
+}
+
+uiProgressBar *uiNewProgressBar(void)
+{
+	uiProgressBar *p;
+
+	uiUnixNewControl(uiProgressBar, p);
+
+	p->widget = gtk_progress_bar_new();
+	p->pbar = GTK_PROGRESS_BAR(p->widget);
+
+	return p;
+}
diff --git a/src/libui_sdl/libui/unix/radiobuttons.c b/src/libui_sdl/libui/unix/radiobuttons.c
new file mode 100644
index 0000000..da41107
--- /dev/null
+++ b/src/libui_sdl/libui/unix/radiobuttons.c
@@ -0,0 +1,121 @@
+// 11 june 2015
+#include "uipriv_unix.h"
+
+// on GTK+ a uiRadioButtons is a GtkBox with each of the GtkRadioButtons as children
+
+struct uiRadioButtons {
+	uiUnixControl c;
+	GtkWidget *widget;
+	GtkContainer *container;
+	GtkBox *box;
+	GPtrArray *buttons;
+	void (*onSelected)(uiRadioButtons *, void *);
+	void *onSelectedData;
+	gboolean changing;
+};
+
+uiUnixControlAllDefaultsExceptDestroy(uiRadioButtons)
+
+static void defaultOnSelected(uiRadioButtons *r, void *data)
+{
+	// do nothing
+}
+
+static void onToggled(GtkToggleButton *tb, gpointer data)
+{
+	uiRadioButtons *r = uiRadioButtons(data);
+
+	// only care if a button is selected
+	if (!gtk_toggle_button_get_active(tb))
+		return;
+	// ignore programmatic changes
+	if (r->changing)
+		return;
+	(*(r->onSelected))(r, r->onSelectedData);
+}
+
+static void uiRadioButtonsDestroy(uiControl *c)
+{
+	uiRadioButtons *r = uiRadioButtons(c);
+	GtkWidget *b;
+
+	while (r->buttons->len != 0) {
+		b = GTK_WIDGET(g_ptr_array_remove_index(r->buttons, 0));
+		gtk_widget_destroy(b);
+	}
+	g_ptr_array_free(r->buttons, TRUE);
+	// and free ourselves
+	g_object_unref(r->widget);
+	uiFreeControl(uiControl(r));
+}
+
+void uiRadioButtonsAppend(uiRadioButtons *r, const char *text)
+{
+	GtkWidget *rb;
+	GtkRadioButton *previous;
+
+	previous = NULL;
+	if (r->buttons->len > 0)
+		previous = GTK_RADIO_BUTTON(g_ptr_array_index(r->buttons, 0));
+	rb = gtk_radio_button_new_with_label_from_widget(previous, text);
+	g_signal_connect(rb, "toggled", G_CALLBACK(onToggled), r);
+	gtk_container_add(r->container, rb);
+	g_ptr_array_add(r->buttons, rb);
+	gtk_widget_show(rb);
+}
+
+int uiRadioButtonsSelected(uiRadioButtons *r)
+{
+	GtkToggleButton *tb;
+	guint i;
+
+	for (i = 0; i < r->buttons->len; i++) {
+		tb = GTK_TOGGLE_BUTTON(g_ptr_array_index(r->buttons, i));
+		if (gtk_toggle_button_get_active(tb))
+			return i;
+	}
+	return -1;
+}
+
+void uiRadioButtonsSetSelected(uiRadioButtons *r, int n)
+{
+	GtkToggleButton *tb;
+	gboolean active;
+
+	active = TRUE;
+	// TODO this doesn't work
+	if (n == -1) {
+		n = uiRadioButtonsSelected(r);
+		if (n == -1)		// no selection; keep it that way
+			return;
+		active = FALSE;
+	}
+	tb = GTK_TOGGLE_BUTTON(g_ptr_array_index(r->buttons, n));
+	// this is easier than remembering all the signals
+	r->changing = TRUE;
+	gtk_toggle_button_set_active(tb, active);
+	r->changing = FALSE;
+}
+
+void uiRadioButtonsOnSelected(uiRadioButtons *r, void (*f)(uiRadioButtons *, void *), void *data)
+{
+	r->onSelected = f;
+	r->onSelectedData = data;
+}
+
+uiRadioButtons *uiNewRadioButtons(void)
+{
+	uiRadioButtons *r;
+
+	uiUnixNewControl(uiRadioButtons, r);
+
+	r->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
+	r->container = GTK_CONTAINER(r->widget);
+	r->box = GTK_BOX(r->widget);
+
+	r->buttons = g_ptr_array_new();
+
+	uiRadioButtonsOnSelected(r, defaultOnSelected, NULL);
+
+	return r;
+}
diff --git a/src/libui_sdl/libui/unix/separator.c b/src/libui_sdl/libui/unix/separator.c
new file mode 100644
index 0000000..02c75da
--- /dev/null
+++ b/src/libui_sdl/libui/unix/separator.c
@@ -0,0 +1,34 @@
+// 11 june 2015
+#include "uipriv_unix.h"
+
+struct uiSeparator {
+	uiUnixControl c;
+	GtkWidget *widget;
+	GtkSeparator *separator;
+};
+
+uiUnixControlAllDefaults(uiSeparator)
+
+uiSeparator *uiNewHorizontalSeparator(void)
+{
+	uiSeparator *s;
+
+	uiUnixNewControl(uiSeparator, s);
+
+	s->widget = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
+	s->separator = GTK_SEPARATOR(s->widget);
+
+	return s;
+}
+
+uiSeparator *uiNewVerticalSeparator(void)
+{
+	uiSeparator *s;
+
+	uiUnixNewControl(uiSeparator, s);
+
+	s->widget = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
+	s->separator = GTK_SEPARATOR(s->widget);
+
+	return s;
+}
diff --git a/src/libui_sdl/libui/unix/slider.c b/src/libui_sdl/libui/unix/slider.c
new file mode 100644
index 0000000..7f0cc24
--- /dev/null
+++ b/src/libui_sdl/libui/unix/slider.c
@@ -0,0 +1,71 @@
+// 11 june 2015
+#include "uipriv_unix.h"
+
+struct uiSlider {
+	uiUnixControl c;
+	GtkWidget *widget;
+	GtkRange *range;
+	GtkScale *scale;
+	void (*onChanged)(uiSlider *, void *);
+	void *onChangedData;
+	gulong onChangedSignal;
+};
+
+uiUnixControlAllDefaults(uiSlider)
+
+static void onChanged(GtkRange *range, gpointer data)
+{
+	uiSlider *s = uiSlider(data);
+
+	(*(s->onChanged))(s, s->onChangedData);
+}
+
+static void defaultOnChanged(uiSlider *s, void *data)
+{
+	// do nothing
+}
+
+int uiSliderValue(uiSlider *s)
+{
+	return gtk_range_get_value(s->range);
+}
+
+void uiSliderSetValue(uiSlider *s, int value)
+{
+	// we need to inhibit sending of ::value-changed because this WILL send a ::value-changed otherwise
+	g_signal_handler_block(s->range, s->onChangedSignal);
+	gtk_range_set_value(s->range, value);
+	g_signal_handler_unblock(s->range, s->onChangedSignal);
+}
+
+void uiSliderOnChanged(uiSlider *s, void (*f)(uiSlider *, void *), void *data)
+{
+	s->onChanged = f;
+	s->onChangedData = data;
+}
+
+uiSlider *uiNewSlider(int min, int max)
+{
+	uiSlider *s;
+	int temp;
+
+	if (min >= max) {
+		temp = min;
+		min = max;
+		max = temp;
+	}
+
+	uiUnixNewControl(uiSlider, s);
+
+	s->widget = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, min, max, 1);
+	s->range = GTK_RANGE(s->widget);
+	s->scale = GTK_SCALE(s->widget);
+
+	// ensure integers, just to be safe
+	gtk_scale_set_digits(s->scale, 0);
+
+	s->onChangedSignal = g_signal_connect(s->scale, "value-changed", G_CALLBACK(onChanged), s);
+	uiSliderOnChanged(s, defaultOnChanged, NULL);
+
+	return s;
+}
diff --git a/src/libui_sdl/libui/unix/spinbox.c b/src/libui_sdl/libui/unix/spinbox.c
new file mode 100644
index 0000000..90a5d3c
--- /dev/null
+++ b/src/libui_sdl/libui/unix/spinbox.c
@@ -0,0 +1,72 @@
+// 11 june 2015
+#include "uipriv_unix.h"
+
+struct uiSpinbox {
+	uiUnixControl c;
+	GtkWidget *widget;
+	GtkEntry *entry;
+	GtkSpinButton *spinButton;
+	void (*onChanged)(uiSpinbox *, void *);
+	void *onChangedData;
+	gulong onChangedSignal;
+};
+
+uiUnixControlAllDefaults(uiSpinbox)
+
+static void onChanged(GtkSpinButton *sb, gpointer data)
+{
+	uiSpinbox *s = uiSpinbox(data);
+
+	(*(s->onChanged))(s, s->onChangedData);
+}
+
+static void defaultOnChanged(uiSpinbox *s, void *data)
+{
+	// do nothing
+}
+
+int uiSpinboxValue(uiSpinbox *s)
+{
+	return gtk_spin_button_get_value(s->spinButton);
+}
+
+void uiSpinboxSetValue(uiSpinbox *s, int value)
+{
+	// we need to inhibit sending of ::value-changed because this WILL send a ::value-changed otherwise
+	g_signal_handler_block(s->spinButton, s->onChangedSignal);
+	// this clamps for us
+	gtk_spin_button_set_value(s->spinButton, (gdouble) value);
+	g_signal_handler_unblock(s->spinButton, s->onChangedSignal);
+}
+
+void uiSpinboxOnChanged(uiSpinbox *s, void (*f)(uiSpinbox *, void *), void *data)
+{
+	s->onChanged = f;
+	s->onChangedData = data;
+}
+
+uiSpinbox *uiNewSpinbox(int min, int max)
+{
+	uiSpinbox *s;
+	int temp;
+
+	if (min >= max) {
+		temp = min;
+		min = max;
+		max = temp;
+	}
+
+	uiUnixNewControl(uiSpinbox, s);
+
+	s->widget = gtk_spin_button_new_with_range(min, max, 1);
+	s->entry = GTK_ENTRY(s->widget);
+	s->spinButton = GTK_SPIN_BUTTON(s->widget);
+
+	// ensure integers, just to be safe
+	gtk_spin_button_set_digits(s->spinButton, 0);
+
+	s->onChangedSignal = g_signal_connect(s->spinButton, "value-changed", G_CALLBACK(onChanged), s);
+	uiSpinboxOnChanged(s, defaultOnChanged, NULL);
+
+	return s;
+}
diff --git a/src/libui_sdl/libui/unix/stddialogs.c b/src/libui_sdl/libui/unix/stddialogs.c
new file mode 100644
index 0000000..93302f7
--- /dev/null
+++ b/src/libui_sdl/libui/unix/stddialogs.c
@@ -0,0 +1,66 @@
+// 26 june 2015
+#include "uipriv_unix.h"
+
+// LONGTERM figure out why, and describe, that this is the desired behavior
+// LONGTERM also point out that font and color buttons also work like this
+
+#define windowWindow(w) (GTK_WINDOW(uiControlHandle(uiControl(w))))
+
+static char *filedialog(GtkWindow *parent, GtkFileChooserAction mode, const gchar *confirm)
+{
+	GtkWidget *fcd;
+	GtkFileChooser *fc;
+	gint response;
+	char *filename;
+
+	fcd = gtk_file_chooser_dialog_new(NULL, parent, mode,
+		"_Cancel", GTK_RESPONSE_CANCEL,
+		confirm, GTK_RESPONSE_ACCEPT,
+		NULL);
+	fc = GTK_FILE_CHOOSER(fcd);
+	gtk_file_chooser_set_local_only(fc, FALSE);
+	gtk_file_chooser_set_select_multiple(fc, FALSE);
+	gtk_file_chooser_set_show_hidden(fc, TRUE);
+	gtk_file_chooser_set_do_overwrite_confirmation(fc, TRUE);
+	gtk_file_chooser_set_create_folders(fc, TRUE);
+	response = gtk_dialog_run(GTK_DIALOG(fcd));
+	if (response != GTK_RESPONSE_ACCEPT) {
+		gtk_widget_destroy(fcd);
+		return NULL;
+	}
+	filename = uiUnixStrdupText(gtk_file_chooser_get_filename(fc));
+	gtk_widget_destroy(fcd);
+	return filename;
+}
+
+char *uiOpenFile(uiWindow *parent)
+{
+	return filedialog(windowWindow(parent), GTK_FILE_CHOOSER_ACTION_OPEN, "_Open");
+}
+
+char *uiSaveFile(uiWindow *parent)
+{
+	return filedialog(windowWindow(parent), GTK_FILE_CHOOSER_ACTION_SAVE, "_Save");
+}
+
+static void msgbox(GtkWindow *parent, const char *title, const char *description, GtkMessageType type, GtkButtonsType buttons)
+{
+	GtkWidget *md;
+
+	md = gtk_message_dialog_new(parent, GTK_DIALOG_MODAL,
+		type, buttons,
+		"%s", title);
+	gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(md), "%s", description);
+	gtk_dialog_run(GTK_DIALOG(md));
+	gtk_widget_destroy(md);
+}
+
+void uiMsgBox(uiWindow *parent, const char *title, const char *description)
+{
+	msgbox(windowWindow(parent), title, description, GTK_MESSAGE_OTHER, GTK_BUTTONS_OK);
+}
+
+void uiMsgBoxError(uiWindow *parent, const char *title, const char *description)
+{
+	msgbox(windowWindow(parent), title, description, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK);
+}
diff --git a/src/libui_sdl/libui/unix/tab.c b/src/libui_sdl/libui/unix/tab.c
new file mode 100644
index 0000000..552e0e3
--- /dev/null
+++ b/src/libui_sdl/libui/unix/tab.c
@@ -0,0 +1,97 @@
+// 11 june 2015
+#include "uipriv_unix.h"
+
+struct uiTab {
+	uiUnixControl c;
+
+	GtkWidget *widget;
+	GtkContainer *container;
+	GtkNotebook *notebook;
+
+	GArray *pages;				// []*struct child
+};
+
+uiUnixControlAllDefaultsExceptDestroy(uiTab)
+
+static void uiTabDestroy(uiControl *c)
+{
+	uiTab *t = uiTab(c);
+	guint i;
+	struct child *page;
+
+	for (i = 0; i < t->pages->len; i++) {
+		page = g_array_index(t->pages, struct child *, i);
+		childDestroy(page);
+	}
+	g_array_free(t->pages, TRUE);
+	// and free ourselves
+	g_object_unref(t->widget);
+	uiFreeControl(uiControl(t));
+}
+
+void uiTabAppend(uiTab *t, const char *name, uiControl *child)
+{
+	uiTabInsertAt(t, name, t->pages->len, child);
+}
+
+void uiTabInsertAt(uiTab *t, const char *name, int n, uiControl *child)
+{
+	struct child *page;
+
+	// this will create a tab, because of gtk_container_add()
+	page = newChildWithBox(child, uiControl(t), t->container, 0);
+
+	gtk_notebook_set_tab_label_text(t->notebook, childBox(page), name);
+	gtk_notebook_reorder_child(t->notebook, childBox(page), n);
+
+	g_array_insert_val(t->pages, n, page);
+}
+
+void uiTabDelete(uiTab *t, int n)
+{
+	struct child *page;
+
+	page = g_array_index(t->pages, struct child *, n);
+	// this will remove the tab, because gtk_widget_destroy() calls gtk_container_remove()
+	childRemove(page);
+	g_array_remove_index(t->pages, n);
+}
+
+int uiTabNumPages(uiTab *t)
+{
+	return t->pages->len;
+}
+
+int uiTabMargined(uiTab *t, int n)
+{
+	struct child *page;
+
+	page = g_array_index(t->pages, struct child *, n);
+	return childFlag(page);
+}
+
+void uiTabSetMargined(uiTab *t, int n, int margined)
+{
+	struct child *page;
+
+	page = g_array_index(t->pages, struct child *, n);
+	childSetFlag(page, margined);
+	childSetMargined(page, childFlag(page));
+}
+
+uiTab *uiNewTab(void)
+{
+	uiTab *t;
+
+	uiUnixNewControl(uiTab, t);
+
+	t->widget = gtk_notebook_new();
+	t->container = GTK_CONTAINER(t->widget);
+	t->notebook = GTK_NOTEBOOK(t->widget);
+
+	gtk_notebook_set_scrollable(t->notebook, TRUE);
+
+	t->pages = g_array_new(FALSE, TRUE, sizeof (struct child *));
+
+	return t;
+}
diff --git a/src/libui_sdl/libui/unix/text.c b/src/libui_sdl/libui/unix/text.c
new file mode 100644
index 0000000..ad92738
--- /dev/null
+++ b/src/libui_sdl/libui/unix/text.c
@@ -0,0 +1,12 @@
+// 9 april 2015
+#include "uipriv_unix.h"
+
+char *uiUnixStrdupText(const char *t)
+{
+	return g_strdup(t);
+}
+
+void uiFreeText(char *t)
+{
+	g_free(t);
+}
diff --git a/src/libui_sdl/libui/unix/uipriv_unix.h b/src/libui_sdl/libui/unix/uipriv_unix.h
new file mode 100644
index 0000000..33ff1e3
--- /dev/null
+++ b/src/libui_sdl/libui/unix/uipriv_unix.h
@@ -0,0 +1,65 @@
+// 22 april 2015
+#define GLIB_VERSION_MIN_REQUIRED GLIB_VERSION_2_40
+#define GLIB_VERSION_MAX_ALLOWED GLIB_VERSION_2_40
+#define GDK_VERSION_MIN_REQUIRED GDK_VERSION_3_10
+#define GDK_VERSION_MAX_ALLOWED GDK_VERSION_3_10
+#include <gtk/gtk.h>
+#include <math.h>
+#include <dlfcn.h>		// see drawtext.c
+#include <langinfo.h>
+#include <string.h>
+#include <stdlib.h>
+#include "../ui.h"
+#include "../ui_unix.h"
+#include "../common/uipriv.h"
+
+#define gtkXMargin 12
+#define gtkYMargin 12
+#define gtkXPadding 12
+#define gtkYPadding 6
+
+// menu.c
+extern GtkWidget *makeMenubar(uiWindow *);
+extern void freeMenubar(GtkWidget *);
+extern void uninitMenus(void);
+
+// alloc.c
+extern void initAlloc(void);
+extern void uninitAlloc(void);
+
+// util.c
+extern void setMargined(GtkContainer *, int);
+
+// child.c
+extern struct child *newChild(uiControl *child, uiControl *parent, GtkContainer *parentContainer);
+extern struct child *newChildWithBox(uiControl *child, uiControl *parent, GtkContainer *parentContainer, int margined);
+extern void childRemove(struct child *c);
+extern void childDestroy(struct child *c);
+extern GtkWidget *childWidget(struct child *c);
+extern int childFlag(struct child *c);
+extern void childSetFlag(struct child *c, int flag);
+extern GtkWidget *childBox(struct child *c);
+extern void childSetMargined(struct child *c, int margined);
+
+// draw.c
+extern uiDrawContext *newContext(cairo_t *);
+extern void freeContext(uiDrawContext *);
+
+// drawtext.c
+extern uiDrawTextFont *mkTextFont(PangoFont *f, gboolean add);
+extern PangoFont *pangoDescToPangoFont(PangoFontDescription *pdesc);
+
+// graphemes.c
+extern ptrdiff_t *graphemes(const char *text, PangoContext *context);
+
+// image.c
+/*TODO remove this*/typedef struct uiImage uiImage;
+extern cairo_surface_t *imageAppropriateSurface(uiImage *i, GtkWidget *w);
+
+// cellrendererbutton.c
+extern GtkCellRenderer *newCellRendererButton(void);
+
+// future.c
+extern void loadFutures(void);
+extern PangoAttribute *FUTURE_pango_attr_foreground_alpha_new(guint16 alpha);
+extern gboolean FUTURE_gtk_widget_path_iter_set_object_name(GtkWidgetPath *path, gint pos, const char *name);
diff --git a/src/libui_sdl/libui/unix/util.c b/src/libui_sdl/libui/unix/util.c
new file mode 100644
index 0000000..7f4f43f
--- /dev/null
+++ b/src/libui_sdl/libui/unix/util.c
@@ -0,0 +1,10 @@
+// 18 april 2015
+#include "uipriv_unix.h"
+
+void setMargined(GtkContainer *c, int margined)
+{
+	if (margined)
+		gtk_container_set_border_width(c, gtkXMargin);
+	else
+		gtk_container_set_border_width(c, 0);
+}
diff --git a/src/libui_sdl/libui/unix/window.c b/src/libui_sdl/libui/unix/window.c
new file mode 100644
index 0000000..ea9ba37
--- /dev/null
+++ b/src/libui_sdl/libui/unix/window.c
@@ -0,0 +1,279 @@
+// 11 june 2015
+#include "uipriv_unix.h"
+
+struct uiWindow {
+	uiUnixControl c;
+
+	GtkWidget *widget;
+	GtkContainer *container;
+	GtkWindow *window;
+
+	GtkWidget *vboxWidget;
+	GtkContainer *vboxContainer;
+	GtkBox *vbox;
+
+	GtkWidget *childHolderWidget;
+	GtkContainer *childHolderContainer;
+
+	GtkWidget *menubar;
+
+	uiControl *child;
+	int margined;
+
+	int (*onClosing)(uiWindow *, void *);
+	void *onClosingData;
+	void (*onContentSizeChanged)(uiWindow *, void *);
+	void *onContentSizeChangedData;
+	gboolean fullscreen;
+};
+
+static gboolean onClosing(GtkWidget *win, GdkEvent *e, gpointer data)
+{
+	uiWindow *w = uiWindow(data);
+
+	// manually destroy the window ourselves; don't let the delete-event handler do it
+	if ((*(w->onClosing))(w, w->onClosingData))
+		uiControlDestroy(uiControl(w));
+	// don't continue to the default delete-event handler; we destroyed the window by now
+	return TRUE;
+}
+
+static void onSizeAllocate(GtkWidget *widget, GdkRectangle *allocation, gpointer data)
+{
+	uiWindow *w = uiWindow(data);
+
+	// TODO deal with spurious size-allocates
+	(*(w->onContentSizeChanged))(w, w->onContentSizeChangedData);
+}
+
+static int defaultOnClosing(uiWindow *w, void *data)
+{
+	return 0;
+}
+
+static void defaultOnPositionContentSizeChanged(uiWindow *w, void *data)
+{
+	// do nothing
+}
+
+static void uiWindowDestroy(uiControl *c)
+{
+	uiWindow *w = uiWindow(c);
+
+	// first hide ourselves
+	gtk_widget_hide(w->widget);
+	// now destroy the child
+	if (w->child != NULL) {
+		uiControlSetParent(w->child, NULL);
+		uiUnixControlSetContainer(uiUnixControl(w->child), w->childHolderContainer, TRUE);
+		uiControlDestroy(w->child);
+	}
+	// now destroy the menus, if any
+	if (w->menubar != NULL)
+		freeMenubar(w->menubar);
+	gtk_widget_destroy(w->childHolderWidget);
+	gtk_widget_destroy(w->vboxWidget);
+	// and finally free ourselves
+	// use gtk_widget_destroy() instead of g_object_unref() because GTK+ has internal references (see #165)
+	gtk_widget_destroy(w->widget);
+	uiFreeControl(uiControl(w));
+}
+
+uiUnixControlDefaultHandle(uiWindow)
+
+uiControl *uiWindowParent(uiControl *c)
+{
+	return NULL;
+}
+
+void uiWindowSetParent(uiControl *c, uiControl *parent)
+{
+	uiUserBugCannotSetParentOnToplevel("uiWindow");
+}
+
+static int uiWindowToplevel(uiControl *c)
+{
+	return 1;
+}
+
+uiUnixControlDefaultVisible(uiWindow)
+
+static void uiWindowShow(uiControl *c)
+{
+	uiWindow *w = uiWindow(c);
+
+	// don't use gtk_widget_show_all() as that will show all children, regardless of user settings
+	// don't use gtk_widget_show(); that doesn't bring to front or give keyboard focus
+	// (gtk_window_present() does call gtk_widget_show() though)
+	gtk_window_present(w->window);
+}
+
+uiUnixControlDefaultHide(uiWindow)
+uiUnixControlDefaultEnabled(uiWindow)
+uiUnixControlDefaultEnable(uiWindow)
+uiUnixControlDefaultDisable(uiWindow)
+// TODO?
+uiUnixControlDefaultSetContainer(uiWindow)
+
+char *uiWindowTitle(uiWindow *w)
+{
+	return uiUnixStrdupText(gtk_window_get_title(w->window));
+}
+
+void uiWindowSetTitle(uiWindow *w, const char *title)
+{
+	gtk_window_set_title(w->window, title);
+}
+
+void uiWindowContentSize(uiWindow *w, int *width, int *height)
+{
+	GtkAllocation allocation;
+
+	gtk_widget_get_allocation(w->childHolderWidget, &allocation);
+	*width = allocation.width;
+	*height = allocation.height;
+}
+
+void uiWindowSetContentSize(uiWindow *w, int width, int height)
+{
+	GtkAllocation childAlloc;
+	gint winWidth, winHeight;
+
+	// we need to resize the child holder widget to the given size
+	// we can't resize that without running the event loop
+	// but we can do gtk_window_set_size()
+	// so how do we deal with the differences in sizes?
+	// simple arithmetic, of course!
+
+	// from what I can tell, the return from gtk_widget_get_allocation(w->window) and gtk_window_get_size(w->window) will be the same
+	// this is not affected by Wayland and not affected by GTK+ builtin CSD
+	// so we can safely juse use them to get the real window size!
+	// since we're using gtk_window_resize(), use the latter
+	gtk_window_get_size(w->window, &winWidth, &winHeight);
+
+	// now get the child holder widget's current allocation
+	gtk_widget_get_allocation(w->childHolderWidget, &childAlloc);
+	// and punch that out of the window size
+	winWidth -= childAlloc.width;
+	winHeight -= childAlloc.height;
+
+	// now we just need to add the new size back in
+	winWidth += width;
+	winHeight += height;
+	// and set it
+	// this will not move the window in my tests, so we're good
+	gtk_window_resize(w->window, winWidth, winHeight);
+}
+
+int uiWindowFullscreen(uiWindow *w)
+{
+	return w->fullscreen;
+}
+
+// TODO use window-state-event to track
+// TODO does this send an extra size changed?
+// TODO what behavior do we want?
+void uiWindowSetFullscreen(uiWindow *w, int fullscreen)
+{
+	w->fullscreen = fullscreen;
+	if (w->fullscreen)
+		gtk_window_fullscreen(w->window);
+	else
+		gtk_window_unfullscreen(w->window);
+}
+
+void uiWindowOnContentSizeChanged(uiWindow *w, void (*f)(uiWindow *, void *), void *data)
+{
+	w->onContentSizeChanged = f;
+	w->onContentSizeChangedData = data;
+}
+
+void uiWindowOnClosing(uiWindow *w, int (*f)(uiWindow *, void *), void *data)
+{
+	w->onClosing = f;
+	w->onClosingData = data;
+}
+
+int uiWindowBorderless(uiWindow *w)
+{
+	return gtk_window_get_decorated(w->window) == FALSE;
+}
+
+void uiWindowSetBorderless(uiWindow *w, int borderless)
+{
+	gtk_window_set_decorated(w->window, borderless == 0);
+}
+
+// TODO save and restore expands and aligns
+void uiWindowSetChild(uiWindow *w, uiControl *child)
+{
+	if (w->child != NULL) {
+		uiControlSetParent(w->child, NULL);
+		uiUnixControlSetContainer(uiUnixControl(w->child), w->childHolderContainer, TRUE);
+	}
+	w->child = child;
+	if (w->child != NULL) {
+		uiControlSetParent(w->child, uiControl(w));
+		uiUnixControlSetContainer(uiUnixControl(w->child), w->childHolderContainer, FALSE);
+	}
+}
+
+int uiWindowMargined(uiWindow *w)
+{
+	return w->margined;
+}
+
+void uiWindowSetMargined(uiWindow *w, int margined)
+{
+	w->margined = margined;
+	setMargined(w->childHolderContainer, w->margined);
+}
+
+uiWindow *uiNewWindow(const char *title, int width, int height, int hasMenubar)
+{
+	uiWindow *w;
+
+	uiUnixNewControl(uiWindow, w);
+
+	w->widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+	w->container = GTK_CONTAINER(w->widget);
+	w->window = GTK_WINDOW(w->widget);
+
+	gtk_window_set_title(w->window, title);
+	gtk_window_resize(w->window, width, height);
+
+	w->vboxWidget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
+	w->vboxContainer = GTK_CONTAINER(w->vboxWidget);
+	w->vbox = GTK_BOX(w->vboxWidget);
+
+	// set the vbox as the GtkWindow child
+	gtk_container_add(w->container, w->vboxWidget);
+
+	if (hasMenubar) {
+		w->menubar = makeMenubar(uiWindow(w));
+		gtk_container_add(w->vboxContainer, w->menubar);
+	}
+
+	w->childHolderWidget = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+	w->childHolderContainer = GTK_CONTAINER(w->childHolderWidget);
+	gtk_widget_set_hexpand(w->childHolderWidget, TRUE);
+	gtk_widget_set_halign(w->childHolderWidget, GTK_ALIGN_FILL);
+	gtk_widget_set_vexpand(w->childHolderWidget, TRUE);
+	gtk_widget_set_valign(w->childHolderWidget, GTK_ALIGN_FILL);
+	gtk_container_add(w->vboxContainer, w->childHolderWidget);
+
+	// show everything in the vbox, but not the GtkWindow itself
+	gtk_widget_show_all(w->vboxWidget);
+
+	// and connect our events
+	g_signal_connect(w->widget, "delete-event", G_CALLBACK(onClosing), w);
+	g_signal_connect(w->childHolderWidget, "size-allocate", G_CALLBACK(onSizeAllocate), w);
+	uiWindowOnClosing(w, defaultOnClosing, NULL);
+	uiWindowOnContentSizeChanged(w, defaultOnPositionContentSizeChanged, NULL);
+
+	// normally it's SetParent() that does this, but we can't call SetParent() on a uiWindow
+	// TODO we really need to clean this up, especially since see uiWindowDestroy() above
+	g_object_ref(w->widget);
+
+	return w;
+}
diff --git a/src/libui_sdl/libui/windows/CMakeLists.txt b/src/libui_sdl/libui/windows/CMakeLists.txt
new file mode 100644
index 0000000..4695eb4
--- /dev/null
+++ b/src/libui_sdl/libui/windows/CMakeLists.txt
@@ -0,0 +1,91 @@
+# 3 june 2016
+
+list(APPEND _LIBUI_SOURCES
+	windows/alloc.cpp
+	windows/area.cpp
+	windows/areadraw.cpp
+	windows/areaevents.cpp
+	windows/areascroll.cpp
+	windows/areautil.cpp
+	windows/box.cpp
+	windows/button.cpp
+	windows/checkbox.cpp
+	windows/colorbutton.cpp
+	windows/colordialog.cpp
+	windows/combobox.cpp
+	windows/container.cpp
+	windows/control.cpp
+	windows/d2dscratch.cpp
+	windows/datetimepicker.cpp
+	windows/debug.cpp
+	windows/draw.cpp
+	windows/drawmatrix.cpp
+	windows/drawpath.cpp
+	windows/drawtext.cpp
+	windows/dwrite.cpp
+	windows/editablecombo.cpp
+	windows/entry.cpp
+	windows/events.cpp
+	windows/fontbutton.cpp
+	windows/fontdialog.cpp
+	windows/form.cpp
+	windows/graphemes.cpp
+	windows/grid.cpp
+	windows/group.cpp
+	windows/init.cpp
+	windows/label.cpp
+	windows/main.cpp
+	windows/menu.cpp
+	windows/multilineentry.cpp
+	windows/parent.cpp
+	windows/progressbar.cpp
+	windows/radiobuttons.cpp
+	windows/separator.cpp
+	windows/sizing.cpp
+	windows/slider.cpp
+	windows/spinbox.cpp
+	windows/stddialogs.cpp
+	windows/tab.cpp
+	windows/tabpage.cpp
+	windows/text.cpp
+	windows/utf16.cpp
+	windows/utilwin.cpp
+	windows/window.cpp
+	windows/winpublic.cpp
+	windows/winutil.cpp
+	windows/resources.rc
+)
+set(_LIBUI_SOURCES ${_LIBUI_SOURCES} PARENT_SCOPE)
+
+list(APPEND _LIBUI_INCLUDEDIRS
+	windows
+)
+set(_LIBUI_INCLUDEDIRS _LIBUI_INCLUDEDIRS PARENT_SCOPE)
+
+# Windows won't link resources in static libraries; we need to provide the libui.res file in this case.
+set(_LIBUINAME libui PARENT_SCOPE)
+if(NOT BUILD_SHARED_LIBS)
+	set(_LIBUI_STATIC_RES ${CMAKE_ARCHIVE_OUTPUT_DIRECTORY}/libui.res PARENT_SCOPE)
+endif()
+macro(_handle_static)
+	# TODO this full path feels hacky
+	add_custom_command(
+		TARGET libui POST_BUILD
+		COMMAND
+			${CMAKE_COMMAND} -E copy $<TARGET_PROPERTY:libui,BINARY_DIR>/CMakeFiles/libui.dir/windows/resources.rc.* ${_LIBUI_STATIC_RES}
+		COMMENT "Copying libui.res")
+endmacro()
+
+# notice that usp10 comes before gdi32
+# TODO prune this list
+set(_LIBUI_LIBS
+	user32 kernel32 usp10 gdi32 comctl32 uxtheme msimg32 comdlg32 d2d1 dwrite ole32 oleaut32 oleacc uuid
+PARENT_SCOPE)
+
+if(NOT MSVC)
+	if(BUILD_SHARED_LIBS)
+		message(FATAL_ERROR
+			"Sorry, but libui for Windows can currently only be built as a static library with MinGW. You will need to either build as a static library or switch to MSVC."
+		)
+	endif()
+endif()
diff --git a/src/libui_sdl/libui/windows/_uipriv_migrate.hpp b/src/libui_sdl/libui/windows/_uipriv_migrate.hpp
new file mode 100644
index 0000000..13d3670
--- /dev/null
+++ b/src/libui_sdl/libui/windows/_uipriv_migrate.hpp
@@ -0,0 +1,61 @@
+
+// menu.c
+extern HMENU makeMenubar(void);
+extern const uiMenuItem *menuIDToItem(UINT_PTR);
+extern void runMenuEvent(WORD, uiWindow *);
+extern void freeMenubar(HMENU);
+extern void uninitMenus(void);
+
+// draw.c
+extern HRESULT initDraw(void);
+extern void uninitDraw(void);
+extern ID2D1HwndRenderTarget *makeHWNDRenderTarget(HWND hwnd);
+extern uiDrawContext *newContext(ID2D1RenderTarget *);
+extern void freeContext(uiDrawContext *);
+
+// dwrite.cpp
+#ifdef __cplusplus
+extern IDWriteFactory *dwfactory;
+#endif
+extern HRESULT initDrawText(void);
+extern void uninitDrawText(void);
+#ifdef __cplusplus
+struct fontCollection {
+	IDWriteFontCollection *fonts;
+	WCHAR userLocale[LOCALE_NAME_MAX_LENGTH];
+	int userLocaleSuccess;
+};
+extern fontCollection *loadFontCollection(void);
+extern WCHAR *fontCollectionFamilyName(fontCollection *fc, IDWriteFontFamily *family);
+extern void fontCollectionFree(fontCollection *fc);
+extern WCHAR *fontCollectionCorrectString(fontCollection *fc, IDWriteLocalizedStrings *names);
+#endif
+
+// drawtext.cpp
+#ifdef __cplusplus
+extern uiDrawTextFont *mkTextFont(IDWriteFont *df, BOOL addRef, WCHAR *family, BOOL copyFamily, double size);
+struct dwriteAttr {
+	uiDrawTextWeight weight;
+	uiDrawTextItalic italic;
+	uiDrawTextStretch stretch;
+	DWRITE_FONT_WEIGHT dweight;
+	DWRITE_FONT_STYLE ditalic;
+	DWRITE_FONT_STRETCH dstretch;
+};
+extern void attrToDWriteAttr(struct dwriteAttr *attr);
+extern void dwriteAttrToAttr(struct dwriteAttr *attr);
+#endif
+
+// fontdialog.cpp
+#ifdef __cplusplus
+struct fontDialogParams {
+	IDWriteFont *font;
+	double size;
+	WCHAR *familyName;
+	WCHAR *styleName;
+};
+extern BOOL showFontDialog(HWND parent, struct fontDialogParams *params);
+extern void loadInitialFontDialogParams(struct fontDialogParams *params);
+extern void destroyFontDialogParams(struct fontDialogParams *params);
+extern WCHAR *fontDialogParamsToString(struct fontDialogParams *params);
+#endif
diff --git a/src/libui_sdl/libui/windows/alloc.cpp b/src/libui_sdl/libui/windows/alloc.cpp
new file mode 100644
index 0000000..eeee3ad
--- /dev/null
+++ b/src/libui_sdl/libui/windows/alloc.cpp
@@ -0,0 +1,63 @@
+// 4 december 2014
+#include "uipriv_windows.hpp"
+
+typedef std::vector<uint8_t> byteArray;
+
+static std::map<uint8_t *, byteArray *> heap;
+static std::map<byteArray *, const char *> types;
+
+void initAlloc(void)
+{
+	// do nothing
+}
+
+void uninitAlloc(void)
+{
+	std::ostringstream oss;
+	std::string ossstr;		// keep alive, just to be safe
+
+	if (heap.size() == 0)
+		return;
+	for (const auto &alloc : heap)
+		// note the void * cast; otherwise it'll be treated as a string
+		oss << (void *) (alloc.first) << " " << types[alloc.second] << "\n";
+	ossstr = oss.str();
+	userbug("Some data was leaked; either you left a uiControl lying around or there's a bug in libui itself. Leaked data:\n%s", ossstr.c_str());
+}
+
+#define rawBytes(pa) (&((*pa)[0]))
+
+void *uiAlloc(size_t size, const char *type)
+{
+	byteArray *out;
+
+	out = new byteArray(size, 0);
+	heap[rawBytes(out)] = out;
+	types[out] = type;
+	return rawBytes(out);
+}
+
+void *uiRealloc(void *_p, size_t size, const char *type)
+{
+	uint8_t *p = (uint8_t *) _p;
+	byteArray *arr;
+
+	if (p == NULL)
+		return uiAlloc(size, type);
+	arr = heap[p];
+	arr->resize(size, 0);
+	heap.erase(p);
+	heap[rawBytes(arr)] = arr;
+	return rawBytes(arr);
+}
+
+void uiFree(void *_p)
+{
+	uint8_t *p = (uint8_t *) _p;
+
+	if (p == NULL)
+		implbug("attempt to uiFree(NULL)");
+	types.erase(heap[p]);
+	delete heap[p];
+	heap.erase(p);
+}
diff --git a/src/libui_sdl/libui/windows/area.cpp b/src/libui_sdl/libui/windows/area.cpp
new file mode 100644
index 0000000..ab69ff1
--- /dev/null
+++ b/src/libui_sdl/libui/windows/area.cpp
@@ -0,0 +1,206 @@
+// 8 september 2015
+#include "uipriv_windows.hpp"
+#include "area.hpp"
+
+// TODO handle WM_DESTROY/WM_NCDESTROY
+// TODO same for other Direct2D stuff
+static LRESULT CALLBACK areaWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+	uiArea *a;
+	CREATESTRUCTW *cs = (CREATESTRUCTW *) lParam;
+	RECT client;
+	WINDOWPOS *wp = (WINDOWPOS *) lParam;
+	LRESULT lResult;
+
+	a = (uiArea *) GetWindowLongPtrW(hwnd, GWLP_USERDATA);
+	if (a == NULL) {
+		if (uMsg == WM_CREATE) {
+			a = (uiArea *) (cs->lpCreateParams);
+			// assign a->hwnd here so we can use it immediately
+			a->hwnd = hwnd;
+			SetWindowLongPtrW(hwnd, GWLP_USERDATA, (LONG_PTR) a);
+		}
+		// fall through to DefWindowProcW() anyway
+		return DefWindowProcW(hwnd, uMsg, wParam, lParam);
+	}
+
+	// always recreate the render target if necessary
+	if (a->rt == NULL)
+		a->rt = makeHWNDRenderTarget(a->hwnd);
+
+	if (areaDoDraw(a, uMsg, wParam, lParam, &lResult) != FALSE)
+		return lResult;
+
+	if (uMsg == WM_WINDOWPOSCHANGED) {
+		if ((wp->flags & SWP_NOSIZE) != 0)
+			return DefWindowProcW(hwnd, uMsg, wParam, lParam);
+		uiWindowsEnsureGetClientRect(a->hwnd, &client);
+		areaDrawOnResize(a, &client);
+		areaScrollOnResize(a, &client);
+		return 0;
+	}
+
+	if (areaDoScroll(a, uMsg, wParam, lParam, &lResult) != FALSE)
+		return lResult;
+	if (areaDoEvents(a, uMsg, wParam, lParam, &lResult) != FALSE)
+		return lResult;
+
+	// nothing done
+	return DefWindowProc(hwnd, uMsg, wParam, lParam);
+}
+
+// control implementation
+
+uiWindowsControlAllDefaults(uiArea)
+
+static void uiAreaMinimumSize(uiWindowsControl *c, int *width, int *height)
+{
+	// TODO
+	*width = 0;
+	*height = 0;
+}
+
+ATOM registerAreaClass(HICON hDefaultIcon, HCURSOR hDefaultCursor)
+{
+	WNDCLASSW wc;
+
+	ZeroMemory(&wc, sizeof (WNDCLASSW));
+	wc.lpszClassName = areaClass;
+	wc.lpfnWndProc = areaWndProc;
+	wc.hInstance = hInstance;
+	wc.hIcon = hDefaultIcon;
+	wc.hCursor = hDefaultCursor;
+	wc.hbrBackground = (HBRUSH) (COLOR_BTNFACE + 1);
+	// this is just to be safe; see the InvalidateRect() call in the WM_WINDOWPOSCHANGED handler for more details
+	wc.style = CS_HREDRAW | CS_VREDRAW;
+	return RegisterClassW(&wc);
+}
+
+void unregisterArea(void)
+{
+	if (UnregisterClassW(areaClass, hInstance) == 0)
+		logLastError(L"error unregistering uiArea window class");
+}
+
+void uiAreaSetSize(uiArea *a, int width, int height)
+{
+	a->scrollWidth = width;
+	a->scrollHeight = height;
+	areaUpdateScroll(a);
+}
+
+void uiAreaQueueRedrawAll(uiArea *a)
+{
+	// don't erase the background; we do that ourselves in doPaint()
+	invalidateRect(a->hwnd, NULL, FALSE);
+}
+
+void uiAreaScrollTo(uiArea *a, double x, double y, double width, double height)
+{
+	// TODO
+}
+
+void uiAreaBeginUserWindowMove(uiArea *a)
+{
+	HWND toplevel;
+
+	// TODO restrict execution
+	ReleaseCapture();		// TODO use properly and reset internal data structures
+	toplevel = parentToplevel(a->hwnd);
+	if (toplevel == NULL) {
+		// TODO
+		return;
+	}
+	// see http://stackoverflow.com/questions/40249940/how-do-i-initiate-a-user-mouse-driven-move-or-resize-for-custom-window-borders-o#40250654
+	SendMessageW(toplevel, WM_SYSCOMMAND,
+		SC_MOVE | 2, 0);
+}
+
+void uiAreaBeginUserWindowResize(uiArea *a, uiWindowResizeEdge edge)
+{
+	HWND toplevel;
+	WPARAM wParam;
+
+	// TODO restrict execution
+	ReleaseCapture();		// TODO use properly and reset internal data structures
+	toplevel = parentToplevel(a->hwnd);
+	if (toplevel == NULL) {
+		// TODO
+		return;
+	}
+	// see http://stackoverflow.com/questions/40249940/how-do-i-initiate-a-user-mouse-driven-move-or-resize-for-custom-window-borders-o#40250654
+	wParam = SC_SIZE;
+	switch (edge) {
+	case uiWindowResizeEdgeLeft:
+		wParam |= 1;
+		break;
+	case uiWindowResizeEdgeTop:
+		wParam |= 3;
+		break;
+	case uiWindowResizeEdgeRight:
+		wParam |= 2;
+		break;
+	case uiWindowResizeEdgeBottom:
+		wParam |= 6;
+		break;
+	case uiWindowResizeEdgeTopLeft:
+		wParam |= 4;
+		break;
+	case uiWindowResizeEdgeTopRight:
+		wParam |= 5;
+		break;
+	case uiWindowResizeEdgeBottomLeft:
+		wParam |= 7;
+		break;
+	case uiWindowResizeEdgeBottomRight:
+		wParam |= 8;
+		break;
+	}
+	SendMessageW(toplevel, WM_SYSCOMMAND,
+		wParam, 0);
+}
+
+uiArea *uiNewArea(uiAreaHandler *ah)
+{
+	uiArea *a;
+
+	uiWindowsNewControl(uiArea, a);
+
+	a->ah = ah;
+	a->scrolling = FALSE;
+	clickCounterReset(&(a->cc));
+
+	// a->hwnd is assigned in areaWndProc()
+	uiWindowsEnsureCreateControlHWND(0,
+		areaClass, L"",
+		0,
+		hInstance, a,
+		FALSE);
+
+	return a;
+}
+
+uiArea *uiNewScrollingArea(uiAreaHandler *ah, int width, int height)
+{
+	uiArea *a;
+
+	uiWindowsNewControl(uiArea, a);
+
+	a->ah = ah;
+	a->scrolling = TRUE;
+	a->scrollWidth = width;
+	a->scrollHeight = height;
+	clickCounterReset(&(a->cc));
+
+	// a->hwnd is assigned in areaWndProc()
+	uiWindowsEnsureCreateControlHWND(0,
+		areaClass, L"",
+		WS_HSCROLL | WS_VSCROLL,
+		hInstance, a,
+		FALSE);
+
+	// set initial scrolling parameters
+	areaUpdateScroll(a);
+
+	return a;
+}
diff --git a/src/libui_sdl/libui/windows/area.hpp b/src/libui_sdl/libui/windows/area.hpp
new file mode 100644
index 0000000..86a62de
--- /dev/null
+++ b/src/libui_sdl/libui/windows/area.hpp
@@ -0,0 +1,45 @@
+// 18 december 2015
+
+// TODOs
+// - things look very wrong on initial draw
+// - initial scrolling is not set properly
+// - should background be inherited from parent control?
+
+struct uiArea {
+	uiWindowsControl c;
+	HWND hwnd;
+	uiAreaHandler *ah;
+
+	BOOL scrolling;
+	int scrollWidth;
+	int scrollHeight;
+	int hscrollpos;
+	int vscrollpos;
+	int hwheelCarry;
+	int vwheelCarry;
+
+	clickCounter cc;
+	BOOL capturing;
+
+	BOOL inside;
+	BOOL tracking;
+
+	ID2D1HwndRenderTarget *rt;
+};
+
+// areadraw.cpp
+extern BOOL areaDoDraw(uiArea *a, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *lResult);
+extern void areaDrawOnResize(uiArea *, RECT *);
+
+// areascroll.cpp
+extern BOOL areaDoScroll(uiArea *a, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *lResult);
+extern void areaScrollOnResize(uiArea *, RECT *);
+extern void areaUpdateScroll(uiArea *a);
+
+// areaevents.cpp
+extern BOOL areaDoEvents(uiArea *a, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *lResult);
+
+// areautil.cpp
+extern void loadAreaSize(uiArea *a, ID2D1RenderTarget *rt, double *width, double *height);
+extern void pixelsToDIP(uiArea *a, double *x, double *y);
+extern void dipToPixels(uiArea *a, double *x, double *y);
diff --git a/src/libui_sdl/libui/windows/areadraw.cpp b/src/libui_sdl/libui/windows/areadraw.cpp
new file mode 100644
index 0000000..7b3dc69
--- /dev/null
+++ b/src/libui_sdl/libui/windows/areadraw.cpp
@@ -0,0 +1,137 @@
+// 8 september 2015
+#include "uipriv_windows.hpp"
+#include "area.hpp"
+
+static HRESULT doPaint(uiArea *a, ID2D1RenderTarget *rt, RECT *clip)
+{
+	uiAreaHandler *ah = a->ah;
+	uiAreaDrawParams dp;
+	COLORREF bgcolorref;
+	D2D1_COLOR_F bgcolor;
+	D2D1_MATRIX_3X2_F scrollTransform;
+
+	// no need to save or restore the graphics state to reset transformations;  it's handled by resetTarget() in draw.c, called during the following
+	dp.Context = newContext(rt);
+
+	loadAreaSize(a, rt, &(dp.AreaWidth), &(dp.AreaHeight));
+
+	dp.ClipX = clip->left;
+	dp.ClipY = clip->top;
+	dp.ClipWidth = clip->right - clip->left;
+	dp.ClipHeight = clip->bottom - clip->top;
+	if (a->scrolling) {
+		dp.ClipX += a->hscrollpos;
+		dp.ClipY += a->vscrollpos;
+	}
+
+	rt->BeginDraw();
+
+	if (a->scrolling) {
+		ZeroMemory(&scrollTransform, sizeof (D2D1_MATRIX_3X2_F));
+		scrollTransform._11 = 1;
+		scrollTransform._22 = 1;
+		// negative because we want nonzero scroll positions to move the drawing area up/left
+		scrollTransform._31 = -a->hscrollpos;
+		scrollTransform._32 = -a->vscrollpos;
+		rt->SetTransform(&scrollTransform);
+	}
+
+	// TODO push axis aligned clip
+
+	// TODO only clear the clip area
+	// TODO clear with actual background brush
+	bgcolorref = GetSysColor(COLOR_BTNFACE);
+	bgcolor.r = ((float) GetRValue(bgcolorref)) / 255.0;
+	// due to utter apathy on Microsoft's part, GetGValue() does not work with MSVC's Run-Time Error Checks
+	// it has not worked since 2008 and they have *never* fixed it
+	// TODO now that -RTCc has just been deprecated entirely, should we switch back?
+	bgcolor.g = ((float) ((BYTE) ((bgcolorref & 0xFF00) >> 8))) / 255.0;
+	bgcolor.b = ((float) GetBValue(bgcolorref)) / 255.0;
+	bgcolor.a = 1.0;
+	rt->Clear(&bgcolor);
+
+	(*(ah->Draw))(ah, a, &dp);
+
+	freeContext(dp.Context);
+
+	// TODO pop axis aligned clip
+
+	return rt->EndDraw(NULL, NULL);
+}
+
+static void onWM_PAINT(uiArea *a)
+{
+	RECT clip;
+	HRESULT hr;
+
+	// do not clear the update rect; we do that ourselves in doPaint()
+	if (GetUpdateRect(a->hwnd, &clip, FALSE) == 0) {
+		// set a zero clip rect just in case GetUpdateRect() didn't change clip
+		clip.left = 0;
+		clip.top = 0;
+		clip.right = 0;
+		clip.bottom = 0;
+	}
+	hr = doPaint(a, a->rt, &clip);
+	switch (hr) {
+	case S_OK:
+		if (ValidateRect(a->hwnd, NULL) == 0)
+			logLastError(L"error validating rect");
+		break;
+	case D2DERR_RECREATE_TARGET:
+		// DON'T validate the rect
+		// instead, simply drop the render target
+		// we'll get another WM_PAINT and make the render target again
+		// TODO would this require us to invalidate the entire client area?
+		a->rt->Release();;
+		a->rt = NULL;
+		break;
+	default:
+		logHRESULT(L"error painting", hr);
+	}
+}
+
+static void onWM_PRINTCLIENT(uiArea *a, HDC dc)
+{
+	ID2D1DCRenderTarget *rt;
+	RECT client;
+	HRESULT hr;
+
+	uiWindowsEnsureGetClientRect(a->hwnd, &client);
+	rt = makeHDCRenderTarget(dc, &client);
+	hr = doPaint(a, rt, &client);
+	if (hr != S_OK)
+		logHRESULT(L"error printing uiArea client area", hr);
+	rt->Release();
+}
+
+BOOL areaDoDraw(uiArea *a, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *lResult)
+{
+	switch (uMsg) {
+	case WM_PAINT:
+		onWM_PAINT(a);
+		*lResult = 0;
+		return TRUE;
+	case WM_PRINTCLIENT:
+		onWM_PRINTCLIENT(a, (HDC) wParam);
+		*lResult = 0;
+		return TRUE;
+	}
+	return FALSE;
+}
+
+// TODO only if the render target wasn't just created?
+void areaDrawOnResize(uiArea *a, RECT *newClient)
+{
+	D2D1_SIZE_U size;
+
+	size.width = newClient->right - newClient->left;
+	size.height = newClient->bottom - newClient->top;
+	// don't track the error; we'll get that in EndDraw()
+	// see https://msdn.microsoft.com/en-us/library/windows/desktop/dd370994%28v=vs.85%29.aspx
+	a->rt->Resize(&size);
+
+	// according to Rick Brewster, we must always redraw the entire client area after calling ID2D1RenderTarget::Resize() (see http://stackoverflow.com/a/33222983/3408572)
+	// we used to have a uiAreaHandler.RedrawOnResize() method to decide this; now you know why we don't anymore
+	invalidateRect(a->hwnd, NULL, TRUE);
+}
diff --git a/src/libui_sdl/libui/windows/areaevents.cpp b/src/libui_sdl/libui/windows/areaevents.cpp
new file mode 100644
index 0000000..7d391b8
--- /dev/null
+++ b/src/libui_sdl/libui/windows/areaevents.cpp
@@ -0,0 +1,421 @@
+// 8 september 2015
+#include "uipriv_windows.hpp"
+#include "area.hpp"
+
+static uiModifiers getModifiers(void)
+{
+	uiModifiers m = 0;
+
+	if ((GetKeyState(VK_CONTROL) & 0x80) != 0)
+		m |= uiModifierCtrl;
+	if ((GetKeyState(VK_MENU) & 0x80) != 0)
+		m |= uiModifierAlt;
+	if ((GetKeyState(VK_SHIFT) & 0x80) != 0)
+		m |= uiModifierShift;
+	if ((GetKeyState(VK_LWIN) & 0x80) != 0)
+		m |= uiModifierSuper;
+	if ((GetKeyState(VK_RWIN) & 0x80) != 0)
+		m |= uiModifierSuper;
+	return m;
+}
+
+/*
+Windows doesn't natively support mouse crossing events.
+
+TrackMouseEvent() (and its comctl32.dll wrapper _TrackMouseEvent()) both allow for a window to receive the WM_MOUSELEAVE message when the mouse leaves the client area. There's no equivalent WM_MOUSEENTER because it can be simulated (https://blogs.msdn.microsoft.com/oldnewthing/20031013-00/?p=42193).
+
+Unfortunately, WM_MOUSELEAVE does not get generated while the mouse is captured. We need to capture for drag behavior to work properly, so this isn't going to mix well.
+
+So what we do:
+- on WM_MOUSEMOVE, if we don't have the capture, start tracking
+	- this will handle the case of the capture being released while still in the area
+- on WM_MOUSELEAVE, mark that we are no longer tracking
+	- Windows has already done the work of that for us; it's just a flag we use for the next part
+- when starting capture, stop tracking if we are tracking
+- if capturing, manually check if the pointer is in the client rect on each area event
+*/
+static void track(uiArea *a, BOOL tracking)
+{
+	TRACKMOUSEEVENT tm;
+
+	// do nothing if there's no change
+	if (a->tracking && tracking)
+		return;
+	if (!a->tracking && !tracking)
+		return;
+
+	a->tracking = tracking;
+	ZeroMemory(&tm, sizeof (TRACKMOUSEEVENT));
+	tm.cbSize = sizeof (TRACKMOUSEEVENT);
+	tm.dwFlags = TME_LEAVE;
+	if (!a->tracking)
+		tm.dwFlags |= TME_CANCEL;
+	tm.hwndTrack = a->hwnd;
+	if (_TrackMouseEvent(&tm) == 0)
+		logLastError(L"error setting up mouse tracking");
+}
+
+static void capture(uiArea *a, BOOL capturing)
+{
+	// do nothing if there's no change
+	if (a->capturing && capturing)
+		return;
+	if (!a->capturing && !capturing)
+		return;
+
+	// change flag first as ReleaseCapture() sends WM_CAPTURECHANGED
+	a->capturing = capturing;
+	if (a->capturing) {
+		track(a, FALSE);
+		SetCapture(a->hwnd);
+	} else
+		if (ReleaseCapture() == 0)
+			logLastError(L"error releasing capture on drag");
+}
+
+static void areaMouseEvent(uiArea *a, int down, int  up, WPARAM wParam, LPARAM lParam)
+{
+	uiAreaMouseEvent me;
+	int button;
+	POINT clientpt;
+	RECT client;
+	BOOL inClient;
+	double xpix, ypix;
+
+	if (a->capturing) {
+		clientpt.x = GET_X_LPARAM(lParam);
+		clientpt.y = GET_Y_LPARAM(lParam);
+		uiWindowsEnsureGetClientRect(a->hwnd, &client);
+		inClient = PtInRect(&client, clientpt);
+		if (inClient && !a->inside) {
+			a->inside = TRUE;
+			(*(a->ah->MouseCrossed))(a->ah, a, 0);
+			clickCounterReset(&(a->cc));
+		} else if (!inClient && a->inside) {
+			a->inside = FALSE;
+			(*(a->ah->MouseCrossed))(a->ah, a, 1);
+			clickCounterReset(&(a->cc));
+		}
+	}
+
+	xpix = (double) GET_X_LPARAM(lParam);
+	ypix = (double) GET_Y_LPARAM(lParam);
+	// these are in pixels; we need points
+	pixelsToDIP(a, &xpix, &ypix);
+	me.X = xpix;
+	me.Y = ypix;
+	if (a->scrolling) {
+		me.X += a->hscrollpos;
+		me.Y += a->vscrollpos;
+	}
+
+	loadAreaSize(a, NULL, &(me.AreaWidth), &(me.AreaHeight));
+
+	me.Down = down;
+	me.Up = up;
+	me.Count = 0;
+	if (me.Down != 0)
+		// GetMessageTime() returns LONG and GetDoubleClckTime() returns UINT, which are int32 and uint32, respectively, but we don't need to worry about the signedness because for the same bit widths and two's complement arithmetic, s1-s2 == u1-u2 if bits(s1)==bits(s2) and bits(u1)==bits(u2) (and Windows requires two's complement: http://blogs.msdn.com/b/oldnewthing/archive/2005/05/27/422551.aspx)
+		// signedness isn't much of an issue for these calls anyway because http://stackoverflow.com/questions/24022225/what-are-the-sign-extension-rules-for-calling-windows-api-functions-stdcall-t and that we're only using unsigned values (think back to how you (didn't) handle signedness in assembly language) AND because of the above AND because the statistics below (time interval and width/height) really don't make sense if negative
+		// GetSystemMetrics() returns int, which is int32
+		me.Count = clickCounterClick(&(a->cc), me.Down,
+			me.X, me.Y,
+			GetMessageTime(), GetDoubleClickTime(),
+			GetSystemMetrics(SM_CXDOUBLECLK) / 2,
+			GetSystemMetrics(SM_CYDOUBLECLK) / 2);
+
+	// though wparam will contain control and shift state, let's just one function to get modifiers for both keyboard and mouse events; it'll work the same anyway since we have to do this for alt and windows key (super)
+	me.Modifiers = getModifiers();
+
+	button = me.Down;
+	if (button == 0)
+		button = me.Up;
+	me.Held1To64 = 0;
+	if (button != 1 && (wParam & MK_LBUTTON) != 0)
+		me.Held1To64 |= 1 << 0;
+	if (button != 2 && (wParam & MK_MBUTTON) != 0)
+		me.Held1To64 |= 1 << 1;
+	if (button != 3 && (wParam & MK_RBUTTON) != 0)
+		me.Held1To64 |= 1 << 2;
+	if (button != 4 && (wParam & MK_XBUTTON1) != 0)
+		me.Held1To64 |= 1 << 3;
+	if (button != 5 && (wParam & MK_XBUTTON2) != 0)
+		me.Held1To64 |= 1 << 4;
+
+	// on Windows, we have to capture on drag ourselves
+	if (me.Down != 0)
+		capture(a, TRUE);
+	// only release capture when all buttons released
+	if (me.Up != 0 && me.Held1To64 == 0)
+		capture(a, FALSE);
+
+	(*(a->ah->MouseEvent))(a->ah, a, &me);
+}
+
+// TODO genericize this so it can be called above
+static void onMouseEntered(uiArea *a)
+{
+	if (a->inside)
+		return;
+	if (a->capturing)		// we handle mouse crossing in areaMouseEvent()
+		return;
+	track(a, TRUE);
+	(*(a->ah->MouseCrossed))(a->ah, a, 0);
+	// TODO figure out why we did this to begin with; either we do it on both GTK+ and Windows or not at all
+	clickCounterReset(&(a->cc));
+}
+
+// TODO genericize it so that it can be called above
+static void onMouseLeft(uiArea *a)
+{
+	a->tracking = FALSE;
+	a->inside = FALSE;
+	(*(a->ah->MouseCrossed))(a->ah, a, 1);
+	// TODO figure out why we did this to begin with; either we do it on both GTK+ and Windows or not at all
+	clickCounterReset(&(a->cc));
+}
+
+// we use VK_SNAPSHOT as a sentinel because libui will never support the print screen key; that key belongs to the user
+struct extkeymap {
+	WPARAM vk;
+	uiExtKey extkey;
+};
+
+// all mappings come from GLFW - https://github.com/glfw/glfw/blob/master/src/win32_window.c#L152
+static const struct extkeymap numpadExtKeys[] = {
+	{ VK_HOME, uiExtKeyN7 },
+	{ VK_UP, uiExtKeyN8 },
+	{ VK_PRIOR, uiExtKeyN9 },
+	{ VK_LEFT, uiExtKeyN4 },
+	{ VK_CLEAR, uiExtKeyN5 },
+	{ VK_RIGHT, uiExtKeyN6 },
+	{ VK_END, uiExtKeyN1 },
+	{ VK_DOWN, uiExtKeyN2 },
+	{ VK_NEXT, uiExtKeyN3 },
+	{ VK_INSERT, uiExtKeyN0 },
+	{ VK_DELETE, uiExtKeyNDot },
+	{ VK_SNAPSHOT, 0 },
+};
+
+static const struct extkeymap extKeys[] = {
+	{ VK_ESCAPE, uiExtKeyEscape },
+	{ VK_INSERT, uiExtKeyInsert },
+	{ VK_DELETE, uiExtKeyDelete },
+	{ VK_HOME, uiExtKeyHome },
+	{ VK_END, uiExtKeyEnd },
+	{ VK_PRIOR, uiExtKeyPageUp },
+	{ VK_NEXT, uiExtKeyPageDown },
+	{ VK_UP, uiExtKeyUp },
+	{ VK_DOWN, uiExtKeyDown },
+	{ VK_LEFT, uiExtKeyLeft },
+	{ VK_RIGHT, uiExtKeyRight },
+	{ VK_F1, uiExtKeyF1 },
+	{ VK_F2, uiExtKeyF2 },
+	{ VK_F3, uiExtKeyF3 },
+	{ VK_F4, uiExtKeyF4 },
+	{ VK_F5, uiExtKeyF5 },
+	{ VK_F6, uiExtKeyF6 },
+	{ VK_F7, uiExtKeyF7 },
+	{ VK_F8, uiExtKeyF8 },
+	{ VK_F9, uiExtKeyF9 },
+	{ VK_F10, uiExtKeyF10 },
+	{ VK_F11, uiExtKeyF11 },
+	{ VK_F12, uiExtKeyF12 },
+	// numpad numeric keys and . are handled in common/areaevents.c
+	// numpad enter is handled in code below
+	{ VK_ADD, uiExtKeyNAdd },
+	{ VK_SUBTRACT, uiExtKeyNSubtract },
+	{ VK_MULTIPLY, uiExtKeyNMultiply },
+	{ VK_DIVIDE, uiExtKeyNDivide },
+	{ VK_SNAPSHOT, 0 },
+};
+
+static const struct {
+	WPARAM vk;
+	uiModifiers mod;
+} modKeys[] = {
+	// even if the separate left/right aren't necessary, have them here anyway, just to be safe
+	{ VK_CONTROL, uiModifierCtrl },
+	{ VK_LCONTROL, uiModifierCtrl },
+	{ VK_RCONTROL, uiModifierCtrl },
+	{ VK_MENU, uiModifierAlt },
+	{ VK_LMENU, uiModifierAlt },
+	{ VK_RMENU, uiModifierAlt },
+	{ VK_SHIFT, uiModifierShift },
+	{ VK_LSHIFT, uiModifierShift },
+	{ VK_RSHIFT, uiModifierShift },
+	// there's no combined Windows key virtual-key code as there is with the others
+	{ VK_LWIN, uiModifierSuper },
+	{ VK_RWIN, uiModifierSuper },
+	{ VK_SNAPSHOT, 0 },
+};
+
+static int areaKeyEvent(uiArea *a, int up, WPARAM wParam, LPARAM lParam)
+{
+	uiAreaKeyEvent ke;
+	int righthand;
+	int i;
+
+	ke.Key = 0;
+	ke.ExtKey = 0;
+	ke.Modifier = 0;
+
+	ke.Modifiers = getModifiers();
+
+	ke.Up = up;
+
+	// the numeric keypad keys when Num Lock is off are considered left-hand keys as the separate navigation buttons were added later
+	// the numeric keypad Enter, however, is a right-hand key because it has the same virtual-key code as the typewriter Enter
+	righthand = (lParam & 0x01000000) != 0;
+	if (righthand) {
+		if (wParam == VK_RETURN) {
+			ke.ExtKey = uiExtKeyNEnter;
+			goto keyFound;
+		}
+	} else
+		// this is special handling for numpad keys to ignore the state of Num Lock and Shift; see http://blogs.msdn.com/b/oldnewthing/archive/2004/09/06/226045.aspx and https://github.com/glfw/glfw/blob/master/src/win32_window.c#L152
+		for (i = 0; numpadExtKeys[i].vk != VK_SNAPSHOT; i++)
+			if (numpadExtKeys[i].vk == wParam) {
+				ke.ExtKey = numpadExtKeys[i].extkey;
+				goto keyFound;
+			}
+
+	// okay, those above cases didn't match anything
+	// first try the extended keys
+	for (i = 0; extKeys[i].vk != VK_SNAPSHOT; i++)
+		if (extKeys[i].vk == wParam) {
+			ke.ExtKey = extKeys[i].extkey;
+			goto keyFound;
+		}
+
+	// then try modifier keys
+	for (i = 0; modKeys[i].vk != VK_SNAPSHOT; i++)
+		if (modKeys[i].vk == wParam) {
+			ke.Modifier = modKeys[i].mod;
+			// and don't include the key in Modifiers
+			ke.Modifiers &= ~ke.Modifier;
+			goto keyFound;
+		}
+
+	// and finally everything else
+	if (fromScancode((lParam >> 16) & 0xFF, &ke))
+		goto keyFound;
+
+	// not a supported key, assume unhandled
+	// TODO the original code only did this if ke.Modifiers == 0 - why?
+	return 0;
+
+keyFound:
+	return (*(a->ah->KeyEvent))(a->ah, a, &ke);
+}
+
+// We don't handle the standard Windows keyboard messages directly, to avoid both the dialog manager and TranslateMessage().
+// Instead, we set up a message filter and do things there.
+// That stuff is later in this file.
+enum {
+	// start at 0x40 to avoid clobbering dialog messages
+	msgAreaKeyDown = WM_USER + 0x40,
+	msgAreaKeyUp,
+};
+
+BOOL areaDoEvents(uiArea *a, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *lResult)
+{
+	switch (uMsg) {
+	case WM_ACTIVATE:
+		// don't keep the double-click timer running if the user switched programs in between clicks
+		clickCounterReset(&(a->cc));
+		*lResult = 0;
+		return TRUE;
+	case WM_MOUSEMOVE:
+		onMouseEntered(a);
+		areaMouseEvent(a, 0, 0, wParam, lParam);
+		*lResult = 0;
+		return TRUE;
+	case WM_MOUSELEAVE:
+		onMouseLeft(a);
+		*lResult = 0;
+		return TRUE;
+	case WM_LBUTTONDOWN:
+		SetFocus(a->hwnd);
+		areaMouseEvent(a, 1, 0, wParam, lParam);
+		*lResult = 0;
+		return TRUE;
+	case WM_LBUTTONUP:
+		areaMouseEvent(a, 0, 1, wParam, lParam);
+		*lResult = 0;
+		return TRUE;
+	case WM_MBUTTONDOWN:
+		SetFocus(a->hwnd);
+		areaMouseEvent(a, 2, 0, wParam, lParam);
+		*lResult = 0;
+		return TRUE;
+	case WM_MBUTTONUP:
+		areaMouseEvent(a, 0, 2, wParam, lParam);
+		*lResult = 0;
+		return TRUE;
+	case WM_RBUTTONDOWN:
+		SetFocus(a->hwnd);
+		areaMouseEvent(a, 3, 0, wParam, lParam);
+		*lResult = 0;
+		return TRUE;
+	case WM_RBUTTONUP:
+		areaMouseEvent(a, 0, 3, wParam, lParam);
+		*lResult = 0;
+		return TRUE;
+	case WM_XBUTTONDOWN:
+		SetFocus(a->hwnd);
+		// values start at 1; we want them to start at 4
+		areaMouseEvent(a,
+			GET_XBUTTON_WPARAM(wParam) + 3, 0,
+			GET_KEYSTATE_WPARAM(wParam), lParam);
+		*lResult = TRUE;	// XBUTTON messages are different!
+		return TRUE;
+	case WM_XBUTTONUP:
+		areaMouseEvent(a,
+			0, GET_XBUTTON_WPARAM(wParam) + 3,
+			GET_KEYSTATE_WPARAM(wParam), lParam);
+		*lResult = TRUE;	// XBUTTON messages are different!
+		return TRUE;
+	case WM_CAPTURECHANGED:
+		if (a->capturing) {
+			a->capturing = FALSE;
+			(*(a->ah->DragBroken))(a->ah, a);
+		}
+		*lResult = 0;
+		return TRUE;
+	case msgAreaKeyDown:
+		*lResult = (LRESULT) areaKeyEvent(a, 0, wParam, lParam);
+		return TRUE;
+	case msgAreaKeyUp:
+		*lResult = (LRESULT) areaKeyEvent(a, 1, wParam, lParam);
+		return TRUE;
+	}
+	return FALSE;
+}
+
+// TODO affect visibility properly
+// TODO what did this mean
+BOOL areaFilter(MSG *msg)
+{
+	LRESULT handled;
+
+	// is the recipient an area?
+	if (msg->hwnd == NULL)		// this can happen; for example, WM_TIMER
+		return FALSE;
+	if (windowClassOf(msg->hwnd, areaClass, NULL) != 0)
+		return FALSE;			// nope
+
+	handled = 0;
+	switch (msg->message) {
+	case WM_KEYDOWN:
+	case WM_SYSKEYDOWN:
+		handled = SendMessageW(msg->hwnd, msgAreaKeyDown, msg->wParam, msg->lParam);
+		break;
+	case WM_KEYUP:
+	case WM_SYSKEYUP:
+		handled = SendMessageW(msg->hwnd, msgAreaKeyUp, msg->wParam, msg->lParam);
+		break;
+	// otherwise handled remains 0, as we didn't handle this
+	}
+	return (BOOL) handled;
+}
diff --git a/src/libui_sdl/libui/windows/areascroll.cpp b/src/libui_sdl/libui/windows/areascroll.cpp
new file mode 100644
index 0000000..f18d0ad
--- /dev/null
+++ b/src/libui_sdl/libui/windows/areascroll.cpp
@@ -0,0 +1,247 @@
+// 8 september 2015
+#include "uipriv_windows.hpp"
+#include "area.hpp"
+
+// TODO
+// - move from pixels to points somehow
+// 	- add a function to offset points and rects by scrolling amounts; call it from doPaint() in areadraw.c
+// - recalculate scrolling after:
+// 	- creation?
+// 	- resize?
+// 	- recreating the render target? (after moving to points)
+// - error if these are called without scrollbars?
+
+struct scrollParams {
+	int *pos;
+	int pagesize;
+	int length;
+	int *wheelCarry;
+	UINT wheelSPIAction;
+};
+
+static void scrollto(uiArea *a, int which, struct scrollParams *p, int pos)
+{
+	SCROLLINFO si;
+
+	// note that the pos < 0 check is /after/ the p->length - p->pagesize check
+	// it used to be /before/; this was actually a bug in Raymond Chen's original algorithm: if there are fewer than a page's worth of items, p->length - p->pagesize will be negative and our content draw at the bottom of the window
+	// this SHOULD have the same effect with that bug fixed and no others introduced... (thanks to devin on irc.badnik.net for confirming this logic)
+	if (pos > p->length - p->pagesize)
+		pos = p->length - p->pagesize;
+	if (pos < 0)
+		pos = 0;
+
+	// Direct2D doesn't have a method for scrolling the existing contents of a render target.
+	// We'll have to just invalidate everything and hope for the best.
+	invalidateRect(a->hwnd, NULL, FALSE);
+
+	*(p->pos) = pos;
+
+	// now commit our new scrollbar setup...
+	ZeroMemory(&si, sizeof (SCROLLINFO));
+	si.cbSize = sizeof (SCROLLINFO);
+	si.fMask = SIF_PAGE | SIF_POS | SIF_RANGE;
+	si.nPage = p->pagesize;
+	si.nMin = 0;
+	si.nMax = p->length - 1;		// endpoint inclusive
+	si.nPos = *(p->pos);
+	SetScrollInfo(a->hwnd, which, &si, TRUE);
+}
+
+static void scrollby(uiArea *a, int which, struct scrollParams *p, int delta)
+{
+	scrollto(a, which, p, *(p->pos) + delta);
+}
+
+static void scroll(uiArea *a, int which, struct scrollParams *p, WPARAM wParam, LPARAM lParam)
+{
+	int pos;
+	SCROLLINFO si;
+
+	pos = *(p->pos);
+	switch (LOWORD(wParam)) {
+	case SB_LEFT:			// also SB_TOP
+		pos = 0;
+		break;
+	case SB_RIGHT:		// also SB_BOTTOM
+		pos = p->length - p->pagesize;
+		break;
+	case SB_LINELEFT:		// also SB_LINEUP
+		pos--;
+		break;
+	case SB_LINERIGHT:		// also SB_LINEDOWN
+		pos++;
+		break;
+	case SB_PAGELEFT:		// also SB_PAGEUP
+		pos -= p->pagesize;
+		break;
+	case SB_PAGERIGHT:	// also SB_PAGEDOWN
+		pos += p->pagesize;
+		break;
+	case SB_THUMBPOSITION:
+		ZeroMemory(&si, sizeof (SCROLLINFO));
+		si.cbSize = sizeof (SCROLLINFO);
+		si.fMask = SIF_POS;
+		if (GetScrollInfo(a->hwnd, which, &si) == 0)
+			logLastError(L"error getting thumb position for area");
+		pos = si.nPos;
+		break;
+	case SB_THUMBTRACK:
+		ZeroMemory(&si, sizeof (SCROLLINFO));
+		si.cbSize = sizeof (SCROLLINFO);
+		si.fMask = SIF_TRACKPOS;
+		if (GetScrollInfo(a->hwnd, which, &si) == 0)
+			logLastError(L"error getting thumb track position for area");
+		pos = si.nTrackPos;
+		break;
+	}
+	scrollto(a, which, p, pos);
+}
+
+static void wheelscroll(uiArea *a, int which, struct scrollParams *p, WPARAM wParam, LPARAM lParam)
+{
+	int delta;
+	int lines;
+	UINT scrollAmount;
+
+	delta = GET_WHEEL_DELTA_WPARAM(wParam);
+	if (SystemParametersInfoW(p->wheelSPIAction, 0, &scrollAmount, 0) == 0)
+		// TODO use scrollAmount == 3 (for both v and h) instead?
+		logLastError(L"error getting area wheel scroll amount");
+	if (scrollAmount == WHEEL_PAGESCROLL)
+		scrollAmount = p->pagesize;
+	if (scrollAmount == 0)		// no mouse wheel scrolling (or t->pagesize == 0)
+		return;
+	// the rest of this is basically http://blogs.msdn.com/b/oldnewthing/archive/2003/08/07/54615.aspx and http://blogs.msdn.com/b/oldnewthing/archive/2003/08/11/54624.aspx
+	// see those pages for information on subtleties
+	delta += *(p->wheelCarry);
+	lines = delta * ((int) scrollAmount) / WHEEL_DELTA;
+	*(p->wheelCarry) = delta - lines * WHEEL_DELTA / ((int) scrollAmount);
+	scrollby(a, which, p, -lines);
+}
+
+static void hscrollParams(uiArea *a, struct scrollParams *p)
+{
+	RECT r;
+
+	ZeroMemory(p, sizeof (struct scrollParams));
+	p->pos = &(a->hscrollpos);
+	// TODO get rid of these and replace with points
+	uiWindowsEnsureGetClientRect(a->hwnd, &r);
+	p->pagesize = r.right - r.left;
+	p->length = a->scrollWidth;
+	p->wheelCarry = &(a->hwheelCarry);
+	p->wheelSPIAction = SPI_GETWHEELSCROLLCHARS;
+}
+
+static void hscrollto(uiArea *a, int pos)
+{
+	struct scrollParams p;
+
+	hscrollParams(a, &p);
+	scrollto(a, SB_HORZ, &p, pos);
+}
+
+static void hscrollby(uiArea *a, int delta)
+{
+	struct scrollParams p;
+
+	hscrollParams(a, &p);
+	scrollby(a, SB_HORZ, &p, delta);
+}
+
+static void hscroll(uiArea *a, WPARAM wParam, LPARAM lParam)
+{
+	struct scrollParams p;
+
+	hscrollParams(a, &p);
+	scroll(a, SB_HORZ, &p, wParam, lParam);
+}
+
+static void hwheelscroll(uiArea *a, WPARAM wParam, LPARAM lParam)
+{
+	struct scrollParams p;
+
+	hscrollParams(a, &p);
+	wheelscroll(a, SB_HORZ, &p, wParam, lParam);
+}
+
+static void vscrollParams(uiArea *a, struct scrollParams *p)
+{
+	RECT r;
+
+	ZeroMemory(p, sizeof (struct scrollParams));
+	p->pos = &(a->vscrollpos);
+	uiWindowsEnsureGetClientRect(a->hwnd, &r);
+	p->pagesize = r.bottom - r.top;
+	p->length = a->scrollHeight;
+	p->wheelCarry = &(a->vwheelCarry);
+	p->wheelSPIAction = SPI_GETWHEELSCROLLLINES;
+}
+
+static void vscrollto(uiArea *a, int pos)
+{
+	struct scrollParams p;
+
+	vscrollParams(a, &p);
+	scrollto(a, SB_VERT, &p, pos);
+}
+
+static void vscrollby(uiArea *a, int delta)
+{
+	struct scrollParams p;
+
+	vscrollParams(a, &p);
+	scrollby(a, SB_VERT, &p, delta);
+}
+
+static void vscroll(uiArea *a, WPARAM wParam, LPARAM lParam)
+{
+	struct scrollParams p;
+
+	vscrollParams(a, &p);
+	scroll(a, SB_VERT, &p, wParam, lParam);
+}
+
+static void vwheelscroll(uiArea *a, WPARAM wParam, LPARAM lParam)
+{
+	struct scrollParams p;
+
+	vscrollParams(a, &p);
+	wheelscroll(a, SB_VERT, &p, wParam, lParam);
+}
+
+BOOL areaDoScroll(uiArea *a, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *lResult)
+{
+	switch (uMsg) {
+	case WM_HSCROLL:
+		hscroll(a, wParam, lParam);
+		*lResult = 0;
+		return TRUE;
+	case WM_MOUSEHWHEEL:
+		hwheelscroll(a, wParam, lParam);
+		*lResult = 0;
+		return TRUE;
+	case WM_VSCROLL:
+		vscroll(a, wParam, lParam);
+		*lResult = 0;
+		return TRUE;
+	case WM_MOUSEWHEEL:
+		vwheelscroll(a, wParam, lParam);
+		*lResult = 0;
+		return TRUE;
+	}
+	return FALSE;
+}
+
+void areaScrollOnResize(uiArea *a, RECT *client)
+{
+	areaUpdateScroll(a);
+}
+
+void areaUpdateScroll(uiArea *a)
+{
+	// use a no-op scroll to simulate scrolling
+	hscrollby(a, 0);
+	vscrollby(a, 0);
+}
diff --git a/src/libui_sdl/libui/windows/areautil.cpp b/src/libui_sdl/libui/windows/areautil.cpp
new file mode 100644
index 0000000..9dc72fb
--- /dev/null
+++ b/src/libui_sdl/libui/windows/areautil.cpp
@@ -0,0 +1,37 @@
+// 18 december 2015
+#include "uipriv_windows.hpp"
+#include "area.hpp"
+
+void loadAreaSize(uiArea *a, ID2D1RenderTarget *rt, double *width, double *height)
+{
+	D2D1_SIZE_F size;
+
+	*width = 0;
+	*height = 0;
+	if (!a->scrolling) {
+		if (rt == NULL)
+			rt = a->rt;
+		size = realGetSize(rt);
+		*width = size.width;
+		*height = size.height;
+	}
+}
+
+void pixelsToDIP(uiArea *a, double *x, double *y)
+{
+	FLOAT dpix, dpiy;
+
+	a->rt->GetDpi(&dpix, &dpiy);
+	// see https://msdn.microsoft.com/en-us/library/windows/desktop/dd756649%28v=vs.85%29.aspx (and others; search "direct2d mouse")
+	*x = (*x * 96) / dpix;
+	*y = (*y * 96) / dpiy;
+}
+
+void dipToPixels(uiArea *a, double *x, double *y)
+{
+	FLOAT dpix, dpiy;
+
+	a->rt->GetDpi(&dpix, &dpiy);
+	*x = (*x * dpix) / 96;
+	*y = (*y * dpiy) / 96;
+}
diff --git a/src/libui_sdl/libui/windows/box.cpp b/src/libui_sdl/libui/windows/box.cpp
new file mode 100644
index 0000000..9567954
--- /dev/null
+++ b/src/libui_sdl/libui/windows/box.cpp
@@ -0,0 +1,320 @@
+// 7 april 2015
+#include "uipriv_windows.hpp"
+
+struct boxChild {
+	uiControl *c;
+	int stretchy;
+	int width;
+	int height;
+};
+
+struct uiBox {
+	uiWindowsControl c;
+	HWND hwnd;
+	std::vector<struct boxChild> *controls;
+	int vertical;
+	int padded;
+};
+
+static void boxPadding(uiBox *b, int *xpadding, int *ypadding)
+{
+	uiWindowsSizing sizing;
+
+	*xpadding = 0;
+	*ypadding = 0;
+	if (b->padded) {
+		uiWindowsGetSizing(b->hwnd, &sizing);
+		uiWindowsSizingStandardPadding(&sizing, xpadding, ypadding);
+	}
+}
+
+static void boxRelayout(uiBox *b)
+{
+	RECT r;
+	int x, y, width, height;
+	int xpadding, ypadding;
+	int nStretchy;
+	int stretchywid, stretchyht;
+	int i;
+	int minimumWidth, minimumHeight;
+	int nVisible;
+	uiWindowsSizing *d;
+
+	if (b->controls->size() == 0)
+		return;
+
+	uiWindowsEnsureGetClientRect(b->hwnd, &r);
+	x = r.left;
+	y = r.top;
+	width = r.right - r.left;
+	height = r.bottom - r.top;
+
+	// -1) get this Box's padding
+	boxPadding(b, &xpadding, &ypadding);
+
+	// 1) get width and height of non-stretchy controls
+	// this will tell us how much space will be left for stretchy controls
+	stretchywid = width;
+	stretchyht = height;
+	nStretchy = 0;
+	nVisible = 0;
+	for (struct boxChild &bc : *(b->controls)) {
+		if (!uiControlVisible(bc.c))
+			continue;
+		nVisible++;
+		if (bc.stretchy) {
+			nStretchy++;
+			continue;
+		}
+		uiWindowsControlMinimumSize(uiWindowsControl(bc.c), &minimumWidth, &minimumHeight);
+		if (b->vertical) {		// all controls have same width
+			bc.width = width;
+			bc.height = minimumHeight;
+			stretchyht -= minimumHeight;
+		} else {				// all controls have same height
+			bc.width = minimumWidth;
+			bc.height = height;
+			stretchywid -= minimumWidth;
+		}
+	}
+	if (nVisible == 0)			// nothing to do
+		return;
+
+	// 2) now inset the available rect by the needed padding
+	if (b->vertical) {
+		height -= (nVisible - 1) * ypadding;
+		stretchyht -= (nVisible - 1) * ypadding;
+	} else {
+		width -= (nVisible - 1) * xpadding;
+		stretchywid -= (nVisible - 1) * xpadding;
+	}
+
+	// 3) now get the size of stretchy controls
+	if (nStretchy != 0) {
+		if (b->vertical)
+			stretchyht /= nStretchy;
+		else
+			stretchywid /= nStretchy;
+		for (struct boxChild &bc : *(b->controls)) {
+			if (!uiControlVisible(bc.c))
+				continue;
+			if (bc.stretchy) {
+				bc.width = stretchywid;
+				bc.height = stretchyht;
+			}
+		}
+	}
+
+	// 4) now we can position controls
+	// first, make relative to the top-left corner of the container
+	x = 0;
+	y = 0;
+	for (const struct boxChild &bc : *(b->controls)) {
+		if (!uiControlVisible(bc.c))
+			continue;
+		uiWindowsEnsureMoveWindowDuringResize((HWND) uiControlHandle(bc.c), x, y, bc.width, bc.height);
+		if (b->vertical)
+			y += bc.height + ypadding;
+		else
+			x += bc.width + xpadding;
+	}
+}
+
+static void uiBoxDestroy(uiControl *c)
+{
+	uiBox *b = uiBox(c);
+
+	for (const struct boxChild &bc : *(b->controls)) {
+		uiControlSetParent(bc.c, NULL);
+		uiControlDestroy(bc.c);
+	}
+	delete b->controls;
+	uiWindowsEnsureDestroyWindow(b->hwnd);
+	uiFreeControl(uiControl(b));
+}
+
+uiWindowsControlDefaultHandle(uiBox)
+uiWindowsControlDefaultParent(uiBox)
+uiWindowsControlDefaultSetParent(uiBox)
+uiWindowsControlDefaultToplevel(uiBox)
+uiWindowsControlDefaultVisible(uiBox)
+uiWindowsControlDefaultShow(uiBox)
+uiWindowsControlDefaultHide(uiBox)
+uiWindowsControlDefaultEnabled(uiBox)
+uiWindowsControlDefaultEnable(uiBox)
+uiWindowsControlDefaultDisable(uiBox)
+
+static void uiBoxSyncEnableState(uiWindowsControl *c, int enabled)
+{
+	uiBox *b = uiBox(c);
+
+	if (uiWindowsShouldStopSyncEnableState(uiWindowsControl(b), enabled))
+		return;
+	for (const struct boxChild &bc : *(b->controls))
+		uiWindowsControlSyncEnableState(uiWindowsControl(bc.c), enabled);
+}
+
+uiWindowsControlDefaultSetParentHWND(uiBox)
+
+static void uiBoxMinimumSize(uiWindowsControl *c, int *width, int *height)
+{
+	uiBox *b = uiBox(c);
+	int xpadding, ypadding;
+	int nStretchy;
+	// these two contain the largest minimum width and height of all stretchy controls in the box
+	// all stretchy controls will use this value to determine the final minimum size
+	int maxStretchyWidth, maxStretchyHeight;
+	int i;
+	int minimumWidth, minimumHeight;
+	int nVisible;
+	uiWindowsSizing sizing;
+
+	*width = 0;
+	*height = 0;
+	if (b->controls->size() == 0)
+		return;
+
+	// 0) get this Box's padding
+	boxPadding(b, &xpadding, &ypadding);
+
+	// 1) add in the size of non-stretchy controls and get (but not add in) the largest widths and heights of stretchy controls
+	// we still add in like direction of stretchy controls
+	nStretchy = 0;
+	maxStretchyWidth = 0;
+	maxStretchyHeight = 0;
+	nVisible = 0;
+	for (const struct boxChild &bc : *(b->controls)) {
+		if (!uiControlVisible(bc.c))
+			continue;
+		nVisible++;
+		uiWindowsControlMinimumSize(uiWindowsControl(bc.c), &minimumWidth, &minimumHeight);
+		if (bc.stretchy) {
+			nStretchy++;
+			if (maxStretchyWidth < minimumWidth)
+				maxStretchyWidth = minimumWidth;
+			if (maxStretchyHeight < minimumHeight)
+				maxStretchyHeight = minimumHeight;
+		}
+		if (b->vertical) {
+			if (*width < minimumWidth)
+				*width = minimumWidth;
+			if (!bc.stretchy)
+				*height += minimumHeight;
+		} else {
+			if (!bc.stretchy)
+				*width += minimumWidth;
+			if (*height < minimumHeight)
+				*height = minimumHeight;
+		}
+	}
+	if (nVisible == 0)		// just return 0x0
+		return;
+
+	// 2) now outset the desired rect with the needed padding
+	if (b->vertical)
+		*height += (nVisible - 1) * ypadding;
+	else
+		*width += (nVisible - 1) * xpadding;
+
+	// 3) and now we can add in stretchy controls
+	if (b->vertical)
+		*height += nStretchy * maxStretchyHeight;
+	else
+		*width += nStretchy * maxStretchyWidth;
+}
+
+static void uiBoxMinimumSizeChanged(uiWindowsControl *c)
+{
+	uiBox *b = uiBox(c);
+
+	if (uiWindowsControlTooSmall(uiWindowsControl(b))) {
+		uiWindowsControlContinueMinimumSizeChanged(uiWindowsControl(b));
+		return;
+	}
+	boxRelayout(b);
+}
+
+uiWindowsControlDefaultLayoutRect(uiBox)
+uiWindowsControlDefaultAssignControlIDZOrder(uiBox)
+
+static void uiBoxChildVisibilityChanged(uiWindowsControl *c)
+{
+	// TODO eliminate the redundancy
+	uiWindowsControlMinimumSizeChanged(c);
+}
+
+static void boxArrangeChildren(uiBox *b)
+{
+	LONG_PTR controlID;
+	HWND insertAfter;
+
+	controlID = 100;
+	insertAfter = NULL;
+	for (const struct boxChild &bc : *(b->controls))
+		uiWindowsControlAssignControlIDZOrder(uiWindowsControl(bc.c), &controlID, &insertAfter);
+}
+
+void uiBoxAppend(uiBox *b, uiControl *c, int stretchy)
+{
+	struct boxChild bc;
+
+	bc.c = c;
+	bc.stretchy = stretchy;
+	uiControlSetParent(bc.c, uiControl(b));
+	uiWindowsControlSetParentHWND(uiWindowsControl(bc.c), b->hwnd);
+	b->controls->push_back(bc);
+	boxArrangeChildren(b);
+	uiWindowsControlMinimumSizeChanged(uiWindowsControl(b));
+}
+
+void uiBoxDelete(uiBox *b, int index)
+{
+	uiControl *c;
+
+	c = (*(b->controls))[index].c;
+	uiControlSetParent(c, NULL);
+	uiWindowsControlSetParentHWND(uiWindowsControl(c), NULL);
+	b->controls->erase(b->controls->begin() + index);
+	boxArrangeChildren(b);
+	uiWindowsControlMinimumSizeChanged(uiWindowsControl(b));
+}
+
+int uiBoxPadded(uiBox *b)
+{
+	return b->padded;
+}
+
+void uiBoxSetPadded(uiBox *b, int padded)
+{
+	b->padded = padded;
+	uiWindowsControlMinimumSizeChanged(uiWindowsControl(b));
+}
+
+static void onResize(uiWindowsControl *c)
+{
+	boxRelayout(uiBox(c));
+}
+
+static uiBox *finishNewBox(int vertical)
+{
+	uiBox *b;
+
+	uiWindowsNewControl(uiBox, b);
+
+	b->hwnd = uiWindowsMakeContainer(uiWindowsControl(b), onResize);
+
+	b->vertical = vertical;
+	b->controls = new std::vector<struct boxChild>;
+
+	return b;
+}
+
+uiBox *uiNewHorizontalBox(void)
+{
+	return finishNewBox(0);
+}
+
+uiBox *uiNewVerticalBox(void)
+{
+	return finishNewBox(1);
+}
diff --git a/src/libui_sdl/libui/windows/button.cpp b/src/libui_sdl/libui/windows/button.cpp
new file mode 100644
index 0000000..3b12e72
--- /dev/null
+++ b/src/libui_sdl/libui/windows/button.cpp
@@ -0,0 +1,104 @@
+// 7 april 2015
+#include "uipriv_windows.hpp"
+
+struct uiButton {
+	uiWindowsControl c;
+	HWND hwnd;
+	void (*onClicked)(uiButton *, void *);
+	void *onClickedData;
+};
+
+static BOOL onWM_COMMAND(uiControl *c, HWND hwnd, WORD code, LRESULT *lResult)
+{
+	uiButton *b = uiButton(c);
+
+	if (code != BN_CLICKED)
+		return FALSE;
+	(*(b->onClicked))(b, b->onClickedData);
+	*lResult = 0;
+	return TRUE;
+}
+
+static void uiButtonDestroy(uiControl *c)
+{
+	uiButton *b = uiButton(c);
+
+	uiWindowsUnregisterWM_COMMANDHandler(b->hwnd);
+	uiWindowsEnsureDestroyWindow(b->hwnd);
+	uiFreeControl(uiControl(b));
+}
+
+uiWindowsControlAllDefaultsExceptDestroy(uiButton)
+
+// from http://msdn.microsoft.com/en-us/library/windows/desktop/dn742486.aspx#sizingandspacing
+#define buttonHeight 14
+
+static void uiButtonMinimumSize(uiWindowsControl *c, int *width, int *height)
+{
+	uiButton *b = uiButton(c);
+	SIZE size;
+	uiWindowsSizing sizing;
+	int y;
+
+	// try the comctl32 version 6 way
+	size.cx = 0;		// explicitly ask for ideal size
+	size.cy = 0;
+	if (SendMessageW(b->hwnd, BCM_GETIDEALSIZE, 0, (LPARAM) (&size)) != FALSE) {
+		*width = size.cx;
+		*height = size.cy;
+		return;
+	}
+
+	// that didn't work; fall back to using Microsoft's metrics
+	// Microsoft says to use a fixed width for all buttons; this isn't good enough
+	// use the text width instead, with some edge padding
+	*width = uiWindowsWindowTextWidth(b->hwnd) + (2 * GetSystemMetrics(SM_CXEDGE));
+	y = buttonHeight;
+	uiWindowsGetSizing(b->hwnd, &sizing);
+	uiWindowsSizingDlgUnitsToPixels(&sizing, NULL, &y);
+	*height = y;
+}
+
+static void defaultOnClicked(uiButton *b, void *data)
+{
+	// do nothing
+}
+
+char *uiButtonText(uiButton *b)
+{
+	return uiWindowsWindowText(b->hwnd);
+}
+
+void uiButtonSetText(uiButton *b, const char *text)
+{
+	uiWindowsSetWindowText(b->hwnd, text);
+	// changing the text might necessitate a change in the button's size
+	uiWindowsControlMinimumSizeChanged(uiWindowsControl(b));
+}
+
+void uiButtonOnClicked(uiButton *b, void (*f)(uiButton *, void *), void *data)
+{
+	b->onClicked = f;
+	b->onClickedData = data;
+}
+
+uiButton *uiNewButton(const char *text)
+{
+	uiButton *b;
+	WCHAR *wtext;
+
+	uiWindowsNewControl(uiButton, b);
+
+	wtext = toUTF16(text);
+	b->hwnd = uiWindowsEnsureCreateControlHWND(0,
+		L"button", wtext,
+		BS_PUSHBUTTON | WS_TABSTOP,
+		hInstance, NULL,
+		TRUE);
+	uiFree(wtext);
+
+	uiWindowsRegisterWM_COMMANDHandler(b->hwnd, onWM_COMMAND, uiControl(b));
+	uiButtonOnClicked(b, defaultOnClicked, NULL);
+
+	return b;
+}
diff --git a/src/libui_sdl/libui/windows/checkbox.cpp b/src/libui_sdl/libui/windows/checkbox.cpp
new file mode 100644
index 0000000..be425c0
--- /dev/null
+++ b/src/libui_sdl/libui/windows/checkbox.cpp
@@ -0,0 +1,117 @@
+// 7 april 2015
+#include "uipriv_windows.hpp"
+
+struct uiCheckbox {
+	uiWindowsControl c;
+	HWND hwnd;
+	void (*onToggled)(uiCheckbox *, void *);
+	void *onToggledData;
+};
+
+static BOOL onWM_COMMAND(uiControl *cc, HWND hwnd, WORD code, LRESULT *lResult)
+{
+	uiCheckbox *c = uiCheckbox(cc);
+	WPARAM check;
+
+	if (code != BN_CLICKED)
+		return FALSE;
+
+	// we didn't use BS_AUTOCHECKBOX (http://blogs.msdn.com/b/oldnewthing/archive/2014/05/22/10527522.aspx) so we have to manage the check state ourselves
+	check = BST_CHECKED;
+	if (SendMessage(c->hwnd, BM_GETCHECK, 0, 0) == BST_CHECKED)
+		check = BST_UNCHECKED;
+	SendMessage(c->hwnd, BM_SETCHECK, check, 0);
+
+	(*(c->onToggled))(c, c->onToggledData);
+	*lResult = 0;
+	return TRUE;
+}
+
+static void uiCheckboxDestroy(uiControl *cc)
+{
+	uiCheckbox *c = uiCheckbox(cc);
+
+	uiWindowsUnregisterWM_COMMANDHandler(c->hwnd);
+	uiWindowsEnsureDestroyWindow(c->hwnd);
+	uiFreeControl(uiControl(c));
+}
+
+uiWindowsControlAllDefaultsExceptDestroy(uiCheckbox)
+
+// from http://msdn.microsoft.com/en-us/library/windows/desktop/dn742486.aspx#sizingandspacing
+#define checkboxHeight 10
+// from http://msdn.microsoft.com/en-us/library/windows/desktop/bb226818%28v=vs.85%29.aspx
+#define checkboxXFromLeftOfBoxToLeftOfLabel 12
+
+static void uiCheckboxMinimumSize(uiWindowsControl *cc, int *width, int *height)
+{
+	uiCheckbox *c = uiCheckbox(cc);
+	uiWindowsSizing sizing;
+	int x, y;
+
+	x = checkboxXFromLeftOfBoxToLeftOfLabel;
+	y = checkboxHeight;
+	uiWindowsGetSizing(c->hwnd, &sizing);
+	uiWindowsSizingDlgUnitsToPixels(&sizing, &x, &y);
+	*width = x + uiWindowsWindowTextWidth(c->hwnd);
+	*height = y;
+}
+
+static void defaultOnToggled(uiCheckbox *c, void *data)
+{
+	// do nothing
+}
+
+char *uiCheckboxText(uiCheckbox *c)
+{
+	return uiWindowsWindowText(c->hwnd);
+}
+
+void uiCheckboxSetText(uiCheckbox *c, const char *text)
+{
+	uiWindowsSetWindowText(c->hwnd, text);
+	// changing the text might necessitate a change in the checkbox's size
+	uiWindowsControlMinimumSizeChanged(uiWindowsControl(c));
+}
+
+void uiCheckboxOnToggled(uiCheckbox *c, void (*f)(uiCheckbox *, void *), void *data)
+{
+	c->onToggled = f;
+	c->onToggledData = data;
+}
+
+int uiCheckboxChecked(uiCheckbox *c)
+{
+	return SendMessage(c->hwnd, BM_GETCHECK, 0, 0) == BST_CHECKED;
+}
+
+void uiCheckboxSetChecked(uiCheckbox *c, int checked)
+{
+	WPARAM check;
+
+	check = BST_CHECKED;
+	if (!checked)
+		check = BST_UNCHECKED;
+	SendMessage(c->hwnd, BM_SETCHECK, check, 0);
+}
+
+uiCheckbox *uiNewCheckbox(const char *text)
+{
+	uiCheckbox *c;
+	WCHAR *wtext;
+
+	uiWindowsNewControl(uiCheckbox, c);
+
+	wtext = toUTF16(text);
+	c->hwnd = uiWindowsEnsureCreateControlHWND(0,
+		L"button", wtext,
+		BS_CHECKBOX | WS_TABSTOP,
+		hInstance, NULL,
+		TRUE);
+	uiFree(wtext);
+
+	uiWindowsRegisterWM_COMMANDHandler(c->hwnd, onWM_COMMAND, uiControl(c));
+	uiCheckboxOnToggled(c, defaultOnToggled, NULL);
+
+	return c;
+}
diff --git a/src/libui_sdl/libui/windows/colorbutton.cpp b/src/libui_sdl/libui/windows/colorbutton.cpp
new file mode 100644
index 0000000..c1ba695
--- /dev/null
+++ b/src/libui_sdl/libui/windows/colorbutton.cpp
@@ -0,0 +1,192 @@
+// 16 may 2016
+#include "uipriv_windows.hpp"
+
+struct uiColorButton {
+	uiWindowsControl c;
+	HWND hwnd;
+	double r;
+	double g;
+	double b;
+	double a;
+	void (*onChanged)(uiColorButton *, void *);
+	void *onChangedData;
+};
+
+static void uiColorButtonDestroy(uiControl *c)
+{
+	uiColorButton *b = uiColorButton(c);
+
+	uiWindowsUnregisterWM_COMMANDHandler(b->hwnd);
+	uiWindowsUnregisterWM_NOTIFYHandler(b->hwnd);
+	uiWindowsEnsureDestroyWindow(b->hwnd);
+	uiFreeControl(uiControl(b));
+}
+
+static BOOL onWM_COMMAND(uiControl *c, HWND hwnd, WORD code, LRESULT *lResult)
+{
+	uiColorButton *b = uiColorButton(c);
+	HWND parent;
+	struct colorDialogRGBA rgba;
+
+	if (code != BN_CLICKED)
+		return FALSE;
+
+	parent = parentToplevel(b->hwnd);
+	rgba.r = b->r;
+	rgba.g = b->g;
+	rgba.b = b->b;
+	rgba.a = b->a;
+	if (showColorDialog(parent, &rgba)) {
+		b->r = rgba.r;
+		b->g = rgba.g;
+		b->b = rgba.b;
+		b->a = rgba.a;
+		invalidateRect(b->hwnd, NULL, TRUE);
+		(*(b->onChanged))(b, b->onChangedData);
+	}
+
+	*lResult = 0;
+	return TRUE;
+}
+
+static BOOL onWM_NOTIFY(uiControl *c, HWND hwnd, NMHDR *nmhdr, LRESULT *lResult)
+{
+	uiColorButton *b = uiColorButton(c);
+	NMCUSTOMDRAW *nm = (NMCUSTOMDRAW *) nmhdr;
+	RECT client;
+	ID2D1DCRenderTarget *rt;
+	D2D1_RECT_F r;
+	D2D1_COLOR_F color;
+	D2D1_BRUSH_PROPERTIES bprop;
+	ID2D1SolidColorBrush *brush;
+	uiWindowsSizing sizing;
+	int x, y;
+	HRESULT hr;
+
+	if (nmhdr->code != NM_CUSTOMDRAW)
+		return FALSE;
+	// and allow the button to draw its background
+	if (nm->dwDrawStage != CDDS_PREPAINT)
+		return FALSE;
+
+	uiWindowsEnsureGetClientRect(b->hwnd, &client);
+	rt = makeHDCRenderTarget(nm->hdc, &client);
+	rt->BeginDraw();
+
+	uiWindowsGetSizing(b->hwnd, &sizing);
+	x = 3;		// should be enough
+	y = 3;
+	uiWindowsSizingDlgUnitsToPixels(&sizing, &x, &y);
+	r.left = client.left + x;
+	r.top = client.top + y;
+	r.right = client.right - x;
+	r.bottom = client.bottom - y;
+
+	color.r = b->r;
+	color.g = b->g;
+	color.b = b->b;
+	color.a = b->a;
+	ZeroMemory(&bprop, sizeof (D2D1_BRUSH_PROPERTIES));
+	bprop.opacity = 1.0;
+	bprop.transform._11 = 1;
+	bprop.transform._22 = 1;
+	hr = rt->CreateSolidColorBrush(&color, &bprop, &brush);
+	if (hr != S_OK)
+		logHRESULT(L"error creating brush for color button", hr);
+	rt->FillRectangle(&r, brush);
+	brush->Release();
+
+	hr = rt->EndDraw(NULL, NULL);
+	if (hr != S_OK)
+		logHRESULT(L"error drawing color on color button", hr);
+	rt->Release();
+
+	// skip default processing (don't draw text)
+	*lResult = CDRF_SKIPDEFAULT;
+	return TRUE;
+}
+
+uiWindowsControlAllDefaultsExceptDestroy(uiColorButton)
+
+// from http://msdn.microsoft.com/en-us/library/windows/desktop/dn742486.aspx#sizingandspacing
+#define buttonHeight 14
+
+// TODO check widths
+static void uiColorButtonMinimumSize(uiWindowsControl *c, int *width, int *height)
+{
+	uiColorButton *b = uiColorButton(c);
+	SIZE size;
+	uiWindowsSizing sizing;
+	int y;
+
+	// try the comctl32 version 6 way
+	size.cx = 0;		// explicitly ask for ideal size
+	size.cy = 0;
+	if (SendMessageW(b->hwnd, BCM_GETIDEALSIZE, 0, (LPARAM) (&size)) != FALSE) {
+		*width = size.cx;
+		*height = size.cy;
+		return;
+	}
+
+	// that didn't work; fall back to using Microsoft's metrics
+	// Microsoft says to use a fixed width for all buttons; this isn't good enough
+	// use the text width instead, with some edge padding
+	*width = uiWindowsWindowTextWidth(b->hwnd) + (2 * GetSystemMetrics(SM_CXEDGE));
+	y = buttonHeight;
+	uiWindowsGetSizing(b->hwnd, &sizing);
+	uiWindowsSizingDlgUnitsToPixels(&sizing, NULL, &y);
+	*height = y;
+}
+
+static void defaultOnChanged(uiColorButton *b, void *data)
+{
+	// do nothing
+}
+
+void uiColorButtonColor(uiColorButton *b, double *r, double *g, double *bl, double *a)
+{
+	*r = b->r;
+	*g = b->g;
+	*bl = b->b;
+	*a = b->a;
+}
+
+void uiColorButtonSetColor(uiColorButton *b, double r, double g, double bl, double a)
+{
+	b->r = r;
+	b->g = g;
+	b->b = bl;
+	b->a = a;
+	invalidateRect(b->hwnd, NULL, TRUE);
+}
+
+void uiColorButtonOnChanged(uiColorButton *b, void (*f)(uiColorButton *, void *), void *data)
+{
+	b->onChanged = f;
+	b->onChangedData = data;
+}
+
+uiColorButton *uiNewColorButton(void)
+{
+	uiColorButton *b;
+
+	uiWindowsNewControl(uiColorButton, b);
+
+	// initial color is black
+	b->r = 0.0;
+	b->g = 0.0;
+	b->b = 0.0;
+	b->a = 1.0;
+
+	b->hwnd = uiWindowsEnsureCreateControlHWND(0,
+		L"button", L" ",		// TODO; can't use "" TODO
+		BS_PUSHBUTTON | WS_TABSTOP,
+		hInstance, NULL,
+		TRUE);
+
+	uiWindowsRegisterWM_COMMANDHandler(b->hwnd, onWM_COMMAND, uiControl(b));
+	uiWindowsRegisterWM_NOTIFYHandler(b->hwnd, onWM_NOTIFY, uiControl(b));
+	uiColorButtonOnChanged(b, defaultOnChanged, NULL);
+
+	return b;
+}
diff --git a/src/libui_sdl/libui/windows/colordialog.cpp b/src/libui_sdl/libui/windows/colordialog.cpp
new file mode 100644
index 0000000..2efe72c
--- /dev/null
+++ b/src/libui_sdl/libui/windows/colordialog.cpp
@@ -0,0 +1,1264 @@
+// 16 may 2016
+#include "uipriv_windows.hpp"
+
+// TODO should the d2dscratch programs capture mouse?
+
+struct colorDialog {
+	HWND hwnd;
+
+	HWND svChooser;
+	HWND hSlider;
+	HWND preview;
+	HWND opacitySlider;
+	HWND editH;
+	HWND editS;
+	HWND editV;
+	HWND editRDouble, editRInt;
+	HWND editGDouble, editGInt;
+	HWND editBDouble, editBInt;
+	HWND editADouble, editAInt;
+	HWND editHex;
+
+	double h;
+	double s;
+	double v;
+	double a;
+	struct colorDialogRGBA *out;
+
+	BOOL updating;
+};
+
+// both of these are from the wikipedia page on HSV
+// TODO what to do about negative h?
+static void rgb2HSV(double r, double g, double b, double *h, double *s, double *v)
+{
+	double M, m;
+	int whichmax;
+	double c;
+
+	M = r;
+	whichmax = 0;
+	if (M < g) {
+		M = g;
+		whichmax = 1;
+	}
+	if (M < b) {
+		M = b;
+		whichmax = 2;
+	}
+	m = r;
+	if (m > g)
+		m = g;
+	if (m > b)
+		m = b;
+	c = M - m;
+
+	if (c == 0)
+		*h = 0;
+	else {
+		switch (whichmax) {
+		case 0:
+			*h = ((g - b) / c);
+			*h = fmod(*h, 6);
+			break;
+		case 1:
+			*h = ((b - r) / c) + 2;
+			break;
+		case 2:
+			*h = ((r - g) / c) + 4;
+			break;
+		}
+		*h /= 6;		// put in range [0,1)
+	}
+
+	*v = M;
+
+	if (c == 0)
+		*s = 0;
+	else
+		*s = c / *v;
+}
+
+// TODO negative R values?
+static void hsv2RGB(double h, double s, double v, double *r, double *g, double *b)
+{
+	double c;
+	double hPrime;
+	int h60;
+	double x;
+	double m;
+	double c1, c2;
+
+	c = v * s;
+	hPrime = h * 6;
+	h60 = (int) hPrime;		// equivalent to splitting into 60° chunks
+	x = c * (1.0 - fabs(fmod(hPrime, 2) - 1.0));
+	m = v - c;
+	switch (h60) {
+	case 0:
+		*r = c + m;
+		*g = x + m;
+		*b = m;
+		return;
+	case 1:
+		*r = x + m;
+		*g = c + m;
+		*b = m;
+		return;
+	case 2:
+		*r = m;
+		*g = c + m;
+		*b = x + m;
+		return;
+	case 3:
+		*r = m;
+		*g = x + m;
+		*b = c + m;
+		return;
+	case 4:
+		*r = x + m;
+		*g = m;
+		*b = c + m;
+		return;
+	case 5:
+		*r = c + m;
+		*g = m;
+		*b = x + m;
+		return;
+	}
+	// TODO
+}
+
+#define hexd L"0123456789ABCDEF"
+
+static void rgba2Hex(uint8_t r, uint8_t g, uint8_t b, uint8_t a, WCHAR *buf)
+{
+	buf[0] = L'#';
+	buf[1] = hexd[(a >> 4) & 0xF];
+	buf[2] = hexd[a & 0xF];
+	buf[3] = hexd[(r >> 4) & 0xF];
+	buf[4] = hexd[r & 0xF];
+	buf[5] = hexd[(g >> 4) & 0xF];
+	buf[6] = hexd[g & 0xF];
+	buf[7] = hexd[(b >> 4) & 0xF];
+	buf[8] = hexd[b & 0xF];
+	buf[9] = L'\0';
+}
+
+static int convHexDigit(WCHAR c)
+{
+	if (c >= L'0' && c <= L'9')
+		return c - L'0';
+	if (c >= L'A' && c <= L'F')
+		return c - L'A' + 0xA;
+	if (c >= L'a' && c <= L'f')
+		return c - L'a' + 0xA;
+	return -1;
+}
+
+// TODO allow #NNN shorthand
+static BOOL hex2RGBA(WCHAR *buf, double *r, double *g, double *b, double *a)
+{
+	uint8_t component;
+	int i;
+
+	if (*buf == L'#')
+		buf++;
+
+	component = 0;
+	i = convHexDigit(*buf++);
+	if (i < 0)
+		return FALSE;
+	component |= ((uint8_t) i) << 4;
+	i = convHexDigit(*buf++);
+	if (i < 0)
+		return FALSE;
+	component |= ((uint8_t) i);
+	*a = ((double) component) / 255;
+
+	component = 0;
+	i = convHexDigit(*buf++);
+	if (i < 0)
+		return FALSE;
+	component |= ((uint8_t) i) << 4;
+	i = convHexDigit(*buf++);
+	if (i < 0)
+		return FALSE;
+	component |= ((uint8_t) i);
+	*r = ((double) component) / 255;
+
+	component = 0;
+	i = convHexDigit(*buf++);
+	if (i < 0)
+		return FALSE;
+	component |= ((uint8_t) i) << 4;
+	i = convHexDigit(*buf++);
+	if (i < 0)
+		return FALSE;
+	component |= ((uint8_t) i);
+	*g = ((double) component) / 255;
+
+	if (*buf == L'\0') {		// #NNNNNN syntax
+		*b = *g;
+		*g = *r;
+		*r = *a;
+		*a = 1;
+		return TRUE;
+	}
+
+	component = 0;
+	i = convHexDigit(*buf++);
+	if (i < 0)
+		return FALSE;
+	component |= ((uint8_t) i) << 4;
+	i = convHexDigit(*buf++);
+	if (i < 0)
+		return FALSE;
+	component |= ((uint8_t) i);
+	*b = ((double) component) / 255;
+
+	return *buf == L'\0';
+}
+
+static void updateDouble(HWND hwnd, double d, HWND whichChanged)
+{
+	WCHAR *str;
+
+	if (whichChanged == hwnd)
+		return;
+	str = ftoutf16(d);
+	setWindowText(hwnd, str);
+	uiFree(str);
+}
+
+static void updateDialog(struct colorDialog *c, HWND whichChanged)
+{
+	double r, g, b;
+	uint8_t rb, gb, bb, ab;
+	WCHAR *str;
+	WCHAR hexbuf[16];		// more than enough
+
+	c->updating = TRUE;
+
+	updateDouble(c->editH, c->h, whichChanged);
+	updateDouble(c->editS, c->s, whichChanged);
+	updateDouble(c->editV, c->v, whichChanged);
+
+	hsv2RGB(c->h, c->s, c->v, &r, &g, &b);
+
+	updateDouble(c->editRDouble, r, whichChanged);
+	updateDouble(c->editGDouble, g, whichChanged);
+	updateDouble(c->editBDouble, b, whichChanged);
+	updateDouble(c->editADouble, c->a, whichChanged);
+
+	rb = (uint8_t) (r * 255);
+	gb = (uint8_t) (g * 255);
+	bb = (uint8_t) (b * 255);
+	ab = (uint8_t) (c->a * 255);
+
+	if (whichChanged != c->editRInt) {
+		str = itoutf16(rb);
+		setWindowText(c->editRInt, str);
+		uiFree(str);
+	}
+	if (whichChanged != c->editGInt) {
+		str = itoutf16(gb);
+		setWindowText(c->editGInt, str);
+		uiFree(str);
+	}
+	if (whichChanged != c->editBInt) {
+		str = itoutf16(bb);
+		setWindowText(c->editBInt, str);
+		uiFree(str);
+	}
+	if (whichChanged != c->editAInt) {
+		str = itoutf16(ab);
+		setWindowText(c->editAInt, str);
+		uiFree(str);
+	}
+
+	if (whichChanged != c->editHex) {
+		rgba2Hex(rb, gb, bb, ab, hexbuf);
+		setWindowText(c->editHex, hexbuf);
+	}
+
+	// TODO TRUE?
+	invalidateRect(c->svChooser, NULL, TRUE);
+	invalidateRect(c->hSlider, NULL, TRUE);
+	invalidateRect(c->preview, NULL, TRUE);
+	invalidateRect(c->opacitySlider, NULL, TRUE);
+
+	c->updating = FALSE;
+}
+
+// this imitates http://blogs.msdn.com/b/wpfsdk/archive/2006/10/26/uncommon-dialogs--font-chooser-and-color-picker-dialogs.aspx
+static void drawGrid(ID2D1RenderTarget *rt, D2D1_RECT_F *fillRect)
+{
+	D2D1_SIZE_F size;
+	D2D1_PIXEL_FORMAT pformat;
+	ID2D1BitmapRenderTarget *brt;
+	D2D1_COLOR_F color;
+	D2D1_BRUSH_PROPERTIES bprop;
+	ID2D1SolidColorBrush *brush;
+	D2D1_RECT_F rect;
+	ID2D1Bitmap *bitmap;
+	D2D1_BITMAP_BRUSH_PROPERTIES bbp;
+	ID2D1BitmapBrush *bb;
+	HRESULT hr;
+
+	// mind the divisions; they represent the fact the original uses a viewport
+	size.width = 100 / 10;
+	size.height = 100 / 10;
+	// yay more ABI bugs
+#ifdef _MSC_VER
+	pformat = rt->GetPixelFormat();
+#else
+	{
+		typedef D2D1_PIXEL_FORMAT *(__stdcall ID2D1RenderTarget::* GetPixelFormatF)(D2D1_PIXEL_FORMAT *);
+		GetPixelFormatF gpf;
+
+		gpf = (GetPixelFormatF) (&(rt->GetPixelFormat));
+		(rt->*gpf)(&pformat);
+	}
+#endif
+	hr = rt->CreateCompatibleRenderTarget(&size, NULL,
+		&pformat, D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE,
+		&brt);
+	if (hr != S_OK)
+		logHRESULT(L"error creating render target for grid", hr);
+
+	brt->BeginDraw();
+
+	color.r = 1.0;
+	color.g = 1.0;
+	color.b = 1.0;
+	color.a = 1.0;
+	brt->Clear(&color);
+
+	color = D2D1::ColorF(D2D1::ColorF::LightGray, 1.0);
+	ZeroMemory(&bprop, sizeof (D2D1_BRUSH_PROPERTIES));
+	bprop.opacity = 1.0;
+	bprop.transform._11 = 1;
+	bprop.transform._22 = 1;
+	hr = brt->CreateSolidColorBrush(&color, &bprop, &brush);
+	if (hr != S_OK)
+		logHRESULT(L"error creating brush for grid", hr);
+	rect.left = 0;
+	rect.top = 0;
+	rect.right = 50 / 10;
+	rect.bottom = 50 / 10;
+	brt->FillRectangle(&rect, brush);
+	rect.left = 50 / 10;
+	rect.top = 50 / 10;
+	rect.right = 100 / 10;
+	rect.bottom = 100 / 10;
+	brt->FillRectangle(&rect, brush);
+	brush->Release();
+
+	hr = brt->EndDraw(NULL, NULL);
+	if (hr != S_OK)
+		logHRESULT(L"error finalizing render target for grid", hr);
+	hr = brt->GetBitmap(&bitmap);
+	if (hr != S_OK)
+		logHRESULT(L"error getting bitmap for grid", hr);
+	brt->Release();
+
+	ZeroMemory(&bbp, sizeof (D2D1_BITMAP_BRUSH_PROPERTIES));
+	bbp.extendModeX = D2D1_EXTEND_MODE_WRAP;
+	bbp.extendModeY = D2D1_EXTEND_MODE_WRAP;
+	bbp.interpolationMode = D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR;
+	hr = rt->CreateBitmapBrush(bitmap, &bbp, &bprop, &bb);
+	if (hr != S_OK)
+		logHRESULT(L"error creating bitmap brush for grid", hr);
+	rt->FillRectangle(fillRect, bb);
+	bb->Release();
+	bitmap->Release();
+}
+
+// this interesting approach comes from http://blogs.msdn.com/b/wpfsdk/archive/2006/10/26/uncommon-dialogs--font-chooser-and-color-picker-dialogs.aspx
+static void drawSVChooser(struct colorDialog *c, ID2D1RenderTarget *rt)
+{
+	D2D1_SIZE_F size;
+	D2D1_RECT_F rect;
+	double rTop, gTop, bTop;
+	D2D1_GRADIENT_STOP stops[2];
+	ID2D1GradientStopCollection *collection;
+	D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES lprop;
+	D2D1_BRUSH_PROPERTIES bprop;
+	ID2D1LinearGradientBrush *brush;
+	ID2D1LinearGradientBrush *opacity;
+	ID2D1Layer *layer;
+	D2D1_LAYER_PARAMETERS layerparams;
+	D2D1_ELLIPSE mparam;
+	D2D1_COLOR_F mcolor;
+	ID2D1SolidColorBrush *markerBrush;
+	HRESULT hr;
+
+	size = realGetSize(rt);
+	rect.left = 0;
+	rect.top = 0;
+	rect.right = size.width;
+	rect.bottom = size.height;
+
+	drawGrid(rt, &rect);
+
+	// first, draw a vertical gradient from the current hue at max S/V to black
+	// the source example draws it upside down; let's do so too just to be safe
+	hsv2RGB(c->h, 1.0, 1.0, &rTop, &gTop, &bTop);
+	stops[0].position = 0;
+	stops[0].color.r = 0.0;
+	stops[0].color.g = 0.0;
+	stops[0].color.b = 0.0;
+	stops[0].color.a = 1.0;
+	stops[1].position = 1;
+	stops[1].color.r = rTop;
+	stops[1].color.g = gTop;
+	stops[1].color.b = bTop;
+	stops[1].color.a = 1.0;
+	hr = rt->CreateGradientStopCollection(stops, 2,
+		D2D1_GAMMA_2_2, D2D1_EXTEND_MODE_CLAMP,
+		&collection);
+	if (hr != S_OK)
+		logHRESULT(L"error making gradient stop collection for first gradient in SV chooser", hr);
+	ZeroMemory(&lprop, sizeof (D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES));
+	lprop.startPoint.x = size.width / 2;
+	lprop.startPoint.y = size.height;
+	lprop.endPoint.x = size.width / 2;
+	lprop.endPoint.y = 0;
+	// TODO decide what to do about the duplication of this
+	ZeroMemory(&bprop, sizeof (D2D1_BRUSH_PROPERTIES));
+	bprop.opacity = c->a;		// note this part; we also use it below for the layer
+	bprop.transform._11 = 1;
+	bprop.transform._22 = 1;
+	hr = rt->CreateLinearGradientBrush(&lprop, &bprop,
+		collection, &brush);
+	if (hr != S_OK)
+		logHRESULT(L"error making gradient brush for first gradient in SV chooser", hr);
+	rt->FillRectangle(&rect, brush);
+	brush->Release();
+	collection->Release();
+
+	// second, create an opacity mask for the third step: a horizontal gradientthat goes from opaque to translucent
+	stops[0].position = 0;
+	stops[0].color.r = 0.0;
+	stops[0].color.g = 0.0;
+	stops[0].color.b = 0.0;
+	stops[0].color.a = 1.0;
+	stops[1].position = 1;
+	stops[1].color.r = 0.0;
+	stops[1].color.g = 0.0;
+	stops[1].color.b = 0.0;
+	stops[1].color.a = 0.0;
+	hr = rt->CreateGradientStopCollection(stops, 2,
+		D2D1_GAMMA_2_2, D2D1_EXTEND_MODE_CLAMP,
+		&collection);
+	if (hr != S_OK)
+		logHRESULT(L"error making gradient stop collection for opacity mask gradient in SV chooser", hr);
+	ZeroMemory(&lprop, sizeof (D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES));
+	lprop.startPoint.x = 0;
+	lprop.startPoint.y = size.height / 2;
+	lprop.endPoint.x = size.width;
+	lprop.endPoint.y = size.height / 2;
+	ZeroMemory(&bprop, sizeof (D2D1_BRUSH_PROPERTIES));
+	bprop.opacity = 1.0;
+	bprop.transform._11 = 1;
+	bprop.transform._22 = 1;
+	hr = rt->CreateLinearGradientBrush(&lprop, &bprop,
+		collection, &opacity);
+	if (hr != S_OK)
+		logHRESULT(L"error making gradient brush for opacity mask gradient in SV chooser", hr);
+	collection->Release();
+
+	// finally, make a vertical gradient from white at the top to black at the bottom (right side up this time) and with the previous opacity mask
+	stops[0].position = 0;
+	stops[0].color.r = 1.0;
+	stops[0].color.g = 1.0;
+	stops[0].color.b = 1.0;
+	stops[0].color.a = 1.0;
+	stops[1].position = 1;
+	stops[1].color.r = 0.0;
+	stops[1].color.g = 0.0;
+	stops[1].color.b = 0.0;
+	stops[1].color.a = 1.0;
+	hr = rt->CreateGradientStopCollection(stops, 2,
+		D2D1_GAMMA_2_2, D2D1_EXTEND_MODE_CLAMP,
+		&collection);
+	if (hr != S_OK)
+		logHRESULT(L"error making gradient stop collection for second gradient in SV chooser", hr);
+	ZeroMemory(&lprop, sizeof (D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES));
+	lprop.startPoint.x = size.width / 2;
+	lprop.startPoint.y = 0;
+	lprop.endPoint.x = size.width / 2;
+	lprop.endPoint.y = size.height;
+	ZeroMemory(&bprop, sizeof (D2D1_BRUSH_PROPERTIES));
+	bprop.opacity = 1.0;
+	bprop.transform._11 = 1;
+	bprop.transform._22 = 1;
+	hr = rt->CreateLinearGradientBrush(&lprop, &bprop,
+		collection, &brush);
+	if (hr != S_OK)
+		logHRESULT(L"error making gradient brush for second gradient in SV chooser", hr);
+	// oh but wait we can't use FillRectangle() with an opacity mask
+	// and we can't use FillGeometry() with both an opacity mask and a non-bitmap
+	// layers it is!
+	hr = rt->CreateLayer(&size, &layer);
+	if (hr != S_OK)
+		logHRESULT(L"error making layer for second gradient in SV chooser", hr);
+	ZeroMemory(&layerparams, sizeof (D2D1_LAYER_PARAMETERS));
+	layerparams.contentBounds = rect;
+	// TODO make sure these are right
+	layerparams.geometricMask = NULL;
+	layerparams.maskAntialiasMode = D2D1_ANTIALIAS_MODE_PER_PRIMITIVE;
+	layerparams.maskTransform._11 = 1;
+	layerparams.maskTransform._22 = 1;
+	layerparams.opacity = c->a;			// here's the other use of c->a to note
+	layerparams.opacityBrush = opacity;
+	layerparams.layerOptions = D2D1_LAYER_OPTIONS_NONE;
+	rt->PushLayer(&layerparams, layer);
+	rt->FillRectangle(&rect, brush);
+	rt->PopLayer();
+	layer->Release();
+	brush->Release();
+	collection->Release();
+	opacity->Release();
+
+	// and now we just draw the marker
+	ZeroMemory(&mparam, sizeof (D2D1_ELLIPSE));
+	mparam.point.x = c->s * size.width;
+	mparam.point.y = (1 - c->v) * size.height;
+	mparam.radiusX = 7;
+	mparam.radiusY = 7;
+	// TODO make the color contrast?
+	mcolor.r = 1.0;
+	mcolor.g = 1.0;
+	mcolor.b = 1.0;
+	mcolor.a = 1.0;
+	bprop.opacity = 1.0;		// the marker should always be opaque
+	hr = rt->CreateSolidColorBrush(&mcolor, &bprop, &markerBrush);
+	if (hr != S_OK)
+		logHRESULT(L"error creating brush for SV chooser marker", hr);
+	rt->DrawEllipse(&mparam, markerBrush, 2, NULL);
+	markerBrush->Release();
+}
+
+static LRESULT CALLBACK svChooserSubProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
+{
+	ID2D1RenderTarget *rt;
+	struct colorDialog *c;
+	D2D1_POINT_2F *pos;
+	D2D1_SIZE_F *size;
+
+	c = (struct colorDialog *) dwRefData;
+	switch (uMsg) {
+	case msgD2DScratchPaint:
+		rt = (ID2D1RenderTarget *) lParam;
+		drawSVChooser(c, rt);
+		return 0;
+	case msgD2DScratchLButtonDown:
+		pos = (D2D1_POINT_2F *) wParam;
+		size = (D2D1_SIZE_F *) lParam;
+		c->s = pos->x / size->width;
+		c->v = 1 - (pos->y / size->height);
+		updateDialog(c, NULL);
+		return 0;
+	case WM_NCDESTROY:
+		if (RemoveWindowSubclass(hwnd, svChooserSubProc, uIdSubclass) == FALSE)
+			logLastError(L"error removing color dialog SV chooser subclass");
+		break;
+	}
+	return DefSubclassProc(hwnd, uMsg, wParam, lParam);
+}
+
+static void drawArrow(ID2D1RenderTarget *rt, D2D1_POINT_2F center, double hypot)
+{
+	double leg;
+	D2D1_RECT_F rect;
+	D2D1_MATRIX_3X2_F oldtf, rotate;
+	D2D1_COLOR_F color;
+	D2D1_BRUSH_PROPERTIES bprop;
+	ID2D1SolidColorBrush *brush;
+	HRESULT hr;
+
+	// to avoid needing a geometry, this will just be a rotated square
+	// compute the length of each side; the diagonal of the square is 2 * offset to gradient
+	// a^2 + a^2 = c^2 -> 2a^2 = c^2
+	// a = sqrt(c^2/2)
+	hypot *= hypot;
+	hypot /= 2;
+	leg = sqrt(hypot);
+	rect.left = center.x - leg;
+	rect.top = center.y - leg;
+	rect.right = center.x + leg;
+	rect.bottom = center.y + leg;
+
+	// now we need to rotate the render target 45° (either way works) about the center point
+	rt->GetTransform(&oldtf);
+	rotate = oldtf * D2D1::Matrix3x2F::Rotation(45, center);
+	rt->SetTransform(&rotate);
+
+	// and draw
+	color.r = 0.0;
+	color.g = 0.0;
+	color.b = 0.0;
+	color.a = 1.0;
+	ZeroMemory(&bprop, sizeof (D2D1_BRUSH_PROPERTIES));
+	bprop.opacity = 1.0;
+	bprop.transform._11 = 1;
+	bprop.transform._22 = 1;
+	hr = rt->CreateSolidColorBrush(&color, &bprop, &brush);
+	if (hr != S_OK)
+		logHRESULT(L"error creating brush for arrow", hr);
+	rt->FillRectangle(&rect, brush);
+	brush->Release();
+
+	// clean up
+	rt->SetTransform(&oldtf);
+}
+
+// the gradient stuff also comes from http://blogs.msdn.com/b/wpfsdk/archive/2006/10/26/uncommon-dialogs--font-chooser-and-color-picker-dialogs.aspx
+#define nStops (30)
+#define degPerStop (360 / nStops)
+#define stopIncr (1.0 / ((double) nStops))
+
+static void drawHSlider(struct colorDialog *c, ID2D1RenderTarget *rt)
+{
+	D2D1_SIZE_F size;
+	D2D1_RECT_F rect;
+	D2D1_GRADIENT_STOP stops[nStops];
+	double r, g, b;
+	int i;
+	double h;
+	ID2D1GradientStopCollection *collection;
+	D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES lprop;
+	D2D1_BRUSH_PROPERTIES bprop;
+	ID2D1LinearGradientBrush *brush;
+	double hypot;
+	D2D1_POINT_2F center;
+	HRESULT hr;
+
+	size = realGetSize(rt);
+	rect.left = size.width / 6;		// leftmost sixth for arrow
+	rect.top = 0;
+	rect.right = size.width;
+	rect.bottom = size.height;
+
+	for (i = 0; i < nStops; i++) {
+		h = ((double) (i * degPerStop)) / 360.0;
+		if (i == (nStops - 1))
+			h = 0;
+		hsv2RGB(h, 1.0, 1.0, &r, &g, &b);
+		stops[i].position = ((double) i) * stopIncr;
+		stops[i].color.r = r;
+		stops[i].color.g = g;
+		stops[i].color.b = b;
+		stops[i].color.a = 1.0;
+	}
+	// and pin the last one
+	stops[i - 1].position = 1.0;
+
+	hr = rt->CreateGradientStopCollection(stops, nStops,
+		// note that in this case this gamma is explicitly specified by the original
+		D2D1_GAMMA_2_2, D2D1_EXTEND_MODE_CLAMP,
+		&collection);
+	if (hr != S_OK)
+		logHRESULT(L"error creating stop collection for H slider gradient", hr);
+	ZeroMemory(&lprop, sizeof (D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES));
+	lprop.startPoint.x = (rect.right - rect.left) / 2;
+	lprop.startPoint.y = 0;
+	lprop.endPoint.x = (rect.right - rect.left) / 2;
+	lprop.endPoint.y = size.height;
+	ZeroMemory(&bprop, sizeof (D2D1_BRUSH_PROPERTIES));
+	bprop.opacity = 1.0;
+	bprop.transform._11 = 1;
+	bprop.transform._22 = 1;
+	hr = rt->CreateLinearGradientBrush(&lprop, &bprop,
+		collection, &brush);
+	if (hr != S_OK)
+		logHRESULT(L"error creating gradient brush for H slider", hr);
+	rt->FillRectangle(&rect, brush);
+	brush->Release();
+	collection->Release();
+
+	// now draw a black arrow
+	center.x = 0;
+	center.y = c->h * size.height;
+	hypot = rect.left;
+	drawArrow(rt, center, hypot);
+}
+
+static LRESULT CALLBACK hSliderSubProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
+{
+	ID2D1RenderTarget *rt;
+	struct colorDialog *c;
+	D2D1_POINT_2F *pos;
+	D2D1_SIZE_F *size;
+
+	c = (struct colorDialog *) dwRefData;
+	switch (uMsg) {
+	case msgD2DScratchPaint:
+		rt = (ID2D1RenderTarget *) lParam;
+		drawHSlider(c, rt);
+		return 0;
+	case msgD2DScratchLButtonDown:
+		pos = (D2D1_POINT_2F *) wParam;
+		size = (D2D1_SIZE_F *) lParam;
+		c->h = pos->y / size->height;
+		updateDialog(c, NULL);
+		return 0;
+	case WM_NCDESTROY:
+		if (RemoveWindowSubclass(hwnd, hSliderSubProc, uIdSubclass) == FALSE)
+			logLastError(L"error removing color dialog H slider subclass");
+		break;
+	}
+	return DefSubclassProc(hwnd, uMsg, wParam, lParam);
+}
+
+static void drawPreview(struct colorDialog *c, ID2D1RenderTarget *rt)
+{
+	D2D1_SIZE_F size;
+	D2D1_RECT_F rect;
+	double r, g, b;
+	D2D1_COLOR_F color;
+	D2D1_BRUSH_PROPERTIES bprop;
+	ID2D1SolidColorBrush *brush;
+	HRESULT hr;
+
+	size = realGetSize(rt);
+	rect.left = 0;
+	rect.top = 0;
+	rect.right = size.width;
+	rect.bottom = size.height;
+
+	drawGrid(rt, &rect);
+
+	hsv2RGB(c->h, c->s, c->v, &r, &g, &b);
+	color.r = r;
+	color.g = g;
+	color.b = b;
+	color.a = c->a;
+	ZeroMemory(&bprop, sizeof (D2D1_BRUSH_PROPERTIES));
+	bprop.opacity = 1.0;
+	bprop.transform._11 = 1;
+	bprop.transform._22 = 1;
+	hr = rt->CreateSolidColorBrush(&color, &bprop, &brush);
+	if (hr != S_OK)
+		logHRESULT(L"error creating brush for preview", hr);
+	rt->FillRectangle(&rect, brush);
+	brush->Release();
+}
+
+static LRESULT CALLBACK previewSubProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
+{
+	ID2D1RenderTarget *rt;
+	struct colorDialog *c;
+
+	c = (struct colorDialog *) dwRefData;
+	switch (uMsg) {
+	case msgD2DScratchPaint:
+		rt = (ID2D1RenderTarget *) lParam;
+		drawPreview(c, rt);
+		return 0;
+	case WM_NCDESTROY:
+		if (RemoveWindowSubclass(hwnd, previewSubProc, uIdSubclass) == FALSE)
+			logLastError(L"error removing color dialog previewer subclass");
+		break;
+	}
+	return DefSubclassProc(hwnd, uMsg, wParam, lParam);
+}
+
+// once again, this is based on the Microsoft sample above
+static void drawOpacitySlider(struct colorDialog *c, ID2D1RenderTarget *rt)
+{
+	D2D1_SIZE_F size;
+	D2D1_RECT_F rect;
+	D2D1_GRADIENT_STOP stops[2];
+	ID2D1GradientStopCollection *collection;
+	D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES lprop;
+	D2D1_BRUSH_PROPERTIES bprop;
+	ID2D1LinearGradientBrush *brush;
+	double hypot;
+	D2D1_POINT_2F center;
+	HRESULT hr;
+
+	size = realGetSize(rt);
+	rect.left = 0;
+	rect.top = 0;
+	rect.right = size.width;
+	rect.bottom = size.height * (5.0 / 6.0);		// bottommost sixth for arrow
+
+	drawGrid(rt, &rect);
+
+	stops[0].position = 0.0;
+	stops[0].color.r = 0.0;
+	stops[0].color.g = 0.0;
+	stops[0].color.b = 0.0;
+	stops[0].color.a = 1.0;
+	stops[1].position = 1.0;
+	stops[1].color.r = 1.0;		// this is the XAML color Transparent, as in the source
+	stops[1].color.g = 1.0;
+	stops[1].color.b = 1.0;
+	stops[1].color.a = 0.0;
+	hr = rt->CreateGradientStopCollection(stops, 2,
+		// note that in this case this gamma is explicitly specified by the original
+		D2D1_GAMMA_2_2, D2D1_EXTEND_MODE_CLAMP,
+		&collection);
+	if (hr != S_OK)
+		logHRESULT(L"error creating stop collection for opacity slider gradient", hr);
+	ZeroMemory(&lprop, sizeof (D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES));
+	lprop.startPoint.x = 0;
+	lprop.startPoint.y = (rect.bottom - rect.top) / 2;
+	lprop.endPoint.x = size.width;
+	lprop.endPoint.y = (rect.bottom - rect.top) / 2;
+	ZeroMemory(&bprop, sizeof (D2D1_BRUSH_PROPERTIES));
+	bprop.opacity = 1.0;
+	bprop.transform._11 = 1;
+	bprop.transform._22 = 1;
+	hr = rt->CreateLinearGradientBrush(&lprop, &bprop,
+		collection, &brush);
+	if (hr != S_OK)
+		logHRESULT(L"error creating gradient brush for opacity slider", hr);
+	rt->FillRectangle(&rect, brush);
+	brush->Release();
+	collection->Release();
+
+	// now draw a black arrow
+	center.x = (1 - c->a) * size.width;
+	center.y = size.height;
+	hypot = size.height - rect.bottom;
+	drawArrow(rt, center, hypot);
+}
+
+static LRESULT CALLBACK opacitySliderSubProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
+{
+	ID2D1RenderTarget *rt;
+	struct colorDialog *c;
+	D2D1_POINT_2F *pos;
+	D2D1_SIZE_F *size;
+
+	c = (struct colorDialog *) dwRefData;
+	switch (uMsg) {
+	case msgD2DScratchPaint:
+		rt = (ID2D1RenderTarget *) lParam;
+		drawOpacitySlider(c, rt);
+		return 0;
+	case msgD2DScratchLButtonDown:
+		pos = (D2D1_POINT_2F *) wParam;
+		size = (D2D1_SIZE_F *) lParam;
+		c->a = 1 - (pos->x / size->width);
+		updateDialog(c, NULL);
+		return 0;
+	case WM_NCDESTROY:
+		if (RemoveWindowSubclass(hwnd, opacitySliderSubProc, uIdSubclass) == FALSE)
+			logLastError(L"error removing color dialog opacity slider subclass");
+		break;
+	}
+	return DefSubclassProc(hwnd, uMsg, wParam, lParam);
+}
+
+// TODO extract into d2dscratch.cpp, use in font dialog
+HWND replaceWithD2DScratch(HWND parent, int id, SUBCLASSPROC subproc, void *data)
+{
+	HWND replace;
+	RECT r;
+
+	replace = getDlgItem(parent, id);
+	uiWindowsEnsureGetWindowRect(replace, &r);
+	mapWindowRect(NULL, parent, &r);
+	uiWindowsEnsureDestroyWindow(replace);
+	return newD2DScratch(parent, &r, (HMENU) id, subproc, (DWORD_PTR) data);
+	// TODO preserve Z-order
+}
+
+// a few issues:
+// - some controls are positioned wrong; see http://stackoverflow.com/questions/37263267/why-are-some-of-my-controls-positioned-slightly-off-in-a-dialog-template-in-a-re
+// - labels are too low; need to adjust them by the font's internal leading
+// fixupControlPositions() and the following helper routines fix that for us
+
+static LONG offsetTo(HWND a, HWND b)
+{
+	RECT ra, rb;
+
+	uiWindowsEnsureGetWindowRect(a, &ra);
+	uiWindowsEnsureGetWindowRect(b, &rb);
+	return rb.top - ra.bottom;
+}
+
+static void moveWindowsUp(struct colorDialog *c, LONG by, ...)
+{
+	va_list ap;
+	HWND cur;
+	RECT r;
+
+	va_start(ap, by);
+	for (;;) {
+		cur = va_arg(ap, HWND);
+		if (cur == NULL)
+			break;
+		uiWindowsEnsureGetWindowRect(cur, &r);
+		mapWindowRect(NULL, c->hwnd, &r);
+		r.top -= by;
+		r.bottom -= by;
+		// TODO this isn't technically during a resize
+		uiWindowsEnsureMoveWindowDuringResize(cur,
+			r.left, r.top,
+			r.right - r.left, r.bottom - r.top);
+	}
+	va_end(ap);
+}
+
+static void fixupControlPositions(struct colorDialog *c)
+{
+	HWND labelH;
+	HWND labelS;
+	HWND labelV;
+	HWND labelR;
+	HWND labelG;
+	HWND labelB;
+	HWND labelA;
+	HWND labelHex;
+	LONG offset;
+	uiWindowsSizing sizing;
+
+	labelH = getDlgItem(c->hwnd, rcHLabel);
+	labelS = getDlgItem(c->hwnd, rcSLabel);
+	labelV = getDlgItem(c->hwnd, rcVLabel);
+	labelR = getDlgItem(c->hwnd, rcRLabel);
+	labelG = getDlgItem(c->hwnd, rcGLabel);
+	labelB = getDlgItem(c->hwnd, rcBLabel);
+	labelA = getDlgItem(c->hwnd, rcALabel);
+	labelHex = getDlgItem(c->hwnd, rcHexLabel);
+
+	offset = offsetTo(c->editH, c->editS);
+	moveWindowsUp(c, offset,
+		labelS, c->editS,
+		labelG, c->editGDouble, c->editGInt,
+		NULL);
+	offset = offsetTo(c->editS, c->editV);
+	moveWindowsUp(c, offset,
+		labelV, c->editV,
+		labelB, c->editBDouble, c->editBInt,
+		NULL);
+	offset = offsetTo(c->editBDouble, c->editADouble);
+	moveWindowsUp(c, offset,
+		labelA, c->editADouble, c->editAInt,
+		NULL);
+
+	getSizing(c->hwnd, &sizing, (HFONT) SendMessageW(labelH, WM_GETFONT, 0, 0));
+	offset = sizing.InternalLeading;
+	moveWindowsUp(c, offset,
+		labelH, labelS, labelV,
+		labelR, labelG, labelB, labelA,
+		labelHex,
+		NULL);
+}
+
+static struct colorDialog *beginColorDialog(HWND hwnd, LPARAM lParam)
+{
+	struct colorDialog *c;
+
+	c = uiNew(struct colorDialog);
+	c->hwnd = hwnd;
+	c->out = (struct colorDialogRGBA *) lParam;
+	// load initial values now
+	rgb2HSV(c->out->r, c->out->g, c->out->b, &(c->h), &(c->s), &(c->v));
+	c->a = c->out->a;
+
+	// TODO set up d2dscratches
+
+	// TODO prefix all these with rcColor instead of just rc
+	c->editH = getDlgItem(c->hwnd, rcH);
+	c->editS = getDlgItem(c->hwnd, rcS);
+	c->editV = getDlgItem(c->hwnd, rcV);
+	c->editRDouble = getDlgItem(c->hwnd, rcRDouble);
+	c->editRInt = getDlgItem(c->hwnd, rcRInt);
+	c->editGDouble = getDlgItem(c->hwnd, rcGDouble);
+	c->editGInt = getDlgItem(c->hwnd, rcGInt);
+	c->editBDouble = getDlgItem(c->hwnd, rcBDouble);
+	c->editBInt = getDlgItem(c->hwnd, rcBInt);
+	c->editADouble = getDlgItem(c->hwnd, rcADouble);
+	c->editAInt = getDlgItem(c->hwnd, rcAInt);
+	c->editHex = getDlgItem(c->hwnd, rcHex);
+
+	c->svChooser = replaceWithD2DScratch(c->hwnd, rcColorSVChooser, svChooserSubProc, c);
+	c->hSlider = replaceWithD2DScratch(c->hwnd, rcColorHSlider, hSliderSubProc, c);
+	c->preview = replaceWithD2DScratch(c->hwnd, rcPreview, previewSubProc, c);
+	c->opacitySlider = replaceWithD2DScratch(c->hwnd, rcOpacitySlider, opacitySliderSubProc, c);
+
+	fixupControlPositions(c);
+
+	// and get the ball rolling
+	updateDialog(c, NULL);
+	return c;
+}
+
+static void endColorDialog(struct colorDialog *c, INT_PTR code)
+{
+	if (EndDialog(c->hwnd, code) == 0)
+		logLastError(L"error ending color dialog");
+	uiFree(c);
+}
+
+// TODO make this void on the font dialog too
+static void tryFinishDialog(struct colorDialog *c, WPARAM wParam)
+{
+	// cancelling
+	if (LOWORD(wParam) != IDOK) {
+		endColorDialog(c, 1);
+		return;
+	}
+
+	// OK
+	hsv2RGB(c->h, c->s, c->v, &(c->out->r), &(c->out->g), &(c->out->b));
+	c->out->a = c->a;
+	endColorDialog(c, 2);
+}
+
+static double editDouble(HWND hwnd)
+{
+	WCHAR *s;
+	double d;
+
+	s = windowText(hwnd);
+	d = _wtof(s);
+	uiFree(s);
+	return d;
+}
+
+static void hChanged(struct colorDialog *c)
+{
+	double h;
+
+	h = editDouble(c->editH);
+	if (h < 0 || h >= 1.0)		// note the >=
+		return;
+	c->h = h;
+	updateDialog(c, c->editH);
+}
+
+static void sChanged(struct colorDialog *c)
+{
+	double s;
+
+	s = editDouble(c->editS);
+	if (s < 0 || s > 1)
+		return;
+	c->s = s;
+	updateDialog(c, c->editS);
+}
+
+static void vChanged(struct colorDialog *c)
+{
+	double v;
+
+	v = editDouble(c->editV);
+	if (v < 0 || v > 1)
+		return;
+	c->v = v;
+	updateDialog(c, c->editV);
+}
+
+static void rDoubleChanged(struct colorDialog *c)
+{
+	double r, g, b;
+
+	hsv2RGB(c->h, c->s, c->v, &r, &g, &b);
+	r = editDouble(c->editRDouble);
+	if (r < 0 || r > 1)
+		return;
+	rgb2HSV(r, g, b, &(c->h), &(c->s), &(c->v));
+	updateDialog(c, c->editRDouble);
+}
+
+static void gDoubleChanged(struct colorDialog *c)
+{
+	double r, g, b;
+
+	hsv2RGB(c->h, c->s, c->v, &r, &g, &b);
+	g = editDouble(c->editGDouble);
+	if (g < 0 || g > 1)
+		return;
+	rgb2HSV(r, g, b, &(c->h), &(c->s), &(c->v));
+	updateDialog(c, c->editGDouble);
+}
+
+static void bDoubleChanged(struct colorDialog *c)
+{
+	double r, g, b;
+
+	hsv2RGB(c->h, c->s, c->v, &r, &g, &b);
+	b = editDouble(c->editBDouble);
+	if (b < 0 || b > 1)
+		return;
+	rgb2HSV(r, g, b, &(c->h), &(c->s), &(c->v));
+	updateDialog(c, c->editBDouble);
+}
+
+static void aDoubleChanged(struct colorDialog *c)
+{
+	double a;
+
+	a = editDouble(c->editADouble);
+	if (a < 0 || a > 1)
+		return;
+	c->a = a;
+	updateDialog(c, c->editADouble);
+}
+
+static int editInt(HWND hwnd)
+{
+	WCHAR *s;
+	int i;
+
+	s = windowText(hwnd);
+	i = _wtoi(s);
+	uiFree(s);
+	return i;
+}
+
+static void rIntChanged(struct colorDialog *c)
+{
+	double r, g, b;
+	int i;
+
+	hsv2RGB(c->h, c->s, c->v, &r, &g, &b);
+	i = editInt(c->editRInt);
+	if (i < 0 || i > 255)
+		return;
+	r = ((double) i) / 255.0;
+	rgb2HSV(r, g, b, &(c->h), &(c->s), &(c->v));
+	updateDialog(c, c->editRInt);
+}
+
+static void gIntChanged(struct colorDialog *c)
+{
+	double r, g, b;
+	int i;
+
+	hsv2RGB(c->h, c->s, c->v, &r, &g, &b);
+	i = editInt(c->editGInt);
+	if (i < 0 || i > 255)
+		return;
+	g = ((double) i) / 255.0;
+	rgb2HSV(r, g, b, &(c->h), &(c->s), &(c->v));
+	updateDialog(c, c->editGInt);
+}
+
+static void bIntChanged(struct colorDialog *c)
+{
+	double r, g, b;
+	int i;
+
+	hsv2RGB(c->h, c->s, c->v, &r, &g, &b);
+	i = editInt(c->editBInt);
+	if (i < 0 || i > 255)
+		return;
+	b = ((double) i) / 255.0;
+	rgb2HSV(r, g, b, &(c->h), &(c->s), &(c->v));
+	updateDialog(c, c->editBInt);
+}
+
+static void aIntChanged(struct colorDialog *c)
+{
+	int a;
+
+	a = editInt(c->editAInt);
+	if (a < 0 || a > 255)
+		return;
+	c->a = ((double) a) / 255;
+	updateDialog(c, c->editAInt);
+}
+
+static void hexChanged(struct colorDialog *c)
+{
+	WCHAR *buf;
+	double r, g, b, a;
+	BOOL is;
+
+	buf = windowText(c->editHex);
+	is = hex2RGBA(buf, &r, &g, &b, &a);
+	uiFree(buf);
+	if (!is)
+		return;
+	rgb2HSV(r, g, b, &(c->h), &(c->s), &(c->v));
+	c->a = a;
+	updateDialog(c, c->editHex);
+}
+
+// TODO change fontdialog to use this
+// note that if we make this const, we get lots of weird compiler errors
+static std::map<int, void (*)(struct colorDialog *)> changed = {
+	{ rcH, hChanged },
+	{ rcS, sChanged },
+	{ rcV, vChanged },
+	{ rcRDouble, rDoubleChanged },
+	{ rcGDouble, gDoubleChanged },
+	{ rcBDouble, bDoubleChanged },
+	{ rcADouble, aDoubleChanged },
+	{ rcRInt, rIntChanged },
+	{ rcGInt, gIntChanged },
+	{ rcBInt, bIntChanged },
+	{ rcAInt, aIntChanged },
+	{ rcHex, hexChanged },
+};
+
+static INT_PTR CALLBACK colorDialogDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+	struct colorDialog *c;
+
+	c = (struct colorDialog *) GetWindowLongPtrW(hwnd, DWLP_USER);
+	if (c == NULL) {
+		if (uMsg == WM_INITDIALOG) {
+			c = beginColorDialog(hwnd, lParam);
+			SetWindowLongPtrW(hwnd, DWLP_USER, (LONG_PTR) c);
+			return TRUE;
+		}
+		return FALSE;
+	}
+
+	switch (uMsg) {
+	case WM_COMMAND:
+		SetWindowLongPtrW(c->hwnd, DWLP_MSGRESULT, 0);		// just in case
+		switch (LOWORD(wParam)) {
+		case IDOK:
+		case IDCANCEL:
+			if (HIWORD(wParam) != BN_CLICKED)
+				return FALSE;
+			tryFinishDialog(c, wParam);
+			return TRUE;
+		case rcH:
+		case rcS:
+		case rcV:
+		case rcRDouble:
+		case rcGDouble:
+		case rcBDouble:
+		case rcADouble:
+		case rcRInt:
+		case rcGInt:
+		case rcBInt:
+		case rcAInt:
+		case rcHex:
+			if (HIWORD(wParam) != EN_CHANGE)
+				return FALSE;
+			if (c->updating)		// prevent infinite recursion during an update
+				return FALSE;
+			(*(changed[LOWORD(wParam)]))(c);
+			return TRUE;
+		}
+		return FALSE;
+	}
+	return FALSE;
+}
+
+BOOL showColorDialog(HWND parent, struct colorDialogRGBA *c)
+{
+	switch (DialogBoxParamW(hInstance, MAKEINTRESOURCE(rcColorDialog), parent, colorDialogDlgProc, (LPARAM) c)) {
+	case 1:			// cancel
+		return FALSE;
+	case 2:			// ok
+		// make the compiler happy by putting the return after the switch
+		break;
+	default:
+		logLastError(L"error running color dialog");
+	}
+	return TRUE;
+}
diff --git a/src/libui_sdl/libui/windows/combobox.cpp b/src/libui_sdl/libui/windows/combobox.cpp
new file mode 100644
index 0000000..87c999e
--- /dev/null
+++ b/src/libui_sdl/libui/windows/combobox.cpp
@@ -0,0 +1,110 @@
+// 20 may 2015
+#include "uipriv_windows.hpp"
+
+// we as Common Controls 6 users don't need to worry about the height of comboboxes; see http://blogs.msdn.com/b/oldnewthing/archive/2006/03/10/548537.aspx
+
+struct uiCombobox {
+	uiWindowsControl c;
+	HWND hwnd;
+	void (*onSelected)(uiCombobox *, void *);
+	void *onSelectedData;
+};
+
+static BOOL onWM_COMMAND(uiControl *cc, HWND hwnd, WORD code, LRESULT *lResult)
+{
+	uiCombobox *c = uiCombobox(cc);
+
+	if (code != CBN_SELCHANGE)
+		return FALSE;
+	(*(c->onSelected))(c, c->onSelectedData);
+	*lResult = 0;
+	return TRUE;
+}
+
+void uiComboboxDestroy(uiControl *cc)
+{
+	uiCombobox *c = uiCombobox(cc);
+
+	uiWindowsUnregisterWM_COMMANDHandler(c->hwnd);
+	uiWindowsEnsureDestroyWindow(c->hwnd);
+	uiFreeControl(uiControl(c));
+}
+
+uiWindowsControlAllDefaultsExceptDestroy(uiCombobox)
+
+// from http://msdn.microsoft.com/en-us/library/windows/desktop/dn742486.aspx#sizingandspacing
+#define comboboxWidth 107	/* this is actually the shorter progress bar width, but Microsoft only indicates as wide as necessary; LONGTERM */
+#define comboboxHeight 14	/* LONGTERM: is this too high? */
+
+static void uiComboboxMinimumSize(uiWindowsControl *cc, int *width, int *height)
+{
+	uiCombobox *c = uiCombobox(cc);
+	uiWindowsSizing sizing;
+	int x, y;
+
+	x = comboboxWidth;
+	y = comboboxHeight;
+	uiWindowsGetSizing(c->hwnd, &sizing);
+	uiWindowsSizingDlgUnitsToPixels(&sizing, &x, &y);
+	*width = x;
+	*height = y;
+}
+
+static void defaultOnSelected(uiCombobox *c, void *data)
+{
+	// do nothing
+}
+
+void uiComboboxAppend(uiCombobox *c, const char *text)
+{
+	WCHAR *wtext;
+	LRESULT res;
+
+	wtext = toUTF16(text);
+	res = SendMessageW(c->hwnd, CB_ADDSTRING, 0, (LPARAM) wtext);
+	if (res == (LRESULT) CB_ERR)
+		logLastError(L"error appending item to uiCombobox");
+	else if (res == (LRESULT) CB_ERRSPACE)
+		logLastError(L"memory exhausted appending item to uiCombobox");
+	uiFree(wtext);
+}
+
+int uiComboboxSelected(uiCombobox *c)
+{
+	LRESULT n;
+
+	n = SendMessage(c->hwnd, CB_GETCURSEL, 0, 0);
+	if (n == (LRESULT) CB_ERR)
+		return -1;
+	return n;
+}
+
+void uiComboboxSetSelected(uiCombobox *c, int n)
+{
+	// TODO error check
+	SendMessageW(c->hwnd, CB_SETCURSEL, (WPARAM) n, 0);
+}
+
+void uiComboboxOnSelected(uiCombobox *c, void (*f)(uiCombobox *c, void *data), void *data)
+{
+	c->onSelected = f;
+	c->onSelectedData = data;
+}
+
+uiCombobox *uiNewCombobox(void)
+{
+	uiCombobox *c;
+
+	uiWindowsNewControl(uiCombobox, c);
+
+	c->hwnd = uiWindowsEnsureCreateControlHWND(WS_EX_CLIENTEDGE,
+		L"combobox", L"",
+		CBS_DROPDOWNLIST | WS_TABSTOP,
+		hInstance, NULL,
+		TRUE);
+
+	uiWindowsRegisterWM_COMMANDHandler(c->hwnd, onWM_COMMAND, uiControl(c));
+	uiComboboxOnSelected(c, defaultOnSelected, NULL);
+
+	return c;
+}
diff --git a/src/libui_sdl/libui/windows/compilerver.hpp b/src/libui_sdl/libui/windows/compilerver.hpp
new file mode 100644
index 0000000..6c9e6b8
--- /dev/null
+++ b/src/libui_sdl/libui/windows/compilerver.hpp
@@ -0,0 +1,13 @@
+// 9 june 2015
+
+// Visual Studio (Microsoft's compilers)
+// VS2013 is needed for va_copy().
+#ifdef _MSC_VER
+#if _MSC_VER < 1800
+#error Visual Studio 2013 or higher is required to build libui.
+#endif
+#endif
+
+// LONGTERM MinGW
+
+// other compilers can be added here as necessary
diff --git a/src/libui_sdl/libui/windows/container.cpp b/src/libui_sdl/libui/windows/container.cpp
new file mode 100644
index 0000000..9ec1e28
--- /dev/null
+++ b/src/libui_sdl/libui/windows/container.cpp
@@ -0,0 +1,110 @@
+// 26 april 2015
+#include "uipriv_windows.hpp"
+
+// Code for the HWND of the following uiControls:
+// - uiBox
+// - uiRadioButtons
+// - uiSpinbox
+// - uiTab
+// - uiForm
+// - uiGrid
+
+struct containerInit {
+	uiWindowsControl *c;
+	void (*onResize)(uiWindowsControl *);
+};
+
+static LRESULT CALLBACK containerWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+	RECT r;
+	HDC dc;
+	PAINTSTRUCT ps;
+	CREATESTRUCTW *cs = (CREATESTRUCTW *) lParam;
+	WINDOWPOS *wp = (WINDOWPOS *) lParam;
+	MINMAXINFO *mmi = (MINMAXINFO *) lParam;
+	struct containerInit *init;
+	uiWindowsControl *c;
+	void (*onResize)(uiWindowsControl *);
+	int minwid, minht;
+	LRESULT lResult;
+
+	if (handleParentMessages(hwnd, uMsg, wParam, lParam, &lResult) != FALSE)
+		return lResult;
+	switch (uMsg) {
+	case WM_CREATE:
+		init = (struct containerInit *) (cs->lpCreateParams);
+		SetWindowLongPtrW(hwnd, GWLP_USERDATA, (LONG_PTR) (init->onResize));
+		SetWindowLongPtrW(hwnd, 0, (LONG_PTR) (init->c));
+		break;		// defer to DefWindowProc()
+	case WM_WINDOWPOSCHANGED:
+		if ((wp->flags & SWP_NOSIZE) != 0)
+			break;	// defer to DefWindowProc();
+		onResize = (void (*)(uiWindowsControl *)) GetWindowLongPtrW(hwnd, GWLP_USERDATA);
+		c = (uiWindowsControl *) GetWindowLongPtrW(hwnd, 0);
+		(*(onResize))(c);
+		return 0;
+	case WM_GETMINMAXINFO:
+		lResult = DefWindowProcW(hwnd, uMsg, wParam, lParam);
+		c = (uiWindowsControl *) GetWindowLongPtrW(hwnd, 0);
+		uiWindowsControlMinimumSize(c, &minwid, &minht);
+		mmi->ptMinTrackSize.x = minwid;
+		mmi->ptMinTrackSize.y = minht;
+		return lResult;
+	case WM_PAINT:
+		dc = BeginPaint(hwnd, &ps);
+		if (dc == NULL) {
+			logLastError(L"error beginning container paint");
+			// bail out; hope DefWindowProc() catches us
+			break;
+		}
+		r = ps.rcPaint;
+		paintContainerBackground(hwnd, dc, &r);
+		EndPaint(hwnd, &ps);
+		return 0;
+	// tab controls use this to draw the background of the tab area
+	case WM_PRINTCLIENT:
+		uiWindowsEnsureGetClientRect(hwnd, &r);
+		paintContainerBackground(hwnd, (HDC) wParam, &r);
+		return 0;
+	case WM_ERASEBKGND:
+		// avoid some flicker
+		// we draw the whole update area anyway
+		return 1;
+	}
+	return DefWindowProcW(hwnd, uMsg, wParam, lParam);
+}
+
+ATOM initContainer(HICON hDefaultIcon, HCURSOR hDefaultCursor)
+{
+	WNDCLASSW wc;
+
+	ZeroMemory(&wc, sizeof (WNDCLASSW));
+	wc.lpszClassName = containerClass;
+	wc.lpfnWndProc = containerWndProc;
+	wc.hInstance = hInstance;
+	wc.hIcon = hDefaultIcon;
+	wc.hCursor = hDefaultCursor;
+	wc.hbrBackground = (HBRUSH) (COLOR_BTNFACE + 1);
+	wc.cbWndExtra = sizeof (void *);
+	return RegisterClassW(&wc);
+}
+
+void uninitContainer(void)
+{
+	if (UnregisterClassW(containerClass, hInstance) == 0)
+		logLastError(L"error unregistering container window class");
+}
+
+HWND uiWindowsMakeContainer(uiWindowsControl *c, void (*onResize)(uiWindowsControl *))
+{
+	struct containerInit init;
+
+	// TODO onResize cannot be NULL
+	init.c = c;
+	init.onResize = onResize;
+	return uiWindowsEnsureCreateControlHWND(WS_EX_CONTROLPARENT,
+		containerClass, L"",
+		0,
+		hInstance, (LPVOID) (&init),
+		FALSE);
+}
diff --git a/src/libui_sdl/libui/windows/control.cpp b/src/libui_sdl/libui/windows/control.cpp
new file mode 100644
index 0000000..ce953cf
--- /dev/null
+++ b/src/libui_sdl/libui/windows/control.cpp
@@ -0,0 +1,121 @@
+// 16 august 2015
+#include "uipriv_windows.hpp"
+
+void uiWindowsControlSyncEnableState(uiWindowsControl *c, int enabled)
+{
+	(*(c->SyncEnableState))(c, enabled);
+}
+
+void uiWindowsControlSetParentHWND(uiWindowsControl *c, HWND parent)
+{
+	(*(c->SetParentHWND))(c, parent);
+}
+
+void uiWindowsControlMinimumSize(uiWindowsControl *c, int *width, int *height)
+{
+	(*(c->MinimumSize))(c, width, height);
+}
+
+void uiWindowsControlMinimumSizeChanged(uiWindowsControl *c)
+{
+	(*(c->MinimumSizeChanged))(c);
+}
+
+// TODO get rid of this
+void uiWindowsControlLayoutRect(uiWindowsControl *c, RECT *r)
+{
+	(*(c->LayoutRect))(c, r);
+}
+
+void uiWindowsControlAssignControlIDZOrder(uiWindowsControl *c, LONG_PTR *controlID, HWND *insertAfter)
+{
+	(*(c->AssignControlIDZOrder))(c, controlID, insertAfter);
+}
+
+void uiWindowsControlChildVisibilityChanged(uiWindowsControl *c)
+{
+	(*(c->ChildVisibilityChanged))(c);
+}
+
+HWND uiWindowsEnsureCreateControlHWND(DWORD dwExStyle, LPCWSTR lpClassName, LPCWSTR lpWindowName, DWORD dwStyle, HINSTANCE hInstance, LPVOID lpParam, BOOL useStandardControlFont)
+{
+	HWND hwnd;
+
+	// don't let using the arrow keys in a uiRadioButtons leave the radio buttons
+	if ((dwStyle & WS_TABSTOP) != 0)
+		dwStyle |= WS_GROUP;
+	hwnd = CreateWindowExW(dwExStyle,
+		lpClassName, lpWindowName,
+		dwStyle | WS_CHILD | WS_VISIBLE,
+		0, 0,
+		// use a nonzero initial size just in case some control breaks with a zero initial size
+		100, 100,
+		utilWindow, NULL, hInstance, lpParam);
+	if (hwnd == NULL) {
+		logLastError(L"error creating window");
+		// TODO return a decoy window
+	}
+	if (useStandardControlFont)
+		SendMessageW(hwnd, WM_SETFONT, (WPARAM) hMessageFont, (LPARAM) TRUE);
+	return hwnd;
+}
+
+// choose a value distinct from uiWindowSignature
+#define uiWindowsControlSignature 0x4D53576E
+
+uiWindowsControl *uiWindowsAllocControl(size_t n, uint32_t typesig, const char *typenamestr)
+{
+	return uiWindowsControl(uiAllocControl(n, uiWindowsControlSignature, typesig, typenamestr));
+}
+
+BOOL uiWindowsShouldStopSyncEnableState(uiWindowsControl *c, BOOL enabled)
+{
+	int ce;
+
+	ce = uiControlEnabled(uiControl(c));
+	// only stop if we're going from disabled back to enabled; don't stop under any other condition
+	// (if we stop when going from enabled to disabled then enabled children of a disabled control won't get disabled at the OS level)
+	if (!ce && enabled)
+		return TRUE;
+	return FALSE;
+}
+
+void uiWindowsControlAssignSoleControlIDZOrder(uiWindowsControl *c)
+{
+	LONG_PTR controlID;
+	HWND insertAfter;
+
+	controlID = 100;
+	insertAfter = NULL;
+	uiWindowsControlAssignControlIDZOrder(c, &controlID, &insertAfter);
+}
+
+BOOL uiWindowsControlTooSmall(uiWindowsControl *c)
+{
+	RECT r;
+	int width, height;
+
+	uiWindowsControlLayoutRect(c, &r);
+	uiWindowsControlMinimumSize(c, &width, &height);
+	if ((r.right - r.left) < width)
+		return TRUE;
+	if ((r.bottom - r.top) < height)
+		return TRUE;
+	return FALSE;
+}
+
+void uiWindowsControlContinueMinimumSizeChanged(uiWindowsControl *c)
+{
+	uiControl *parent;
+
+	parent = uiControlParent(uiControl(c));
+	if (parent != NULL)
+		uiWindowsControlMinimumSizeChanged(uiWindowsControl(parent));
+}
+
+// TODO rename this nad the OS X this and hugging ones to NotifyChild
+void uiWindowsControlNotifyVisibilityChanged(uiWindowsControl *c)
+{
+	// TODO we really need to figure this out; the duplication is a mess
+	uiWindowsControlContinueMinimumSizeChanged(c);
+}
diff --git a/src/libui_sdl/libui/windows/d2dscratch.cpp b/src/libui_sdl/libui/windows/d2dscratch.cpp
new file mode 100644
index 0000000..6dc2ba5
--- /dev/null
+++ b/src/libui_sdl/libui/windows/d2dscratch.cpp
@@ -0,0 +1,166 @@
+// 17 april 2016
+#include "uipriv_windows.hpp"
+
+// The Direct2D scratch window is a utility for libui internal use to do quick things with Direct2D.
+// To use, call newD2DScratch() passing in a subclass procedure. This subclass procedure should handle the msgD2DScratchPaint message, which has the following usage:
+// - wParam - 0
+// - lParam - ID2D1RenderTarget *
+// - lResult - 0
+// You can optionally also handle msgD2DScratchLButtonDown, which is sent when the left mouse button is either pressed for the first time or held while the mouse is moving.
+// - wParam - position in DIPs, as D2D1_POINT_2F *
+// - lParam - size of render target in DIPs, as D2D1_SIZE_F *
+// - lResult - 0
+// Other messages can also be handled here.
+
+// TODO allow resize
+
+#define d2dScratchClass L"libui_d2dScratchClass"
+
+// TODO clip rect
+static HRESULT d2dScratchDoPaint(HWND hwnd, ID2D1RenderTarget *rt)
+{
+	COLORREF bgcolorref;
+	D2D1_COLOR_F bgcolor;
+
+	rt->BeginDraw();
+
+	// TODO only clear the clip area
+	// TODO clear with actual background brush
+	bgcolorref = GetSysColor(COLOR_BTNFACE);
+	bgcolor.r = ((float) GetRValue(bgcolorref)) / 255.0;
+	// due to utter apathy on Microsoft's part, GetGValue() does not work with MSVC's Run-Time Error Checks
+	// it has not worked since 2008 and they have *never* fixed it
+	// TODO now that -RTCc has just been deprecated entirely, should we switch back?
+	bgcolor.g = ((float) ((BYTE) ((bgcolorref & 0xFF00) >> 8))) / 255.0;
+	bgcolor.b = ((float) GetBValue(bgcolorref)) / 255.0;
+	bgcolor.a = 1.0;
+	rt->Clear(&bgcolor);
+
+	SendMessageW(hwnd, msgD2DScratchPaint, 0, (LPARAM) rt);
+
+	return rt->EndDraw(NULL, NULL);
+}
+
+static void d2dScratchDoLButtonDown(HWND hwnd, ID2D1RenderTarget *rt, LPARAM lParam)
+{
+	double xpix, ypix;
+	FLOAT dpix, dpiy;
+	D2D1_POINT_2F pos;
+	D2D1_SIZE_F size;
+
+	xpix = (double) GET_X_LPARAM(lParam);
+	ypix = (double) GET_Y_LPARAM(lParam);
+	// these are in pixels; we need points
+	// TODO separate the function from areautil.cpp?
+	rt->GetDpi(&dpix, &dpiy);
+	pos.x = (xpix * 96) / dpix;
+	pos.y = (ypix * 96) / dpiy;
+
+	size = realGetSize(rt);
+
+	SendMessageW(hwnd, msgD2DScratchLButtonDown, (WPARAM) (&pos), (LPARAM) (&size));
+}
+
+static LRESULT CALLBACK d2dScratchWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+	LONG_PTR init;
+	ID2D1HwndRenderTarget *rt;
+	ID2D1DCRenderTarget *dcrt;
+	RECT client;
+	HRESULT hr;
+
+	init = GetWindowLongPtrW(hwnd, 0);
+	if (!init) {
+		if (uMsg == WM_CREATE)
+			SetWindowLongPtrW(hwnd, 0, (LONG_PTR) TRUE);
+		return DefWindowProcW(hwnd, uMsg, wParam, lParam);
+	}
+
+	rt = (ID2D1HwndRenderTarget *) GetWindowLongPtrW(hwnd, GWLP_USERDATA);
+	if (rt == NULL) {
+		rt = makeHWNDRenderTarget(hwnd);
+		SetWindowLongPtrW(hwnd, GWLP_USERDATA, (LONG_PTR) rt);
+	}
+
+	switch (uMsg) {
+	case WM_DESTROY:
+		rt->Release();
+		SetWindowLongPtrW(hwnd, 0, (LONG_PTR) FALSE);
+		break;
+	case WM_PAINT:
+		hr = d2dScratchDoPaint(hwnd, rt);
+		switch (hr) {
+		case S_OK:
+			if (ValidateRect(hwnd, NULL) == 0)
+				logLastError(L"error validating D2D scratch control rect");
+			break;
+		case D2DERR_RECREATE_TARGET:
+			// DON'T validate the rect
+			// instead, simply drop the render target
+			// we'll get another WM_PAINT and make the render target again
+			// TODO would this require us to invalidate the entire client area?
+			rt->Release();
+			SetWindowLongPtrW(hwnd, GWLP_USERDATA, (LONG_PTR) NULL);
+			break;
+		default:
+			logHRESULT(L"error drawing D2D scratch window", hr);
+		}
+		return 0;
+	case WM_PRINTCLIENT:
+		uiWindowsEnsureGetClientRect(hwnd, &client);
+		dcrt = makeHDCRenderTarget((HDC) wParam, &client);
+		hr = d2dScratchDoPaint(hwnd, dcrt);
+		if (hr != S_OK)
+			logHRESULT(L"error printing D2D scratch window client area", hr);
+		dcrt->Release();
+		return 0;
+	case WM_LBUTTONDOWN:
+		d2dScratchDoLButtonDown(hwnd, rt, lParam);
+		return 0;
+	case WM_MOUSEMOVE:
+		// also send LButtonDowns when dragging
+		if ((wParam & MK_LBUTTON) != 0)
+			d2dScratchDoLButtonDown(hwnd, rt, lParam);
+		return 0;
+	}
+	return DefWindowProcW(hwnd, uMsg, wParam, lParam);
+}
+
+ATOM registerD2DScratchClass(HICON hDefaultIcon, HCURSOR hDefaultCursor)
+{
+	WNDCLASSW wc;
+
+	ZeroMemory(&wc, sizeof (WNDCLASSW));
+	wc.lpszClassName = d2dScratchClass;
+	wc.lpfnWndProc = d2dScratchWndProc;
+	wc.hInstance = hInstance;
+	wc.hIcon = hDefaultIcon;
+	wc.hCursor = hDefaultCursor;
+	wc.hbrBackground = (HBRUSH) (COLOR_BTNFACE + 1);
+	wc.cbWndExtra = sizeof (LONG_PTR);			// for the init status
+	return RegisterClassW(&wc);
+}
+
+void unregisterD2DScratchClass(void)
+{
+	if (UnregisterClassW(d2dScratchClass, hInstance) == 0)
+		logLastError(L"error unregistering D2D scratch window class");
+}
+
+HWND newD2DScratch(HWND parent, RECT *rect, HMENU controlID, SUBCLASSPROC subclass, DWORD_PTR subclassData)
+{
+	HWND hwnd;
+
+	hwnd = CreateWindowExW(0,
+		d2dScratchClass, L"",
+		WS_CHILD | WS_VISIBLE,
+		rect->left, rect->top,
+		rect->right - rect->left, rect->bottom - rect->top,
+		parent, controlID, hInstance, NULL);
+	if (hwnd == NULL)
+		// TODO return decoy window
+		logLastError(L"error creating D2D scratch window");
+	if (SetWindowSubclass(hwnd, subclass, 0, subclassData) == FALSE)
+		logLastError(L"error subclassing D2D scratch window");
+	return hwnd;
+}
diff --git a/src/libui_sdl/libui/windows/datetimepicker.cpp b/src/libui_sdl/libui/windows/datetimepicker.cpp
new file mode 100644
index 0000000..e105c2f
--- /dev/null
+++ b/src/libui_sdl/libui/windows/datetimepicker.cpp
@@ -0,0 +1,191 @@
+// 22 may 2015
+#include "uipriv_windows.hpp"
+
+struct uiDateTimePicker {
+	uiWindowsControl c;
+	HWND hwnd;
+};
+
+// utility functions
+
+#define GLI(what, buf, n) GetLocaleInfoEx(LOCALE_NAME_USER_DEFAULT, what, buf, n)
+
+// The real date/time picker does a manual replacement of "yy" with "yyyy" for DTS_SHORTDATECENTURYFORMAT.
+// Because we're also duplicating its functionality (see below), we have to do it too.
+static WCHAR *expandYear(WCHAR *dts, int n)
+{
+	WCHAR *out;
+	WCHAR *p, *q;
+	int ny = 0;
+
+	// allocate more than we need to be safe
+	out = (WCHAR *) uiAlloc((n * 3) * sizeof (WCHAR), "WCHAR[]");
+	q = out;
+	for (p = dts; *p != L'\0'; p++) {
+		// first, if the current character is a y, increment the number of consecutive ys
+		// otherwise, stop counting, and if there were only two, add two more to make four
+		if (*p != L'y') {
+			if (ny == 2) {
+				*q++ = L'y';
+				*q++ = L'y';
+			}
+			ny = 0;
+		} else
+			ny++;
+		// next, handle quoted blocks
+		// we do this AFTER the above so yy'abc' becomes yyyy'abc' and not yy'abc'yy
+		// this handles the case of 'a''b' elegantly as well
+		if (*p == L'\'') {
+			// copy the opening quote
+			*q++ = *p;
+			// copy the contents
+			for (;;) {
+				p++;
+				if (*p == L'\'')
+					break;
+				if (*p == L'\0')
+					implbug("unterminated quote in system-provided locale date string in expandYear()");
+				*q++ = *p;
+			}
+			// and fall through to copy the closing quote
+		}
+		// copy the current character
+		*q++ = *p;
+	}
+	// handle trailing yy
+	if (ny == 2) {
+		*q++ = L'y';
+		*q++ = L'y';
+	}
+	*q++ = L'\0';
+	return out;
+}
+
+// Windows has no combined date/time prebuilt constant; we have to build the format string ourselves
+// TODO use a default format if one fails
+static void setDateTimeFormat(HWND hwnd)
+{
+	WCHAR *unexpandedDate, *date;
+	WCHAR *time;
+	WCHAR *datetime;
+	int ndate, ntime;
+
+	ndate = GLI(LOCALE_SSHORTDATE, NULL, 0);
+	if (ndate == 0)
+		logLastError(L"error getting date string length");
+	date = (WCHAR *) uiAlloc(ndate * sizeof (WCHAR), "WCHAR[]");
+	if (GLI(LOCALE_SSHORTDATE, date, ndate) == 0)
+		logLastError(L"error geting date string");
+	unexpandedDate = date;		// so we can free it
+	date = expandYear(unexpandedDate, ndate);
+	uiFree(unexpandedDate);
+
+	ntime = GLI(LOCALE_STIMEFORMAT, NULL, 0);
+	if (ndate == 0)
+		logLastError(L"error getting time string length");
+	time = (WCHAR *) uiAlloc(ntime * sizeof (WCHAR), "WCHAR[]");
+	if (GLI(LOCALE_STIMEFORMAT, time, ntime) == 0)
+		logLastError(L"error geting time string");
+
+	datetime = strf(L"%s %s", date, time);
+	if (SendMessageW(hwnd, DTM_SETFORMAT, 0, (LPARAM) datetime) == 0)
+		logLastError(L"error applying format string to date/time picker");
+
+	uiFree(datetime);
+	uiFree(time);
+	uiFree(date);
+}
+
+// control implementation
+
+static void uiDateTimePickerDestroy(uiControl *c)
+{
+	uiDateTimePicker *d = uiDateTimePicker(c);
+
+	uiWindowsUnregisterReceiveWM_WININICHANGE(d->hwnd);
+	uiWindowsEnsureDestroyWindow(d->hwnd);
+	uiFreeControl(uiControl(d));
+}
+
+uiWindowsControlAllDefaultsExceptDestroy(uiDateTimePicker)
+
+// the height returned from DTM_GETIDEALSIZE is unreliable; see http://stackoverflow.com/questions/30626549/what-is-the-proper-use-of-dtm-getidealsize-treating-the-returned-size-as-pixels
+// from http://msdn.microsoft.com/en-us/library/windows/desktop/dn742486.aspx#sizingandspacing
+#define entryHeight 14
+
+static void uiDateTimePickerMinimumSize(uiWindowsControl *c, int *width, int *height)
+{
+	uiDateTimePicker *d = uiDateTimePicker(c);
+	SIZE s;
+	uiWindowsSizing sizing;
+	int y;
+
+	s.cx = 0;
+	s.cy = 0;
+	SendMessageW(d->hwnd, DTM_GETIDEALSIZE, 0, (LPARAM) (&s));
+	*width = s.cx;
+
+	y = entryHeight;
+	uiWindowsGetSizing(d->hwnd, &sizing);
+	uiWindowsSizingDlgUnitsToPixels(&sizing, NULL, &y);
+	*height = y;
+}
+
+static uiDateTimePicker *finishNewDateTimePicker(DWORD style)
+{
+	uiDateTimePicker *d;
+
+	uiWindowsNewControl(uiDateTimePicker, d);
+
+	d->hwnd = uiWindowsEnsureCreateControlHWND(WS_EX_CLIENTEDGE,
+		DATETIMEPICK_CLASSW, L"",
+		style | WS_TABSTOP,
+		hInstance, NULL,
+		TRUE);
+
+	// automatically update date/time format when user changes locale settings
+	// for the standard styles, this is in the date-time picker itself
+	// for our date/time mode, we do it in a subclass assigned in uiNewDateTimePicker()
+	uiWindowsRegisterReceiveWM_WININICHANGE(d->hwnd);
+
+	return d;
+}
+
+static LRESULT CALLBACK datetimepickerSubProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
+{
+	switch (uMsg) {
+	case WM_WININICHANGE:
+		// we can optimize this by only doing it when the real date/time picker does it
+		// unfortunately, I don't know when that is :/
+		// hopefully this won't hurt
+		setDateTimeFormat(hwnd);
+		return 0;
+	case WM_NCDESTROY:
+		if (RemoveWindowSubclass(hwnd, datetimepickerSubProc, uIdSubclass) == FALSE)
+			logLastError(L"error removing date-time picker locale change handling subclass");
+		break;
+	}
+	return DefSubclassProc(hwnd, uMsg, wParam, lParam);
+}
+
+uiDateTimePicker *uiNewDateTimePicker(void)
+{
+	uiDateTimePicker *d;
+
+	d = finishNewDateTimePicker(0);
+	setDateTimeFormat(d->hwnd);
+	if (SetWindowSubclass(d->hwnd, datetimepickerSubProc, 0, (DWORD_PTR) d) == FALSE)
+		logLastError(L"error subclassing date-time-picker to assist in locale change handling");
+		// TODO set a suitable default in this case
+	return d;
+}
+
+uiDateTimePicker *uiNewDatePicker(void)
+{
+	return finishNewDateTimePicker(DTS_SHORTDATECENTURYFORMAT);
+}
+
+uiDateTimePicker *uiNewTimePicker(void)
+{
+	return finishNewDateTimePicker(DTS_TIMEFORMAT);
+}
diff --git a/src/libui_sdl/libui/windows/debug.cpp b/src/libui_sdl/libui/windows/debug.cpp
new file mode 100644
index 0000000..cfafffd
--- /dev/null
+++ b/src/libui_sdl/libui/windows/debug.cpp
@@ -0,0 +1,84 @@
+// 25 february 2015
+#include "uipriv_windows.hpp"
+
+// LONGTERM disable logging and stopping on no-debug builds
+
+static void printDebug(const WCHAR *msg)
+{
+	OutputDebugStringW(msg);
+}
+
+HRESULT _logLastError(debugargs, const WCHAR *s)
+{
+	DWORD le;
+	WCHAR *msg;
+	WCHAR *formatted;
+	BOOL useFormatted;
+
+	le = GetLastError();
+
+	useFormatted = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, le, 0, (LPWSTR) (&formatted), 0, NULL) != 0;
+	if (!useFormatted)
+		formatted = L"\n";
+	msg = strf(L"[libui] %s:%s:%s() %s: GetLastError() == %I32u %s",
+		file, line, func,
+		s, le, formatted);
+	if (useFormatted)
+		LocalFree(formatted);		// ignore error
+	printDebug(msg);
+	uiFree(msg);
+	DebugBreak();
+
+	SetLastError(le);
+	// a function does not have to set a last error
+	// if the last error we get is actually 0, then HRESULT_FROM_WIN32(0) will return S_OK (0 cast to an HRESULT, since 0 <= 0), which we don't want
+	// prevent this by returning E_FAIL
+	if (le == 0)
+		return E_FAIL;
+	return HRESULT_FROM_WIN32(le);
+}
+
+HRESULT _logHRESULT(debugargs, const WCHAR *s, HRESULT hr)
+{
+	WCHAR *msg;
+	WCHAR *formatted;
+	BOOL useFormatted;
+
+	useFormatted = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, hr, 0, (LPWSTR) (&formatted), 0, NULL) != 0;
+	if (!useFormatted)
+		formatted = L"\n";
+	msg = strf(L"[libui] %s:%s:%s() %s: HRESULT == 0x%08I32X %s",
+		file, line, func,
+		s, hr, formatted);
+	if (useFormatted)
+		LocalFree(formatted);		// ignore error
+	printDebug(msg);
+	uiFree(msg);
+	DebugBreak();
+
+	return hr;
+}
+
+void realbug(const char *file, const char *line, const char *func, const char *prefix, const char *format, va_list ap)
+{
+	va_list ap2;
+	char *msg;
+	size_t n;
+	WCHAR *final;
+
+	va_copy(ap2, ap);
+	n = _vscprintf(format, ap2);
+	va_end(ap2);
+	n++;		// terminating '\0'
+
+	msg = (char *) uiAlloc(n * sizeof (char), "char[]");
+	// includes terminating '\0' according to example in https://msdn.microsoft.com/en-us/library/xa1a1a6z.aspx
+	vsprintf_s(msg, n, format, ap);
+
+	final = strf(L"[libui] %hs:%hs:%hs() %hs%hs\n", file, line, func, prefix, msg);
+	uiFree(msg);
+	printDebug(final);
+	uiFree(final);
+
+	DebugBreak();
+}
diff --git a/src/libui_sdl/libui/windows/draw.cpp b/src/libui_sdl/libui/windows/draw.cpp
new file mode 100644
index 0000000..5f4d29f
--- /dev/null
+++ b/src/libui_sdl/libui/windows/draw.cpp
@@ -0,0 +1,511 @@
+// 7 september 2015
+#include "uipriv_windows.hpp"
+#include "draw.hpp"
+
+ID2D1Factory *d2dfactory = NULL;
+
+HRESULT initDraw(void)
+{
+	D2D1_FACTORY_OPTIONS opts;
+
+	ZeroMemory(&opts, sizeof (D2D1_FACTORY_OPTIONS));
+	// TODO make this an option
+	opts.debugLevel = D2D1_DEBUG_LEVEL_NONE;
+	return D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED,
+		IID_ID2D1Factory,
+		&opts,
+		(void **) (&d2dfactory));
+}
+
+void uninitDraw(void)
+{
+	d2dfactory->Release();
+}
+
+ID2D1HwndRenderTarget *makeHWNDRenderTarget(HWND hwnd)
+{
+	D2D1_RENDER_TARGET_PROPERTIES props;
+	D2D1_HWND_RENDER_TARGET_PROPERTIES hprops;
+	HDC dc;
+	RECT r;
+	ID2D1HwndRenderTarget *rt;
+	HRESULT hr;
+
+	// we need a DC for the DPI
+	// we *could* just use the screen DPI but why when we have a window handle and its DC has a DPI
+	dc = GetDC(hwnd);
+	if (dc == NULL)
+		logLastError(L"error getting DC to find DPI");
+
+	ZeroMemory(&props, sizeof (D2D1_RENDER_TARGET_PROPERTIES));
+	props.type = D2D1_RENDER_TARGET_TYPE_DEFAULT;
+	props.pixelFormat.format = DXGI_FORMAT_UNKNOWN;
+	props.pixelFormat.alphaMode = D2D1_ALPHA_MODE_UNKNOWN;
+	props.dpiX = GetDeviceCaps(dc, LOGPIXELSX);
+	props.dpiY = GetDeviceCaps(dc, LOGPIXELSY);
+	props.usage = D2D1_RENDER_TARGET_USAGE_NONE;
+	props.minLevel = D2D1_FEATURE_LEVEL_DEFAULT;
+
+	if (ReleaseDC(hwnd, dc) == 0)
+		logLastError(L"error releasing DC for finding DPI");
+
+	uiWindowsEnsureGetClientRect(hwnd, &r);
+
+	ZeroMemory(&hprops, sizeof (D2D1_HWND_RENDER_TARGET_PROPERTIES));
+	hprops.hwnd = hwnd;
+	hprops.pixelSize.width = r.right - r.left;
+	hprops.pixelSize.height = r.bottom - r.top;
+	// according to Rick Brewster, some drivers will misbehave if we don't specify this (see http://stackoverflow.com/a/33222983/3408572)
+	hprops.presentOptions = D2D1_PRESENT_OPTIONS_RETAIN_CONTENTS;
+
+	hr = d2dfactory->CreateHwndRenderTarget(
+		&props,
+		&hprops,
+		&rt);
+	if (hr != S_OK)
+		logHRESULT(L"error creating HWND render target", hr);
+	return rt;
+}
+
+ID2D1DCRenderTarget *makeHDCRenderTarget(HDC dc, RECT *r)
+{
+	D2D1_RENDER_TARGET_PROPERTIES props;
+	ID2D1DCRenderTarget *rt;
+	HRESULT hr;
+
+	ZeroMemory(&props, sizeof (D2D1_RENDER_TARGET_PROPERTIES));
+	props.type = D2D1_RENDER_TARGET_TYPE_DEFAULT;
+	props.pixelFormat.format = DXGI_FORMAT_B8G8R8A8_UNORM;
+	props.pixelFormat.alphaMode = D2D1_ALPHA_MODE_PREMULTIPLIED;
+	props.dpiX = GetDeviceCaps(dc, LOGPIXELSX);
+	props.dpiY = GetDeviceCaps(dc, LOGPIXELSY);
+	props.usage = D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE;
+	props.minLevel = D2D1_FEATURE_LEVEL_DEFAULT;
+
+	hr = d2dfactory->CreateDCRenderTarget(&props, &rt);
+	if (hr != S_OK)
+		logHRESULT(L"error creating DC render target", hr);
+	hr = rt->BindDC(dc, r);
+	if (hr != S_OK)
+		logHRESULT(L"error binding DC to DC render target", hr);
+	return rt;
+}
+
+static void resetTarget(ID2D1RenderTarget *rt)
+{
+	D2D1_MATRIX_3X2_F dm;
+
+	// transformations persist
+	// reset to the identity matrix
+	ZeroMemory(&dm, sizeof (D2D1_MATRIX_3X2_F));
+	dm._11 = 1;
+	dm._22 = 1;
+	rt->SetTransform(&dm);
+}
+
+uiDrawContext *newContext(ID2D1RenderTarget *rt)
+{
+	uiDrawContext *c;
+
+	c = uiNew(uiDrawContext);
+	c->rt = rt;
+	c->states = new std::vector<struct drawState>;
+	resetTarget(c->rt);
+	return c;
+}
+
+void freeContext(uiDrawContext *c)
+{
+	if (c->currentClip != NULL)
+		c->currentClip->Release();
+	if (c->states->size() != 0)
+		// TODO do this on other platforms
+		userbug("You did not balance uiDrawSave() and uiDrawRestore() calls.");
+	delete c->states;
+	uiFree(c);
+}
+
+static ID2D1Brush *makeSolidBrush(uiDrawBrush *b, ID2D1RenderTarget *rt, D2D1_BRUSH_PROPERTIES *props)
+{
+	D2D1_COLOR_F color;
+	ID2D1SolidColorBrush *brush;
+	HRESULT hr;
+
+	color.r = b->R;
+	color.g = b->G;
+	color.b = b->B;
+	color.a = b->A;
+
+	hr = rt->CreateSolidColorBrush(
+		&color,
+		props,
+		&brush);
+	if (hr != S_OK)
+		logHRESULT(L"error creating solid brush", hr);
+	return brush;
+}
+
+static ID2D1GradientStopCollection *mkstops(uiDrawBrush *b, ID2D1RenderTarget *rt)
+{
+	ID2D1GradientStopCollection *s;
+	D2D1_GRADIENT_STOP *stops;
+	size_t i;
+	HRESULT hr;
+
+	stops = (D2D1_GRADIENT_STOP *) uiAlloc(b->NumStops * sizeof (D2D1_GRADIENT_STOP), "D2D1_GRADIENT_STOP[]");
+	for (i = 0; i < b->NumStops; i++) {
+		stops[i].position = b->Stops[i].Pos;
+		stops[i].color.r = b->Stops[i].R;
+		stops[i].color.g = b->Stops[i].G;
+		stops[i].color.b = b->Stops[i].B;
+		stops[i].color.a = b->Stops[i].A;
+	}
+
+	hr = rt->CreateGradientStopCollection(
+		stops,
+		b->NumStops,
+		D2D1_GAMMA_2_2,			// this is the default for the C++-only overload of ID2D1RenderTarget::GradientStopCollection()
+		D2D1_EXTEND_MODE_CLAMP,
+		&s);
+	if (hr != S_OK)
+		logHRESULT(L"error creating stop collection", hr);
+
+	uiFree(stops);
+	return s;
+}
+
+static ID2D1Brush *makeLinearBrush(uiDrawBrush *b, ID2D1RenderTarget *rt, D2D1_BRUSH_PROPERTIES *props)
+{
+	ID2D1LinearGradientBrush *brush;
+	D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES gprops;
+	ID2D1GradientStopCollection *stops;
+	HRESULT hr;
+
+	ZeroMemory(&gprops, sizeof (D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES));
+	gprops.startPoint.x = b->X0;
+	gprops.startPoint.y = b->Y0;
+	gprops.endPoint.x = b->X1;
+	gprops.endPoint.y = b->Y1;
+
+	stops = mkstops(b, rt);
+
+	hr = rt->CreateLinearGradientBrush(
+		&gprops,
+		props,
+		stops,
+		&brush);
+	if (hr != S_OK)
+		logHRESULT(L"error creating gradient brush", hr);
+
+	// the example at https://msdn.microsoft.com/en-us/library/windows/desktop/dd756682%28v=vs.85%29.aspx says this is safe to do now
+	stops->Release();
+	return brush;
+}
+
+static ID2D1Brush *makeRadialBrush(uiDrawBrush *b, ID2D1RenderTarget *rt, D2D1_BRUSH_PROPERTIES *props)
+{
+	ID2D1RadialGradientBrush *brush;
+	D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES gprops;
+	ID2D1GradientStopCollection *stops;
+	HRESULT hr;
+
+	ZeroMemory(&gprops, sizeof (D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES));
+	gprops.gradientOriginOffset.x = b->X0 - b->X1;
+	gprops.gradientOriginOffset.y = b->Y0 - b->Y1;
+	gprops.center.x = b->X1;
+	gprops.center.y = b->Y1;
+	gprops.radiusX = b->OuterRadius;
+	gprops.radiusY = b->OuterRadius;
+
+	stops = mkstops(b, rt);
+
+	hr = rt->CreateRadialGradientBrush(
+		&gprops,
+		props,
+		stops,
+		&brush);
+	if (hr != S_OK)
+		logHRESULT(L"error creating gradient brush", hr);
+
+	stops->Release();
+	return brush;
+}
+
+static ID2D1Brush *makeBrush(uiDrawBrush *b, ID2D1RenderTarget *rt)
+{
+	D2D1_BRUSH_PROPERTIES props;
+
+	ZeroMemory(&props, sizeof (D2D1_BRUSH_PROPERTIES));
+	props.opacity = 1.0;
+	// identity matrix
+	props.transform._11 = 1;
+	props.transform._22 = 1;
+
+	switch (b->Type) {
+	case uiDrawBrushTypeSolid:
+		return makeSolidBrush(b, rt, &props);
+	case uiDrawBrushTypeLinearGradient:
+		return makeLinearBrush(b, rt, &props);
+	case uiDrawBrushTypeRadialGradient:
+		return makeRadialBrush(b, rt, &props);
+//	case uiDrawBrushTypeImage:
+//		TODO
+	}
+
+	// TODO do this on all platforms
+	userbug("Invalid brush type %d given to drawing operation.", b->Type);
+	// TODO dummy brush?
+	return NULL;		// make compiler happy
+}
+
+// how clipping works:
+// every fill and stroke is done on a temporary layer with the clip geometry applied to it
+// this is really the only way to clip in Direct2D that doesn't involve opacity images
+// reference counting:
+// - initially the clip is NULL, which means do not use a layer
+// - the first time uiDrawClip() is called, we take a reference on the path passed in (this is also why uiPathEnd() is needed)
+// - every successive time, we create a new PathGeometry and merge the current clip with the new path, releasing the reference we took earlier and taking a reference to the new one
+// - in Save, we take another reference; in Restore we drop the refernece to the existing path geometry and transfer that saved ref to the new path geometry over to the context
+// uiDrawFreePath() doesn't destroy the path geometry, it just drops the reference count, so a clip can exist independent of its path
+
+static ID2D1Layer *applyClip(uiDrawContext *c)
+{
+	ID2D1Layer *layer;
+	D2D1_LAYER_PARAMETERS params;
+	HRESULT hr;
+
+	// if no clip, don't do anything
+	if (c->currentClip == NULL)
+		return NULL;
+
+	// create a layer for clipping
+	// we have to explicitly make the layer because we're still targeting Windows 7
+	hr = c->rt->CreateLayer(NULL, &layer);
+	if (hr != S_OK)
+		logHRESULT(L"error creating clip layer", hr);
+
+	// apply it as the clip
+	ZeroMemory(&params, sizeof (D2D1_LAYER_PARAMETERS));
+	// this is the equivalent of InfiniteRect() in d2d1helper.h
+	params.contentBounds.left = -FLT_MAX;
+	params.contentBounds.top = -FLT_MAX;
+	params.contentBounds.right = FLT_MAX;
+	params.contentBounds.bottom = FLT_MAX;
+	params.geometricMask = (ID2D1Geometry *) (c->currentClip);
+	// TODO is this correct?
+	params.maskAntialiasMode = c->rt->GetAntialiasMode();
+	// identity matrix
+	params.maskTransform._11 = 1;
+	params.maskTransform._22 = 1;
+	params.opacity = 1.0;
+	params.opacityBrush = NULL;
+	params.layerOptions = D2D1_LAYER_OPTIONS_NONE;
+	// TODO is this correct?
+	if (c->rt->GetTextAntialiasMode() == D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE)
+		params.layerOptions = D2D1_LAYER_OPTIONS_INITIALIZE_FOR_CLEARTYPE;
+	c->rt->PushLayer(&params, layer);
+
+	// return the layer so it can be freed later
+	return layer;
+}
+
+static void unapplyClip(uiDrawContext *c, ID2D1Layer *layer)
+{
+	if (layer == NULL)
+		return;
+	c->rt->PopLayer();
+	layer->Release();
+}
+
+void uiDrawStroke(uiDrawContext *c, uiDrawPath *p, uiDrawBrush *b, uiDrawStrokeParams *sp)
+{
+	ID2D1Brush *brush;
+	ID2D1StrokeStyle *style;
+	D2D1_STROKE_STYLE_PROPERTIES dsp;
+	FLOAT *dashes;
+	size_t i;
+	ID2D1Layer *cliplayer;
+	HRESULT hr;
+
+	brush = makeBrush(b, c->rt);
+
+	ZeroMemory(&dsp, sizeof (D2D1_STROKE_STYLE_PROPERTIES));
+	switch (sp->Cap) {
+	case uiDrawLineCapFlat:
+		dsp.startCap = D2D1_CAP_STYLE_FLAT;
+		dsp.endCap = D2D1_CAP_STYLE_FLAT;
+		dsp.dashCap = D2D1_CAP_STYLE_FLAT;
+		break;
+	case uiDrawLineCapRound:
+		dsp.startCap = D2D1_CAP_STYLE_ROUND;
+		dsp.endCap = D2D1_CAP_STYLE_ROUND;
+		dsp.dashCap = D2D1_CAP_STYLE_ROUND;
+		break;
+	case uiDrawLineCapSquare:
+		dsp.startCap = D2D1_CAP_STYLE_SQUARE;
+		dsp.endCap = D2D1_CAP_STYLE_SQUARE;
+		dsp.dashCap = D2D1_CAP_STYLE_SQUARE;
+		break;
+	}
+	switch (sp->Join) {
+	case uiDrawLineJoinMiter:
+		dsp.lineJoin = D2D1_LINE_JOIN_MITER_OR_BEVEL;
+		dsp.miterLimit = sp->MiterLimit;
+		break;
+	case uiDrawLineJoinRound:
+		dsp.lineJoin = D2D1_LINE_JOIN_ROUND;
+		break;
+	case uiDrawLineJoinBevel:
+		dsp.lineJoin = D2D1_LINE_JOIN_BEVEL;
+		break;
+	}
+	dsp.dashStyle = D2D1_DASH_STYLE_SOLID;
+	dashes = NULL;
+	// note that dash widths and the dash phase are scaled up by the thickness by Direct2D
+	// TODO be sure to formally document this
+	if (sp->NumDashes != 0) {
+		dsp.dashStyle = D2D1_DASH_STYLE_CUSTOM;
+		dashes = (FLOAT *) uiAlloc(sp->NumDashes * sizeof (FLOAT), "FLOAT[]");
+		for (i = 0; i < sp->NumDashes; i++)
+			dashes[i] = sp->Dashes[i] / sp->Thickness;
+	}
+	dsp.dashOffset = sp->DashPhase / sp->Thickness;
+	hr = d2dfactory->CreateStrokeStyle(
+		&dsp,
+		dashes,
+		sp->NumDashes,
+		&style);
+	if (hr != S_OK)
+		logHRESULT(L"error creating stroke style", hr);
+	if (sp->NumDashes != 0)
+		uiFree(dashes);
+
+	cliplayer = applyClip(c);
+	c->rt->DrawGeometry(
+		pathGeometry(p),
+		brush,
+		sp->Thickness,
+		style);
+	unapplyClip(c, cliplayer);
+
+	style->Release();
+	brush->Release();
+}
+
+void uiDrawFill(uiDrawContext *c, uiDrawPath *p, uiDrawBrush *b)
+{
+	ID2D1Brush *brush;
+	ID2D1Layer *cliplayer;
+
+	brush = makeBrush(b, c->rt);
+	cliplayer = applyClip(c);
+	c->rt->FillGeometry(
+		pathGeometry(p),
+		brush,
+		NULL);
+	unapplyClip(c, cliplayer);
+	brush->Release();
+}
+
+void uiDrawTransform(uiDrawContext *c, uiDrawMatrix *m)
+{
+	D2D1_MATRIX_3X2_F dm, cur;
+
+	c->rt->GetTransform(&cur);
+	m2d(m, &dm);
+	// you would think we have to do already * m, right?
+	// WRONG! we have to do m * already
+	// why? a few reasons
+	// a) this lovely comment in cairo's source - http://cgit.freedesktop.org/cairo/tree/src/cairo-matrix.c?id=0537479bd1d4c5a3bc0f6f41dec4deb98481f34a#n330
+	// 	Direct2D uses column vectors and I don't know if this is even documented
+	// b) that's what Core Graphics does
+	// TODO see if Microsoft says to do this
+	dm = dm * cur;		// for whatever reason operator * is defined but not operator *=
+	c->rt->SetTransform(&dm);
+}
+
+void uiDrawClip(uiDrawContext *c, uiDrawPath *path)
+{
+	ID2D1PathGeometry *newPath;
+	ID2D1GeometrySink *newSink;
+	HRESULT hr;
+
+	// if there's no current clip, borrow the path
+	if (c->currentClip == NULL) {
+		c->currentClip = pathGeometry(path);
+		// we have to take our own reference to that clip
+		c->currentClip->AddRef();
+		return;
+	}
+
+	// otherwise we have to intersect the current path with the new one
+	// we do that into a new path, and then replace c->currentClip with that new path
+	hr = d2dfactory->CreatePathGeometry(&newPath);
+	if (hr != S_OK)
+		logHRESULT(L"error creating new path", hr);
+	hr = newPath->Open(&newSink);
+	if (hr != S_OK)
+		logHRESULT(L"error opening new path", hr);
+	hr = c->currentClip->CombineWithGeometry(
+		pathGeometry(path),
+		D2D1_COMBINE_MODE_INTERSECT,
+		NULL,
+		// TODO is this correct or can this be set per target?
+		D2D1_DEFAULT_FLATTENING_TOLERANCE,
+		newSink);
+	if (hr != S_OK)
+		logHRESULT(L"error intersecting old path with new path", hr);
+	hr = newSink->Close();
+	if (hr != S_OK)
+		logHRESULT(L"error closing new path", hr);
+	newSink->Release();
+
+	// okay we have the new clip; we just need to replace the old one with it
+	c->currentClip->Release();
+	c->currentClip = newPath;
+	// we have a reference already; no need for another
+}
+
+struct drawState {
+	ID2D1DrawingStateBlock *dsb;
+	ID2D1PathGeometry *clip;
+};
+
+void uiDrawSave(uiDrawContext *c)
+{
+	struct drawState state;
+	HRESULT hr;
+
+	hr = d2dfactory->CreateDrawingStateBlock(
+		// TODO verify that these are correct
+		NULL,
+		NULL,
+		&(state.dsb));
+	if (hr != S_OK)
+		logHRESULT(L"error creating drawing state block", hr);
+	c->rt->SaveDrawingState(state.dsb);
+
+	// if we have a clip, we need to hold another reference to it
+	if (c->currentClip != NULL)
+		c->currentClip->AddRef();
+	state.clip = c->currentClip;		// even if NULL assign it
+
+	c->states->push_back(state);
+}
+
+void uiDrawRestore(uiDrawContext *c)
+{
+	struct drawState state;
+
+	state = (*(c->states))[c->states->size() - 1];
+	c->states->pop_back();
+
+	c->rt->RestoreDrawingState(state.dsb);
+	state.dsb->Release();
+
+	// if we have a current clip, we need to drop it
+	if (c->currentClip != NULL)
+		c->currentClip->Release();
+	// no need to explicitly addref or release; just transfer the ref
+	c->currentClip = state.clip;
+}
diff --git a/src/libui_sdl/libui/windows/draw.hpp b/src/libui_sdl/libui/windows/draw.hpp
new file mode 100644
index 0000000..b015791
--- /dev/null
+++ b/src/libui_sdl/libui/windows/draw.hpp
@@ -0,0 +1,16 @@
+// 5 may 2016
+
+// draw.cpp
+extern ID2D1Factory *d2dfactory;
+struct uiDrawContext {
+	ID2D1RenderTarget *rt;
+	// TODO find out how this works
+	std::vector<struct drawState> *states;
+	ID2D1PathGeometry *currentClip;
+};
+
+// drawpath.cpp
+extern ID2D1PathGeometry *pathGeometry(uiDrawPath *p);
+
+// drawmatrix.cpp
+extern void m2d(uiDrawMatrix *m, D2D1_MATRIX_3X2_F *d);
diff --git a/src/libui_sdl/libui/windows/drawmatrix.cpp b/src/libui_sdl/libui/windows/drawmatrix.cpp
new file mode 100644
index 0000000..090972a
--- /dev/null
+++ b/src/libui_sdl/libui/windows/drawmatrix.cpp
@@ -0,0 +1,117 @@
+// 7 september 2015
+#include "uipriv_windows.hpp"
+#include "draw.hpp"
+
+void m2d(uiDrawMatrix *m, D2D1_MATRIX_3X2_F *d)
+{
+	d->_11 = m->M11;
+	d->_12 = m->M12;
+	d->_21 = m->M21;
+	d->_22 = m->M22;
+	d->_31 = m->M31;
+	d->_32 = m->M32;
+}
+
+static void d2m(D2D1_MATRIX_3X2_F *d, uiDrawMatrix *m)
+{
+	m->M11 = d->_11;
+	m->M12 = d->_12;
+	m->M21 = d->_21;
+	m->M22 = d->_22;
+	m->M31 = d->_31;
+	m->M32 = d->_32;
+}
+
+void uiDrawMatrixTranslate(uiDrawMatrix *m, double x, double y)
+{
+	D2D1_MATRIX_3X2_F dm;
+
+	m2d(m, &dm);
+	dm = dm * D2D1::Matrix3x2F::Translation(x, y);
+	d2m(&dm, m);
+}
+
+void uiDrawMatrixScale(uiDrawMatrix *m, double xCenter, double yCenter, double x, double y)
+{
+	D2D1_MATRIX_3X2_F dm;
+	D2D1_POINT_2F center;
+
+	m2d(m, &dm);
+	center.x = xCenter;
+	center.y = yCenter;
+	dm = dm * D2D1::Matrix3x2F::Scale(x, y, center);
+	d2m(&dm, m);
+}
+
+#define r2d(x) (x * (180.0 / uiPi))
+
+void uiDrawMatrixRotate(uiDrawMatrix *m, double x, double y, double amount)
+{
+	D2D1_MATRIX_3X2_F dm;
+	D2D1_POINT_2F center;
+
+	m2d(m, &dm);
+	center.x = x;
+	center.y = y;
+	dm = dm * D2D1::Matrix3x2F::Rotation(r2d(amount), center);
+	d2m(&dm, m);
+}
+
+void uiDrawMatrixSkew(uiDrawMatrix *m, double x, double y, double xamount, double yamount)
+{
+	D2D1_MATRIX_3X2_F dm;
+	D2D1_POINT_2F center;
+
+	m2d(m, &dm);
+	center.x = x;
+	center.y = y;
+	dm = dm * D2D1::Matrix3x2F::Skew(r2d(xamount), r2d(yamount), center);
+	d2m(&dm, m);
+}
+
+void uiDrawMatrixMultiply(uiDrawMatrix *dest, uiDrawMatrix *src)
+{
+	D2D1_MATRIX_3X2_F c, d;
+
+	m2d(dest, &c);
+	m2d(src, &d);
+	c = c * d;
+	d2m(&c, dest);
+}
+
+int uiDrawMatrixInvertible(uiDrawMatrix *m)
+{
+	D2D1_MATRIX_3X2_F d;
+
+	m2d(m, &d);
+	return D2D1IsMatrixInvertible(&d) != FALSE;
+}
+
+int uiDrawMatrixInvert(uiDrawMatrix *m)
+{
+	D2D1_MATRIX_3X2_F d;
+
+	m2d(m, &d);
+	if (D2D1InvertMatrix(&d) == FALSE)
+		return 0;
+	d2m(&d, m);
+	return 1;
+}
+
+void uiDrawMatrixTransformPoint(uiDrawMatrix *m, double *x, double *y)
+{
+	D2D1::Matrix3x2F dm;
+	D2D1_POINT_2F pt;
+
+	m2d(m, &dm);
+	pt.x = *x;
+	pt.y = *y;
+	pt = dm.TransformPoint(pt);
+	*x = pt.x;
+	*y = pt.y;
+}
+
+void uiDrawMatrixTransformSize(uiDrawMatrix *m, double *x, double *y)
+{
+	fallbackTransformSize(m, x, y);
+}
diff --git a/src/libui_sdl/libui/windows/drawpath.cpp b/src/libui_sdl/libui/windows/drawpath.cpp
new file mode 100644
index 0000000..49855be
--- /dev/null
+++ b/src/libui_sdl/libui/windows/drawpath.cpp
@@ -0,0 +1,246 @@
+// 7 september 2015
+#include "uipriv_windows.hpp"
+#include "draw.hpp"
+
+// TODO
+// - write a test for transform followed by clip and clip followed by transform to make sure they work the same as on gtk+ and cocoa
+// - write a test for nested transforms for gtk+
+
+struct uiDrawPath {
+	ID2D1PathGeometry *path;
+	ID2D1GeometrySink *sink;
+	BOOL inFigure;
+};
+
+uiDrawPath *uiDrawNewPath(uiDrawFillMode fillmode)
+{
+	uiDrawPath *p;
+	HRESULT hr;
+
+	p = uiNew(uiDrawPath);
+	hr = d2dfactory->CreatePathGeometry(&(p->path));
+	if (hr != S_OK)
+		logHRESULT(L"error creating path", hr);
+	hr = p->path->Open(&(p->sink));
+	if (hr != S_OK)
+		logHRESULT(L"error opening path", hr);
+	switch (fillmode) {
+	case uiDrawFillModeWinding:
+		p->sink->SetFillMode(D2D1_FILL_MODE_WINDING);
+		break;
+	case uiDrawFillModeAlternate:
+		p->sink->SetFillMode(D2D1_FILL_MODE_ALTERNATE);
+		break;
+	}
+	return p;
+}
+
+void uiDrawFreePath(uiDrawPath *p)
+{
+	if (p->inFigure)
+		p->sink->EndFigure(D2D1_FIGURE_END_OPEN);
+	if (p->sink != NULL)
+		// TODO close sink first?
+		p->sink->Release();
+	p->path->Release();
+	uiFree(p);
+}
+
+void uiDrawPathNewFigure(uiDrawPath *p, double x, double y)
+{
+	D2D1_POINT_2F pt;
+
+	if (p->inFigure)
+		p->sink->EndFigure(D2D1_FIGURE_END_OPEN);
+	pt.x = x;
+	pt.y = y;
+	p->sink->BeginFigure(pt, D2D1_FIGURE_BEGIN_FILLED);
+	p->inFigure = TRUE;
+}
+
+// Direct2D arcs require a little explanation.
+// An arc in Direct2D is defined by the chord between the endpoints.
+// There are four possible arcs with the same two endpoints that you can draw this way.
+// See https://www.youtube.com/watch?v=ATS0ANW1UxQ for a demonstration.
+// There is a property rotationAngle which deals with the rotation /of the entire ellipse that forms an ellpitical arc/ - it's effectively a transformation on the arc.
+// That is to say, it's NOT THE SWEEP.
+// The sweep is defined by the start and end points and whether the arc is "large".
+// As a result, this design does not allow for full circles or ellipses with a single arc; they have to be simulated with two.
+
+struct arc {
+	double xCenter;
+	double yCenter;
+	double radius;
+	double startAngle;
+	double sweep;
+	int negative;
+};
+
+// this is used for the comparison below
+// if it falls apart it can be changed later
+#define aerMax 6 * DBL_EPSILON
+
+static void drawArc(uiDrawPath *p, struct arc *a, void (*startFunction)(uiDrawPath *, double, double))
+{
+	double sinx, cosx;
+	double startX, startY;
+	double endX, endY;
+	D2D1_ARC_SEGMENT as;
+	BOOL fullCircle;
+	double absSweep;
+
+	// as above, we can't do a full circle with one arc
+	// simulate it with two half-circles
+	// of course, we have a dragon: equality on floating-point values!
+	// I've chosen to do the AlmostEqualRelative() technique in https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
+	fullCircle = FALSE;
+	// use the absolute value to tackle both ≥2π and ≤-2π at the same time
+	absSweep = fabs(a->sweep);
+	if (absSweep > (2 * uiPi))		// this part is easy
+		fullCircle = TRUE;
+	else {
+		double aerDiff;
+
+		aerDiff = fabs(absSweep - (2 * uiPi));
+		// if we got here then we know a->sweep is larger (or the same!)
+		fullCircle = aerDiff <= absSweep * aerMax;
+	}
+	// TODO make sure this works right for the negative direction
+	if (fullCircle) {
+		a->sweep = uiPi;
+		drawArc(p, a, startFunction);
+		a->startAngle += uiPi;
+		drawArc(p, a, NULL);
+		return;
+	}
+
+	// first, figure out the arc's endpoints
+	// unfortunately D2D1SinCos() is only defined on Windows 8 and newer
+	// the MSDN page doesn't say this, but says it requires d2d1_1.h, which is listed as only supported on Windows 8 and newer elsewhere on MSDN
+	// so we must use sin() and cos() and hope it's right...
+	sinx = sin(a->startAngle);
+	cosx = cos(a->startAngle);
+	startX = a->xCenter + a->radius * cosx;
+	startY = a->yCenter + a->radius * sinx;
+	sinx = sin(a->startAngle + a->sweep);
+	cosx = cos(a->startAngle + a->sweep);
+	endX = a->xCenter + a->radius * cosx;
+	endY = a->yCenter + a->radius * sinx;
+
+	// now do the initial step to get the current point to be the start point
+	// this is either creating a new figure, drawing a line, or (in the case of our full circle code above) doing nothing
+	if (startFunction != NULL)
+		(*startFunction)(p, startX, startY);
+
+	// now we can draw the arc
+	as.point.x = endX;
+	as.point.y = endY;
+	as.size.width = a->radius;
+	as.size.height = a->radius;
+	as.rotationAngle = 0;		// as above, not relevant for circles
+	if (a->negative)
+		as.sweepDirection = D2D1_SWEEP_DIRECTION_COUNTER_CLOCKWISE;
+	else
+		as.sweepDirection = D2D1_SWEEP_DIRECTION_CLOCKWISE;
+	// TODO explain the outer if
+	if (!a->negative)
+		if (a->sweep > uiPi)
+			as.arcSize = D2D1_ARC_SIZE_LARGE;
+		else
+			as.arcSize = D2D1_ARC_SIZE_SMALL;
+	else
+		// TODO especially this part
+		if (a->sweep > uiPi)
+			as.arcSize = D2D1_ARC_SIZE_SMALL;
+		else
+			as.arcSize = D2D1_ARC_SIZE_LARGE;
+	p->sink->AddArc(&as);
+}
+
+void uiDrawPathNewFigureWithArc(uiDrawPath *p, double xCenter, double yCenter, double radius, double startAngle, double sweep, int negative)
+{
+	struct arc a;
+
+	a.xCenter = xCenter;
+	a.yCenter = yCenter;
+	a.radius = radius;
+	a.startAngle = startAngle;
+	a.sweep = sweep;
+	a.negative = negative;
+	drawArc(p, &a, uiDrawPathNewFigure);
+}
+
+void uiDrawPathLineTo(uiDrawPath *p, double x, double y)
+{
+	D2D1_POINT_2F pt;
+
+	pt.x = x;
+	pt.y = y;
+	p->sink->AddLine(pt);
+}
+
+void uiDrawPathArcTo(uiDrawPath *p, double xCenter, double yCenter, double radius, double startAngle, double sweep, int negative)
+{
+	struct arc a;
+
+	a.xCenter = xCenter;
+	a.yCenter = yCenter;
+	a.radius = radius;
+	a.startAngle = startAngle;
+	a.sweep = sweep;
+	a.negative = negative;
+	drawArc(p, &a, uiDrawPathLineTo);
+}
+
+void uiDrawPathBezierTo(uiDrawPath *p, double c1x, double c1y, double c2x, double c2y, double endX, double endY)
+{
+	D2D1_BEZIER_SEGMENT s;
+
+	s.point1.x = c1x;
+	s.point1.y = c1y;
+	s.point2.x = c2x;
+	s.point2.y = c2y;
+	s.point3.x = endX;
+	s.point3.y = endY;
+	p->sink->AddBezier(&s);
+}
+
+void uiDrawPathCloseFigure(uiDrawPath *p)
+{
+	p->sink->EndFigure(D2D1_FIGURE_END_CLOSED);
+	p->inFigure = FALSE;
+}
+
+void uiDrawPathAddRectangle(uiDrawPath *p, double x, double y, double width, double height)
+{
+	// this is the same algorithm used by cairo and Core Graphics, according to their documentations
+	uiDrawPathNewFigure(p, x, y);
+	uiDrawPathLineTo(p, x + width, y);
+	uiDrawPathLineTo(p, x + width, y + height);
+	uiDrawPathLineTo(p, x, y + height);
+	uiDrawPathCloseFigure(p);
+}
+
+void uiDrawPathEnd(uiDrawPath *p)
+{
+	HRESULT hr;
+
+	if (p->inFigure) {
+		p->sink->EndFigure(D2D1_FIGURE_END_OPEN);
+		// needed for uiDrawFreePath()
+		p->inFigure = FALSE;
+	}
+	hr = p->sink->Close();
+	if (hr != S_OK)
+		logHRESULT(L"error closing path", hr);
+	p->sink->Release();
+	// also needed for uiDrawFreePath()
+	p->sink = NULL;
+}
+
+ID2D1PathGeometry *pathGeometry(uiDrawPath *p)
+{
+	if (p->sink != NULL)
+		userbug("You cannot draw with a uiDrawPath that was not ended. (path: %p)", p);
+	return p->path;
+}
diff --git a/src/libui_sdl/libui/windows/drawtext.cpp b/src/libui_sdl/libui/windows/drawtext.cpp
new file mode 100644
index 0000000..05a24f6
--- /dev/null
+++ b/src/libui_sdl/libui/windows/drawtext.cpp
@@ -0,0 +1,531 @@
+// 22 december 2015
+#include "uipriv_windows.hpp"
+#include "draw.hpp"
+// TODO really migrate
+
+// notes:
+// only available in windows 8 and newer:
+// - character spacing
+// - kerning control
+// - justficiation (how could I possibly be making this up?!)
+// - vertical text (SERIOUSLY?! WHAT THE ACTUAL FUCK, MICROSOFT?!?!?!? DID YOU NOT THINK ABOUT THIS THE FIRST TIME, TRYING TO IMPROVE THE INTERNATIONALIZATION OF WINDOWS 7?!?!?! bonus: some parts of MSDN even say 8.1 and up only!)
+
+struct uiDrawFontFamilies {
+	fontCollection *fc;
+};
+
+uiDrawFontFamilies *uiDrawListFontFamilies(void)
+{
+	struct uiDrawFontFamilies *ff;
+
+	ff = uiNew(struct uiDrawFontFamilies);
+	ff->fc = loadFontCollection();
+	return ff;
+}
+
+int uiDrawFontFamiliesNumFamilies(uiDrawFontFamilies *ff)
+{
+	return ff->fc->fonts->GetFontFamilyCount();
+}
+
+char *uiDrawFontFamiliesFamily(uiDrawFontFamilies *ff, int n)
+{
+	IDWriteFontFamily *family;
+	WCHAR *wname;
+	char *name;
+	HRESULT hr;
+
+	hr = ff->fc->fonts->GetFontFamily(n, &family);
+	if (hr != S_OK)
+		logHRESULT(L"error getting font out of collection", hr);
+	wname = fontCollectionFamilyName(ff->fc, family);
+	name = toUTF8(wname);
+	uiFree(wname);
+	family->Release();
+	return name;
+}
+
+void uiDrawFreeFontFamilies(uiDrawFontFamilies *ff)
+{
+	fontCollectionFree(ff->fc);
+	uiFree(ff);
+}
+
+struct uiDrawTextFont {
+	IDWriteFont *f;
+	WCHAR *family;		// save for convenience in uiDrawNewTextLayout()
+	double size;
+};
+
+uiDrawTextFont *mkTextFont(IDWriteFont *df, BOOL addRef, WCHAR *family, BOOL copyFamily, double size)
+{
+	uiDrawTextFont *font;
+	WCHAR *copy;
+	HRESULT hr;
+
+	font = uiNew(uiDrawTextFont);
+	font->f = df;
+	if (addRef)
+		font->f->AddRef();
+	if (copyFamily) {
+		copy = (WCHAR *) uiAlloc((wcslen(family) + 1) * sizeof (WCHAR), "WCHAR[]");
+		wcscpy(copy, family);
+		font->family = copy;
+	} else
+		font->family = family;
+	font->size = size;
+	return font;
+}
+
+// TODO consider moving these all to dwrite.cpp
+
+// TODO MinGW-w64 is missing this one
+#define DWRITE_FONT_WEIGHT_SEMI_LIGHT (DWRITE_FONT_WEIGHT(350))
+static const struct {
+	bool lastOne;
+	uiDrawTextWeight uival;
+	DWRITE_FONT_WEIGHT dwval;
+} dwriteWeights[] = {
+	{ false, uiDrawTextWeightThin, DWRITE_FONT_WEIGHT_THIN },
+	{ false, uiDrawTextWeightUltraLight, DWRITE_FONT_WEIGHT_ULTRA_LIGHT },
+	{ false, uiDrawTextWeightLight, DWRITE_FONT_WEIGHT_LIGHT },
+	{ false, uiDrawTextWeightBook, DWRITE_FONT_WEIGHT_SEMI_LIGHT },
+	{ false, uiDrawTextWeightNormal, DWRITE_FONT_WEIGHT_NORMAL },
+	{ false, uiDrawTextWeightMedium, DWRITE_FONT_WEIGHT_MEDIUM },
+	{ false, uiDrawTextWeightSemiBold, DWRITE_FONT_WEIGHT_SEMI_BOLD },
+	{ false, uiDrawTextWeightBold, DWRITE_FONT_WEIGHT_BOLD },
+	{ false, uiDrawTextWeightUltraBold, DWRITE_FONT_WEIGHT_ULTRA_BOLD },
+	{ false, uiDrawTextWeightHeavy, DWRITE_FONT_WEIGHT_HEAVY },
+	{ true, uiDrawTextWeightUltraHeavy, DWRITE_FONT_WEIGHT_ULTRA_BLACK, },
+};
+
+static const struct {
+	bool lastOne;
+	uiDrawTextItalic uival;
+	DWRITE_FONT_STYLE dwval;
+} dwriteItalics[] = {
+	{ false, uiDrawTextItalicNormal, DWRITE_FONT_STYLE_NORMAL },
+	{ false, uiDrawTextItalicOblique, DWRITE_FONT_STYLE_OBLIQUE },
+	{ true, uiDrawTextItalicItalic, DWRITE_FONT_STYLE_ITALIC },
+};
+
+static const struct {
+	bool lastOne;
+	uiDrawTextStretch uival;
+	DWRITE_FONT_STRETCH dwval;
+} dwriteStretches[] = {
+	{ false, uiDrawTextStretchUltraCondensed, DWRITE_FONT_STRETCH_ULTRA_CONDENSED },
+	{ false, uiDrawTextStretchExtraCondensed, DWRITE_FONT_STRETCH_EXTRA_CONDENSED },
+	{ false, uiDrawTextStretchCondensed, DWRITE_FONT_STRETCH_CONDENSED },
+	{ false, uiDrawTextStretchSemiCondensed, DWRITE_FONT_STRETCH_SEMI_CONDENSED },
+	{ false, uiDrawTextStretchNormal, DWRITE_FONT_STRETCH_NORMAL },
+	{ false, uiDrawTextStretchSemiExpanded, DWRITE_FONT_STRETCH_SEMI_EXPANDED },
+	{ false, uiDrawTextStretchExpanded, DWRITE_FONT_STRETCH_EXPANDED },
+	{ false, uiDrawTextStretchExtraExpanded, DWRITE_FONT_STRETCH_EXTRA_EXPANDED },
+	{ true, uiDrawTextStretchUltraExpanded, DWRITE_FONT_STRETCH_ULTRA_EXPANDED },
+};
+
+void attrToDWriteAttr(struct dwriteAttr *attr)
+{
+	bool found;
+	int i;
+
+	found = false;
+	for (i = 0; ; i++) {
+		if (dwriteWeights[i].uival == attr->weight) {
+			attr->dweight = dwriteWeights[i].dwval;
+			found = true;
+			break;
+		}
+		if (dwriteWeights[i].lastOne)
+			break;
+	}
+	if (!found)
+		userbug("Invalid text weight %d passed to text function.", attr->weight);
+
+	found = false;
+	for (i = 0; ; i++) {
+		if (dwriteItalics[i].uival == attr->italic) {
+			attr->ditalic = dwriteItalics[i].dwval;
+			found = true;
+			break;
+		}
+		if (dwriteItalics[i].lastOne)
+			break;
+	}
+	if (!found)
+		userbug("Invalid text italic %d passed to text function.", attr->italic);
+
+	found = false;
+	for (i = 0; ; i++) {
+		if (dwriteStretches[i].uival == attr->stretch) {
+			attr->dstretch = dwriteStretches[i].dwval;
+			found = true;
+			break;
+		}
+		if (dwriteStretches[i].lastOne)
+			break;
+	}
+	if (!found)
+		// TODO on other platforms too
+		userbug("Invalid text stretch %d passed to text function.", attr->stretch);
+}
+
+void dwriteAttrToAttr(struct dwriteAttr *attr)
+{
+	int weight, against, n;
+	int curdiff, curindex;
+	bool found;
+	int i;
+
+	// weight is scaled; we need to test to see what's nearest
+	weight = (int) (attr->dweight);
+	against = (int) (dwriteWeights[0].dwval);
+	curdiff = abs(against - weight);
+	curindex = 0;
+	for (i = 1; ; i++) {
+		against = (int) (dwriteWeights[i].dwval);
+		n = abs(against - weight);
+		if (n < curdiff) {
+			curdiff = n;
+			curindex = i;
+		}
+		if (dwriteWeights[i].lastOne)
+			break;
+	}
+	attr->weight = dwriteWeights[i].uival;
+
+	// italic and stretch are simple values; we can just do a matching search
+	found = false;
+	for (i = 0; ; i++) {
+		if (dwriteItalics[i].dwval == attr->ditalic) {
+			attr->italic = dwriteItalics[i].uival;
+			found = true;
+			break;
+		}
+		if (dwriteItalics[i].lastOne)
+			break;
+	}
+	if (!found)
+		// these are implbug()s because users shouldn't be able to get here directly; TODO?
+		implbug("invalid italic %d passed to dwriteAttrToAttr()", attr->ditalic);
+
+	found = false;
+	for (i = 0; ; i++) {
+		if (dwriteStretches[i].dwval == attr->dstretch) {
+			attr->stretch = dwriteStretches[i].uival;
+			found = true;
+			break;
+		}
+		if (dwriteStretches[i].lastOne)
+			break;
+	}
+	if (!found)
+		implbug("invalid stretch %d passed to dwriteAttrToAttr()", attr->dstretch);
+}
+
+uiDrawTextFont *uiDrawLoadClosestFont(const uiDrawTextFontDescriptor *desc)
+{
+	uiDrawTextFont *font;
+	IDWriteFontCollection *collection;
+	UINT32 index;
+	BOOL exists;
+	struct dwriteAttr attr;
+	IDWriteFontFamily *family;
+	WCHAR *wfamily;
+	IDWriteFont *match;
+	HRESULT hr;
+
+	// always get the latest available font information
+	hr = dwfactory->GetSystemFontCollection(&collection, TRUE);
+	if (hr != S_OK)
+		logHRESULT(L"error getting system font collection", hr);
+
+	wfamily = toUTF16(desc->Family);
+	hr = collection->FindFamilyName(wfamily, &index, &exists);
+	if (hr != S_OK)
+		logHRESULT(L"error finding font family", hr);
+	if (!exists)
+		implbug("LONGTERM family not found in uiDrawLoadClosestFont()", hr);
+	hr = collection->GetFontFamily(index, &family);
+	if (hr != S_OK)
+		logHRESULT(L"error loading font family", hr);
+
+	attr.weight = desc->Weight;
+	attr.italic = desc->Italic;
+	attr.stretch = desc->Stretch;
+	attrToDWriteAttr(&attr);
+	hr = family->GetFirstMatchingFont(
+		attr.dweight,
+		attr.dstretch,
+		attr.ditalic,
+		&match);
+	if (hr != S_OK)
+		logHRESULT(L"error loading font", hr);
+
+	font = mkTextFont(match,
+		FALSE,				// we own the initial reference; no need to add another one
+		wfamily, FALSE,		// will be freed with font
+		desc->Size);
+
+	family->Release();
+	collection->Release();
+
+	return font;
+}
+
+void uiDrawFreeTextFont(uiDrawTextFont *font)
+{
+	font->f->Release();
+	uiFree(font->family);
+	uiFree(font);
+}
+
+uintptr_t uiDrawTextFontHandle(uiDrawTextFont *font)
+{
+	return (uintptr_t) (font->f);
+}
+
+void uiDrawTextFontDescribe(uiDrawTextFont *font, uiDrawTextFontDescriptor *desc)
+{
+	// TODO
+
+	desc->Size = font->size;
+
+	// TODO
+}
+
+// text sizes are 1/72 of an inch
+// points in Direct2D are 1/96 of an inch (https://msdn.microsoft.com/en-us/library/windows/desktop/ff684173%28v=vs.85%29.aspx, https://msdn.microsoft.com/en-us/library/windows/desktop/hh447022%28v=vs.85%29.aspx)
+// As for the actual conversion from design units, see:
+// - http://cboard.cprogramming.com/windows-programming/136733-directwrite-font-height-issues.html
+// - https://sourceforge.net/p/vstgui/mailman/message/32483143/
+// - http://xboxforums.create.msdn.com/forums/t/109445.aspx
+// - https://msdn.microsoft.com/en-us/library/dd183564%28v=vs.85%29.aspx
+// - http://www.fontbureau.com/blog/the-em/
+// TODO make points here about how DIPs in DirectWrite == DIPs in Direct2D; if not, figure out what they really are? for the width and layout functions later
+static double scaleUnits(double what, double designUnitsPerEm, double size)
+{
+	return (what / designUnitsPerEm) * (size * (96.0 / 72.0));
+}
+
+void uiDrawTextFontGetMetrics(uiDrawTextFont *font, uiDrawTextFontMetrics *metrics)
+{
+	DWRITE_FONT_METRICS dm;
+
+	font->f->GetMetrics(&dm);
+	metrics->Ascent = scaleUnits(dm.ascent, dm.designUnitsPerEm, font->size);
+	metrics->Descent = scaleUnits(dm.descent, dm.designUnitsPerEm, font->size);
+	// TODO what happens if dm.xxx is negative?
+	// TODO remember what this was for
+	metrics->Leading = scaleUnits(dm.lineGap, dm.designUnitsPerEm, font->size);
+	metrics->UnderlinePos = scaleUnits(dm.underlinePosition, dm.designUnitsPerEm, font->size);
+	metrics->UnderlineThickness = scaleUnits(dm.underlineThickness, dm.designUnitsPerEm, font->size);
+}
+
+// some attributes, such as foreground color, can't be applied until after we establish a Direct2D context :/ so we have to prepare all attributes in advance
+// also since there's no way to clear the attributes from a layout en masse (apart from overwriting them all), we'll play it safe by creating a new layout each time
+enum layoutAttrType {
+	layoutAttrColor,
+};
+
+struct layoutAttr {
+	enum layoutAttrType type;
+	int start;
+	int end;
+	double components[4];
+};
+
+struct uiDrawTextLayout {
+	WCHAR *text;
+	size_t textlen;
+	size_t *graphemes;
+	double width;
+	IDWriteTextFormat *format;
+	std::vector<struct layoutAttr> *attrs;
+};
+
+uiDrawTextLayout *uiDrawNewTextLayout(const char *text, uiDrawTextFont *defaultFont, double width)
+{
+	uiDrawTextLayout *layout;
+	HRESULT hr;
+
+	layout = uiNew(uiDrawTextLayout);
+
+	hr = dwfactory->CreateTextFormat(defaultFont->family,
+		NULL,
+		defaultFont->f->GetWeight(),
+		defaultFont->f->GetStyle(),
+		defaultFont->f->GetStretch(),
+		// typographic points are 1/72 inch; this parameter is 1/96 inch
+		// fortunately Microsoft does this too, in https://msdn.microsoft.com/en-us/library/windows/desktop/dd371554%28v=vs.85%29.aspx
+		defaultFont->size * (96.0 / 72.0),
+		// see http://stackoverflow.com/questions/28397971/idwritefactorycreatetextformat-failing and https://msdn.microsoft.com/en-us/library/windows/desktop/dd368203.aspx
+		// TODO use the current locale again?
+		L"",
+		&(layout->format));
+	if (hr != S_OK)
+		logHRESULT(L"error creating IDWriteTextFormat", hr);
+
+	layout->text = toUTF16(text);
+	layout->textlen = wcslen(layout->text);
+	layout->graphemes = graphemes(layout->text);
+
+	uiDrawTextLayoutSetWidth(layout, width);
+
+	layout->attrs = new std::vector<struct layoutAttr>;
+
+	return layout;
+}
+
+void uiDrawFreeTextLayout(uiDrawTextLayout *layout)
+{
+	delete layout->attrs;
+	layout->format->Release();
+	uiFree(layout->graphemes);
+	uiFree(layout->text);
+	uiFree(layout);
+}
+
+static ID2D1SolidColorBrush *mkSolidBrush(ID2D1RenderTarget *rt, double r, double g, double b, double a)
+{
+	D2D1_BRUSH_PROPERTIES props;
+	D2D1_COLOR_F color;
+	ID2D1SolidColorBrush *brush;
+	HRESULT hr;
+
+	ZeroMemory(&props, sizeof (D2D1_BRUSH_PROPERTIES));
+	props.opacity = 1.0;
+	// identity matrix
+	props.transform._11 = 1;
+	props.transform._22 = 1;
+	color.r = r;
+	color.g = g;
+	color.b = b;
+	color.a = a;
+	hr = rt->CreateSolidColorBrush(
+		&color,
+		&props,
+		&brush);
+	if (hr != S_OK)
+		logHRESULT(L"error creating solid brush", hr);
+	return brush;
+}
+
+IDWriteTextLayout *prepareLayout(uiDrawTextLayout *layout, ID2D1RenderTarget *rt)
+{
+	IDWriteTextLayout *dl;
+	DWRITE_TEXT_RANGE range;
+	IUnknown *unkBrush;
+	DWRITE_WORD_WRAPPING wrap;
+	FLOAT maxWidth;
+	HRESULT hr;
+
+	hr = dwfactory->CreateTextLayout(layout->text, layout->textlen,
+		layout->format,
+		// FLOAT is float, not double, so this should work... TODO
+		FLT_MAX, FLT_MAX,
+		&dl);
+	if (hr != S_OK)
+		logHRESULT(L"error creating IDWriteTextLayout", hr);
+
+	for (const struct layoutAttr &attr : *(layout->attrs)) {
+		range.startPosition = layout->graphemes[attr.start];
+		range.length = layout->graphemes[attr.end] - layout->graphemes[attr.start];
+		switch (attr.type) {
+		case layoutAttrColor:
+			if (rt == NULL)		// determining extents, not drawing
+				break;
+			unkBrush = mkSolidBrush(rt,
+				attr.components[0],
+				attr.components[1],
+				attr.components[2],
+				attr.components[3]);
+			hr = dl->SetDrawingEffect(unkBrush, range);
+			unkBrush->Release();		// associated with dl
+			break;
+		default:
+			hr = E_FAIL;
+			logHRESULT(L"invalid text attribute type", hr);
+		}
+		if (hr != S_OK)
+			logHRESULT(L"error adding attribute to text layout", hr);
+	}
+
+	// and set the width
+	// this is the only wrapping mode (apart from "no wrap") available prior to Windows 8.1
+	wrap = DWRITE_WORD_WRAPPING_WRAP;
+	maxWidth = layout->width;
+	if (layout->width < 0) {
+		wrap = DWRITE_WORD_WRAPPING_NO_WRAP;
+		// setting the max width in this case technically isn't needed since the wrap mode will simply ignore the max width, but let's do it just to be safe
+		maxWidth = FLT_MAX;		// see TODO above
+	}
+	hr = dl->SetWordWrapping(wrap);
+	if (hr != S_OK)
+		logHRESULT(L"error setting word wrapping mode", hr);
+	hr = dl->SetMaxWidth(maxWidth);
+	if (hr != S_OK)
+		logHRESULT(L"error setting max layout width", hr);
+
+	return dl;
+}
+
+
+void uiDrawTextLayoutSetWidth(uiDrawTextLayout *layout, double width)
+{
+	layout->width = width;
+}
+
+// TODO for a single line the height includes the leading; it should not
+void uiDrawTextLayoutExtents(uiDrawTextLayout *layout, double *width, double *height)
+{
+	IDWriteTextLayout *dl;
+	DWRITE_TEXT_METRICS metrics;
+	HRESULT hr;
+
+	dl = prepareLayout(layout, NULL);
+	hr = dl->GetMetrics(&metrics);
+	if (hr != S_OK)
+		logHRESULT(L"error getting layout metrics", hr);
+	*width = metrics.width;
+	// TODO make sure the behavior of this on empty strings is the same on all platforms
+	*height = metrics.height;
+	dl->Release();
+}
+
+void uiDrawText(uiDrawContext *c, double x, double y, uiDrawTextLayout *layout)
+{
+	IDWriteTextLayout *dl;
+	D2D1_POINT_2F pt;
+	ID2D1Brush *black;
+	HRESULT hr;
+
+	// TODO document that fully opaque black is the default text color; figure out whether this is upheld in various scenarios on other platforms
+	black = mkSolidBrush(c->rt, 0.0, 0.0, 0.0, 1.0);
+
+	dl = prepareLayout(layout, c->rt);
+	pt.x = x;
+	pt.y = y;
+	// TODO D2D1_DRAW_TEXT_OPTIONS_NO_SNAP?
+	// TODO D2D1_DRAW_TEXT_OPTIONS_CLIP?
+	// TODO when setting 8.1 as minimum, D2D1_DRAW_TEXT_OPTIONS_ENABLE_COLOR_FONT?
+	c->rt->DrawTextLayout(pt, dl, black, D2D1_DRAW_TEXT_OPTIONS_NONE);
+	dl->Release();
+
+	black->Release();
+}
+
+void uiDrawTextLayoutSetColor(uiDrawTextLayout *layout, int startChar, int endChar, double r, double g, double b, double a)
+{
+	struct layoutAttr attr;
+
+	attr.type = layoutAttrColor;
+	attr.start = startChar;
+	attr.end = endChar;
+	attr.components[0] = r;
+	attr.components[1] = g;
+	attr.components[2] = b;
+	attr.components[3] = a;
+	layout->attrs->push_back(attr);
+}
diff --git a/src/libui_sdl/libui/windows/dwrite.cpp b/src/libui_sdl/libui/windows/dwrite.cpp
new file mode 100644
index 0000000..9156f17
--- /dev/null
+++ b/src/libui_sdl/libui/windows/dwrite.cpp
@@ -0,0 +1,88 @@
+// 14 april 2016
+#include "uipriv_windows.hpp"
+// TODO really migrate?
+
+IDWriteFactory *dwfactory = NULL;
+
+HRESULT initDrawText(void)
+{
+	// TOOD use DWRITE_FACTORY_TYPE_ISOLATED instead?
+	return DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED,
+		__uuidof (IDWriteFactory),
+		(IUnknown **) (&dwfactory));
+}
+
+void uninitDrawText(void)
+{
+	dwfactory->Release();
+}
+
+fontCollection *loadFontCollection(void)
+{
+	fontCollection *fc;
+	HRESULT hr;
+
+	fc = uiNew(fontCollection);
+	// always get the latest available font information
+	hr = dwfactory->GetSystemFontCollection(&(fc->fonts), TRUE);
+	if (hr != S_OK)
+		logHRESULT(L"error getting system font collection", hr);
+	fc->userLocaleSuccess = GetUserDefaultLocaleName(fc->userLocale, LOCALE_NAME_MAX_LENGTH);
+	return fc;
+}
+
+WCHAR *fontCollectionFamilyName(fontCollection *fc, IDWriteFontFamily *family)
+{
+	IDWriteLocalizedStrings *names;
+	WCHAR *str;
+	HRESULT hr;
+
+	hr = family->GetFamilyNames(&names);
+	if (hr != S_OK)
+		logHRESULT(L"error getting names of font out", hr);
+	str = fontCollectionCorrectString(fc, names);
+	names->Release();
+	return str;
+}
+
+WCHAR *fontCollectionCorrectString(fontCollection *fc, IDWriteLocalizedStrings *names)
+{
+	UINT32 index;
+	BOOL exists;
+	UINT32 length;
+	WCHAR *wname;
+	HRESULT hr;
+
+	// this is complex, but we ignore failure conditions to allow fallbacks
+	// 1) If the user locale name was successfully retrieved, try it
+	// 2) If the user locale name was not successfully retrieved, or that locale's string does not exist, or an error occurred, try L"en-us", the US English locale
+	// 3) And if that fails, assume the first one
+	// This algorithm is straight from MSDN: https://msdn.microsoft.com/en-us/library/windows/desktop/dd368214%28v=vs.85%29.aspx
+	// For step 2 to work, start by setting hr to S_OK and exists to FALSE.
+	// TODO does it skip step 2 entirely if step 1 fails? rewrite it to be a more pure conversion of the MSDN code?
+	hr = S_OK;
+	exists = FALSE;
+	if (fc->userLocaleSuccess != 0)
+		hr = names->FindLocaleName(fc->userLocale, &index, &exists);
+	if (hr != S_OK || (hr == S_OK && !exists))
+		hr = names->FindLocaleName(L"en-us", &index, &exists);
+	if (!exists)
+		index = 0;
+
+	hr = names->GetStringLength(index, &length);
+	if (hr != S_OK)
+		logHRESULT(L"error getting length of font name", hr);
+	// GetStringLength() does not include the null terminator, but GetString() does
+	wname = (WCHAR *) uiAlloc((length + 1) * sizeof (WCHAR), "WCHAR[]");
+	hr = names->GetString(index, wname, length + 1);
+	if (hr != S_OK)
+		logHRESULT(L"error getting font name", hr);
+
+	return wname;
+}
+
+void fontCollectionFree(fontCollection *fc)
+{
+	fc->fonts->Release();
+	uiFree(fc);
+}
diff --git a/src/libui_sdl/libui/windows/editablecombo.cpp b/src/libui_sdl/libui/windows/editablecombo.cpp
new file mode 100644
index 0000000..9e1fdbf
--- /dev/null
+++ b/src/libui_sdl/libui/windows/editablecombo.cpp
@@ -0,0 +1,115 @@
+// 20 may 2015
+#include "uipriv_windows.hpp"
+
+// we as Common Controls 6 users don't need to worry about the height of comboboxes; see http://blogs.msdn.com/b/oldnewthing/archive/2006/03/10/548537.aspx
+
+struct uiEditableCombobox {
+	uiWindowsControl c;
+	HWND hwnd;
+	void (*onChanged)(uiEditableCombobox *, void *);
+	void *onChangedData;
+};
+
+static BOOL onWM_COMMAND(uiControl *cc, HWND hwnd, WORD code, LRESULT *lResult)
+{
+	uiEditableCombobox *c = uiEditableCombobox(cc);
+
+	if (code == CBN_SELCHANGE) {
+		// like on OS X, this is sent before the edit has been updated :(
+		if (PostMessage(parentOf(hwnd),
+			WM_COMMAND,
+			MAKEWPARAM(GetWindowLongPtrW(hwnd, GWLP_ID), CBN_EDITCHANGE),
+			(LPARAM) hwnd) == 0)
+			logLastError(L"error posting CBN_EDITCHANGE after CBN_SELCHANGE");
+		*lResult = 0;
+		return TRUE;
+	}
+	if (code != CBN_EDITCHANGE)
+		return FALSE;
+	(*(c->onChanged))(c, c->onChangedData);
+	*lResult = 0;
+	return TRUE;
+}
+
+void uiEditableComboboxDestroy(uiControl *cc)
+{
+	uiEditableCombobox *c = uiEditableCombobox(cc);
+
+	uiWindowsUnregisterWM_COMMANDHandler(c->hwnd);
+	uiWindowsEnsureDestroyWindow(c->hwnd);
+	uiFreeControl(uiControl(c));
+}
+
+uiWindowsControlAllDefaultsExceptDestroy(uiEditableCombobox)
+
+// from http://msdn.microsoft.com/en-us/library/windows/desktop/dn742486.aspx#sizingandspacing
+#define comboboxWidth 107	/* this is actually the shorter progress bar width, but Microsoft only indicates as wide as necessary; LONGTERM */
+#define comboboxHeight 14	/* LONGTERM: is this too high? */
+
+static void uiEditableComboboxMinimumSize(uiWindowsControl *cc, int *width, int *height)
+{
+	uiEditableCombobox *c = uiEditableCombobox(cc);
+	uiWindowsSizing sizing;
+	int x, y;
+
+	x = comboboxWidth;
+	y = comboboxHeight;
+	uiWindowsGetSizing(c->hwnd, &sizing);
+	uiWindowsSizingDlgUnitsToPixels(&sizing, &x, &y);
+	*width = x;
+	*height = y;
+}
+
+static void defaultOnChanged(uiEditableCombobox *c, void *data)
+{
+	// do nothing
+}
+
+void uiEditableComboboxAppend(uiEditableCombobox *c, const char *text)
+{
+	WCHAR *wtext;
+	LRESULT res;
+
+	wtext = toUTF16(text);
+	res = SendMessageW(c->hwnd, CB_ADDSTRING, 0, (LPARAM) wtext);
+	if (res == (LRESULT) CB_ERR)
+		logLastError(L"error appending item to uiEditableCombobox");
+	else if (res == (LRESULT) CB_ERRSPACE)
+		logLastError(L"memory exhausted appending item to uiEditableCombobox");
+	uiFree(wtext);
+}
+
+char *uiEditableComboboxText(uiEditableCombobox *c)
+{
+	return uiWindowsWindowText(c->hwnd);
+}
+
+void uiEditableComboboxSetText(uiEditableCombobox *c, const char *text)
+{
+	// does not trigger any notifications
+	uiWindowsSetWindowText(c->hwnd, text);
+}
+
+void uiEditableComboboxOnChanged(uiEditableCombobox *c, void (*f)(uiEditableCombobox *c, void *data), void *data)
+{
+	c->onChanged = f;
+	c->onChangedData = data;
+}
+
+uiEditableCombobox *uiNewEditableCombobox(void)
+{
+	uiEditableCombobox *c;
+
+	uiWindowsNewControl(uiEditableCombobox, c);
+
+	c->hwnd = uiWindowsEnsureCreateControlHWND(WS_EX_CLIENTEDGE,
+		L"combobox", L"",
+		CBS_DROPDOWN | WS_TABSTOP,
+		hInstance, NULL,
+		TRUE);
+
+	uiWindowsRegisterWM_COMMANDHandler(c->hwnd, onWM_COMMAND, uiControl(c));
+	uiEditableComboboxOnChanged(c, defaultOnChanged, NULL);
+
+	return c;
+}
diff --git a/src/libui_sdl/libui/windows/entry.cpp b/src/libui_sdl/libui/windows/entry.cpp
new file mode 100644
index 0000000..a7a077f
--- /dev/null
+++ b/src/libui_sdl/libui/windows/entry.cpp
@@ -0,0 +1,134 @@
+// 8 april 2015
+#include "uipriv_windows.hpp"
+
+struct uiEntry {
+	uiWindowsControl c;
+	HWND hwnd;
+	void (*onChanged)(uiEntry *, void *);
+	void *onChangedData;
+	BOOL inhibitChanged;
+};
+
+static BOOL onWM_COMMAND(uiControl *c, HWND hwnd, WORD code, LRESULT *lResult)
+{
+	uiEntry *e = uiEntry(c);
+
+	if (code != EN_CHANGE)
+		return FALSE;
+	if (e->inhibitChanged)
+		return FALSE;
+	(*(e->onChanged))(e, e->onChangedData);
+	*lResult = 0;
+	return TRUE;
+}
+
+static void uiEntryDestroy(uiControl *c)
+{
+	uiEntry *e = uiEntry(c);
+
+	uiWindowsUnregisterWM_COMMANDHandler(e->hwnd);
+	uiWindowsEnsureDestroyWindow(e->hwnd);
+	uiFreeControl(uiControl(e));
+}
+
+uiWindowsControlAllDefaultsExceptDestroy(uiEntry)
+
+// from http://msdn.microsoft.com/en-us/library/windows/desktop/dn742486.aspx#sizingandspacing
+#define entryWidth 107 /* this is actually the shorter progress bar width, but Microsoft only indicates as wide as necessary */
+#define entryHeight 14
+
+static void uiEntryMinimumSize(uiWindowsControl *c, int *width, int *height)
+{
+	uiEntry *e = uiEntry(c);
+	uiWindowsSizing sizing;
+	int x, y;
+
+	x = entryWidth;
+	y = entryHeight;
+	uiWindowsGetSizing(e->hwnd, &sizing);
+	uiWindowsSizingDlgUnitsToPixels(&sizing, &x, &y);
+	*width = x;
+	*height = y;
+}
+
+static void defaultOnChanged(uiEntry *e, void *data)
+{
+	// do nothing
+}
+
+char *uiEntryText(uiEntry *e)
+{
+	return uiWindowsWindowText(e->hwnd);
+}
+
+void uiEntrySetText(uiEntry *e, const char *text)
+{
+	// doing this raises an EN_CHANGED
+	e->inhibitChanged = TRUE;
+	uiWindowsSetWindowText(e->hwnd, text);
+	e->inhibitChanged = FALSE;
+	// don't queue the control for resize; entry sizes are independent of their contents
+}
+
+void uiEntryOnChanged(uiEntry *e, void (*f)(uiEntry *, void *), void *data)
+{
+	e->onChanged = f;
+	e->onChangedData = data;
+}
+
+int uiEntryReadOnly(uiEntry *e)
+{
+	return (getStyle(e->hwnd) & ES_READONLY) != 0;
+}
+
+void uiEntrySetReadOnly(uiEntry *e, int readonly)
+{
+	WPARAM ro;
+
+	ro = (WPARAM) FALSE;
+	if (readonly)
+		ro = (WPARAM) TRUE;
+	if (SendMessage(e->hwnd, EM_SETREADONLY, ro, 0) == 0)
+		logLastError(L"error making uiEntry read-only");
+}
+
+static uiEntry *finishNewEntry(DWORD style)
+{
+	uiEntry *e;
+
+	uiWindowsNewControl(uiEntry, e);
+
+	e->hwnd = uiWindowsEnsureCreateControlHWND(WS_EX_CLIENTEDGE,
+		L"edit", L"",
+		style | ES_AUTOHSCROLL | ES_LEFT | ES_NOHIDESEL | WS_TABSTOP,
+		hInstance, NULL,
+		TRUE);
+
+	uiWindowsRegisterWM_COMMANDHandler(e->hwnd, onWM_COMMAND, uiControl(e));
+	uiEntryOnChanged(e, defaultOnChanged, NULL);
+
+	return e;
+}
+
+uiEntry *uiNewEntry(void)
+{
+	return finishNewEntry(0);
+}
+
+uiEntry *uiNewPasswordEntry(void)
+{
+	return finishNewEntry(ES_PASSWORD);
+}
+
+uiEntry *uiNewSearchEntry(void)
+{
+	uiEntry *e;
+	HRESULT hr;
+
+	e = finishNewEntry(0);
+	// TODO this is from ThemeExplorer; is it documented anywhere?
+	// TODO SearchBoxEditComposited has no border
+	hr = SetWindowTheme(e->hwnd, L"SearchBoxEdit", NULL);
+	// TODO will hr be S_OK if themes are disabled?
+	return e;
+}
diff --git a/src/libui_sdl/libui/windows/events.cpp b/src/libui_sdl/libui/windows/events.cpp
new file mode 100644
index 0000000..45e8d43
--- /dev/null
+++ b/src/libui_sdl/libui/windows/events.cpp
@@ -0,0 +1,151 @@
+// 20 may 2015
+#include "uipriv_windows.hpp"
+
+struct handler {
+	BOOL (*commandHandler)(uiControl *, HWND, WORD, LRESULT *);
+	BOOL (*notifyHandler)(uiControl *, HWND, NMHDR *, LRESULT *);
+	BOOL (*hscrollHandler)(uiControl *, HWND, WORD, LRESULT *);
+	uiControl *c;
+
+	// just to ensure handlers[new HWND] initializes properly
+	// TODO gcc can't handle a struct keyword here? or is that a MSVC extension?
+	handler()
+	{
+		this->commandHandler = NULL;
+		this->notifyHandler = NULL;
+		this->hscrollHandler = NULL;
+		this->c = NULL;
+	}
+};
+
+static std::map<HWND, struct handler> handlers;
+
+void uiWindowsRegisterWM_COMMANDHandler(HWND hwnd, BOOL (*handler)(uiControl *, HWND, WORD, LRESULT *), uiControl *c)
+{
+	if (handlers[hwnd].commandHandler != NULL)
+		implbug("already registered a WM_COMMAND handler to window handle %p", hwnd);
+	handlers[hwnd].commandHandler = handler;
+	handlers[hwnd].c = c;
+}
+
+void uiWindowsRegisterWM_NOTIFYHandler(HWND hwnd, BOOL (*handler)(uiControl *, HWND, NMHDR *, LRESULT *), uiControl *c)
+{
+	if (handlers[hwnd].notifyHandler != NULL)
+		implbug("already registered a WM_NOTIFY handler to window handle %p", hwnd);
+	handlers[hwnd].notifyHandler = handler;
+	handlers[hwnd].c = c;
+}
+
+void uiWindowsRegisterWM_HSCROLLHandler(HWND hwnd, BOOL (*handler)(uiControl *, HWND, WORD, LRESULT *), uiControl *c)
+{
+	if (handlers[hwnd].hscrollHandler != NULL)
+		implbug("already registered a WM_HSCROLL handler to window handle %p", hwnd);
+	handlers[hwnd].hscrollHandler = handler;
+	handlers[hwnd].c = c;
+}
+
+void uiWindowsUnregisterWM_COMMANDHandler(HWND hwnd)
+{
+	if (handlers[hwnd].commandHandler == NULL)
+		implbug("window handle %p not registered to receive WM_COMMAND events", hwnd);
+	handlers[hwnd].commandHandler = NULL;
+}
+
+void uiWindowsUnregisterWM_NOTIFYHandler(HWND hwnd)
+{
+	if (handlers[hwnd].notifyHandler == NULL)
+		implbug("window handle %p not registered to receive WM_NOTIFY events", hwnd);
+	handlers[hwnd].notifyHandler = NULL;
+}
+
+void uiWindowsUnregisterWM_HSCROLLHandler(HWND hwnd)
+{
+	if (handlers[hwnd].hscrollHandler == NULL)
+		implbug("window handle %p not registered to receive WM_HSCROLL events", hwnd);
+	handlers[hwnd].hscrollHandler = NULL;
+}
+
+template<typename T>
+static BOOL shouldRun(HWND hwnd, T method)
+{
+	// not from a window
+	if (hwnd == NULL)
+		return FALSE;
+	// don't bounce back if to the utility window, in which case act as if the message was ignored
+	if (IsChild(utilWindow, hwnd) != 0)
+		return FALSE;
+	// registered?
+	return method != NULL;
+}
+
+BOOL runWM_COMMAND(WPARAM wParam, LPARAM lParam, LRESULT *lResult)
+{
+	HWND hwnd;
+	WORD arg3;
+	BOOL (*handler)(uiControl *, HWND, WORD, LRESULT *);
+	uiControl *c;
+
+	hwnd = (HWND) lParam;
+	arg3 = HIWORD(wParam);
+	handler = handlers[hwnd].commandHandler;
+	c = handlers[hwnd].c;
+	if (shouldRun(hwnd, handler))
+		return (*handler)(c, hwnd, arg3, lResult);
+	return FALSE;
+}
+
+BOOL runWM_NOTIFY(WPARAM wParam, LPARAM lParam, LRESULT *lResult)
+{
+	HWND hwnd;
+	NMHDR *arg3;
+	BOOL (*handler)(uiControl *, HWND, NMHDR *, LRESULT *);
+	uiControl *c;
+
+	arg3 = (NMHDR *) lParam;
+	hwnd = arg3->hwndFrom;
+	handler = handlers[hwnd].notifyHandler;
+	c = handlers[hwnd].c;
+	if (shouldRun(hwnd, handler))
+		return (*handler)(c, hwnd, arg3, lResult);
+	return FALSE;
+}
+
+BOOL runWM_HSCROLL(WPARAM wParam, LPARAM lParam, LRESULT *lResult)
+{
+	HWND hwnd;
+	WORD arg3;
+	BOOL (*handler)(uiControl *, HWND, WORD, LRESULT *);
+	uiControl *c;
+
+	hwnd = (HWND) lParam;
+	arg3 = LOWORD(wParam);
+	handler = handlers[hwnd].hscrollHandler;
+	c = handlers[hwnd].c;
+	if (shouldRun(hwnd, handler))
+		return (*handler)(c, hwnd, arg3, lResult);
+	return FALSE;
+}
+
+static std::map<HWND, bool> wininichanges;
+
+void uiWindowsRegisterReceiveWM_WININICHANGE(HWND hwnd)
+{
+	if (wininichanges[hwnd])
+		implbug("window handle %p already subscribed to receive WM_WINICHANGEs", hwnd);
+	wininichanges[hwnd] = true;
+}
+
+void uiWindowsUnregisterReceiveWM_WININICHANGE(HWND hwnd)
+{
+	if (!wininichanges[hwnd])
+		implbug("window handle %p not registered to receive WM_WININICHANGEs", hwnd);
+	wininichanges[hwnd] = false;
+}
+
+void issueWM_WININICHANGE(WPARAM wParam, LPARAM lParam)
+{
+	struct wininichange *ch;
+
+	for (const auto &iter : wininichanges)
+		SendMessageW(iter.first, WM_WININICHANGE, wParam, lParam);
+}
diff --git a/src/libui_sdl/libui/windows/fontbutton.cpp b/src/libui_sdl/libui/windows/fontbutton.cpp
new file mode 100644
index 0000000..d2d4dab
--- /dev/null
+++ b/src/libui_sdl/libui/windows/fontbutton.cpp
@@ -0,0 +1,122 @@
+// 14 april 2016
+#include "uipriv_windows.hpp"
+
+struct uiFontButton {
+	uiWindowsControl c;
+	HWND hwnd;
+	struct fontDialogParams params;
+	BOOL already;
+	void (*onChanged)(uiFontButton *, void *);
+	void *onChangedData;
+};
+
+static void uiFontButtonDestroy(uiControl *c)
+{
+	uiFontButton *b = uiFontButton(c);
+
+	uiWindowsUnregisterWM_COMMANDHandler(b->hwnd);
+	destroyFontDialogParams(&(b->params));
+	uiWindowsEnsureDestroyWindow(b->hwnd);
+	uiFreeControl(uiControl(b));
+}
+
+static void updateFontButtonLabel(uiFontButton *b)
+{
+	WCHAR *text;
+
+	text = fontDialogParamsToString(&(b->params));
+	setWindowText(b->hwnd, text);
+	uiFree(text);
+
+	// changing the text might necessitate a change in the button's size
+	uiWindowsControlMinimumSizeChanged(uiWindowsControl(b));
+}
+
+static BOOL onWM_COMMAND(uiControl *c, HWND hwnd, WORD code, LRESULT *lResult)
+{
+	uiFontButton *b = uiFontButton(c);
+	HWND parent;
+
+	if (code != BN_CLICKED)
+		return FALSE;
+
+	parent = parentToplevel(b->hwnd);
+	if (showFontDialog(parent, &(b->params))) {
+		updateFontButtonLabel(b);
+		(*(b->onChanged))(b, b->onChangedData);
+	}
+
+	*lResult = 0;
+	return TRUE;
+}
+
+uiWindowsControlAllDefaultsExceptDestroy(uiFontButton)
+
+// from http://msdn.microsoft.com/en-us/library/windows/desktop/dn742486.aspx#sizingandspacing
+#define buttonHeight 14
+
+static void uiFontButtonMinimumSize(uiWindowsControl *c, int *width, int *height)
+{
+	uiFontButton *b = uiFontButton(c);
+	SIZE size;
+	uiWindowsSizing sizing;
+	int y;
+
+	// try the comctl32 version 6 way
+	size.cx = 0;		// explicitly ask for ideal size
+	size.cy = 0;
+	if (SendMessageW(b->hwnd, BCM_GETIDEALSIZE, 0, (LPARAM) (&size)) != FALSE) {
+		*width = size.cx;
+		*height = size.cy;
+		return;
+	}
+
+	// that didn't work; fall back to using Microsoft's metrics
+	// Microsoft says to use a fixed width for all buttons; this isn't good enough
+	// use the text width instead, with some edge padding
+	*width = uiWindowsWindowTextWidth(b->hwnd) + (2 * GetSystemMetrics(SM_CXEDGE));
+	y = buttonHeight;
+	uiWindowsGetSizing(b->hwnd, &sizing);
+	uiWindowsSizingDlgUnitsToPixels(&sizing, NULL, &y);
+	*height = y;
+}
+
+static void defaultOnChanged(uiFontButton *b, void *data)
+{
+	// do nothing
+}
+
+uiDrawTextFont *uiFontButtonFont(uiFontButton *b)
+{
+	// we don't own b->params.font; we have to add a reference
+	// we don't own b->params.familyName either; we have to copy it
+	return mkTextFont(b->params.font, TRUE, b->params.familyName, TRUE, b->params.size);
+}
+
+void uiFontButtonOnChanged(uiFontButton *b, void (*f)(uiFontButton *, void *), void *data)
+{
+	b->onChanged = f;
+	b->onChangedData = data;
+}
+
+uiFontButton *uiNewFontButton(void)
+{
+	uiFontButton *b;
+
+	uiWindowsNewControl(uiFontButton, b);
+
+	b->hwnd = uiWindowsEnsureCreateControlHWND(0,
+		L"button", L"you should not be seeing this",
+		BS_PUSHBUTTON | WS_TABSTOP,
+		hInstance, NULL,
+		TRUE);
+
+	loadInitialFontDialogParams(&(b->params));
+
+	uiWindowsRegisterWM_COMMANDHandler(b->hwnd, onWM_COMMAND, uiControl(b));
+	uiFontButtonOnChanged(b, defaultOnChanged, NULL);
+
+	updateFontButtonLabel(b);
+
+	return b;
+}
diff --git a/src/libui_sdl/libui/windows/fontdialog.cpp b/src/libui_sdl/libui/windows/fontdialog.cpp
new file mode 100644
index 0000000..603a17d
--- /dev/null
+++ b/src/libui_sdl/libui/windows/fontdialog.cpp
@@ -0,0 +1,686 @@
+// 14 april 2016
+#include "uipriv_windows.hpp"
+
+// TODOs
+// - quote the Choose Font sample here for reference
+// - the Choose Font sample defaults to Regular/Italic/Bold/Bold Italic in some case (no styles?); do we? find out what the case is
+// - do we set initial family and style topmost as well?
+// - this should probably just handle IDWriteFonts
+
+struct fontDialog {
+	HWND hwnd;
+	HWND familyCombobox;
+	HWND styleCombobox;
+	HWND sizeCombobox;
+
+	struct fontDialogParams *params;
+
+	fontCollection *fc;
+
+	RECT sampleRect;
+	HWND sampleBox;
+
+	// we store the current selections in case an invalid string is typed in (partial or nonexistent or invalid number)
+	// on OK, these are what are read
+	LRESULT curFamily;
+	LRESULT curStyle;
+	double curSize;
+
+	// these are finding the style that's closest to the previous one (these fields) when changing a font
+	DWRITE_FONT_WEIGHT weight;
+	DWRITE_FONT_STYLE style;
+	DWRITE_FONT_STRETCH stretch;
+};
+
+static LRESULT cbAddString(HWND cb, const WCHAR *str)
+{
+	LRESULT lr;
+
+	lr = SendMessageW(cb, CB_ADDSTRING, 0, (LPARAM) str);
+	if (lr == (LRESULT) CB_ERR || lr == (LRESULT) CB_ERRSPACE)
+		logLastError(L"error adding item to combobox");
+	return lr;
+}
+
+static LRESULT cbInsertString(HWND cb, const WCHAR *str, WPARAM pos)
+{
+	LRESULT lr;
+
+	lr = SendMessageW(cb, CB_INSERTSTRING, pos, (LPARAM) str);
+	if (lr != (LRESULT) pos)
+		logLastError(L"error inserting item to combobox");
+	return lr;
+}
+
+static LRESULT cbGetItemData(HWND cb, WPARAM item)
+{
+	LRESULT data;
+
+	data = SendMessageW(cb, CB_GETITEMDATA, item, 0);
+	if (data == (LRESULT) CB_ERR)
+		logLastError(L"error getting combobox item data for font dialog");
+	return data;
+}
+
+static void cbSetItemData(HWND cb, WPARAM item, LPARAM data)
+{
+	if (SendMessageW(cb, CB_SETITEMDATA, item, data) == (LRESULT) CB_ERR)
+		logLastError(L"error setting combobox item data");
+}
+
+static BOOL cbGetCurSel(HWND cb, LRESULT *sel)
+{
+	LRESULT n;
+
+	n = SendMessageW(cb, CB_GETCURSEL, 0, 0);
+	if (n == (LRESULT) CB_ERR)
+		return FALSE;
+	if (sel != NULL)
+		*sel = n;
+	return TRUE;
+}
+
+static void cbSetCurSel(HWND cb, WPARAM item)
+{
+	if (SendMessageW(cb, CB_SETCURSEL, item, 0) != (LRESULT) item)
+		logLastError(L"error selecting combobox item");
+}
+
+static LRESULT cbGetCount(HWND cb)
+{
+	LRESULT n;
+
+	n = SendMessageW(cb, CB_GETCOUNT, 0, 0);
+	if (n == (LRESULT) CB_ERR)
+		logLastError(L"error getting combobox item count");
+	return n;
+}
+
+static void cbWipeAndReleaseData(HWND cb)
+{
+	IUnknown *obj;
+	LRESULT i, n;
+
+	n = cbGetCount(cb);
+	for (i = 0; i < n; i++) {
+		obj = (IUnknown *) cbGetItemData(cb, (WPARAM) i);
+		obj->Release();
+	}
+	SendMessageW(cb, CB_RESETCONTENT, 0, 0);
+}
+
+static WCHAR *cbGetItemText(HWND cb, WPARAM item)
+{
+	LRESULT len;
+	WCHAR *text;
+
+	// note: neither message includes the terminating L'\0'
+	len = SendMessageW(cb, CB_GETLBTEXTLEN, item, 0);
+	if (len == (LRESULT) CB_ERR)
+		logLastError(L"error getting item text length from combobox");
+	text = (WCHAR *) uiAlloc((len + 1) * sizeof (WCHAR), "WCHAR[]");
+	if (SendMessageW(cb, CB_GETLBTEXT, item, (LPARAM) text) != len)
+		logLastError(L"error getting item text from combobox");
+	return text;
+}
+
+static BOOL cbTypeToSelect(HWND cb, LRESULT *posOut, BOOL restoreAfter)
+{
+	WCHAR *text;
+	LRESULT pos;
+	DWORD selStart, selEnd;
+
+	// start by saving the current selection as setting the item will change the selection
+	SendMessageW(cb, CB_GETEDITSEL, (WPARAM) (&selStart), (LPARAM) (&selEnd));
+	text = windowText(cb);
+	pos = SendMessageW(cb, CB_FINDSTRINGEXACT, (WPARAM) (-1), (LPARAM) text);
+	if (pos == (LRESULT) CB_ERR) {
+		uiFree(text);
+		return FALSE;
+	}
+	cbSetCurSel(cb, (WPARAM) pos);
+	if (posOut != NULL)
+		*posOut = pos;
+	if (restoreAfter)
+		if (SendMessageW(cb, WM_SETTEXT, 0, (LPARAM) text) != (LRESULT) TRUE)
+			logLastError(L"error restoring old combobox text");
+	uiFree(text);
+	// and restore the selection like above
+	// TODO isn't there a 32-bit version of this
+	if (SendMessageW(cb, CB_SETEDITSEL, 0, MAKELPARAM(selStart, selEnd)) != (LRESULT) TRUE)
+		logLastError(L"error restoring combobox edit selection");
+	return TRUE;
+}
+
+static void wipeStylesBox(struct fontDialog *f)
+{
+	cbWipeAndReleaseData(f->styleCombobox);
+}
+
+static WCHAR *fontStyleName(struct fontCollection *fc, IDWriteFont *font)
+{
+	IDWriteLocalizedStrings *str;
+	WCHAR *wstr;
+	HRESULT hr;
+
+	hr = font->GetFaceNames(&str);
+	if (hr != S_OK)
+		logHRESULT(L"error getting font style name for font dialog", hr);
+	wstr = fontCollectionCorrectString(fc, str);
+	str->Release();
+	return wstr;
+}
+
+static void queueRedrawSampleText(struct fontDialog *f)
+{
+	// TODO TRUE?
+	invalidateRect(f->sampleBox, NULL, TRUE);
+}
+
+static void styleChanged(struct fontDialog *f)
+{
+	LRESULT pos;
+	BOOL selected;
+	IDWriteFont *font;
+
+	selected = cbGetCurSel(f->styleCombobox, &pos);
+	if (!selected)		// on deselect, do nothing
+		return;
+	f->curStyle = pos;
+
+	font = (IDWriteFont *) cbGetItemData(f->styleCombobox, (WPARAM) (f->curStyle));
+	// these are for the nearest match when changing the family; see below
+	f->weight = font->GetWeight();
+	f->style = font->GetStyle();
+	f->stretch = font->GetStretch();
+
+	queueRedrawSampleText(f);
+}
+
+static void styleEdited(struct fontDialog *f)
+{
+	if (cbTypeToSelect(f->styleCombobox, &(f->curStyle), FALSE))
+		styleChanged(f);
+}
+
+static void familyChanged(struct fontDialog *f)
+{
+	LRESULT pos;
+	BOOL selected;
+	IDWriteFontFamily *family;
+	IDWriteFont *font, *matchFont;
+	DWRITE_FONT_WEIGHT weight;
+	DWRITE_FONT_STYLE style;
+	DWRITE_FONT_STRETCH stretch;
+	UINT32 i, n;
+	UINT32 matching;
+	WCHAR *label;
+	HRESULT hr;
+
+	selected = cbGetCurSel(f->familyCombobox, &pos);
+	if (!selected)		// on deselect, do nothing
+		return;
+	f->curFamily = pos;
+
+	family = (IDWriteFontFamily *) cbGetItemData(f->familyCombobox, (WPARAM) (f->curFamily));
+
+	// for the nearest style match
+	// when we select a new family, we want the nearest style to the previously selected one to be chosen
+	// this is how the Choose Font sample does it
+	hr = family->GetFirstMatchingFont(
+		f->weight,
+		f->stretch,
+		f->style,
+		&matchFont);
+	if (hr != S_OK)
+		logHRESULT(L"error finding first matching font to previous style in font dialog", hr);
+	// we can't just compare pointers; a "newly created" object comes out
+	// the Choose Font sample appears to do this instead
+	weight = matchFont->GetWeight();
+	style = matchFont->GetStyle();
+	stretch = matchFont->GetStretch();
+	matchFont->Release();
+
+	// TODO test mutliple streteches; all the fonts I have have only one stretch value?
+	wipeStylesBox(f);
+	n = family->GetFontCount();
+	matching = 0;			// a safe/suitable default just in case
+	for (i = 0; i < n; i++) {
+		hr = family->GetFont(i, &font);
+		if (hr != S_OK)
+			logHRESULT(L"error getting font for filling styles box", hr);
+		label = fontStyleName(f->fc, font);
+		pos = cbAddString(f->styleCombobox, label);
+		uiFree(label);
+		cbSetItemData(f->styleCombobox, (WPARAM) pos, (LPARAM) font);
+		if (font->GetWeight() == weight &&
+			font->GetStyle() == style &&
+			font->GetStretch() == stretch)
+			matching = i;
+	}
+
+	// and now, load the match
+	cbSetCurSel(f->styleCombobox, (WPARAM) matching);
+	styleChanged(f);
+}
+
+// TODO search language variants like the sample does
+static void familyEdited(struct fontDialog *f)
+{
+	if (cbTypeToSelect(f->familyCombobox, &(f->curFamily), FALSE))
+		familyChanged(f);
+}
+
+static const struct {
+	const WCHAR *text;
+	double value;
+} defaultSizes[] = {
+	{ L"8", 8 },
+	{ L"9", 9 },
+	{ L"10", 10 },
+	{ L"11", 11 },
+	{ L"12", 12 },
+	{ L"14", 14 },
+	{ L"16", 16 },
+	{ L"18", 18 },
+	{ L"20", 20 },
+	{ L"22", 22 },
+	{ L"24", 24 },
+	{ L"26", 26 },
+	{ L"28", 28 },
+	{ L"36", 36 },
+	{ L"48", 48 },
+	{ L"72", 72 },
+	{ NULL, 0 },
+};
+
+static void sizeChanged(struct fontDialog *f)
+{
+	LRESULT pos;
+	BOOL selected;
+
+	selected = cbGetCurSel(f->sizeCombobox, &pos);
+	if (!selected)		// on deselect, do nothing
+		return;
+	f->curSize = defaultSizes[pos].value;
+	queueRedrawSampleText(f);
+}
+
+static void sizeEdited(struct fontDialog *f)
+{
+	WCHAR *wsize;
+	double size;
+
+	// handle type-to-selection
+	if (cbTypeToSelect(f->sizeCombobox, NULL, FALSE)) {
+		sizeChanged(f);
+		return;
+	}
+	// selection not chosen, try to parse the typing
+	wsize = windowText(f->sizeCombobox);
+	// this is what the Choose Font dialog does; it swallows errors while the real ChooseFont() is not lenient (and only checks on OK)
+	size = wcstod(wsize, NULL);
+	if (size <= 0)		// don't change on invalid size
+		return;
+	f->curSize = size;
+	queueRedrawSampleText(f);
+}
+
+static void fontDialogDrawSampleText(struct fontDialog *f, ID2D1RenderTarget *rt)
+{
+	D2D1_COLOR_F color;
+	D2D1_BRUSH_PROPERTIES props;
+	ID2D1SolidColorBrush *black;
+	IDWriteFont *font;
+	IDWriteLocalizedStrings *sampleStrings;
+	BOOL exists;
+	WCHAR *sample;
+	WCHAR *family;
+	IDWriteTextFormat *format;
+	D2D1_RECT_F rect;
+	HRESULT hr;
+
+	color.r = 0.0;
+	color.g = 0.0;
+	color.b = 0.0;
+	color.a = 1.0;
+	ZeroMemory(&props, sizeof (D2D1_BRUSH_PROPERTIES));
+	props.opacity = 1.0;
+	// identity matrix
+	props.transform._11 = 1;
+	props.transform._22 = 1;
+	hr = rt->CreateSolidColorBrush(
+		&color,
+		&props,
+		&black);
+	if (hr != S_OK)
+		logHRESULT(L"error creating solid brush", hr);
+
+	font = (IDWriteFont *) cbGetItemData(f->styleCombobox, (WPARAM) f->curStyle);
+	hr = font->GetInformationalStrings(DWRITE_INFORMATIONAL_STRING_SAMPLE_TEXT, &sampleStrings, &exists);
+	if (hr != S_OK)
+		exists = FALSE;
+	if (exists) {
+		sample = fontCollectionCorrectString(f->fc, sampleStrings);
+		sampleStrings->Release();
+	} else
+		sample = L"The quick brown fox jumps over the lazy dog.";
+
+	// DirectWrite doesn't allow creating a text format from a font; we need to get this ourselves
+	family = cbGetItemText(f->familyCombobox, f->curFamily);
+	hr = dwfactory->CreateTextFormat(family,
+		NULL,
+		font->GetWeight(),
+		font->GetStyle(),
+		font->GetStretch(),
+		// typographic points are 1/72 inch; this parameter is 1/96 inch
+		// fortunately Microsoft does this too, in https://msdn.microsoft.com/en-us/library/windows/desktop/dd371554%28v=vs.85%29.aspx
+		f->curSize * (96.0 / 72.0),
+		// see http://stackoverflow.com/questions/28397971/idwritefactorycreatetextformat-failing and https://msdn.microsoft.com/en-us/library/windows/desktop/dd368203.aspx
+		// TODO use the current locale again?
+		L"",
+		&format);
+	if (hr != S_OK)
+		logHRESULT(L"error creating IDWriteTextFormat", hr);
+	uiFree(family);
+
+	rect.left = 0;
+	rect.top = 0;
+	rect.right = realGetSize(rt).width;
+	rect.bottom = realGetSize(rt).height;
+	rt->DrawText(sample, wcslen(sample),
+		format,
+		&rect,
+		black,
+		// TODO really?
+		D2D1_DRAW_TEXT_OPTIONS_NONE,
+		DWRITE_MEASURING_MODE_NATURAL);
+
+	format->Release();
+	if (exists)
+		uiFree(sample);
+	black->Release();
+}
+
+static LRESULT CALLBACK fontDialogSampleSubProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
+{
+	ID2D1RenderTarget *rt;
+	struct fontDialog *f;
+
+	switch (uMsg) {
+	case msgD2DScratchPaint:
+		rt = (ID2D1RenderTarget *) lParam;
+		f = (struct fontDialog *) dwRefData;
+		fontDialogDrawSampleText(f, rt);
+		return 0;
+	case WM_NCDESTROY:
+		if (RemoveWindowSubclass(hwnd, fontDialogSampleSubProc, uIdSubclass) == FALSE)
+			logLastError(L"error removing font dialog sample text subclass");
+		break;
+	}
+	return DefSubclassProc(hwnd, uMsg, wParam, lParam);
+}
+
+static void setupInitialFontDialogState(struct fontDialog *f)
+{
+	WCHAR wsize[512];		// this should be way more than enough
+	LRESULT pos;
+
+	// first let's load the size
+	// the real font dialog:
+	// - if the chosen font size is in the list, it selects that item AND makes it topmost
+	// - if the chosen font size is not in the list, don't bother
+	// we'll simulate it by setting the text to a %f representation, then pretending as if it was entered
+	// TODO is 512 the correct number to pass to _snwprintf()?
+	// TODO will this revert to scientific notation?
+	_snwprintf(wsize, 512, L"%g", f->params->size);
+	// TODO make this a setWindowText()
+	if (SendMessageW(f->sizeCombobox, WM_SETTEXT, 0, (LPARAM) wsize) != (LRESULT) TRUE)
+		logLastError(L"error setting size combobox to initial font size");
+	sizeEdited(f);
+	if (cbGetCurSel(f->sizeCombobox, &pos))
+		if (SendMessageW(f->sizeCombobox, CB_SETTOPINDEX, (WPARAM) pos, 0) != 0)
+			logLastError(L"error making chosen size topmost in the size combobox");
+
+	// now we set the family and style
+	// we do this by first setting the previous style attributes, then simulating a font entered
+	f->weight = f->params->font->GetWeight();
+	f->style = f->params->font->GetStyle();
+	f->stretch = f->params->font->GetStretch();
+	if (SendMessageW(f->familyCombobox, WM_SETTEXT, 0, (LPARAM) (f->params->familyName)) != (LRESULT) TRUE)
+		logLastError(L"error setting family combobox to initial font family");
+	familyEdited(f);
+}
+
+static struct fontDialog *beginFontDialog(HWND hwnd, LPARAM lParam)
+{
+	struct fontDialog *f;
+	UINT32 i, nFamilies;
+	IDWriteFontFamily *family;
+	WCHAR *wname;
+	LRESULT pos;
+	HWND samplePlacement;
+	HRESULT hr;
+
+	f = uiNew(struct fontDialog);
+	f->hwnd = hwnd;
+	f->params = (struct fontDialogParams *) lParam;
+
+	f->familyCombobox = getDlgItem(f->hwnd, rcFontFamilyCombobox);
+	f->styleCombobox = getDlgItem(f->hwnd, rcFontStyleCombobox);
+	f->sizeCombobox = getDlgItem(f->hwnd, rcFontSizeCombobox);
+
+	f->fc = loadFontCollection();
+	nFamilies = f->fc->fonts->GetFontFamilyCount();
+	for (i = 0; i < nFamilies; i++) {
+		hr = f->fc->fonts->GetFontFamily(i, &family);
+		if (hr != S_OK)
+			logHRESULT(L"error getting font family", hr);
+		wname = fontCollectionFamilyName(f->fc, family);
+		pos = cbAddString(f->familyCombobox, wname);
+		uiFree(wname);
+		cbSetItemData(f->familyCombobox, (WPARAM) pos, (LPARAM) family);
+	}
+
+	for (i = 0; defaultSizes[i].text != NULL; i++)
+		cbInsertString(f->sizeCombobox, defaultSizes[i].text, (WPARAM) i);
+
+	samplePlacement = getDlgItem(f->hwnd, rcFontSamplePlacement);
+	uiWindowsEnsureGetWindowRect(samplePlacement, &(f->sampleRect));
+	mapWindowRect(NULL, f->hwnd, &(f->sampleRect));
+	uiWindowsEnsureDestroyWindow(samplePlacement);
+	f->sampleBox = newD2DScratch(f->hwnd, &(f->sampleRect), (HMENU) rcFontSamplePlacement, fontDialogSampleSubProc, (DWORD_PTR) f);
+
+	setupInitialFontDialogState(f);
+	return f;
+}
+
+static void endFontDialog(struct fontDialog *f, INT_PTR code)
+{
+	wipeStylesBox(f);
+	cbWipeAndReleaseData(f->familyCombobox);
+	fontCollectionFree(f->fc);
+	if (EndDialog(f->hwnd, code) == 0)
+		logLastError(L"error ending font dialog");
+	uiFree(f);
+}
+
+static INT_PTR tryFinishDialog(struct fontDialog *f, WPARAM wParam)
+{
+	IDWriteFontFamily *family;
+
+	// cancelling
+	if (LOWORD(wParam) != IDOK) {
+		endFontDialog(f, 1);
+		return TRUE;
+	}
+
+	// OK
+	destroyFontDialogParams(f->params);
+	f->params->font = (IDWriteFont *) cbGetItemData(f->styleCombobox, f->curStyle);
+	// we need to save font from being destroyed with the combobox
+	f->params->font->AddRef();
+	f->params->size = f->curSize;
+	family = (IDWriteFontFamily *) cbGetItemData(f->familyCombobox, f->curFamily);
+	f->params->familyName = fontCollectionFamilyName(f->fc, family);
+	f->params->styleName = fontStyleName(f->fc, f->params->font);
+	endFontDialog(f, 2);
+	return TRUE;
+}
+
+static INT_PTR CALLBACK fontDialogDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+	struct fontDialog *f;
+
+	f = (struct fontDialog *) GetWindowLongPtrW(hwnd, DWLP_USER);
+	if (f == NULL) {
+		if (uMsg == WM_INITDIALOG) {
+			f = beginFontDialog(hwnd, lParam);
+			SetWindowLongPtrW(hwnd, DWLP_USER, (LONG_PTR) f);
+			return TRUE;
+		}
+		return FALSE;
+	}
+
+	switch (uMsg) {
+	case WM_COMMAND:
+		SetWindowLongPtrW(f->hwnd, DWLP_MSGRESULT, 0);		// just in case
+		switch (LOWORD(wParam)) {
+		case IDOK:
+		case IDCANCEL:
+			if (HIWORD(wParam) != BN_CLICKED)
+				return FALSE;
+			return tryFinishDialog(f, wParam);
+		case rcFontFamilyCombobox:
+			if (HIWORD(wParam) == CBN_SELCHANGE) {
+				familyChanged(f);
+				return TRUE;
+			}
+			if (HIWORD(wParam) == CBN_EDITCHANGE) {
+				familyEdited(f);
+				return TRUE;
+			}
+			return FALSE;
+		case rcFontStyleCombobox:
+			if (HIWORD(wParam) == CBN_SELCHANGE) {
+				styleChanged(f);
+				return TRUE;
+			}
+			if (HIWORD(wParam) == CBN_EDITCHANGE) {
+				styleEdited(f);
+				return TRUE;
+			}
+			return FALSE;
+		case rcFontSizeCombobox:
+			if (HIWORD(wParam) == CBN_SELCHANGE) {
+				sizeChanged(f);
+				return TRUE;
+			}
+			if (HIWORD(wParam) == CBN_EDITCHANGE) {
+				sizeEdited(f);
+				return TRUE;
+			}
+			return FALSE;
+		}
+		return FALSE;
+	}
+	return FALSE;
+}
+
+BOOL showFontDialog(HWND parent, struct fontDialogParams *params)
+{
+	switch (DialogBoxParamW(hInstance, MAKEINTRESOURCE(rcFontDialog), parent, fontDialogDlgProc, (LPARAM) params)) {
+	case 1:			// cancel
+		return FALSE;
+	case 2:			// ok
+		// make the compiler happy by putting the return after the switch
+		break;
+	default:
+		logLastError(L"error running font dialog");
+	}
+	return TRUE;
+}
+
+static IDWriteFontFamily *tryFindFamily(IDWriteFontCollection *fc, const WCHAR *name)
+{
+	UINT32 index;
+	BOOL exists;
+	IDWriteFontFamily *family;
+	HRESULT hr;
+
+	hr = fc->FindFamilyName(name, &index, &exists);
+	if (hr != S_OK)
+		logHRESULT(L"error finding font family for font dialog", hr);
+	if (!exists)
+		return NULL;
+	hr = fc->GetFontFamily(index, &family);
+	if (hr != S_OK)
+		logHRESULT(L"error extracting found font family for font dialog", hr);
+	return family;
+}
+
+void loadInitialFontDialogParams(struct fontDialogParams *params)
+{
+	struct fontCollection *fc;
+	IDWriteFontFamily *family;
+	IDWriteFont *font;
+	HRESULT hr;
+
+	// Our preferred font is Arial 10 Regular.
+	// 10 comes from the official font dialog.
+	// Arial Regular is a reasonable, if arbitrary, default; it's similar to the defaults on other systems.
+	// If Arial isn't found, we'll use Helvetica and then MS Sans Serif as fallbacks, and if not, we'll just grab the first font family in the collection.
+
+	// We need the correct localized name for Regular (and possibly Arial too? let's say yes to be safe), so let's grab the strings from DirectWrite instead of hardcoding them.
+	fc = loadFontCollection();
+	family = tryFindFamily(fc->fonts, L"Arial");
+	if (family == NULL) {
+		family = tryFindFamily(fc->fonts, L"Helvetica");
+		if (family == NULL) {
+			family = tryFindFamily(fc->fonts, L"MS Sans Serif");
+			if (family == NULL) {
+				hr = fc->fonts->GetFontFamily(0, &family);
+				if (hr != S_OK)
+					logHRESULT(L"error getting first font out of font collection (worst case scenario)", hr);
+			}
+		}
+	}
+
+	// next part is simple: just get the closest match to regular
+	hr = family->GetFirstMatchingFont(
+		DWRITE_FONT_WEIGHT_NORMAL,
+		DWRITE_FONT_STRETCH_NORMAL,
+		DWRITE_FONT_STYLE_NORMAL,
+		&font);
+	if (hr != S_OK)
+		logHRESULT(L"error getting Regular font from Arial", hr);
+
+	params->font = font;
+	params->size = 10;
+	params->familyName = fontCollectionFamilyName(fc, family);
+	params->styleName = fontStyleName(fc, font);
+
+	// don't release font; we still need it
+	family->Release();
+	fontCollectionFree(fc);
+}
+
+void destroyFontDialogParams(struct fontDialogParams *params)
+{
+	params->font->Release();
+	uiFree(params->familyName);
+	uiFree(params->styleName);
+}
+
+WCHAR *fontDialogParamsToString(struct fontDialogParams *params)
+{
+	WCHAR *text;
+
+	// TODO dynamically allocate
+	text = (WCHAR *) uiAlloc(512 * sizeof (WCHAR), "WCHAR[]");
+	_snwprintf(text, 512, L"%s %s %g",
+		params->familyName,
+		params->styleName,
+		params->size);
+	return text;
+}
diff --git a/src/libui_sdl/libui/windows/form.cpp b/src/libui_sdl/libui/windows/form.cpp
new file mode 100644
index 0000000..febcc69
--- /dev/null
+++ b/src/libui_sdl/libui/windows/form.cpp
@@ -0,0 +1,319 @@
+// 8 june 2016
+#include "uipriv_windows.hpp"
+
+struct formChild {
+	uiControl *c;
+	HWND label;
+	int stretchy;
+	int height;
+};
+
+struct uiForm {
+	uiWindowsControl c;
+	HWND hwnd;
+	std::vector<struct formChild> *controls;
+	int padded;
+};
+
+static void formPadding(uiForm *f, int *xpadding, int *ypadding)
+{
+	uiWindowsSizing sizing;
+
+	*xpadding = 0;
+	*ypadding = 0;
+	if (f->padded) {
+		uiWindowsGetSizing(f->hwnd, &sizing);
+		uiWindowsSizingStandardPadding(&sizing, xpadding, ypadding);
+	}
+}
+
+// via http://msdn.microsoft.com/en-us/library/windows/desktop/dn742486.aspx#sizingandspacing
+#define labelHeight 8
+#define labelYOffset 3
+
+static void formRelayout(uiForm *f)
+{
+	RECT r;
+	int x, y, width, height;
+	int xpadding, ypadding;
+	int nStretchy;
+	int labelwid, stretchyht;
+	int thiswid;
+	int i;
+	int minimumWidth, minimumHeight;
+	uiWindowsSizing sizing;
+	int labelht, labelyoff;
+	int nVisible;
+
+	if (f->controls->size() == 0)
+		return;
+
+	uiWindowsEnsureGetClientRect(f->hwnd, &r);
+	x = r.left;
+	y = r.top;
+	width = r.right - r.left;
+	height = r.bottom - r.top;
+
+	// 0) get this Form's padding
+	formPadding(f, &xpadding, &ypadding);
+
+	// 1) get width of labels and height of non-stretchy controls
+	// this will tell us how much space will be left for controls
+	labelwid = 0;
+	stretchyht = height;
+	nStretchy = 0;
+	nVisible = 0;
+	for (struct formChild &fc : *(f->controls)) {
+		if (!uiControlVisible(fc.c)) {
+			ShowWindow(fc.label, SW_HIDE);
+			continue;
+		}
+		ShowWindow(fc.label, SW_SHOW);
+		nVisible++;
+		thiswid = uiWindowsWindowTextWidth(fc.label);
+		if (labelwid < thiswid)
+			labelwid = thiswid;
+		if (fc.stretchy) {
+			nStretchy++;
+			continue;
+		}
+		uiWindowsControlMinimumSize(uiWindowsControl(fc.c), &minimumWidth, &minimumHeight);
+		fc.height = minimumHeight;
+		stretchyht -= minimumHeight;
+	}
+	if (nVisible == 0)		// nothing to do
+		return;
+
+	// 2) inset the available rect by the needed padding
+	width -= xpadding;
+	height -= (nVisible - 1) * ypadding;
+	stretchyht -= (nVisible - 1) * ypadding;
+
+	// 3) now get the width of controls and the height of stretchy controls
+	width -= labelwid;
+	if (nStretchy != 0) {
+		stretchyht /= nStretchy;
+		for (struct formChild &fc : *(f->controls)) {
+			if (!uiControlVisible(fc.c))
+				continue;
+			if (fc.stretchy)
+				fc.height = stretchyht;
+		}
+	}
+
+	// 4) get the y offset
+	labelyoff = labelYOffset;
+	uiWindowsGetSizing(f->hwnd, &sizing);
+	uiWindowsSizingDlgUnitsToPixels(&sizing, NULL, &labelyoff);
+
+	// 5) now we can position controls
+	// first, make relative to the top-left corner of the container
+	// also prefer left alignment on Windows
+	x = labelwid + xpadding;
+	y = 0;
+	for (const struct formChild &fc : *(f->controls)) {
+		if (!uiControlVisible(fc.c))
+			continue;
+		labelht = labelHeight;
+		uiWindowsGetSizing(f->hwnd, &sizing);
+		uiWindowsSizingDlgUnitsToPixels(&sizing, NULL, &labelht);
+		uiWindowsEnsureMoveWindowDuringResize(fc.label, 0, y + labelyoff - sizing.InternalLeading, labelwid, labelht);
+		uiWindowsEnsureMoveWindowDuringResize((HWND) uiControlHandle(fc.c), x, y, width, fc.height);
+		y += fc.height + ypadding;
+	}
+}
+
+static void uiFormDestroy(uiControl *c)
+{
+	uiForm *f = uiForm(c);
+
+	for (const struct formChild &fc : *(f->controls)) {
+		uiControlSetParent(fc.c, NULL);
+		uiControlDestroy(fc.c);
+		uiWindowsEnsureDestroyWindow(fc.label);
+	}
+	delete f->controls;
+	uiWindowsEnsureDestroyWindow(f->hwnd);
+	uiFreeControl(uiControl(f));
+}
+
+uiWindowsControlDefaultHandle(uiForm)
+uiWindowsControlDefaultParent(uiForm)
+uiWindowsControlDefaultSetParent(uiForm)
+uiWindowsControlDefaultToplevel(uiForm)
+uiWindowsControlDefaultVisible(uiForm)
+uiWindowsControlDefaultShow(uiForm)
+uiWindowsControlDefaultHide(uiForm)
+uiWindowsControlDefaultEnabled(uiForm)
+uiWindowsControlDefaultEnable(uiForm)
+uiWindowsControlDefaultDisable(uiForm)
+
+static void uiFormSyncEnableState(uiWindowsControl *c, int enabled)
+{
+	uiForm *f = uiForm(c);
+
+	if (uiWindowsShouldStopSyncEnableState(uiWindowsControl(f), enabled))
+		return;
+	for (const struct formChild &fc : *(f->controls))
+		uiWindowsControlSyncEnableState(uiWindowsControl(fc.c), enabled);
+}
+
+uiWindowsControlDefaultSetParentHWND(uiForm)
+
+static void uiFormMinimumSize(uiWindowsControl *c, int *width, int *height)
+{
+	uiForm *f = uiForm(c);
+	int xpadding, ypadding;
+	int nStretchy;
+	// these two contain the largest minimum width and height of all stretchy controls in the form
+	// all stretchy controls will use this value to determine the final minimum size
+	int maxLabelWidth, maxControlWidth;
+	int maxStretchyHeight;
+	int labelwid;
+	int i;
+	int minimumWidth, minimumHeight;
+	int nVisible;
+	uiWindowsSizing sizing;
+
+	*width = 0;
+	*height = 0;
+	if (f->controls->size() == 0)
+		return;
+
+	// 0) get this Form's padding
+	formPadding(f, &xpadding, &ypadding);
+
+	// 1) determine the longest width of all controls and labels; add in the height of non-stretchy controls and get (but not add in) the largest heights of stretchy controls
+	// we still add in like direction of stretchy controls
+	nStretchy = 0;
+	maxLabelWidth = 0;
+	maxControlWidth = 0;
+	maxStretchyHeight = 0;
+	nVisible = 0;
+	for (const struct formChild &fc : *(f->controls)) {
+		if (!uiControlVisible(fc.c))
+			continue;
+		nVisible++;
+		labelwid = uiWindowsWindowTextWidth(fc.label);
+		if (maxLabelWidth < labelwid)
+			maxLabelWidth = labelwid;
+		uiWindowsControlMinimumSize(uiWindowsControl(fc.c), &minimumWidth, &minimumHeight);
+		if (fc.stretchy) {
+			nStretchy++;
+			if (maxStretchyHeight < minimumHeight)
+				maxStretchyHeight = minimumHeight;
+		}
+		if (maxControlWidth < minimumWidth)
+			maxControlWidth = minimumWidth;
+		if (!fc.stretchy)
+			*height += minimumHeight;
+	}
+	if (nVisible == 0)		// nothing to show; return 0x0
+		return;
+	*width += maxLabelWidth + maxControlWidth;
+
+	// 2) outset the desired rect with the needed padding
+	*width += xpadding;
+	*height += (nVisible - 1) * ypadding;
+
+	// 3) and now we can add in stretchy controls
+	*height += nStretchy * maxStretchyHeight;
+}
+
+static void uiFormMinimumSizeChanged(uiWindowsControl *c)
+{
+	uiForm *f = uiForm(c);
+
+	if (uiWindowsControlTooSmall(uiWindowsControl(f))) {
+		uiWindowsControlContinueMinimumSizeChanged(uiWindowsControl(f));
+		return;
+	}
+	formRelayout(f);
+}
+
+uiWindowsControlDefaultLayoutRect(uiForm)
+uiWindowsControlDefaultAssignControlIDZOrder(uiForm)
+
+static void uiFormChildVisibilityChanged(uiWindowsControl *c)
+{
+	// TODO eliminate the redundancy
+	uiWindowsControlMinimumSizeChanged(c);
+}
+
+static void formArrangeChildren(uiForm *f)
+{
+	LONG_PTR controlID;
+	HWND insertAfter;
+	int i;
+
+	controlID = 100;
+	insertAfter = NULL;
+	for (const struct formChild &fc : *(f->controls)) {
+		// TODO assign label ID and z-order
+		uiWindowsControlAssignControlIDZOrder(uiWindowsControl(fc.c), &controlID, &insertAfter);
+	}
+}
+
+void uiFormAppend(uiForm *f, const char *label, uiControl *c, int stretchy)
+{
+	struct formChild fc;
+	WCHAR *wlabel;
+
+	fc.c = c;
+	wlabel = toUTF16(label);
+	fc.label = uiWindowsEnsureCreateControlHWND(0,
+		L"STATIC", wlabel,
+		SS_LEFT | SS_NOPREFIX,
+		hInstance, NULL,
+		TRUE);
+	uiFree(wlabel);
+	uiWindowsEnsureSetParentHWND(fc.label, f->hwnd);
+	fc.stretchy = stretchy;
+	uiControlSetParent(fc.c, uiControl(f));
+	uiWindowsControlSetParentHWND(uiWindowsControl(fc.c), f->hwnd);
+	f->controls->push_back(fc);
+	formArrangeChildren(f);
+	uiWindowsControlMinimumSizeChanged(uiWindowsControl(f));
+}
+
+void uiFormDelete(uiForm *f, int index)
+{
+	struct formChild fc;
+
+	fc = (*(f->controls))[index];
+	uiControlSetParent(fc.c, NULL);
+	uiWindowsControlSetParentHWND(uiWindowsControl(fc.c), NULL);
+	uiWindowsEnsureDestroyWindow(fc.label);
+	f->controls->erase(f->controls->begin() + index);
+	formArrangeChildren(f);
+	uiWindowsControlMinimumSizeChanged(uiWindowsControl(f));
+}
+
+int uiFormPadded(uiForm *f)
+{
+	return f->padded;
+}
+
+void uiFormSetPadded(uiForm *f, int padded)
+{
+	f->padded = padded;
+	uiWindowsControlMinimumSizeChanged(uiWindowsControl(f));
+}
+
+static void onResize(uiWindowsControl *c)
+{
+	formRelayout(uiForm(c));
+}
+
+uiForm *uiNewForm(void)
+{
+	uiForm *f;
+
+	uiWindowsNewControl(uiForm, f);
+
+	f->hwnd = uiWindowsMakeContainer(uiWindowsControl(f), onResize);
+
+	f->controls = new std::vector<struct formChild>;
+
+	return f;
+}
diff --git a/src/libui_sdl/libui/windows/graphemes.cpp b/src/libui_sdl/libui/windows/graphemes.cpp
new file mode 100644
index 0000000..355e403
--- /dev/null
+++ b/src/libui_sdl/libui/windows/graphemes.cpp
@@ -0,0 +1,80 @@
+// 25 may 2016
+#include "uipriv_windows.hpp"
+
+// We could use CharNext() to generate grapheme cluster boundaries, but it doesn't handle surrogate pairs properly (see http://archives.miloush.net/michkap/archive/2008/12/16/9223301.html).
+// So let's use Uniscribe (see http://archives.miloush.net/michkap/archive/2005/01/14/352802.html)
+// See also http://www.catch22.net/tuts/uniscribe-mysteries and http://www.catch22.net/tuts/keyboard-navigation for more details.
+
+static HRESULT itemize(WCHAR *msg, size_t len, SCRIPT_ITEM **out, int *outn)
+{
+	SCRIPT_CONTROL sc;
+	SCRIPT_STATE ss;
+	SCRIPT_ITEM *items;
+	size_t maxItems;
+	int n;
+	HRESULT hr;
+
+	// make sure these are zero-initialized to avoid mangling the text
+	ZeroMemory(&sc, sizeof (SCRIPT_CONTROL));
+	ZeroMemory(&ss, sizeof (SCRIPT_STATE));
+
+	maxItems = len + 2;
+	for (;;) {
+		items = new SCRIPT_ITEM[maxItems];
+		hr = ScriptItemize(msg, len,
+			maxItems,
+			&sc, &ss,
+			items, &n);
+		if (hr == S_OK)
+			break;
+		// otherwise either an error or not enough room
+		delete[] items;
+		if (hr != E_OUTOFMEMORY)
+			return hr;
+		maxItems *= 2;		// add some more and try again
+	}
+
+	*out = items;
+	*outn = n;
+	return S_OK;
+}
+
+size_t *graphemes(WCHAR *msg)
+{
+	size_t len;
+	SCRIPT_ITEM *items;
+	int i, n;
+	size_t *out;
+	size_t *op;
+	SCRIPT_LOGATTR *logattr;
+	int j, nn;
+	HRESULT hr;
+
+	len = wcslen(msg);
+	hr = itemize(msg, len, &items, &n);
+	if (hr != S_OK)
+		logHRESULT(L"error itemizing string for finding grapheme cluster boundaries", hr);
+
+	// should be enough; 2 more just to be safe
+	out = (size_t *) uiAlloc((len + 2) * sizeof (size_t), "size_t[]");
+	op = out;
+
+	// note that there are actually n + 1 elements in items
+	for (i = 0; i < n; i++) {
+		nn = items[i + 1].iCharPos - items[i].iCharPos;
+		logattr = new SCRIPT_LOGATTR[nn];
+		hr = ScriptBreak(msg + items[i].iCharPos, nn,
+			&(items[i].a), logattr);
+		if (hr != S_OK)
+			logHRESULT(L"error breaking string for finding grapheme cluster boundaries", hr);
+		for (j = 0; j < nn; j++)
+			if (logattr[j].fCharStop != 0)
+				*op++ = items[i].iCharPos + j;
+		delete[] logattr;
+	}
+	// and handle the last item for the end of the string
+	*op++ = items[i].iCharPos;
+
+	delete[] items;
+	return out;
+}
diff --git a/src/libui_sdl/libui/windows/grid.cpp b/src/libui_sdl/libui/windows/grid.cpp
new file mode 100644
index 0000000..c63cd1e
--- /dev/null
+++ b/src/libui_sdl/libui/windows/grid.cpp
@@ -0,0 +1,658 @@
+// 10 june 2016
+#include "uipriv_windows.hpp"
+
+// TODO compare with GTK+:
+// - what happens if you call InsertAt() twice?
+// - what happens if you call Append() twice?
+
+// TODOs
+// - the Assorted page has clipping and repositioning issues
+
+struct gridChild {
+	uiControl *c;
+	int left;
+	int top;
+	int xspan;
+	int yspan;
+	int hexpand;
+	uiAlign halign;
+	int vexpand;
+	uiAlign valign;
+
+	// have these here so they don't need to be reallocated each relayout
+	int finalx, finaly;
+	int finalwidth, finalheight;
+	int minwidth, minheight;
+};
+
+struct uiGrid {
+	uiWindowsControl c;
+	HWND hwnd;
+	std::vector<struct gridChild *> *children;
+	std::map<uiControl *, size_t> *indexof;
+	int padded;
+
+	int xmin, ymin;
+	int xmax, ymax;
+};
+
+static bool gridRecomputeMinMax(uiGrid *g)
+{
+	bool first = true;
+
+	for (struct gridChild *gc : *(g->children)) {
+		// this is important; we want g->xmin/g->ymin to satisfy gridLayoutData::visibleRow()/visibleColumn()
+		if (!uiControlVisible(gc->c))
+			continue;
+		if (first) {
+			g->xmin = gc->left;
+			g->ymin = gc->top;
+			g->xmax = gc->left + gc->xspan;
+			g->ymax = gc->top + gc->yspan;
+			first = false;
+			continue;
+		}
+		if (g->xmin > gc->left)
+			g->xmin = gc->left;
+		if (g->ymin > gc->top)
+			g->ymin = gc->top;
+		if (g->xmax < (gc->left + gc->xspan))
+			g->xmax = gc->left + gc->xspan;
+		if (g->ymax < (gc->top + gc->yspan))
+			g->ymax = gc->top + gc->yspan;
+	}
+	return first != false;
+}
+
+#define xcount(g) ((g)->xmax - (g)->xmin)
+#define ycount(g) ((g)->ymax - (g)->ymin)
+#define toxindex(g, x) ((x) - (g)->xmin)
+#define toyindex(g, y) ((y) - (g)->ymin)
+
+class gridLayoutData {
+	int ycount;
+public:
+	int **gg;		// topological map gg[y][x] = control index
+	int *colwidths;
+	int *rowheights;
+	bool *hexpand;
+	bool *vexpand;
+	int nVisibleRows;
+	int nVisibleColumns;
+
+	bool noVisible;
+
+	gridLayoutData(uiGrid *g)
+	{
+		size_t i;
+		int x, y;
+
+		this->noVisible = gridRecomputeMinMax(g);
+
+		this->gg = new int *[ycount(g)];
+		for (y = 0; y < ycount(g); y++) {
+			this->gg[y] = new int[xcount(g)];
+			for (x = 0; x < xcount(g); x++)
+				this->gg[y][x] = -1;
+		}
+
+		for (i = 0; i < g->children->size(); i++) {
+			struct gridChild *gc;
+
+			gc = (*(g->children))[i];
+			if (!uiControlVisible(gc->c))
+				continue;
+			for (y = gc->top; y < gc->top + gc->yspan; y++)
+				for (x = gc->left; x < gc->left + gc->xspan; x++)
+					this->gg[toyindex(g, y)][toxindex(g, x)] = i;
+		}
+
+		this->colwidths = new int[xcount(g)];
+		ZeroMemory(this->colwidths, xcount(g) * sizeof (int));
+		this->rowheights = new int[ycount(g)];
+		ZeroMemory(this->rowheights, ycount(g) * sizeof (int));
+		this->hexpand = new bool[xcount(g)];
+		ZeroMemory(this->hexpand, xcount(g) * sizeof (bool));
+		this->vexpand = new bool[ycount(g)];
+		ZeroMemory(this->vexpand, ycount(g) * sizeof (bool));
+
+		this->ycount = ycount(g);
+
+		// if a row or column only contains emptys and spanning cells of a opposite-direction spannings, it is invisible and should not be considered for padding amount calculations
+		// note that the first row and column will always be visible because gridRecomputeMinMax() computed a smallest fitting rectangle
+		if (this->noVisible)
+			return;
+		this->nVisibleRows = 0;
+		for (y = 0; y < this->ycount; y++)
+			if (this->visibleRow(g, y))
+				this->nVisibleRows++;
+		this->nVisibleColumns = 0;
+		for (x = 0; x < xcount(g); x++)
+			if (this->visibleColumn(g, x))
+				this->nVisibleColumns++;
+	}
+
+	~gridLayoutData()
+	{
+		size_t y;
+
+		delete[] this->hexpand;
+		delete[] this->vexpand;
+		delete[] this->colwidths;
+		delete[] this->rowheights;
+		for (y = 0; y < this->ycount; y++)
+			delete[] this->gg[y];
+		delete[] this->gg;
+	}
+
+	bool visibleRow(uiGrid *g, int y)
+	{
+		int x;
+		struct gridChild *gc;
+
+		for (x = 0; x < xcount(g); x++)
+			if (this->gg[y][x] != -1) {
+				gc = (*(g->children))[this->gg[y][x]];
+				if (gc->yspan == 1 || gc->top - g->ymin == y)
+					return true;
+			}
+		return false;
+	}
+
+	bool visibleColumn(uiGrid *g, int x)
+	{
+		int y;
+		struct gridChild *gc;
+
+		for (y = 0; y < this->ycount; y++)
+			if (this->gg[y][x] != -1) {
+				gc = (*(g->children))[this->gg[y][x]];
+				if (gc->xspan == 1 || gc->left - g->xmin == x)
+					return true;
+			}
+		return false;
+	}
+};
+
+static void gridPadding(uiGrid *g, int *xpadding, int *ypadding)
+{
+	uiWindowsSizing sizing;
+
+	*xpadding = 0;
+	*ypadding = 0;
+	if (g->padded) {
+		uiWindowsGetSizing(g->hwnd, &sizing);
+		uiWindowsSizingStandardPadding(&sizing, xpadding, ypadding);
+	}
+}
+
+static void gridRelayout(uiGrid *g)
+{
+	RECT r;
+	int x, y, width, height;
+	gridLayoutData *ld;
+	int xpadding, ypadding;
+	int ix, iy;
+	int iwidth, iheight;
+	int i;
+	struct gridChild *gc;
+	int nhexpand, nvexpand;
+
+	if (g->children->size() == 0)
+		return;		// nothing to do
+
+	uiWindowsEnsureGetClientRect(g->hwnd, &r);
+	x = r.left;
+	y = r.top;
+	width = r.right - r.left;
+	height = r.bottom - r.top;
+
+	gridPadding(g, &xpadding, &ypadding);
+	ld = new gridLayoutData(g);
+	if (ld->noVisible) {		// nothing to do
+		delete ld;
+		return;
+	}
+
+	// 0) discount padding from width/height
+	width -= (ld->nVisibleColumns - 1) * xpadding;
+	height -= (ld->nVisibleRows - 1) * ypadding;
+
+	// 1) compute colwidths and rowheights before handling expansion
+	// we only count non-spanning controls to avoid weirdness
+	for (iy = 0; iy < ycount(g); iy++)
+		for (ix = 0; ix < xcount(g); ix++) {
+			i = ld->gg[iy][ix];
+			if (i == -1)
+				continue;
+			gc = (*(g->children))[i];
+			uiWindowsControlMinimumSize(uiWindowsControl(gc->c), &iwidth, &iheight);
+			if (gc->xspan == 1)
+				if (ld->colwidths[ix] < iwidth)
+					ld->colwidths[ix] = iwidth;
+			if (gc->yspan == 1)
+				if (ld->rowheights[iy] < iheight)
+					ld->rowheights[iy] = iheight;
+			// save these for step 6
+			gc->minwidth = iwidth;
+			gc->minheight = iheight;
+		}
+
+	// 2) figure out which rows/columns expand but not span
+	// we need to know which expanding rows/columns don't span before we can handle the ones that do
+	for (i = 0; i < g->children->size(); i++) {
+		gc = (*(g->children))[i];
+		if (!uiControlVisible(gc->c))
+			continue;
+		if (gc->hexpand && gc->xspan == 1)
+			ld->hexpand[toxindex(g, gc->left)] = true;
+		if (gc->vexpand && gc->yspan == 1)
+			ld->vexpand[toyindex(g, gc->top)] = true;
+	}
+
+	// 3) figure out which rows/columns expand that do span
+	// the way we handle this is simple: if none of the spanned rows/columns expand, make all rows/columns expand
+	for (i = 0; i < g->children->size(); i++) {
+		gc = (*(g->children))[i];
+		if (!uiControlVisible(gc->c))
+			continue;
+		if (gc->hexpand && gc->xspan != 1) {
+			bool doit = true;
+
+			for (ix = gc->left; ix < gc->left + gc->xspan; ix++)
+				if (ld->hexpand[toxindex(g, ix)]) {
+					doit = false;
+					break;
+				}
+			if (doit)
+				for (ix = gc->left; ix < gc->left + gc->xspan; ix++)
+					ld->hexpand[toxindex(g, ix)] = true;
+		}
+		if (gc->vexpand && gc->yspan != 1) {
+			bool doit = true;
+
+			for (iy = gc->top; iy < gc->top + gc->yspan; iy++)
+				if (ld->vexpand[toyindex(g, iy)]) {
+					doit = false;
+					break;
+				}
+			if (doit)
+				for (iy = gc->top; iy < gc->top + gc->yspan; iy++)
+					ld->vexpand[toyindex(g, iy)] = true;
+		}
+	}
+
+	// 4) compute and assign expanded widths/heights
+	nhexpand = 0;
+	nvexpand = 0;
+	for (i = 0; i < xcount(g); i++)
+		if (ld->hexpand[i])
+			nhexpand++;
+		else
+			width -= ld->colwidths[i];
+	for (i = 0; i < ycount(g); i++)
+		if (ld->vexpand[i])
+			nvexpand++;
+		else
+			height -= ld->rowheights[i];
+	for (i = 0; i < xcount(g); i++)
+		if (ld->hexpand[i])
+			ld->colwidths[i] = width / nhexpand;
+	for (i = 0; i < ycount(g); i++)
+		if (ld->vexpand[i])
+			ld->rowheights[i] = height / nvexpand;
+
+	// 5) reset the final coordinates for the next step
+	for (i = 0; i < g->children->size(); i++) {
+		gc = (*(g->children))[i];
+		if (!uiControlVisible(gc->c))
+			continue;
+		gc->finalx = 0;
+		gc->finaly = 0;
+		gc->finalwidth = 0;
+		gc->finalheight = 0;
+	}
+
+	// 6) compute cell positions and sizes
+	for (iy = 0; iy < ycount(g); iy++) {
+		int curx;
+		int prev;
+
+		curx = 0;
+		prev = -1;
+		for (ix = 0; ix < xcount(g); ix++) {
+			if (!ld->visibleColumn(g, ix))
+				continue;
+			i = ld->gg[iy][ix];
+			if (i != -1) {
+				gc = (*(g->children))[i];
+				if (iy == toyindex(g, gc->top)) {		// don't repeat this step if the control spans vertically
+					if (i != prev)
+						gc->finalx = curx;
+					else
+						gc->finalwidth += xpadding;
+					gc->finalwidth += ld->colwidths[ix];
+				}
+			}
+			curx += ld->colwidths[ix] + xpadding;
+			prev = i;
+		}
+	}
+	for (ix = 0; ix < xcount(g); ix++) {
+		int cury;
+		int prev;
+
+		cury = 0;
+		prev = -1;
+		for (iy = 0; iy < ycount(g); iy++) {
+			if (!ld->visibleRow(g, iy))
+				continue;
+			i = ld->gg[iy][ix];
+			if (i != -1) {
+				gc = (*(g->children))[i];
+				if (ix == toxindex(g, gc->left)) {		// don't repeat this step if the control spans horizontally
+					if (i != prev)
+						gc->finaly = cury;
+					else
+						gc->finalheight += ypadding;
+					gc->finalheight += ld->rowheights[iy];
+				}
+			}
+			cury += ld->rowheights[iy] + ypadding;
+			prev = i;
+		}
+	}
+
+	// 7) everything as it stands now is set for xalign == Fill yalign == Fill; set the correct alignments
+	// this is why we saved minwidth/minheight above
+	for (i = 0; i < g->children->size(); i++) {
+		gc = (*(g->children))[i];
+		if (!uiControlVisible(gc->c))
+			continue;
+		if (gc->halign != uiAlignFill) {
+			switch (gc->halign) {
+			case uiAlignEnd:
+				gc->finalx += gc->finalwidth - gc->minwidth;
+				break;
+			case uiAlignCenter:
+				gc->finalx += (gc->finalwidth - gc->minwidth) / 2;
+				break;
+			}
+			gc->finalwidth = gc->minwidth;		// for all three
+		}
+		if (gc->valign != uiAlignFill) {
+			switch (gc->valign) {
+			case uiAlignEnd:
+				gc->finaly += gc->finalheight - gc->minheight;
+				break;
+			case uiAlignCenter:
+				gc->finaly += (gc->finalheight - gc->minheight) / 2;
+				break;
+			}
+			gc->finalheight = gc->minheight;		// for all three
+		}
+	}
+
+	// 8) and FINALLY we resize
+	for (iy = 0; iy < ycount(g); iy++)
+		for (ix = 0; ix < xcount(g); ix++) {
+			i = ld->gg[iy][ix];
+			if (i != -1) {		// treat empty cells like spaces
+				gc = (*(g->children))[i];
+				uiWindowsEnsureMoveWindowDuringResize(
+					(HWND) uiControlHandle(gc->c),
+ 					gc->finalx,//TODO + x,
+					gc->finaly,//TODO + y,
+					gc->finalwidth,
+					gc->finalheight);
+			}
+		}
+
+	delete ld;
+}
+
+static void uiGridDestroy(uiControl *c)
+{
+	uiGrid *g = uiGrid(c);
+
+	for (struct gridChild *gc : *(g->children)) {
+		uiControlSetParent(gc->c, NULL);
+		uiControlDestroy(gc->c);
+		uiFree(gc);
+	}
+	delete g->indexof;
+	delete g->children;
+	uiWindowsEnsureDestroyWindow(g->hwnd);
+	uiFreeControl(uiControl(g));
+}
+
+uiWindowsControlDefaultHandle(uiGrid)
+uiWindowsControlDefaultParent(uiGrid)
+uiWindowsControlDefaultSetParent(uiGrid)
+uiWindowsControlDefaultToplevel(uiGrid)
+uiWindowsControlDefaultVisible(uiGrid)
+uiWindowsControlDefaultShow(uiGrid)
+uiWindowsControlDefaultHide(uiGrid)
+uiWindowsControlDefaultEnabled(uiGrid)
+uiWindowsControlDefaultEnable(uiGrid)
+uiWindowsControlDefaultDisable(uiGrid)
+
+static void uiGridSyncEnableState(uiWindowsControl *c, int enabled)
+{
+	uiGrid *g = uiGrid(c);
+
+	if (uiWindowsShouldStopSyncEnableState(uiWindowsControl(g), enabled))
+		return;
+	for (const struct gridChild *gc : *(g->children))
+		uiWindowsControlSyncEnableState(uiWindowsControl(gc->c), enabled);
+}
+
+uiWindowsControlDefaultSetParentHWND(uiGrid)
+
+static void uiGridMinimumSize(uiWindowsControl *c, int *width, int *height)
+{
+	uiGrid *g = uiGrid(c);
+	int xpadding, ypadding;
+	gridLayoutData *ld;
+	int x, y;
+	int i;
+	struct gridChild *gc;
+	int minwid, minht;
+	int colwidth, rowheight;
+
+	*width = 0;
+	*height = 0;
+	if (g->children->size() == 0)
+		return;		// nothing to do
+
+	gridPadding(g, &xpadding, &ypadding);
+	ld = new gridLayoutData(g);
+	if (ld->noVisible) {		// nothing to do; return 0x0
+		delete ld;
+		return;
+	}
+
+	// 1) compute colwidths and rowheights before handling expansion
+	// TODO put this in its own function (but careful about the spanning calculation in gridRelayout())
+	for (y = 0; y < ycount(g); y++)
+		for (x = 0; x < xcount(g); x++) {
+			i = ld->gg[y][x];
+			if (i == -1)
+				continue;
+			gc = (*(g->children))[i];
+			uiWindowsControlMinimumSize(uiWindowsControl(gc->c), &minwid, &minht);
+			// allot equal space in the presence of spanning to keep things sane
+			if (ld->colwidths[x] < minwid / gc->xspan)
+				ld->colwidths[x] = minwid / gc->xspan;
+			if (ld->rowheights[y] < minht / gc->yspan)
+				ld->rowheights[y] = minht / gc->yspan;
+			// save these for step 6
+			gc->minwidth = minwid;
+			gc->minheight = minht;
+		}
+
+	// 2) compute total column width/row height
+	colwidth = 0;
+	rowheight = 0;
+	for (x = 0; x < xcount(g); x++)
+		colwidth += ld->colwidths[x];
+	for (y = 0; y < ycount(g); y++)
+		rowheight += ld->rowheights[y];
+
+	// and that's it; just account for padding
+	*width = colwidth + (ld->nVisibleColumns - 1) * xpadding;
+	*height = rowheight + (ld->nVisibleRows - 1) * ypadding;
+}
+
+static void uiGridMinimumSizeChanged(uiWindowsControl *c)
+{
+	uiGrid *g = uiGrid(c);
+
+	if (uiWindowsControlTooSmall(uiWindowsControl(g))) {
+		uiWindowsControlContinueMinimumSizeChanged(uiWindowsControl(g));
+		return;
+	}
+	gridRelayout(g);
+}
+
+uiWindowsControlDefaultLayoutRect(uiGrid)
+uiWindowsControlDefaultAssignControlIDZOrder(uiGrid)
+
+static void uiGridChildVisibilityChanged(uiWindowsControl *c)
+{
+	// TODO eliminate the redundancy
+	uiWindowsControlMinimumSizeChanged(c);
+}
+
+// must have called gridRecomputeMinMax() first
+static void gridArrangeChildren(uiGrid *g)
+{
+	LONG_PTR controlID;
+	HWND insertAfter;
+	gridLayoutData *ld;
+	bool *visited;
+	int x, y;
+	int i;
+	struct gridChild *gc;
+
+	if (g->children->size() == 0)
+		return;		// nothing to do
+	ld = new gridLayoutData(g);
+	controlID = 100;
+	insertAfter = NULL;
+	visited = new bool[g->children->size()];
+	ZeroMemory(visited, g->children->size() * sizeof (bool));
+	for (y = 0; y < ycount(g); y++)
+		for (x = 0; x < xcount(g); x++) {
+			i = ld->gg[y][x];
+			if (i == -1)
+				continue;
+			if (visited[i])
+				continue;
+			visited[i] = true;
+			gc = (*(g->children))[i];
+			uiWindowsControlAssignControlIDZOrder(uiWindowsControl(gc->c), &controlID, &insertAfter);
+		}
+	delete[] visited;
+	delete ld;
+}
+
+static struct gridChild *toChild(uiControl *c, int xspan, int yspan, int hexpand, uiAlign halign, int vexpand, uiAlign valign)
+{
+	struct gridChild *gc;
+
+	if (xspan < 0)
+		userbug("You cannot have a negative xspan in a uiGrid cell.");
+	if (yspan < 0)
+		userbug("You cannot have a negative yspan in a uiGrid cell.");
+	gc = uiNew(struct gridChild);
+	gc->c = c;
+	gc->xspan = xspan;
+	gc->yspan = yspan;
+	gc->hexpand = hexpand;
+	gc->halign = halign;
+	gc->vexpand = vexpand;
+	gc->valign = valign;
+	return gc;
+}
+
+static void add(uiGrid *g, struct gridChild *gc)
+{
+	uiControlSetParent(gc->c, uiControl(g));
+	uiWindowsControlSetParentHWND(uiWindowsControl(gc->c), g->hwnd);
+	g->children->push_back(gc);
+	(*(g->indexof))[gc->c] = g->children->size() - 1;
+	gridRecomputeMinMax(g);
+	gridArrangeChildren(g);
+	uiWindowsControlMinimumSizeChanged(uiWindowsControl(g));
+}
+
+void uiGridAppend(uiGrid *g, uiControl *c, int left, int top, int xspan, int yspan, int hexpand, uiAlign halign, int vexpand, uiAlign valign)
+{
+	struct gridChild *gc;
+
+	gc = toChild(c, xspan, yspan, hexpand, halign, vexpand, valign);
+	gc->left = left;
+	gc->top = top;
+	add(g, gc);
+}
+
+// TODO decide what happens if existing is NULL
+void uiGridInsertAt(uiGrid *g, uiControl *c, uiControl *existing, uiAt at, int xspan, int yspan, int hexpand, uiAlign halign, int vexpand, uiAlign valign)
+{
+	struct gridChild *gc;
+	struct gridChild *other;
+
+	gc = toChild(c, xspan, yspan, hexpand, halign, vexpand, valign);
+	other = (*(g->children))[(*(g->indexof))[existing]];
+	switch (at) {
+	case uiAtLeading:
+		gc->left = other->left - gc->xspan;
+		gc->top = other->top;
+		break;
+	case uiAtTop:
+		gc->left = other->left;
+		gc->top = other->top - gc->yspan;
+		break;
+	case uiAtTrailing:
+		gc->left = other->left + other->xspan;
+		gc->top = other->top;
+		break;
+	case uiAtBottom:
+		gc->left = other->left;
+		gc->top = other->top + other->yspan;
+		break;
+	// TODO add error checks to ALL enums
+	}
+	add(g, gc);
+}
+
+int uiGridPadded(uiGrid *g)
+{
+	return g->padded;
+}
+
+void uiGridSetPadded(uiGrid *g, int padded)
+{
+	g->padded = padded;
+	uiWindowsControlMinimumSizeChanged(uiWindowsControl(g));
+}
+
+static void onResize(uiWindowsControl *c)
+{
+	gridRelayout(uiGrid(c));
+}
+
+uiGrid *uiNewGrid(void)
+{
+	uiGrid *g;
+
+	uiWindowsNewControl(uiGrid, g);
+
+	g->hwnd = uiWindowsMakeContainer(uiWindowsControl(g), onResize);
+
+	g->children = new std::vector<struct gridChild *>;
+	g->indexof = new std::map<uiControl *, size_t>;
+
+	return g;
+}
diff --git a/src/libui_sdl/libui/windows/group.cpp b/src/libui_sdl/libui/windows/group.cpp
new file mode 100644
index 0000000..8824c5a
--- /dev/null
+++ b/src/libui_sdl/libui/windows/group.cpp
@@ -0,0 +1,217 @@
+// 16 may 2015
+#include "uipriv_windows.hpp"
+
+struct uiGroup {
+	uiWindowsControl c;
+	HWND hwnd;
+	struct uiControl *child;
+	int margined;
+};
+
+// from https://msdn.microsoft.com/en-us/library/windows/desktop/dn742486.aspx#sizingandspacing
+#define groupXMargin 6
+#define groupYMarginTop 11 /* note this value /includes/ the groupbox label */
+#define groupYMarginBottom 7
+
+// unfortunately because the client area of a groupbox includes the frame and caption text, we have to apply some margins ourselves, even if we don't want "any"
+// these were deduced by hand based on the standard DLU conversions; the X and Y top margins are the width and height, respectively, of one character cell
+// they can be fine-tuned later
+#define groupUnmarginedXMargin 4
+#define groupUnmarginedYMarginTop 8
+#define groupUnmarginedYMarginBottom 3
+
+static void groupMargins(uiGroup *g, int *mx, int *mtop, int *mbottom)
+{
+	uiWindowsSizing sizing;
+
+	*mx = groupUnmarginedXMargin;
+	*mtop = groupUnmarginedYMarginTop;
+	*mbottom = groupUnmarginedYMarginBottom;
+	if (g->margined) {
+		*mx = groupXMargin;
+		*mtop = groupYMarginTop;
+		*mbottom = groupYMarginBottom;
+	}
+	uiWindowsGetSizing(g->hwnd, &sizing);
+	uiWindowsSizingDlgUnitsToPixels(&sizing, mx, mtop);
+	uiWindowsSizingDlgUnitsToPixels(&sizing, NULL, mbottom);
+}
+
+static void groupRelayout(uiGroup *g)
+{
+	RECT r;
+	int mx, mtop, mbottom;
+
+	if (g->child == NULL)
+		return;
+	uiWindowsEnsureGetClientRect(g->hwnd, &r);
+	groupMargins(g, &mx, &mtop, &mbottom);
+	r.left += mx;
+	r.top += mtop;
+	r.right -= mx;
+	r.bottom -= mbottom;
+	uiWindowsEnsureMoveWindowDuringResize((HWND) uiControlHandle(g->child), r.left, r.top, r.right - r.left, r.bottom - r.top);
+}
+
+static void uiGroupDestroy(uiControl *c)
+{
+	uiGroup *g = uiGroup(c);
+
+	if (g->child != NULL) {
+		uiControlSetParent(g->child, NULL);
+		uiControlDestroy(g->child);
+	}
+	uiWindowsEnsureDestroyWindow(g->hwnd);
+	uiFreeControl(uiControl(g));
+}
+
+uiWindowsControlDefaultHandle(uiGroup)
+uiWindowsControlDefaultParent(uiGroup)
+uiWindowsControlDefaultSetParent(uiGroup)
+uiWindowsControlDefaultToplevel(uiGroup)
+uiWindowsControlDefaultVisible(uiGroup)
+uiWindowsControlDefaultShow(uiGroup)
+uiWindowsControlDefaultHide(uiGroup)
+uiWindowsControlDefaultEnabled(uiGroup)
+uiWindowsControlDefaultEnable(uiGroup)
+uiWindowsControlDefaultDisable(uiGroup)
+
+static void uiGroupSyncEnableState(uiWindowsControl *c, int enabled)
+{
+	uiGroup *g = uiGroup(c);
+
+	if (uiWindowsShouldStopSyncEnableState(uiWindowsControl(g), enabled))
+		return;
+	EnableWindow(g->hwnd, enabled);
+	if (g->child != NULL)
+		uiWindowsControlSyncEnableState(uiWindowsControl(g->child), enabled);
+}
+
+uiWindowsControlDefaultSetParentHWND(uiGroup)
+
+static void uiGroupMinimumSize(uiWindowsControl *c, int *width, int *height)
+{
+	uiGroup *g = uiGroup(c);
+	int mx, mtop, mbottom;
+	int labelWidth;
+
+	*width = 0;
+	*height = 0;
+	if (g->child != NULL)
+		uiWindowsControlMinimumSize(uiWindowsControl(g->child), width, height);
+	labelWidth = uiWindowsWindowTextWidth(g->hwnd);
+	if (*width < labelWidth)		// don't clip the label; it doesn't ellipsize
+		*width = labelWidth;
+	groupMargins(g, &mx, &mtop, &mbottom);
+	*width += 2 * mx;
+	*height += mtop + mbottom;
+}
+
+static void uiGroupMinimumSizeChanged(uiWindowsControl *c)
+{
+	uiGroup *g = uiGroup(c);
+
+	if (uiWindowsControlTooSmall(uiWindowsControl(g))) {
+		uiWindowsControlContinueMinimumSizeChanged(uiWindowsControl(g));
+		return;
+	}
+	groupRelayout(g);
+}
+
+uiWindowsControlDefaultLayoutRect(uiGroup)
+uiWindowsControlDefaultAssignControlIDZOrder(uiGroup)
+
+static void uiGroupChildVisibilityChanged(uiWindowsControl *c)
+{
+	// TODO eliminate the redundancy
+	uiWindowsControlMinimumSizeChanged(c);
+}
+
+char *uiGroupTitle(uiGroup *g)
+{
+	return uiWindowsWindowText(g->hwnd);
+}
+
+void uiGroupSetTitle(uiGroup *g, const char *text)
+{
+	uiWindowsSetWindowText(g->hwnd, text);
+	// changing the text might necessitate a change in the groupbox's size
+	uiWindowsControlMinimumSizeChanged(uiWindowsControl(g));
+}
+
+void uiGroupSetChild(uiGroup *g, uiControl *child)
+{
+	if (g->child != NULL) {
+		uiControlSetParent(g->child, NULL);
+		uiWindowsControlSetParentHWND(uiWindowsControl(g->child), NULL);
+	}
+	g->child = child;
+	if (g->child != NULL) {
+		uiControlSetParent(g->child, uiControl(g));
+		uiWindowsControlSetParentHWND(uiWindowsControl(g->child), g->hwnd);
+		uiWindowsControlAssignSoleControlIDZOrder(uiWindowsControl(g->child));
+		uiWindowsControlMinimumSizeChanged(uiWindowsControl(g));
+	}
+}
+
+int uiGroupMargined(uiGroup *g)
+{
+	return g->margined;
+}
+
+void uiGroupSetMargined(uiGroup *g, int margined)
+{
+	g->margined = margined;
+	uiWindowsControlMinimumSizeChanged(uiWindowsControl(g));
+}
+
+static LRESULT CALLBACK groupSubProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
+{
+	uiGroup *g = uiGroup(dwRefData);
+	WINDOWPOS *wp = (WINDOWPOS *) lParam;
+	MINMAXINFO *mmi = (MINMAXINFO *) lParam;
+	int minwid, minht;
+	LRESULT lResult;
+
+	if (handleParentMessages(hwnd, uMsg, wParam, lParam, &lResult) != FALSE)
+		return lResult;
+	switch (uMsg) {
+	case WM_WINDOWPOSCHANGED:
+		if ((wp->flags & SWP_NOSIZE) != 0)
+			break;
+		groupRelayout(g);
+		return 0;
+	case WM_GETMINMAXINFO:
+		lResult = DefWindowProcW(hwnd, uMsg, wParam, lParam);
+		uiWindowsControlMinimumSize(uiWindowsControl(g), &minwid, &minht);
+		mmi->ptMinTrackSize.x = minwid;
+		mmi->ptMinTrackSize.y = minht;
+		return lResult;
+	case WM_NCDESTROY:
+		if (RemoveWindowSubclass(hwnd, groupSubProc, uIdSubclass) == FALSE)
+			logLastError(L"error removing groupbox subclass");
+		break;
+	}
+	return DefSubclassProc(hwnd, uMsg, wParam, lParam);
+}
+
+uiGroup *uiNewGroup(const char *text)
+{
+	uiGroup *g;
+	WCHAR *wtext;
+
+	uiWindowsNewControl(uiGroup, g);
+
+	wtext = toUTF16(text);
+	g->hwnd = uiWindowsEnsureCreateControlHWND(WS_EX_CONTROLPARENT,
+		L"button", wtext,
+		BS_GROUPBOX,
+		hInstance, NULL,
+		TRUE);
+	uiFree(wtext);
+
+	if (SetWindowSubclass(g->hwnd, groupSubProc, 0, (DWORD_PTR) g) == FALSE)
+		logLastError(L"error subclassing groupbox to handle parent messages");
+
+	return g;
+}
diff --git a/src/libui_sdl/libui/windows/init.cpp b/src/libui_sdl/libui/windows/init.cpp
new file mode 100644
index 0000000..2287416
--- /dev/null
+++ b/src/libui_sdl/libui/windows/init.cpp
@@ -0,0 +1,167 @@
+// 6 april 2015
+#include "uipriv_windows.hpp"
+
+HINSTANCE hInstance;
+int nCmdShow;
+
+HFONT hMessageFont;
+
+// LONGTERM needed?
+HBRUSH hollowBrush;
+
+// the returned pointer is actually to the second character
+// if the first character is - then free, otherwise don't
+static const char *initerr(const char *message, const WCHAR *label, DWORD value)
+{
+	WCHAR *sysmsg;
+	BOOL hassysmsg;
+	WCHAR *wmessage;
+	WCHAR *wout;
+	char *out;
+
+	hassysmsg = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, value, 0, (LPWSTR) (&sysmsg), 0, NULL) != 0;
+	if (!hassysmsg)
+		sysmsg = L"";
+	wmessage = toUTF16(message + 1);
+	wout = strf(L"-error initializing libui: %s; code %I32d (0x%08I32X) %s",
+		wmessage,
+		value, value,
+		sysmsg);
+	uiFree(wmessage);
+	if (hassysmsg)
+		LocalFree(sysmsg);		// ignore error
+	out = toUTF8(wout);
+	uiFree(wout);
+	return out + 1;
+}
+
+#define ieLastErr(msg) initerr("=" msg, L"GetLastError() ==", GetLastError())
+#define ieHRESULT(msg, hr) initerr("=" msg, L"HRESULT", (DWORD) hr)
+
+// LONGTERM make common
+uiInitOptions options;
+
+#define wantedICCClasses ( \
+	ICC_STANDARD_CLASSES |	/* user32.dll controls */		\
+	ICC_PROGRESS_CLASS |		/* progress bars */			\
+	ICC_TAB_CLASSES |			/* tabs */					\
+	ICC_LISTVIEW_CLASSES |		/* table headers */			\
+	ICC_UPDOWN_CLASS |		/* spinboxes */			\
+	ICC_BAR_CLASSES |			/* trackbar */				\
+	ICC_DATE_CLASSES |		/* date/time picker */		\
+	0)
+
+const char *uiInit(uiInitOptions *o)
+{
+	STARTUPINFOW si;
+	const char *ce;
+	HICON hDefaultIcon;
+	HCURSOR hDefaultCursor;
+	NONCLIENTMETRICSW ncm;
+	INITCOMMONCONTROLSEX icc;
+	HRESULT hr;
+
+	options = *o;
+
+	initAlloc();
+
+	nCmdShow = SW_SHOWDEFAULT;
+	GetStartupInfoW(&si);
+	if ((si.dwFlags & STARTF_USESHOWWINDOW) != 0)
+		nCmdShow = si.wShowWindow;
+
+	// LONGTERM set DPI awareness
+
+	hDefaultIcon = LoadIconW(NULL, IDI_APPLICATION);
+	if (hDefaultIcon == NULL)
+		return ieLastErr("loading default icon for window classes");
+	hDefaultCursor = LoadCursorW(NULL, IDC_ARROW);
+	if (hDefaultCursor == NULL)
+		return ieLastErr("loading default cursor for window classes");
+
+	ce = initUtilWindow(hDefaultIcon, hDefaultCursor);
+	if (ce != NULL)
+		return initerr(ce, L"GetLastError() ==", GetLastError());
+
+	if (registerWindowClass(hDefaultIcon, hDefaultCursor) == 0)
+		return ieLastErr("registering uiWindow window class");
+
+	ZeroMemory(&ncm, sizeof (NONCLIENTMETRICSW));
+	ncm.cbSize = sizeof (NONCLIENTMETRICSW);
+	if (SystemParametersInfoW(SPI_GETNONCLIENTMETRICS, sizeof (NONCLIENTMETRICSW), &ncm, sizeof (NONCLIENTMETRICSW)) == 0)
+		return ieLastErr("getting default fonts");
+	hMessageFont = CreateFontIndirectW(&(ncm.lfMessageFont));
+	if (hMessageFont == NULL)
+		return ieLastErr("loading default messagebox font; this is the default UI font");
+
+	if (initContainer(hDefaultIcon, hDefaultCursor) == 0)
+		return ieLastErr("initializing uiWindowsMakeContainer() window class");
+
+	hollowBrush = (HBRUSH) GetStockObject(HOLLOW_BRUSH);
+	if (hollowBrush == NULL)
+		return ieLastErr("getting hollow brush");
+
+	ZeroMemory(&icc, sizeof (INITCOMMONCONTROLSEX));
+	icc.dwSize = sizeof (INITCOMMONCONTROLSEX);
+	icc.dwICC = wantedICCClasses;
+	if (InitCommonControlsEx(&icc) == 0)
+		return ieLastErr("initializing Common Controls");
+
+	hr = CoInitialize(NULL);
+	if (hr != S_OK && hr != S_FALSE)
+		return ieHRESULT("initializing COM", hr);
+	// LONGTERM initialize COM security
+	// LONGTERM (windows vista) turn off COM exception handling
+
+	hr = initDraw();
+	if (hr != S_OK)
+		return ieHRESULT("initializing Direct2D", hr);
+
+	hr = initDrawText();
+	if (hr != S_OK)
+		return ieHRESULT("initializing DirectWrite", hr);
+
+	if (registerAreaClass(hDefaultIcon, hDefaultCursor) == 0)
+		return ieLastErr("registering uiArea window class");
+
+	if (registerMessageFilter() == 0)
+		return ieLastErr("registering libui message filter");
+
+	if (registerD2DScratchClass(hDefaultIcon, hDefaultCursor) == 0)
+		return ieLastErr("initializing D2D scratch window class");
+
+	return NULL;
+}
+
+void uiUninit(void)
+{
+	uninitMenus();
+	unregisterD2DScratchClass();
+	unregisterMessageFilter();
+	unregisterArea();
+	uninitDrawText();
+	uninitDraw();
+	CoUninitialize();
+	if (DeleteObject(hollowBrush) == 0)
+		logLastError(L"error freeing hollow brush");
+	uninitContainer();
+	if (DeleteObject(hMessageFont) == 0)
+		logLastError(L"error deleting control font");
+	unregisterWindowClass();
+	// no need to delete the default icon or cursor; see http://stackoverflow.com/questions/30603077/
+	uninitUtilWindow();
+	uninitAlloc();
+}
+
+void uiFreeInitError(const char *err)
+{
+	if (*(err - 1) == '-')
+		uiFree((void *) (err - 1));
+}
+
+BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
+{
+	if (fdwReason == DLL_PROCESS_ATTACH)
+		hInstance = hinstDLL;
+	return TRUE;
+}
diff --git a/src/libui_sdl/libui/windows/label.cpp b/src/libui_sdl/libui/windows/label.cpp
new file mode 100644
index 0000000..d74b7d1
--- /dev/null
+++ b/src/libui_sdl/libui/windows/label.cpp
@@ -0,0 +1,57 @@
+// 11 april 2015
+#include "uipriv_windows.hpp"
+
+struct uiLabel {
+	uiWindowsControl c;
+	HWND hwnd;
+};
+
+uiWindowsControlAllDefaults(uiLabel)
+
+// via http://msdn.microsoft.com/en-us/library/windows/desktop/dn742486.aspx#sizingandspacing
+#define labelHeight 8
+
+static void uiLabelMinimumSize(uiWindowsControl *c, int *width, int *height)
+{
+	uiLabel *l = uiLabel(c);
+	uiWindowsSizing sizing;
+	int y;
+
+	*width = uiWindowsWindowTextWidth(l->hwnd);
+	y = labelHeight;
+	uiWindowsGetSizing(l->hwnd, &sizing);
+	uiWindowsSizingDlgUnitsToPixels(&sizing, NULL, &y);
+	*height = y;
+}
+
+char *uiLabelText(uiLabel *l)
+{
+	return uiWindowsWindowText(l->hwnd);
+}
+
+void uiLabelSetText(uiLabel *l, const char *text)
+{
+	uiWindowsSetWindowText(l->hwnd, text);
+	// changing the text might necessitate a change in the label's size
+	uiWindowsControlMinimumSizeChanged(uiWindowsControl(l));
+}
+
+uiLabel *uiNewLabel(const char *text)
+{
+	uiLabel *l;
+	WCHAR *wtext;
+
+	uiWindowsNewControl(uiLabel, l);
+
+	wtext = toUTF16(text);
+	l->hwnd = uiWindowsEnsureCreateControlHWND(0,
+		L"static", wtext,
+		// SS_LEFTNOWORDWRAP clips text past the end; SS_NOPREFIX avoids accelerator translation
+		// controls are vertically aligned to the top by default (thanks Xeek in irc.freenode.net/#winapi)
+		SS_LEFTNOWORDWRAP | SS_NOPREFIX,
+		hInstance, NULL,
+		TRUE);
+	uiFree(wtext);
+
+	return l;
+}
diff --git a/src/libui_sdl/libui/windows/libui.manifest b/src/libui_sdl/libui/windows/libui.manifest
new file mode 100644
index 0000000..8beb6cf
--- /dev/null
+++ b/src/libui_sdl/libui/windows/libui.manifest
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+<assemblyIdentity
+    version="1.0.0.0"
+    processorArchitecture="*"
+    name="CompanyName.ProductName.YourApplication"
+    type="win32"
+/>
+<description>Your application description here.</description>
+<dependency>
+    <dependentAssembly>
+        <assemblyIdentity
+            type="win32"
+            name="Microsoft.Windows.Common-Controls"
+            version="6.0.0.0"
+            processorArchitecture="*"
+            publicKeyToken="6595b64144ccf1df"
+            language="*"
+        />
+    </dependentAssembly>
+</dependency>
+<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
+    <application>
+        <!--The ID below indicates application support for Windows Vista -->
+        <supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/>
+        <!--The ID below indicates application support for Windows 7 -->
+        <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
+    </application>
+</compatibility>
+</assembly>
+
diff --git a/src/libui_sdl/libui/windows/main.cpp b/src/libui_sdl/libui/windows/main.cpp
new file mode 100644
index 0000000..eb6d849
--- /dev/null
+++ b/src/libui_sdl/libui/windows/main.cpp
@@ -0,0 +1,130 @@
+// 6 april 2015
+#include "uipriv_windows.hpp"
+
+static HHOOK filter;
+
+static LRESULT CALLBACK filterProc(int code, WPARAM wParam, LPARAM lParam)
+{
+	MSG *msg = (MSG *) lParam;
+
+	if (code < 0)
+		goto callNext;
+
+	if (areaFilter(msg))		// don't continue to our IsDialogMessage() hack if the area handled it
+		goto discard;
+
+	// TODO IsDialogMessage() hack here
+
+	// otherwise keep going
+	goto callNext;
+
+discard:
+	// we handled it; discard the message so the dialog manager doesn't see it
+	return 1;
+
+callNext:
+	return CallNextHookEx(filter, code, wParam, lParam);
+}
+
+int registerMessageFilter(void)
+{
+	filter = SetWindowsHookExW(WH_MSGFILTER,
+		filterProc,
+		hInstance,
+		GetCurrentThreadId());
+	return filter != NULL;
+}
+
+void unregisterMessageFilter(void)
+{
+	if (UnhookWindowsHookEx(filter) == 0)
+		logLastError(L"error unregistering libui message filter");
+}
+
+// LONGTERM http://blogs.msdn.com/b/oldnewthing/archive/2005/04/08/406509.aspx when adding accelerators, TranslateAccelerators() before IsDialogMessage()
+
+static void processMessage(MSG *msg)
+{
+	HWND correctParent;
+
+	if (msg->hwnd != NULL)
+		correctParent = parentToplevel(msg->hwnd);
+	else		// just to be safe
+		correctParent = GetActiveWindow();
+	if (correctParent != NULL)
+		// this calls our mesage filter above for us
+		if (IsDialogMessage(correctParent, msg) != 0)
+			return;
+	TranslateMessage(msg);
+	DispatchMessageW(msg);
+}
+
+static int waitMessage(MSG *msg)
+{
+	int res;
+
+	res = GetMessageW(msg, NULL, 0, 0);
+	if (res < 0) {
+		logLastError(L"error calling GetMessage()");
+		return 0;		// bail out on error
+	}
+	return res != 0;		// returns false on WM_QUIT
+}
+
+void uiMain(void)
+{
+	while (uiMainStep(1))
+		;
+}
+
+void uiMainSteps(void)
+{
+	// don't need to do anything here
+}
+
+static int peekMessage(MSG *msg)
+{
+	BOOL res;
+
+	res = PeekMessageW(msg, NULL, 0, 0, PM_REMOVE);
+	if (res == 0)
+		return 2;		// no message available
+	if (msg->message != WM_QUIT)
+		return 1;		// a message
+	return 0;			// WM_QUIT
+}
+
+int uiMainStep(int wait)
+{
+	MSG msg;
+
+	if (wait) {
+		if (!waitMessage(&msg))
+			return 0;
+		processMessage(&msg);
+		return 1;
+	}
+
+	// don't wait for a message
+	switch (peekMessage(&msg)) {
+	case 0:		// quit
+		// TODO PostQuitMessage() again?
+		return 0;
+	case 1:		// process a message
+		processMessage(&msg);
+		// fall out to the case for no message
+	}
+	return 1;		// no message
+}
+
+void uiQuit(void)
+{
+	PostQuitMessage(0);
+}
+
+void uiQueueMain(void (*f)(void *data), void *data)
+{
+	if (PostMessageW(utilWindow, msgQueued, (WPARAM) f, (LPARAM) data) == 0)
+		// LONGTERM this is likely not safe to call across threads (allocates memory)
+		logLastError(L"error queueing function to run on main thread");
+}
diff --git a/src/libui_sdl/libui/windows/menu.cpp b/src/libui_sdl/libui/windows/menu.cpp
new file mode 100644
index 0000000..6112fc1
--- /dev/null
+++ b/src/libui_sdl/libui/windows/menu.cpp
@@ -0,0 +1,369 @@
+// 24 april 2015
+#include "uipriv_windows.hpp"
+
+// LONGTERM migrate to std::vector
+
+static uiMenu **menus = NULL;
+static size_t len = 0;
+static size_t cap = 0;
+static BOOL menusFinalized = FALSE;
+static WORD curID = 100;			// start somewhere safe
+static BOOL hasQuit = FALSE;
+static BOOL hasPreferences = FALSE;
+static BOOL hasAbout = FALSE;
+
+struct uiMenu {
+	WCHAR *name;
+	uiMenuItem **items;
+	size_t len;
+	size_t cap;
+};
+
+struct uiMenuItem {
+	WCHAR *name;
+	int type;
+	WORD id;
+	void (*onClicked)(uiMenuItem *, uiWindow *, void *);
+	void *onClickedData;
+	BOOL disabled;				// template for new instances; kept in sync with everything else
+	BOOL checked;
+	HMENU *hmenus;
+	size_t len;
+	size_t cap;
+};
+
+enum {
+	typeRegular,
+	typeCheckbox,
+	typeQuit,
+	typePreferences,
+	typeAbout,
+	typeSeparator,
+};
+
+#define grow 32
+
+static void sync(uiMenuItem *item)
+{
+	size_t i;
+	MENUITEMINFOW mi;
+
+	ZeroMemory(&mi, sizeof (MENUITEMINFOW));
+	mi.cbSize = sizeof (MENUITEMINFOW);
+	mi.fMask = MIIM_STATE;
+	if (item->disabled)
+		mi.fState |= MFS_DISABLED;
+	if (item->checked)
+		mi.fState |= MFS_CHECKED;
+
+	for (i = 0; i < item->len; i++)
+		if (SetMenuItemInfo(item->hmenus[i], item->id, FALSE, &mi) == 0)
+			logLastError(L"error synchronizing menu items");
+}
+
+static void defaultOnClicked(uiMenuItem *item, uiWindow *w, void *data)
+{
+	// do nothing
+}
+
+static void onQuitClicked(uiMenuItem *item, uiWindow *w, void *data)
+{
+	if (shouldQuit())
+		uiQuit();
+}
+
+void uiMenuItemEnable(uiMenuItem *i)
+{
+	i->disabled = FALSE;
+	sync(i);
+}
+
+void uiMenuItemDisable(uiMenuItem *i)
+{
+	i->disabled = TRUE;
+	sync(i);
+}
+
+void uiMenuItemOnClicked(uiMenuItem *i, void (*f)(uiMenuItem *, uiWindow *, void *), void *data)
+{
+	if (i->type == typeQuit)
+		userbug("You can not call uiMenuItemOnClicked() on a Quit item; use uiOnShouldQuit() instead.");
+	i->onClicked = f;
+	i->onClickedData = data;
+}
+
+int uiMenuItemChecked(uiMenuItem *i)
+{
+	return i->checked != FALSE;
+}
+
+void uiMenuItemSetChecked(uiMenuItem *i, int checked)
+{
+	// use explicit values
+	i->checked = FALSE;
+	if (checked)
+		i->checked = TRUE;
+	sync(i);
+}
+
+static uiMenuItem *newItem(uiMenu *m, int type, const char *name)
+{
+	uiMenuItem *item;
+
+	if (menusFinalized)
+		userbug("You can not create a new menu item after menus have been finalized.");
+
+	if (m->len >= m->cap) {
+		m->cap += grow;
+		m->items = (uiMenuItem **) uiRealloc(m->items, m->cap * sizeof (uiMenuItem *), "uiMenuitem *[]");
+	}
+
+	item = uiNew(uiMenuItem);
+
+	m->items[m->len] = item;
+	m->len++;
+
+	item->type = type;
+	switch (item->type) {
+	case typeQuit:
+		item->name = toUTF16("Quit");
+		break;
+	case typePreferences:
+		item->name = toUTF16("Preferences...");
+		break;
+	case typeAbout:
+		item->name = toUTF16("About");
+		break;
+	case typeSeparator:
+		break;
+	default:
+		item->name = toUTF16(name);
+		break;
+	}
+
+	if (item->type != typeSeparator) {
+		item->id = curID;
+		curID++;
+	}
+
+	if (item->type == typeQuit) {
+		// can't call uiMenuItemOnClicked() here
+		item->onClicked = onQuitClicked;
+		item->onClickedData = NULL;
+	} else
+		uiMenuItemOnClicked(item, defaultOnClicked, NULL);
+
+	return item;
+}
+
+uiMenuItem *uiMenuAppendItem(uiMenu *m, const char *name)
+{
+	return newItem(m, typeRegular, name);
+}
+
+uiMenuItem *uiMenuAppendCheckItem(uiMenu *m, const char *name)
+{
+	return newItem(m, typeCheckbox, name);
+}
+
+uiMenuItem *uiMenuAppendQuitItem(uiMenu *m)
+{
+	if (hasQuit)
+		userbug("You can not have multiple Quit menu items in a program.");
+	hasQuit = TRUE;
+	newItem(m, typeSeparator, NULL);
+	return newItem(m, typeQuit, NULL);
+}
+
+uiMenuItem *uiMenuAppendPreferencesItem(uiMenu *m)
+{
+	if (hasPreferences)
+		userbug("You can not have multiple Preferences menu items in a program.");
+	hasPreferences = TRUE;
+	newItem(m, typeSeparator, NULL);
+	return newItem(m, typePreferences, NULL);
+}
+
+uiMenuItem *uiMenuAppendAboutItem(uiMenu *m)
+{
+	if (hasAbout)
+		// TODO place these userbug strings in a header
+		userbug("You can not have multiple About menu items in a program.");
+	hasAbout = TRUE;
+	newItem(m, typeSeparator, NULL);
+	return newItem(m, typeAbout, NULL);
+}
+
+void uiMenuAppendSeparator(uiMenu *m)
+{
+	newItem(m, typeSeparator, NULL);
+}
+
+uiMenu *uiNewMenu(const char *name)
+{
+	uiMenu *m;
+
+	if (menusFinalized)
+		userbug("You can not create a new menu after menus have been finalized.");
+	if (len >= cap) {
+		cap += grow;
+		menus = (uiMenu **) uiRealloc(menus, cap * sizeof (uiMenu *), "uiMenu *[]");
+	}
+
+	m = uiNew(uiMenu);
+
+	menus[len] = m;
+	len++;
+
+	m->name = toUTF16(name);
+
+	return m;
+}
+
+static void appendMenuItem(HMENU menu, uiMenuItem *item)
+{
+	UINT uFlags;
+
+	uFlags = MF_SEPARATOR;
+	if (item->type != typeSeparator) {
+		uFlags = MF_STRING;
+		if (item->disabled)
+			uFlags |= MF_DISABLED | MF_GRAYED;
+		if (item->checked)
+			uFlags |= MF_CHECKED;
+	}
+	if (AppendMenuW(menu, uFlags, item->id, item->name) == 0)
+		logLastError(L"error appending menu item");
+
+	if (item->len >= item->cap) {
+		item->cap += grow;
+		item->hmenus = (HMENU *) uiRealloc(item->hmenus, item->cap * sizeof (HMENU), "HMENU[]");
+	}
+	item->hmenus[item->len] = menu;
+	item->len++;
+}
+
+static HMENU makeMenu(uiMenu *m)
+{
+	HMENU menu;
+	size_t i;
+
+	menu = CreatePopupMenu();
+	if (menu == NULL)
+		logLastError(L"error creating menu");
+	for (i = 0; i < m->len; i++)
+		appendMenuItem(menu, m->items[i]);
+	return menu;
+}
+
+HMENU makeMenubar(void)
+{
+	HMENU menubar;
+	HMENU menu;
+	size_t i;
+
+	menusFinalized = TRUE;
+
+	menubar = CreateMenu();
+	if (menubar == NULL)
+		logLastError(L"error creating menubar");
+
+	for (i = 0; i < len; i++) {
+		menu = makeMenu(menus[i]);
+		if (AppendMenuW(menubar, MF_POPUP | MF_STRING, (UINT_PTR) menu, menus[i]->name) == 0)
+			logLastError(L"error appending menu to menubar");
+	}
+
+	return menubar;
+}
+
+void runMenuEvent(WORD id, uiWindow *w)
+{
+	uiMenu *m;
+	uiMenuItem *item;
+	size_t i, j;
+
+	// this isn't optimal, but it works, and it should be just fine for most cases
+	for (i = 0; i < len; i++) {
+		m = menus[i];
+		for (j = 0; j < m->len; j++) {
+			item = m->items[j];
+			if (item->id == id)
+				goto found;
+		}
+	}
+	// no match
+	implbug("unknown menu ID %hu in runMenuEvent()", id);
+
+found:
+	// first toggle checkboxes, if any
+	if (item->type == typeCheckbox)
+		uiMenuItemSetChecked(item, !uiMenuItemChecked(item));
+
+	// then run the event
+	(*(item->onClicked))(item, w, item->onClickedData);
+}
+
+static void freeMenu(uiMenu *m, HMENU submenu)
+{
+	size_t i;
+	uiMenuItem *item;
+	size_t j;
+
+	for (i = 0; i < m->len; i++) {
+		item = m->items[i];
+		for (j = 0; j < item->len; j++)
+			if (item->hmenus[j] == submenu)
+				break;
+		if (j >= item->len)
+			implbug("submenu handle %p not found in freeMenu()", submenu);
+		for (; j < item->len - 1; j++)
+			item->hmenus[j] = item->hmenus[j + 1];
+		item->hmenus[j] = NULL;
+		item->len--;
+	}
+}
+
+void freeMenubar(HMENU menubar)
+{
+	size_t i;
+	MENUITEMINFOW mi;
+
+	for (i = 0; i < len; i++) {
+		ZeroMemory(&mi, sizeof (MENUITEMINFOW));
+		mi.cbSize = sizeof (MENUITEMINFOW);
+		mi.fMask = MIIM_SUBMENU;
+		if (GetMenuItemInfoW(menubar, i, TRUE, &mi) == 0)
+			logLastError(L"error getting menu to delete item references from");
+		freeMenu(menus[i], mi.hSubMenu);
+	}
+	// no need to worry about destroying any menus; destruction of the window they're in will do it for us
+}
+
+void uninitMenus(void)
+{
+	uiMenu *m;
+	uiMenuItem *item;
+	size_t i, j;
+
+	for (i = 0; i < len; i++) {
+		m = menus[i];
+		uiFree(m->name);
+		for (j = 0; j < m->len; j++) {
+			item = m->items[j];
+			if (item->len != 0)
+				// LONGTERM userbug()?
+				implbug("menu item %p (%ws) still has uiWindows attached; did you forget to destroy some windows?", item, item->name);
+			if (item->name != NULL)
+				uiFree(item->name);
+			if (item->hmenus != NULL)
+				uiFree(item->hmenus);
+			uiFree(item);
+		}
+		if (m->items != NULL)
+			uiFree(m->items);
+		uiFree(m);
+	}
+	if (menus != NULL)
+		uiFree(menus);
+}
diff --git a/src/libui_sdl/libui/windows/multilineentry.cpp b/src/libui_sdl/libui/windows/multilineentry.cpp
new file mode 100644
index 0000000..a32960c
--- /dev/null
+++ b/src/libui_sdl/libui/windows/multilineentry.cpp
@@ -0,0 +1,152 @@
+// 8 april 2015
+#include "uipriv_windows.hpp"
+
+// TODO there's alpha darkening of text going on in read-only ones; something is up in our parent logic
+
+struct uiMultilineEntry {
+	uiWindowsControl c;
+	HWND hwnd;
+	void (*onChanged)(uiMultilineEntry *, void *);
+	void *onChangedData;
+	BOOL inhibitChanged;
+};
+
+static BOOL onWM_COMMAND(uiControl *c, HWND hwnd, WORD code, LRESULT *lResult)
+{
+	uiMultilineEntry *e = uiMultilineEntry(c);
+
+	if (code != EN_CHANGE)
+		return FALSE;
+	if (e->inhibitChanged)
+		return FALSE;
+	(*(e->onChanged))(e, e->onChangedData);
+	*lResult = 0;
+	return TRUE;
+}
+
+static void uiMultilineEntryDestroy(uiControl *c)
+{
+	uiMultilineEntry *e = uiMultilineEntry(c);
+
+	uiWindowsUnregisterWM_COMMANDHandler(e->hwnd);
+	uiWindowsEnsureDestroyWindow(e->hwnd);
+	uiFreeControl(uiControl(e));
+}
+
+uiWindowsControlAllDefaultsExceptDestroy(uiMultilineEntry)
+
+// from http://msdn.microsoft.com/en-us/library/windows/desktop/dn742486.aspx#sizingandspacing
+#define entryWidth 107 /* this is actually the shorter progress bar width, but Microsoft only indicates as wide as necessary */
+// LONGTERM change this for multiline text boxes (longterm because how?)
+#define entryHeight 14
+
+static void uiMultilineEntryMinimumSize(uiWindowsControl *c, int *width, int *height)
+{
+	uiMultilineEntry *e = uiMultilineEntry(c);
+	uiWindowsSizing sizing;
+	int x, y;
+
+	x = entryWidth;
+	y = entryHeight;
+	uiWindowsGetSizing(e->hwnd, &sizing);
+	uiWindowsSizingDlgUnitsToPixels(&sizing, &x, &y);
+	*width = x;
+	*height = y;
+}
+
+static void defaultOnChanged(uiMultilineEntry *e, void *data)
+{
+	// do nothing
+}
+
+char *uiMultilineEntryText(uiMultilineEntry *e)
+{
+	char *out;
+
+	out = uiWindowsWindowText(e->hwnd);
+	CRLFtoLF(out);
+	return out;
+}
+
+void uiMultilineEntrySetText(uiMultilineEntry *e, const char *text)
+{
+	char *crlf;
+
+	// doing this raises an EN_CHANGED
+	e->inhibitChanged = TRUE;
+	crlf = LFtoCRLF(text);
+	uiWindowsSetWindowText(e->hwnd, text);
+	uiFree(crlf);
+	e->inhibitChanged = FALSE;
+	// don't queue the control for resize; entry sizes are independent of their contents
+}
+
+void uiMultilineEntryAppend(uiMultilineEntry *e, const char *text)
+{
+	LRESULT n;
+	char *crlf;
+	WCHAR *wtext;
+
+	// doing this raises an EN_CHANGED
+	e->inhibitChanged = TRUE;
+	// TODO preserve selection? caret? what if caret used to be at end?
+	// TODO scroll to bottom?
+	n = SendMessageW(e->hwnd, WM_GETTEXTLENGTH, 0, 0);
+	SendMessageW(e->hwnd, EM_SETSEL, n, n);
+	crlf = LFtoCRLF(text);
+	wtext = toUTF16(crlf);
+	uiFree(crlf);
+	SendMessageW(e->hwnd, EM_REPLACESEL, FALSE, (LPARAM) wtext);
+	uiFree(wtext);
+	e->inhibitChanged = FALSE;
+}
+
+void uiMultilineEntryOnChanged(uiMultilineEntry *e, void (*f)(uiMultilineEntry *, void *), void *data)
+{
+	e->onChanged = f;
+	e->onChangedData = data;
+}
+
+int uiMultilineEntryReadOnly(uiMultilineEntry *e)
+{
+	return (getStyle(e->hwnd) & ES_READONLY) != 0;
+}
+
+void uiMultilineEntrySetReadOnly(uiMultilineEntry *e, int readonly)
+{
+	WPARAM ro;
+
+	ro = (WPARAM) FALSE;
+	if (readonly)
+		ro = (WPARAM) TRUE;
+	if (SendMessage(e->hwnd, EM_SETREADONLY, ro, 0) == 0)
+		logLastError(L"error making uiMultilineEntry read-only");
+}
+
+static uiMultilineEntry *finishMultilineEntry(DWORD style)
+{
+	uiMultilineEntry *e;
+
+	uiWindowsNewControl(uiMultilineEntry, e);
+
+	e->hwnd = uiWindowsEnsureCreateControlHWND(WS_EX_CLIENTEDGE,
+		L"edit", L"",
+		ES_AUTOVSCROLL | ES_LEFT | ES_MULTILINE | ES_NOHIDESEL | ES_WANTRETURN | WS_TABSTOP | WS_VSCROLL | style,
+		hInstance, NULL,
+		TRUE);
+
+	uiWindowsRegisterWM_COMMANDHandler(e->hwnd, onWM_COMMAND, uiControl(e));
+	uiMultilineEntryOnChanged(e, defaultOnChanged, NULL);
+
+	return e;
+}
+
+uiMultilineEntry *uiNewMultilineEntry(void)
+{
+	return finishMultilineEntry(0);
+}
+
+uiMultilineEntry *uiNewNonWrappingMultilineEntry(void)
+{
+	return finishMultilineEntry(WS_HSCROLL | ES_AUTOHSCROLL);
+}
diff --git a/src/libui_sdl/libui/windows/notes b/src/libui_sdl/libui/windows/notes
new file mode 100644
index 0000000..f554dd2
--- /dev/null
+++ b/src/libui_sdl/libui/windows/notes
@@ -0,0 +1,3 @@
+DIALOGS
+do not accelerate OK and Cancel buttons in dialogs
+	http://blogs.msdn.com/b/oldnewthing/archive/2008/05/08/8467905.aspx
diff --git a/src/libui_sdl/libui/windows/parent.cpp b/src/libui_sdl/libui/windows/parent.cpp
new file mode 100644
index 0000000..bde6fb9
--- /dev/null
+++ b/src/libui_sdl/libui/windows/parent.cpp
@@ -0,0 +1,144 @@
+// 26 april 2015
+#include "uipriv_windows.hpp"
+
+// This contains code used by all uiControls that contain other controls.
+// It also contains the code to draw the background of a container.c container, as that is a variant of the WM_CTLCOLORxxx handler code.
+
+static HBRUSH parentBrush = NULL;
+
+static HWND parentWithBackground(HWND hwnd)
+{
+	HWND parent;
+	int cls;
+
+	parent = hwnd;
+	for (;;) {
+		parent = parentOf(parent);
+		// skip groupboxes; they're (supposed to be) transparent
+		// skip uiContainers; they don't draw anything
+		cls = windowClassOf(parent, L"button", containerClass, NULL);
+		if (cls != 0 && cls != 1)
+			break;
+	}
+	return parent;
+}
+
+struct parentDraw {
+	HDC cdc;
+	HBITMAP bitmap;
+	HBITMAP prevbitmap;
+};
+
+static HRESULT parentDraw(HDC dc, HWND parent, struct parentDraw *pd)
+{
+	RECT r;
+
+	uiWindowsEnsureGetClientRect(parent, &r);
+	pd->cdc = CreateCompatibleDC(dc);
+	if (pd->cdc == NULL)
+		return logLastError(L"error creating compatible DC");
+	pd->bitmap = CreateCompatibleBitmap(dc, r.right - r.left, r.bottom - r.top);
+	if (pd->bitmap == NULL)
+		return logLastError(L"error creating compatible bitmap");
+	pd->prevbitmap = (HBITMAP) SelectObject(pd->cdc, pd->bitmap);
+	if (pd->prevbitmap == NULL)
+		return logLastError(L"error selecting bitmap into compatible DC");
+	SendMessageW(parent, WM_PRINTCLIENT, (WPARAM) (pd->cdc), PRF_CLIENT);
+	return S_OK;
+}
+
+static void endParentDraw(struct parentDraw *pd)
+{
+	// continue in case of any error
+	if (pd->prevbitmap != NULL)
+		if (((HBITMAP) SelectObject(pd->cdc, pd->prevbitmap)) != pd->bitmap)
+			logLastError(L"error selecting previous bitmap back into compatible DC");
+	if (pd->bitmap != NULL)
+		if (DeleteObject(pd->bitmap) == 0)
+			logLastError(L"error deleting compatible bitmap");
+	if (pd->cdc != NULL)
+		if (DeleteDC(pd->cdc) == 0)
+			logLastError(L"error deleting compatible DC");
+}
+
+// see http://www.codeproject.com/Articles/5978/Correctly-drawn-themed-dialogs-in-WinXP
+static HBRUSH getControlBackgroundBrush(HWND hwnd, HDC dc)
+{
+	HWND parent;
+	RECT hwndScreenRect;
+	struct parentDraw pd;
+	HBRUSH brush;
+	HRESULT hr;
+
+	parent = parentWithBackground(hwnd);
+
+	hr = parentDraw(dc, parent, &pd);
+	if (hr != S_OK)
+		return NULL;
+	brush = CreatePatternBrush(pd.bitmap);
+	if (brush == NULL) {
+		logLastError(L"error creating pattern brush");
+		endParentDraw(&pd);
+		return NULL;
+	}
+	endParentDraw(&pd);
+
+	// now figure out where the control is relative to the parent so we can align the brush properly
+	// if anything fails, give up and return the brush as-is
+	uiWindowsEnsureGetWindowRect(hwnd, &hwndScreenRect);
+	// this will be in screen coordinates; convert to parent coordinates
+	mapWindowRect(NULL, parent, &hwndScreenRect);
+	if (SetBrushOrgEx(dc, -hwndScreenRect.left, -hwndScreenRect.top, NULL) == 0)
+		logLastError(L"error setting brush origin");
+
+	return brush;
+}
+
+void paintContainerBackground(HWND hwnd, HDC dc, RECT *paintRect)
+{
+	HWND parent;
+	RECT paintRectParent;
+	struct parentDraw pd;
+	HRESULT hr;
+
+	parent = parentWithBackground(hwnd);
+	hr = parentDraw(dc, parent, &pd);
+	if (hr != S_OK)		// we couldn't get it; draw nothing
+		return;
+
+	paintRectParent = *paintRect;
+	mapWindowRect(hwnd, parent, &paintRectParent);
+	if (BitBlt(dc, paintRect->left, paintRect->top, paintRect->right - paintRect->left, paintRect->bottom - paintRect->top,
+		pd.cdc, paintRectParent.left, paintRectParent.top,
+		SRCCOPY) == 0)
+		logLastError(L"error drawing parent background over uiContainer");
+
+	endParentDraw(&pd);
+}
+
+// TODO make this public if we want custom containers
+// why have this to begin with? http://blogs.msdn.com/b/oldnewthing/archive/2010/03/16/9979112.aspx
+BOOL handleParentMessages(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *lResult)
+{
+	switch (uMsg) {
+	case WM_COMMAND:
+		return runWM_COMMAND(wParam, lParam, lResult);
+	case WM_NOTIFY:
+		return runWM_NOTIFY(wParam, lParam, lResult);
+	case WM_HSCROLL:
+		return runWM_HSCROLL(wParam, lParam, lResult);
+	case WM_CTLCOLORSTATIC:
+	case WM_CTLCOLORBTN:
+		if (parentBrush != NULL)
+			if (DeleteObject(parentBrush) == 0)
+				logLastError(L"error deleting old background brush()");		// but continue anyway; we will leak a brush but whatever
+		if (SetBkMode((HDC) wParam, TRANSPARENT) == 0)
+			logLastError(L"error setting transparent background mode to controls");		// but continue anyway; text will be wrong
+		parentBrush = getControlBackgroundBrush((HWND) lParam, (HDC) wParam);
+		if (parentBrush == NULL)		// failed; just do default behavior
+			return FALSE;
+		*lResult = (LRESULT) parentBrush;
+		return TRUE;
+	}
+	return FALSE;
+}
diff --git a/src/libui_sdl/libui/windows/progressbar.cpp b/src/libui_sdl/libui/windows/progressbar.cpp
new file mode 100644
index 0000000..3750eb6
--- /dev/null
+++ b/src/libui_sdl/libui/windows/progressbar.cpp
@@ -0,0 +1,83 @@
+// 19 may 2015
+#include "uipriv_windows.hpp"
+
+struct uiProgressBar {
+	uiWindowsControl c;
+	HWND hwnd;
+};
+
+uiWindowsControlAllDefaults(uiProgressBar)
+
+// via http://msdn.microsoft.com/en-us/library/windows/desktop/dn742486.aspx#sizingandspacing
+#define pbarWidth 237
+#define pbarHeight 8
+
+static void uiProgressBarMinimumSize(uiWindowsControl *c, int *width, int *height)
+{
+	uiProgressBar *p = uiProgressBar(c);
+	uiWindowsSizing sizing;
+	int x, y;
+
+	x = pbarWidth;
+	y = pbarHeight;
+	uiWindowsGetSizing(p->hwnd, &sizing);
+	uiWindowsSizingDlgUnitsToPixels(&sizing, &x, &y);
+	*width = x;
+	*height = y;
+}
+
+#define indeterminate(p) ((getStyle(p->hwnd) & PBS_MARQUEE) != 0)
+
+int uiProgressBarValue(uiProgressBar *p)
+{
+	if (indeterminate(p))
+		return -1;
+	return SendMessage(p->hwnd, PBM_GETPOS, 0, 0);
+}
+
+// unfortunately, as of Vista progress bars have a forced animation on increase
+// we have to set the progress bar to value + 1 and decrease it back to value if we want an "instant" change
+// see http://stackoverflow.com/questions/2217688/windows-7-aero-theme-progress-bar-bug
+// it's not ideal/perfect, but it will have to do
+void uiProgressBarSetValue(uiProgressBar *p, int value)
+{
+	if (value == -1) {
+		if (!indeterminate(p)) {
+			setStyle(p->hwnd, getStyle(p->hwnd) | PBS_MARQUEE);
+			SendMessageW(p->hwnd, PBM_SETMARQUEE, (WPARAM) TRUE, 0);
+		}
+		return;
+	}
+	if (indeterminate(p)) {
+		SendMessageW(p->hwnd, PBM_SETMARQUEE, (WPARAM) FALSE, 0);
+		setStyle(p->hwnd, getStyle(p->hwnd) & ~PBS_MARQUEE);
+	}
+
+	if (value < 0 || value > 100)
+		userbug("Value %d is out of range for uiProgressBars.", value);
+
+	if (value == 100) {			// because we can't 101
+		SendMessageW(p->hwnd, PBM_SETRANGE32, 0, 101);
+		SendMessageW(p->hwnd, PBM_SETPOS, 101, 0);
+		SendMessageW(p->hwnd, PBM_SETPOS, 100, 0);
+		SendMessageW(p->hwnd, PBM_SETRANGE32, 0, 100);
+		return;
+	}
+	SendMessageW(p->hwnd, PBM_SETPOS, (WPARAM) (value + 1), 0);
+	SendMessageW(p->hwnd, PBM_SETPOS, (WPARAM) value, 0);
+}
+
+uiProgressBar *uiNewProgressBar(void)
+{
+	uiProgressBar *p;
+
+	uiWindowsNewControl(uiProgressBar, p);
+
+	p->hwnd = uiWindowsEnsureCreateControlHWND(0,
+		PROGRESS_CLASSW, L"",
+		PBS_SMOOTH,
+		hInstance, NULL,
+		FALSE);
+
+	return p;
+}
diff --git a/src/libui_sdl/libui/windows/radiobuttons.cpp b/src/libui_sdl/libui/windows/radiobuttons.cpp
new file mode 100644
index 0000000..29cd2e6
--- /dev/null
+++ b/src/libui_sdl/libui/windows/radiobuttons.cpp
@@ -0,0 +1,196 @@
+// 20 may 2015
+#include "uipriv_windows.hpp"
+
+// desired behavior:
+// - tab moves between the radio buttons and the adjacent controls
+// - arrow keys navigate between radio buttons
+// - arrow keys do not leave the radio buttons (this is done in control.c)
+// - arrow keys wrap around bare groups (if the previous control has WS_GROUP but the first radio button doesn't, then it doesn't; since our radio buttons are all in their own child window we can't do that)
+// - clicking on a radio button draws a focus rect (TODO)
+
+struct uiRadioButtons {
+	uiWindowsControl c;
+	HWND hwnd;					// of the container
+	std::vector<HWND> *hwnds;		// of the buttons
+	void (*onSelected)(uiRadioButtons *, void *);
+	void *onSelectedData;
+};
+
+static BOOL onWM_COMMAND(uiControl *c, HWND clicked, WORD code, LRESULT *lResult)
+{
+	uiRadioButtons *r = uiRadioButtons(c);
+	WPARAM check;
+
+	if (code != BN_CLICKED)
+		return FALSE;
+	for (const HWND &hwnd : *(r->hwnds)) {
+		check = BST_UNCHECKED;
+		if (clicked == hwnd)
+			check = BST_CHECKED;
+		SendMessage(hwnd, BM_SETCHECK, check, 0);
+	}
+	(*(r->onSelected))(r, r->onSelectedData);
+	*lResult = 0;
+	return TRUE;
+}
+
+static void defaultOnSelected(uiRadioButtons *r, void *data)
+{
+	// do nothing
+}
+
+static void uiRadioButtonsDestroy(uiControl *c)
+{
+	uiRadioButtons *r = uiRadioButtons(c);
+
+	for (const HWND &hwnd : *(r->hwnds)) {
+		uiWindowsUnregisterWM_COMMANDHandler(hwnd);
+		uiWindowsEnsureDestroyWindow(hwnd);
+	}
+	delete r->hwnds;
+	uiWindowsEnsureDestroyWindow(r->hwnd);
+	uiFreeControl(uiControl(r));
+}
+
+// TODO SyncEnableState
+uiWindowsControlAllDefaultsExceptDestroy(uiRadioButtons)
+
+// from http://msdn.microsoft.com/en-us/library/windows/desktop/dn742486.aspx#sizingandspacing
+#define radiobuttonHeight 10
+// from http://msdn.microsoft.com/en-us/library/windows/desktop/bb226818%28v=vs.85%29.aspx
+#define radiobuttonXFromLeftOfBoxToLeftOfLabel 12
+
+static void uiRadioButtonsMinimumSize(uiWindowsControl *c, int *width, int *height)
+{
+	uiRadioButtons *r = uiRadioButtons(c);
+	int wid, maxwid;
+	uiWindowsSizing sizing;
+	int x, y;
+
+	if (r->hwnds->size() == 0) {
+		*width = 0;
+		*height = 0;
+		return;
+	}
+	maxwid = 0;
+	for (const HWND &hwnd : *(r->hwnds)) {
+		wid = uiWindowsWindowTextWidth(hwnd);
+		if (maxwid < wid)
+			maxwid = wid;
+	}
+
+	x = radiobuttonXFromLeftOfBoxToLeftOfLabel;
+	y = radiobuttonHeight;
+	uiWindowsGetSizing((*(r->hwnds))[0], &sizing);
+	uiWindowsSizingDlgUnitsToPixels(&sizing, &x, &y);
+
+	*width = x + maxwid;
+	*height = y * r->hwnds->size();
+}
+
+static void radiobuttonsRelayout(uiRadioButtons *r)
+{
+	RECT client;
+	int x, y, width, height;
+	int height1;
+	uiWindowsSizing sizing;
+
+	if (r->hwnds->size() == 0)
+		return;
+	uiWindowsEnsureGetClientRect(r->hwnd, &client);
+	x = client.left;
+	y = client.top;
+	width = client.right - client.left;
+	height1 = radiobuttonHeight;
+	uiWindowsGetSizing((*(r->hwnds))[0], &sizing);
+	uiWindowsSizingDlgUnitsToPixels(&sizing, NULL, &height1);
+	height = height1;
+	for (const HWND &hwnd : *(r->hwnds)) {
+		uiWindowsEnsureMoveWindowDuringResize(hwnd, x, y, width, height);
+		y += height;
+	}
+}
+
+static void radiobuttonsArrangeChildren(uiRadioButtons *r)
+{
+	LONG_PTR controlID;
+	HWND insertAfter;
+
+	controlID = 100;
+	insertAfter = NULL;
+	for (const HWND &hwnd : *(r->hwnds))
+		uiWindowsEnsureAssignControlIDZOrder(hwnd, &controlID, &insertAfter);
+}
+
+void uiRadioButtonsAppend(uiRadioButtons *r, const char *text)
+{
+	HWND hwnd;
+	WCHAR *wtext;
+	DWORD groupTabStop;
+
+	// the first radio button gets both WS_GROUP and WS_TABSTOP
+	// successive radio buttons get *neither*
+	groupTabStop = 0;
+	if (r->hwnds->size() == 0)
+		groupTabStop = WS_GROUP | WS_TABSTOP;
+
+	wtext = toUTF16(text);
+	hwnd = uiWindowsEnsureCreateControlHWND(0,
+		L"button", wtext,
+		BS_RADIOBUTTON | groupTabStop,
+		hInstance, NULL,
+		TRUE);
+	uiFree(wtext);
+	uiWindowsEnsureSetParentHWND(hwnd, r->hwnd);
+	uiWindowsRegisterWM_COMMANDHandler(hwnd, onWM_COMMAND, uiControl(r));
+	r->hwnds->push_back(hwnd);
+	radiobuttonsArrangeChildren(r);
+	uiWindowsControlMinimumSizeChanged(uiWindowsControl(r));
+}
+
+int uiRadioButtonsSelected(uiRadioButtons *r)
+{
+	size_t i;
+
+	for (i = 0; i < r->hwnds->size(); i++)
+		if (SendMessage((*(r->hwnds))[i], BM_GETCHECK, 0, 0) == BST_CHECKED)
+			return i;
+	return -1;
+}
+
+void uiRadioButtonsSetSelected(uiRadioButtons *r, int n)
+{
+	int m;
+
+	m = uiRadioButtonsSelected(r);
+	if (m != -1)
+		SendMessage((*(r->hwnds))[m], BM_SETCHECK, BST_UNCHECKED, 0);
+	if (n != -1)
+		SendMessage((*(r->hwnds))[n], BM_SETCHECK, BST_CHECKED, 0);
+}
+
+void uiRadioButtonsOnSelected(uiRadioButtons *r, void (*f)(uiRadioButtons *, void *), void *data)
+{
+	r->onSelected = f;
+	r->onSelectedData = data;
+}
+
+static void onResize(uiWindowsControl *c)
+{
+	radiobuttonsRelayout(uiRadioButtons(c));
+}
+
+uiRadioButtons *uiNewRadioButtons(void)
+{
+	uiRadioButtons *r;
+
+	uiWindowsNewControl(uiRadioButtons, r);
+
+	r->hwnd = uiWindowsMakeContainer(uiWindowsControl(r), onResize);
+
+	r->hwnds = new std::vector<HWND>;
+
+	uiRadioButtonsOnSelected(r, defaultOnSelected, NULL);
+
+	return r;
+}
diff --git a/src/libui_sdl/libui/windows/resources.hpp b/src/libui_sdl/libui/windows/resources.hpp
new file mode 100644
index 0000000..4ae5472
--- /dev/null
+++ b/src/libui_sdl/libui/windows/resources.hpp
@@ -0,0 +1,37 @@
+// 30 may 2015
+
+#define rcTabPageDialog 29000
+#define rcFontDialog 29001
+#define rcColorDialog 29002
+
+// TODO normalize these
+
+#define rcFontFamilyCombobox 1000
+#define rcFontStyleCombobox 1001
+#define rcFontSizeCombobox 1002
+#define rcFontSamplePlacement 1003
+
+#define rcColorSVChooser 1100
+#define rcColorHSlider 1101
+#define rcPreview 1102
+#define rcOpacitySlider 1103
+#define rcH 1104
+#define rcS 1105
+#define rcV 1106
+#define rcRDouble 1107
+#define rcRInt 1108
+#define rcGDouble 1109
+#define rcGInt 1110
+#define rcBDouble 1111
+#define rcBInt 1112
+#define rcADouble 1113
+#define rcAInt 1114
+#define rcHex 1115
+#define rcHLabel 1116
+#define rcSLabel 1117
+#define rcVLabel 1118
+#define rcRLabel 1119
+#define rcGLabel 1120
+#define rcBLabel 1121
+#define rcALabel 1122
+#define rcHexLabel 1123
diff --git a/src/libui_sdl/libui/windows/resources.rc b/src/libui_sdl/libui/windows/resources.rc
new file mode 100644
index 0000000..989dfc9
--- /dev/null
+++ b/src/libui_sdl/libui/windows/resources.rc
@@ -0,0 +1,96 @@
+// 30 may 2015
+#include "winapi.hpp"
+#include "resources.hpp"
+
+// this is a UTF-8 file
+#pragma code_page(65001)
+
+// this is the Common Controls 6 manifest
+// we only define it in a shared build; static builds have to include the appropriate parts of the manifest in the output executable
+// LONGTERM set up the string values here
+#ifndef _UI_STATIC
+ISOLATIONAWARE_MANIFEST_RESOURCE_ID RT_MANIFEST "libui.manifest"
+#endif
+
+// this is the dialog template used by tab pages; see windows/tabpage.c for details
+rcTabPageDialog DIALOGEX 0, 0, 100, 100
+STYLE DS_CONTROL | WS_CHILD | WS_VISIBLE
+EXSTYLE WS_EX_CONTROLPARENT
+BEGIN
+	// nothing
+END
+
+// this is for our custom DirectWrite-based font dialog (see fontdialog.cpp)
+// this is based on the "New Font Dialog with Syslink" in Microsoft's font.dlg
+// LONGTERM look at localization
+// LONGTERM make it look tighter and nicer like the real one, including the actual heights of the font family and style comboboxes
+rcFontDialog DIALOGEX 13, 54, 243, 200
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU | DS_3DLOOK
+CAPTION "Font"
+FONT 9, "Segoe UI"
+BEGIN
+	LTEXT		"&Font:", -1, 7, 7, 98, 9
+	COMBOBOX	rcFontFamilyCombobox, 7, 16, 98, 76,
+		CBS_SIMPLE | CBS_AUTOHSCROLL | CBS_DISABLENOSCROLL |
+		CBS_SORT | WS_VSCROLL | WS_TABSTOP | CBS_HASSTRINGS
+
+	LTEXT		"Font st&yle:", -1, 114, 7, 74, 9
+	COMBOBOX	rcFontStyleCombobox, 114, 16, 74, 76,
+		CBS_SIMPLE | CBS_AUTOHSCROLL | CBS_DISABLENOSCROLL |
+		WS_VSCROLL | WS_TABSTOP | CBS_HASSTRINGS
+
+	LTEXT		"&Size:", -1, 198, 7, 36, 9
+	COMBOBOX	rcFontSizeCombobox, 198, 16, 36, 76,
+		CBS_SIMPLE | CBS_AUTOHSCROLL | CBS_DISABLENOSCROLL |
+		CBS_SORT | WS_VSCROLL | WS_TABSTOP | CBS_HASSTRINGS
+
+	GROUPBOX		"Sample", -1, 7, 97, 227, 70, WS_GROUP
+	CTEXT			"AaBbYyZz", rcFontSamplePlacement, 9, 106, 224, 60, SS_NOPREFIX | NOT WS_VISIBLE
+
+	DEFPUSHBUTTON	"OK", IDOK, 141, 181, 45, 14, WS_GROUP
+	PUSHBUTTON		"Cancel", IDCANCEL, 190, 181, 45, 14, WS_GROUP
+END
+
+rcColorDialog DIALOGEX 13, 54, 344, 209
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU | DS_3DLOOK
+CAPTION "Color"
+FONT 9, "Segoe UI"
+BEGIN
+	// this size should be big enough to get at least 256x256 on font sizes >= 8 pt
+	CTEXT		"AaBbYyZz", rcColorSVChooser, 7, 7, 195, 195, SS_NOPREFIX | SS_BLACKRECT
+
+	// width is the suggested slider height since this is vertical
+	CTEXT		"AaBbYyZz", rcColorHSlider, 206, 7, 15, 195, SS_NOPREFIX | SS_BLACKRECT
+
+	LTEXT		"Preview:", -1, 230, 7, 107, 9, SS_NOPREFIX
+	CTEXT		"AaBbYyZz", rcPreview, 230, 16, 107, 20, SS_NOPREFIX | SS_BLACKRECT
+
+	LTEXT		"Opacity:", -1, 230, 45, 107, 9, SS_NOPREFIX
+	CTEXT		"AaBbYyZz", rcOpacitySlider, 230, 54, 107, 15, SS_NOPREFIX | SS_BLACKRECT
+
+	LTEXT		"&H:", rcHLabel, 230, 81, 8, 8
+	EDITTEXT		rcH, 238, 78, 30, 14, ES_LEFT | ES_AUTOHSCROLL | WS_TABSTOP, WS_EX_CLIENTEDGE
+	LTEXT		"&S:", rcSLabel, 230, 95, 8, 8
+	EDITTEXT		rcS, 238, 92, 30, 14, ES_LEFT | ES_AUTOHSCROLL | WS_TABSTOP, WS_EX_CLIENTEDGE
+	LTEXT		"&V:", rcVLabel, 230, 109, 8, 8
+	EDITTEXT		rcV, 238, 106, 30, 14, ES_LEFT | ES_AUTOHSCROLL | WS_TABSTOP, WS_EX_CLIENTEDGE
+
+	LTEXT		"&R:", rcRLabel, 277, 81, 8, 8
+	EDITTEXT		rcRDouble, 285, 78, 30, 14, ES_LEFT | ES_AUTOHSCROLL | WS_TABSTOP, WS_EX_CLIENTEDGE
+	EDITTEXT		rcRInt, 315, 78, 20, 14, ES_LEFT | ES_AUTOHSCROLL | ES_NUMBER | WS_TABSTOP, WS_EX_CLIENTEDGE
+	LTEXT		"&G:", rcGLabel, 277, 95, 8, 8
+	EDITTEXT		rcGDouble, 285, 92, 30, 14, ES_LEFT | ES_AUTOHSCROLL | WS_TABSTOP, WS_EX_CLIENTEDGE
+	EDITTEXT		rcGInt, 315, 92, 20, 14, ES_LEFT | ES_AUTOHSCROLL | ES_NUMBER | WS_TABSTOP, WS_EX_CLIENTEDGE
+	LTEXT		"&B:", rcBLabel, 277, 109, 8, 8
+	EDITTEXT		rcBDouble, 285, 106, 30, 14, ES_LEFT | ES_AUTOHSCROLL | WS_TABSTOP, WS_EX_CLIENTEDGE
+	EDITTEXT		rcBInt, 315, 106, 20, 14, ES_LEFT | ES_AUTOHSCROLL | ES_NUMBER | WS_TABSTOP, WS_EX_CLIENTEDGE
+	LTEXT		"&A:", rcALabel, 277, 123, 8, 8
+	EDITTEXT		rcADouble, 285, 120, 30, 14, ES_LEFT | ES_AUTOHSCROLL | WS_TABSTOP, WS_EX_CLIENTEDGE
+	EDITTEXT		rcAInt, 315, 120, 20, 14, ES_LEFT | ES_AUTOHSCROLL | ES_NUMBER | WS_TABSTOP, WS_EX_CLIENTEDGE
+
+	LTEXT		"He&x:", rcHexLabel, 269, 146, 16, 8
+	EDITTEXT		rcHex, 285, 143, 50, 14, ES_LEFT | ES_AUTOHSCROLL | WS_TABSTOP, WS_EX_CLIENTEDGE
+
+	DEFPUSHBUTTON	"OK", IDOK, 243, 188, 45, 14, WS_GROUP
+	PUSHBUTTON		"Cancel", IDCANCEL, 292, 188, 45, 14, WS_GROUP
+END
diff --git a/src/libui_sdl/libui/windows/separator.cpp b/src/libui_sdl/libui/windows/separator.cpp
new file mode 100644
index 0000000..e123e27
--- /dev/null
+++ b/src/libui_sdl/libui/windows/separator.cpp
@@ -0,0 +1,69 @@
+// 20 may 2015
+#include "uipriv_windows.hpp"
+
+// references:
+// - http://stackoverflow.com/questions/2892703/how-do-i-draw-separators
+// - https://msdn.microsoft.com/en-us/library/windows/desktop/dn742405%28v=vs.85%29.aspx
+
+struct uiSeparator {
+	uiWindowsControl c;
+	HWND hwnd;
+	BOOL vertical;
+};
+
+uiWindowsControlAllDefaults(uiSeparator)
+
+// via https://msdn.microsoft.com/en-us/library/windows/desktop/bb226818%28v=vs.85%29.aspx
+#define separatorHeight 1
+
+// TODO
+#define separatorWidth 1
+
+static void uiSeparatorMinimumSize(uiWindowsControl *c, int *width, int *height)
+{
+	uiSeparator *s = uiSeparator(c);
+	uiWindowsSizing sizing;
+	int x, y;
+
+	*width = 1;		// TODO
+	*height = 1;
+	x = separatorWidth;
+	y = separatorHeight;
+	uiWindowsGetSizing(s->hwnd, &sizing);
+	uiWindowsSizingDlgUnitsToPixels(&sizing, &x, &y);
+	if (s->vertical)
+		*width = x;
+	else
+		*height = y;
+}
+
+uiSeparator *uiNewHorizontalSeparator(void)
+{
+	uiSeparator *s;
+
+	uiWindowsNewControl(uiSeparator, s);
+
+	s->hwnd = uiWindowsEnsureCreateControlHWND(0,
+		L"static", L"",
+		SS_ETCHEDHORZ,
+		hInstance, NULL,
+		TRUE);
+
+	return s;
+}
+
+uiSeparator *uiNewVerticalSeparator(void)
+{
+	uiSeparator *s;
+
+	uiWindowsNewControl(uiSeparator, s);
+
+	s->hwnd = uiWindowsEnsureCreateControlHWND(0,
+		L"static", L"",
+		SS_ETCHEDHORZ,
+		hInstance, NULL,
+		TRUE);
+	s->vertical = TRUE;
+
+	return s;
+}
diff --git a/src/libui_sdl/libui/windows/sizing.cpp b/src/libui_sdl/libui/windows/sizing.cpp
new file mode 100644
index 0000000..a6d25d6
--- /dev/null
+++ b/src/libui_sdl/libui/windows/sizing.cpp
@@ -0,0 +1,62 @@
+// 14 may 2015
+#include "uipriv_windows.hpp"
+
+// TODO rework the error handling
+void getSizing(HWND hwnd, uiWindowsSizing *sizing, HFONT font)
+{
+	HDC dc;
+	HFONT prevfont;
+	TEXTMETRICW tm;
+	SIZE size;
+
+	dc = GetDC(hwnd);
+	if (dc == NULL)
+		logLastError(L"error getting DC");
+	prevfont = (HFONT) SelectObject(dc, font);
+	if (prevfont == NULL)
+		logLastError(L"error loading control font into device context");
+
+	ZeroMemory(&tm, sizeof (TEXTMETRICW));
+	if (GetTextMetricsW(dc, &tm) == 0)
+		logLastError(L"error getting text metrics");
+	if (GetTextExtentPoint32W(dc, L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 52, &size) == 0)
+		logLastError(L"error getting text extent point");
+
+	sizing->BaseX = (int) ((size.cx / 26 + 1) / 2);
+	sizing->BaseY = (int) tm.tmHeight;
+	sizing->InternalLeading = tm.tmInternalLeading;
+
+	if (SelectObject(dc, prevfont) != font)
+		logLastError(L"error restoring previous font into device context");
+	if (ReleaseDC(hwnd, dc) == 0)
+		logLastError(L"error releasing DC");
+}
+
+void uiWindowsGetSizing(HWND hwnd, uiWindowsSizing *sizing)
+{
+	return getSizing(hwnd, sizing, hMessageFont);
+}
+
+#define dlgUnitsToX(dlg, baseX) MulDiv((dlg), (baseX), 4)
+#define dlgUnitsToY(dlg, baseY) MulDiv((dlg), (baseY), 8)
+
+void uiWindowsSizingDlgUnitsToPixels(uiWindowsSizing *sizing, int *x, int *y)
+{
+	if (x != NULL)
+		*x = dlgUnitsToX(*x, sizing->BaseX);
+	if (y != NULL)
+		*y = dlgUnitsToY(*y, sizing->BaseY);
+}
+
+// from https://msdn.microsoft.com/en-us/library/windows/desktop/dn742486.aspx#sizingandspacing and https://msdn.microsoft.com/en-us/library/windows/desktop/bb226818%28v=vs.85%29.aspx
+// this X value is really only for buttons but I don't see a better one :/
+#define winXPadding 4
+#define winYPadding 4
+
+void uiWindowsSizingStandardPadding(uiWindowsSizing *sizing, int *x, int *y)
+{
+	if (x != NULL)
+		*x = dlgUnitsToX(winXPadding, sizing->BaseX);
+	if (y != NULL)
+		*y = dlgUnitsToY(winYPadding, sizing->BaseY);
+}
diff --git a/src/libui_sdl/libui/windows/slider.cpp b/src/libui_sdl/libui/windows/slider.cpp
new file mode 100644
index 0000000..5c671dd
--- /dev/null
+++ b/src/libui_sdl/libui/windows/slider.cpp
@@ -0,0 +1,98 @@
+// 20 may 2015
+#include "uipriv_windows.hpp"
+
+struct uiSlider {
+	uiWindowsControl c;
+	HWND hwnd;
+	void (*onChanged)(uiSlider *, void *);
+	void *onChangedData;
+};
+
+static BOOL onWM_HSCROLL(uiControl *c, HWND hwnd, WORD code, LRESULT *lResult)
+{
+	uiSlider *s = uiSlider(c);
+
+	(*(s->onChanged))(s, s->onChangedData);
+	*lResult = 0;
+	return TRUE;
+}
+
+static void uiSliderDestroy(uiControl *c)
+{
+	uiSlider *s = uiSlider(c);
+
+	uiWindowsUnregisterWM_HSCROLLHandler(s->hwnd);
+	uiWindowsEnsureDestroyWindow(s->hwnd);
+	uiFreeControl(uiControl(s));
+}
+
+uiWindowsControlAllDefaultsExceptDestroy(uiSlider);
+
+// from http://msdn.microsoft.com/en-us/library/windows/desktop/dn742486.aspx#sizingandspacing
+#define sliderWidth 107 /* this is actually the shorter progress bar width, but Microsoft doesn't indicate a width */
+#define sliderHeight 15
+
+static void uiSliderMinimumSize(uiWindowsControl *c, int *width, int *height)
+{
+	uiSlider *s = uiSlider(c);
+	uiWindowsSizing sizing;
+	int x, y;
+
+	x = sliderWidth;
+	y = sliderHeight;
+	uiWindowsGetSizing(s->hwnd, &sizing);
+	uiWindowsSizingDlgUnitsToPixels(&sizing, &x, &y);
+	*width = x;
+	*height = y;
+}
+
+static void defaultOnChanged(uiSlider *s, void *data)
+{
+	// do nothing
+}
+
+int uiSliderValue(uiSlider *s)
+{
+	return SendMessageW(s->hwnd, TBM_GETPOS, 0, 0);
+}
+
+void uiSliderSetValue(uiSlider *s, int value)
+{
+	// don't use TBM_SETPOSNOTIFY; that triggers an event
+	SendMessageW(s->hwnd, TBM_SETPOS, (WPARAM) TRUE, (LPARAM) value);
+}
+
+void uiSliderOnChanged(uiSlider *s, void (*f)(uiSlider *, void *), void *data)
+{
+	s->onChanged = f;
+	s->onChangedData = data;
+}
+
+uiSlider *uiNewSlider(int min, int max)
+{
+	uiSlider *s;
+	int temp;
+
+	if (min >= max) {
+		temp = min;
+		min = max;
+		max = temp;
+	}
+
+	uiWindowsNewControl(uiSlider, s);
+
+	s->hwnd = uiWindowsEnsureCreateControlHWND(0,
+		TRACKBAR_CLASSW, L"",
+		TBS_HORZ | TBS_TOOLTIPS | TBS_TRANSPARENTBKGND | WS_TABSTOP,
+		hInstance, NULL,
+		TRUE);
+
+	uiWindowsRegisterWM_HSCROLLHandler(s->hwnd, onWM_HSCROLL, uiControl(s));
+	uiSliderOnChanged(s, defaultOnChanged, NULL);
+
+	SendMessageW(s->hwnd, TBM_SETRANGEMIN, (WPARAM) TRUE, (LPARAM) min);
+	SendMessageW(s->hwnd, TBM_SETRANGEMAX, (WPARAM) TRUE, (LPARAM) max);
+	SendMessageW(s->hwnd, TBM_SETPOS, (WPARAM) TRUE, (LPARAM) min);
+
+	return s;
+}
diff --git a/src/libui_sdl/libui/windows/spinbox.cpp b/src/libui_sdl/libui/windows/spinbox.cpp
new file mode 100644
index 0000000..2b6af66
--- /dev/null
+++ b/src/libui_sdl/libui/windows/spinbox.cpp
@@ -0,0 +1,215 @@
+// 8 april 2015
+#include "uipriv_windows.hpp"
+
+struct uiSpinbox {
+	uiWindowsControl c;
+	HWND hwnd;
+	HWND edit;
+	HWND updown;
+	void (*onChanged)(uiSpinbox *, void *);
+	void *onChangedData;
+	BOOL inhibitChanged;
+};
+
+// utility functions
+
+static int value(uiSpinbox *s)
+{
+	BOOL neededCap = FALSE;
+	LRESULT val;
+
+	// This verifies the value put in, capping it automatically.
+	// We don't need to worry about checking for an error; that flag should really be called "did we have to cap?".
+	// We DO need to set the value in case of a cap though.
+	val = SendMessageW(s->updown, UDM_GETPOS32, 0, (LPARAM) (&neededCap));
+	if (neededCap) {
+		s->inhibitChanged = TRUE;
+		SendMessageW(s->updown, UDM_SETPOS32, 0, (LPARAM) val);
+		s->inhibitChanged = FALSE;
+	}
+	return val;
+}
+
+// control implementation
+
+static BOOL onWM_COMMAND(uiControl *c, HWND hwnd, WORD code, LRESULT *lResult)
+{
+	uiSpinbox *s = (uiSpinbox *) c;
+	WCHAR *wtext;
+
+	if (code != EN_CHANGE)
+		return FALSE;
+	if (s->inhibitChanged)
+		return FALSE;
+	// We want to allow typing negative numbers; the natural way to do so is to start with a -.
+	// However, if we just have the code below, the up-down will catch the bare - and reject it.
+	// Let's fix that.
+	// This won't handle leading spaces, but spaces aren't allowed *anyway*.
+	wtext = windowText(s->edit);
+	if (wcscmp(wtext, L"-") == 0) {
+		uiFree(wtext);
+		return TRUE;
+	}
+	uiFree(wtext);
+	// value() does the work for us
+	value(s);
+	(*(s->onChanged))(s, s->onChangedData);
+	return TRUE;
+}
+
+static void uiSpinboxDestroy(uiControl *c)
+{
+	uiSpinbox *s = uiSpinbox(c);
+
+	uiWindowsUnregisterWM_COMMANDHandler(s->edit);
+	uiWindowsEnsureDestroyWindow(s->updown);
+	uiWindowsEnsureDestroyWindow(s->edit);
+	uiWindowsEnsureDestroyWindow(s->hwnd);
+	uiFreeControl(uiControl(s));
+}
+
+// TODO SyncEnableState
+uiWindowsControlAllDefaultsExceptDestroy(uiSpinbox)
+
+// from http://msdn.microsoft.com/en-us/library/windows/desktop/dn742486.aspx#sizingandspacing
+// TODO reduce this?
+#define entryWidth 107 /* this is actually the shorter progress bar width, but Microsoft only indicates as wide as necessary */
+#define entryHeight 14
+
+static void uiSpinboxMinimumSize(uiWindowsControl *c, int *width, int *height)
+{
+	uiSpinbox *s = uiSpinbox(c);
+	uiWindowsSizing sizing;
+	int x, y;
+
+	x = entryWidth;
+	y = entryHeight;
+	// note that we go by the edit here
+	uiWindowsGetSizing(s->edit, &sizing);
+	uiWindowsSizingDlgUnitsToPixels(&sizing, &x, &y);
+	*width = x;
+	*height = y;
+}
+
+static void spinboxArrangeChildren(uiSpinbox *s)
+{
+	LONG_PTR controlID;
+	HWND insertAfter;
+
+	controlID = 100;
+	insertAfter = NULL;
+	uiWindowsEnsureAssignControlIDZOrder(s->edit, &controlID, &insertAfter);
+	uiWindowsEnsureAssignControlIDZOrder(s->updown, &controlID, &insertAfter);
+}
+
+// an up-down control will only properly position itself the first time
+// stupidly, there are no messages to force a size calculation, nor can I seem to reset the buddy window to force a new position
+// alas, we have to make a new up/down control each time :(
+static void recreateUpDown(uiSpinbox *s)
+{
+	BOOL preserve = FALSE;
+	int current;
+	// Microsoft's commctrl.h says to use this type
+	INT min, max;
+
+	if (s->updown != NULL) {
+		preserve = TRUE;
+		current = value(s);
+		SendMessageW(s->updown, UDM_GETRANGE32, (WPARAM) (&min), (LPARAM) (&max));
+		uiWindowsEnsureDestroyWindow(s->updown);
+	}
+	s->inhibitChanged = TRUE;
+	s->updown = CreateWindowExW(0,
+		UPDOWN_CLASSW, L"",
+		// no WS_VISIBLE; we set visibility ourselves
+		// up-down control should not be a tab stop
+		WS_CHILD | UDS_ALIGNRIGHT | UDS_ARROWKEYS | UDS_HOTTRACK | UDS_NOTHOUSANDS | UDS_SETBUDDYINT,
+		// this is important; it's necessary for autosizing to work
+		0, 0, 0, 0,
+		s->hwnd, NULL, hInstance, NULL);
+	if (s->updown == NULL)
+		logLastError(L"error creating updown");
+	SendMessageW(s->updown, UDM_SETBUDDY, (WPARAM) (s->edit), 0);
+	if (preserve) {
+		SendMessageW(s->updown, UDM_SETRANGE32, (WPARAM) min, (LPARAM) max);
+		SendMessageW(s->updown, UDM_SETPOS32, 0, (LPARAM) current);
+	}
+	// preserve the Z-order
+	spinboxArrangeChildren(s);
+	// TODO properly show/enable
+	ShowWindow(s->updown, SW_SHOW);
+	s->inhibitChanged = FALSE;
+}
+
+static void spinboxRelayout(uiSpinbox *s)
+{
+	RECT r;
+
+	// make the edit fill the container first; the new updown will resize it
+	uiWindowsEnsureGetClientRect(s->hwnd, &r);
+	uiWindowsEnsureMoveWindowDuringResize(s->edit, r.left, r.top, r.right - r.left, r.bottom - r.top);
+	recreateUpDown(s);
+}
+
+static void defaultOnChanged(uiSpinbox *s, void *data)
+{
+	// do nothing
+}
+
+int uiSpinboxValue(uiSpinbox *s)
+{
+	return value(s);
+}
+
+void uiSpinboxSetValue(uiSpinbox *s, int value)
+{
+	s->inhibitChanged = TRUE;
+	SendMessageW(s->updown, UDM_SETPOS32, 0, (LPARAM) value);
+	s->inhibitChanged = FALSE;
+}
+
+void uiSpinboxOnChanged(uiSpinbox *s, void (*f)(uiSpinbox *, void *), void *data)
+{
+	s->onChanged = f;
+	s->onChangedData = data;
+}
+
+static void onResize(uiWindowsControl *c)
+{
+	spinboxRelayout(uiSpinbox(c));
+}
+
+uiSpinbox *uiNewSpinbox(int min, int max)
+{
+	uiSpinbox *s;
+	int temp;
+
+	if (min >= max) {
+		temp = min;
+		min = max;
+		max = temp;
+	}
+
+	uiWindowsNewControl(uiSpinbox, s);
+
+	s->hwnd = uiWindowsMakeContainer(uiWindowsControl(s), onResize);
+
+	s->edit = uiWindowsEnsureCreateControlHWND(WS_EX_CLIENTEDGE,
+		L"edit", L"",
+		// don't use ES_NUMBER; it doesn't allow typing in a leading -
+		ES_AUTOHSCROLL | ES_LEFT | ES_NOHIDESEL | WS_TABSTOP,
+		hInstance, NULL,
+		TRUE);
+	uiWindowsEnsureSetParentHWND(s->edit, s->hwnd);
+
+	uiWindowsRegisterWM_COMMANDHandler(s->edit, onWM_COMMAND, uiControl(s));
+	uiSpinboxOnChanged(s, defaultOnChanged, NULL);
+
+	recreateUpDown(s);
+	s->inhibitChanged = TRUE;
+	SendMessageW(s->updown, UDM_SETRANGE32, (WPARAM) min, (LPARAM) max);
+	SendMessageW(s->updown, UDM_SETPOS32, 0, (LPARAM) min);
+	s->inhibitChanged = FALSE;
+
+	return s;
+}
diff --git a/src/libui_sdl/libui/windows/stddialogs.cpp b/src/libui_sdl/libui/windows/stddialogs.cpp
new file mode 100644
index 0000000..89d26ba
--- /dev/null
+++ b/src/libui_sdl/libui/windows/stddialogs.cpp
@@ -0,0 +1,133 @@
+// 22 may 2015
+#include "uipriv_windows.hpp"
+
+// TODO document all this is what we want
+// TODO do the same for font and color buttons
+
+// notes:
+// - FOS_SUPPORTSTREAMABLEITEMS doesn't seem to be supported on windows vista, or at least not with the flags we use
+// - even with FOS_NOVALIDATE the dialogs will reject invalid filenames (at least on Vista, anyway)
+// - lack of FOS_NOREADONLYRETURN doesn't seem to matter on Windows 7
+
+// TODO
+// - http://blogs.msdn.com/b/wpfsdk/archive/2006/10/26/uncommon-dialogs--font-chooser-and-color-picker-dialogs.aspx
+// - when a dialog is active, tab navigation in other windows stops working
+// - when adding uiOpenFolder(), use IFileDialog as well - https://msdn.microsoft.com/en-us/library/windows/desktop/bb762115%28v=vs.85%29.aspx
+
+#define windowHWND(w) ((HWND) uiControlHandle(uiControl(w)))
+
+char *commonItemDialog(HWND parent, REFCLSID clsid, REFIID iid, FILEOPENDIALOGOPTIONS optsadd)
+{
+	IFileDialog *d = NULL;
+	FILEOPENDIALOGOPTIONS opts;
+	IShellItem *result = NULL;
+	WCHAR *wname = NULL;
+	char *name = NULL;
+	HRESULT hr;
+
+	hr = CoCreateInstance(clsid,
+		NULL, CLSCTX_INPROC_SERVER,
+		iid, (LPVOID *) (&d));
+	if (hr != S_OK) {
+		logHRESULT(L"error creating common item dialog", hr);
+		// always return NULL on error
+		goto out;
+	}
+	hr = d->GetOptions(&opts);
+	if (hr != S_OK) {
+		logHRESULT(L"error getting current options", hr);
+		goto out;
+	}
+	opts |= optsadd;
+	// the other platforms don't check read-only; we won't either
+	opts &= ~FOS_NOREADONLYRETURN;
+	hr = d->SetOptions(opts);
+	if (hr != S_OK) {
+		logHRESULT(L"error setting options", hr);
+		goto out;
+	}
+	hr = d->Show(parent);
+	if (hr == HRESULT_FROM_WIN32(ERROR_CANCELLED))
+		// cancelled; return NULL like we have ready
+		goto out;
+	if (hr != S_OK) {
+		logHRESULT(L"error showing dialog", hr);
+		goto out;
+	}
+	hr = d->GetResult(&result);
+	if (hr != S_OK) {
+		logHRESULT(L"error getting dialog result", hr);
+		goto out;
+	}
+	hr = result->GetDisplayName(SIGDN_FILESYSPATH, &wname);
+	if (hr != S_OK) {
+		logHRESULT(L"error getting filename", hr);
+		goto out;
+	}
+	name = toUTF8(wname);
+
+out:
+	if (wname != NULL)
+		CoTaskMemFree(wname);
+	if (result != NULL)
+		result->Release();
+	if (d != NULL)
+		d->Release();
+	return name;
+}
+
+char *uiOpenFile(uiWindow *parent)
+{
+	char *res;
+
+	disableAllWindowsExcept(parent);
+	res = commonItemDialog(windowHWND(parent),
+		CLSID_FileOpenDialog, IID_IFileOpenDialog,
+		FOS_NOCHANGEDIR | FOS_ALLNONSTORAGEITEMS | FOS_NOVALIDATE | FOS_PATHMUSTEXIST | FOS_FILEMUSTEXIST | FOS_SHAREAWARE | FOS_NOTESTFILECREATE | FOS_NODEREFERENCELINKS | FOS_FORCESHOWHIDDEN | FOS_DEFAULTNOMINIMODE);
+	enableAllWindowsExcept(parent);
+	return res;
+}
+
+char *uiSaveFile(uiWindow *parent)
+{
+	char *res;
+
+	disableAllWindowsExcept(parent);
+	res = commonItemDialog(windowHWND(parent),
+		CLSID_FileSaveDialog, IID_IFileSaveDialog,
+		FOS_OVERWRITEPROMPT | FOS_NOCHANGEDIR | FOS_ALLNONSTORAGEITEMS | FOS_NOVALIDATE | FOS_SHAREAWARE | FOS_NOTESTFILECREATE | FOS_NODEREFERENCELINKS | FOS_FORCESHOWHIDDEN | FOS_DEFAULTNOMINIMODE);
+	enableAllWindowsExcept(parent);
+	return res;
+}
+
+// TODO switch to TaskDialogIndirect()?
+
+static void msgbox(HWND parent, const char *title, const char *description, TASKDIALOG_COMMON_BUTTON_FLAGS buttons, PCWSTR icon)
+{
+	WCHAR *wtitle, *wdescription;
+	HRESULT hr;
+
+	wtitle = toUTF16(title);
+	wdescription = toUTF16(description);
+
+	hr = TaskDialog(parent, NULL, NULL, wtitle, wdescription, buttons, icon, NULL);
+	if (hr != S_OK)
+		logHRESULT(L"error showing task dialog", hr);
+
+	uiFree(wdescription);
+	uiFree(wtitle);
+}
+
+void uiMsgBox(uiWindow *parent, const char *title, const char *description)
+{
+	disableAllWindowsExcept(parent);
+	msgbox(windowHWND(parent), title, description, TDCBF_OK_BUTTON, NULL);
+	enableAllWindowsExcept(parent);
+}
+
+void uiMsgBoxError(uiWindow *parent, const char *title, const char *description)
+{
+	disableAllWindowsExcept(parent);
+	msgbox(windowHWND(parent), title, description, TDCBF_OK_BUTTON, TD_ERROR_ICON);
+	enableAllWindowsExcept(parent);
+}
diff --git a/src/libui_sdl/libui/windows/tab.cpp b/src/libui_sdl/libui/windows/tab.cpp
new file mode 100644
index 0000000..365f5a1
--- /dev/null
+++ b/src/libui_sdl/libui/windows/tab.cpp
@@ -0,0 +1,287 @@
+// 16 may 2015
+#include "uipriv_windows.hpp"
+
+// You don't add controls directly to a tab control on Windows; instead you make them siblings and swap between them on a TCN_SELCHANGING/TCN_SELCHANGE notification pair.
+// In addition, you use dialogs because they can be textured properly; other controls cannot. (Things will look wrong if the tab background in the current theme is fancy if you just use the tab background by itself; see http://stackoverflow.com/questions/30087540/why-are-my-programss-tab-controls-rendering-their-background-in-a-blocky-way-b.)
+
+struct uiTab {
+	uiWindowsControl c;
+	HWND hwnd;			// of the outer container
+	HWND tabHWND;		// of the tab control itself
+	std::vector<struct tabPage *> *pages;
+	HWND parent;
+};
+
+// utility functions
+
+static LRESULT curpage(uiTab *t)
+{
+	return SendMessageW(t->tabHWND, TCM_GETCURSEL, 0, 0);
+}
+
+static struct tabPage *tabPage(uiTab *t, int i)
+{
+	return (*(t->pages))[i];
+}
+
+static void tabPageRect(uiTab *t, RECT *r)
+{
+	// this rect needs to be in parent window coordinates, but TCM_ADJUSTRECT wants a window rect, which is screen coordinates
+	// because we have each page as a sibling of the tab, use the tab's own rect as the input rect
+	uiWindowsEnsureGetWindowRect(t->tabHWND, r);
+	SendMessageW(t->tabHWND, TCM_ADJUSTRECT, (WPARAM) FALSE, (LPARAM) r);
+	// and get it in terms of the container instead of the screen
+	mapWindowRect(NULL, t->hwnd, r);
+}
+
+static void tabRelayout(uiTab *t)
+{
+	struct tabPage *page;
+	RECT r;
+
+	// first move the tab control itself
+	uiWindowsEnsureGetClientRect(t->hwnd, &r);
+	uiWindowsEnsureMoveWindowDuringResize(t->tabHWND, r.left, r.top, r.right - r.left, r.bottom - r.top);
+
+	// then the current page
+	if (t->pages->size() == 0)
+		return;
+	page = tabPage(t, curpage(t));
+	tabPageRect(t, &r);
+	uiWindowsEnsureMoveWindowDuringResize(page->hwnd, r.left, r.top, r.right - r.left, r.bottom - r.top);
+}
+
+static void showHidePage(uiTab *t, LRESULT which, int hide)
+{
+	struct tabPage *page;
+
+	if (which == (LRESULT) (-1))
+		return;
+	page = tabPage(t, which);
+	if (hide)
+		ShowWindow(page->hwnd, SW_HIDE);
+	else {
+		ShowWindow(page->hwnd, SW_SHOW);
+		// we only resize the current page, so we have to resize it; before we can do that, we need to make sure we are of the right size
+		uiWindowsControlMinimumSizeChanged(uiWindowsControl(t));
+	}
+}
+
+// control implementation
+
+static BOOL onWM_NOTIFY(uiControl *c, HWND hwnd, NMHDR *nm, LRESULT *lResult)
+{
+	uiTab *t = uiTab(c);
+
+	if (nm->code != TCN_SELCHANGING && nm->code != TCN_SELCHANGE)
+		return FALSE;
+	showHidePage(t, curpage(t), nm->code == TCN_SELCHANGING);
+	*lResult = 0;
+	if (nm->code == TCN_SELCHANGING)
+		*lResult = FALSE;
+	return TRUE;
+}
+
+static void uiTabDestroy(uiControl *c)
+{
+	uiTab *t = uiTab(c);
+	uiControl *child;
+
+	for (struct tabPage *&page : *(t->pages)) {
+		child = page->child;
+		tabPageDestroy(page);
+		if (child != NULL) {
+			uiControlSetParent(child, NULL);
+			uiControlDestroy(child);
+		}
+	}
+	delete t->pages;
+	uiWindowsUnregisterWM_NOTIFYHandler(t->tabHWND);
+	uiWindowsEnsureDestroyWindow(t->tabHWND);
+	uiWindowsEnsureDestroyWindow(t->hwnd);
+	uiFreeControl(uiControl(t));
+}
+
+uiWindowsControlDefaultHandle(uiTab)
+uiWindowsControlDefaultParent(uiTab)
+uiWindowsControlDefaultSetParent(uiTab)
+uiWindowsControlDefaultToplevel(uiTab)
+uiWindowsControlDefaultVisible(uiTab)
+uiWindowsControlDefaultShow(uiTab)
+uiWindowsControlDefaultHide(uiTab)
+uiWindowsControlDefaultEnabled(uiTab)
+uiWindowsControlDefaultEnable(uiTab)
+uiWindowsControlDefaultDisable(uiTab)
+
+static void uiTabSyncEnableState(uiWindowsControl *c, int enabled)
+{
+	uiTab *t = uiTab(c);
+
+	if (uiWindowsShouldStopSyncEnableState(uiWindowsControl(t), enabled))
+		return;
+	EnableWindow(t->tabHWND, enabled);
+	for (struct tabPage *&page : *(t->pages))
+		if (page->child != NULL)
+			uiWindowsControlSyncEnableState(uiWindowsControl(page->child), enabled);
+}
+
+uiWindowsControlDefaultSetParentHWND(uiTab)
+
+static void uiTabMinimumSize(uiWindowsControl *c, int *width, int *height)
+{
+	uiTab *t = uiTab(c);
+	int pagewid, pageht;
+	struct tabPage *page;
+	RECT r;
+
+	// only consider the current page
+	pagewid = 0;
+	pageht = 0;
+	if (t->pages->size() != 0) {
+		page = tabPage(t, curpage(t));
+		tabPageMinimumSize(page, &pagewid, &pageht);
+	}
+
+	r.left = 0;
+	r.top = 0;
+	r.right = pagewid;
+	r.bottom = pageht;
+	// this also includes the tabs themselves
+	SendMessageW(t->tabHWND, TCM_ADJUSTRECT, (WPARAM) TRUE, (LPARAM) (&r));
+	*width = r.right - r.left;
+	*height = r.bottom - r.top;
+}
+
+static void uiTabMinimumSizeChanged(uiWindowsControl *c)
+{
+	uiTab *t = uiTab(c);
+
+	if (uiWindowsControlTooSmall(uiWindowsControl(t))) {
+		uiWindowsControlContinueMinimumSizeChanged(uiWindowsControl(t));
+		return;
+	}
+	tabRelayout(t);
+}
+
+uiWindowsControlDefaultLayoutRect(uiTab)
+uiWindowsControlDefaultAssignControlIDZOrder(uiTab)
+
+static void uiTabChildVisibilityChanged(uiWindowsControl *c)
+{
+	// TODO eliminate the redundancy
+	uiWindowsControlMinimumSizeChanged(c);
+}
+
+static void tabArrangePages(uiTab *t)
+{
+	LONG_PTR controlID = 100;
+	HWND insertAfter = NULL;
+
+	// TODO is this first or last?
+	uiWindowsEnsureAssignControlIDZOrder(t->tabHWND, &controlID, &insertAfter);
+	for (struct tabPage *&page : *(t->pages))
+		uiWindowsEnsureAssignControlIDZOrder(page->hwnd, &controlID, &insertAfter);
+}
+
+void uiTabAppend(uiTab *t, const char *name, uiControl *child)
+{
+	uiTabInsertAt(t, name, t->pages->size(), child);
+}
+
+void uiTabInsertAt(uiTab *t, const char *name, int n, uiControl *child)
+{
+	struct tabPage *page;
+	LRESULT hide, show;
+	TCITEMW item;
+	WCHAR *wname;
+
+	// see below
+	hide = curpage(t);
+
+	if (child != NULL)
+		uiControlSetParent(child, uiControl(t));
+
+	page = newTabPage(child);
+	uiWindowsEnsureSetParentHWND(page->hwnd, t->hwnd);
+	t->pages->insert(t->pages->begin() + n, page);
+	tabArrangePages(t);
+
+	ZeroMemory(&item, sizeof (TCITEMW));
+	item.mask = TCIF_TEXT;
+	wname = toUTF16(name);
+	item.pszText = wname;
+	if (SendMessageW(t->tabHWND, TCM_INSERTITEM, (WPARAM) n, (LPARAM) (&item)) == (LRESULT) -1)
+		logLastError(L"error adding tab to uiTab");
+	uiFree(wname);
+
+	// we need to do this because adding the first tab doesn't send a TCN_SELCHANGE; it just shows the page
+	show = curpage(t);
+	if (show != hide) {
+		showHidePage(t, hide, 1);
+		showHidePage(t, show, 0);
+	}
+}
+
+void uiTabDelete(uiTab *t, int n)
+{
+	struct tabPage *page;
+
+	// first delete the tab from the tab control
+	// if this is the current tab, no tab will be selected, which is good
+	if (SendMessageW(t->tabHWND, TCM_DELETEITEM, (WPARAM) n, 0) == FALSE)
+		logLastError(L"error deleting uiTab tab");
+
+	// now delete the page itself
+	page = tabPage(t, n);
+	if (page->child != NULL)
+		uiControlSetParent(page->child, NULL);
+	tabPageDestroy(page);
+	t->pages->erase(t->pages->begin() + n);
+}
+
+int uiTabNumPages(uiTab *t)
+{
+	return t->pages->size();
+}
+
+int uiTabMargined(uiTab *t, int n)
+{
+	return tabPage(t, n)->margined;
+}
+
+void uiTabSetMargined(uiTab *t, int n, int margined)
+{
+	struct tabPage *page;
+
+	page = tabPage(t, n);
+	page->margined = margined;
+	// even if the page doesn't have a child it might still have a new minimum size with margins; this is the easiest way to verify it
+	uiWindowsControlMinimumSizeChanged(uiWindowsControl(t));
+}
+
+static void onResize(uiWindowsControl *c)
+{
+	tabRelayout(uiTab(c));
+}
+
+uiTab *uiNewTab(void)
+{
+	uiTab *t;
+
+	uiWindowsNewControl(uiTab, t);
+
+	t->hwnd = uiWindowsMakeContainer(uiWindowsControl(t), onResize);
+
+	t->tabHWND = uiWindowsEnsureCreateControlHWND(0,
+		WC_TABCONTROLW, L"",
+		TCS_TOOLTIPS | WS_TABSTOP,
+		hInstance, NULL,
+		TRUE);
+	uiWindowsEnsureSetParentHWND(t->tabHWND, t->hwnd);
+
+	uiWindowsRegisterWM_NOTIFYHandler(t->tabHWND, onWM_NOTIFY, uiControl(t));
+
+	t->pages = new std::vector<struct tabPage *>;
+
+	return t;
+}
diff --git a/src/libui_sdl/libui/windows/tabpage.cpp b/src/libui_sdl/libui/windows/tabpage.cpp
new file mode 100644
index 0000000..5283ce7
--- /dev/null
+++ b/src/libui_sdl/libui/windows/tabpage.cpp
@@ -0,0 +1,131 @@
+// 30 may 2015
+#include "uipriv_windows.hpp"
+
+// TODO refine error handling
+
+// from http://msdn.microsoft.com/en-us/library/windows/desktop/bb226818%28v=vs.85%29.aspx
+#define tabMargin 7
+
+static void tabPageMargins(struct tabPage *tp, int *mx, int *my)
+{
+	uiWindowsSizing sizing;
+
+	*mx = 0;
+	*my = 0;
+	if (!tp->margined)
+		return;
+	uiWindowsGetSizing(tp->hwnd, &sizing);
+	*mx = tabMargin;
+	*my = tabMargin;
+	uiWindowsSizingDlgUnitsToPixels(&sizing, mx, my);
+}
+
+static void tabPageRelayout(struct tabPage *tp)
+{
+	RECT r;
+	int mx, my;
+	HWND child;
+
+	if (tp->child == NULL)
+		return;
+	uiWindowsEnsureGetClientRect(tp->hwnd, &r);
+	tabPageMargins(tp, &mx, &my);
+	r.left += mx;
+	r.top += my;
+	r.right -= mx;
+	r.bottom -= my;
+	child = (HWND) uiControlHandle(tp->child);
+	uiWindowsEnsureMoveWindowDuringResize(child, r.left, r.top, r.right - r.left, r.bottom - r.top);
+}
+
+// dummy dialog procedure; see below for details
+// let's handle parent messages here to avoid needing to subclass
+// TODO do we need to handle DM_GETDEFID/DM_SETDEFID here too because of the ES_WANTRETURN stuff at http://blogs.msdn.com/b/oldnewthing/archive/2007/08/20/4470527.aspx? what about multiple default buttons (TODO)?
+// TODO we definitely need to do something about edit message handling; it does a fake close of our parent on pressing escape, causing uiWindow to stop responding to maximizes but still respond to events and then die horribly on destruction
+static INT_PTR CALLBACK dlgproc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+	struct tabPage *tp;
+	LRESULT lResult;
+
+	if (uMsg == WM_INITDIALOG) {
+		tp = (struct tabPage *) lParam;
+		tp->hwnd = hwnd;
+		SetWindowLongPtrW(hwnd, DWLP_USER, (LONG_PTR) tp);
+		return TRUE;
+	}
+	if (handleParentMessages(hwnd, uMsg, wParam, lParam, &lResult) != FALSE) {
+		SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, (LONG_PTR) lResult);
+		return TRUE;
+	}
+	if (uMsg == WM_WINDOWPOSCHANGED) {
+		tp = (struct tabPage *) GetWindowLongPtrW(hwnd, DWLP_USER);
+		tabPageRelayout(tp);
+		// pretend the dialog hasn't handled this just in case it needs to do something special
+		return FALSE;
+	}
+
+	// unthemed dialogs don't respond to WM_PRINTCLIENT
+	// fortunately they don't have any special painting
+	if (uMsg == WM_PRINTCLIENT) {
+		// don't worry about the return value; hopefully DefWindowProcW() caught it (if not the dialog procedure itself)
+		// we COULD paint the dialog background brush ourselves but meh, it works
+		SendMessageW(hwnd, WM_ERASEBKGND, wParam, lParam);
+		// and pretend we did nothing just so the themed dialog can still paint its content
+		// TODO see if w ecan avoid erasing the background in this case in the first place, or if we even need to
+		return FALSE;
+	}
+
+	return FALSE;
+}
+
+struct tabPage *newTabPage(uiControl *child)
+{
+	struct tabPage *tp;
+	HRESULT hr;
+
+	tp = uiNew(struct tabPage);
+
+	// unfortunately this needs to be a proper dialog for EnableThemeDialogTexture() to work; CreateWindowExW() won't suffice
+	if (CreateDialogParamW(hInstance, MAKEINTRESOURCE(rcTabPageDialog),
+		utilWindow, dlgproc, (LPARAM) tp) == NULL)
+		logLastError(L"error creating tab page");
+
+	tp->child = child;
+	if (tp->child != NULL) {
+		uiWindowsEnsureSetParentHWND((HWND) uiControlHandle(tp->child), tp->hwnd);
+		uiWindowsControlAssignSoleControlIDZOrder(uiWindowsControl(tp->child));
+	}
+
+	hr = EnableThemeDialogTexture(tp->hwnd, ETDT_ENABLE | ETDT_USETABTEXTURE | ETDT_ENABLETAB);
+	if (hr != S_OK)
+		logHRESULT(L"error setting tab page background", hr);
+		// continue anyway; it'll look wrong but eh
+
+	// and start the tab page hidden
+	ShowWindow(tp->hwnd, SW_HIDE);
+
+	return tp;
+}
+
+void tabPageDestroy(struct tabPage *tp)
+{
+	// don't destroy the child with the page
+	if (tp->child != NULL)
+		uiWindowsControlSetParentHWND(uiWindowsControl(tp->child), NULL);
+	// don't call EndDialog(); that's for the DialogBox() family of functions instead of CreateDialog()
+	uiWindowsEnsureDestroyWindow(tp->hwnd);
+	uiFree(tp);
+}
+
+void tabPageMinimumSize(struct tabPage *tp, int *width, int *height)
+{
+	int mx, my;
+
+	*width = 0;
+	*height = 0;
+	if (tp->child != NULL)
+		uiWindowsControlMinimumSize(uiWindowsControl(tp->child), width, height);
+	tabPageMargins(tp, &mx, &my);
+	*width += 2 * mx;
+	*height += 2 * my;
+}
diff --git a/src/libui_sdl/libui/windows/text.cpp b/src/libui_sdl/libui/windows/text.cpp
new file mode 100644
index 0000000..af79fb8
--- /dev/null
+++ b/src/libui_sdl/libui/windows/text.cpp
@@ -0,0 +1,107 @@
+// 9 april 2015
+#include "uipriv_windows.hpp"
+
+WCHAR *windowTextAndLen(HWND hwnd, LRESULT *len)
+{
+	LRESULT n;
+	WCHAR *text;
+
+	n = SendMessageW(hwnd, WM_GETTEXTLENGTH, 0, 0);
+	if (len != NULL)
+		*len = n;
+	// WM_GETTEXTLENGTH does not include the null terminator
+	text = (WCHAR *) uiAlloc((n + 1) * sizeof (WCHAR), "WCHAR[]");
+	// note the comparison: the size includes the null terminator, but the return does not
+	if (GetWindowTextW(hwnd, text, n + 1) != n) {
+		logLastError(L"error getting window text");
+		// on error, return an empty string to be safe
+		*text = L'\0';
+		if (len != NULL)
+			*len = 0;
+	}
+	return text;
+}
+
+WCHAR *windowText(HWND hwnd)
+{
+	return windowTextAndLen(hwnd, NULL);
+}
+
+void setWindowText(HWND hwnd, WCHAR *wtext)
+{
+	if (SetWindowTextW(hwnd, wtext) == 0)
+		logLastError(L"error setting window text");
+}
+
+void uiFreeText(char *text)
+{
+	uiFree(text);
+}
+
+int uiWindowsWindowTextWidth(HWND hwnd)
+{
+	LRESULT len;
+	WCHAR *text;
+	HDC dc;
+	HFONT prevfont;
+	SIZE size;
+
+	size.cx = 0;
+	size.cy = 0;
+
+	text = windowTextAndLen(hwnd, &len);
+	if (len == 0)		// no text; nothing to do
+		goto noTextOrError;
+
+	// now we can do the calculations
+	dc = GetDC(hwnd);
+	if (dc == NULL) {
+		logLastError(L"error getting DC");
+		// on any error, assume no text
+		goto noTextOrError;
+	}
+	prevfont = (HFONT) SelectObject(dc, hMessageFont);
+	if (prevfont == NULL) {
+		logLastError(L"error loading control font into device context");
+		ReleaseDC(hwnd, dc);
+		goto noTextOrError;
+	}
+	if (GetTextExtentPoint32W(dc, text, len, &size) == 0) {
+		logLastError(L"error getting text extent point");
+		// continue anyway, assuming size is 0
+		size.cx = 0;
+		size.cy = 0;
+	}
+	// continue on errors; we got what we want
+	if (SelectObject(dc, prevfont) != hMessageFont)
+		logLastError(L"error restoring previous font into device context");
+	if (ReleaseDC(hwnd, dc) == 0)
+		logLastError(L"error releasing DC");
+
+	uiFree(text);
+	return size.cx;
+
+noTextOrError:
+	uiFree(text);
+	return 0;
+}
+
+char *uiWindowsWindowText(HWND hwnd)
+{
+	WCHAR *wtext;
+	char *text;
+
+	wtext = windowText(hwnd);
+	text = toUTF8(wtext);
+	uiFree(wtext);
+	return text;
+}
+
+void uiWindowsSetWindowText(HWND hwnd, const char *text)
+{
+	WCHAR *wtext;
+
+	wtext = toUTF16(text);
+	setWindowText(hwnd, wtext);
+	uiFree(wtext);
+}
diff --git a/src/libui_sdl/libui/windows/uipriv_windows.hpp b/src/libui_sdl/libui/windows/uipriv_windows.hpp
new file mode 100644
index 0000000..6ffe09f
--- /dev/null
+++ b/src/libui_sdl/libui/windows/uipriv_windows.hpp
@@ -0,0 +1,164 @@
+// 21 april 2016
+#include "winapi.hpp"
+#include "../ui.h"
+#include "../ui_windows.h"
+#include "../common/uipriv.h"
+#include "resources.hpp"
+#include "compilerver.hpp"
+
+// ui internal window messages
+enum {
+	// redirected WM_COMMAND and WM_NOTIFY
+	msgCOMMAND = WM_APP + 0x40,		// start offset just to be safe
+	msgNOTIFY,
+	msgHSCROLL,
+	msgQueued,
+	msgD2DScratchPaint,
+	msgD2DScratchLButtonDown,
+};
+
+// alloc.cpp
+extern void initAlloc(void);
+extern void uninitAlloc(void);
+
+// events.cpp
+extern BOOL runWM_COMMAND(WPARAM wParam, LPARAM lParam, LRESULT *lResult);
+extern BOOL runWM_NOTIFY(WPARAM wParam, LPARAM lParam, LRESULT *lResult);
+extern BOOL runWM_HSCROLL(WPARAM wParam, LPARAM lParam, LRESULT *lResult);
+extern void issueWM_WININICHANGE(WPARAM wParam, LPARAM lParam);
+
+// utf16.cpp
+#define emptyUTF16() ((WCHAR *) uiAlloc(1 * sizeof (WCHAR), "WCHAR[]"))
+#define emptyUTF8() ((char *) uiAlloc(1 * sizeof (char), "char[]"))
+extern WCHAR *toUTF16(const char *str);
+extern char *toUTF8(const WCHAR *wstr);
+extern WCHAR *utf16dup(const WCHAR *orig);
+extern WCHAR *strf(const WCHAR *format, ...);
+extern WCHAR *vstrf(const WCHAR *format, va_list ap);
+extern char *LFtoCRLF(const char *lfonly);
+extern void CRLFtoLF(char *s);
+extern WCHAR *ftoutf16(double d);
+extern WCHAR *itoutf16(int i);
+
+// debug.cpp
+// see http://stackoverflow.com/questions/14421656/is-there-widely-available-wide-character-variant-of-file
+// we turn __LINE__ into a string because PRIiMAX can't be converted to a wide string in MSVC (it seems to be defined as "ll" "i" according to the compiler errors)
+// also note the use of __FUNCTION__ here; __func__ doesn't seem to work for some reason
+#define _ws2(m) L ## m
+#define _ws(m) _ws2(m)
+#define _ws2n(m) L ## #m
+#define _wsn(m) _ws2n(m)
+#define debugargs const WCHAR *file, const WCHAR *line, const WCHAR *func
+extern HRESULT _logLastError(debugargs, const WCHAR *s);
+#ifdef _MSC_VER
+#define logLastError(s) _logLastError(_ws(__FILE__), _wsn(__LINE__), _ws(__FUNCTION__), s)
+#else
+#define logLastError(s) _logLastError(_ws(__FILE__), _wsn(__LINE__), L"TODO none of the function name macros are macros in MinGW", s)
+#endif
+extern HRESULT _logHRESULT(debugargs, const WCHAR *s, HRESULT hr);
+#ifdef _MSC_VER
+#define logHRESULT(s, hr) _logHRESULT(_ws(__FILE__), _wsn(__LINE__), _ws(__FUNCTION__), s, hr)
+#else
+#define logHRESULT(s, hr) _logHRESULT(_ws(__FILE__), _wsn(__LINE__), L"TODO none of the function name macros are macros in MinGW", s, hr)
+#endif
+
+// winutil.cpp
+extern int windowClassOf(HWND hwnd, ...);
+extern void mapWindowRect(HWND from, HWND to, RECT *r);
+extern DWORD getStyle(HWND hwnd);
+extern void setStyle(HWND hwnd, DWORD style);
+extern DWORD getExStyle(HWND hwnd);
+extern void setExStyle(HWND hwnd, DWORD exstyle);
+extern void clientSizeToWindowSize(HWND hwnd, int *width, int *height, BOOL hasMenubar);
+extern HWND parentOf(HWND child);
+extern HWND parentToplevel(HWND child);
+extern void setWindowInsertAfter(HWND hwnd, HWND insertAfter);
+extern HWND getDlgItem(HWND hwnd, int id);
+extern void invalidateRect(HWND hwnd, RECT *r, BOOL erase);
+
+// text.cpp
+extern WCHAR *windowTextAndLen(HWND hwnd, LRESULT *len);
+extern WCHAR *windowText(HWND hwnd);
+extern void setWindowText(HWND hwnd, WCHAR *wtext);
+
+// init.cpp
+extern HINSTANCE hInstance;
+extern int nCmdShow;
+extern HFONT hMessageFont;
+extern HBRUSH hollowBrush;
+extern uiInitOptions options;
+
+// utilwin.cpp
+extern HWND utilWindow;
+extern const char *initUtilWindow(HICON hDefaultIcon, HCURSOR hDefaultCursor);
+extern void uninitUtilWindow(void);
+
+// main.cpp
+extern int registerMessageFilter(void);
+extern void unregisterMessageFilter(void);
+
+// parent.cpp
+extern void paintContainerBackground(HWND hwnd, HDC dc, RECT *paintRect);
+extern BOOL handleParentMessages(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *lResult);
+
+// d2dscratch.cpp
+extern ATOM registerD2DScratchClass(HICON hDefaultIcon, HCURSOR hDefaultCursor);
+extern void unregisterD2DScratchClass(void);
+extern HWND newD2DScratch(HWND parent, RECT *rect, HMENU controlID, SUBCLASSPROC subclass, DWORD_PTR subclassData);
+
+// area.cpp
+#define areaClass L"libui_uiAreaClass"
+extern ATOM registerAreaClass(HICON, HCURSOR);
+extern void unregisterArea(void);
+
+// areaevents.cpp
+extern BOOL areaFilter(MSG *);
+
+// window.cpp
+extern ATOM registerWindowClass(HICON, HCURSOR);
+extern void unregisterWindowClass(void);
+extern void ensureMinimumWindowSize(uiWindow *);
+extern void disableAllWindowsExcept(uiWindow *which);
+extern void enableAllWindowsExcept(uiWindow *which);
+
+// container.cpp
+#define containerClass L"libui_uiContainerClass"
+extern ATOM initContainer(HICON, HCURSOR);
+extern void uninitContainer(void);
+
+// tabpage.cpp
+struct tabPage {
+	HWND hwnd;
+	uiControl *child;
+	BOOL margined;
+};
+extern struct tabPage *newTabPage(uiControl *child);
+extern void tabPageDestroy(struct tabPage *tp);
+extern void tabPageMinimumSize(struct tabPage *tp, int *width, int *height);
+
+// colordialog.cpp
+struct colorDialogRGBA {
+	double r;
+	double g;
+	double b;
+	double a;
+};
+extern BOOL showColorDialog(HWND parent, struct colorDialogRGBA *c);
+
+// sizing.cpp
+extern void getSizing(HWND hwnd, uiWindowsSizing *sizing, HFONT font);
+
+// graphemes.cpp
+extern size_t *graphemes(WCHAR *msg);
+
+// TODO move into a dedicated file abibugs.cpp when we rewrite the drawing code
+extern D2D1_SIZE_F realGetSize(ID2D1RenderTarget *rt);
+
+
+
+
+// TODO
+#include "_uipriv_migrate.hpp"
+
+// draw.cpp
+extern ID2D1DCRenderTarget *makeHDCRenderTarget(HDC dc, RECT *r);
diff --git a/src/libui_sdl/libui/windows/utf16.cpp b/src/libui_sdl/libui/windows/utf16.cpp
new file mode 100644
index 0000000..98954d0
--- /dev/null
+++ b/src/libui_sdl/libui/windows/utf16.cpp
@@ -0,0 +1,153 @@
+// 21 april 2016
+#include "uipriv_windows.hpp"
+
+// see http://stackoverflow.com/a/29556509/3408572
+
+#define MBTWC(str, wstr, bufsiz) MultiByteToWideChar(CP_UTF8, 0, str, -1, wstr, bufsiz)
+
+WCHAR *toUTF16(const char *str)
+{
+	WCHAR *wstr;
+	int n;
+
+	if (*str == '\0')			// empty string
+		return emptyUTF16();
+	n = MBTWC(str, NULL, 0);
+	if (n == 0) {
+		logLastError(L"error figuring out number of characters to convert to");
+		return emptyUTF16();
+	}
+	wstr = (WCHAR *) uiAlloc(n * sizeof (WCHAR), "WCHAR[]");
+	if (MBTWC(str, wstr, n) != n) {
+		logLastError(L"error converting from UTF-8 to UTF-16");
+		// and return an empty string
+		*wstr = L'\0';
+	}
+	return wstr;
+}
+
+#define WCTMB(wstr, str, bufsiz) WideCharToMultiByte(CP_UTF8, 0, wstr, -1, str, bufsiz, NULL, NULL)
+
+char *toUTF8(const WCHAR *wstr)
+{
+	char *str;
+	int n;
+
+	if (*wstr == L'\0')		// empty string
+		return emptyUTF8();
+	n = WCTMB(wstr, NULL, 0);
+	if (n == 0) {
+		logLastError(L"error figuring out number of characters to convert to");
+		return emptyUTF8();
+	}
+	str = (char *) uiAlloc(n * sizeof (char), "char[]");
+	if (WCTMB(wstr, str, n) != n) {
+		logLastError(L"error converting from UTF-16 to UTF-8");
+		// and return an empty string
+		*str = '\0';
+	}
+	return str;
+}
+
+WCHAR *utf16dup(const WCHAR *orig)
+{
+	WCHAR *out;
+	size_t len;
+
+	len = wcslen(orig);
+	out = (WCHAR *) uiAlloc((len + 1) * sizeof (WCHAR), "WCHAR[]");
+	wcscpy_s(out, len + 1, orig);
+	return out;
+}
+
+WCHAR *strf(const WCHAR *format, ...)
+{
+	va_list ap;
+	WCHAR *str;
+
+	va_start(ap, format);
+	str = vstrf(format, ap);
+	va_end(ap);
+	return str;
+}
+
+WCHAR *vstrf(const WCHAR *format, va_list ap)
+{
+	va_list ap2;
+	WCHAR *buf;
+	size_t n;
+
+	if (*format == L'\0')
+		return emptyUTF16();
+
+	va_copy(ap2, ap);
+	n = _vscwprintf(format, ap2);
+	va_end(ap2);
+	n++;		// terminating L'\0'
+
+	buf = (WCHAR *) uiAlloc(n * sizeof (WCHAR), "WCHAR[]");
+	// includes terminating L'\0' according to example in https://msdn.microsoft.com/en-us/library/xa1a1a6z.aspx
+	vswprintf_s(buf, n, format, ap);
+
+	return buf;
+}
+
+// Let's shove these utility routines here too.
+// Prerequisite: lfonly is UTF-8.
+char *LFtoCRLF(const char *lfonly)
+{
+	char *crlf;
+	size_t i, len;
+	char *out;
+
+	len = strlen(lfonly);
+	crlf = (char *) uiAlloc((len * 2 + 1) * sizeof (char), "char[]");
+	out = crlf;
+	for (i = 0; i < len; i++) {
+		if (*lfonly == '\n')
+			*crlf++ = '\r';
+		*crlf++ = *lfonly++;
+	}
+	*crlf = '\0';
+	return out;
+}
+
+// Prerequisite: s is UTF-8.
+void CRLFtoLF(char *s)
+{
+	char *t = s;
+
+	for (; *s != '\0'; s++) {
+		// be sure to preserve \rs that are genuinely there
+		if (*s == '\r' && *(s + 1) == '\n')
+			continue;
+		*t++ = *s;
+	}
+	*t = '\0';
+	// pad out the rest of t, just to be safe
+	while (t != s)
+		*t++ = '\0';
+}
+
+// std::to_string() always uses %f; we want %g
+// fortunately std::iostream seems to use %g by default so
+WCHAR *ftoutf16(double d)
+{
+	std::wostringstream ss;
+	std::wstring s;
+
+	ss << d;
+	s = ss.str();		// to be safe
+	return utf16dup(s.c_str());
+}
+
+// to complement the above
+WCHAR *itoutf16(int i)
+{
+	std::wostringstream ss;
+	std::wstring s;
+
+	ss << i;
+	s = ss.str();		// to be safe
+	return utf16dup(s.c_str());
+}
diff --git a/src/libui_sdl/libui/windows/utilwin.cpp b/src/libui_sdl/libui/windows/utilwin.cpp
new file mode 100644
index 0000000..414ae83
--- /dev/null
+++ b/src/libui_sdl/libui/windows/utilwin.cpp
@@ -0,0 +1,76 @@
+// 14 may 2015
+#include "uipriv_windows.hpp"
+
+// The utility window is a special window that performs certain tasks internal to libui.
+// It is not a message-only window, and it is always hidden and disabled.
+// Its roles:
+// - It is the initial parent of all controls. When a control loses its parent, it also becomes that control's parent.
+// - It handles WM_QUERYENDSESSION and console end session requests.
+// - It handles WM_WININICHANGE and forwards the message to any child windows that request it.
+// - It handles executing functions queued to run by uiQueueMain().
+
+#define utilWindowClass L"libui_utilWindowClass"
+
+HWND utilWindow;
+
+static LRESULT CALLBACK utilWindowWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+	void (*qf)(void *);
+	LRESULT lResult;
+
+	if (handleParentMessages(hwnd, uMsg, wParam, lParam, &lResult) != FALSE)
+		return lResult;
+	switch (uMsg) {
+	case WM_QUERYENDSESSION:
+		// TODO block handler
+		if (shouldQuit()) {
+			uiQuit();
+			return TRUE;
+		}
+		return FALSE;
+	case WM_WININICHANGE:
+		issueWM_WININICHANGE(wParam, lParam);
+		return 0;
+	case msgQueued:
+		qf = (void (*)(void *)) wParam;
+		(*qf)((void *) lParam);
+		return 0;
+	}
+	return DefWindowProcW(hwnd, uMsg, wParam, lParam);
+}
+
+const char *initUtilWindow(HICON hDefaultIcon, HCURSOR hDefaultCursor)
+{
+	WNDCLASSW wc;
+
+	ZeroMemory(&wc, sizeof (WNDCLASSW));
+	wc.lpszClassName = utilWindowClass;
+	wc.lpfnWndProc = utilWindowWndProc;
+	wc.hInstance = hInstance;
+	wc.hIcon = hDefaultIcon;
+	wc.hCursor = hDefaultCursor;
+	wc.hbrBackground = (HBRUSH) (COLOR_BTNFACE + 1);
+	if (RegisterClass(&wc) == 0)
+		// see init.cpp for an explanation of the =s
+		return "=registering utility window class";
+
+	utilWindow = CreateWindowExW(0,
+		utilWindowClass, L"libui utility window",
+		WS_OVERLAPPEDWINDOW,
+		0, 0, 100, 100,
+		NULL, NULL, hInstance, NULL);
+	if (utilWindow == NULL)
+		return "=creating utility window";
+	// and just to be safe
+	EnableWindow(utilWindow, FALSE);
+
+	return NULL;
+}
+
+void uninitUtilWindow(void)
+{
+	if (DestroyWindow(utilWindow) == 0)
+		logLastError(L"error destroying utility window");
+	if (UnregisterClass(utilWindowClass, hInstance) == 0)
+		logLastError(L"error unregistering utility window class");
+}
diff --git a/src/libui_sdl/libui/windows/winapi.hpp b/src/libui_sdl/libui/windows/winapi.hpp
new file mode 100644
index 0000000..86aba5d
--- /dev/null
+++ b/src/libui_sdl/libui/windows/winapi.hpp
@@ -0,0 +1,51 @@
+// 31 may 2015
+#define UNICODE
+#define _UNICODE
+#define STRICT
+#define STRICT_TYPED_ITEMIDS
+
+// see https://github.com/golang/go/issues/9916#issuecomment-74812211
+// TODO get rid of this
+#define INITGUID
+
+// for the manifest
+#ifndef _UI_STATIC
+#define ISOLATION_AWARE_ENABLED 1
+#endif
+
+// get Windows version right; right now Windows Vista
+// unless otherwise stated, all values from Microsoft's sdkddkver.h
+// TODO is all of this necessary? how is NTDDI_VERSION used?
+// TODO plaform update sp2
+#define WINVER			0x0600	/* from Microsoft's winnls.h */
+#define _WIN32_WINNT		0x0600
+#define _WIN32_WINDOWS	0x0600	/* from Microsoft's pdh.h */
+#define _WIN32_IE			0x0700
+#define NTDDI_VERSION		0x06000000
+
+#include <windows.h>
+
+// Microsoft's resource compiler will segfault if we feed it headers it was not designed to handle
+#ifndef RC_INVOKED
+#include <commctrl.h>
+#include <uxtheme.h>
+#include <windowsx.h>
+#include <shobjidl.h>
+#include <d2d1.h>
+#include <d2d1helper.h>
+#include <dwrite.h>
+#include <usp10.h>
+
+#include <stdint.h>
+#include <string.h>
+#include <wchar.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <math.h>
+#include <float.h>
+#include <inttypes.h>
+
+#include <vector>
+#include <map>
+#include <sstream>
+#endif
diff --git a/src/libui_sdl/libui/windows/window.cpp b/src/libui_sdl/libui/windows/window.cpp
new file mode 100644
index 0000000..9cf13a2
--- /dev/null
+++ b/src/libui_sdl/libui/windows/window.cpp
@@ -0,0 +1,533 @@
+// 27 april 2015
+#include "uipriv_windows.hpp"
+
+#define windowClass L"libui_uiWindowClass"
+
+struct uiWindow {
+	uiWindowsControl c;
+	HWND hwnd;
+	HMENU menubar;
+	uiControl *child;
+	BOOL shownOnce;
+	int visible;
+	int (*onClosing)(uiWindow *, void *);
+	void *onClosingData;
+	int margined;
+	BOOL hasMenubar;
+	void (*onContentSizeChanged)(uiWindow *, void *);
+	void *onContentSizeChangedData;
+	BOOL changingSize;
+	int fullscreen;
+	WINDOWPLACEMENT fsPrevPlacement;
+	int borderless;
+};
+
+// from https://msdn.microsoft.com/en-us/library/windows/desktop/dn742486.aspx#sizingandspacing
+#define windowMargin 7
+
+static void windowMargins(uiWindow *w, int *mx, int *my)
+{
+	uiWindowsSizing sizing;
+
+	*mx = 0;
+	*my = 0;
+	if (!w->margined)
+		return;
+	uiWindowsGetSizing(w->hwnd, &sizing);
+	*mx = windowMargin;
+	*my = windowMargin;
+	uiWindowsSizingDlgUnitsToPixels(&sizing, mx, my);
+}
+
+static void windowRelayout(uiWindow *w)
+{
+	int x, y, width, height;
+	RECT r;
+	int mx, my;
+	HWND child;
+
+	if (w->child == NULL)
+		return;
+	x = 0;
+	y = 0;
+	uiWindowsEnsureGetClientRect(w->hwnd, &r);
+	width = r.right - r.left;
+	height = r.bottom - r.top;
+	windowMargins(w, &mx, &my);
+	x += mx;
+	y += my;
+	width -= 2 * mx;
+	height -= 2 * my;
+	child = (HWND) uiControlHandle(w->child);
+	uiWindowsEnsureMoveWindowDuringResize(child, x, y, width, height);
+}
+
+static LRESULT CALLBACK windowWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+	LONG_PTR ww;
+	uiWindow *w;
+	CREATESTRUCTW *cs = (CREATESTRUCTW *) lParam;
+	WINDOWPOS *wp = (WINDOWPOS *) lParam;
+	MINMAXINFO *mmi = (MINMAXINFO *) lParam;
+	int width, height;
+	LRESULT lResult;
+
+	ww = GetWindowLongPtrW(hwnd, GWLP_USERDATA);
+	if (ww == 0) {
+		if (uMsg == WM_CREATE)
+			SetWindowLongPtrW(hwnd, GWLP_USERDATA, (LONG_PTR) (cs->lpCreateParams));
+		// fall through to DefWindowProc() anyway
+		return DefWindowProcW(hwnd, uMsg, wParam, lParam);
+	}
+	w = uiWindow((void *) ww);
+	if (handleParentMessages(hwnd, uMsg, wParam, lParam, &lResult) != FALSE)
+		return lResult;
+	switch (uMsg) {
+	case WM_COMMAND:
+		// not a menu
+		if (lParam != 0)
+			break;
+		if (HIWORD(wParam) != 0)
+			break;
+		runMenuEvent(LOWORD(wParam), uiWindow(w));
+		return 0;
+	case WM_WINDOWPOSCHANGED:
+		if ((wp->flags & SWP_NOSIZE) != 0)
+			break;
+		if (w->onContentSizeChanged != NULL)		// TODO figure out why this is happening too early
+			if (!w->changingSize)
+				(*(w->onContentSizeChanged))(w, w->onContentSizeChangedData);
+		windowRelayout(w);
+		return 0;
+	case WM_GETMINMAXINFO:
+		// ensure the user cannot resize the window smaller than its minimum size
+		lResult = DefWindowProcW(hwnd, uMsg, wParam, lParam);
+		uiWindowsControlMinimumSize(uiWindowsControl(w), &width, &height);
+		// width and height are in client coordinates; ptMinTrackSize is in window coordinates
+		clientSizeToWindowSize(w->hwnd, &width, &height, w->hasMenubar);
+		mmi->ptMinTrackSize.x = width;
+		mmi->ptMinTrackSize.y = height;
+		return lResult;
+	case WM_PRINTCLIENT:
+		// we do no special painting; just erase the background
+		// don't worry about the return value; we let DefWindowProcW() handle this message
+		SendMessageW(hwnd, WM_ERASEBKGND, wParam, lParam);
+		return 0;
+	case WM_CLOSE:
+		if ((*(w->onClosing))(w, w->onClosingData))
+			uiControlDestroy(uiControl(w));
+		return 0;		// we destroyed it already
+	}
+	return DefWindowProcW(hwnd, uMsg, wParam, lParam);
+}
+
+ATOM registerWindowClass(HICON hDefaultIcon, HCURSOR hDefaultCursor)
+{
+	WNDCLASSW wc;
+
+	ZeroMemory(&wc, sizeof (WNDCLASSW));
+	wc.lpszClassName = windowClass;
+	wc.lpfnWndProc = windowWndProc;
+	wc.hInstance = hInstance;
+	wc.hIcon = hDefaultIcon;
+	wc.hCursor = hDefaultCursor;
+	wc.hbrBackground = (HBRUSH) (COLOR_BTNFACE + 1);
+	return RegisterClassW(&wc);
+}
+
+void unregisterWindowClass(void)
+{
+	if (UnregisterClassW(windowClass, hInstance) == 0)
+		logLastError(L"error unregistering uiWindow window class");
+}
+
+static int defaultOnClosing(uiWindow *w, void *data)
+{
+	return 0;
+}
+
+static void defaultOnPositionContentSizeChanged(uiWindow *w, void *data)
+{
+	// do nothing
+}
+
+static std::map<uiWindow *, bool> windows;
+
+static void uiWindowDestroy(uiControl *c)
+{
+	uiWindow *w = uiWindow(c);
+
+	// first hide ourselves
+	ShowWindow(w->hwnd, SW_HIDE);
+	// now destroy the child
+	if (w->child != NULL) {
+		uiControlSetParent(w->child, NULL);
+		uiControlDestroy(w->child);
+	}
+	// now free the menubar, if any
+	if (w->menubar != NULL)
+		freeMenubar(w->menubar);
+	// and finally free ourselves
+	windows.erase(w);
+	uiWindowsEnsureDestroyWindow(w->hwnd);
+	uiFreeControl(uiControl(w));
+}
+
+uiWindowsControlDefaultHandle(uiWindow)
+
+uiControl *uiWindowParent(uiControl *c)
+{
+	return NULL;
+}
+
+void uiWindowSetParent(uiControl *c, uiControl *parent)
+{
+	uiUserBugCannotSetParentOnToplevel("uiWindow");
+}
+
+static int uiWindowToplevel(uiControl *c)
+{
+	return 1;
+}
+
+// TODO initial state of windows is hidden; ensure this here and make it so on other platforms
+static int uiWindowVisible(uiControl *c)
+{
+	uiWindow *w = uiWindow(c);
+
+	return w->visible;
+}
+
+static void uiWindowShow(uiControl *c)
+{
+	uiWindow *w = uiWindow(c);
+
+	w->visible = 1;
+	// just in case the window's minimum size wasn't recalculated already
+	ensureMinimumWindowSize(w);
+	if (w->shownOnce) {
+		ShowWindow(w->hwnd, SW_SHOW);
+		return;
+	}
+	w->shownOnce = TRUE;
+	// make sure the child is the correct size
+	uiWindowsControlMinimumSizeChanged(uiWindowsControl(w));
+	ShowWindow(w->hwnd, nCmdShow);
+	if (UpdateWindow(w->hwnd) == 0)
+		logLastError(L"error calling UpdateWindow() after showing uiWindow for the first time");
+}
+
+static void uiWindowHide(uiControl *c)
+{
+	uiWindow *w = uiWindow(c);
+
+	w->visible = 0;
+	ShowWindow(w->hwnd, SW_HIDE);
+}
+
+// TODO we don't want the window to be disabled completely; that would prevent it from being moved! ...would it?
+uiWindowsControlDefaultEnabled(uiWindow)
+uiWindowsControlDefaultEnable(uiWindow)
+uiWindowsControlDefaultDisable(uiWindow)
+// TODO we need to do something about undocumented fields in the OS control types
+uiWindowsControlDefaultSyncEnableState(uiWindow)
+// TODO
+uiWindowsControlDefaultSetParentHWND(uiWindow)
+
+static void uiWindowMinimumSize(uiWindowsControl *c, int *width, int *height)
+{
+	uiWindow *w = uiWindow(c);
+	int mx, my;
+
+	*width = 0;
+	*height = 0;
+	if (w->child != NULL)
+		uiWindowsControlMinimumSize(uiWindowsControl(w->child), width, height);
+	windowMargins(w, &mx, &my);
+	*width += 2 * mx;
+	*height += 2 * my;
+}
+
+static void uiWindowMinimumSizeChanged(uiWindowsControl *c)
+{
+	uiWindow *w = uiWindow(c);
+
+	if (uiWindowsControlTooSmall(uiWindowsControl(w))) {
+		// TODO figure out what to do with this function
+		// maybe split it into two so WM_GETMINMAXINFO can use it?
+		ensureMinimumWindowSize(w);
+		return;
+	}
+	// otherwise we only need to re-layout everything
+	windowRelayout(w);
+}
+
+static void uiWindowLayoutRect(uiWindowsControl *c, RECT *r)
+{
+	uiWindow *w = uiWindow(c);
+
+	// the layout rect is the client rect in this case
+	uiWindowsEnsureGetClientRect(w->hwnd, r);
+}
+
+uiWindowsControlDefaultAssignControlIDZOrder(uiWindow)
+
+static void uiWindowChildVisibilityChanged(uiWindowsControl *c)
+{
+	// TODO eliminate the redundancy
+	uiWindowsControlMinimumSizeChanged(c);
+}
+
+char *uiWindowTitle(uiWindow *w)
+{
+	return uiWindowsWindowText(w->hwnd);
+}
+
+void uiWindowSetTitle(uiWindow *w, const char *title)
+{
+	uiWindowsSetWindowText(w->hwnd, title);
+	// don't queue resize; the caption isn't part of what affects layout and sizing of the client area (it'll be ellipsized if too long)
+}
+
+// this is used for both fullscreening and centering
+// see also https://blogs.msdn.microsoft.com/oldnewthing/20100412-00/?p=14353 and https://blogs.msdn.microsoft.com/oldnewthing/20050505-04/?p=35703
+static void windowMonitorRect(HWND hwnd, RECT *r)
+{
+	HMONITOR monitor;
+	MONITORINFO mi;
+
+	monitor = MonitorFromWindow(hwnd, MONITOR_DEFAULTTOPRIMARY);
+	ZeroMemory(&mi, sizeof (MONITORINFO));
+	mi.cbSize = sizeof (MONITORINFO);
+	if (GetMonitorInfoW(monitor, &mi) == 0) {
+		logLastError(L"error getting window monitor rect");
+		// default to SM_CXSCREEN x SM_CYSCREEN to be safe
+		r->left = 0;
+		r->top = 0;
+		r->right = GetSystemMetrics(SM_CXSCREEN);
+		r->bottom = GetSystemMetrics(SM_CYSCREEN);
+		return;
+	}
+	*r = mi.rcMonitor;
+}
+
+void uiWindowContentSize(uiWindow *w, int *width, int *height)
+{
+	RECT r;
+
+	uiWindowsEnsureGetClientRect(w->hwnd, &r);
+	*width = r.right - r.left;
+	*height = r.bottom - r.top;
+}
+
+// TODO should this disallow too small?
+void uiWindowSetContentSize(uiWindow *w, int width, int height)
+{
+	w->changingSize = TRUE;
+	clientSizeToWindowSize(w->hwnd, &width, &height, w->hasMenubar);
+	if (SetWindowPos(w->hwnd, NULL, 0, 0, width, height, SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOOWNERZORDER | SWP_NOZORDER) == 0)
+		logLastError(L"error resizing window");
+	w->changingSize = FALSE;
+}
+
+int uiWindowFullscreen(uiWindow *w)
+{
+	return w->fullscreen;
+}
+
+void uiWindowSetFullscreen(uiWindow *w, int fullscreen)
+{
+	RECT r;
+
+	if (w->fullscreen && fullscreen)
+		return;
+	if (!w->fullscreen && !fullscreen)
+		return;
+	w->fullscreen = fullscreen;
+	w->changingSize = TRUE;
+	if (w->fullscreen) {
+		ZeroMemory(&(w->fsPrevPlacement), sizeof (WINDOWPLACEMENT));
+		w->fsPrevPlacement.length = sizeof (WINDOWPLACEMENT);
+		if (GetWindowPlacement(w->hwnd, &(w->fsPrevPlacement)) == 0)
+			logLastError(L"error getting old window placement");
+		windowMonitorRect(w->hwnd, &r);
+		setStyle(w->hwnd, getStyle(w->hwnd) & ~WS_OVERLAPPEDWINDOW);
+		if (SetWindowPos(w->hwnd, HWND_TOP,
+			r.left, r.top,
+			r.right - r.left, r.bottom - r.top,
+			SWP_FRAMECHANGED | SWP_NOOWNERZORDER) == 0)
+			logLastError(L"error making window fullscreen");
+	} else {
+		if (!w->borderless)		// keep borderless until that is turned off
+			setStyle(w->hwnd, getStyle(w->hwnd) | WS_OVERLAPPEDWINDOW);
+		if (SetWindowPlacement(w->hwnd, &(w->fsPrevPlacement)) == 0)
+			logLastError(L"error leaving fullscreen");
+		if (SetWindowPos(w->hwnd, NULL,
+			0, 0, 0, 0,
+			SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOOWNERZORDER | SWP_NOSIZE | SWP_NOZORDER) == 0)
+			logLastError(L"error restoring window border after fullscreen");
+	}
+	w->changingSize = FALSE;
+}
+
+void uiWindowOnContentSizeChanged(uiWindow *w, void (*f)(uiWindow *, void *), void *data)
+{
+	w->onContentSizeChanged = f;
+	w->onContentSizeChangedData = data;
+}
+
+void uiWindowOnClosing(uiWindow *w, int (*f)(uiWindow *, void *), void *data)
+{
+	w->onClosing = f;
+	w->onClosingData = data;
+}
+
+int uiWindowBorderless(uiWindow *w)
+{
+	return w->borderless;
+}
+
+// TODO window should move to the old client position and should not have the extra space the borders left behind
+// TODO extract the relevant styles from WS_OVERLAPPEDWINDOW?
+void uiWindowSetBorderless(uiWindow *w, int borderless)
+{
+	w->borderless = borderless;
+	if (w->borderless)
+		setStyle(w->hwnd, getStyle(w->hwnd) & ~WS_OVERLAPPEDWINDOW);
+	else
+		if (!w->fullscreen)		// keep borderless until leaving fullscreen
+			setStyle(w->hwnd, getStyle(w->hwnd) | WS_OVERLAPPEDWINDOW);
+}
+
+void uiWindowSetChild(uiWindow *w, uiControl *child)
+{
+	if (w->child != NULL) {
+		uiControlSetParent(w->child, NULL);
+		uiWindowsControlSetParentHWND(uiWindowsControl(w->child), NULL);
+	}
+	w->child = child;
+	if (w->child != NULL) {
+		uiControlSetParent(w->child, uiControl(w));
+		uiWindowsControlSetParentHWND(uiWindowsControl(w->child), w->hwnd);
+		uiWindowsControlAssignSoleControlIDZOrder(uiWindowsControl(w->child));
+		windowRelayout(w);
+	}
+}
+
+int uiWindowMargined(uiWindow *w)
+{
+	return w->margined;
+}
+
+void uiWindowSetMargined(uiWindow *w, int margined)
+{
+	w->margined = margined;
+	windowRelayout(w);
+}
+
+// see http://blogs.msdn.com/b/oldnewthing/archive/2003/09/11/54885.aspx and http://blogs.msdn.com/b/oldnewthing/archive/2003/09/13/54917.aspx
+// TODO use clientSizeToWindowSize()
+static void setClientSize(uiWindow *w, int width, int height, BOOL hasMenubar, DWORD style, DWORD exstyle)
+{
+	RECT window;
+
+	window.left = 0;
+	window.top = 0;
+	window.right = width;
+	window.bottom = height;
+	if (AdjustWindowRectEx(&window, style, hasMenubar, exstyle) == 0)
+		logLastError(L"error getting real window coordinates");
+	if (hasMenubar) {
+		RECT temp;
+
+		temp = window;
+		temp.bottom = 0x7FFF;		// infinite height
+		SendMessageW(w->hwnd, WM_NCCALCSIZE, (WPARAM) FALSE, (LPARAM) (&temp));
+		window.bottom += temp.top;
+	}
+	if (SetWindowPos(w->hwnd, NULL, 0, 0, window.right - window.left, window.bottom - window.top, SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOOWNERZORDER | SWP_NOZORDER) == 0)
+		logLastError(L"error resizing window");
+}
+
+uiWindow *uiNewWindow(const char *title, int width, int height, int hasMenubar)
+{
+	uiWindow *w;
+	WCHAR *wtitle;
+	BOOL hasMenubarBOOL;
+
+	uiWindowsNewControl(uiWindow, w);
+
+	hasMenubarBOOL = FALSE;
+	if (hasMenubar)
+		hasMenubarBOOL = TRUE;
+	w->hasMenubar = hasMenubarBOOL;
+
+#define style WS_OVERLAPPEDWINDOW
+#define exstyle 0
+
+	wtitle = toUTF16(title);
+	w->hwnd = CreateWindowExW(exstyle,
+		windowClass, wtitle,
+		style,
+		CW_USEDEFAULT, CW_USEDEFAULT,
+		// use the raw width and height for now
+		// this will get CW_USEDEFAULT (hopefully) predicting well
+		// even if it doesn't, we're adjusting it later
+		width, height,
+		NULL, NULL, hInstance, w);
+	if (w->hwnd == NULL)
+		logLastError(L"error creating window");
+	uiFree(wtitle);
+
+	if (hasMenubar) {
+		w->menubar = makeMenubar();
+		if (SetMenu(w->hwnd, w->menubar) == 0)
+			logLastError(L"error giving menu to window");
+	}
+
+	// and use the proper size
+	setClientSize(w, width, height, hasMenubarBOOL, style, exstyle);
+
+	uiWindowOnClosing(w, defaultOnClosing, NULL);
+	uiWindowOnContentSizeChanged(w, defaultOnPositionContentSizeChanged, NULL);
+
+	windows[w] = true;
+	return w;
+}
+
+// this cannot queue a resize because it's called by the resize handler
+void ensureMinimumWindowSize(uiWindow *w)
+{
+	int width, height;
+	RECT r;
+
+	uiWindowsControlMinimumSize(uiWindowsControl(w), &width, &height);
+	uiWindowsEnsureGetClientRect(w->hwnd, &r);
+	if (width < (r.right - r.left))		// preserve width if larger
+		width = r.right - r.left;
+	if (height < (r.bottom - r.top))		// preserve height if larger
+		height = r.bottom - r.top;
+	clientSizeToWindowSize(w->hwnd, &width, &height, w->hasMenubar);
+	if (SetWindowPos(w->hwnd, NULL, 0, 0, width, height, SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOOWNERZORDER | SWP_NOZORDER) == 0)
+		logLastError(L"error resizing window");
+}
+
+void disableAllWindowsExcept(uiWindow *which)
+{
+	for (auto &w : windows) {
+		if (w.first == which)
+			continue;
+		EnableWindow(w.first->hwnd, FALSE);
+	}
+}
+
+void enableAllWindowsExcept(uiWindow *which)
+{
+	for (auto &w : windows) {
+		if (w.first == which)
+			continue;
+		if (!uiControlEnabled(uiControl(w.first)))
+			continue;
+		EnableWindow(w.first->hwnd, TRUE);
+	}
+}
diff --git a/src/libui_sdl/libui/windows/winpublic.cpp b/src/libui_sdl/libui/windows/winpublic.cpp
new file mode 100644
index 0000000..397a3b5
--- /dev/null
+++ b/src/libui_sdl/libui/windows/winpublic.cpp
@@ -0,0 +1,61 @@
+// 6 april 2015
+#include "uipriv_windows.hpp"
+
+void uiWindowsEnsureDestroyWindow(HWND hwnd)
+{
+	if (DestroyWindow(hwnd) == 0)
+		logLastError(L"error destroying window");
+}
+
+void uiWindowsEnsureSetParentHWND(HWND hwnd, HWND parent)
+{
+	if (parent == NULL)
+		parent = utilWindow;
+	if (SetParent(hwnd, parent) == 0)
+		logLastError(L"error setting window parent");
+}
+
+void uiWindowsEnsureAssignControlIDZOrder(HWND hwnd, LONG_PTR *controlID, HWND *insertAfter)
+{
+	SetWindowLongPtrW(hwnd, GWLP_ID, *controlID);
+	(*controlID)++;
+	setWindowInsertAfter(hwnd, *insertAfter);
+	*insertAfter = hwnd;
+}
+
+void uiWindowsEnsureMoveWindowDuringResize(HWND hwnd, int x, int y, int width, int height)
+{
+	RECT r;
+
+	r.left = x;
+	r.top = y;
+	r.right = x + width;
+	r.bottom = y + height;
+	if (SetWindowPos(hwnd, NULL, r.left, r.top, r.right - r.left, r.bottom - r.top, SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOZORDER) == 0)
+		logLastError(L"error moving window");
+}
+
+// do these function even error out in any case other than invalid parameters?! I thought all windows had rects
+void uiWindowsEnsureGetClientRect(HWND hwnd, RECT *r)
+{
+	if (GetClientRect(hwnd, r) == 0) {
+		logLastError(L"error getting window client rect");
+		// zero out the rect on error just to be safe
+		r->left = 0;
+		r->top = 0;
+		r->right = 0;
+		r->bottom = 0;
+	}
+}
+
+void uiWindowsEnsureGetWindowRect(HWND hwnd, RECT *r)
+{
+	if (GetWindowRect(hwnd, r) == 0) {
+		logLastError(L"error getting window rect");
+		// zero out the rect on error just to be safe
+		r->left = 0;
+		r->top = 0;
+		r->right = 0;
+		r->bottom = 0;
+	}
+}
diff --git a/src/libui_sdl/libui/windows/winutil.cpp b/src/libui_sdl/libui/windows/winutil.cpp
new file mode 100644
index 0000000..507c5a3
--- /dev/null
+++ b/src/libui_sdl/libui/windows/winutil.cpp
@@ -0,0 +1,154 @@
+// 6 april 2015
+#include "uipriv_windows.hpp"
+
+// this is a helper function that takes the logic of determining window classes and puts it all in one place
+// there are a number of places where we need to know what window class an arbitrary handle has
+// theoretically we could use the class atom to avoid a _wcsicmp()
+// however, raymond chen advises against this - http://blogs.msdn.com/b/oldnewthing/archive/2004/10/11/240744.aspx (and we're not in control of the Tab class, before you say anything)
+// usage: windowClassOf(hwnd, L"class 1", L"class 2", ..., NULL)
+int windowClassOf(HWND hwnd, ...)
+{
+// MSDN says 256 is the maximum length of a class name; add a few characters just to be safe (because it doesn't say whether this includes the terminating null character)
+#define maxClassName 260
+	WCHAR classname[maxClassName + 1];
+	va_list ap;
+	WCHAR *curname;
+	int i;
+
+	if (GetClassNameW(hwnd, classname, maxClassName) == 0) {
+		logLastError(L"error getting name of window class");
+		// assume no match on error, just to be safe
+		return -1;
+	}
+	va_start(ap, hwnd);
+	i = 0;
+	for (;;) {
+		curname = va_arg(ap, WCHAR *);
+		if (curname == NULL)
+			break;
+		if (_wcsicmp(classname, curname) == 0) {
+			va_end(ap);
+			return i;
+		}
+		i++;
+	}
+	// no match
+	va_end(ap);
+	return -1;
+}
+
+// wrapper around MapWindowRect() that handles the complex error handling
+void mapWindowRect(HWND from, HWND to, RECT *r)
+{
+	RECT prevr;
+	DWORD le;
+
+	prevr = *r;
+	SetLastError(0);
+	if (MapWindowRect(from, to, r) == 0) {
+		le = GetLastError();
+		SetLastError(le);		// just to be safe
+		if (le != 0) {
+			logLastError(L"error calling MapWindowRect()");
+			// restore original rect on error, just in case
+			*r = prevr;
+		}
+	}
+}
+
+DWORD getStyle(HWND hwnd)
+{
+	return (DWORD) GetWindowLongPtrW(hwnd, GWL_STYLE);
+}
+
+void setStyle(HWND hwnd, DWORD style)
+{
+	SetWindowLongPtrW(hwnd, GWL_STYLE, (LONG_PTR) style);
+}
+
+DWORD getExStyle(HWND hwnd)
+{
+	return (DWORD) GetWindowLongPtrW(hwnd, GWL_EXSTYLE);
+}
+
+void setExStyle(HWND hwnd, DWORD exstyle)
+{
+	SetWindowLongPtrW(hwnd, GWL_EXSTYLE, (LONG_PTR) exstyle);
+}
+
+// see http://blogs.msdn.com/b/oldnewthing/archive/2003/09/11/54885.aspx and http://blogs.msdn.com/b/oldnewthing/archive/2003/09/13/54917.aspx
+void clientSizeToWindowSize(HWND hwnd, int *width, int *height, BOOL hasMenubar)
+{
+	RECT window;
+
+	window.left = 0;
+	window.top = 0;
+	window.right = *width;
+	window.bottom = *height;
+	if (AdjustWindowRectEx(&window, getStyle(hwnd), hasMenubar, getExStyle(hwnd)) == 0) {
+		logLastError(L"error getting adjusted window rect");
+		// on error, don't give up; the window will be smaller but whatever
+		window.left = 0;
+		window.top = 0;
+		window.right = *width;
+		window.bottom = *height;
+	}
+	if (hasMenubar) {
+		RECT temp;
+
+		temp = window;
+		temp.bottom = 0x7FFF;		// infinite height
+		SendMessageW(hwnd, WM_NCCALCSIZE, (WPARAM) FALSE, (LPARAM) (&temp));
+		window.bottom += temp.top;
+	}
+	*width = window.right - window.left;
+	*height = window.bottom - window.top;
+}
+
+HWND parentOf(HWND child)
+{
+	return GetAncestor(child, GA_PARENT);
+}
+
+HWND parentToplevel(HWND child)
+{
+	return GetAncestor(child, GA_ROOT);
+}
+
+void setWindowInsertAfter(HWND hwnd, HWND insertAfter)
+{
+	if (SetWindowPos(hwnd, insertAfter, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOOWNERZORDER | SWP_NOSIZE) == 0)
+		logLastError(L"error reordering window");
+}
+
+HWND getDlgItem(HWND hwnd, int id)
+{
+	HWND out;
+
+	out = GetDlgItem(hwnd, id);
+	if (out == NULL)
+		logLastError(L"error getting dialog item handle");
+	return out;
+}
+
+void invalidateRect(HWND hwnd, RECT *r, BOOL erase)
+{
+	if (InvalidateRect(hwnd, r, erase) == 0)
+		logLastError(L"error invalidating window rect");
+}
+
+// that damn ABI bug is never going to escape me is it
+D2D1_SIZE_F realGetSize(ID2D1RenderTarget *rt)
+{
+#ifdef _MSC_VER
+	return rt->GetSize();
+#else
+	D2D1_SIZE_F size;
+	typedef D2D1_SIZE_F *(__stdcall ID2D1RenderTarget::* GetSizeF)(D2D1_SIZE_F *);
+	GetSizeF gs;
+
+	gs = (GetSizeF) (&(rt->GetSize));
+	(rt->*gs)(&size);
+	return size;
+#endif
+}