bump version to 1.4.0

It was supposed to be equal to JWIDGET_KEY, but was no longer since
constructors were de-prioritized by the new widget declaration systems,
non-deterministically, causing a lot of confusion.

.gitignore

@@ -1,6 +1,5 @@
 # Build files
-build-fx
-build-cg
+/build*/
 
 # GiteaPC support
 giteapc-config.make
@@ -8,3 +7,5 @@ giteapc-config-*.make
 
 # Developer's files
 *.sublime-*
+
+__pycache__

CMakeLists.txt

@@ -1,8 +1,8 @@
 # Just UI
 
 cmake_minimum_required(VERSION 3.16)
-project(JustUI VERSION 1.3.0 LANGUAGES C)
-find_package(Gint 2.8 REQUIRED)
+project(JustUI VERSION 1.4.0 LANGUAGES C)
+find_package(Gint 2.11 REQUIRED)
 include(Fxconv)
 
 set(CMAKE_INSTALL_MESSAGE LAZY)
@@ -11,10 +11,12 @@ configure_file(include/justui/config.h.in include/justui/config.h)
 
 set(ASSETS_fx
   assets/input-modes-fx.png
+  assets/font-fkeys-fx.png
 )
 set(ASSETS_cg
   assets/input-modes-cg.png
 )
+set(ASSETS_cp ${ASSETS_cg})
 fxconv_declare_assets(${ASSETS_fx} ${ASSETS_cg} WITH_METADATA)
 
 set(NAME "justui-${FXSDK_PLATFORM}")
@@ -38,13 +40,19 @@ add_library(${NAME} STATIC
 )
 
 target_compile_options(${NAME} PUBLIC
-  -Wall -Wextra -std=c11 -Os)
+  -Wall -Wextra -std=c11 -Os -flto)
 target_include_directories(${NAME} PUBLIC
   "${CMAKE_CURRENT_SOURCE_DIR}/include"
   "${CMAKE_CURRENT_BINARY_DIR}/include")
 target_link_libraries(${NAME}
   Gint::Gint -lm)
 
+# Generate the archive with gcc-ar instead of ar as it will load the LTO plugin
+# which is required to generate a usable archive.
+set(CMAKE_C_ARCHIVE_CREATE "${CMAKE_C_COMPILER_AR} qcs <TARGET> <OBJECTS>")
+# Also the ranlib rule (useless because ar is passed the s flag anyway)
+set(CMAKE_C_ARCHIVE_FINISH "${CMAKE_C_COMPILER_RANLIB} <TARGET>")
+
 install(TARGETS ${NAME}
   DESTINATION "${FXSDK_LIB}")
 install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/"

assets/fxconv-metadata.txt

@@ -6,3 +6,13 @@ input-modes-cg.png:
   name: j_img_input_modes
   type: bopti-image
   profile: p4
+
+font-fkeys-fx.png:
+  name: j_font_fkeys_fx
+  type: font
+  charset: print
+  grid.size: 5x6
+  grid.padding: 1
+  grid.border: 0
+  proportional: true
+  height: 6

doc/changelogs.md

@@ -0,0 +1,139 @@
+# Changelog and migration guides
+
+## 1.4.0
+
+**Migration: event functions**
+
+The convention for event functions has changed to allow the removall of the "inheritance" property, which was clumsy in C and only useful for event functions.
+Now, instead of returning `false` for events that a widget is not interested in, the event function should explicitly forward the event to the "inherited" function, i.e. usually the one from jwidget, and the inheritance parameter to `j_register_widget()` must be removed. The lack of inheritance also removes the need to order constructors.
+
+```c
+//=== Before =================================================================//
+static bool mywidget_poly_event(void *w, jevent e) {
+    if(event_is_interesting(e)) { /* ... */ }
+    return false;
+}
+__attribute__((constructor(1020)))
+static void j_register_mywidget(void) {
+	mywidget_type_id = j_register_widget(&type_mywidget, "jwidget");
+	/* ... */
+}
+
+//=== After ==================================================================//
+static bool mywidget_poly_event(void *w, jevent e) {
+    if(event_is_interesting(e)) { /* ... */ }
+    return jwidget_poly_event(w, e); //< Forward to jwidget
+}
+__attribute__((constructor)) //< No priority needed
+static void j_register_mywidget(void) {
+	mywidget_type_id = j_register_widget(&type_mywidget); //< No inheritance
+	/* ... */
+}
+```
+
+The event function should not forward events to focused sub-widgets; `jscene` handles that. Emitting an event at the scene level already leads to multiple event function calls, starting at the focused widget, and bubbling up to parents along the way.
+
+**Migration: widget definitions**
+
+The widget definition system has been improved with macros. This change is optional but removes a lot of boilerplate.
+
+The macro `J_DEFINE_WIDGET(<NAME>, <FUNCTIONS>...)` defines a widget with the given `NAME` that implements the given poly-`FUNCTIONS`. This macro:
+- Defines `int NAME_type_id`, which is assigned automatically at startup in a constructor;
+- Uses `NAME_poly_FUN` for each `FUN` in the list of `FUNCTIONS`.
+
+For instance (see https://git.planet-casio.com/Lephenixnoir/JustUI/commit/626da6f378fd3763fe51dd9478f85d9f9ea4874c):
+
+```c
+//=== Macro version ==========================================================//
+#include <justui/jwidget-api.h>
+J_DEFINE_WIDGET(jpainted, csize, render)
+
+void jpainted_poly_csize(void *p) { /* ... */ }
+void jpainted_poly_render(void *p, int x, int y) { /* ... */ }
+
+//=== Equivalent to ==========================================================//
+static int jpainted_type_id = -1;
+
+void jpainted_poly_csize(void *p) { /* ... */ }
+void jpainted_poly_render(void *p, int x, int y) { /* ... */ }
+
+static jwidget_poly type_jpainted = {
+    .name    = "jpainted",
+    .csize   = jpainted_poly_csize,
+    .render  = jpainted_poly_render,
+};
+
+__attribute__((constructor))
+static void j_register_jpainted(void) {
+    jpainted_type_id = j_register_widget(&type_jpainted);
+}
+```
+
+**Migration: event definitions**
+
+To allow the complete removal of explicit constructor functions from widgets, events can also be defined by a macro.
+
+```c
+J_DEFINE_EVENTS(<NAMES>...)
+```
+
+This simply defines new variables `uint16_t NAME` for every `NAME` in the list of `NAMES` and registers them as events at startup with a constructor.
+
+**Migration: focus system**
+
+The focus system changed; see the [appropriate documentation](scene.md). The main changes are as follow.
+
+Any widget that wants to receive keyboard input must set a focus policy, typically fixed at creation. This is either `J_FOCUS_POLICY_ACCEPT` if the widget has no children or `J_FOCUS_POLICY_SCOPE` if the widget contains children that may themselves want to receive keyboard focus. In most cases this is all that needs to be done (example with `jlist`: https://git.planet-casio.com/Lephenixnoir/JustUI/commit/57a460894f1395bd2b789f32c922fbc61e231a66#diff-94b157d9507dee40d44c23076d92c5ceb0b427d4)
+
+```c
+mywidget *mywidget_create(void *parent)
+{
+    if(mywidget_type_id < 0) return NULL;
+
+    mywidget *w = malloc(sizeof *w);
+    if(!w) return NULL;
+
+    jwidget_init(&w->widget, mywidget_type_id, parent);
+    jwidget_set_focus_policy(w, J_FOCUS_POLICY_ACCEPT); //< Set policy
+    /* ... */
+}
+```
+
+The events `JWIDGET_FOCUS_IN` and `JWIDGET_FOCUS_OUT` are replaced with a general `JWIDGET_FOCUS_CHANGED` event encompassing their meaning (among other things). The handler for such an event can call `jwidget_has_focus()` (example with `jinput`: https://git.planet-casio.com/Lephenixnoir/JustUI/commit/57a460894f1395bd2b789f32c922fbc61e231a66#diff-492b1daa1b4361eb231c82b4b1fca013601eb54c).
+
+**Breaking features and major features**
+
+* Rework widget focus model https://git.planet-casio.com/Lephenixnoir/JustUI/commit/57a460894f1395bd2b789f32c922fbc61e231a66 https://git.planet-casio.com/Lephenixnoir/JustUI/commit/7a5101360a86bc0d7d28e7a26f460fcea5f80dea
+  - Widgets that want keyboard input must now specify a focus policy at creation
+  - The events `JWIDGET_FOCUS_IN` and `JWIDGET_FOCUS_OUT` are replaced with a general `JWIDGET_FOCUS_CHANGED`
+  - This also removes `JSCENE_KEY` in favor of `JWIDGET_KEY`, which were supposed to be the same but weren't, leading to confusing bugs https://git.planet-casio.com/Lephenixnoir/JustUI/commit/23294b77ac945ac35a2b9571e778f8193fd6f4de
+* Replace widget definition process https://git.planet-casio.com/Lephenixnoir/JustUI/commit/216918123fc484793bef2e9d6072b13e129fa655 https://git.planet-casio.com/Lephenixnoir/JustUI/commit/683e89d7257d5d303071f9c63e238c8bb11400a9 https://git.planet-casio.com/Lephenixnoir/JustUI/commit/626da6f378fd3763fe51dd9478f85d9f9ea4874c
+  - This removes the inheritance property
+  - This modifies the convention for event handling functions, which should now default to `jwidget_poly_event()` https://git.planet-casio.com/Lephenixnoir/JustUI/commit/683e89d7257d5d303071f9c63e238c8bb11400a9 https://git.planet-casio.com/Lephenixnoir/JustUI/commit/93eb0df38aab9ebf1f71a4f27a53ba2039ed946d
+  - Results in much less boilerplate
+* fx-CP 400 build and basic compatibility (no touch input yet) https://git.planet-casio.com/Lephenixnoir/JustUI/commit/5b092a5a4ec2a74337ef6a98ccb4da3f658ab738 with correctly-sizes (but barely usable) F-keys https://git.planet-casio.com/Lephenixnoir/JustUI/commit/e12a58c1f0cd48cc1abd14630e4d44152e810948s
+* WIP: Denotational UIs still a work-in-progress.
+
+**Minor improvemements**
+
+* `jfileselect`: Now displays "(No entries)" for empty folders https://git.planet-casio.com/Lephenixnoir/JustUI/commit/4c44b3e413e81ad443e02d2d136efd3207ffcb54 and error values when a filesystem error occurs https://git.planet-casio.com/Lephenixnoir/JustUI/commit/bea113f09e33fea6e9cb91a78a15a93b8c4842aa
+* `jscene`: Now turns off with SHIFT+AC/ON, with option to disable https://git.planet-casio.com/Lephenixnoir/JustUI/commit/ef71bc11c0634fc575164e40bfe4afa6688c3fd9 https://git.planet-casio.com/Lephenixnoir/JustUI/commit/0c8371edceb768de6077f0fef2e2deaa912d2e8c
+* `jscene`: Autopaint option https://git.planet-casio.com/Lephenixnoir/JustUI/commit/7f2131d6a03af4930dc85a3900a537940d4689cc
+* `jscene`: Defaults to vbox layout instead of no layout https://git.planet-casio.com/Lephenixnoir/JustUI/commit/a2129f1ed208f5e982ae822e230e46a4b7406756
+* `jinput`: Add function to customize keymap https://git.planet-casio.com/Lephenixnoir/JustUI/commit/0e5ccf4cc3723f47d592cf0ba2375edd954c24ad
+* `jlabel`: Now recognizes the `font_t` property `line_distance` for inter-line spacing https://git.planet-casio.com/Lephenixnoir/JustUI/commit/33e99622096b892ae8406b160d19908e82f854cb
+* `jlabel`: Defaults to top alignment https://git.planet-casio.com/Lephenixnoir/JustUI/commit/4728c6ecbe4c1fcfcd11fbab15078bf51828f384
+* `jlabel`: No longer gobbles spaces after line breaks if the break is caused by an explicit `\n` https://git.planet-casio.com/Lephenixnoir/JustUI/commit/4728c6ecbe4c1fcfcd11fbab15078bf51828f384
+* `jlist`: More fluid user code with default selection https://git.planet-casio.com/Lephenixnoir/JustUI/commit/3488c6515ab1d4f4c664b353362a82aa328decc9, info values https://git.planet-casio.com/Lephenixnoir/JustUI/commit/12b29f8223e91753250ad5e64a730e8c7ff2db19, and a user data pointer for rendering https://git.planet-casio.com/Lephenixnoir/JustUI/commit/7587dfa17cdc643881a3048a0935abe2f31d2936
+* `jevent`: Provide functions for identifying key events (still looking for a good design there) https://git.planet-casio.com/Lephenixnoir/JustUI/commit/7b8070f02c01f8eb74487c4e61acf98f5b076cfc
+* `jfkeys`: Now returns events instead of leaving keys F1...F6 pass through. This requires jfkeys to get key events, which needs support from the scene (in gintctl, gscreen handles it). https://git.planet-casio.com/Lephenixnoir/JustUI/commit/f28d7a9cb8e9a1249e761a7b97e2e6f5e9faa6b5
+* Optimization: turn on LTO https://git.planet-casio.com/Lephenixnoir/JustUI/commit/5a885b541f7aad3dfcc76f522d4deec274cc91e4
+* Optimization: full-screen widget with background (usually `jscene`) now renders with `dclear()` https://git.planet-casio.com/Lephenixnoir/JustUI/commit/f32dcc69ce9055606d8efff97150fed291ceadb5
+
+**Fixes**
+
+* Compatibility: less FX vs. CG hardcoding https://git.planet-casio.com/Lephenixnoir/JustUI/commit/e324f9a3a281d9ce29bb6d4953ba39763b52dbed
+* `jframe`: Fix crash with NULL child https://git.planet-casio.com/Lephenixnoir/JustUI/commit/5e2488cdf4ac73761bc11612b10a37d0375e5ba9
+* `jscene`: Interrupt-safe access to event queue https://git.planet-casio.com/Lephenixnoir/JustUI/commit/550c08e200fd6479e51d1afc7f625657a659d9db
+* `jlist`, `jscrolledlist`: Fix parent not being last parameter https://git.planet-casio.com/Lephenixnoir/JustUI/commit/ba7b0a02d0701bd564294456452b897251bb2768
+* Add checks to avoid the compiler inserting certain `abort()` calls https://git.planet-casio.com/Lephenixnoir/JustUI/commit/4d6b760b1ae6744332ce929321c6b0d0ea2b8f30

doc/jui-lang.txt

@@ -0,0 +1,229 @@
+## Introduction
+
+JustUI includes a UI specification language which can be used to specify user interfaces in a declarative/functional manner, and generates C code for building the user interface and basic interactions. It doesn't remove the need to write custom C code for most of the dynamic aspects of the interface, but it automates its construction and sometimes a bit more.
+
+The language is a purely functional, dynamically-typed language with call-by-need evaluation. Its main feature is _record types_, a structure data type which comes with convenient construction tools and supports flexible kinds of (non-recursive) self-references.
+
+---
+
+## Types of data
+
+- The null constant (`null`) and booleans (`true`, `false`);
+- Primitive types: arbitrary-precision integers (`42`, `-666`), floats (`-73.0f`, `1729.0`), strings (`"JustUI?\n"`);
+- References to C/C++ objects, treated as pure text (`@img_title`, `@mywidget::draw`);
+- Collections: lists.
+- Functions: closures (carry their own context), but not curried.
+- Records.
+
+Another kind of “data” that isn't actually a language value is record types themselves, e.g. the `jlabel` type which is used to construct records that describe a label widget.
+
+> Note: they couldn't easily be first-class because they're associated with a given interpretation of inline parameters, which makes no visual sense unless the name is explicit. Computing a record type then instantiating it with inline parameters is way too confusing. If it's just used in an update, compute the instance.
+
+---
+
+## Semantics: Basics
+
+Expressions for primitive data types are pure.
+
+The following builtin operators are defined (in decreasing order of precedence).
+
+- `!`, `-`, `...` (unary)
+- `*`, `/`, `%` (left associative)
+- `+`, `-` (left associative)
+- `==`, `!=`, `<`, `>`, `<=`, `>=` (not associative)
+- `&&` (left associative)
+- `||` (left associative)
+- `f <| x` (left associative)
+- `x | f` (right associative)
+
+Arithmetic/logical operators have their usual meaning as in Python/C. The other operators, `...x`, `f <| x` and `x | f`, are described later.
+
+Interesting expressions start at `let`-bindings and functions. Within a scope (described later), values can be defined with a `let`-binding:
+
+```
+let x = 3 * 14 + 31;
+```
+
+And functions can be defined with `fun`:
+
+```
+fun add(x, y) = x + y;
+```
+
+The operators `f <| x` and `x | f` are left-sided and right-sided function application, respectively. They are both equivalent to `f(x)` and are mainly useful because of their syntax: they don't need parentheses and are associative, which makes chaining much easier to read.
+
+Functions can take variadic parameters with `...`. There can only be zero or one variadic parameter in a function; it there is one, it must be at the end of the parameter list. The variadic parameter will collect any number of extra arguments (including zero) in a list value.
+
+```
+fun multiply_sum(factor, ...floats) = factor * sum(floats);
+```
+
+Conversely, arguments to a call can be produced from a list by using the pack expansion operator `...`.
+
+```
+let args = [3.2, 4.0, 5.0];
+multiply_sum(...args, 8.0);
+/* equivalent to multiply_sum(3.2, 4.0, 5.0, 8.0) = 54.4 */
+```
+
+---
+
+## Semantics: Record types
+
+Record types are dictionary-like structures with key/value pairs. The primary motivation for records is to represent widgets.
+
+Records are built using _record constructors_, which are simply the names of record types. Using a record type's name as an expression produces the _default record_ of that type, which is usually empty. Most of the time however, the record is further specified by adding fields in braces:
+
+```
+/* Default record of type jwidget */
+jwidget;
+/* Default jwidget with the height set to 20 */
+jwidget { height: 20; };
+```
+
+`jwidget` also has a children field, which can be used to add new widgets in it.
+
+```
+jwidget {
+   children: [
+      jlabel { text: "Hello" },
+      jlabel { text: "World" }
+   ];
+};
+```
+
+However, this syntax is a bit cumbersome. Record types can take _direct_ parameters, which are raw values not prefixed by a field name. `jwidget` handles its direct parameters by adding the to its `children` field, so the previous example can be shortened to:
+
+```
+jwidget {
+   jlabel { text: "Hello" };
+   jlabel { text: "World" };
+};
+```
+
+In fact, `jlabel` also accepts a single direct parameter which is its string, so the example can be further simplified down to:
+
+```
+jwidget {
+   jlabel { "Hello" };
+   jlabel { "World" };
+};
+```
+
+A constructed record can further be updated with the `<{ ... }` operator, which can override fields. Direct parameters cannot be specified during an update, because direct parameters are literal arguments to the construction function, so they no longer exist once the construction is finished. A typical example is functions to apply common properties on widgets.
+
+```
+/* Make any widget size 80x20 */
+fun mysize(w) = w <{ width: 80; height: 20 };
+/* Widget with three labels of that size */
+jwidget {
+   mysize(jlabel { "Hello" });          // standard function call
+   mysize <| jlabel { "again" };        // left-side function call
+   jlabel { "world!" } | mysize;        // right-side function call
+```
+
+Such functions are often called on direct record parameters (when they represent children of existing widgets), in which case the function call operators `<|` and `|` are useful for improving readability.
+
+When updating a record, other fields can be referred to by using the `this` keyword, which represents the object being updated. Fields are updated in-order, and `this` always reflects the latest value of fields.
+
+```
+fun mysize(w) = w <{
+   margin: this.width - 20;             // refers to original width of w
+   width: this.width - 40;              // refers to original width of w
+   height: this.width;                  // refers to updated width
+};
+```
+
+TODO: Custom record types (`rec`) with direct of parameters: children, string for labels, tabs for gscreen...
+
+TODO: Evaluation order of `this` in record constructors, cycle resolution through call-by-need (arguments and field values are thunked).
+
+TODO: `set` statement modifies a constructor in the current scope.
+
+TODO: Pack expansion for inline parameters
+
+---
+
+## Generating user interfaces
+
+The UI file is interpreted statically. It produces a hierarchy of elements for
+which scene setup code, "signal connections" and access to inner widgets are
+provided.
+
+---
+
+BIG TODO:
+- Don't have a scope and ability to let- or fun-declare inside function body!!
+- `rec x() = y {}; x {}` is it of record type `x` or `y`? How to say that `x`
+  is based on `y`?
+  -> it's of type y, which is derived from x and may or may not have custom
+     codegen that overrides that of x
+
+IMPLEMENTATION TODO:
+- List syntax
+- List manip' (including for loop)
+
+TODO:
+
+The syntax for assigning at labels is a bit dodgy at the moment. It should be
+`@ident: value` but we already use that for record entry def + implicit child.
+-> Competing methods for accessing fields: we already have `.name`, labels are
+   thus useful for accessing inline-children
+-> But labels were supposed to be for runtime, this is mixing things up
+-> How should labels work really?
+-> TODO
+
+- Need ability to reference sub-images in order to assign sprites to BGs
+  -> builtin sub-image record type
+- Need to have global parameters to control fx/cg
+  -> function-based interface param("FX")
+- "Control-flow": for(each) loops, what else needed for basic ops?
+
+Capturing "this" in a local variable to get a snapshot is required, otherwise
+we can't refer to parents.
+
+ability to define nice operators?
+
+`fun "<|>"(...elems) = hbox <| jwidget { ...elems };`
+
+(priority/associativity difficult)
+
+---
+
+Notes on resolved topics:
+
+Call-by-need to allow non-recursive dependencies in record constructors.
+
+Semantics of "this" in evaluation of rec:
+-> gscreen { x: 1; y: 2; z; u; v; a: 2; c; }
+-> Fact #1: New fields like x: 1; y: 2 must be defined in terms of base fields
+   of gscreen {}, otherwise it's inconsistent with record update
+-> Fact #2: Parameters may or may not be needed to specify base fields
+-> Build a "future context" which tells how to map fields of "this" to either
+   existing attributes or thunks of that expression, and then use that context
+   during the evaluation of the argument thunk.
+-> OK.
+
+Static is the right choice, even if gintctl might add stuff dynamically
+-> In Azur it will almost entirely be static, we want the ability to optimize
+   things by precomputing.
+-> As long as the interface is well specified (i.e. the added tabs are children
+   of the named child "stack") we can always add some C
+-> The jui-lang file will mostly initialize, we can minimize interference with
+   runtime dynamics, hopefully
+
+---
+
+rogue life bindings UI example?
+
+let PanelFrame = rectangle {
+  bg: @paintPanelFrame
+  padding: 16px
+}
+let BindingsWindow = vbox <| PanelFrame {
+  jlabel { "Select bindings" }
+
+  (Checkbox { bg0: "img1a"; bg1: "img1b" } <|>
+   Checkbox { bg0: "img2a"; bg1: "img2b" } <|>
+   Checkbox { bg0: "img3a"; bg1: "img3b" })
+}

doc/scene.md

@@ -1,3 +1,124 @@
-# JustUI: Scenes and events
+# JustUI: Scenes, events and keyboard focus
 
-TODO.
+## Introduction
+
+The _scene_ in JustUI is the component sitting at the root of the widget hierarchy. It handles all the dynamic aspects of the UI, including distributing/propagating events and managing keyboard focus among the widgets.
+
+TODO...
+
+## Keyboard focus system
+
+### Principles: focus policies, focused widgets and active-focus widgets
+
+Every widget has a focus policy, which can be:
+* `J_FOCUS_POLICY_REJECT`: The widget does not receive keyboard input and is ignored for the purposes of input handling (its children are not ignored though). This is the default and is usually overridden at creation by `jwidget_set_focus_policy()`.
+* `J_FOCUS_POLICY_ACCEPT`: The widget receives keyboard input and keeps it to itself, not allowing any children to get it. Children will not see any events unless the widget's event function decides to forward them.
+* `J_FOCUS_POLICY_SCOPE`: The widget can receive focus but also allows a child to get focus. In this case, events that the child is not interested in will be offered to the scope widget.
+
+Additionally, widgets have three focus states defined by two status flags `FOCUSED` and `ACTIVE_FOCUSED`:
+
+* No focus - `FOCUSED=0`
+* Inactive focus - `FOCUSED=1`, `ACTIVE_FOCUSED=0`
+* Active focus - `FOCUSED=1`, `ACTIVE_FOCUSED=1`
+
+Roughly speaking, active focus means the widget currently receives input, whereas inactive focus means the widget has focus within a parent that is inactive. For instance, an input field within a tab that is currently invisible would have inactive focus. If the tab becomes visible, the input field gets active focus. Inactive focus essentially remembers who had focus while certain parts of the interface are not being used.
+
+Each widget w with the `SCOPE` policy defines a region called a *focus scope*, which is essentially the widgets whose focus is managed by w. This region consists of w's subtree, excluding w itself and any children of other focus scopes.
+
+The fact that w can transmit its focus to a child is formalized as follows. Within the scope, up to one widget with policy `ACCEPT` or `SCOPE` can have its `FOCUSED` flag set and this widget is called the *focus target* of the scope. The focus target has the same value for the `ACTIVE_FOCUSED` flag as w.
+
+If the focus target is also a scope, it may itself have a target. Thus, each scope induces a *focus chain* FC, defined mathematically by
+
+* `FC(w) = []` if w is not a scope or has no target;
+* `FC(w) = FC(target) + [target]` if w is a scope with the given target.
+
+The elements of the chain are exactly the children of w that have their `FOCUSED` flag set, and they all have the same value for `ACTIVE_FOCUSED` as w.
+
+`jscene`, where focus originates, is a scope and is defined to have its `ACTIVE_FOCUSED` flag set at all times (the only widget that doesn't inherit this flag from a scope parent).  Thus, the `ACTIVE_FOCUSED` flag identifies the focus chain of the scene. When given an event, `jscene` offers it to all of the elements of its focus chain, starting from the deepest children and then to the parents, until one accepts the event.
+
+TODO: Diagram! It's not straightforward.
+
+Related functions:
+
+```c
+// Set the focus policy of a widget (usually when created, possible anytime)
+void jwidget_set_focus_policy(void *w, jwidget_focus_policy_t fp);
+// Check if a widget has any (inactive or active) focus
+bool jwidget_has_focus(void *w);
+// Check if a widget has active focus, i.e., receives keyboard events right now
+bool jwidget_has_active_focus(void *w);
+```
+
+### Operations
+
+**Changing the target of a scope**
+
+Focus can moved by changing the target of a scope. When this happens:
+
+- The old target, if any, loses its `FOCUSED` and `ACTIVE_FOCUSED` flags. If it's a scope and it had active focus, all widgets in its focus chain also lose active focus.
+- The new target, if any, gets its `FOCUSED` flag and the scope's value for the `ACTIVE_FOCUSED` flag. If it's a focus scope and it gets active focus, then its focus chain also gets active focus.
+
+All widgets affected receive a `JWIDGET_FOCUS_CHANGED` event and the scope itself receives a `JWIDGET_FOCUS_TARGET_CHANGED` event.
+
+```c
+// Set the target of a focus scope.
+void jwidget_scope_set_target(void *fs, void *target);
+// Get the current target of a focus scope (may be NULL).
+jwidget *jwidget_scope_get_target(void *fs);
+// Remove the current target (same as setting NULL).
+void jwidget_scope_clear_focus(void *fs);
+```
+
+**Giving a widget active focus**
+
+There is a scene function to give a widget active focus.
+- If the widget has policy `ACCEPT` or `SCOPE`, this function gives active focus to all of its sopce ancestors until it reaches the scene.
+- If the widget is `NULL`, this call just removes the surrounding scope's target.
+- [TODO] If the widget has policy `REJECT`, it clears scopes from that widget up until reaching the scene.
+
+**Relinquishing focus**
+
+[TODO] It is intended that there by a widget-context function to relinquish one's own focus within the parent scope. This is intended to allow scopes to implement special logic for moving focus to a nearby widget automatically.
+
+**Widget-context and global scene functions**
+
+Most functions on widgets ignore the widget's surroundings, such as its parents (or lack thereof). Widget-context functions are all the functions on widgets that *do* depend on the widget's surroundings.
+
+```c
+// Widget's enclosing scope (may be NULL, but not if there's a jscene).
+jwidget *jwidgetctx_enclosing_focus_scope(void *w);
+// Grab focus for w within enclosing scope.
+void jwidgetctx_grab_focus(void *w);
+// Drop focus from w (if it has it) within enclosing scope.
+void jwidgetctx_drop_focus(void *w);
+```
+
+Additionally, a few global functions are available at the scene level. If you're not sure how to proceed: `jscene_show_and_focus(w)` is the easy way to give focus to a widget `w` and it will do what you want most of the time.
+
+```c
+// Widget at the end of the focus chain of the scene.
+void *jscene_focused_widget(jscene *scene);
+// Active-focus the given widget and all its enclosing scopes.
+void jscene_set_focused_widget(jscene *scene, void *widget);
+// Active-focus the given widget and make sure it's visible.
+void jscene_show_and_focus(jscene *scene, void *widget);
+```
+
+### Key-listener pattern
+
+The operations described above allow a "key-listener" pattern where a widget KL (not the scene) receives keyboard events from its potentially-focused descendants (i.e. inserts itself in the focus chain) without impacting the focus mechanics of its surrounding scope SS.
+
+The pattern consists of making KL a focus scope, and whenever it receives a `FOCUS_TARGET_CHANGED` event that assigns a target, make KL grab focus within SS. This way, with regards to SS, when focus moves:
+* From within KL to within KL: the grab is a no-op: OK.
+* From within KL to outside it: outside widget gets focus within SS and KL does nothing: OK.
+* From outside KL to within it: inside widget gets focus in KL, KL gets focus in SS: OK.
+* From outside KL to outside it: KL is not involved: OK.
+
+[TODO] Should this be a built-in behavior?
+
+## Behavior of built-in widgets
+
+- `jfileselect`, `jinput`, `jlist` have policy `ACCEPT`
+- `jscene`, `jscrolledlist` have policy `SCOPE`
+- `jfkeys` has policy `REJECT` and must be given events manually (awkward)
+- [TODO] Widgets with a stack layout will try and give focus (within their surrounding scope) to the current element. If the element is complex, it should be a focus scope. Similarly, widgets with invisible children will move focus around to their direct children as needed to make sure focus remains on a visible child.

doc/widgets.md

@@ -21,15 +21,15 @@ compromise to work with polymorphic types in the C type system.
 and layout](layout.md)) and size constraints, geometry (margin, border,
 padding, background), and automatic repaint/relayout mechanisms.
 
-**`jlabel`** is a content widget that shows a single-line or multi-line piece
-of text. It supports various text alignment options (left/right/center), line
-wrapping (letter and word level), and a couple of graphical options.
-
 **`jscene`** is a special widget designed to be at the root of the widget tree.
 It provides event dispatching, automatic repaint and layout, keyboard input,
 and a generic input loop that is suitable for most GUI programs. See [Scenes
 and events](scene.md).
 
+**`jlabel`** is a content widget that shows a single-line or multi-line piece
+of text. It supports various text alignment options (left/right/center), line
+wrapping (letter and word level), and a couple of graphical options.
+
 **`jinput`** is a one-line input field. It supports direct key input, delayed
 and instant SHIFT and ALPHA modifiers, as well as modifier locking, with visual
 hints.
@@ -44,6 +44,20 @@ screen. On fx-9860G, it uses an image to show keys; on fx-CG 50, it supports a
 string specification that looks like `"@JUMP;;#ROM;#RAM;#ILRAM;#ADDIN"`. It can
 change options dynamically.
 
+**`jframe`** is a scrolling frame. It contains a single child widget that's
+larger than the frame, scrolls it around, renders scrollbars, and ensures that
+the child widget's rendering is clipped to the frame.
+
+**`jlist`** and **`jscrolledlist`** are browsable lists. The list model is not
+forced; the user provides an info function (indicating which elements can be
+selected and triggered) and a paint function for rendering them. Custom
+rendering is possible at any point and delegate widgets for edition can also be
+specified. `jscrolledlist` is a `jlist` in a `jframe`, which provides scrolling
+and is usually what one wants.
+
+**`jfilebrowser`** is a `jlist`-like file browser which is used to open and
+save files in applications.
+
 ## Custom widgets and polymorphic operations
 
 For custom widgets that just have custom rendering a no event management, one
@@ -125,20 +139,13 @@ static jwidget_poly type_jcounter = {
 
 static int jcounter_type_id;
 
-__attribute__((constructor(2001)))
+__attribute__((constructor))
 static void j_register_jcounter(void)
 {
-	jcounter_type_id = j_register_widget(&type_jcounter, "jwidget");
+	jcounter_type_id = j_register_widget(&type_jcounter);
 }
 ```
 
-The second parameter to `j_register_widget()` specifies inheritance. `jcounter`
-inherits from `jwidget`, which means that the unspecified polymorphic functions
-(`layout`, `event` and `destroy`) will use the default behavior of `jwidget`.
-This is mostly useful if you don't specify `csize` (the default behavior is to
-select the smallest size where all children fit) or `render` (the default
-behavior is to render all visible children).
-
 The type ID returned by `j_register_widget()` is how JustUI differentiates
 labels from input fields from custom counters. When creating the widget, you
 should initialize the `jwidget` field with `jwidget_init()` and specify the

include/justui/jevent.h

@@ -9,6 +9,7 @@
 #include <justui/jwidget.h>
 
 #include <gint/keyboard.h>
+#include <gint/defs/attributes.h>
 
 /* jevent: GUI event
 
@@ -49,4 +50,20 @@ typedef struct {
 
 } jevent;
 
+/* Check if an event is a key press of the specified key with modifiers. */
+GINLINE static bool jevent_is_press_mods(
+   jevent e, int key, bool shift, bool alpha) {
+   return e.type == JWIDGET_KEY
+      && (e.key.type == KEYEV_DOWN || e.key.type == KEYEV_HOLD)
+      && e.key.key == key
+      && e.key.shift == shift
+      && e.key.alpha == alpha;
+}
+
+#define jevent_is_press(E, KEY) jevent_is_press_mods(E, KEY, false, false)
+#define jevent_is_shift_press(E, KEY) jevent_is_press_mods(E, KEY, true, false)
+#define jevent_is_alpha_press(E, KEY) jevent_is_press_mods(E, KEY, false, true)
+#define jevent_is_shift_alpha_press(E, KEY) \
+   jevent_is_press_mods(E, KEY, true, true)
+
 #endif /* _J_EVENT */

include/justui/jfileselect.h

@@ -30,6 +30,8 @@ typedef struct {
     void *entries;
     /* Number of entries in the current folder */
     int entry_count;
+    /* Error code for loaded folder */
+    int folder_error;
 
     /* Full path to file last selected with EXE */
     char *selected_file;

include/justui/jfkeys.h

@@ -9,6 +9,7 @@
 #include <justui/jwidget.h>
 
 #include <gint/display.h>
+#include <gint/config.h>
 
 /* jfkeys: Functions keys indicating functions for the F1..F6 keys
 
@@ -32,33 +33,39 @@
      that should catch attention, or particularly unsafe actions. They are
      round white keys.
 
-   On fx-CG 50, the keys are drawn dynamically using gint's default font, and
-   specified using 6 strings that give the type and name of the keys:
+   The more flexible option to draw the keys is dynamically with text. In that
+   case each key are specified with a strings that combines a type and name:
 
    * "/NAME" for a menu key;
    * ".NAME" for an entry key;
    * "@NAME" for an action key;
-   " "#NAME" for a special key.
+   * "#NAME" for a special key.
 
    The names are separated by semicolons, eg. "/F1;;/F3;.F4;@F5;#F6". Several
    sets of function keys can be defined if separated by a '|' character. For
    instance, "/F1;#F2|/F1" represents a function bar where the F2
    function can be hidden by switching from level 0 to level 1.
 
-   On fx-9860G, there is not enough space to generate keys on-the-fly, so the
-   full specification is just an image. The convention for the image is to be
-   128x8 pixels, with each function key (i) positioned at (x = 21*i + 2) of
-   width 19. Several levels can be stacked up (n levels in an image of height
-   9n-1) and selected independently. */
+   The other option is to draw the keys with an image. This is most useful at
+   small resolutions where hand-drawn keys often look better. On the fx-9860G
+   with its 128x64 resolution, the convention is that the image is 128x8, and
+   key #i is positioned at x = 21i+2 with width 19. The equivalent of "|"-
+   separated levels is allowed by stacking up rows of keys (in which case the
+   image is of height 9n-1 for n rows).
+
+   jkfeys will gobble keyboard events for F1..F6 and emit JFKEYS_TRIGGERED
+   events instead. However, in general jfkeys doesn't have keyboard focus, so
+   you have to give the events manually. */
 typedef struct {
 	jwidget widget;
 	int8_t level;
 
-	#ifdef FX9860G
-	bopti_image_t const *img;
-	#endif
+	/* Image version; if specified this overrides all text parameters */
+
+	bopti_image_t const *img;
+
+	/* Text version */
 
-	#ifdef FXCG50
 	char const *labels;
 	char const *overrides[6];
 
@@ -66,39 +73,32 @@ typedef struct {
 	int text_color, text_special_color;
 
 	font_t const *font;
-	#endif
 
 } jfkeys;
 
-/* jfkeys_create(): Create a set of function keysed
+/* Events */
+extern uint16_t JFKEYS_TRIGGERED;
 
-   The arguments are obviously different on fx-9860G and fx-CG 50. If your
-   application supports both, you might want to specify arguments for both
-   platforms in a single call with jfkeys_create2() which will filter them out
-   for you. Referencing an image unavailable on fx-CG 50 in jfkeys_create2() is
-   safe since the preprocessor will remove that text. */
+/* jfkeys_create2(): Create a set of function keys
 
-#ifdef FX9860G
-jfkeys *jfkeys_create(bopti_image_t const *img, void *parent);
-#define jfkeys_create2(img, labels, parent) jfkeys_create(img, parent)
-#endif
+   Both the image and text specification are provided; one of them should
+   generally be NULL (if both are non-NULL, the image takes precedence). For
+   historical reasons the name fkeys_create() is a one-argument version with
+   either the text or image depending on the platform. */
+jfkeys *jfkeys_create2(
+   bopti_image_t const *img, char const *labels, void *parent);
 
-#ifdef FXCG50
-jfkeys *jfkeys_create(char const *labels, void *parent);
-#define jfkeys_create2(img, labels, parent) jfkeys_create(labels, parent)
-#endif
-
-/* jfkeys_set(): Replace functions
+/* jfkeys_set2(): Replace the definition of function keys
    This will also reset the level to 0. */
+void jfkeys_set2(jfkeys *keys, bopti_image_t const *img, char const *labels);
 
-#ifdef FX9860G
-void jfkeys_set(jfkeys *keys, bopti_image_t const *img);
-#define jfkeys_set2(keys, img, labels) jfkeys_set(keys, img)
-#endif
-
-#ifdef FXCG50
-void jfkeys_set(jfkeys *keys, char const *labels);
-#define jfkeys_set2(keys, img, labels) jfkeys_set(keys, labels)
+/* Deprecated platform-specific shortcuts */
+#if GINT_RENDER_MONO
+# define jfkeys_create(img, parent) jfkeys_create2(img, NULL, parent)
+# define jfkeys_set(keys, img) jfkeys_set2(keys, img, NULL)
+#elif GINT_RENDER_RGB
+# define jfkeys_create(labels, parent) jfkeys_create2(NULL, labels, parent)
+# define jfkeys_set(keys, labels) jfkeys_set2(keys, NULL, labels)
 #endif
 
 /* jfkeys_level(): Return the current function key level */

include/justui/jinput.h

@@ -11,6 +11,9 @@
 
 #include <gint/display.h>
 
+/* Keymap function for jinput. See jinput_set_keymap_function(). */
+typedef uint32_t jinput_keymap_function_t(int key, bool shift, bool alpha);
+
 /* jinput: One-line input field
 
    This widget is used to read input from the user. It has a single line of
@@ -63,6 +66,9 @@ typedef struct {
 	/* Timer ID for the cursor state */
 	int8_t timer;
 
+	/* Custom keymap function (may be NULL) */
+	jinput_keymap_function_t *keymap_fun;
+
 } jinput;
 
 /* Type IDs */
@@ -81,6 +87,15 @@ void jinput_set_text_color(jinput *input, int color);
 void jinput_set_font(jinput *input, font_t const *font);
 void jinput_set_prompt(jinput *input, char const *prompt);
 
+/* Set a custom keymap function. The keymap function is called when a key is
+   pressed that should produce input in the field. The following parameters are
+   provided:
+   * key is the code for the pressed key (<gint/keycodes.h>)
+   * shift and alpha indicate the state of modifiers
+   The function should return a Unicode code point. Note that jinput can deal
+   with any Unicode code point but the font used for the jinput might not! */
+void jinput_set_keymap_function(jinput *input, jinput_keymap_function_t *kf);
+
 /* Current value visible in the widget, normally useful upon receiving the
    JINPUT_VALIDATED event, not guaranteed otherwise */
 char const *jinput_value(jinput *input);

include/justui/jlabel.h

@@ -67,7 +67,7 @@ typedef struct {
 	jalign block_valign;
 	/* Text alignment */
 	jalign text_align;
-	/* Pixels of spacing between each line, in addition to font->height */
+	/* Pixels of spacing between lines, in addition to font->line_distance */
 	int8_t line_spacing;
 
 	/* Text to display */
@@ -76,12 +76,16 @@ typedef struct {
 	   of line number n */
   DECLARE_VEC(uint16_t, breaks);
 
+	/* Block width (maximum length of a rendered line) */
+	uint16_t block_width;
 	/* Text wrapping mode */
 	enum jwrapmode wrap_mode;
 	/* Whether the text has been allocated by the label or supplied by user */
-	int8_t owns_text;
-	/* Block width (maximum length of a rendered line) */
-	uint16_t block_width;
+	bool owns_text                :1;
+	/* Whether to preserve spaces around line-wrapping newlines */
+	bool wrapped_newline_spacing  :1;
+
+	uint                          :5;
 
 	/* Color and font of text; if NULL, gint's default font is used */
 	int color;
@@ -130,5 +134,6 @@ void jlabel_set_line_spacing(jlabel *l, int line_spacing);
 void jlabel_set_wrap_mode(jlabel *l, jwrapmode mode);
 void jlabel_set_text_color(jlabel *l, int color);
 void jlabel_set_font(jlabel *l, font_t const *font);
+void jlabel_set_wrapped_newline_spacing(jlabel *l, bool preserve);
 
 #endif /* _J_JLABEL */

include/justui/jlist.h

@@ -9,10 +9,12 @@
 #include <justui/jwidget.h>
 
 typedef enum {
+    /* Selected item is styled by the paint function or delegate */
+    JLIST_SELECTION_MANUAL = 0,
     /* Selected item is indicated by inverting its rendered area */
-    JLIST_SELECTION_INVERT = 0,
+    JLIST_SELECTION_INVERT = 1,
     /* Selected item is indicated by applying a background color */
-    JLIST_SELECTION_BACKGROUND = 1,
+    JLIST_SELECTION_BACKGROUND = 2,
 
 } jlist_selection_style;
 
@@ -23,6 +25,10 @@ typedef struct {
     bool selectable;
     /* Whether item can be triggered */
     bool triggerable;
+    /* Selection style for jlist to draw */
+    int8_t selection_style;
+    /* Selection background color for JLIST_SELECTION_BACKGROUND */
+    uint16_t selection_bg_color;
 
     /* The following fields are only applicable if there is no delegate. */
 
@@ -33,9 +39,16 @@ typedef struct {
 
 struct jlist;
 
+/* Info function: should fill `info` with the data related to list element
+   #index (starts at 0). `info` is guaranteed to be pre-initialized to 0. */
 typedef void (*jlist_item_info_function)(struct jlist *list, int index,
     jlist_item_info *info);
 
+/* Paint function: should draw element #index on the rectangle of size `w×h`
+   at position `x,y`. If the item has a selection style that is not
+   JLIST_SELECTION_MANUAL, the selection effect is handled by jlist. Otherwise,
+   the paint function should check the `selected` parameter to apply any
+   relevant styling. */
 typedef void (*jlist_item_paint_function)(int x, int y, int w, int h,
     struct jlist *list, int index, bool selected);
 
@@ -64,6 +77,8 @@ typedef struct jlist {
 
     /* Currently selected item, -1 if none */
     int cursor;
+    /* User data pointer */
+    void *user;
 
 } jlist;
 
@@ -73,13 +88,14 @@ extern uint16_t JLIST_SELECTION_MOVED;
 extern uint16_t JLIST_MODEL_UPDATED;
 
 /* jlist_create(): Create a new (empty) jlist. */
-jlist *jlist_create(void *parent, jlist_item_info_function info_function,
-    jlist_item_paint_function paint_function);
+jlist *jlist_create(jlist_item_info_function info_function,
+    jlist_item_paint_function paint_function, void *parent);
 
 /* jlist_update_model(): Update jlists's information about the model
    The new model size is passed as parameter. The model is refreshed by
-   repeatedly calling the info function. */
-void jlist_update_model(jlist *l, int item_count);
+   repeatedly calling the info function. The user pointer is also updated. To
+   keep it unchanged, pass `l->user` as third parameter. */
+void jlist_update_model(jlist *l, int item_count, void *user);
 
 /* jlist_clear(): Remove all items */
 void jlist_clear(jlist *l);

include/justui/jpainted.h

@@ -7,7 +7,6 @@
 
 #include <justui/defs.h>
 #include <justui/jwidget.h>
-#include <justui/jwidget-api.h>
 
 /* jpainted: Simple widget designed to integrate low-effort rendering
 

include/justui/jscene.h

@@ -21,8 +21,6 @@ typedef struct {
 
 	/* Location on screen */
 	int16_t x, y;
-	/* Widget with focus */
-	jwidget *focus;
 
    /* Circular event queue */
    jevent queue[JSCENE_QUEUE_SIZE];
@@ -33,13 +31,16 @@ typedef struct {
    uint16_t lost_events;
    /* Whether jscene_run() returns to the main menu */
    bool mainmenu;
+   /* Whether jscene_run() powers off */
+   bool poweroff;
+   /* Whether jscene_run() will autopaint */
+   bool autopaint;
 
 } jscene;
 
 /* Events */
 extern uint16_t JSCENE_NONE;
 extern uint16_t JSCENE_PAINT;
-extern uint16_t JSCENE_KEY; /* Deprecated, merged with JWIDGET_KEY */
 
 /* jscene_create(): Create a new scene at that specified screen position */
 jscene *jscene_create(int x, int y, int w, int h, void *parent);
@@ -110,6 +111,23 @@ bool jscene_process_event(jscene *scene, jevent event);
    resources before invoking the main menu. */
 void jscene_set_mainmenu(jscene *scene, bool mainmenu);
 
+/* jscene_set_poweroff(): Set whether jscene_run() will poweroff
+   This type of poweroff (SHIFT+AC/ON) doesn't allow return to menu, so the
+   add-in "must" resume after powering on again, however sensitive programs
+   will probably want to save important data before leaving anyway. */
+void jscene_set_poweroff(jscene *scene, bool poweroff);
+
+/* jscene_set_autopaint(): Set whether jscene_run() handles its own painting
+
+   This will automatically handle JSCENE_PAINT events by drawing the scene
+   widget and updating the screen. You should use this only if the scene is the
+   only thing to draw; don't overdraw after this. If you have things to draw
+   not handled by jscene, handle JSCENE_PAINT yourself.
+
+   When enabling autopaint, you should also set a background color for the
+   scene, otherwise frames will draw transparently on top of each other. */
+void jscene_set_autopaint(jscene *scene, bool autopaint);
+
 /* jscene_run(): Run a scene's main loop
 
    This function implements a main control loop that sleeps when there is

include/justui/jscrolledlist.h

@@ -25,9 +25,10 @@ typedef struct {
 
 } jscrolledlist;
 
-/* jscrolledlist_create(): Create a scrolled list */
-jscrolledlist *jscrolledlist_create(void *parent,
+/* Create a scrolled list; arguments are forwarded to the jlist. */
+jscrolledlist *jscrolledlist_create(
     jlist_item_info_function info_function,
-    jlist_item_paint_function paint_function);
+    jlist_item_paint_function paint_function,
+    void *parent);
 
 #endif /* _J_JSCROLLEDLIST */

include/justui/jwidget-api.h

@@ -6,6 +6,7 @@
 #define _J_JWIDGET_API
 
 #include <justui/defs.h>
+#include <justui/p/preproc.h>
 #include <justui/jevent.h>
 #include <gint/keyboard.h>
 
@@ -28,7 +29,13 @@
 
    Implementations of this function should use jwidget_msize() on the children
    to position their margin box within the widget's content box. The size set
-   by this function needs not be in the minimum/maximum range of the widget. */
+   by this function needs not be in the minimum/maximum range of the widget,
+   which is handled later.
+
+   If not overloaded (i.e. NULL in the poly structure), the default behavior is
+   to compute the smallest size that fits all children (based on their own
+   natural content size), which only makes sense if the children are at fixed
+   positions. */
 typedef void jwidget_poly_csize_t(void *w);
 
 /* jwidget_poly_layout_t: Layout a widget after its size has been set
@@ -37,25 +44,45 @@ typedef void jwidget_poly_csize_t(void *w);
    the widget has no layout. The margin-box size allocated to the widget has
    been set in (w->w) and (w->h); the widget must now position its contents and
    children. If the widget has a layout, the layout's specialized function is
-   called instead of this one. */
+   called instead of this one.
+
+   Custom positioning for children is only relevant for widgets that use custom
+   layouts, which is fairly rare. Most often, this function is used to position
+   internal elements of the widget after the size has been set (e.g. jlabel
+   computes line breaks here).
+
+   If not overloaded (i.e. NULL in the poly structure), the default behavior is
+   to leave children's positions unchanged, assuming they are fixed. */
 typedef void jwidget_poly_layout_t(void *w);
 
 /* jwidget_poly_render_t: Render a widget
 
    This function is called during rendering after the widget's geometry is
    drawn. (x,y) are the coordinates of the content box. This function must
-   render widget-specific visuals; there is no clipping, so the widget should
-   honor its width and height.
+   render widget-specific visuals. If the widget is clipped (as specified by
+   `jwidget_set_clipped()`), this function can specify any drawing coordinates
+   and all drawing will automatically be restricted with the widget's box.
+   However, if the widget is not clipped, drawing beyond the widget's width and
+   height will overflow to other widgets.
 
-   This function should call jwidget_render() for all children that need to be
-   rendered. jwidget_render() handles the geometry and takes as parameters the
-   coordinates of the margin box, so it can be called as:
+   This function should render its children. In the simple case where all
+   children can be rendered at the same time, you can simply call
+   `jwidget_poly_render(w)` which will do that.
+
+   If for any reason children need to be rendered separately, this function can
+   also called `jwidget_render()` on individual children. `jwidget_render()`
+   handles the geometry and takes as parameters the coordinates of the margin
+   box, so it can be called as:
 
      jwidget_render(child, x + child->x, y + child->y).
 
    It will draw the geometry and call the polymorphic renderer of the child at
-   its content-box coordinates. Normally you can ignore geometry altogether. */
+   its content-box coordinates. Normally you can ignore geometry altogether.
+
+   If not overloaded, the behavior is `jwidget_poly_render(w)`, i.e. just
+   render the children if there are any. */
 typedef void jwidget_poly_render_t(void *w, int x, int y);
+extern jwidget_poly_render_t jwidget_poly_render;
 
 /* jwidget_poly_event_t: Handle an event
 
@@ -63,22 +90,32 @@ typedef void jwidget_poly_render_t(void *w, int x, int y);
    key events. This function is somewhat of a catch-all function for dynamic
    occurrences. The widget should either accept the event, do something with
    it, and return true, or refuse the event, do nothing and return false. This
-   influences events that propagate, such as key events. */
+   influences events that propagate, such as key events.
+
+   This function should always default to
+
+       return jwidget_poly_event(w, e);
+
+   to allow default/generic behaviors to propagate, unless the widget
+   explicitly wants to interfere with them. */
 typedef bool jwidget_poly_event_t(void *w, jevent e);
+extern jwidget_poly_event_t jwidget_poly_event;
 
 /* jwidget_poly_destroy_t: Destroy a widget's specific resources
 
    This function must destroy the widget-specific resources. It is called by
    jwidget_destroy(), which follows it by freeing the widget's standard data
    and destroying the children. This function can be NULL if there are no
-   widget-specific resources to free. */
+   widget-specific resources to free. It should not call the "base" version of
+   the function. */
 typedef void jwidget_poly_destroy_t(void *w);
 
 /* jwidget_poly: Polymorphic interface for a widget type */
 typedef struct {
 	/* Type name, used for display and inheritance */
 	char const *name;
-	/* Polymorphic functions */
+	/* Polymorphic functions. If unused for custom widgets, should be set to
+	   NULL and the default behavior (described above) will apply. */
 	jwidget_poly_csize_t   *csize;
 	jwidget_poly_layout_t  *layout;
 	jwidget_poly_render_t  *render;
@@ -95,13 +132,8 @@ typedef struct {
 
    This function returns a new widget type ID to pass to jwidget_init() when
    creating widgets of the custom type. Returns -1 if registration fails. The
-   polymorphic structure must outlive all widgets of the custom type.
-
-   If (inherits) is non-NULL, the new type will inherit from the widget type
-   with the provided name. All NULL functions in (poly) will be replaced by the
-   parent type's functions. This mechanism only works if widgets are declared
-   in inheritance order, which is normally enforced by constructor priority. */
-int j_register_widget(jwidget_poly *poly, char const *inherits);
+   polymorphic structure must outlive all widgets of the custom type. */
+int j_register_widget(jwidget_poly *poly);
 
 /* j_register_event(): Register a new event type
 
@@ -155,4 +187,52 @@ void jwidget_emit(void *w, jevent e);
    notify it of the specified event. */
 bool jwidget_event(void *w, jevent e);
 
+/* Helper macro for defining a new widget. Parameters are:
+   - Widget NAME
+   - Variadic list of overridden widget poly METHODs, can be empty
+   - Implicity, non-static poly functions `<NAME>_poly_<METHOD>`
+   And it defines:
+   - The `NAME_type_id` identifier for use with `jwidget_init()`
+   - A constructor that registers the widget and sets `NAME_type_id`.
+
+   For example:
+   ```
+   J_DEFINE_WIDGET(jpainted, csize, render)
+   ```
+
+   gets the functions `jpainted_poly_csize` and `jpainted_poly_render` from
+   context, registers the type at startup and provides `jpainted_type_id` for
+   the widget creation function. */
+#define J_DEFINE_WIDGET(NAME, ...) \
+    static int NAME##_type_id = -1; \
+    J_REPEAT(J_DEFINE_WIDGET_POLY_PROTO, (NAME), __VA_ARGS__) \
+    static jwidget_poly type_##NAME = { \
+        .name = #NAME, \
+        J_REPEAT(J_DEFINE_WIDGET_POLY, (NAME), __VA_ARGS__) \
+    }; \
+    __attribute__((constructor)) \
+    static void j_register_##NAME(void) { \
+        NAME##_type_id = j_register_widget(&type_##NAME); \
+    }
+#define J_DEFINE_WIDGET_POLY(NAME, METHOD) \
+    .METHOD = NAME##_poly_##METHOD,
+#define J_DEFINE_WIDGET_POLY_PROTO(NAME, METHOD) \
+    extern jwidget_poly_##METHOD##_t NAME##_poly_##METHOD;
+
+/* Helper macro for defining new events. Each parameter is an event name to
+   define, e.g.
+
+   ```
+   J_DEFINE_EVENTS(MYWIDGET_EVENT1, MYWIDGET_EVENT2, MYWIDGET_EVENT3)
+   ``` */
+#define J_DEFINE_EVENTS(...) \
+    uint16_t __VA_ARGS__; \
+    __attribute__((constructor)) \
+    static void J_DEFINE_EVENTS_NAME(__COUNTER__)(void) { \
+        J_REPEAT(J_DEFINE_EVENTS_INIT, (), __VA_ARGS__) \
+    }
+#define J_DEFINE_EVENTS_NAME2(COUNTER) _j_init_##COUNTER
+#define J_DEFINE_EVENTS_NAME(COUNTER) J_DEFINE_EVENTS_NAME2(COUNTER)
+#define J_DEFINE_EVENTS_INIT(EVENT) EVENT = j_register_event();
+
 #endif /* _J_JWIDGET_API */

include/justui/jwidget.h

@@ -67,6 +67,9 @@ typedef struct jwidget {
 		jlayout_grid  layout_grid;
 	};
 
+	/* Focused subwidget for focus scopes */
+	struct jwidget *focus_scope_target;
+
 	/* Widget type, used to find polymorphic operations */
 	uint8_t type;
 	/* Number of children */
@@ -91,8 +94,13 @@ typedef struct jwidget {
 	uint floating       :1;
 	/* Widget is clipped during rendering */
 	uint clipped        :1;
+	/* Focus policy */
+	uint focus_policy   :2;
+	/* Focus flags */
+	uint focused        :1;
+	uint active_focused :1;
 
-	uint :22;
+	uint :18;
 
 } jwidget;
 
@@ -106,6 +114,17 @@ typedef enum {
 
 } jwidget_border_style;
 
+/* jwidget_focus_policy: Options for receiving and handling keyboard focus */
+typedef enum {
+	/* The widget does not accept focus or interact with keyboard (default) */
+	J_FOCUS_POLICY_REJECT,
+	/* The widget accepts keyboard input and hides it from descendants */
+	J_FOCUS_POLICY_ACCEPT,
+	/* The widget accepts keyboard focus and forwards it to a descendant */
+	J_FOCUS_POLICY_SCOPE,
+
+} jwidget_focus_policy_t;
+
 /* jwidget_geometry: Built-in positioning and border geometry
 
    Every widget has a "geometry", which consists of a border and two layers of
@@ -143,14 +162,13 @@ typedef struct jwidget_geometry {
 
 } jwidget_geometry;
 
-/* Downwards key event: widget is notified of a key press that ocurred while it
-   had active focus.
+/* Key press event; the widget has active focus and a key was pressed.
     -> .data.key: Key event */
 extern uint16_t JWIDGET_KEY;
-/* Downwards focus-in event: the widget has just received focus */
-extern uint16_t JWIDGET_FOCUS_IN;
-/* Downwards focus-out event: the widget has just lost focus */
-extern uint16_t JWIDGET_FOCUS_OUT;
+/* The widget's focus state (either .focused or .active_focused) changed. */
+extern uint16_t JWIDGET_FOCUS_CHANGED;
+/* The widget is a scope and its target changed. */
+extern uint16_t JWIDGET_FOCUS_TARGET_CHANGED;
 
 //---
 // Creation and destruction
@@ -395,6 +413,53 @@ bool jwidget_needs_update(void *w);
    widgets if there has been changes. */
 void jwidget_render(void *w, int x, int y);
 
+//---
+// Keyboard focus
+//---
+
+/* Change the widget's focus policy. This is usually done in the constructor
+   but can be done anytime. If the policy is changed to JWIDGET_FOCUS_REJECT
+   while the widget has focus, the focus will be lost. */
+void jwidget_set_focus_policy(void *w, jwidget_focus_policy_t fp);
+
+/* Check whether a widget is currently focused within its surrounding scope. */
+GINLINE static bool jwidget_has_focus(void *w)
+{
+	return ((jwidget *)w)->focused;
+}
+/* Check whether a widget is current in the key event propagation chain. */
+GINLINE static bool jwidget_has_active_focus(void *w)
+{
+	return ((jwidget *)w)->active_focused;
+}
+
+/* Change the target of a focus scope widget. */
+void jwidget_scope_set_target(void *fs, void *target);
+
+/* Get the target of a focus scope, NULL if none or not a scope. */
+GINLINE static jwidget *jwidget_scope_get_target(void *fs)
+{
+	return ((jwidget *)fs)->focus_scope_target;
+}
+
+/* Clear the target of a focus scope widget. */
+GINLINE static void jwidget_scope_clear_focus(void *fs)
+{
+	return jwidget_scope_set_target(fs, NULL);
+}
+
+/* Context function that returns the immediately surrounding scope that owns
+   this widget, NULL if there's none. Since jscene is a scope, in general there
+   should always be one. */
+jwidget *jwidgetctx_enclosing_focus_scope(void *w);
+
+/* Context function that gives w focus within its enclosing focus scope. */
+void jwidgetctx_grab_focus(void *w);
+
+/* Context function that drops the focus from w (if it has it) within its
+   enclosing focus scope. */
+void jwidgetctx_drop_focus(void *w);
+
 //---
 // Misc
 //---

include/justui/p/preproc.h

@@ -0,0 +1,64 @@
+//---
+// JustUI.util.preproc: Preprocessor utilities
+//---
+
+#ifndef _J_UTIL_PREPROC
+#define _J_UTIL_PREPROC
+
+/* J_REPEAT: Dispatch a partially-evaluated macro call on each arg in a list
+   The call `J_REPEAT(X, C, V1, ..., VN)` where `C = (C1, ..., CM)` (with the
+   parentheses) is equivalent to the series of calls
+
+   ```
+   X(C1, ..., CM, V1)
+   X(C1, ..., CM, V2)
+   ...
+   X(C1, ..., CM, VN)
+   ```
+
+   and is used to iterate on lists. There is a size limit of N≤8. */
+#define J_REPEAT1(X, C, V1, ...) \
+    J_CALL(X, C, V1) __VA_OPT__(J_REPEAT2(X, C, __VA_ARGS__))
+#define J_REPEAT2(X, C, V2, ...) \
+    J_CALL(X, C, V2) __VA_OPT__(J_REPEAT3(X, C, __VA_ARGS__))
+#define J_REPEAT3(X, C, V3, ...) \
+    J_CALL(X, C, V3) __VA_OPT__(J_REPEAT4(X, C, __VA_ARGS__))
+#define J_REPEAT4(X, C, V4, ...) \
+    J_CALL(X, C, V4) __VA_OPT__(J_REPEAT5(X, C, __VA_ARGS__))
+#define J_REPEAT5(X, C, V5, ...) \
+    J_CALL(X, C, V5) __VA_OPT__(J_REPEAT6(X, C, __VA_ARGS__))
+#define J_REPEAT6(X, C, V6, ...) \
+    J_CALL(X, C, V6) __VA_OPT__(J_REPEAT7(X, C, __VA_ARGS__))
+#define J_REPEAT7(X, C, V7, ...) \
+    J_CALL(X, C, V7) __VA_OPT__(J_REPEAT8(X, C, __VA_ARGS__))
+#define J_REPEAT8(X, C, V8, ...) \
+    ({ __VA_OPT__(_Static_assert(0, \
+        "J_REPEAT: too many macro arguments (maximum 8)");) \
+    J_CALL(X, C, V8); })
+#define J_REPEAT(X, C, ...) __VA_OPT__(J_REPEAT1(X, C, __VA_ARGS__))
+
+/* J_CALL: Perform a call to a partially evaluated macro
+   The call `J_CALL(X, C, A1, ..., AN)` where `C = (C1, ..., CM)` (with the
+   parentheses) reduces to `X(C1, ..., CM, A1, ..., AN)`, i.e. it calls the
+   already-partially-applied `X(C)` with further arguments. Both M=0 (`C=()`)
+   and N=0 (no variadic arguments) are allowed.
+
+   The main difficulty is "unfolding" `C` into the arguments of `X`. This
+   problem is dealt with by absorbing the parentheses into an ID-function macro
+   call:
+
+   ```
+       J_ID C
+   ~>  J_ID (C1, ..., CM)
+   ~>  , C1, ..., CM
+  ```
+
+   From there, the only subtletly is gobbling the commas. We gobble the comma
+   before `J_ID C` if M=0 and the comma before the other arguments if N=0. This
+   requires a few expansion stages. */
+#define J_ID(...) __VA_OPT__(,) __VA_ARGS__
+#define J_CALL3(X, ...) X(__VA_ARGS__)
+#define J_CALL2(...) J_CALL3(__VA_ARGS__)
+#define J_CALL(X, C, ...) J_CALL2(X J_ID C, ##__VA_ARGS__)
+
+#endif /* _J_UTIL_PREPROC */

juic/builtins.py

@@ -0,0 +1,29 @@
+from juic.datatypes import *
+from juic.eval import *
+
+def juiPrint(*args):
+    print("[print]", *(juiValueString(a) for a in args))
+
+def juiLen(x):
+    if type(x) not in [str, list]:
+        raise JuiTypeError("len")
+    return len(x)
+
+R_record = RecordType("record", None)
+R_subrecord = RecordType("subrecord", R_record)
+R_jwidget = RecordType("jwidget", None)
+R_jlabel = RecordType("jlabel", R_jwidget)
+R_jfkeys = RecordType("jfkeys", R_jwidget)
+
+builtinClosure = Closure(parent=None, scope=MutableScopeData(defs={
+    "print": (0, BuiltinFunction(juiPrint)),
+    "len": (0, BuiltinFunction(juiLen)),
+
+    # TODO: Remove the built-in record type "record" used for testing
+    "record": (0, R_record),
+    "subrecord": (0, R_subrecord),
+    "jwidget": (0, R_jwidget),
+    "jlabel": (0, R_jlabel),
+    "jfkeys": (0, R_jfkeys),
+
+}, timestamp=1))

juic/datatypes.py

@@ -0,0 +1,195 @@
+from dataclasses import dataclass, field
+from typing import Callable, Union, TYPE_CHECKING
+import juic
+
+if TYPE_CHECKING:
+    import juic.eval
+
+# Mapping of Jui types to Python types:
+#   Null           None
+#   Booleans       bool
+#   Integers       int
+#   Floats         float
+#   Strings        str
+#   C/C++ refs     CXXQualid
+#   List           list
+#   "this"         ThisRef
+#   Functions      Function, BuiltinFunction
+#   Record types   RecordType
+#   Records        Record
+
+@dataclass
+class CXXQualid:
+    qualid: str
+
+@dataclass
+class BuiltinFunction:
+    func: Callable
+
+@dataclass
+class Function:
+    # Context in which the function gets evaluated
+    closure: "juic.eval.Closure"
+    # Expression node to evaluate when calling the function
+    body: "juic.parser.Node"
+    # Parameter names, must all be unique. May be empty
+    params: list[str] = field(default_factory=list)
+    # Name of variadic argument if one; must also be unique
+    variadic: str | None = None
+
+@dataclass
+class RecordType:
+    # Record name
+    name: str
+    # Base type for inheritance/subconstructor logic
+    base: Union[None, "RecordType"]
+
+    # TODO: Record prototypes?
+
+@dataclass
+class RecordCtor:
+    func: Function
+
+@dataclass
+class Record:
+    # A record type if it's pure, or a thunk with the base object otherwise.
+    base: Union[RecordType, "juic.eval.Thunk"]
+    # Standard key-value attribute pairs
+    attr: dict[str, Union["JuiValue", "juic.eval.Thunk"]]
+    # Children elements
+    children: list[Union["JuiValue", "juic.eval.Thunk"]]
+    # TODO: Keep track of variables that are not fields, i.e. "methods"?
+    # scope: dict[str, "JuiValue"]
+    # TODO: Labels
+    # labels: dict[str, "JuiValue"]
+
+JuiValue = Union[None, bool, int, float, str, CXXQualid, list,
+                 "juic.eval.PartialRecordSnapshot", BuiltinFunction, Function,
+                 RecordType, RecordCtor, Record]
+
+def juiIsArith(value):
+    return type(value) in [bool, int, float]
+
+def juiIsAddable(value):
+    return juiIsArith(value) or type(value) in [str, list]
+
+def juiIsComparable(value):
+    return type(value) in [None, bool, int, float, str]
+
+def juiIsLogical(value):
+    return type(value) == bool
+
+def juiIsUnpackable(value):
+    return type(value) == list
+
+def juiIsCallable(value):
+    return type(value) in [BuiltinFunction, Function]
+
+def juiIsProjectable(value):
+    return type(value) in [Record, juic.eval.PartialRecordSnapshot]
+
+def juiIsConstructible(value):
+    return type(value) in [RecordType, RecordCtor]
+
+def juiIsRecordUpdatable(value):
+    return type(value) == Record
+
+# Generic functions on values
+
+# String representation of a value
+def juiValueString(v):
+    match v:
+        case None:
+            return "null"
+        case bool():
+            return str(v).lower()
+        case int() | float():
+            return str(v)
+        case str():
+            return repr(v)
+        case CXXQualid():
+            return "&" + v.qualid
+        case list():
+            return "[" + ", ".join(juiValueString(x) for x in v) + "]"
+        case BuiltinFunction():
+            return str(v)
+        case Function() as f:
+            p = f.params + (["..." + f.variadic] if f.variadic else [])
+            s = "fun(" + ", ".join(p) + ") => " + str(f.body)
+            s += " (in some closure)"
+            return s
+        case RecordCtor() as rc:
+            f = rc.func
+            p = f.params + (["..." + f.variadic] if f.variadic else [])
+            s = "rec(" + ", ".join(p) + ") => " + str(f.body)
+            s += " (in some closure)"
+            return s
+        case RecordType() as rt:
+            return str(rt)
+        case Record() as r:
+            s = r.base.name + " {"
+            s += "; ".join(x + ": " + juiValueString(y) for x, y in r.attr.items())
+            if len(r.attr) and len(r.children):
+                s += "; "
+            s += "; ".join(juiValueString(x) for x in r.children)
+            return s + "}"
+            raise NotImplementedError
+        case juic.eval.Thunk() as th:
+            return str(th)
+        case juic.eval.PartialRecordSnapshot() as prs:
+            return str(prs)
+        case _:
+            raise NotImplementedError
+
+# Check whether two *forced* values are equal
+def juiValuesEqual(v1, v2):
+    def unwrapThunk(v):
+        match v:
+            case juic.eval.Thunk() as th:
+                assert th.evaluated and not th.invalid
+                return unwrapThunk(th.result)
+            case _:
+                return v
+
+    v1 = unwrapThunk(v1)
+    v2 = unwrapThunk(v2)
+    match v1, v2:
+        case None, None:
+            return True
+        case bool(), bool():
+            return v1 == v2
+        case int(), int():
+            return v1 == v2
+        case float(), float():
+            return v1 == v2
+        case str(), str():
+            return v1 == v2
+        case CXXQualid(), CXXQualid():
+            return v1.qualid == v2.qualid
+        case list() as l1, list() as l2:
+            return len(l1) == len(l2) and \
+                all(juiValuesEqual(v1, v2) for v1, v2 in zip(l1, l2))
+        case BuiltinFunction(), BuiltinFunction():
+            return id(v1) == id(v2)
+        case Function(), Function():
+            raise Exception("cannot compare functions")
+        case RecordType(), RecordType():
+            return id(v1) == id(v2)
+        case Record() as r1, Record() as r2:
+            if not juiValuesEqual(r1.base, r2.base):
+                return False
+            if r1.attr.keys() != r2.attr.keys():
+                return False
+            if any(not juiValuesEqual(r1.attr[k], r2.attr[k]) for k in r1.attr):
+                return False
+            if len(r1.children) != len(r2.children):
+                return False
+            if any(not juiValuesEqual(v1, v2)
+                   for v1, v2 in zip(r1.children, r2.children)):
+                return False
+            return True
+        case juic.eval.PartialRecordSnapshot(), \
+             juic.eval.PartialRecordSnapshot():
+            raise Exception("cannot compare PRSs")
+        case _, _:
+            raise Exception(f"invalid types for comparison: {type(v1)}, {type(v2)}")

juic/eval.py

@@ -0,0 +1,609 @@
+from dataclasses import dataclass, field
+from typing import Tuple, Union
+
+import juic.parser
+from juic.parser import Node
+from juic.datatypes import *
+
+# Storage of a scope's internal data, including all definitions in the scope.
+# The data in this object is never copied, so for instance, the name -> value
+# mappings are always unique and can only be found in the relevant's scope
+# unique MutableScopeData instance. This data is, of course, not constant,
+# which makes it unsuitable for building closures. The Closure type captures an
+# immutable snapshot of a scope's contents at one point in time.
+@dataclass
+class MutableScopeData:
+    # List of definitions. Each value has a timestamp integer that indicates
+    # when it was added; this allows snapshots to ignore definitions newer than
+    # the snapshot by simply comparing timestamp values. The value itself is
+    # either a thunk (evaluated or not), or a runtime value.
+    defs: dict[str, Tuple[int, Union[JuiValue, "Thunk"]]] = \
+        field(default_factory=dict)
+
+    # Current timestamp, changed every time a value is added.
+    timestamp: int = 0
+
+    def addDefinition(self, name: str, content: Union[JuiValue, "Thunk"]):
+        if name in self.defs:
+            raise JuiRuntimeError(f"{name} already defined in current scope")
+        self.defs[name] = (self.timestamp, content)
+        self.timestamp += 1
+
+    def lookup(self, name: str, maxTimestamp: int = -1) \
+            -> Union[JuiValue, "Thunk", None]:
+        if name not in self.defs:
+            return None
+        if maxTimestamp >= 0 and self.defs[name][0] >= maxTimestamp:
+            return None
+        return self.defs[name][1]
+
+    def dump(self):
+        digits = len(str(self.timestamp))
+        print(f"Scope: timestamp={self.timestamp}, defs:")
+        for name, (ts, content) in self.defs.items():
+            print(f"  {ts: >{digits}}  {name}:", juiValueString(content))
+
+# An immutable snapshot of all definitions that can be referred to at a given
+# point in time. This specifies the interpretation of all defined identifiers
+# but not of the "this" keyword.
+@dataclass
+class Closure:
+    # Parent snapshot on which this one is based, which defines the contents of
+    # surrounding scopes at that time.
+    parent: Union["Closure", None]
+    # Reference to the scope in which the closure was created.
+    scope: MutableScopeData
+    # Timestamp at which the closure was created. Definitions from `scope`
+    # created later than the closure will be ignored during name lookup.
+    timestamp: int = field(init=False)
+
+    def __post_init__(self):
+        # Automatically get the timestamp at the time of creation
+        self.timestamp = self.scope.timestamp
+
+    def lookup(self, name: str) -> Union[JuiValue, "Thunk", None]:
+        value = self.scope.lookup(name, self.timestamp)
+        if value is not None or self.parent is None:
+            return value
+        return self.parent.lookup(name)
+
+    def dump(self, level=0):
+        print(f"Closure at depth {level}: timestamp={self.timestamp}:")
+        self.scope.dump()
+        if self.parent is not None:
+            self.parent.dump(level+1)
+
+# Thunk representing a suspended/lazy computation. Thunks are evaluated when
+# needed (which is the call-by-need evaluation strategy). They are always
+# interpreted in the context of the associated closure.
+#
+# While the object is technically mutable, the result of the computation
+# (whether a value or a cyclic invalid result) is entirely determined by the
+# expression AST and closure, so the result is just a lazily computed/memoized
+# member. That said, the result might not exist if there is a cyclic dependency
+# between this and other thunks referenced by the closure.
+@dataclass
+class Thunk:
+    # Expression AST that the thunk evaluates to
+    ast: Node
+    # Closure in which the thunk can be evaluated, plus the definition for
+    # "this"; if there is one, it is always a PRS
+    closure: Closure
+    thisReference: Union[None, "PartialRecordSnapshot"] = None
+
+    # Whether the thunk has been evaluated yet
+    evaluated: bool = False
+    # Whether the thunk has been evaluated to an invalid result because of a
+    # cyclic dependency with other thunks captured by the closure
+    invalid: bool = False
+    # If the thunk has been evaluated and is not invalid, resulting value. None
+    # is a possible resulting value (`null` in the language); do not use this
+    # field to determine whether the thunk has been successfully evaluted.
+    result: JuiValue = None
+
+    # Whether the thunk is currently under evaluation
+    _running: bool = False
+
+    def __str__(self):
+        s = "Thunk("
+        if self._running:
+            s += "running, "
+        if self.evaluated:
+            s += "evaluated"
+            if self.invalid:
+                s += ", invalid"
+            else:
+                s += " = " + juiValueString(self.result)
+        else:
+            s += "unevaluated"
+        s += "){ " + str(self.ast) + " }"
+        return s
+
+# Object representing the interpretation of a partially-built record. In a
+# record construction or update operation, fields of `this` refer to the latest
+# definition before the point of use, if there is one, or the definition in the
+# underlying record otherwise, if there is one. Because the use of record
+# constructor arguments can create forwards dependencies, all these definitions
+# are thunked and computed lazily in a somewhat unpredictable order. A partial
+# record snapshot fully specifies the interpretation of all fields of a
+# partially-constructed record (i.e. `this`) at the location of one record
+# entry. It does so by mapping defined field names to the correct thunks. This
+# object is how dependencies between fields are discovered and followed.
+@dataclass
+class PartialRecordSnapshot:
+    # Mapping from fields of `this` to thunks
+    fieldThunks: dict[str, Thunk] = field(default_factory=dict)
+    # Base object for fields not captured in `fieldThunks`
+    base: None | Thunk = None
+
+    def __str__(self):
+        return "<PartialRecordSnapshot>" # TODO
+
+    def copy(self):
+        return PartialRecordSnapshot(self.fieldThunks.copy(), self.base)
+
+class JuiTypeError(Exception):
+    pass
+
+class JuiNameError(Exception):
+    pass
+
+class JuiStaticError(Exception):
+    pass
+
+class JuiRuntimeError(Exception):
+    pass
+
+# TODO: Better diagnostics for type errors
+def requireType(v: JuiValue, predicate: Callable[[JuiValue], bool]):
+    if not predicate(v):
+        raise JuiTypeError(f"type error: got {v}, needed {predicate}")
+
+def requireSameType(vs: list[JuiValue], predicate: Callable[[JuiValue], bool]):
+    if len(vs) == 0:
+        return
+    if len(set(type(v) for v in vs)) != 1:
+        vals = ", ".join(str(v) for v in vs)
+        raise JuiTypeError(f"type error: heterogeneous types for {vals}")
+
+    if not predicate(vs[0]):
+        raise JuiTypeError(f"type error: got {vs[0]}, needed {predicate}")
+
+# Evaluation context. This tracks the current scope and provides evaluation
+# functions, error tracking, etc.
+class Context:
+    # Current top-level scope. Can be None. This is the only scope in which we
+    # can add definitions.
+    currentScope: MutableScopeData
+    # Current closure defining the scopes that surround `currentScope`.
+    currentClosure: Closure | None
+
+    def __init__(self, initialClosure = None):
+        self.currentScope = MutableScopeData()
+        self.currentClosure = initialClosure
+        self._contextStack = []
+
+    #=== Context switch commodity ===#
+
+    _contextStack: list[Tuple[MutableScopeData, Closure]]
+
+    class ContextSwitchContextManager:
+        def __init__(self, parent: "Context", c: Closure):
+            self.parent = parent
+            self.targetClosure = c
+
+        def __enter__(self):
+            p = self.parent
+            p._contextStack.append((p.currentScope, p.currentClosure))
+            p.currentScope = MutableScopeData()
+            p.currentClosure = self.targetClosure
+
+        def __exit__(self, exc_type, exc_value, traceback):
+            p = self.parent
+            s, c = p._contextStack.pop()
+            p.currentScope = s
+            p.currentClosure = c
+
+    # Temporarily switch the execution context. This is used when we need e.g.
+    # to evaluate a thunk in its associated closure. Morally one could
+    # construct a different Context object, but it's easier to accumulate error
+    # messages and other things in the same Context object.
+    # Example:
+    #     with self.contextSwitchAndPushNewScope(myClosure):
+    #         myResult = self.eval(myExprNode)
+    def contextSwitchAndPushNewScope(self, c: Closure):
+        return Context.ContextSwitchContextManager(self, c)
+
+    # Freeze the current scope and push a new empty one to start working in.
+    # Example:
+    #     with self.pushNewScope():
+    #         self.addDefinition(myParamName, myParamValue)
+    #         myResult = self.eval(myFunctionBody)
+    def pushNewScope(self):
+        return self.contextSwitchAndPushNewScope(self.currentStateClosure())
+
+    #=== State management ===#
+
+    # Build a the closure of the current state
+    def currentStateClosure(self):
+        return Closure(parent=self.currentClosure, scope=self.currentScope)
+
+    # Add a new definition in the innermost scope
+    def addDefinition(self, name: str, content: JuiValue | Thunk):
+        return self.currentScope.addDefinition(name, content)
+
+    # Lookup a name
+    def lookup(self, name: str) -> JuiValue | Thunk | None:
+        return self.currentStateClosure().lookup(name)
+
+    #=== Evaluation helpers ===#
+
+    def makeFunction(self, params: list[Tuple[str, bool]], body: Node) \
+            -> Function:
+        # Check validity of the variadic parameter specification
+        variadics = [i for i, (_, v, _) in enumerate(params) if v]
+
+        for (name, _, _) in params:
+            count = len([0 for (n, _, _) in params if n == name])
+            if count > 1:
+                raise JuiStaticError(f"duplicate argument {name}")
+
+        if len(variadics) > 1:
+            names = ", ".join(params[i][0] for i in variadics)
+            raise JuiStaticError(f"multiple variadic arguments: {names}")
+
+        if variadics and variadics != [len(params) - 1]:
+            name = params[variadics[0]][0]
+            raise JuiStaticError(f"variadic argument {name} not at the end")
+        variadic = params[variadics[0]][0] if variadics else None
+
+        # Build function object
+        # TODO: Make a full scope not just an expr
+        return Function(closure = self.currentStateClosure(),
+                        body = Node(Node.T.SCOPE_EXPR, [body]),
+                        params = [name for (name, v, _) in params if not v],
+                        variadic = variadic)
+
+    def makeRecordCtor(self, params: list[Tuple[str, bool]], body: Node) \
+        -> RecordCtor:
+        return RecordCtor(func=self.makeFunction(params, body))
+
+    #=== Main evaluation functions ===#
+
+    # Expression evaluator; this function is pure. It can cause thunks to be
+    # evaluated and thus reveal previously-undiscovered cyclic dependencies,
+    # but it doesn't modify the context.
+    def evalExpr(self, node: Node) -> JuiValue:
+        match node.ctor, node.args:
+            case Node.T.LIT, [x]:
+                return x
+
+            case Node.T.IDENT, [name]:
+                match self.lookup(name):
+                    case None:
+                        raise JuiNameError(f"name {name} not defined")
+                    case Thunk() as t:
+                        return self.evalThunk(t)
+                    case value:
+                        return value
+
+            case Node.T.OP, ["+", X, Y]:
+                x = self.evalExpr(X)
+                y = self.evalExpr(Y)
+                requireSameType([x, y], juiIsAddable)
+                return x + y
+
+            # TODO: Arithmetic: integer division, type conversions
+            case Node.T.OP, [("+" | "-" | "*" | "/" | "%") as op, X, Y]:
+                x = self.evalExpr(X)
+                y = self.evalExpr(Y)
+                requireSameType([x, y], juiIsArith)
+                match op:
+                    case "+": return x + y
+                    case "-": return x - y
+                    case "*": return x * y
+                    case "/":
+                        match x, y:
+                            case float(), float(): return (x / y)
+                            case _, _: return  (x // y)
+                    case "%": return x % y
+
+            case Node.T.OP, [("!" | "+" | "-") as op, X]:
+                x = self.evalExpr(X)
+                requireType(x, juiIsArith)
+                match op:
+                    case "!": return not x
+                    case "+": return +x
+                    case "-": return -x
+
+            case Node.T.OP, [(">"|">="|"<"|"<="|"=="|"!=") as op, X, Y]:
+                x = self.evalExpr(X)
+                y = self.evalExpr(Y)
+                requireSameType([x, y], juiIsComparable)
+                match op:
+                    case ">": return x > y
+                    case "<": return x < y
+                    case ">=": return x >= y
+                    case "<=": return x <= y
+                    case "==": return x == y
+                    case "!=": return x != y
+
+            case Node.T.OP, [("&&" | "||") as op, X, Y]:
+                x = self.evalExpr(X)
+                y = self.evalExpr(Y)
+                requireSameType([x, y], juiIsLogical)
+                match op:
+                    case "&&": return x and y
+                    case "||": return x or y
+
+            case Node.T.OP, ["...", X]:
+                x = self.evalExpr(X)
+                requireType(x, juiIsUnpackable)
+                raise NotImplementedError("unpack operator o(x_x)o")
+
+            case Node.T.OP, [("|"|"|>"), X, F]:
+                f = self.evalExpr(F)
+                requireType(f, juiIsCallable)
+                return self.evalCall(f, [X])
+
+            case Node.T.OP, ["<|", F, X]:
+                f = self.evalExpr(F)
+                requireType(f, juiIsCallable)
+                return self.evalCall(f, [X])
+
+            case Node.T.THIS, []:
+                v = self.lookup("this")
+                if v is None:
+                    raise JuiNameError(f"no 'this' in current context")
+                assert isinstance(v, PartialRecordSnapshot)
+                return v
+
+            case Node.T.PROJ, [R, field]:
+                r = self.evalExpr(R)
+                requireType(r, juiIsProjectable)
+                f = self.project(r, field)
+                if isinstance(f, Thunk):
+                    return self.evalThunk(f)
+                else:
+                    return f
+
+
+            case Node.T.CALL, [F, *A]:
+                f = self.evalExpr(F)
+                requireType(f, juiIsCallable)
+                return self.evalCall(f, A)
+
+            case Node.T.IF, [C, T, E]:
+                c = self.evalExpr(C)
+                requireType(c, juiIsLogical)
+                if bool(c):
+                    return self.evalExpr(T)
+                else:
+                    return None if E is None else self.evalExpr(E)
+
+            case Node.T.RECORD, [R, *A]:
+                r = self.evalExpr(R)
+                requireType(r, juiIsConstructible)
+                return self.evalRecordConstructor(r, A)
+
+            case Node.T.REC_ATTR, _:
+                raise NotImplementedError
+
+            case Node.T.REC_VALUE, args:
+                raise NotImplementedError
+
+        raise Exception("invalid expr o(x_x)o: " + str(node))
+
+    def project(self, v: JuiValue, field: str) -> JuiValue:
+        match v:
+            case Record() as r:
+                if field not in r.attr:
+                    raise Exception(f"access to undefined field {field}")
+                return self.evalValueOrThunk(r.attr[field])
+            case PartialRecordSnapshot() as prs:
+                if field in prs.fieldThunks:
+                    return self.evalThunk(prs.fieldThunks[field])
+                elif prs.base is None:
+                    raise Exception(f"access to undefined field {field} of 'this'")
+                else:
+                    return self.project(self.evalThunk(prs.base), field)
+            case _:
+                raise NotImplementedError # unreachable
+
+    def execStmt(self, node: Node) -> JuiValue:
+        match node.ctor, node.args:
+            case Node.T.LET_DECL, [name, X, let_type]:
+                self.addDefinition(name, self.evalExpr(X))
+                # TODO: Check type?
+                return None
+
+            case Node.T.FUN_DECL, [name, params, body, body_type]:
+                self.addDefinition(name, self.makeFunction(params, body))
+                # TODO: Check type when called?
+                return None
+
+            case Node.T.REC_DECL, [name, params, body, body_type]:
+                self.addDefinition(name, self.makeRecordCtor(params, body))
+                return None
+
+            case Node.T.SET_STMT, _:
+                raise NotImplementedError
+
+            case Node.T.UNIT_TEST, [subject, expected]:
+                vs = self.evalExpr(subject)
+                ve = self.evalExpr(expected)
+                vs = self.force(vs)
+                ve = self.force(ve)
+                if not juiValuesEqual(vs, ve):
+                    print("unit test failed:")
+                    print("  " + juiValueString(vs))
+                    print("vs.")
+                    print("  " + juiValueString(ve))
+                return None
+
+            case Node.T.SCOPE_EXPR, [e]:
+                return self.evalExpr(e)
+
+        raise Exception(f"execStmt: unrecognized node {node.ctor.name}")
+
+    # TODO: Context.eval*: continue failed computations to find other errors?
+    def evalThunk(self, th: Thunk) -> JuiValue:
+        if th.evaluated:
+            if th.invalid:
+                raise JuiRuntimeError("cyclic dependency result encountered")
+            return th.result
+        if th._running:
+            raise JuiRuntimeError("cyclic dependency detected!")
+
+        with self.contextSwitchAndPushNewScope(th.closure):
+            if th.thisReference is not None:
+                self.addDefinition("this", th.thisReference)
+
+            th._running = True
+            result = self.evalExpr(th.ast)
+            th._running = False
+
+        # TODO: Set invalid = True if we continue failed computations
+        th.evaluated = True
+        th.result = result
+        return result
+
+    def evalValueOrThunk(self, v: JuiValue | Thunk) -> JuiValue:
+        return self.evalThunk(v) if isinstance(v, Thunk) else v
+
+    def evalCall(self, f: JuiValue, args: list[Node]) -> JuiValue:
+        # Built-in functions: just evaluate arguments and go
+        # TODO: Check types of built-in function calls
+        if type(f) == BuiltinFunction:
+            return f.func(*[self.evalExpr(a) for a in args])
+
+        assert type(f) == Function and "evalCall: bad type check precondition"
+
+        # Check number of arguments
+        req = str(len(f.params)) + ("+" if f.variadic is not None else "")
+        if len(args) < len(f.params):
+            raise JuiRuntimeError(f"not enough args (need {req}, got {len(args)})")
+        if len(args) > len(f.params) and f.variadic is None:
+            raise JuiRuntimeError(f"too many args (need {req}, got {len(args)})")
+
+        # TODO: In order to build variadic set I need a LIST node
+        if f.variadic is not None:
+            raise NotImplementedError("list node for building varargs o(x_x)o")
+
+        # Run into the function's scope
+        with self.contextSwitchAndPushNewScope(f.closure):
+            for name, node in zip(f.params, args):
+                th = Thunk(ast=node, closure=self.currentStateClosure())
+                self.addDefinition(name, th)
+            # self.currentScope.dump()
+            # self.currentClosure.dump()
+            assert f.body.ctor == Node.T.SCOPE_EXPR
+            return self.execStmt(f.body)
+
+    def evalRecordConstructor(self, ctor: JuiValue, entries: list[Node]) \
+            -> JuiValue:
+
+        # Base record constructor: starts out with an empty record. All
+        # arguments are children. Easy.
+        if isinstance(ctor, RecordType):
+            r = Record(base=ctor, attr=dict(), children=[])
+
+            # Create thunks for all entries while providing them with
+            # progressively more complete PRS of r.
+            prs = PartialRecordSnapshot()
+
+            for i, e in enumerate(entries):
+                if e.ctor == Node.T.REC_ATTR:
+                    name, label, node = e.args
+                elif e.ctor == Node.T.REC_VALUE:
+                    name, label, node = None, None, e.args[0]
+
+                th = Thunk(ast=node, closure=self.currentStateClosure())
+                th.thisReference = prs.copy()
+
+                if name is not None:
+                    r.attr[name] = th
+                    prs.fieldThunks[name] = th
+                else:
+                    r.children.append(th)
+
+            return r
+
+        # NOTE: NO WAY TO SPECIFY AN ATTRIBUTE IN A NON-STATIC WAY.
+
+        # Create thunks for all entries that have everything but the "this".
+        entry_thunks = []
+        for e in entries:
+            if e.ctor == Node.T.REC_ATTR:
+                name, label, node = e.args
+            elif e.ctor == Node.T.REC_VALUE:
+                name, label, node = None, None, e.args[0]
+            th = Thunk(ast=node, closure=self.currentStateClosure())
+            entry_thunks.append(th)
+
+        # Collect arguments to the constructor and build a thunk the call.
+        args = [entry_thunks[i]
+                for i, e in enumerate(entries) if e.ctor == Node.T.REC_VALUE]
+
+        # TODO: Merge with an internal version of evalCall()
+        #---
+
+        assert isinstance(ctor, RecordCtor)
+        f = ctor.func
+
+        # Check number of arguments
+        req = str(len(f.params)) + ("+" if f.variadic is not None else "")
+        if len(args) < len(f.params):
+            raise JuiRuntimeError(f"not enough args (need {req}, got {len(args)})")
+        if len(args) > len(f.params) and f.variadic is None:
+            raise JuiRuntimeError(f"too many args (need {req}, got {len(args)})")
+
+        # TODO: In order to build variadic set I need a LIST node
+        if f.variadic is not None:
+            raise NotImplementedError("list node for building varargs o(x_x)o")
+
+        # Run into the function's scope to build the thunk
+        with self.contextSwitchAndPushNewScope(f.closure):
+            for name, th in zip(f.params, args):
+                self.addDefinition(name, th)
+            assert f.body.ctor == Node.T.SCOPE_EXPR
+            call_thunk = Thunk(ast=f.body.args[0],
+                               closure=self.currentStateClosure())
+        #---
+
+        # Use the call as base for a PRS and assign "this" in all thunks.
+        prs = PartialRecordSnapshot()
+        prs.base = call_thunk
+
+        for i, e in enumerate(entries):
+            entry_thunks[i].thisReference = prs.copy()
+            if e.ctor == Node.T.REC_ATTR:
+                name, label, node = e.args
+                prs.fieldThunks[name] = th
+
+        baseRecord = self.evalThunk(call_thunk)
+        if not isinstance(baseRecord, Record):
+            raise Exception("record ctor did not return a record")
+
+        for i, e in enumerate(entries):
+            if e.ctor == Node.T.REC_ATTR:
+                name, label, node = e.args
+                baseRecord.attr[name] = entry_thunks[i]
+
+        return baseRecord
+
+    def force(self, v: JuiValue | Thunk) -> JuiValue:
+        match v:
+            case Record() as r:
+                for a in r.attr:
+                    r.attr[a] = self.force(r.attr[a])
+                for i, e in enumerate(r.children):
+                    r.children[i] = self.force(e)
+                return r
+            case Thunk() as th:
+                self.evalThunk(th)
+                if th.evaluated:
+                    return self.force(th.result)
+                return th.result
+            case _:
+                return v

juic/examples/ex1.jui

@@ -0,0 +1,114 @@
+1+2;
+/* comment */
+3;
+let zero = 0;
+zero + 2 * 20
+/* other
+comment */
+- 8
+/ 4;
+("hello" + "," + "world");
+if(2 < 4) 8;
+if(2 > 4) 8;
+if(2 > 4) 8 else "ok";
+let z = 4;
+(z + 10) * 3;
+let helloworld = "Hello, World!";
+len("xyz" + helloworld) + 1;
+print(12);
+print(42, "42", 73, "73");
+
+fun myprint3(x, y, z) = print(x, y, z);
+myprint3(1, 2, 3);
+
+let u = 2;
+fun test(x, t, gr) = 42 * x + z + 7;
+let v = 9;
+test(2, 3, u);
+
+record {};
+record { attr: 2 + 3; };
+
+record { x: 1; y: 2; z: subrecord { u: "42"; }; };
+
+fun stack(x) = x;
+fun stretch(x) = x;
+
+jwidget {
+  fullscreen: true;
+  @title jlabel { "title"; };
+  @stack jwidget {} |> stack |> stretch;
+
+  // let x = 4;
+  // jfkeys { x };
+  jfkeys { 4 };
+
+  // fun test(x, y, ...all) = x + y + sum(all);
+};
+
+rec jlabel2(s) = jwidget { text: s };
+
+jlabel2 {"Hello"};
+
+/*
+fun _(fx, cg) = if(param("FX")) fx else cg;
+fun stack(elem) = elem <{ layout: stack };
+fun stretch(elem) = elem <{ stretch_x: 1; stretch_y: 1; strech_beyond_limits: false };
+fun myvbox(elem) = elem <{ layout: vbox { spacing: 1 } };
+
+rec gscreen(name, keys, ...tabs) = myvbox <| jscene {
+  fullscreen: true;
+  @title if(name) jlabel { name };
+  @stack jwidget { ...map(stretch, tabs) } | stack | stretch;
+  jfkeys { keys };
+};
+
+gscreen {
+  @name name: "Test";
+  @fs jfileselect {};
+  @shell peshell {};
+};
+
+set jlabel { font: &font_rogue };
+
+jlabel {
+  width: 80;
+  margin: this.width - 2 * 20;
+};
+let hello_world_jlabel = jlabel { "Hello, World!" };
+# implicit hole
+hello_world_jlabel { width: dsize(this.text) };
+*/
+
+/*
+fun f(x) = x + 2;
+label { text: "hello"; height: 4; };
+
+fun my_widget(children) =
+  widget {
+    height: len(children) * 20;
+    ...children;
+  };
+// closure for my_widget function
+
+my_widget {
+  x: this.height; // 4
+  height: 8;
+// closure for the value of y
+// "this" is my_widget:14
+  y: this.height; // 8
+
+// closure for "children" parameter
+// "this" is my_widget:18
+  $children:
+    [label { "hello my height is " + str(this.height) };
+     button { height: this.x } ];
+
+  bg: none;
+};
+*/
+
+let x: int = 4;
+fun fun2(x: int, y: str): int = x + len(y);
+fun fun3(x, y: str) = x + len(y);
+let alias2: (int, str) -> int = fun2;

juic/examples/unit_tests.jui

@@ -0,0 +1,42 @@
+null;
+//^ null;
+
+1+2;
+//^ 3;
+
+let zero = 0;
+zero + 2 * 20 - 8 / 4;
+//^ 38;
+
+"hello" + "," + "world";
+//^ "hello,world";
+
+if(2 < 4) 8;
+//^ 8;
+
+if(2 > 4) 8;
+//^ null;
+
+if(2 > 4) 8 else 14;
+//^ 14;
+
+let z = 4;
+(z + 10) * 3;
+//^ 42;
+
+let helloworld = "Hello, World!";
+len("xyz" + helloworld) + 1;
+//^ 17;
+
+record {};
+//^ record {};
+
+let r = record {x: 2; y: 3+5};
+r;
+//^ record {y:8; x:2};
+
+r.x;
+//^ 2;
+
+record {x: r.x; y: this.x + 2; x: 4; z: this.x + 5};
+//^ record {x: 4; y: 4; z: 9};

juic/main.py

@@ -0,0 +1,88 @@
+import getopt
+import sys
+
+import juic.parser
+import juic.eval
+import juic.builtins
+
+USAGE_STRING = """
+usage: juic [OPTIONS] INPUT
+
+JustUI high-level description compiler.
+
+Options:
+  --debug=lexer      Dump the lexer output and stop
+         =parser     Dump the parser output and stop
+  --unit-tests       Check unit tests specified by "//^" comments
+""".strip()
+
+def usage(exitcode=None):
+    print(USAGE_STRING, file=sys.stderr)
+
+    if exitcode is not None:
+        sys.exit(exitcode)
+
+def main(argv):
+    # Read command-line arguments
+    try:
+        opts, args = getopt.gnu_getopt(argv[1:], "",
+            ["help", "debug=", "unit-tests"])
+        opts = dict(opts)
+
+        if len(argv) == 1 or "-h" in opts or "--help" in opts:
+            usage(0)
+        if len(args) < 1:
+            usage(1)
+        if len(args) > 1:
+            raise getopt.GetoptError("only one input file can be specified")
+
+    except getopt.GetoptError as e:
+        print("error:", e, file=sys.stderr)
+        print("Try '{} --help' for details.".format(argv[0]), file=sys.stderr)
+        sys.exit(1)
+
+    #---
+
+    with open(args[0], "r") as fp:
+        source = fp.read()
+
+    try:
+        lexer = juic.parser.JuiLexer(source, args[0],
+            keepUnitTests="--unit-tests" in opts)
+        if opts.get("--debug") == "lexer":
+            lexer.dump()
+            return 0
+
+        parser = juic.parser.JuiParser(lexer)
+        ast = parser.scope()
+        if opts.get("--debug") == "parser":
+            for node in ast.args:
+                node.dump()
+                print("---")
+            return 0
+
+    except juic.parser.SyntaxError as e:
+        print(e.loc, ": ", "\x1b[31merror:\x1b[0m ", e.message, sep="",
+            file=sys.stdout)
+        return 1
+
+    ctx = juic.eval.Context(juic.builtins.builtinClosure)
+
+    if "--unit-tests" in opts:
+        for node in ast.args:
+            ctx.execStmt(node)
+        return 0
+
+    for node in ast.args:
+        v = ctx.execStmt(node)
+        if node.ctor == juic.parser.Node.T.SCOPE_EXPR:
+            v = ctx.force(v)
+            print(">>>>>>>", juic.eval.juiValueString(v))
+
+    ctx.currentScope.dump()
+    ctx.currentClosure.dump()
+
+    print("TODO: Codegen not implemented yet o(x_x)o")
+    return 1
+
+sys.exit(main(sys.argv))

juic/parser.py

@@ -0,0 +1,566 @@
+from dataclasses import dataclass
+from typing import Any, Tuple
+import enum
+import sys
+import re
+
+import juic.datatypes
+
+@dataclass
+class Loc:
+    path: str
+    line: int
+    column: int
+
+    def __str__(self):
+        path = self.path or "(anonymous)"
+        return f"{path}:{self.line}:{self.column}"
+
+@dataclass
+class SyntaxError(Exception):
+    loc: Loc
+    message: str
+
+@dataclass
+class Token:
+    type: Any
+    value: Any
+    loc: Loc
+
+    def __str__(self):
+        if self.value is None:
+            return f"{self.type}"
+        else:
+            return f"{self.type}({self.value})"
+
+class NaiveRegexLexer:
+    """
+    Base class for a very naive regex-based lexer. This class provides the
+    naive matching algorithm that applies all regexes at the current point and
+    constructs a token with the longest, earliest match in the list. Regular
+    expressions for tokens as specified in a class-wide TOKEN_REGEX list which
+    consist of triples (regex, token type, token value).
+    """
+
+    # Override with list of (regex, token type, token value). Both the token
+    # type and value can be functions, in which case they'll be called with the
+    # match object as parameter.
+    Rule = Tuple[str, Any, Any] | Tuple[str, Any, Any, int]
+    TOKEN_REGEX: list[Rule] = []
+    # Override with token predicate that matches token to be discarded and not
+    # sent to the parser (typically, whitespace and comments).
+    TOKEN_DISCARD = lambda _: False
+
+    def __init__(self, input, inputFilename):
+        self.input = input
+        self.inputFilename = inputFilename
+        self.line = 1
+        self.column = 1
+
+        # TODO: Precompile the regular expressions
+
+    def loc(self):
+        return Loc(self.inputFilename, self.line, self.column)
+
+    def raiseError(self, message):
+        raise SyntaxError(self.loc, message)
+
+    def advancePosition(self, lexeme):
+        for c in lexeme:
+            if c == "\n":
+                self.line += 1
+                self.column = 0
+            self.column += 1
+
+    def nextToken(self):
+        """Return the next token in the input stream, None at EOF."""
+        if not len(self.input):
+            return None
+
+        highestPriority = 0
+        longestMatch = None
+        longestMatchIndex = -1
+
+        for i, (regex, _, _, *rest) in enumerate(self.TOKEN_REGEX):
+            priority = rest[0] if len(rest) else 0
+
+            if (m := re.match(regex, self.input)):
+                score = (priority, len(m[0]))
+                if longestMatch is None or \
+                    score > (highestPriority, len(longestMatch[0])):
+                    highestPriority = priority
+                    longestMatch = m
+                    longestMatchIndex = i
+
+        if longestMatch is None:
+            nextWord = self.input.split(None, 1)[0]
+            self.raiseError(f"unknown syntax '{nextWord}'")
+
+        # Build the token
+        _, type_info, value_info, *rest = self.TOKEN_REGEX[longestMatchIndex]
+        m = longestMatch
+
+        typ = type_info(m) if callable(type_info) else type_info
+        value = value_info(m) if callable(value_info) else value_info
+        t = Token(typ, value, self.loc())
+
+        self.advancePosition(m[0])
+        # Urgh. I need to find how to match a regex at a specific offset.
+        self.input = self.input[len(m[0]):]
+        return t
+
+    def lex(self):
+        """Return the next token that's visible to the parser, None at EOF."""
+        t = self.nextToken()
+        discard = type(self).TOKEN_DISCARD
+        while t is not None and discard(t):
+            t = self.nextToken()
+        return t
+
+    def dump(self, showDiscarded=False, fp=sys.stdout):
+        """Dump all remaining tokens on a stream, for debugging."""
+        t = 0
+        discard = type(self).TOKEN_DISCARD
+        while t is not None:
+            t = self.nextToken()
+            if t is not None and discard(t):
+                if showDiscarded:
+                    print(t, "(discarded)")
+            else:
+                print(t)
+
+class LL1Parser:
+    """
+    Base class for an LL(1) recursive descent parser. This class provides the
+    base mechanisms for hooking up a lexer, consuming tokens, checking the
+    lookahead, and combinators for writing common types of rules such as
+    expressions with operator precedence.
+    """
+
+    def __init__(self, lexer):
+        self.lexer = lexer
+        self.la = None
+        self.advance()
+
+    def advance(self):
+        """Return the next token and update the lookahead."""
+        t, self.la = self.la, self.lexer.lex()
+        return t
+
+    def atEnd(self):
+        return self.la is None
+
+    def raiseErrorAt(self, token, message):
+        raise SyntaxError(token.loc, message)
+
+    def expect(self, types, pred=None, optional=False):
+        """
+        Read the next token, ensuring it is one of the specified types; if
+        `pred` is specified, also tests the predicate. If `optional` is set,
+        returns None in case of mismatch rather than raising an error.
+        """
+
+        if not isinstance(types, list):
+            types = [types]
+        if self.la is not None and self.la.type in types and \
+            (pred is None or pred(self.la)):
+            return self.advance()
+        if optional:
+            return None
+
+        expected = ", ".join(str(t) for t in types)
+        err = f"expected one of {expected}, got {self.la}"
+        if pred is not None:
+            err += " (with predicate)"
+        self.raiseErrorAt(self.la, err)
+
+    # Rule combinators implementing unary and binary operators with precedence
+
+    @staticmethod
+    def binaryOpsLeft(ctor, ops):
+        def decorate(f):
+            def symbol(self):
+                e = f(self)
+                while (op := self.expect(ops, optional=True)) is not None:
+                    e = ctor(op, [e, f(self)])
+                return e
+            return symbol
+        return decorate
+
+    @staticmethod
+    def binaryOps(ctor, ops, *, rassoc=False):
+        def decorate(f):
+            def symbol(self):
+                lhs = f(self)
+                if (op := self.expect(ops, optional=True)) is not None:
+                    rhs = symbol(self) if rassoc else f(self)
+                    return ctor(op, [lhs, rhs])
+                else:
+                    return lhs
+            return symbol
+        return decorate
+
+    @staticmethod
+    def binaryOpsRight(ctor, ops):
+        return LL1Parser.binaryOps(ctor, ops, rassoc=True)
+
+    @staticmethod
+    def unaryOps(ctor, ops, assoc=True):
+        def decorate(f):
+            def symbol(self):
+                if (op := self.expect(ops, optional=True)) is not None:
+                    arg = symbol(self) if assoc else f(self)
+                    return ctor(op, [arg])
+                else:
+                    return f(self)
+            return symbol
+        return decorate
+
+#---
+
+def unescape(s: str) -> str:
+    return s.encode("raw_unicode_escape").decode("unicode_escape")
+
+class JuiLexer(NaiveRegexLexer):
+    T = enum.Enum("T",
+        ["WS", "KW", "COMMENT", "UNIT_TEST_MARKER",
+         "TEXTLIT", "INT", "FLOAT", "STRING",
+         "IDENT", "ATTR", "VAR", "LABEL", "FIELD", "CXXIDENT"])
+
+    RE_UTMARKER = r'//\^'
+
+    RE_COMMENT  = r'(#|//)[^\n]*|/\*([^/]|/[^*])+\*/'
+    RE_INT      = r'0|[1-9][0-9]*|0b[0-1]+|0o[0-7]+|0[xX][0-9a-fA-F]+'
+    # RE_FLOAT    = r'([0-9]*\.[0-9]+|[0-9]+\.[0-9]*|[0-9]+)([eE][+-]?{INT})?f?'
+
+    RE_KW       = r'\b(else|fun|if|let|rec|set|this|null|true|false|int|bool|float|str)\b'
+    RE_IDENT    = r'[\w_][\w0-9_]*'
+    RE_ATTR     = r'({})\s*(?:@({}))?\s*:'.format(RE_IDENT, RE_IDENT)
+    RE_VAR      = r'\$(\.)?' + RE_IDENT
+    RE_LABEL    = r'@' + RE_IDENT
+    RE_FIELD    = r'\.' + RE_IDENT
+    RE_CXXIDENT = r'&(::)?[a-zA-Z_]((::)?[a-zA-Z0-9_])*'
+
+    RE_STRING   = r'["]((?:[^\\"]|\\"|\\n|\\t|\\\\)*)["]'
+    RE_PUNCT    = r'\.\.\.|[.,:;=(){}]'
+    # TODO: Extend operator language to allow custom operators?
+    RE_OP       = r'<\||\|>|->|>=|<=|!=|==|\|\||&&|<{|[|+*/%-<>!]'
+
+    TOKEN_REGEX = [
+        (r'[ \t\n]+', T.WS, None),
+        (RE_COMMENT, T.COMMENT, None),
+        (RE_INT, T.INT, lambda m: int(m[0], 0)),
+        # FLOAT
+
+        (RE_KW, T.KW, lambda m: m[0]),
+        (RE_IDENT, T.IDENT, lambda m: m[0]),
+        (RE_ATTR, T.ATTR, lambda m: (m[1], m[2])),
+        (RE_VAR, T.VAR, lambda m: m[0][1:]),
+        (RE_LABEL, T.LABEL, lambda m: m[0][1:]),
+        (RE_FIELD, T.FIELD, lambda m: m[0][1:]),
+        (RE_CXXIDENT, T.CXXIDENT, lambda m: m[0][1:]),
+
+        (RE_STRING, T.STRING, lambda m: unescape(m[1])),
+        (RE_PUNCT, lambda m: m[0], None),
+        (RE_OP, lambda m: m[0], None),
+    ]
+    TOKEN_DISCARD = lambda t: t.type in [JuiLexer.T.WS, JuiLexer.T.COMMENT]
+
+    def __init__(self, input, inputFilename, *, keepUnitTests):
+        if keepUnitTests:
+            unit_rule = (self.RE_UTMARKER, JuiLexer.T.UNIT_TEST_MARKER, None, 1)
+            self.TOKEN_REGEX.insert(0, unit_rule)
+
+        super().__init__(input, inputFilename)
+
+@dataclass
+class Node:
+    T = enum.Enum("T", [
+        "LIT", "IDENT", "OP", "THIS", "PROJ", "CALL", "IF", "SCOPE",
+        "BASE_TYPE", "FUN_TYPE",
+        "RECORD", "REC_ATTR", "REC_VALUE",
+        "LET_DECL", "FUN_DECL", "REC_DECL", "SET_STMT",
+        "SCOPE_EXPR", "UNIT_TEST"])
+    ctor: T
+    args: list[Any]
+
+    def dump(self, indent=0):
+        print("  " * indent + self.ctor.name, end=" ")
+        match self.ctor, self.args:
+            case Node.T.LIT, [v]:
+                print(repr(v))
+            case Node.T.IDENT, [v]:
+                print(v)
+            case Node.T.OP, [op, *args]:
+                print(op)
+                self.dumpArgs(args, indent)
+            case _, args:
+                print("")
+                self.dumpArgs(args, indent)
+
+    def dumpArgs(self, args, indent=0):
+        for arg in args:
+            if isinstance(arg, Node):
+                arg.dump(indent + 1)
+            else:
+                print("  " * (indent + 1) + str(arg))
+
+    def __str__(self):
+        match self.ctor, self.args:
+            case Node.T.LIT, [v]:
+                return repr(v)
+            case Node.T.IDENT, [v]:
+                return v
+            case ctor, args:
+                return f"{ctor.name}({', '.join(str(a) for a in args)})"
+
+def mkOpNode(op, args):
+    return Node(Node.T.OP, [op.type] + args)
+
+# TODO: Parser: Track locations when building up AST nodes
+class JuiParser(LL1Parser):
+
+    def expectKeyword(self, *args):
+        return self.expect(JuiLexer.T.KW, pred=lambda t: t.value in args).value
+
+    # A list of elementFunction separated by sep, with an optional final sep.
+    # There must be a distinguishable termination marker "term" in order to
+    # detemrine whether there are more elements incoming. "term" can either be
+    # a token type or a callable applied to self.la.
+    def separatedList(self, elementFunction, *, sep, term):
+        elements = []
+        termFunction = term if callable(term) else lambda la: la.type == term
+        while not termFunction(self.la):
+            elements.append(elementFunction())
+            if termFunction(self.la):
+                break
+            self.expect(sep)
+        return elements
+
+    # expr0 ::= "null" | "true" | "false"         (constants)
+    #         | INT | FLOAT | STRING | CXXIDENT   (literals)
+    #         | IDENT
+    #         | "(" expr ")"
+    #         | "{" scope_stmt,* "}"
+    def expr0(self):
+        T = JuiLexer.T
+        lit_kws = ["this", "null", "true", "false"]
+        t = self.expect(
+            [T.INT, T.FLOAT, T.STRING, T.IDENT, T.CXXIDENT, T.KW, "("],
+            pred = lambda t: t.type != T.KW or t.value in lit_kws)
+
+        match t.type:
+            case T.INT | T.FLOAT | T.STRING:
+                node = Node(Node.T.LIT, [t.value])
+            case T.CXXIDENT:
+                node = Node(Node.T.LIT, [juic.datatypes.CXXQualid(t.value)])
+            case T.IDENT:
+                node = Node(Node.T.IDENT, [t.value])
+            case T.KW if t.value == "this":
+                node = Node(Node.T.THIS, [])
+            case T.KW if t.value == "null":
+                node = Node(Node.T.LIT, [None])
+            case T.KW if t.value in ["true", "false"]:
+                node = Node(Node.T.LIT, [t.value == "true"])
+            case "(":
+                node = self.expr()
+                self.expect(")")
+        return node
+
+    # The following are in loose -> tight precedence order:
+    # expr1 ::= expr1 <binary operator> expr1
+    #         | <unary operator> expr1
+    #         | expr0 "{" record_entry,* "}"   (record construction)
+    #         | expr0 "<{" record_entry,* "}"  (record update)
+    #         | expr0 "(" expr,* ")"           (function call)
+    #         | expr0 "." ident                (projection, same prec as call)
+    @LL1Parser.binaryOpsLeft(mkOpNode, ["|","|>"])
+    @LL1Parser.binaryOpsLeft(mkOpNode, ["<|"])
+    @LL1Parser.binaryOpsLeft(mkOpNode, ["||"])
+    @LL1Parser.binaryOpsLeft(mkOpNode, ["&&"])
+    @LL1Parser.binaryOps(mkOpNode, [">", ">=", "<", "<=", "==", "!="])
+    @LL1Parser.binaryOpsLeft(mkOpNode, ["+", "-"])
+    @LL1Parser.binaryOpsLeft(mkOpNode, ["*", "/", "%"])
+    @LL1Parser.unaryOps(mkOpNode, ["!", "+", "-", "..."])
+    def expr1(self):
+        node = self.expr0()
+
+        # Tight postfix operators
+        while (t := self.expect([JuiLexer.T.FIELD, "("], optional=True)) \
+              is not None:
+            match t.type:
+                case JuiLexer.T.FIELD:
+                    node = Node(Node.T.PROJ, [node, t.value])
+                case "(":
+                    args = self.separatedList(self.expr, sep=",", term=")")
+                    self.expect(")")
+                    node = Node(Node.T.CALL, [node, *args])
+
+        # Postfix update or record creation operation
+        while self.la is not None and self.la.type in ["{", "<{"]:
+            entries = self.record_literal()
+            node = Node(Node.T.RECORD, [node, *entries])
+
+        return node
+
+    # expr2 ::= expr1
+    #         | "if" "(" expr ")" expr1 ("else" expr2)?
+    def expr2(self):
+        match self.la.type, self.la.value:
+            case JuiLexer.T.KW, "if":
+                self.expectKeyword("if")
+                self.expect("(")
+                cond = self.expr()
+                self.expect(")")
+                body1 = self.expr1()
+
+                if self.la.type == JuiLexer.T.KW and self.la.value == "else":
+                    self.expectKeyword("else")
+                    body2 = self.expr2()
+                else:
+                    body2 = None
+
+                return Node(Node.T.IF, [cond, body1, body2])
+            case _, _:
+                return self.expr1()
+
+    def expr(self):
+        return self.expr2()
+
+    # type ::= int | bool | float | str
+    #        | (type,*) -> type
+    def type(self):
+        builtin_type_kws = ["int", "bool", "float", "str"]
+        t = self.expect([JuiLexer.T.KW, "("])
+        if t.type == JuiLexer.T.KW:
+            if t.value in builtin_type_kws:
+                return Node(Node.T.BASE_TYPE, [t.value])
+            else:
+                self.raiseErrorAt(t, "not a type keyword")
+        if t.type == "(":
+            args_types = self.separatedList(self.type, sep=",", term=")")
+            self.expect(")")
+            self.expect("->")
+            ret_type = self.type()
+            return Node(Node.T.FUN_TYPE, [args_types, ret_type])
+
+    # record_literal ::= "{" record_entry,* "}"
+    # record_entry ::= LABEL? ATTR? expr
+    #                | let_decl
+    #                | fun_rec_decl
+    #                | set_stmt
+    def record_literal(self):
+        # TODO: Distinguish constructor and update
+        self.expect(["{", "<{"])
+        entries = self.separatedList(self.record_entry, sep=";", term="}")
+        self.expect("}")
+        return entries
+
+    def record_entry(self):
+        T = JuiLexer.T
+        label_t = self.expect(T.LABEL, optional=True)
+        label = label_t.value if label_t is not None else None
+
+        match self.la.type, self.la.value:
+            case T.ATTR, _:
+                t = self.expect(T.ATTR)
+                e = self.expr()
+                return Node(Node.T.REC_ATTR, [t.value[0], label, e])
+            case T.KW, "let":
+                if label is not None:
+                    self.raiseErrorAt(label_t, "label not allowed with let")
+                return self.let_decl()
+            case T.KW, ("fun" | "rec"):
+                if label is not None:
+                    self.raiseErrorAt(label_t, "label not allowed with fun/rec")
+                return self.fun_rec_decl()
+            case T.KW, "set":
+                if label is not None:
+                    self.raiseErrorAt(label_t, "label not allowed with set")
+                return self.set_stmt()
+            case _, _:
+                return Node(Node.T.REC_VALUE, [self.expr()])
+
+    # let_decl ::= "let" ident (":" type)? "=" expr
+    def let_decl(self):
+        self.expectKeyword("let")
+        t_ident = self.expect([JuiLexer.T.IDENT, JuiLexer.T.ATTR])
+        if t_ident.type == JuiLexer.T.IDENT:
+            ident = t_ident.value
+            let_type = None
+        if t_ident.type == JuiLexer.T.ATTR:
+            ident = t_ident.value[0]
+            let_type = self.type()
+        self.expect("=")
+        expr = self.expr()
+        return Node(Node.T.LET_DECL, [ident, expr, let_type])
+
+    # fun_rec_decl ::= ("fun" | "rec") ident "(" fun_rec_param,* ")" "=" expr
+    # fun_rec_param ::= "..."? ident (":" type)?
+    def fun_rec_param(self):
+        variadic = self.expect("...", optional=True) is not None
+        t_ident = self.expect([JuiLexer.T.IDENT, JuiLexer.T.ATTR])
+        if t_ident.type == JuiLexer.T.IDENT:
+            ident = t_ident.value
+            arg_type = None
+        if t_ident.type == JuiLexer.T.ATTR:
+            ident = t_ident.value[0]
+            arg_type = self.type()
+        return (ident, variadic, arg_type)
+
+    def fun_rec_decl(self):
+        t = self.expectKeyword("fun", "rec")
+        ident = self.expect(JuiLexer.T.IDENT).value
+        self.expect("(")
+        params = self.separatedList(self.fun_rec_param, sep=",", term=")")
+        self.expect(")")
+        if self.la.type == ":":
+            self.expect(":")
+            body_type = self.type()
+        else:
+            body_type = None
+        self.expect("=")
+        body = self.expr()
+        return Node(Node.T.FUN_DECL if t == "fun" else Node.T.REC_DECL,
+            [ident, params, body, body_type])
+
+        # TODO: Check variadic param validity
+
+    # set_stmt ::= "set" ident record_literal
+    def set_stmt(self):
+        self.expectKeyword("set")
+        ident = self.expect(JuiLexer.T.IDENT)
+        entries = self.record_literal()
+        return Node(Node.T.SET_STMT, [ident, *entries])
+
+    def scope(self):
+        isNone = lambda t: t is None
+        entries = self.separatedList(self.scope_stmt, sep=";", term=isNone)
+
+        # Rearrange unit tests around their predecessors
+        entries2 = []
+        i = 0
+        while i < len(entries):
+            if i < len(entries) - 1 and entries[i+1].ctor == Node.T.UNIT_TEST:
+                entries[i+1].args[0] = entries[i]
+                entries2.append(entries[i+1])
+                i += 2
+            else:
+                entries2.append(entries[i])
+                i += 1
+
+        return Node(Node.T.SCOPE, entries2)
+
+    def scope_stmt(self):
+        match self.la.type, self.la.value:
+            case JuiLexer.T.KW, "let":
+                return self.let_decl()
+            case JuiLexer.T.KW, ("fun" | "rec"):
+                return self.fun_rec_decl()
+            case JuiLexer.T.KW, "set":
+                return self.set_stmt()
+            case JuiLexer.T.UNIT_TEST_MARKER, _:
+                self.expect(JuiLexer.T.UNIT_TEST_MARKER)
+                return Node(Node.T.UNIT_TEST, [None, self.expr()])
+            case _:
+                return Node(Node.T.SCOPE_EXPR, [self.expr()])

src/jfileselect.c

@@ -4,15 +4,27 @@
 
 #include <gint/display.h>
 #include <gint/gint.h>
+#include <gint/config.h>
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <errno.h>
 #include <sys/stat.h>
 
 /* Type identifier for jfileselect */
 static int jfileselect_type_id = -1;
 
+#if GINT_RENDER_MONO
+# define JFILESELECT_LINE_SPACING 1
+# define JFILESELECT_SCROLLBAR_WIDTH 1
+# define JFILESELECT_INFO_SHORT 1
+#elif GINT_RENDER_RGB
+# define JFILESELECT_LINE_SPACING 4
+# define JFILESELECT_SCROLLBAR_WIDTH 2
+# define JFILESELECT_INFO_SHORT 0
+#endif
+
 /* Events */
 uint16_t JFILESELECT_LOADED;
 uint16_t JFILESELECT_VALIDATED;
@@ -27,9 +39,9 @@ struct fileinfo {
 	/* Entry name (owned by the structure) */
 	char *name;
 	/* File size in bytes if file, number of entries if folder */
-	int size;
+	int size :24;
 	/* Type from [struct dirent], -1 for the "Save As" entry */
-	int type;
+	int8_t type;
 };
 
 jfileselect *jfileselect_create(void *parent)
@@ -40,6 +52,7 @@ jfileselect *jfileselect_create(void *parent)
 	if(!fs) return NULL;
 
 	jwidget_init(&fs->widget, jfileselect_type_id, parent);
+	jwidget_set_focus_policy(fs, J_FOCUS_POLICY_SCOPE);
 
 	jinput *input = jinput_create("Filename: ", 32, fs);
 	if(!input) {
@@ -52,25 +65,20 @@ jfileselect *jfileselect_create(void *parent)
 	fs->path = NULL;
 	fs->entries = NULL;
 	fs->entry_count = 0;
+	fs->folder_error = 0;
 
 	fs->selected_file = NULL;
 	fs->saveas_input = input;
 	fs->saveas = false;
 	fs->input_mode = false;
+	fs->scrollbar_width = JFILESELECT_SCROLLBAR_WIDTH;
 	fs->filter_function = jfileselect_default_filter;
 
 	fs->cursor = -1;
 	fs->scroll = 0;
 	fs->visible_lines = 0;
 
-#ifdef FX9860G
-	fs->line_spacing = 1;
-	fs->scrollbar_width = 1;
-#else
-	fs->line_spacing = 4;
-	fs->scrollbar_width = 2;
-#endif
-
+	fs->line_spacing = JFILESELECT_LINE_SPACING;
 	fs->font = dfont_default();
 	fs->show_file_size = false;
 
@@ -109,14 +117,14 @@ static void start_input(jfileselect *fs)
 {
 	fs->input_mode = true;
 	jinput_clear(fs->saveas_input);
-	jwidget_event(fs->saveas_input, (jevent){ .type = JWIDGET_FOCUS_IN });
+	jwidget_scope_set_target(fs, fs->saveas_input);
 	fs->widget.update = true;
 }
 
 static void stop_input(jfileselect *fs)
 {
 	fs->input_mode = false;
-	jwidget_event(fs->saveas_input, (jevent){ .type = JWIDGET_FOCUS_OUT });
+	jwidget_scope_set_target(fs, NULL);
 	fs->widget.update = true;
 }
 
@@ -215,19 +223,24 @@ static int compare_entries(void const *i1_0, void const *i2_0)
 static bool load_folder_switch(jfileselect *fs, char *path)
 {
 	set_finfo(fs, NULL, 0);
+	free(fs->path);
+	fs->path = path;
 
 	struct dirent *ent;
 	DIR *dp = opendir(path);
-	if(!dp)
+	if(!dp) {
+		fs->folder_error = errno;
 		return false;
+	}
 
 	/* Count entries */
 	int n = count_accepted_entries(fs, dp) + fs->saveas;
 
 	/* Allocate memory for the fileinfo structures */
 	struct fileinfo *finfo = malloc(n * sizeof *finfo);
-	if(!finfo) {
+	if(n && !finfo) {
 		closedir(dp);
+		fs->folder_error = errno;
 		return false;
 	}
 
@@ -246,6 +259,7 @@ static bool load_folder_switch(jfileselect *fs, char *path)
 			for(int j = 0; j < i; j++) free(finfo[j].name);
 			free(finfo);
 			closedir(dp);
+			fs->folder_error = errno;
 			return false;
 		}
 
@@ -257,6 +271,9 @@ static bool load_folder_switch(jfileselect *fs, char *path)
 					finfo[i].size = count_accepted_entries(fs, sub);
 					closedir(sub);
 				}
+				else {
+					finfo[i].size = -errno;
+				}
 			}
 			else {
 				struct stat st;
@@ -278,18 +295,20 @@ static bool load_folder_switch(jfileselect *fs, char *path)
 	qsort(finfo, n, sizeof *finfo, compare_entries);
 
 	closedir(dp);
-	free(fs->path);
-	fs->path = path;
 	set_finfo(fs, finfo, n);
-	fs->widget.update = true;
-
-	jwidget_emit(fs, (jevent){ .type = JFILESELECT_LOADED });
+	fs->folder_error = 0;
 	return true;
 }
 
 static bool load_folder(jfileselect *fs, char *path)
 {
-	return gint_world_switch(GINT_CALL(load_folder_switch, (void *)fs, path));
+	bool ok =
+		gint_world_switch(GINT_CALL(load_folder_switch, (void *)fs, path));
+
+	fs->widget.update = true;
+	jwidget_emit(fs, (jevent){ .type = JFILESELECT_LOADED });
+
+	return ok;
 }
 
 bool jfileselect_browse(jfileselect *fs, char const *path)
@@ -298,8 +317,7 @@ bool jfileselect_browse(jfileselect *fs, char const *path)
 	if(!path_copy)
 		return false;
 
-	if(!load_folder(fs, path_copy))
-		return false;
+	bool ok = load_folder(fs, path_copy);
 
 	free(fs->selected_file);
 	fs->selected_file = NULL;
@@ -307,7 +325,7 @@ bool jfileselect_browse(jfileselect *fs, char const *path)
 	fs->cursor = 0;
 	fs->scroll = 0;
 	stop_input(fs);
-	return true;
+	return ok;
 }
 
 char const *jfileselect_selected_file(jfileselect *fs)
@@ -361,15 +379,19 @@ static void jfileselect_poly_layout(void *fs0)
 
 static void generate_info_string(char *str, bool isfolder, int size)
 {
-#ifdef FX9860G
-	if(isfolder)
+#if JFILESELECT_INFO_SHORT
+	if(size < 0)
+		sprintf(str, "E%d", -size);
+	else if(isfolder)
 		sprintf(str, "%d/", size);
 	else if(size < 10000) /* 10 kB */
 		sprintf(str, "%d", size);
 	else
 		sprintf(str, "%dk", size / 1000);
 #else
-	if(isfolder)
+	if(size < 0)
+		sprintf(str, "E%d", -size);
+	else if(isfolder)
 		sprintf(str, "%d entries", size);
 	else
 		sprintf(str, "%d B", size);
@@ -379,8 +401,6 @@ static void generate_info_string(char *str, bool isfolder, int size)
 static void jfileselect_poly_render(void *fs0, int x, int y)
 {
 	jfileselect *fs = fs0;
-	if(!fs->path || !fs->entries)
-		return;
 
 	font_t const *old_font = dfont(fs->font);
 	int line_height = fs->font->line_height + fs->line_spacing;
@@ -393,6 +413,17 @@ static void jfileselect_poly_render(void *fs0, int x, int y)
 		&& fs->scrollbar_width > 0;
 	int entry_width = cw - (scrollbar ? 2 * fs->scrollbar_width : 0);
 
+	if(fs->folder_error) {
+		int text_y = y + (fs->line_spacing + 0) / 2;
+		dprint(x, text_y, C_BLACK, "(E%d)", fs->folder_error);
+		return;
+	}
+	if(!fs->entries || fs->entry_count == 0) {
+		int text_y = y + (fs->line_spacing + 0) / 2;
+		dprint(x, text_y, C_BLACK, "(No entries)");
+		return;
+	}
+
 	for(int i = 0; i < fs->visible_lines && i < fs->entry_count; i++) {
 		bool selected = (fs->cursor == fs->scroll + i);
 		struct fileinfo *info = &finfo[fs->scroll + i];
@@ -417,7 +448,7 @@ static void jfileselect_poly_render(void *fs0, int x, int y)
 		}
 
 		dprint(x+2, text_y, fg, "%s%s", info->name, isfolder ? "/" : "");
-		if(fs->show_file_size && info->size >= 0) {
+		if(fs->show_file_size) {
 			char str[32];
 			generate_info_string(str, isfolder, info->size);
 			dtext_opt(x + entry_width - 3, text_y, fg, C_NONE, DTEXT_RIGHT,
@@ -440,7 +471,7 @@ static void jfileselect_poly_render(void *fs0, int x, int y)
 static bool jfileselect_poly_event(void *fs0, jevent e)
 {
 	jfileselect *fs = fs0;
-	if(!fs->path || !fs->entries)
+	if(!fs->path)
 		return false;
 
 	if(e.type == JINPUT_CANCELED && e.source == fs->saveas_input) {
@@ -510,7 +541,7 @@ static bool jfileselect_poly_event(void *fs0, jevent e)
 				return true;
 			}
 		}
-		else if(key == KEY_EXE) {
+		else if(key == KEY_EXE && fs->entries) {
 			struct fileinfo *finfo = fs->entries;
 			struct fileinfo *i = &finfo[fs->cursor];
 
@@ -537,7 +568,7 @@ static bool jfileselect_poly_event(void *fs0, jevent e)
 		}
 	}
 
-	return false;
+	return jwidget_poly_event(fs, e);
 }
 
 static void jfileselect_poly_destroy(void *fs0)
@@ -559,10 +590,10 @@ static jwidget_poly type_jfileselect = {
 	.destroy = jfileselect_poly_destroy,
 };
 
-__attribute__((constructor(1003)))
+__attribute__((constructor))
 static void j_register_jfileselect(void)
 {
-	jfileselect_type_id = j_register_widget(&type_jfileselect, "jwidget");
+	jfileselect_type_id = j_register_widget(&type_jfileselect);
 	JFILESELECT_LOADED = j_register_event();
 	JFILESELECT_VALIDATED = j_register_event();
 	JFILESELECT_CANCELED = j_register_event();

src/jfkeys.c

@@ -4,48 +4,42 @@
 #include <gint/std/stdlib.h>
 #include <gint/std/string.h>
 
-/* Type identified for jfkeys */
-static int jfkeys_type_id = -1;
+J_DEFINE_WIDGET(jfkeys, csize, render, event)
+J_DEFINE_EVENTS(JFKEYS_TRIGGERED)
 
-#ifdef FX9860G
-jfkeys *jfkeys_create(bopti_image_t const *img, void *parent)
+extern font_t j_font_fkeys_fx;
+
+#if GINT_RENDER_MONO
+# define JFKEYS_HEIGHT 8
+#elif GINT_RENDER_RGB
+# define JFKEYS_HEIGHT 17
+#endif
+
+jfkeys *jfkeys_create2(
+	bopti_image_t const *img, char const *labels, void *parent)
 {
 	if(jfkeys_type_id < 0) return NULL;
 
 	jfkeys *f = malloc(sizeof *f);
 	jwidget_init(&f->widget, jfkeys_type_id, parent);
-	jfkeys_set(f, img);
-
-	return f;
-}
-
-void jfkeys_set(jfkeys *f, bopti_image_t const *img)
-{
-	f->img = img;
-	f->level = 0;
-	f->widget.update = true;
-}
-#endif /* FX9860G */
-
-#ifdef FXCG50
-jfkeys *jfkeys_create(char const *labels, void *parent)
-{
-	if(jfkeys_type_id < 0) return NULL;
-
-	jfkeys *f = malloc(sizeof *f);
-	jwidget_init(&f->widget, jfkeys_type_id, parent);
-	jfkeys_set(f, labels);
+	jfkeys_set2(f, img, labels);
 	for(int i = 0; i < 6; i++) f->overrides[i] = NULL;
 	f->bg_color = C_BLACK;
 	f->bg_special_color = C_WHITE;
 	f->text_color = C_WHITE;
 	f->text_special_color = C_BLACK;
+
+#if GINT_RENDER_MONO
+	f->font = &j_font_fkeys_fx;
+#else
 	f->font = dfont_default();
+#endif
 	return f;
 }
 
-void jfkeys_set(jfkeys *f, char const *labels)
+void jfkeys_set2(jfkeys *f, bopti_image_t const *img, char const *labels)
 {
+	f->img = img;
 	f->labels = labels;
 	f->level = 0;
 	f->widget.update = true;
@@ -90,52 +84,44 @@ static char const *get_label(char const *level, int key, size_t *len)
 
 	return NULL;
 }
-#endif /* FXCG50 */
 
 //---
 // Polymorphic widget operations
 //---
 
-static void jfkeys_poly_csize(void *f0)
+void jfkeys_poly_csize(void *f0)
 {
 	jfkeys *f = f0;
-
-	#ifdef FX9860G
-	f->widget.w = 128;
-	f->widget.h = 8;
-	#endif
-
-	#ifdef FXCG50
-	f->widget.w = 396;
-	f->widget.h = 17;
-	#endif
+	f->widget.w = DWIDTH;
+	f->widget.h = JFKEYS_HEIGHT;
 }
 
-static void jfkeys_poly_render(void *f0, int base_x, int y)
+void jfkeys_poly_render(void *f0, int base_x, int y)
 {
 	jfkeys *f = f0;
 
-	#ifdef FX9860G
-	dsubimage(base_x, y, f->img, 0, 9*f->level, f->img->width, 8, DIMAGE_NONE);
-	#endif
+	if(f->img) {
+		dsubimage(base_x, y, f->img, 0, (JFKEYS_HEIGHT+1) * f->level,
+			f->img->width, JFKEYS_HEIGHT, DIMAGE_NONE);
+		return;
+	}
 
-	#ifdef FXCG50
 	font_t const *old_font = dfont(f->font);
 	char const *level = get_level(f->labels, f->level);
 	if(!level) return;
 
 	for(int position = 0; position < 6; position++) {
 		size_t length = 0;
-		char const *text = NULL;
-		#ifdef FXCG50
-		text = f->overrides[position];
-		#endif
+		char const *text = f->overrides[position];
 		if(!text) text = get_label(level, position, &length);
 		if(!text || (*text != '.' && *text != '/' && *text != '@'
 			&& *text != '#')) continue;
 
-		int x = base_x + 4 + 65 * position;
-		int w = 63;
+		int fw = jwidget_full_width(f);
+		int margin = (fw >= 250 ? 4 : 2);
+		int spacing = 2;
+		int w = (fw - 2 * margin - 5 * spacing) / 6;
+		int x = base_x + margin + (w + spacing) * position;
 		int color = (text[0] == '#') ? f->text_special_color : f->text_color;
 
 		if(text[0] == '.') {
@@ -168,7 +154,38 @@ static void jfkeys_poly_render(void *f0, int base_x, int y)
 	}
 
 	dfont(old_font);
-	#endif /* FXCG50 */
+}
+
+bool jfkeys_poly_event(void *f0, jevent e)
+{
+	jfkeys *f = f0;
+	jevent te;
+	te.source = f;
+	te.type = JFKEYS_TRIGGERED;
+
+	if(e.type == JWIDGET_KEY && e.key.type == KEYEV_DOWN) {
+		int fun = keycode_function(e.key.key);
+		if(fun >= 0) {
+			te.data = fun - 1;
+			jwidget_emit(f, te);
+			return true;
+		}
+
+#if GINT_HW_CP
+		static uint8_t const CP_Fk[6] = {
+			KEY_EQUALS, KEY_X, KEY_Y, KEY_Z, KEY_CARET, KEY_DIV };
+
+		for(int i = 0; i < 6; i++) {
+			if(e.key.key == CP_Fk[i]) {
+				te.data = i;
+				jwidget_emit(f, te);
+				return true;
+			}
+		}
+#endif
+	}
+
+	return jwidget_poly_event(f, e);
 }
 
 int jfkeys_level(jfkeys *f)
@@ -183,56 +200,28 @@ void jfkeys_set_level(jfkeys *f, int level)
 	f->widget.update = 1;
 }
 
-char const *jfkeys_override(GUNUSED jfkeys *keys, GUNUSED int key)
+char const *jfkeys_override(jfkeys *keys, int key)
 {
-	#ifdef FXCG50
 	if(key < 1 || key > 6) return NULL;
 	return keys->overrides[key - 1];
-	#endif
-
-	return NULL;
 }
 
-void jfkeys_set_override(GUNUSED jfkeys *keys, GUNUSED int key,
-	GUNUSED char const *override)
+void jfkeys_set_override(jfkeys *keys, int key, char const *override)
 {
-	#ifdef FXCG50
 	if(key < 1 || key > 6) return;
 	keys->overrides[key - 1] = override;
-	#endif
 }
 
-void jfkeys_set_color(GUNUSED jfkeys *keys, GUNUSED int bg,
-	GUNUSED int bg_special, GUNUSED int text, GUNUSED int text_special)
+void jfkeys_set_color(
+	jfkeys *keys, int bg, int bg_special, int text, int text_special)
 {
-	#ifdef FXCG50
 	keys->bg_color = bg;
 	keys->bg_special_color = bg_special;
 	keys->text_color = text;
 	keys->text_special_color = text_special;
-	#endif
 }
 
-void jfkeys_set_font(GUNUSED jfkeys *keys, GUNUSED font_t const *font)
+void jfkeys_set_font(jfkeys *keys, font_t const *font)
 {
-	#ifdef FXCG50
 	keys->font = font;
-	#endif
-}
-
-/* jfkeys type definition */
-static jwidget_poly type_jfkeys = {
-	.name    = "jfkeys",
-	.csize   = jfkeys_poly_csize,
-	.layout  = NULL,
-	.render  = jfkeys_poly_render,
-	.event   = NULL,
-	.destroy = NULL,
-};
-
-/* Type registration */
-__attribute__((constructor(1005)))
-static void j_register_jfkeys(void)
-{
-	jfkeys_type_id = j_register_widget(&type_jfkeys, "jwidget");
 }

src/jframe.c

@@ -4,18 +4,28 @@
 #include "util.h"
 
 #include <gint/display.h>
+#include <gint/config.h>
 
 #include <stdlib.h>
 
 /* Type identifier for jframe */
 static int jframe_type_id = -1;
 
+#if GINT_RENDER_MONO
+# define JFRAME_SCROLLBAR_WIDTH 1
+# define JFRAME_SCROLLBAR_SPACING 1
+# define JFRAME_DEFAULT_MARGIN 4
+#elif GINT_RENDER_RGB
+# define JFRAME_SCROLLBAR_WIDTH 2
+# define JFRAME_SCROLLBAR_SPACING 2
+# define JFRAME_DEFAULT_MARGIN 8
+#endif
+
 jframe *jframe_create(void *parent)
 {
     if(jframe_type_id < 0)
         return NULL;
 
-
     jframe *f = malloc(sizeof *f);
     if(!f)
         return NULL;
@@ -30,18 +40,11 @@ jframe *jframe_create(void *parent)
     f->keyboard_control = false;
     f->match_width = false;
     f->match_height = false;
+    f->scrollbar_width = JFRAME_SCROLLBAR_WIDTH;
+    f->scrollbar_spacing = JFRAME_SCROLLBAR_SPACING;
 
-#ifdef FX9860G
-    f->scrollbar_width = 1;
-    f->scrollbar_spacing = 1;
-    f->visibility_margin_x = 4;
-    f->visibility_margin_y = 4;
-#else
-    f->scrollbar_width = 2;
-    f->scrollbar_spacing = 2;
-    f->visibility_margin_x = 8;
-    f->visibility_margin_y = 8;
-#endif
+    f->visibility_margin_x = JFRAME_DEFAULT_MARGIN;
+    f->visibility_margin_y = JFRAME_DEFAULT_MARGIN;
 
     f->scroll_x = 0;
     f->scroll_y = 0;
@@ -281,6 +284,9 @@ static void jframe_poly_render(void *f0, int x, int y)
     jframe *f = f0;
     jwidget *child = frame_child(f);
 
+    if(!child)
+        return;
+
     int child_w = jwidget_full_width(child);
     int child_h = jwidget_full_height(child);
 
@@ -373,7 +379,7 @@ static bool jframe_poly_event(void *f0, jevent e)
         return true;
     }
 
-    return false;
+    return jwidget_poly_event(f, e);
 }
 
 /* jframe type definition */
@@ -385,8 +391,8 @@ static jwidget_poly type_jframe = {
     .event  = jframe_poly_event,
 };
 
-__attribute__((constructor(1001)))
+__attribute__((constructor))
 static void j_register_jframe(void)
 {
-    jframe_type_id = j_register_widget(&type_jframe, "jwidget");
+    jframe_type_id = j_register_widget(&type_jframe);
 }

src/jinput.c

@@ -5,7 +5,8 @@
 
 #include <gint/display.h>
 #include <gint/keyboard.h>
-#include <gint/std/stdlib.h>
+#include <gint/config.h>
+#include <stdlib.h>
 
 /* Type identifier for jinput */
 static int jinput_type_id = -1;
@@ -28,11 +29,12 @@ enum {
 
 /* Mode indicators and their size */
 extern bopti_image_t j_img_input_modes;
-#ifdef FX9860G
-#define JINPUT_INDICATOR 9
-#endif
-#ifdef FXCG50
-#define JINPUT_INDICATOR 12
+#if GINT_RENDER_MONO
+# define JINPUT_INDICATOR 9
+# define JINPUT_CURSOR_WIDTH 1
+#elif GINT_RENDER_RGB
+# define JINPUT_INDICATOR 12
+# define JINPUT_CURSOR_WIDTH 2
 #endif
 
 jinput *jinput_create(char const *prompt, size_t length, void *parent)
@@ -43,6 +45,7 @@ jinput *jinput_create(char const *prompt, size_t length, void *parent)
 	if(!i) return NULL;
 
 	jwidget_init(&i->widget, jinput_type_id, parent);
+	jwidget_set_focus_policy(i, J_FOCUS_POLICY_ACCEPT);
 
 	i->color = C_BLACK;
 	jinput_set_font(i, NULL);
@@ -56,6 +59,7 @@ jinput *jinput_create(char const *prompt, size_t length, void *parent)
 
 	i->mode = JINPUT_FLAT;
 	i->timer = -1;
+	i->keymap_fun = NULL;
 
 	return i;
 }
@@ -79,6 +83,11 @@ void jinput_set_prompt(jinput *i, char const *prompt)
 	i->widget.dirty = 1;
 }
 
+void jinput_set_keymap_function(jinput *i, jinput_keymap_function_t *kf)
+{
+	i->keymap_fun = kf;
+}
+
 //---
 // Input helpers
 //---
@@ -212,10 +221,7 @@ static void jinput_poly_render(void *i0, int x, int y)
 		else cursor_w = 0;
 
 		int cursor_x = x + prompt_w + cursor_w;
-		dline(cursor_x, y, cursor_x, y + h - 1, i->color);
-		#ifdef FXCG50
-		dline(cursor_x + 1, y, cursor_x + 1, y + h - 1, i->color);
-		#endif
+		drect(cursor_x, y, cursor_x+JINPUT_CURSOR_WIDTH-1, y + h - 1, i->color);
 	}
 
 	dfont(old_font);
@@ -237,20 +243,15 @@ static bool jinput_poly_event(void *i0, jevent e)
 {
 	jinput *i = i0;
 
-	if(e.type == JWIDGET_FOCUS_IN) {
-		i->cursor = i->size - 1;
-		i->mode = 0;
-		i->widget.update = 1;
-	}
-
-	if(e.type == JWIDGET_FOCUS_OUT) {
-		i->cursor = -1;
+	if(e.type == JWIDGET_FOCUS_CHANGED) {
+		i->cursor = jwidget_has_focus(i) ? (i->size - 1) : -1;
 		i->mode = 0;
 		i->widget.update = 1;
 	}
 
 	if(e.type == JWIDGET_KEY) {
 		key_event_t ev = e.key;
+		bool handled = true;
 
 		/* Releasing modifiers */
 		if(ev.type == KEYEV_UP && ev.key == KEY_SHIFT) {
@@ -305,7 +306,10 @@ static bool jinput_poly_event(void *i0, jevent e)
 				i->mode |= JINPUT_ALPHA;
 		}
 		else {
-			uint32_t code_point = keymap_translate(ev.key,
+			jinput_keymap_function_t *kf = i->keymap_fun;
+			if(!kf)
+				kf = &keymap_translate;
+			uint32_t code_point = (*kf)(ev.key,
 				(i->mode & JINPUT_SHIFT) || (i->mode & JINPUT_SHIFT_LOCK),
 				(i->mode & JINPUT_ALPHA) || (i->mode & JINPUT_ALPHA_LOCK)
 			);
@@ -318,13 +322,15 @@ static bool jinput_poly_event(void *i0, jevent e)
 				/* Remove modifiers otherwise */
 				else i->mode &= ~(JINPUT_SHIFT | JINPUT_ALPHA);
 			}
-			else return false;
+			else handled = false;
 		}
 
 		i->widget.update = 1;
+		if(handled)
+			return true;
 	}
 
-	return true;
+	return jwidget_poly_event(i, e);
 }
 
 static void jinput_poly_destroy(void *i0)
@@ -343,10 +349,10 @@ static jwidget_poly type_jinput = {
 	.destroy = jinput_poly_destroy,
 };
 
-__attribute__((constructor(1003)))
+__attribute__((constructor))
 static void j_register_jinput(void)
 {
-	jinput_type_id = j_register_widget(&type_jinput, "jwidget");
+	jinput_type_id = j_register_widget(&type_jinput);
 	JINPUT_VALIDATED = j_register_event();
 	JINPUT_CANCELED = j_register_event();
 }

src/jlabel.c

@@ -21,16 +21,17 @@ jlabel *jlabel_create(char const *text, void *parent)
 	jwidget_init(&l->widget, jlabel_type_id, parent);
 
 	l->block_halign = J_ALIGN_LEFT;
-	l->block_valign = J_ALIGN_MIDDLE;
+	l->block_valign = J_ALIGN_TOP;
 	l->text_align   = J_ALIGN_LEFT;
 
-	l->line_spacing = 1;
+	l->line_spacing = 0;
 	l->color = C_BLACK;
 	l->font = NULL;
 
 	l->wrap_mode = J_WRAP_NONE;
 	l->text = text;
 	l->owns_text = false;
+	l->wrapped_newline_spacing = false;
 
 	vec_init(&l->breaks_vec, sizeof *l->breaks);
 
@@ -188,6 +189,12 @@ void jlabel_set_font(jlabel *l, font_t const *font)
 	l->widget.dirty = 1;
 }
 
+void jlabel_set_wrapped_newline_spacing(jlabel *l, bool preserve)
+{
+	l->wrapped_newline_spacing = preserve;
+	l->widget.dirty = 1;
+}
+
 //---
 // Polymorphic widget operations
 //---
@@ -236,7 +243,7 @@ static void jlabel_poly_layout(void *l0)
 		/* Start of line */
 		add_break(l, str - l->text);
 
-		/* A "\n" forces a newline in all wrap omdes */
+		/* A "\n" forces a newline in all wrap modes */
 		char const *end_of_line = strchrnul(str, '\n');
 
 		/* Also consider word or letters boundaries */
@@ -257,14 +264,17 @@ static void jlabel_poly_layout(void *l0)
 			}
 		}
 
+		bool natural_break = (*end_of_line == '\n');
 		char const *next_start = end_of_line + (*end_of_line == '\n');
 
-		/* Skip trailing spaces on this line */
-		while(end_of_line > str && end_of_line[-1] == ' ')
-			end_of_line--;
-		/* Skip leading spaces on the next line */
-		while(next_start[0] == ' ')
-			next_start++;
+		if(!natural_break && !l->wrapped_newline_spacing) {
+			/* Skip trailing spaces on this line */
+			while(end_of_line > str && end_of_line[-1] == ' ')
+				end_of_line--;
+			/* Skip leading spaces on the next line */
+			while(next_start[0] == ' ')
+				next_start++;
+		}
 
 		add_break(l, end_of_line - l->text);
 
@@ -295,7 +305,7 @@ static void jlabel_poly_render(void *l0, int x, int y)
 	/* Position the block vertically */
 
 	int lines = l->breaks_vec.size / 2;
-	int block_height = lines * (f->line_height + l->line_spacing) -
+	int block_height = lines * (f->line_distance + l->line_spacing) -
 		l->line_spacing;
 
 	if(l->block_valign == J_ALIGN_MIDDLE)
@@ -331,7 +341,7 @@ static void jlabel_poly_render(void *l0, int x, int y)
 		dtext_opt(x + dx, y, l->color, C_NONE, DTEXT_LEFT, DTEXT_TOP,
 			str, line_length);
 
-		y += f->line_height + l->line_spacing;
+		y += f->line_distance + l->line_spacing;
 		str = l->text + l->breaks[i];
 	}
 
@@ -354,8 +364,8 @@ static jwidget_poly type_jlabel = {
 };
 
 /* Type registration */
-__attribute__((constructor(1002)))
+__attribute__((constructor))
 static void j_register_jlabel(void)
 {
-	jlabel_type_id = j_register_widget(&type_jlabel, "jwidget");
+	jlabel_type_id = j_register_widget(&type_jlabel);
 }

src/jlist.c

@@ -5,6 +5,7 @@
 
 #include <gint/display.h>
 #include <stdlib.h>
+#include <string.h>
 
 /* Type identifier for jlist */
 static int jlist_type_id = -1;
@@ -19,8 +20,8 @@ struct jlist_item_info {
     bool selectable;
 };
 
-jlist *jlist_create(void *parent, jlist_item_info_function info_function,
-    jlist_item_paint_function paint_function)
+jlist *jlist_create(jlist_item_info_function info_function,
+    jlist_item_paint_function paint_function, void *parent)
 {
     if(jlist_type_id < 0)
         return NULL;
@@ -30,12 +31,14 @@ jlist *jlist_create(void *parent, jlist_item_info_function info_function,
         return NULL;
 
     jwidget_init(&l->widget, jlist_type_id, parent);
+    jwidget_set_focus_policy(l, J_FOCUS_POLICY_ACCEPT);
 
     l->item_count = 0;
     l->items = NULL;
     l->info_function = info_function;
     l->paint_function = paint_function;
     l->cursor = -1;
+    l->user = NULL;
     return l;
 }
 
@@ -112,8 +115,10 @@ int jlist_selected_item(jlist *l)
 // Item management
 //---
 
-void jlist_update_model(jlist *l, int item_count)
+void jlist_update_model(jlist *l, int item_count, void *user)
 {
+    l->user = user;
+
     if(l->item_count != item_count) {
         l->items = realloc(l->items, item_count * sizeof *l->items);
         if(!l->items) {
@@ -126,6 +131,7 @@ void jlist_update_model(jlist *l, int item_count)
 
     l->item_count = item_count;
     for(int i = 0; i < item_count; i++) {
+        memset(&l->items[i], 0, sizeof l->items[i]);
         l->info_function(l, i, &l->items[i]);
     }
 
@@ -136,7 +142,7 @@ void jlist_update_model(jlist *l, int item_count)
 
 void jlist_clear(jlist *l)
 {
-    jlist_update_model(l, 0);
+    jlist_update_model(l, 0, NULL);
 }
 
 jrect jlist_selected_region(jlist *l)
@@ -193,16 +199,24 @@ static void jlist_poly_render(void *l0, int x, int y)
 
     for(int i = 0; i < l->item_count; i++) {
         jlist_item_info *info = &l->items[i];
+        bool selected = (l->cursor == i);
 
-        if(info->delegate) {
+        int h = info->delegate
+            ? jwidget_full_height(info->delegate)
+            : info->natural_height;
+
+        if(selected && info->selection_style == JLIST_SELECTION_BACKGROUND)
+            drect(x1, y, x2, y + h - 1, info->selection_bg_color);
+
+        if(info->delegate)
             jwidget_render(info->delegate, x1, y);
-            y += jwidget_full_height(info->delegate);
-        }
-        else {
-            l->paint_function(x1, y, x2-x1+1, info->natural_height, l, i,
-                l->cursor == i);
-            y += info->natural_height;
-        }
+        else
+            l->paint_function(x1, y, x2-x1+1, h, l, i, selected);
+
+        if(selected && info->selection_style == JLIST_SELECTION_INVERT)
+            drect(x1, y, x2, y + h - 1, C_INVERT);
+
+        y += h;
     }
 }
 
@@ -246,7 +260,7 @@ static bool jlist_poly_event(void *l0, jevent e)
         return true;
     }
 
-    return false;
+    return jwidget_poly_event(l, e);
 }
 
 static void jlist_poly_destroy(void *l0)
@@ -264,10 +278,10 @@ static jwidget_poly type_jlist = {
     .destroy = jlist_poly_destroy,
 };
 
-__attribute__((constructor(1001)))
+__attribute__((constructor))
 static void j_register_jlist(void)
 {
-    jlist_type_id = j_register_widget(&type_jlist, "jwidget");
+    jlist_type_id = j_register_widget(&type_jlist);
     JLIST_ITEM_TRIGGERED = j_register_event();
     JLIST_SELECTION_MOVED = j_register_event();
     JLIST_MODEL_UPDATED = j_register_event();

src/jpainted.c

@@ -1,8 +1,8 @@
 #include <justui/jpainted.h>
-#include <gint/std/stdlib.h>
+#include <justui/jwidget-api.h>
+#include <stdlib.h>
 
-/* Type identifier for jpainted */
-static int jpainted_type_id = -1;
+J_DEFINE_WIDGET(jpainted, csize, render)
 
 jpainted *jpainted_create(void *function, j_arg_t arg, int natural_w,
 	int natural_h, void *parent)
@@ -20,36 +20,15 @@ jpainted *jpainted_create(void *function, j_arg_t arg, int natural_w,
 	return p;
 }
 
-//---
-// Polymorphic widget operations
-//---
-
-static void jpainted_poly_csize(void *p0)
+void jpainted_poly_csize(void *p0)
 {
 	jpainted *p = p0;
 	p->widget.w = p->natural_w;
 	p->widget.h = p->natural_h;
 }
 
-static void jpainted_poly_render(void *p0, int x, int y)
+void jpainted_poly_render(void *p0, int x, int y)
 {
 	jpainted *p = p0;
 	p->paint(x, y, p->arg);
 }
-
-/* jpainted type definition */
-static jwidget_poly type_jpainted = {
-	.name    = "jpainted",
-	.csize   = jpainted_poly_csize,
-	.layout  = NULL,
-	.render  = jpainted_poly_render,
-	.event   = NULL,
-	.destroy = NULL,
-};
-
-/* Type registration */
-__attribute__((constructor(1004)))
-static void j_register_jpainted(void)
-{
-	jpainted_type_id = j_register_widget(&type_jpainted, "jwidget");
-}

src/jscene.c

@@ -9,13 +9,13 @@
 #include <gint/std/stdlib.h>
 #include <gint/gint.h>
 #include <gint/drivers/t6k11.h>
+#include <gint/cpu.h>
 
 /* Type identifier for jscene */
 static int jscene_type_id = -1;
 /* Events */
 uint16_t JSCENE_NONE;
 uint16_t JSCENE_PAINT;
-uint16_t JSCENE_KEY;
 
 /* Keyboard transformation for inputs in a jscene */
 static int jscene_repeater(int key, GUNUSED int duration, int count)
@@ -43,16 +43,23 @@ jscene *jscene_create(int x, int y, int w, int h, void *parent)
 	if(!s) return NULL;
 
 	jwidget_init(&s->widget, jscene_type_id, parent);
+	jwidget_set_focus_policy(s, J_FOCUS_POLICY_SCOPE);
 	jwidget_set_fixed_size(s, w, h);
+	jlayout_set_vbox(s);
+
+	/* The scene is where active focus originates */
+	s->widget.focused = 1;
+	s->widget.active_focused = 1;
 
 	s->x = x;
 	s->y = y;
 
-	s->focus = NULL;
 	s->queue_first = 0;
 	s->queue_next = 0;
 	s->lost_events = 0;
 	s->mainmenu = true;
+	s->poweroff = true;
+	s->autopaint = false;
 
 	/* Prepare first layout/paint operation */
 	s->widget.dirty = 1;
@@ -88,25 +95,34 @@ void jscene_render(jscene *scene)
 
 jevent jscene_read_event(jscene *s)
 {
-	if(s->queue_first == s->queue_next)
+	cpu_atomic_start();
+
+	if(s->queue_first == s->queue_next) {
+		cpu_atomic_end();
 		return (jevent){ .source = NULL, .type = JSCENE_NONE };
+	}
 
 	jevent e = s->queue[s->queue_first];
 	s->queue_first = (s->queue_first + 1) % JSCENE_QUEUE_SIZE;
+	cpu_atomic_end();
 	return e;
 }
 
 void jscene_queue_event(jscene *s, jevent e)
 {
+	cpu_atomic_start();
+
 	/* Prevent filling and overflowing the queue */
 	int next = (s->queue_next + 1) % JSCENE_QUEUE_SIZE;
 	if(next == s->queue_first) {
 		s->lost_events++;
-		return;
+	}
+	else {
+		s->queue[s->queue_next] = e;
+		s->queue_next = next;
 	}
 
-	s->queue[s->queue_next] = e;
-	s->queue_next = next;
+	cpu_atomic_end();
 }
 
 //---
@@ -115,27 +131,37 @@ void jscene_queue_event(jscene *s, jevent e)
 
 void *jscene_focused_widget(jscene *s)
 {
-	return s->focus;
+	jwidget *w = &s->widget;
+	while(w->focus_scope_target)
+		w = w->focus_scope_target;
+	return w;
 }
 
 void jscene_set_focused_widget(jscene *s, void *w0)
 {
 	J_CAST(w)
 
+	/* Unfocus only at the top level */
+	if(!w) {
+		jwidget_scope_set_target(s, NULL);
+		return;
+	}
+
+	if(w->focus_policy == J_FOCUS_POLICY_REJECT)
+		return;
+
 	/* Check that (s) is an ancestor of (w) */
-	if(w) for(jwidget *anc = w; anc != (jwidget *)s; anc = anc->parent) {
+	for(jwidget *anc = w; anc != (jwidget *)s; anc = anc->parent) {
 		if(anc == NULL) return;
 	}
 
-	/* Focus out old focused widget */
-	if(s->focus) jwidget_event(s->focus,
-		(jevent){ .type = JWIDGET_FOCUS_OUT, .source = s->focus });
-
-	s->focus = w;
-
-	/* Focus in newly-selected widget */
-	if(w) jwidget_event(w,
-		(jevent){ .type = JWIDGET_FOCUS_IN, .source = w });
+	/* Set targets in every scope along the way up */
+	jwidget *scope = w;
+	while(scope != NULL) {
+		scope = jwidgetctx_enclosing_focus_scope(scope);
+		jwidget_scope_set_target(scope, w);
+		w = scope;
+	}
 }
 
 void jscene_show_and_focus(jscene *scene, void *w0)
@@ -169,12 +195,13 @@ void jscene_show_and_focus(jscene *scene, void *w0)
 
 bool jscene_process_key_event(jscene *scene, key_event_t event)
 {
-	jwidget *candidate = scene->focus;
+	jwidget *candidate = jscene_focused_widget(scene);
 	jevent e = { .type = JWIDGET_KEY, .key = event };
 
 	while(candidate) {
-		if(jwidget_event(candidate, e)) return true;
-		candidate = candidate->parent;
+		if(jwidget_event(candidate, e))
+			return true;
+		candidate = jwidgetctx_enclosing_focus_scope(candidate);
 	}
 
 	return false;
@@ -198,6 +225,16 @@ void jscene_set_mainmenu(jscene *scene, bool mainmenu)
 	scene->mainmenu = mainmenu;
 }
 
+void jscene_set_poweroff(jscene *scene, bool poweroff)
+{
+	scene->poweroff = poweroff;
+}
+
+void jscene_set_autopaint(jscene *scene, bool autopaint)
+{
+	scene->autopaint = autopaint;
+}
+
 jevent jscene_run(jscene *s)
 {
 	keydev_t *d = keydev_std();
@@ -213,6 +250,11 @@ jevent jscene_run(jscene *s)
 
 		/* Queued GUI events */
 		e = jscene_read_event(s);
+		if(e.type == JSCENE_PAINT && s->autopaint) {
+			jscene_render(s);
+			dupdate();
+			continue;
+		}
 		if(e.type != JSCENE_NONE && !jscene_process_event(s, e)) break;
 
 		/* Queued keyboard events */
@@ -225,12 +267,21 @@ jevent jscene_run(jscene *s)
 				continue;
 			}
 		}
-		#ifdef FX9860G
+		if(k.type == KEYEV_DOWN && k.key == KEY_ACON && k.shift && !k.alpha) {
+			if(s->poweroff) {
+				gint_poweroff(true);
+				jscene_queue_event(s, (jevent){ .type = JSCENE_PAINT });
+				continue;
+			}
+		}
+		// TODO: Temporarily disabled to allow build-fxg3a, will put back when
+		// gint's generic video interface is available
+/*		#ifdef FX9860G
 		if(k.type == KEYEV_DOWN && k.key == KEY_OPTN && k.shift && !k.alpha) {
 			t6k11_backlight(-1);
 			continue;
 		}
-		#endif
+		#endif */
 
 		getkey_feature_t feat = getkey_feature_function();
 		if((k.type == KEYEV_DOWN || k.type == KEYEV_HOLD) && feat && feat(k))
@@ -260,11 +311,10 @@ static jwidget_poly type_jscene = {
 	.destroy = NULL,
 };
 
-__attribute__((constructor(1001)))
+__attribute__((constructor))
 static void j_register_jscene(void)
 {
-	jscene_type_id = j_register_widget(&type_jscene, "jwidget");
+	jscene_type_id = j_register_widget(&type_jscene);
 	JSCENE_NONE = j_register_event();
 	JSCENE_PAINT = j_register_event();
-	JSCENE_KEY = JWIDGET_KEY;
 }

src/jscrolledlist.c

@@ -8,9 +8,10 @@
 /* Type identifier for jscrolledlist */
 static int jscrolledlist_type_id = -1;
 
-jscrolledlist *jscrolledlist_create(void *parent,
+jscrolledlist *jscrolledlist_create(
     jlist_item_info_function info_function,
-    jlist_item_paint_function paint_function)
+    jlist_item_paint_function paint_function,
+    void *parent)
 {
     if(jscrolledlist_type_id < 0)
         return NULL;
@@ -23,10 +24,20 @@ jscrolledlist *jscrolledlist_create(void *parent,
     jwidget_set_stretch(l, 1, 1, false);
 
     l->frame = jframe_create(l);
+    if(!l->frame) {
+        free(l);
+        return NULL;
+    }
+
     jwidget_set_stretch(l->frame, 1, 1, false);
     jframe_set_align(l->frame, J_ALIGN_LEFT, J_ALIGN_TOP);
 
-    l->list = jlist_create(l->frame, info_function, paint_function);
+    l->list = jlist_create(info_function, paint_function, l->frame);
+    if(!l->list) {
+        jwidget_destroy(l->frame);
+        free(l);
+        return NULL;
+    }
     jwidget_set_stretch(l->list, 1, 1, false);
 
     return l;
@@ -67,8 +78,7 @@ static bool jscrolledlist_poly_event(void *l0, jevent e)
     if(e.type == JLIST_MODEL_UPDATED && e.source == l->list)
         shake_scroll(l, true);
 
-    /* Allow the evnts to bubble up */
-    return false;
+    return jwidget_poly_event(l, e);
 }
 
 /* jscrolledlist type definition */
@@ -78,8 +88,8 @@ static jwidget_poly type_jscrolledlist = {
     .event   = jscrolledlist_poly_event,
 };
 
-__attribute__((constructor(1002)))
+__attribute__((constructor))
 static void j_register_jscrolledlist(void)
 {
-    jscrolledlist_type_id = j_register_widget(&type_jscrolledlist, "jwidget");
+    jscrolledlist_type_id = j_register_widget(&type_jscrolledlist);
 }

src/jwidget.c

@@ -12,7 +12,6 @@
 #define WIDGET_TYPES_MAX 32
 
 /* Polymorphic functions for jwidget */
-static jwidget_poly_render_t jwidget_poly_render;
 static jwidget_poly_csize_t  jwidget_poly_csize;
 
 /* jwidget type definition */
@@ -21,7 +20,7 @@ static jwidget_poly type_jwidget = {
 	.csize   = jwidget_poly_csize,
 	.layout  = NULL,
 	.render  = jwidget_poly_render,
-	.event   = NULL,
+	.event   = jwidget_poly_event,
 	.destroy = NULL,
 };
 
@@ -32,15 +31,16 @@ static jwidget_poly *widget_types[WIDGET_TYPES_MAX] = {
 };
 
 /* Events */
-uint16_t JWIDGET_KEY;
-uint16_t JWIDGET_FOCUS_IN;
-uint16_t JWIDGET_FOCUS_OUT;
+J_DEFINE_EVENTS(
+	JWIDGET_KEY,
+	JWIDGET_FOCUS_CHANGED,
+	JWIDGET_FOCUS_TARGET_CHANGED);
 
 //---
 // Polymorphic functions for widgets
 //---
 
-static void jwidget_poly_render(void *w0, int x, int y)
+void jwidget_poly_render(void *w0, int x, int y)
 {
 	J_CAST(w)
 	jlayout_stack *l;
@@ -86,6 +86,14 @@ static void jwidget_poly_csize(void *w0)
 	}
 }
 
+bool jwidget_poly_event(void *w0, jevent e)
+{
+	J_CAST(w)
+	(void)w;
+	(void)e;
+	return false;
+}
+
 //---
 // Initialization
 //---
@@ -110,9 +118,13 @@ void jwidget_init(jwidget *w, int type, void *parent)
 	w->visible = 1;
 	w->floating = 0;
 	w->clipped = 0;
+	w->focus_policy = J_FOCUS_POLICY_REJECT;
+	w->focused = 0;
+	w->active_focused = 0;
 
 	w->type = type;
 	w->geometry = NULL;
+	w->focus_scope_target = NULL;
 
 	w->x = 0;
 	w->y = 0;
@@ -224,6 +236,8 @@ void jwidget_remove_child(void *w0, void *child0)
 	J_CAST(w, child)
 	if(child->parent != w) return;
 
+	// TODO[jwidget_remove_child]: Remove focus
+
 	int write = 0;
 	int index = -1;
 
@@ -598,6 +612,10 @@ void jwidget_set_floating(void *w0, bool floating)
 	if(w->parent) w->parent->dirty = 1;
 }
 
+//---
+// Rendering
+//---
+
 bool jwidget_clipped(void *w0)
 {
 	J_CAST(w)
@@ -613,10 +631,6 @@ void jwidget_set_clipped(void *w0, bool clipped)
 	w->update = 1;
 }
 
-//---
-// Rendering
-//---
-
 void jwidget_render(void *w0, int x, int y)
 {
 	J_CAST(w)
@@ -651,7 +665,13 @@ void jwidget_render(void *w0, int x, int y)
 	/* TODO: jwidget_render(): More border types */
 
 	if(g->background_color != C_NONE) {
-		drect(x1 + b.left, y1 + b.top, x2-1, y2-1, g->background_color);
+		int bgx = x1 + b.left;
+		int bgy = y1 + b.top;
+
+		if(bgx == 0 && bgy == 0 && x2 == DWIDTH && y2 == DHEIGHT)
+			dclear(g->background_color);
+		else
+			drect(bgx, bgy, x2-1, y2-1, g->background_color);
 	}
 
 	/* Call the polymorphic render function at the top-left content point */
@@ -679,6 +699,117 @@ void jwidget_render(void *w0, int x, int y)
 	w->update = 0;
 }
 
+//---
+// Keyboard focus
+//---
+
+void jwidget_set_focus_policy(void *w0, jwidget_focus_policy_t fp)
+{
+	J_CAST(w)
+	if(w->focus_policy == fp)
+		return;
+
+	/* If this was a scope, clear it (otherwise the surrounding scope, which is
+	   going to expand, could pick up a second, untargeted focused widget). */
+	if(w->focus_policy == J_FOCUS_POLICY_SCOPE)
+		jwidget_scope_clear_focus(w);
+
+	/* Remove focus if we're no longer accepting it */
+	if(fp == J_FOCUS_POLICY_REJECT && jwidget_has_focus(w))
+		jwidgetctx_drop_focus(w);
+
+	w->focus_policy = fp;
+}
+
+static void notify_focus_changed(jwidget *w)
+{
+	jevent e;
+	e.source = w;
+	e.type = JWIDGET_FOCUS_CHANGED;
+	jwidget_event(w, e);
+}
+
+static void set_focus_chain_active(
+	jwidget *w, bool set, bool notify_toplevel, bool bottom_up)
+{
+	bool recursive =
+		(w->focus_policy == J_FOCUS_POLICY_SCOPE && w->focus_scope_target);
+
+	if(recursive && bottom_up)
+		set_focus_chain_active(w->focus_scope_target, set, true, bottom_up);
+
+	w->active_focused = set;
+	if(notify_toplevel)
+		notify_focus_changed(w);
+
+	if(recursive && !bottom_up)
+		set_focus_chain_active(w->focus_scope_target, set, true, bottom_up);
+}
+
+void jwidget_scope_set_target(void *fs0, void *target0)
+{
+	J_CAST(fs, target)
+	if(!fs || fs->focus_policy != J_FOCUS_POLICY_SCOPE
+		|| fs->focus_scope_target == target)
+		return;
+
+	jwidget *oldt = fs->focus_scope_target;
+
+	if(oldt) {
+		/* First, if we have active focus, remove it from the entire chain */
+		if(jwidget_has_active_focus(fs))
+			set_focus_chain_active(oldt, false, false, true);
+
+		/* Then, remove the focus flag from the scope target and notify it */
+		oldt->focused = 0;
+		notify_focus_changed(oldt);
+	}
+
+	fs->focus_scope_target = target;
+
+	if(target) {
+		/* Now, give focus to the new scope target */
+		target->focused = 1;
+		notify_focus_changed(target);
+
+		if(jwidget_has_active_focus(fs))
+			set_focus_chain_active(target, true, false, false);
+	}
+
+	jevent e;
+	e.source = fs;
+	e.type = JWIDGET_FOCUS_TARGET_CHANGED;
+	jwidget_event(fs, e);
+}
+
+jwidget *jwidgetctx_enclosing_focus_scope(void *w0)
+{
+	J_CAST(w)
+	do w = w->parent;
+	while(w && w->focus_policy != J_FOCUS_POLICY_SCOPE);
+	return w;
+}
+
+void jwidgetctx_drop_focus(void *w0)
+{
+	J_CAST(w)
+	if(!w || !jwidget_has_focus(w))
+		return;
+	jwidget *scope = jwidgetctx_enclosing_focus_scope(w);
+	if(scope)
+		jwidget_scope_clear_focus(scope);
+}
+
+void jwidgetctx_grab_focus(void *w0)
+{
+	J_CAST(w)
+	if(!w || jwidget_has_focus(w))
+		return;
+	jwidget *scope = jwidgetctx_enclosing_focus_scope(w);
+	if(scope)
+		jwidget_scope_set_target(scope, w);
+}
+
 //---
 // Event management
 //---
@@ -715,25 +846,14 @@ char const *jwidget_type(void *w0)
 	return widget_types[w->type]->name;
 }
 
-int j_register_widget(jwidget_poly *poly, char const *inherits)
+int j_register_widget(jwidget_poly *poly)
 {
-	/* Resolve inheritance */
-	if(inherits) {
-		jwidget_poly const *base = NULL;
-
-		for(int i = 0; i < WIDGET_TYPES_MAX && !base; i++) {
-			if(widget_types[i] && !strcmp(widget_types[i]->name, inherits))
-				base = widget_types[i];
-		}
-
-		if(!base) return -1;
-
-		if(!poly->csize)   poly->csize   = base->csize;
-		if(!poly->layout)  poly->layout  = base->layout;
-		if(!poly->render)  poly->render  = base->render;
-		if(!poly->event)   poly->event   = base->event;
-		if(!poly->destroy) poly->destroy = base->destroy;
-	}
+	/* Resolve default behaviors */
+	if(!poly->csize)   poly->csize   = jwidget_poly_csize;
+	if(!poly->layout)  poly->layout  = NULL;
+	if(!poly->render)  poly->render  = jwidget_poly_render;
+	if(!poly->event)   poly->event   = jwidget_poly_event;
+	if(!poly->destroy) poly->destroy = NULL;
 
 	for(int i = 0; i < WIDGET_TYPES_MAX; i++) {
 		if(widget_types[i] == NULL) {
@@ -750,11 +870,3 @@ int j_register_event(void)
 	event_id++;
 	return event_id;
 }
-
-__attribute__((constructor(1000)))
-static void j_register_jwidget(void)
-{
-	JWIDGET_KEY = j_register_event();
-	JWIDGET_FOCUS_IN = j_register_event();
-	JWIDGET_FOCUS_OUT = j_register_event();
-}