RetroFuturaGUI is a signal-slot-based GUI framework written in C++. It merges retro-inspired and modern aesthetics with backward/forward compatibility - hence its name. The framework is designed for cross-platform use, and its logic can be compiled into a dynamic library, making it accessible from other languages while ensuring compatibility with past, current, and future standards.

• Font Manager
  • Update Windows font support to the new system
  • A family that isn't installed doesn't fail: LoadFont falls back to Arial's file and stores it under the name Arial, so GetFontInfo never finds the family it was asked for, returns nullptr - the widget draws no text - and loads one more Arial atlas on every call
  • Per-user fonts aren't found: the Windows side reads the machine's font list (HKEY_LOCAL_MACHINE) only
  • The Unicode block table (UnicodeBlocks.hpp) is from Unicode 6.0, so CJK Unified Ideographs end at U+9FCB instead of U+9FFF. The kanji in Japanese use lie below that, apart from 𠮟 (U+20B9F, in Extension B, 42,711 code points), which fonts and input methods mostly write as 叱 anyway
  • A glyph rendered on first use needs a GL context current; laid out without one, its text leaves the glyph out until it's laid out again- Update all Input to use PlatformBridge's implementation
• Test ITextEditable.cpp#L119 on Linux
• Text
  • Optimizations
  • Combining marks draw as glyphs of their own instead of over the letter before them, so a name stored decomposed (NFD) reads ヘ゛ where ベ is meant
• TextBox
  • suppress text overflow
  • Home and End don't move the caret, nor Shift with them extend the selection; a table cell being edited has the same gap
• Button
  • suppress text overflow
• Table
  • More cell types (TableProgressBar); TableText, TableColor, TableCheckBox and TableImage exist so far
  • Connect_/Disconnect_OnColorChange and OnCheckBoxChange: both signals are emitted when a cell's value changes but have no public connector yet
  • Checkbox inner padding (the gap between the box' border and its checkmark) is stored but not applied yet, so the checkmark fills the whole box
  • Auto track sizing (measure a track against its content); currently resolves like Fixed
  • Changing column widths and row heights by hand: dragging the line between two header cells resizes that track, down to a minimum, and a double-click on it fits the track to its content once Auto sizing exists. Tracks are only sized by code today (SetTrackDefinitions). The FileExplorer's columns would take it too, so a user can widen Name when the thumbnails and the preview squeeze it
  • Row/column spanning (the cells carry the spans already, the layout doesn't apply them yet)
  • Draw the header band's outer border (the width and colors are configurable but unused)
  • Keyboard traversal between cells (Tab); the arrow keys move the caret within a cell
  • Clipping is an axis-aligned scissor, so it stops being exact once the table carries a rotation
  • No scrolling by mouse wheel; an external Slider drives the scroll position, and the table scrolls itself only for the keys, a band or a drag
  • A drag of the selected rows reports the pointer (OnSelectionDrag), but the table can't mark the row a drop would land on yet
  • Key repeat counts frames, as the text cells' keys do, so held arrows run faster at a higher frame rate
  • Alt+press and Alt+drag are untested on Linux, where window managers often take Alt+drag to move the window
• Slider / ProgressBar
  • The graph doesn't account for the track's border width, so an enabled graph paints over the frame; the indicator does account for it
  • A Circle indicator takes its corner radius from the indicator's x size alone, so it draws as a rounded rectangle whenever the two axes differ
• IRangedMultiValue (shared base of Histogram and LineDiagram)
  • All data sets are read in one type, so while one set holds values SetData refuses a set in another type (and returns false). Sources that deliver different types need a type per set - and the min/max range then needs a type of its own, since today it follows the data's
• LineDiagram
  • The lines are only spaced by index across the longest set. Sets that cover the same span at different resolutions (32 and 64 frequency bands, say) want a mode that stretches every line across the full width
  • Labels and the hover text take the track's rotation, so with Orientation::Vertical they turn with the lines and read sideways
  • Where points sit closer together than the line is wide, the inner side of a mitered corner can fold back over the previous segment
  • A translucent line blends twice where a bevel overlaps its segments at a sharp turn - Polyline draws with GL_LEQUAL so the overlap isn't rejected by the depth test
  • The pointer is the inherited indicator, which IRangedValue switches on without ever applying its colors, so it stays invisible until EnableIndicator(true) or SetIndicatorBackgroundColors is called
  • No signal tells the application which line or data point is hovered
  • Labels always take their line's color; there is no label color of their own
• IDropDown (shared base of ComboBox and ExtendedComboBox)
  • _borderColorsEnabled/Disabled/Hover/Clicked and _backgroundColorsEnabled/Disabled/Hover/Clicked are never read or written. The colors that actually reach the closed box come from IBorder's _borderColorEnabled and IBackground's _backgroundColorEnabled - one letter apart - so assigning the IDropDown ones looks right and changes nothing
  • The per-row border (_dropDownItemBorder) is declared but never built or drawn
  • Most of the protected surface is only touched inside IDropDown.cpp and could be private: setDropDownArrowColors, setDropDownBackgroundColors, setDropDownBorderColors, dropDownCenter, rotateLocalOffset, the three per-state drop-down color sets, _highLightColor, _dropDownArrowPathFill, the three ColorState fields, _zOffset, _arrowPadding and _maxItemsToDraw - subclasses reach all of them through the public setters and setColors
  • _dropDownBackgroundColorSate and _dropDownBorderColorSate are missing a t
• ComboBox
  • Scrolling past the visible row cap; the list shows the first rows only, up to the cap
  • SetIndex neither clamps to the item count nor emits OnIndexChanged - only picking a row does
  • No SetEnabled override, so the disabled colors it carries never reach the elements
  • RemoveItem doesn't range-check its index and leaves the selected index pointing at whatever moved into that slot
  • Only the drop-down's corner radii are exposed (SetDropDownCornerRadii); the closed box has no public setter, and neither the panel's nor the arrow's fill type can be chosen, so their gradient fills are out of reach
  • The visible row cap is fixed at 8 with no setter
  • In the closed box the selected item's text can run under the arrow icon; only the border width is kept clear of it
• Prefab
  • Children aren't registered with the DynamicLibWidgetManager, so a binding can't address them by string ID yet. That needs a deregistration path as well, or destroying a prefab would leave the manager holding freed pointers
  • The Lasagna is fixed at construction; a prefab keeps whatever AxisDefinition it was built with
• Scene
  • Shared, cross-window scenes. SceneLoader::CreateScene hands back a std::unique_ptr, so a scene is one instance belonging to one window, and "the same scene in two windows" means instantiating the same description twice. Returning a shared scene is planned and needs three things: windows created with a shared GL context (done: every window shares textures, buffers and shaders with the first one created), per-context VAOs over shared buffers (done: the spec never shares VAOs or framebuffers, so VertexArray and Framebuffer keep one for each context that draws the object), and splitting shared state from per-window view. Consequence until then: a 3D Model changed in one window does not propagate to another - they are separate objects with separate transform matrices. For 2D widgets sharing is incoherent anyway, because Window::UpdateLayout writes screen-space positions into the widgets and two differently sized windows need different values in the same fields; for 3D content it is coherent, and the shape it wants is one world with a camera per window, which belongs to the planned Environment container rather than to Scene
  • Widgets are owned by the generated _p struct, not by the Scene, and the Scene owns only its root container. Closing a scene therefore has to tear down its owner's entry too - SceneLoader registers scenes and borrows a pointer, but whoever holds the unique_ptr owns the lifetime, so CloseScene needs a release hook to make closing actually complete rather than just unregistering
  • SceneLoader owns no assets yet, so nothing holds what scenes share. When it does it has to be the single asset cache rather than a second one beside ResourceManager, and widgets need a way to reach it - they currently load their own textures, SVGs and models straight from a path in their constructors
  • Loading is synchronous. SceneLoadingProgress always reports 1.0 for a scene that exists, and becomes meaningful only once asset loading is split into an off-thread prepare step and a main-thread realize step - every gl* call has to stay on the context thread, and destruction can never leave it at all
  • No lifecycle signals (OnActivate, OnDeactivate, OnLoad, OnUnload), so application code has nothing to hook a scene transition to
  • Overlay scenes don't block the scene underneath them. Widgets hit-test inside their own Draw, so there is no central pass that could stop at the topmost hit the way a raycast would. Docking avoids it geometrically - a content scene is never given the strip, so it has nothing there to click - but a modal overlay needs the scene beneath it disabled, passing emitSignal = false to SetEnabled so the sweep doesn't fire every connected slot
  • The root container is one of a fixed set - Lasagna, Environment, ScrollView or WindowTab, through the RootContainer concept. An IContainer interface would open it to any container
  • SetLasagnaAxis takes its AxisDefinition by value, copying three vectors per call
• SeparatorLine
  • The caption's left padding isn't clamped to the line's width, so a long caption or a large padding runs the gap and its text off the right end
  • The gap always starts from the left edge, so centering or right-aligning a caption means working out the padding by hand. SetTextAlignment doesn't do it either: the caption is always centered inside its own gap, and the alignment passed in is overwritten the next time the layout runs
• ColorPreview
  • The checkerboard's two colors and its square size are fixed internals, so neither the board's contrast nor its scale can be set from outside
  • The dual preview is on by default, so a preview that was never asked to be split is
  • Against the light checkerboard the white half reads almost the same as the checkered one - compositing over white and over a white/light-grey board differ only inside the grey squares. Drawing the color at full opacity there instead would carry information the checkered half can't
  • Each rectangle rotates around its own center, so a rotated dual preview pulls its halves apart instead of turning as one piece
  • DualPrevieAlignment is missing a w
• Window
  • Check if Draw()'s updateProjection() call can be made conditional again and also called at programmatic size change instead
  • Rounded window corners are cut by the fill shaders discarding fragments, so their edges aren't anti-aliased
  • The docking preview is a window of its own, so it gets a taskbar button while it shows. Hiding it needs WS_EX_TOOLWINDOW on Windows (_NET_WM_STATE_SKIP_TASKBAR on X11), which belongs in PlatformBridge
  • A minimized or maximized window stays out of the docking layout until it is restored, and minimizing a group's root leaves the rest of the group on screen
• WindowTab
  • Only the selected tab's window draws, so a window in a background tab pauses, as in ImGui: a video stops advancing (its audio keeps playing), Scene::Connect_OnUpdate stops ticking, and whatever they feed freezes until the tab shows again. A separate update step (see "Update and FixedUpdate loops") would let background tabs keep updating without drawing
  • The strip runs along the top only. Its fields have no icons, and there is no "+" field, no closing by middle-click and no switching tabs by keyboard
  • A dropped window goes to the end of the strip, the way ImGui docks one, not where the cursor is; reorder it by dragging afterwards
  • A dragged window stays a window until it is let go, instead of joining the strip as a tab right away the way browsers do
  • Fields that don't fit at their minimum width are left out; the strip doesn't scroll
  • Tabs don't nest: a window holding windows in tabs doesn't go into a tab, and a window in a tab takes none
  • The WindowTab's rotation is ignored, since the content is drawn through a viewport, which can't turn
  • Not addressable through the C binding (DynamicLibWidgetManager) yet
  • Linux is untested: a window in a tab keeps its native window, hidden, under the content area for its input, and whether X11 moves and reports an unmapped window the same way is unverified
• Popups
  • Widgets under a popup keep whatever hover color they had when it opened, since they stop reacting before they would reset it
  • A popup opens centered over the one below it, so a nested popup of the same size covers it completely
  • No key closes the top popup yet (Escape, Enter)
  • No styling API: a popup's window background, border, corner radii and bar are whatever the code building it sets, so the library's own popups (the FileExplorer and its prompts) can't be made to match an app's look. A style set on a popup, or once for every popup of a window, would do it, and later the aesthetics of roadmap 9
  • Linux is untested: the owner is set with XSetTransientForHint, and whether the popup stays off the taskbar is up to the window manager
• IWidget
  • SetEnabled ignores its emitSignal argument, so OnEnable and OnDisable never fire for widgets that don't override it - SvgImage among them, which is why a window bar polls its undock handle's state instead of listening
• SvgImage
  • No disabled look of its own. Graying it out means recoloring its named paths, which would overwrite path colors set by the application, so whoever owns the image does it
• ScrollView
  • Doesn't clip yet: content scrolled past its edges is still drawn, over whatever lies there. As the root container of a scene with a window bar, the bar has to be drawn after it to stay on top
  • SetAlignmentDirection is declared but not defined, so calling it doesn't link; the content always stacks vertically
• CheckBox
  • Every checkbox shares one checkmark (ResourceManager::GetCheckmarkIcon) but places it only when it is laid out, not right before it draws it, so of two checked boxes in one window both checkmarks draw where the last one laid out put it
• FileExplorer
  • No styling API: only the font can be set (SetFontFamily). Every color is fixed in FileExplorer.cpp - the bar, the buttons and menus, the list's row, header, selection and drop target colors, the toggles' accent, the scrollbar, the boxes - and the prompts (NamePrompt, ConfirmPrompt, ClashPrompt) copy them. A style set before Open, per widget kind and color state, which the prompts take over too, would let an app match its own look
  • With thumbnails on, the Name column gets what the thumbnails (72 px), Size, Modified and Type leave: about 70 px in the default 1000 px window with the preview pane, a few characters
  • The Thumbnails toggle was tried only by opening with the Thumbnails flag; clicking it, which keeps the selection and the top row in view, hasn't been done yet
  • The preview shows as many detail rows as fit, the most telling first; the rest can't be scrolled to yet. The row for playback controls stays empty until playing is built
  • A cloud file that isn't on this computer is downloaded to be previewed, which the pane says meanwhile; that hasn't been tried yet, since only personal files were at hand to download
  • The file operations were tried through their keys and prompts only, by posting key messages to the windows: the menu items, the Rename and Stop buttons, a slow double-click to rename and the clash prompt's Replace and Skip buttons haven't been clicked yet. Of drag and drop only a drop from another program was tried, called the way the system's drop calls it; dragging rows inside, the drop target marks and dragging out haven't been done with the mouse yet
  • Files dragged in from another program show where they would go only once dropped: GLFW takes drops as WM_DROPFILES, which tells nothing while they hover. While rows are dragged out, the system runs the drag in a loop of its own, so the app's windows don't draw until the drop
  • Linux can't drag files out yet: a drag past the window's edge stays the explorer's own
  • A Replace can't be undone in full: Undo takes the copy away, but the item it replaced was deleted. Undo covers what explorers with the Undo flag did, and only while the app runs
  • Redo (Ctrl+Y, and a Redo item in the Edit menu) is still to come: an undone step should go onto a redo list that the next new operation clears
  • The Hidden files and Extensions toggles are buttons drawn in an accent color while on; they become labeled checkboxes once a LabeledCheckBox prefab exists (roadmap 7)
  • Renaming has its own button in the menu strip; once a ContextMenu widget exists (roadmap 4), Rename moves to a right-click menu on the rows and the button goes. Delete, Cut, Copy and Paste join that menu too
  • Typing a name doesn't jump to it
  • File icons show only with thumbnails on; the plain list has none
  • The menu strip's titles and buttons use the font at 0.8 of its size so they fit; long drive labels still run past their place buttons (see Button)
  • Only filling the table is left on the main thread: storing the cells' strings and resolving the track sizes. In a Debug build the frame that shows WinSxS (35951 entries) takes about 140 ms, System32 (4781) under 40 ms
  • A folder still being listed when the app exits is cut off wherever its thread is, since a stuck listing is let go rather than waited for
  • Names in other scripts need a font holding their glyphs, set with SetFontFamily; the explorer only adds Latin-1 to its font itself
  • Its widgets are sized from the window size given to the constructor, so resizing the explorer's window doesn't refit them
  • From another language it opens over the main window only, and with an extensions string: the named filters stay C++-only. The Python binding's OpenFileExplorer hasn't been run, since no Python is installed here
  • Linux is untested: PlatformBridge::FileSystem's Linux side (listing, watching, the trash) and the in-app clipboard are written but have never been compiled
• Raster wrappers (IBackground, IBorder, IRangedValue, MenuBar)
  • The raster wrappers expose the Dotted settings only - no pattern selection and no secondary color - so a widget's background or border can't draw the Checkered pattern. Only a Rectangle owned directly can, which is why ColorPreview builds its own
• IBackground
  • Make SetBackgroundImage() differenciate between image formats and treat SVGs as SvgImage and implement path color setters
  • Padding that automatically applies to the background image as well
• AudioPlayback / MediaSource / Decoder
  • The FFmpeg half decodes, but nothing plays what it decodes yet. AudioPlayback still opens files through miniaudio alone, so only WAV, FLAC and MP3 are audible. Opus, Vorbis and audio inside containers (MKV/WebM/MP4) need a bridge: a custom ma_data_source that pulls frames from a Decoder and converts them with swr_convert
  • Decoder::Open refuses anything outside the codec allowlist in DecodingPolicy.hpp, so a build can't quietly start distributing a decoder it isn't licensed for. FreeCodecs holds the royalty-free and patent-expired ones (VP8/VP9/AV1, MPEG-2, MJPEG, FFV1, Theora, FLAC, Vorbis, Opus, MP3, 16-bit PCM); NonCommercialUseCodecs names the encumbered ones (H.264, HEVC, VVC, VC1, AAC) so a refusal can say which codec it refused and why. The FFmpeg build itself is LGPL 2.1 with GPL and nonfree off, and has to stay dynamically linked
  • FreeCodecs is narrower than the licensing situation: 24-bit and float PCM (WAV, AIFF), ALAC, ADX and Nintendo DSP ADPCM are all refused, although PCM has no patents at all and ALAC has been royalty-free since 2011. Each addition is a deliberate licensing decision rather than a code change
  • Packet owns an AVPacket's lifetime, but MediaSource::ReadPacket still takes a raw AVPacket* and leaves the unref to the caller. A Frame wrapper and a reader that runs the send / receive / drain / flush-after-seek protocol behind one call aren't built yet, so every caller currently repeats it by hand
  • A reader built on FindBestStream drops the packets of every other stream. That's right for audio alone; audio and video from one file will need a packet queue per stream
  • AudioMetadata's loop points (_Loop) aren't wired into AudioPlayback yet - ma_data_source_set_loop_point_in_pcm_frames is the hook
  • AudioMetadata doesn't read the Opus vendor string (it sits in OpusTags, which FFmpeg skips) or APE tags; WAV loops come from the first smpl loop only, and RF64/BW64/RIFX files aren't scanned for smpl at all
  • Cover art is handed over still encoded (JPEG/PNG bytes); a CoverArtCodec enum and decoded covers are planned
  • AHX and ADX encoding types other than 3 read but don't decode - FFmpeg has no AHX support at all, and its ADX decoder takes standard ADX only. Encrypted ADX decodes to noise without FFmpeg noticing, so AdxMetadata::_Decodable has to gate playback
  • One sound at a time. AudioPlayback owns a single ma_sound so it can be sought and queried, which means opening a second file replaces the first. Layered UI sounds want a second, fire-and-forget path alongside it
  • GetDuration is unreliable by format: Vorbis always reports 0 (an stb_vorbis push-mode limitation) and MP3 has to decode the whole file to answer, so it must be cached rather than polled
  • Playback speed shifts pitch with it, because it is resampling rather than time-stretching. miniaudio has no time-stretcher at all; pitch-preserving speed would mean routing through FFmpeg's atempo filter, which is already compiled into the build
  • Negative speeds do nothing - miniaudio drops any pitch <= 0, silently, through a void function. Reverse playback isn't a rate at all: it needs the decoded audio reversed by frame (not by sample, or the channels swap) behind a custom data source, which also gives up streaming
  • Levels are linear RMS with no dB helper, so a meter bound straight to them sits low and barely moves - music averages well under 0.3. A 20*log10 mapping belongs either in the meter widget or beside GetChannelVolume
  • The meter's decay is a fixed constant per processed block, so its feel shifts with the device's buffer size instead of with wall-clock time
  • No signals yet (OnPlaybackFinished, OnPositionChanged), so application code has nothing to hook a track ending to

• Better (relative) Viewports
• Custom text renderer with many IANA character sets

There are many C++ GUI frameworks available, but most come with one or more drawbacks: restrictive licensing, enforced use of proprietary containers, inflexible window layouts, limited design capabilities, or poor cross-platform support, often confined to C++ only. RetroFuturaGUI aims to break these barriers!

• SvgTexture.cpp
  • Draw() switches the depth test off for its whole draw so that its coplanar mask passes can blend over the base layer. That also lets any SVG drawn later in the frame paint over whatever is already there, whatever the z - an SvgImage in a later Lasagna cell paints over a widget reaching into it, for instance. Keeping the test on and using GL_LEQUAL for the mask passes would keep the blending and respect depth
• Text
  • A font size is rasterized as points at 96 DPI (FontManager::generateGlyphAtlas), so 25 draws glyphs about 33 px tall, but Text lays its lines out as if the size were pixels: the baseline, the line height and the caret all use 25. Since glyphs are clipped to their widget, a widget only a little taller than the font size cuts off the tails of p, g and y - a 30 px Label at 25 does
• TextBox.cpp
  • A TextBox reports WidgetTypeID::Button, so DynamicLibWidgetManager::SetText and ConnectSlot take the Button branch, dynamic_cast to Button* yields null and is then dereferenced. The WidgetTypeID::TextBox branches are unreachable as a result

AI is often used for repititive tasks like adding code comments to functions, classes, and structs and updating this readme's ToDo and feature list. Shaders are mostly written by AI and AI is sometimes used for finding bugs and to assist with complicated calculations. The architecture of font loading and Scene management was partially planned with AI. AudioMetadata.hpp/cpp are entirely written by AI. YUV to RGB conversion was done by AI. Multi-window support, transparent windows, window docking, window tabs and popups were written by AI, following a design of mine