Support explicit liga, calt, clig, and dlig shaping features and include
text hints in layout caching, measurement, drawing, and character
position calculations.
Propagate scene-wide font feature defaults through UI text producers,
with granular widget overrides and recursive cache invalidation. Update
UICodeEditor and UIConsole to use shaped positioning when font features
are enabled, including with monospaced fonts.
Add separate UI and editor font feature settings to ecode, persist them
as comma-separated OpenType tags, and apply changes immediately. Add
localized menu labels, reusable Text feature conversion helpers, and
regression coverage for shaping, positioning, propagation, and parsing.
Preserve explicitly selected font styles and correctly reconcile external fonts with the asynchronously loaded system font list.
Group same-family external fonts under the Style column when styles are visible, and expose them as distinct family entries when styles are hidden. Include filenames in localized external-font labels to distinguish alternate
font versions.
Ensure system-listed regular faces remain available after asynchronous loading and add regression coverage for collisions, selection, and hidden style behavior.
Implement spec-oriented paint phases for normal flow, floats, and
positioned descendants, including atomic stacking groups and applicable
z-index handling for flex and grid items.
Share cached ordering between drawing and hit testing, propagate
invalidation across stacking scopes, and preserve ancestor transforms
and clipping for promoted descendants.
Add regression coverage for paint order, hit testing, reparenting,
clipping, flex ordering, and the old Reddit layout. Document the
supported stacking model and remove the completed implementation plan.
- add a reusable right-side panel managed at the application level
- migrate debugger tabs to UITabWidgetSplitter instances
- support moving and splitting debugger tabs across bottom and right panels
- restrict debugger tab drops to debugger-owned panel targets
- serialize debugger tab layouts, panel state, and table column widths
- add pixel and percentage column-width modes to UIAbstractTableView
- support XML/CSS configuration and an optional width-mode context menu
- preserve percentage totals across resizing, fit-to-content, minimum widths,
scrollbar changes, and pixel-density rounding
- add splitter edge hiding while preserving splitter-always-show precedence
- use EventConnection ownership for safe widget and controller lifetimes
- validate serialized splitter layouts with structural limits
- display project-relative source paths in debugger stack frames
- add ecode localization strings, CSS documentation, tests, and agent rules
Refactor IniFile storage to keep keys and values in unified SmallVector-backed
records, avoiding parallel vector growth and allocations for common small
configurations.
Use std::string_view by value throughout the IniFile input API to prevent
temporary std::string allocations for keys, value names, paths, and comments.
Write serialized components directly to streams instead of constructing a
temporary string for every line.
Return ProjectBuildConfiguration by const reference to avoid copying it during
project saves, and use inline storage for DocumentView visual lines to avoid
heap allocations while rendering the code editor minimap.
Add IniFile tests covering parsing, mutation, ordered serialization, and a
byte-for-byte ecode project-state round trip.
Allow UIFontPickerDialog sections to be hidden and make ecode's UI, editor, and terminal font dialogs select both the font and its size.
Keep external fonts selectable across asynchronous font enumeration, including when they share a family name with a system font, and label them as external. Also normalize UILinearLayout weights across visible children so hidden picker columns release their space correctly.
Update font picker previews, size units, menu labels, translations, and lifetime handling.
Addresses SpartanJ/ecode#944.
- migrate TextRanges to SmallVector with capacity for two selections
- preserve vector, initializer-list, and single-range construction
- add coverage for inline storage, copying, and heap fallback
- export UIStyle::PropertyResolution for Windows shared builds
- reuse formatting, document text, property resolution, and layout storage
- use inline containers for interpolations, callbacks, wrapping, and matcher state
- optimize single-line insertion by mutating document lines without splitting
- iterate PATH entries directly in Sys::which and reuse candidate buffers
- avoid temporary clocks and string copies in frequent ecode plugin updates
- retain documents during autocomplete cache jobs and prevent duplicate scheduling
- fix PatternMatcher copy assignment and MSVC move-only container compilation
- expand coverage for matching, text insertion, reusable strings, and Sys::which
- 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
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
- 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.
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.
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.
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.
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
Fix:
- User fallback now uses "user-fallback-font".
- Built-in CJK and custom fallback fonts remain registered together.
- Added and passed a regression test verifying both fallback resources remain in the chain.
Fixes in premake5.lua:
- Removed obsolete PRECISE_F32=1; Wasm already provides precise float behavior.
- Moved ENVIRONMENT=worker,web to final application link options.
Fixed MarkdownView not getting the correct CSS style from the base theme.
