- reuse reentrant property-resolution storage during variable substitution
- skip redundant resolution-slot copies using structural source comparison
- retain variable cache capacity and resolve variables in place
- avoid copying canonical names for definition-backed properties
- propagate resolved inherited properties by reference through widget trees
- parse animation and transition declarations with allocation-light string views
- share declaration tokenization between animation and transition parsers
- avoid empty animation-map and action-query allocations
- parse border radii without temporary split vectors
- accept string views when converting UI lengths
- format color hex values directly without string streams
- use inline storage for small polygon point collections
- preserve animation parsing semantics and fix longhand direction handling
- save eeiv configuration when closing through keyboard shortcuts
- extend animation, variable-resolution, property-name, and color tests
Probable reproduction:
1. Open global search.
2. Enter a search term.
3. Start “replace in files” with Mod+R.
4. Before the asynchronous search finishes, switch to document search.
5. Immediately reopen normal global search.
The replace tree becomes active as soon as the search starts, but its model is only assigned when the asynchronous result arrives. Reopening normal global search tried to reuse that still-null model and called rowCount() on it. The loader is also closed during this transition, explaining the SceneNode::checkClose() trace from another timing of the same sequence.
The fix:
- Only transfers replace results when the replace model exists.
- Adds a defensive null check to updateGlobalSearchBarResults().
Replace boolean output-parameter converters with UIValueResult so conversion failures can provide numeric codes and optional diagnostics without exposing partially converted values.
Expose observable converter error state from UIDataBind, UIProperty, and UIValueBinding.
Reject invalid widget input without changing the model or propagating it to sibling widgets, while keeping programmatic model updates authoritative.
Migrate ecode's custom output parser converter, expand binding tests, and document the data-handling architecture and next form-validation
phase.
Introduce EventConnection and EventConnectionList for scoped Node event listeners that safely handle either emitter or observer destruction order.
Add ObservableValue and UIValueBinding for UI-independent observable state, along with a shared UIValueConverter policy used by both observable and raw data bindings.
Harden UIDataBind and UIProperty lifetime behavior, documentation, conversion, operators, and multi-widget handling. Preserve UIProperty as the lightweight option for UI-local owned values and UIDataBind for explicitly managed external values.
Use inline ordered callback storage to preserve registration-order dispatch without per-listener tree allocations.
Migrate submenu observation to scoped connections, safely clear ecode run configuration bindings before model erasure, and simplify the 7GUIs Counter example with UIProperty.
Add lifecycle, ordering, conversion, binding, and mutation regression tests.
Introduce contiguous PropertyId and ShorthandId enums backed by name-to-ID maps, replacing hash-valued property identifiers throughout the style system.
Replace PropertyIdSet's unordered set with a fixed-size bitset, eliminating heap allocations during style state changes while providing deterministic ascending iteration.
Keep name hashes for stylesheet storage and unknown or custom properties, while using dense typed IDs for registered-property lookup and dispatch.
Preserve property aliases and the public Checked compatibility identifier.
Add transaction-end reconciliation for interdependent image sizing properties, deferring percentage-based calculations until their containing block is resolved.
Keep formatting-context-owned sizes intact for table cells and inline content.
Add validation and tests for dense built-in registration, custom IDs, aliases, bitset operations, allocation-free storage, unknown properties, property application order, and image sizing regressions.
- MSVC:
- Removed lambda-based eeNew expansion in favor of typed MemoryManager::trackNew().
- Added macro expansion indirection.
- Enabled MSVC’s conforming preprocessor with /Zc:preprocessor across Premake 4/5 static libraries, shared libraries, and executables.
- Verified generated VS2022 projects contain the flag, including eterm-static and eepp-maps-static.
- Added explicit standard-library includes to memorymanagerglobal.cpp.
- Linux/macOS release tests:
- MemoryManager.tracesPlainNew is now compiled only with EE_MEMORY_MANAGER, since global tracing is intentionally debug-only.
Added new plan to improve PropertyIdSet.
- intercept global new/delete operations in debug memory-manager builds
- distinguish anonymous global allocations from source-tracked leaks
- modernize eeNew to support constructor-expression syntax
- improve memory reports with tabulated leaks and separate largest allocations
- cache autocomplete shortcuts instead of hashing string keys on key events
- reuse UIStyle property sets across state changes
- reuse Text shadow colors and avoid temporary outline-color copies
- use inline storage for temporary linear-gradient rendering data
- make unit tests resolve assets from the executable directory
- add memory-manager and PropertyIdSet regression coverage
Model HTML images as replaced UIHTMLWidget elements with independent loading, sizing, and rendering behavior.
Resolve auto margins according to each element's formatting context, including normal-flow blocks, positioned elements, flex items, and grid items. Preserve intrinsic sizing for block-level images with width:auto and constrain them through CSS min/max dimensions.
Correct absolute-positioned containing-block coordinates and rich-text handling of atomic inline elements. Add regression coverage for centered images, deferred image loading, grid margins, positioned elements, and document flow after image loading.
Document the remaining work required for dynamically changing non-atomic inline elements.
Avoid saving eeiv configuration during destruction (fixes window state saving).
- stop statement at-rules such as @charset at their semicolon
- preserve the following selector and declaration block
- support feature-level not() expressions in media queries
- add regression coverage for @charset and negated media features
Fixes Lobsters theme variables being discarded, which caused mixed light and dark colors when loading its stylesheets.
- move chrono implementation details out of the public Clock header
- define Sys system time as Unix epoch milliseconds
- add getUnixTimestamp() for epoch timestamps in seconds
- replace chrono wall-clock usage in ecode plugins with Sys APIs
- update existing Sys time callers for the new millisecond contract
- remove redundant chrono inclusion from HTTP tests
- remove the completed user-defined snippets plan
This prevents chrono and std::format internals from being instantiated across large portions of the project while preserving timestamp precision.
Snap dotted and dashed border geometry to physical pixels so centered
patterns cannot begin on ambiguous half-pixel coordinates. This makes
rectangular dot placement deterministic across llvmpipe and macOS GPU
drivers.
Update the old Reddit golden image to use the snapped dot phase.
Optimize compile-time header dependencies
- Extract lightweight singleton declarations.
- Remove unnecessary core.hpp, stream, pack, and container includes.
- Add explicit direct dependencies across system, network, graphics, and syntax headers.
- Forward-declare stream and pack types where possible.
- Normalize selected network headers to LF.
- implement per-side CSS border styles and patterned rendering
- preserve rectangular rasterization for thin dotted borders
- separate CSS and native-widget border defaults
- correct inline atomic-box and vertical-align baseline layout
- collapse adjacent block margins in rich-text flow
- preserve forced line breaks and formatting margins
- size HTML text inputs from font ascent and descent
- expose replaced-control text baselines to inline layout
- enforce single-owner painting for inline backgrounds and borders
- enable and update the old Reddit visual regression golden
- add generic layout, border, and form-control regression tests
- document spec-first HTML work and project build conventions
Resolve auto margins according to the element's formatting context instead of applying native block centering to every HTML child.
Inline-level replaced elements, inline-blocks, floats, and out-of-flow boxes now use zero-valued auto margins in rich-text measurement and positioning, while normal-flow blocks retain horizontal auto-margin resolution. This prevents asynchronously loaded images from feeding stale calculated margins back into their inline ancestors and producing unbounded document widths, as observed on the Asahi Linux site.
Add synchronous and threaded WebView regression coverage using the Asahi fixture, including its weighted host layout and asynchronous SVG loading.
Document the follow-up plan for explicit formatting-role margin resolution, shared image-content composition, and rebasing UIHTMLImage on UIHTMLWidget.
- batch asynchronous HTTP stylesheets and apply them in a single reload
- skip unsupported block at-rules without leaking nested rules
- prevent scripts nested in unknown custom elements from entering the render tree
- add regression coverage for unsupported at-rules and nested scripts
- document the Ninja release workflow for performance testing
Blockify floated inline elements and use wrap-content sizing for width-auto
floats so vote columns do not stretch across their containing block.
Recompute right-aligned text using the float's final shrink-to-fit width,
preventing overflow clipping from hiding rank text.
Handle bottom-edge fallback baselines in middle-aligned atomic boxes so
fixed-height inline parents do not vertically displace and clip elements
such as Reddit flair emoji.
Add a regression test covering the Reddit rank, vote arrows, rendered text,
and flair emoji alignment.
- Added UISceneNode::getVisibleWorldBounds() with an optional bounds-node binding.
- UIWebView binds its document scene to the scroll container’s clipped viewport.
- UINode::nodeDraw() now culls against visible scene bounds instead of the full document extent.
- Existing top-level scenes retain their previous behavior.
- Added a regression test confirming offscreen document widgets are skipped and visible widgets render.
eeiv: Add drag & drop of images and folders. Added small welcome screen.
eterm: Detect windows below the default width and height and resize the window to fix the screen.
ecode image viewing will not auto-scale images to the pixel density.
eeiv: Modernizing eeiv to use eepp GUI, already working just like before, there are probably a few things to fix.
- require propagated float placement to make forward progress
- avoid zero-displacement loops when float edges touch
- recompute collisions after each vertical adjustment
- add regression coverage for touching propagated and active floats
The float-aware rich-text layout was resetting curX for every block formatting context, including inline-blocks. That made consecutive action buttons overlap. The reset is now limited to block-level BFCs;
inline-blocks retain normal cursor advancement.
Added:
- An always-on deferred CSS regression covering inline anchors, inline-block siblings, and float exclusions.
- Strict action-row and title/domain ordering checks in the opt-in Reddit visual smoke test.
- A small CSS fixture reproducing Reddit’s layout rules.
Track percentage-based margins in UIHTMLWidget and re-resolve them when
the containing parent acquires its final size. This prevents margins
computed against an initial zero-width container from remaining stale
until the viewport is resized.
Add regressions covering percentage margin recomputation and the SS64
footer layout after a deferred stylesheet is loaded.
Reserve stylesheet source positions when link elements are encountered
instead of assigning them when asynchronous loading completes.
Track the stylesheet and rule ordinals explicitly so deferred external
styles retain their document order relative to later inline styles.
Preserve this ordering when extracting marked stylesheet rules.
Add an SS64 regression test covering heading and button styles after a
deferred stylesheet finishes loading.
Activate retained CSS cursors when the event dispatcher resolves a new
hover target instead of applying them at the end of UIWidget mouse-over
handling.
Resolve cursors through the nearest widget ancestor for non-widget hit
targets while allowing text inputs, editors, splitters, resize handles,
and plugins to override the default cursor contextually.
This restores ecode and Breeze cursor behavior without changing their
existing styles.
Map the standard CSS pointer value to the hand cursor and retain the
computed cursor in each UIWidget instead of mutating the scene during
style application.
Apply the retained cursor when a widget becomes the hover target, restore
the arrow when leaving the UI, and make cursor inheritance available to
descendants such as inline SVG elements.
Store cursor state in an existing UIWidget padding gap and centralize
cursor serialization in Cursor::toName().
Add regressions for pointer parsing, cursor serialization, inheritance,
and the SS64 search button SVG.
Propagate descendant float exclusions through non-BFC HTML containers so
floats participate in their nearest block formatting context.
Finalize line geometry before translating propagated exclusions, track
finalized lines incrementally, and search successive float bands when a
fixed-width inline-block does not fit beside active floats.
Recognize inline-block elements as block formatting contexts while
preserving their fixed width. Reuse persistent float-exclusion storage
across relayouts to avoid repeated allocations.
Add SS64 regressions covering narrow viewports, HiDPI rendering, stacked
floats, anchor sizing, SVG sizing, and footer overlap.
Fixed `cursor: pointer`, `pointer` was not registered.
Use border-box sizing for HTML buttons to match browser user-agent styles and
prevent padding from increasing explicitly declared button heights.
Keep inline SVG textures rasterized at full physical resolution while assigning
density-independent sprite destination sizes, avoiding double scaling on HiDPI
displays.
Add SS64 and pixel-density regressions for button alignment, percentage-sized
SVG layout, and drawable dimensions.
Resolve percentage dimensions for HTML-backed widgets after their containing
block has a definite size. Apply the resolution during rich-text, flex, and
grid layout without triggering broad layout invalidation.
Rasterize SVGs using their resolved dimensions when intrinsic width or height
attributes are missing or percentage-based.
Add regression coverage for percentage-sized SVGs and the SS64 navigation
buttons and search icon.
Preserve the final cross-axis size assigned to auto-sized stretched flex
items when their block layout runs. Keep intrinsic flex measurement
separate so content changes can still update item sizing correctly.
Add an HTML regression test covering a short sidebar stretched alongside
taller content.
- support runtime locator provider registration and removal
- filter snippets with workspace-relative include/exclude globs
- add the remaining VS Code-compatible snippet variables
- support camelcase, pascalcase, snakecase, and kebabcase modifiers
- reuse the existing insertion flow for locator-selected snippets
- expand snippet parser and store test coverage
- update the implementation plan and C/C++ example snippets
Refs: SpartanJ/ecode#111
Treat UIHTMLInput as the stable HTML/CSS host while keeping its native
control as an anonymous implementation detail.
Prevent author CSS from matching internal control widgets, avoiding
duplicated backgrounds and other styles. Keep valid input types such as
email intact for attribute selectors while falling back to compatible
native implementations.
Synchronize the internal control with the host content box after layout,
including flex sizing, and preserve intrinsic measurement for size and
font changes. Preserve input state across dynamic type changes and make
hidden transitions reversible.
Also fix border-radius calculations and add regressions for CSS ownership,
anonymous widget isolation, dynamic type changes, input sizing, and the
Causality newsletter form.
- parse slash-separated background position and size without requiring whitespace
- recognize custom-property background images following an explicit size
- resolve root body and html minimum heights against the layout viewport
- avoid expanding semantic document boxes to the scrollable content extent
- handle auto margins and percentage offsets correctly for absolute positioning
- add DuckDuckGo layout and background shorthand regression tests
- document the Xvfb limitation with multisampled OpenGL contexts
