Commit Graph

Select branches

Hide Pull Requests

main

Mono Color

• 0872c9149b Make a scroll or fading viewport's sub-canvas again when the window's scale changes, rather than keep drawing it at the old one Prompt opened on a screen at scale 2 and moved to one at scale 1 drew its tab labels and icons at twice their size, with only a couple of letters fitting in each tab, while the star, the + and the menu beside the tab row, and the terminal, came out right. Opened on the second screen directly, the tabs were right too. The sub-canvases of scrolls (scroll_canvases) and fading viewports (viewport_canvases) are kept from one frame to the next and reused, resized when their size changes. Canvas::sub_canvas copies the parent's dpi_scale and layout viewport when it makes one, so a sub-canvas kept across a change of scale went on with the old one. Prompt's tab strip sits in a horizontal scroll, so its labels were drawn at px(13) × 2 on a canvas at scale 1. reuse_sub_canvas takes the pooled sub-canvas only while its dpi_scale matches the parent's, resizing it as before, and otherwise makes a new one with parent.sub_canvas, which takes the current scale, density and viewport. Both the scroll and the fading viewport go through it. Not verified: the move of Prompt between the two screens has not been tried with this change. main admin 2026-11-04 13:13:47 +01:00
• 9900443ff1 Text in the theme's primary text colour unless given another, rather than white A Text given no colour was drawn white, which on a light theme's white surfaces could not be read: Prompt's dialog to share tabs showed neither the code nor the time left in it, and the titles of the clip_path, file_chooser and tab_strip examples, drawn over the theme's background, did not show in the light theme. Text::new now takes the theme's text_primary, as the toast, the text field and the pickers already do, so a label given no colour reads on light and dark themes alike. Its documentation and the test of its defaults say so. admin 2026-11-03 17:05:43 +01:00
• 058a65546d The print dialog in the CHANGELOG and the widget catalogue The commit that added ltk::print left both out. CHANGELOG.md gains its entry under Added, after ltk::dirs: what the dialog offers, how the app answers its requests for a preview, CUPS loaded at first use, the printers, jobs and default printer for a settings page, the print portal for an app in a Flatpak with ltk::print::gtk for a portal backend, zbus in the wayland feature, and only saving as PDF on Windows, Android and in a browser. docs/widgets.md describes print_dialog among the pickers, after file_chooser, and links it from the table of contents: a component the app holds as it holds the file chooser, the preview the app renders on request, the job it delivers with ltk::print::send, and the builders that choose where it starts. Its example opens the dialog, answers its events and sends the PDF to a printer, and is compiled by make doctest-md. admin 2026-11-01 22:53:46 +01:00
• 45b8ddd483 A print dialog with a preview, CUPS and the print portal, a Windows backend, and ltk::dirs for the user's folders Printing. An app that wanted to print had nothing in ltk to ask the user where and how, nor to reach a printer. ltk::print (src/print/) is a dialog built as FileChooser is: the app holds a PrintDialog, puts its view() in its own and hands its PrintDialogMsgs to update(), which returns a PrintEvent; wrap makes the app's message of the dialog's, so the printer list reaches it through the app's ChannelSender. It offers the destination, the printers CUPS knows with their state and "Save as PDF", the number of copies, all pages or a range such as 1-3, 5, 8-, the paper (A4, Letter, Legal, A3, A5), the orientation, the margins, the scale, two-sided printing, colour and background graphics, the copies, sides and colour only for a printer. PrintOptions holds what was chosen and survives between dialogs, parse_pages and format_pages read and write the ranges. On a desktop the dialog is a card with ltk's dialog(), the preview on the left and the settings on the right; compact() makes it a whole page for a phone. .printer( name ) and .save_as_pdf() choose where it starts. The preview. With .preview( true ) the dialog asks the app for one with PrintEvent::Preview( options ) whenever a setting that moves the pages changes, and shows what the app hands back to PrintDialogMsg::previewed, a Preview of some pages as RGBA with the document's total, one page at a time with buttons to move between them, greyed when colour is off. While one is being rendered a new request waits and is sent only if the layout changed meanwhile, so turning the scale quickly does not stack renders; until the first arrives the sheet's box shows "Preparing the preview…", kept to the sheet's width so it does not push the settings aside. CUPS. print/cups.rs loads libcups.so.2 with dlopen at first use, so ltk neither links against it nor needs its headers, and a system without CUPS only loses its printers. It uses the destinations API, which also lists the network's driverless printers that have no queue: printers() with the default first, print( printer, title, options, pdf ) sending the PDF as one job with copies, media as a PWG name, sides and print-color-mode, jobs(), cancel() and set_default(), which writes the user's lpoptions. ltk::print::send, list_printers, jobs, cancel_job and set_default run them on a thread and answer through the app's sender; ltk::print::blocking exposes them as they are, for code that has its own thread, such as a portal backend. print/none.rs stands in on Windows, Android and the browser, where only saving as PDF is offered. The portal. An app in a Flatpak cannot reach the CUPS socket. When /.flatpak-info exists, the dialog shows nothing of its own: it calls org.freedesktop.portal.Print.PreparePrint with the options as GTK's print settings and page setup, and the portal's own dialog answers; Destination::Portal then carries its token, and send passes the PDF to Print through a memfd. The Response signal is subscribed to on the request's path before the call, so a quick answer is not missed. print/gtk.rs translates PrintOptions to and from GTK's keys (n-copies, page-ranges counted from zero, duplex, use-color, scale in percent, the paper by its PWG name and size in millimetres), which a portal backend uses for the other direction. zbus 4, the one accesskit_unix already brings, joins the wayland feature for it. The dialog's strings are in ltk's seven locales. file_chooser::view::icon is shared with the dialog. Windows. The windows feature runs ltk::run in a Win32 window on Windows 10 1703 or later, with Windows's own frame, drawn through ANGLE's EGL and OpenGL ES when libEGL.dll and libGLESv2.dll sit beside the executable and in software through GDI otherwise (src/platform/windows/). It sizes the window by App::window_size_hint at the display's DPI and follows per-monitor DPI changes at fractional scales and the accessibility text size; it takes the mouse, the wheel, touch through WM_POINTER, and keys with Windows's repeat, dead keys and AltGr; it has the system clipboard, the cursor's shape, full screen, and moves and resizes begun from the app's own chrome, and keeps drawing while the window is moved or resized. Themes, fonts, keyboard layouts and MIME globs come from ltk\ beside the executable, which ltk::resource_dir returns there by default; the font fallback chain and the monospace face are Windows's own, the system face stays the embedded Sora, and the file chooser offers each drive's root. A Win32 message loop cannot wait on calloop, so the runtime's timers and channels go through the queue the web backend already used: build.rs sets cfg( queued_sources ) for both, and AppData::dispatch_sources moves from the web backend to event_loop/sources.rs. Canvas::present_to presents a GPU frame stretched over a window that a fractional scale left a pixel off it, and EglContext::new_windows and create_native_surface give ANGLE's display and an HWND's surface. App::save_state is saved into %LOCALAPPDATA%\<app_id>\ every 30 seconds, on exit and when the user's session ends, and restored as on Wayland: the part of the Wayland session runtime that does not speak the protocol, deciding why the app starts and handing it its bytes, is now session_state::bootstrap, which both backends call, with the file modes and the check for a running instance done each platform's way. RunError::Window reports a window Windows refused. make windows-deps and make windows-check typecheck the backend from Debian, compiling std from rust-src. docs/windows.md describes building, what ships beside the executable and what the backend does. ltk::dirs. home, data_home, config_home, cache_home and state_home: XDG's on Linux, with their usual fallbacks under the home folder, and on Windows USERPROFILE, APPDATA for data and settings and LOCALAPPDATA for the cache and state, an XDG_* variable that is set winning everywhere. An app finds its files there instead of reading HOME and the XDG variables itself, which on Windows are unset; ltk's own lookups of themes, keyboard layouts, MIME globs, the file chooser's folders and the session state now go through it, and state_dir takes the base it is given, its tests with it. Docs. The links to WidgetId in the crate's, types' and App's documentation name the struct, since the const fn of the same name made them ambiguous to rustdoc. README.md names the other backends and CHANGELOG.md records the Windows backend and ltk::dirs. Not done. The print dialog has no CHANGELOG entry nor a page in docs/widgets.md. Under the portal there is no preview, since the portal's dialog gets the document only at the end. The desktop card's settings column does not scroll, so with a list open in a low window it may not fit. Tests cover the page ranges and the translation to GTK's keys, not the dialog, CUPS or the portal. On Windows there are no overlays, secondary surfaces or subsurfaces, no preedit for the input method and no accessibility. admin 2026-11-01 22:49:18 +01:00
• 02ab10b3ef State restored on an ordinary launch for apps that ask, focus that follows its widget's id, buttons that do not take the focus when pressed, a focus ring only after the keyboard, and a browser app's surfaces copied rather than transferred, which WebKit got wrong Restore on launch. restore_state follows Android's saved-instance-state contract: the saved bytes come back after a crash or a session restore, and a launch from the launcher starts fresh. Some apps keep state their users expect to find however the last run ended, as an Android browser keeps its tabs in its own storage even when closed from the app switcher. App::restore_on_launch, false by default, has the runtime restore on a plain launch too; SessionRuntime::bootstrap asks it before deciding. Saving, the file layout and the window geometry are the same either way. Its documentation explains when it is asked, that it is not when persistence is off, that restore_state must then merge what the launch itself asks for, such as a URL on the command line, and that what save_state returns now outlives every exit; it carries a compiled example. restore_state's documentation, docs/onboarding.md and the cookbook's session state recipe mention it. Focus on a press. Button::focusable( false ) and WindowButton kept out of the Tab cycle but still took the focus when pressed, and Enter then pressed them again, which closed a browser's tab when the user pressed Enter in a page after closing another tab. LaidOutWidget gains focus_on_press, from Element::focus_on_press: a button's focusable, a WindowButton's, a pressable's new Pressable::focus_on_press, true by default, and true for every other widget. focus_pressed replaces set_focus for pointer and touch presses and leaves the focus where it was when the widget does not take it. Enter's fallback to the widget under the pointer, which hovered_idx follows, skips such widgets too, and a rebuild that leaves the focus on one drops it (drop_misplaced_focus). The close buttons of tab_strip, on the desktop and on the phone's cards, are not focusable; symbol_button takes whether its button is. Focus by id. The focus was held as the index of a widget in the laid-out tree, so a rebuild that inserted or removed widgets before it moved it to whatever widget took that index. WidgetId becomes a name and a key, WidgetId::keyed( name, key ) telling apart widgets of the same kind, such as the tabs of a strip; WidgetId( "name" ) still builds one, through a const fn of that name, so the calls in every app compile unchanged, and only code that read .0, the toasts, the combo and the tooltip here, moves to the derived Hash or name(). After each layout follow_focused_id finds the focused id and moves the focus to its new index with the field's pending text, cursor, selection and scroll; it drops the focus when the widget is gone, keeps it when a scroll only clipped it, and leaves it when the widget at the old index still has the id. draw_surface returns whether the focus moved, and its callers draw the surface again rather than marking it done, since the frame just drawn showed the focus in the old place. Widgets without an id keep the index. Each tab and each card of tab_strip carries WidgetId::keyed with the tab's key, so a chosen tab keeps the focus while others close. Focus ring. A press that focused a button, a toggle or a list item left its ring drawn, which browsers have not done since :focus-visible. SurfaceState::focus_visible is set by Tab and Shift+Tab and cleared by a press that moves the focus, show_focus_ring redrawing the whole surface when it changes, since the partial redraw only sees indices. The draw is given the focused index only while the ring shows or the widget is a text field, which draws its cursor however it was focused; the focus itself is unchanged, so Enter and Space still press the widget. Key repeat. A key repeated by the platform rather than by ltk's own timer reached the focused widget even while App::claims_keyboard was true; key_repeated checks it as key_press does. Browser surfaces. Every surface is painted through the app's one WebGL context on one OffscreenCanvas, and was handed to its own canvas, a bitmaprenderer, with transferToImageBitmap. WebKit reuses the buffer of a bitmap it was handed, so in a WebKit browser each surface showed another's frame, or none, and only the last one painted was right: forge/web's background, dock and windows came and went in a WPE browser while Chromium showed them all. A test page with two canvases fed from one offscreen canvas showed their colours swapped in WPE and right with a copy. Each surface's canvas is now a 2d one, and present_copy copies the offscreen canvas with drawImage in copy composition, set before every copy since resizing a canvas resets its context, so a transparent frame replaces the last rather than leaving trails behind an animation. Subsurfaces go the same way. WebSurfaceState loses bitmap and new its gpu argument, and web-sys loses the ImageBitmap and ImageBitmapRenderingContext features. CHANGELOG records each of these. Not done. The tests that build LaidOutWidget by hand set the new field, but no test covers a press on a non-focusable button, the focus following an id or the ring. For one frame after a rebuild moves the focused widget, its ring and its cursor may show in the old place. admin 2026-11-01 09:19:23 +01:00
• da34eee9e6 External textures drawn at their own size, a repaint without rebuilding the view, an icon size for list rows, and lighter tabs on the desktop strip External textures. ExternalSource::Texture stretches its texture over the widget's rect, so a producer that is a few frames behind a new rect shows its old picture stretched or squeezed. A web page while its window is resized is the clearest case: the page keeps sending frames of the old size until it has laid itself out again, and the content wobbles as the window moves. The new ExternalSource::Frame closure returns the texture with its size in physical pixels, and the texture is drawn at that size from the rect's top left corner, cut to the rect. A late frame then leaves an empty edge or loses one for a moment, as other browsers do, instead of being distorted. The cut uses interior_clip, which moves from the text field's drawing code to render/clip.rs so both widgets can use it, and the clip that was active before is restored afterwards. Repaint without a view. An application whose only change is a new frame in an external texture had to report InvalidationScope::All, which rebuilds the whole view just to draw the same widgets again. App::needs_repaint is asked once per iteration, after the messages are processed. When it returns true, the main surface and the secondary surfaces are redrawn from the cached view, without calling view. The default is false, so existing applications behave as before. List rows. ListItem::icon_size overrides the size of the leading icon, which was always the theme's 24 design px, for dense lists such as a menu, where an icon of that size dominates the row. Tab strip. On the desktop, a tab's title is drawn at the regular weight whether it is selected or not; the selected tab already stands out by its fill and edge, and the bold title made the strip heavy. The desktop tab's close icon is 10 widget pixels instead of the 16 that the cards of the tab overview keep, so parts::close now takes the icon size from its caller. admin 2026-10-27 12:46:20 +01:00
• 8882078743 A text field that serves as an editor, a file chooser, ltk::files with callbacks, Text::fit, App::window_title, and a stack that keeps its children inside it A multiline text field was a box for a few lines: it wrapped its whole value by shaping each character alone on every frame, every click and every caret motion, so a file of some size made it crawl; it drew a tab as the font's glyph for it, had no scroll bar, no page keys and no way to number its lines, kept no record of the view it showed, so once the cursor had left the first screen it stayed on the last row and the arrows moved the text, and an app could neither colour its text, type a tab with Tab, give it a face of its own, ask it to copy, cut, paste or select, nor hear where its cursor was. Notes, the Eydos text editor, needs all of it, and every app that opens or saves the user's files needed a dialog of its own. Speed. Canvas::measure_char measures a character's advance once per font and size and keeps it (text_shaping::char_advance_cached, emptied with the shaped lines), and compute_visual_lines keeps the last four layouts by the value's hash and length, the row width, the size and the face, so a value is wrapped again only when one of them changes, and drawing, hit testing and caret motion over the same value wrap it once. The view. TextEdit::draw returns the view it showed, which the frame keeps in text_scroll, so the view moves only when the cursor leaves it, and by the least; a TextCommand::Select no longer resets it. Window::shown gives the lines as the last frame showed them, wherever the cursor went since, and a press, the wheel, the scroll bar and the page keys act on them: a press that gave a field the focus, which puts its cursor at the end, landed where the view would have gone to show that cursor, near the end of the text, instead of on the character pressed. The cursor a scroll keeps is taken back to the value's length as the view's is, so a scroll made with the cursor at its end sentinel holds instead of going back to the cursor at once. Tabs. In a multiline field a tab reaches the next stop, every four digits' widths, as four monospace columns are (theme::TAB_COLUMNS, text_edit/tabs.rs), when it is drawn, selected, clicked and crossed with the arrows. TextEdit::tab_text( text ) has Tab type text while the field has the focus instead of moving the focus on; Shift+Tab still moves it back and Ctrl+Tab still reaches the app. The scroll bar. A field whose lines do not all fit shows a scroll bar along its right edge (Window::scrollbar): its thumb is held and dragged, or a press on its track brings the thumb there, by pointer or touch, without moving the cursor (AppData::text_scrollbar_grab, handle_text_scrollbar_press, handle_text_scrollbar_drag); the pointer over it is the arrow rather than the text cursor, and a long press that holds it no longer opens the Copy / Cut / Paste menu. Page Up and Page Down move the cursor of a multiline field by the lines on screen but one, at the same height on screen, and the view with it, to the start or the end from the first or the last page (cursor_visual_page, handle_cursor_page); Shift extends the selection, and with Ctrl, or in any other widget, the keys still reach the app. A key without Ctrl that types no text, such as F3, was dropped while a text field had the focus; it now goes to App::on_key_with_modifiers, as it does with no field focused. The text as an editor's. TextEdit::highlights( Arc<Vec<TextHighlight>> ) draws runs of a multiline value, byte ranges in order, in colours of their own, what no run covers in the field's colour and a run off a character boundary left out. TextEdit::font( face ) lays a multiline field's text out in a face of its own at the field's size: wrapping, drawing, the selection, the cursor, clicks, tab stops and the arrows all measure through one TextFont, the size and the face, which text_input_geometry now gives the runtime's paths where it gave them the size; Canvas::measure_char_with_font is measure_char in another face. ltk::monospace_font() finds a monospace face, DejaVu Sans Mono from the app's resources, which a page and an APK carry, else the first of the system's installed, loaded once. TextEdit::line_numbers( true ) numbers the lines in a column at the field's left, in the monospace face when there is one, as wide as the number of the last line needs, a wrapped line numbered on its first row and the cursor's in the text colour while the field has the focus; the text starts right of the column alike when drawn and in every runtime path, since they all lay it out in the rect gutter::text_rect gives. borderless() now also drops a multiline field's background and border. Talking to the field. App::take_text_command hands a field, by its WidgetId, a TextCommand after the next frame: Copy, Cut, Paste and SelectAll through the paths the keys take, and Select { start, end }, which focuses the field, selects the range with its ends taken back to the value and to its characters' starts, and scrolls to it. Reveal { start, end } does the same without moving the focus, as a search does while its own field keeps the keys, and a multiline field without the focus now shows its selection dimmed (theme::selection_inactive). TextEdit::on_cursor( |at| … ) sends the cursor's byte offset once it is placed and whenever it moves or the value changes length (report_text_cursors, after every frame), as an editor's status bar showing the line needs. A file chooser. ltk::FileChooser (src/file_chooser/) picks a file to open or a folder and a name to save one as, over ltk::files, alike natively and in a browser. The app holds it, puts its view() in its own and hands its FileChooserMsgs to update(), which returns Chosen::Path or Chosen::Cancelled once the user chose; wrap makes the app's message of the chooser's, so its listings reach it through the app's ChannelSender. It offers the home folder, the xdg-user-dirs folders that exist, the root and the folders mounted in a browser, with a press there to mount another; it lists folders first, the hidden entries left out, each with its type's icon, a file with its size and the date of its last access or change, sorted as Crate sorts, by name, last access or size, each key in a direction of its own (Sort, SortKey, Directions). dir starts elsewhere, filter( &[ "text/*" ] ) shows only some types of files, compact( true ) puts the places behind a button for a phone, sort starts in an order kept from current_sort, and take_focus_request gives the field to focus. Saving asks before replacing a file and can create a folder; its errors are in the user's words, and its strings in ltk's seven locales. files::mounts() gives the folders mounted in a browser as the desktop last said, which the web backend now keeps. docs/widgets.md describes it and examples/file_chooser.rs shows it, in make examples. ltk::files::callback. The operations of ltk::files with a function in place of a message (list, stat, read, read_range, write, create_dir, rename, remove, remove_all, copy, copy_all, mount and unmount), for code with no run loop's ChannelSender to take one, such as Prompt's session daemon, which in a browser runs in the page beside the window. done is called on ltk's worker thread natively and on the page's thread in a browser. Closing. An app that keeps its window open in on_close_requested, to ask whether to save, was not drawn again, so its question appeared only at the next event, such as a press. Every close request, from the compositor, the title bar's close button, back and the browser, now goes through AppData::request_close, which draws the view again when the app refused it. App::window_title. The main window's title, read when the window is made, which the title bar, the task switcher and the dock show; by default the app_id. A ShellMode::Window app was titled "ltk" on Wayland, whatever the app, with no way to name it but the deprecated window_config; in a browser its title was its app_id, and is now this. Text::fit and Text::valign. fit() draws a text at the largest size up to its own at which it fits the rect the layout gives it, on one line within its width and height or, with wrap, all its lines within its height, so a text whose length varies, such as a calculator's display, neither overflows a box the window sizes nor needs its size worked out from the window and its content; its preferred size is still the one at its own size. valign( VAlign ) places the lines at the top, the centre or the bottom of the rect. A stack keeps its children inside it. A child that Stack aligned to an edge or the centre took its preferred size even when that was larger than the stack, so one aligned to the bottom started above the stack's top and one aligned to the right left of its left edge, drawn over whatever was there. Each child's preferred size is now capped by the stack's, less its margin, before it is aligned; children placed with push_placed and the offsets of push_translated are as they were. Tests cover Tab with and without tab_text, the text commands, Reveal leaving the focus alone, a highlight into a character, on_cursor reporting once, a refused close drawing again, a key that types nothing reaching the app from a field, tab stops, a click on a tab, the kept layouts, the scroll bar, a view kept while the cursor moves inside it and after a scroll with the cursor at its sentinel, a click landing on the view shown, the page keys, the width of the line numbers, the file chooser's listing, filters, names, user folders, sizes, sorting and its open, save and replace flows, Text::fit and a stack's aligned children. CHANGELOG.md and docs/widgets.md describe the changes. admin 2026-10-26 23:00:33 +01:00
• 18a0e02249 A pull from the top that is unwound back to where it started still reports its release, so an app that followed the pull hears that it was not committed A scroll view at its top turns a downward drag into overscroll, which on_move reports as MoveOutcome::OverscrollDown { progress }, and on release ReleaseEvent::OverscrollDown { committed } tells the app whether the pull went past its threshold, as pull-from-top-to-dismiss needs. The release was reported only while overscroll_y was above zero. A pull dragged back up until it was unwound to zero therefore ended without any release event, and an app that had moved its view with the pull's progress was left waiting for one, its view where the last progress put it. GestureState::overscroll_engaged is set once a gesture has reported overscroll progress and cleared with the rest of the gesture's state. On release, a gesture that reported progress now always gets its OverscrollDown, uncommitted when nothing is left of the pull. A gesture that never reached overscroll still reports nothing. Tests cover a pull unwound to zero, which reports an uncommitted release, and a drag that only scrolled, which reports none. CHANGELOG.md describes the change. admin 2026-10-25 17:33:32 +01:00
• 8f689ec479 An ltk app pastes what other applications copied, the middle button pastes the selection just made, a browser desktop's applications share the clipboard and the primary selection, and the office icons are drawn like the terminal's Pasting from other applications. Neither Ctrl+V nor the middle button pasted into an ltk app anything copied in another application; only what was copied within the same process pasted. The Wayland backend bound its wl_data_device and its primary-selection device in SeatHandler::new_seat, which smithay-client-toolkit calls only for seats announced after start-up: SeatState::new binds the seats already in the registry without calling it, and on every compositor the seat is there when the app connects. The app therefore never had either device, the compositor never offered it another client's selection, and what it copied did not reach other applications through the compositor either. A Wayland trace of prompt shows both managers bound and neither get_data_device nor get_device sent. Both devices are now bound in new_capability, which comes for every seat, the first time it does; new_seat does nothing. The middle button and a selection just made. A compositor offers the primary selection to the window it gives the keyboard, and gives it on the press, so a middle click on a window that did not have the keyboard arrives together with the offer. ltk reads an offer on a thread of its own and pasted at once what it held, so after selecting in another application an ltk app pasted the selection before that. Platform::primary_selection_pending says whether another application's selection is still being read: the Wayland backend counts the reader threads it starts and the selections that arrive (PrimarySelection::pending), and the other backends answer false. A middle-button paste, into the text field under the pointer (PrimaryPaste::Field) or for an app that asked with SelectionKind::Primary (PrimaryPaste::App), goes through AppData::paste_primary, which while a read is pending keeps it in pending_primary_paste; check_primary_paste, run before every draw, makes it once the selection has arrived or after 500 ms with what there is, and next_primary_paste_wakeup wakes the loop every 10 ms meanwhile, since the reading thread does not. A field paste is made only if the field still has the focus. The clipboard and the primary selection in a browser desktop. On a page with forge/web, what an app copies goes to forge/web as a set_selection request as well as to the browser's clipboard, and the selection the middle button pastes, which did nothing in a browser, as set_primary_selection (Connection::set_selection). forge/web's selection and primary_selection events, which every client hears when one sets them and each hears on connecting, become PageEvent::Selection and so AppData::clipboard and AppData::primary_selection, as another client's selection does on Wayland. Copying, and selecting and pasting with the middle button, thus work between the page's applications whether or not the browser lets a page write its clipboard. A paste from the browser still brings what other applications of the computer copied; a browser has no primary selection a page can reach. The office icons. The default theme's word processor, spreadsheet and presentation icons came from Figma with a foreignObject backdrop blur that resvg ignores, and showed as flat white discs with pale glyphs. They are drawn again as the terminal's are: a dark gradient disc in each one's colour (blue, green, orange), a bright glyph and the terminal's filter. The doc comment of ltk::files links write() as a function, since write alone was ambiguous with the macro for rustdoc. CHANGELOG.md describes the changes. admin 2026-10-23 19:20:10 +02:00
• cf187a3dcc The user's files through ltk::files, alike natively and in a browser, and a shell's requests answered in a browser through ltk::web::shell_request An app read the user's files with std::fs, which a browser does not have: there a page reaches a folder of the user's computer only through forge/web, which holds it through the File System Access API and answers asynchronously (forge/web/DESIGN.md, section 11). An app that builds for both, such as Crate, had no way to list, read or write a file in a browser, and a page's memory cannot hold a large file whole. ltk::files. Asynchronous operations on the user's files whose results reach the app as messages through its ChannelSender: list, stat, read, read_range, write, open_write, create_dir, rename, remove, remove_all, copy, copy_all, mount and unmount, each taking the sender and a done that turns the io::Result into a message. Results come in no set order, so an app that has moved on checks that one is still the one it waits for. Errors are the same io::ErrorKinds on every platform, Interrupted for a cancelled copy. Entry and Metadata give a file's kind, size and times, the access time natively only. ltk::vfs stays what reads an app's own resources. Natively. std::fs on one worker thread of ltk's, in the order the app asked (files/native.rs), and each copy on a thread of its own, so a long one holds nothing else up (files/copy.rs). A file written whole or through a Writer goes beside its target as a temporary file, synced and renamed over it on commit and removed if dropped before, so a file being written is never seen half done. rename never replaces what is at to, as in a browser. In a browser. Each operation is one of forge/web's fs_* requests over the app's connection (platform/web/files.rs), carrying a number its fs_reply answers with; contents travel as a Uint8Array beside the JSON, the second argument of the connection's request and of the client's event handler, so on_event now takes it. What is asked before the app has connected is sent once it has; on a page without a desktop, or once the connection has closed, it fails with Unsupported. forge/web's error codes become their io::ErrorKinds, and fs_progress reaches a copy's progress. Without the web backend, on wasm32 every operation fails with Unsupported (files/unsupported.rs). Chunks. Contents never travel whole unless they are small: a large file is read with read_range and written through a Writer, chunk by chunk, files::CHUNK (1 MiB) at a time, the next sent once the last is answered. A Writer dropped without close is aborted and the file left as it was; in a browser a new file shows empty until closed. A copy runs where the files are, its contents never passing through the app: it reports its progress every 100 ms, never replaces an existing file, and, cancelled through its Operation or failed, leaves nothing behind. Mounts and the desktop's notices. mount asks the browser for a folder of the user's computer, from the user's press, and unmount lets it go; natively both fail with Unsupported. App::on_files_changed, App::on_mounts_changed and App::on_open_files hear of forge/web's fs_changed, fs_mounts and open_files, which the web backend queues as page events; natively they are not called yet. Types. files::mime_type( name ) gives a file's type by shared-mime-info's globs2, with its weights, its case-sensitive globs and fnmatch's *, ? and bracket classes, from the resource directory's mime/ first, then the user's and the system's. scripts/android-assets.sh, and so web-assets.sh, now copies shared-mime-info's globs2 and subclasses into the tree's mime/ (MIME_DIR overrides where from), so a page has them. ltk::web::shell_request. A shell message that waits for forge/web's reply, such as get_window_thumbnail: sent as shell_send sends one and answered at once with forge/web's reply as JSON, or None before the app has connected, since a request is not kept for later, and when forge/web replies nothing. A shell's requests that wait for an answer natively got none in a browser. shell.rs parses a message once for both, and send returns forge/web's reply. Tests cover writing and committing, aborting, listing, ranges, removing, copying a tree with its progress, a cancelled copy, a copy that would replace, and the globs. CHANGELOG.md describes the changes. admin 2026-10-22 00:15:39 +02:00
• af4009374d A browser app takes part in the desktop as a Wayland client does: fullscreen, the desktop's windows, activation and the shell protocol through forge/web, its own files through ltk::vfs, and images its caller names On a page with forge/web an ltk app had a main surface, overlays and subsurfaces, but none of what a shell such as crustace needs from the compositor: fullscreen did nothing, the app heard nothing of the other windows, an activation token it asked for never came, forge/web was never told when a launched window had shown, the shell could not speak its protocol, and the app had no way to read its own files in a browser. Each now goes through the app's connection to forge/web, in the shape of the Wayland protocol it stands for. Fullscreen. On a page with forge/web, App::fullscreen and App::start_fullscreen send a set_fullscreen request for the main window, as xdg_toplevel.set_fullscreen does, instead of doing nothing; alone on a page the canvas still takes the browser's fullscreen. examples/web_hello.rs gains a button that toggles it. The desktop's windows. On connecting, the backend asks for the list of toplevels, and forge/web's toplevel_opened and toplevel_closed events become ToplevelEvents for App::on_toplevel_event, as ext-foreign-toplevel-list-v1 does on Wayland, so a shell's dock knows which applications have windows open. Activation. The tokens an app asks for with App::take_activation_requests are issued before it draws: forge/web's, through its activation_token request, or empty without a desktop, as on Wayland without xdg-activation, and handed to App::on_activation_token with their messages processed. A browser app that launched others through tokens waited for one that never came. Each surface's first presented frame is reported with a presented request (WebSurfaceState::presented), so forge/web knows when a window it launched has shown and can report it activated, which dismisses crustace's splash. The shell protocol. platform/web/shell.rs carries the JSON a shell speaks to forge over its socket over the app's connection to forge/web: ltk::web::shell_send( json ) sends it as a shell request, and each shell event's message reaches the listener ltk::web::set_shell_listener gives, as JSON. What is sent before the app has connected is kept and sent once it has, so a shell can tell forge/web its theme while it starts. An overlay's role now carries its App::overlay_namespace, as its layer-shell namespace does on Wayland, so forge/web can tell a shell's overlays apart. The cursor over every surface. The CSS cursor was set on the main surface's element only, so over an overlay the pointer kept the page's arrow. WebSurfaceState keeps the element that takes its input, the shape moves to that of the surface the pointer enters, and WebPlatform::cursor keeps the last one asked for. An app's own files. ltk::vfs, through which ltk reads its themes, fonts and keyboard layouts, is public: read, read_to_string, read_dir, is_file and is_dir read the file system natively and, in a browser, the files the page loaded into memory. ltk::web::load_tree( base, root ).await loads any tree served with a MANIFEST under root, and load_resources is that into /ltk with the directory made the resource directory. ltk::time::Instant is public too, std's natively and web_time's on wasm32, where std::time::Instant::now panics, so an app that builds for both measures time with ltk's clock. wasm-bindgen-cli. scripts/wasm-bindgen-cli.sh TOOLS_DIR builds wasm-bindgen-cli into TOOLS_DIR/bin at the version of the wasm-bindgen crate ltk pins in its Cargo.toml, from its sources with a lock resolved for Debian's rustc, which is what make web-deps did inline and now runs. Since make install copies scripts/ into the registry, a project that builds for the browser against the installed ltk, such as forge/web or crustace, gets the same CLI without a checkout of ltk. The README and docs/architecture.md say so. Images named by their caller. Every draw through draw_image_data fingerprints its pixels to find them in the image caches, which for a terminal means hashing every glyph of every frame. Canvas::draw_image_keyed( key, rgba, w, h, dest, opacity ) is draw_image_data with key naming the pixels in place of their fingerprint: every draw with the same key must pass the same pixels, which are read only when the image is not cached. Both backends' caches are keyed by ImageId, Content for a fingerprint and Keyed for a caller's key, so a key never names an image drawn by content even when it equals its fingerprint. GlesCanvas and SoftwareCanvas gain draw_image_keyed, and their draw_image_data and it share one private draw_image. Tests check that a keyed image draws as its pixels do and that a key equal to a fingerprint is another image. A held button is not also tapped. A button with on_long_press and no on_drag_start stayed a tap after its hold fired, so releasing it sent its on_press as well. GestureState::long_press_msg_fired is set when the hold fires long_press_msg and suppresses the press message on release; a test covers it. CHANGELOG.md describes these changes. admin 2026-10-21 10:21:11 +02:00
• cd1a233b2e A browser app joins the page's desktop: on a page with forge/web its main surface, overlays and subsurfaces are surfaces of that desktop, all painted through one WebGL context The browser backend ran an app alone on a canvas over the page. An Eydos desktop in a browser needs crustace as its shell and other ltk apps as its windows on one page, managed by forge/web (forge's web/ directory), which publishes globalThis.forgeWeb and stacks, places and focuses the surfaces its clients ask for (forge/web/DESIGN.md). The desktop's client. On a page where globalThis.forgeWeb exists and set_canvas named no canvas, platform/web/desktop.rs connects as the app's app_id and asks for the main surface in the role the app's hooks give, as a Wayland compositor reads them: shell_mode, and for a layer layer_anchor, layer_size, exclusive_zone and keyboard_exclusive, for a window app_id and window_size_hint, and for SessionLock a full overlay that holds the keyboard. The app draws into the canvas forge/web gives and listens on the input element above it, takes its size and scale from forge/web's configure rather than from the window's resize, sends its input region in logical pixels when it changes, and leaves the keyboard focus to the desktop, which honours the surfaces that hold it exclusively. A close of the main surface reaches App::on_close_requested; on exit the surface is destroyed and the connection closed. The new RunError::Desktop says forge/web refused the main surface. Fullscreen inside a desktop does nothing yet. A page without a desktop, or one that named a canvas, runs the app as before. One WebGL context. A page holds few WebGL contexts, and the browser loses the oldest beyond them, while a shell has many surfaces. Every surface of an app now paints through one WebGL2 context on an OffscreenCanvas: the surface's FBO is blitted onto it, taken as an ImageBitmap and handed to the surface's own canvas, a bitmaprenderer, without a copy. Without WebGL2 each surface draws in software on a 2D context of its own. The context's loss is heard on the OffscreenCanvas, and now drops the GPU canvases of every surface, not only the main one's. Overlays. platform/web/overlays.rs keeps the app's overlays in step with App::overlays(), as the Wayland backend's overlays_reconcile.rs does with layer-shell: a new one becomes a layer surface or, for Layer::Window, a window, with its size and exclusive zone in logical pixels; a changed one gets an update_role; one that went is destroyed; forge/web's close of one delivers its on_dismiss. Popups anchored to a widget and the tooltip wait for a popup role forge/web does not have, and without a desktop an app still shows no overlays. What every backend does as overlays come and go, resolving an OverlaySpec::size and moving a drag and the focuses off an overlay that goes, moved out of the Wayland backend into event_loop/overlays.rs (AppData::overlay_size, AppData::remove_overlay); Wayland's behaviour is unchanged. Subsurfaces. platform/web/subsurfaces.rs makes each of App::subsurfaces() a surface of the desktop sized to its parent with an empty input region, painted on one shared GPU canvas only when it appears, its size changes or its content_version does, its frame then staying on its own canvas, and otherwise moved with an update_role, which the browser composes without painting. App::on_subsurface_committed follows each paint. A subsurface whose parent overlay was destroyed and made again is made again, since forge/web destroys a subsurface with its parent. frame_presented now knows whether a surface hosts subsurfaces, so while the app animates by subsurface motion only its frames keep coming without painting the parent, as Wayland keeps a parent's frame callbacks. Painting a view with no focus, hover or press on a canvas of its own, which both backends' subsurfaces do, moved out of the Wayland backend into draw::paint_detached. Input per surface. input::listen takes the surface's SurfaceFocus, which pointer, touch and keyboard focus events carry; a surface's blur no longer takes the keyboard from the surface focused after it. Listeners remove themselves when dropped, and a surface's live in its WebSurfaceState, so they go with it. The frames owed at the next animation frame are a list of surfaces instead of one, which with several surfaces left the main one waiting on a frame that never came. examples/web_shell.rs is a shell for the desktop: a background, a bar in the top layer with an exclusive zone, a panel that takes the keyboard, and a card on a subsurface that slides. make web-example builds it with web_hello (WEB_EXAMPLES); forge/web's make hello serves both at /shell.html. web-sys gains OffscreenCanvas, ImageBitmap and ImageBitmapRenderingContext. CHANGELOG.md describes the change. Not done. Popups and the tooltip in a desktop, overlays and subsurfaces without one, fullscreen and window moves through forge/web, and the cursor's shape over an overlay, which is still set on the main surface's element. The offscreen canvas is resized for each surface it paints, which reallocates its drawing buffer when the surfaces differ in size. There are no tests for the browser backend. admin 2026-10-19 22:42:12 +02:00
• 95beeda66a Image caches that find an entry in O(log n), so drawing many small images no longer slows down as the caches fill Prompt's window had come to spend 35 ms of CPU on every frame after some hours open, most of it in GlesCanvas::draw_image_data. Every cache hit looked its key up in the LRU order with VecDeque::iter().position() and moved it to the back with remove, both linear in the number of entries. A terminal draws each glyph as an image, one per colour it is drawn in, so the cache filled towards its 32 MiB with thousands of small textures, 7573 in the window measured, and every glyph of every frame walked all of them. The software canvas's premultiplied cache and the GLES surface cache did the same. render/lru.rs is a least-recently-used cache bounded by a byte budget. Each entry keeps the tick it was last used at and a BTreeMap orders the keys by it, so a hit, an insertion and an eviction cost O(log n). insert returns the values it evicted, for the GLES caches to delete their textures, and never evicts the one just inserted, so a value larger than the whole budget is still kept; inserting a key again returns its old value. Tests cover the eviction order, a value over the budget and a replaced key. ImageCache holds its images and its surfaces in one Lru each, with the same budgets of 32 and 16 MiB; ImageCache::image uploads a texture only when it is not cached, and evict_overflow and the two linear lookups are gone. The software canvas keeps its premultiplied images in an Lru in place of PremulCache. What is cached and evicted is unchanged. admin 2026-10-19 22:39:34 +02:00
• 1a39c43762 Composite modes on the GLES canvas: Canvas::set_composite_mode and CompositeMode, completing the blend state the previous commit already applies A canvas only composited source-over. A host that draws Porter-Duff modes, as Android's Canvas does with an xfermode, had to read the pixels back, combine them on the CPU and upload them again, which on the GLES backend meant a glReadPixels and a fresh texture for every such draw. The new CompositeMode in types.rs, exported from the crate root, names the Porter-Duff operators (Clear, Src, Dst, SrcOver, DstOver, SrcIn, DstIn, SrcOut, DstOut, SrcAtop, DstAtop, Xor) and the separable modes with an exact premultiplied form (Plus, Multiply, Screen); SrcOver is the default. Darken and Lighten are left out, since GL can only approximate them where alpha is below one. Canvas::set_composite_mode sets how the following draws, blits included, combine with the canvas. On a GLES canvas it stores the mode, which activate_target turns into the blend function before every draw: each canvas carries its own, because the GL blend state is global and canvases share one context. A sub-canvas starts in SrcOver and does not inherit its parent's mode. A software canvas ignores the call and keeps compositing source-over. The field, its initialisation and apply_composite landed with the previous commit; this one adds the type and the public entry point they use, without which that commit does not build. The inset shadow, which switches the blend for one draw, now restores the canvas's mode instead of always going back to source-over. admin 2026-10-19 22:16:17 +02:00
• 20dc21448e A browser backend: ltk runs on a page's canvas through WebGL2, on a core that builds for wasm32, and a surface's scale may be fractional ltk ran on Wayland and Android only. Running crustace and its apps in a browser needs, first, ltk apps running there; a window manager for the page is the next step. The runtime was already split from Wayland by the platform layer, so what kept it out of a browser was what the core and the runtime took from the operating system: calloop's epoll loop, EGL, a monotonic clock, a file system, threads and environment variables. The core builds for wasm32-unknown-unknown. ltk::ChannelSender is ltk's own type instead of a re-export of calloop's Sender, with the same send and Clone, so apps that only send and clone it build unchanged. The runtime arms its timers and channels through event_loop/sources.rs instead of a calloop LoopHandle: calloop's natively, and in a browser a queue the backend runs, which takes the due timers out, runs them on AppData and hands them back, and does not arm again one removed meanwhile. calloop, khronos-egl and raw-window-handle are dependencies off wasm32 only, where egl_context.rs, UiSurface::try_new_gles and from_current_gles_loader and the native GL names of BorrowedGlesTexture are left out; sub_canvas clones the uniform locations, which are Copy natively and only Clone on wasm. The monotonic clock is crate::time::Instant, web_time's on wasm32, where chrono takes its wasmbind feature; the one subtraction that could go below the clock's origin, a surface's first last_draw, saturates. Themes, fonts, keyboard layouts and images are read through vfs.rs, the file system natively and on wasm32 files held in memory, so a wallpaper or an Image::from_path is now decoded from the file's bytes and its format told from its contents rather than its extension. The text-scale watcher, which runs gsettings on a thread, is left out on wasm32, and the built-in keyboard takes its language from platform::language(), LANG or the page's. criterion is a dev-dependency off wasm32 only, since rayon does not build there. The browser backend is the web feature, platform/web/, with wasm-bindgen, wasm-bindgen-futures, js-sys and web-sys. build.rs refuses it with another backend or for another target. A page's main thread must not block, so ltk::run sets the app up and returns, and the browser drives the loop: AppData lives in a closure a thread-local loop holds, which a setTimeout runs for messages, timers and page events and a requestAnimationFrame runs to draw. Event listeners and ChannelSender::send only queue and schedule, never touching AppData, so nothing they set off runs inside an iteration. The app draws on a canvas laid over the whole page, or the one ltk::web::set_canvas gives, through WebGL2 with the GLES canvas unchanged, its frame kept in its FBO, or without WebGL2 through putImageData. A lost context drops the GPU canvases and draws nothing until it is restored on a new glow::Context, so the glyph atlas and the caches of the old one are not reused. The main surface's logical size is the canvas's CSS size; the window's resize refits it, and on ltk's own canvas a hidden element padded by env( safe-area-inset-* ) gives the insets. Input comes from Pointer Events, a mouse as the pointer and fingers and pens as touches, the wheel, in detents when it scrolls lines, and keys, whose keysym comes from KeyboardEvent.key and code from .code as the Linux input code Wayland reports; keys repeat on the browser's clock, AltGr types its character, and on macOS Command is Ctrl. ltk takes every key the browser lets a page have, and while fullscreen those navigator.keyboard.lock() adds in Chromium. Copies go to navigator.clipboard.writeText; a page reads the clipboard only from a paste event, so Ctrl+V is let through to the browser and held until its paste has put the text in AppData::clipboard, and a paste from the browser's menu comes with a Ctrl+V of its own. The cursor's shape is the canvas's CSS cursor. The built-in keyboard serves text where the page is used by touch. Panics go to the browser's console. When the app exits, the listeners are removed, the canvas receives an ltk-exit event and the app is dropped. The new RunError::NoDocument is returned where there is no page, as in a worker. Resources are the tree an Android package carries. scripts/web-assets.sh builds it through android-assets.sh, and ltk::web::load_resources( base ).await fetches its MANIFEST and every file it lists, with the manifest's hash in their URLs so a changed tree is not served from the browser's cache, into memory under /ltk, which becomes the resource directory. The per-script fallback fonts are read through resources::read_font, so a path that does not exist is found by file name in the resource directory's fonts/, where a page bundles them. A surface's scale may be fractional. SurfaceState::scale_factor is an f32, which Platform::prepare_canvas, Presentation::scale and the paint path take as it is; a surface's physical size is its logical size times the scale, rounded once, and buffer_scale() gives the whole number Wayland's buffer scale and regions need. Wayland and Android still set whole scales, so nothing changes there; the browser backend sets the page's devicePixelRatio, so the canvas holds the display's own pixels at any zoom. App::on_scale_changed keeps its u32, the scale rounded, and App::on_resize gives the exact physical size. The fallback-theme banner placed its text as if draw_text took the top of the line rather than its baseline, so most of the text fell above the banner, out of the surface; it is now centred as the title bar's is. Building. make web-check typechecks the backend. make web-deps installs Debian's std for wasm32 and wasm-bindgen-cli, whose version must be the one of the wasm-bindgen crate in Cargo.lock: the crate is pinned to 0.2.117, the last whose CLI builds with Debian's rustc 1.85, and since the lock the CLI was published with needs a newer rustc and cargo install ignores rust-version when it resolves, the CLI is built from its sources with a lock resolved for the rust-version it declares, into target/tools, where the Makefile finds it. make web-assets builds the resources with the in-tree default theme and the fallback fonts WEB_FONTS names. examples/web_hello.rs, a counter and a text field, and web/index.html are the smoke test: make web-example builds them into target/web/ and make web-serve serves them. make install now copies web/ into the registry. README.md, docs/architecture.md and CHANGELOG.md describe the backend, and docs/cookbook.md points to ChannelSender's new home. Not done. In a browser there are no overlays, secondary surfaces or subsurfaces, no dead keys or input methods, no accessibility tree and no primary selection, and a canvas that changes size while the window does not is not refitted. Pasting relies on the browser sending paste to a focused canvas, which Chrome and Firefox do. The page fetches its whole resource tree, about 7 MB, before the app starts. There are no tests for the browser backend, Sources' queue or vfs.rs's in-memory files, and fractional scales may leave one-pixel artefacts where edges fall between pixels. admin 2026-10-19 20:20:12 +02:00
• 4c7e73d492 Text and RichText take a font face the host loaded itself, for hosts that resolve their own system families Text and RichText could only draw in a theme family, named by (family, weight, style) and resolved through the active theme's font registry, or in the canvas default. A host that finds its fonts elsewhere could not use them: rustdroid draws Android's sans-serif, which is Roboto looked up through fontconfig, so that an app's text keeps the widths it was designed with, and those faces are not in any ltk theme. Both widgets gain face( Arc<FontFace> ). A face given this way takes precedence over font in resolve_font, so it is used for drawing and for measuring alike, and RichText::map carries it over. Without it nothing changes. .gitignore lists what a Debian package build leaves under debian/: the debhelper directories and logs, the staged package trees of libltk-dev, libltk-doc and ltk-theme-default, the build stamp, debian/files and the substvars. admin 2026-10-18 18:01:18 +02:00
• ef6847b12c Rectangles with square corners are filled with hard edges on the GLES backend, so rectangles that share an edge leave no seam between them On the GLES backend, Prompt's selection showed a dark line between every two of its rows. GlesCanvas::fill_rect always grew the quad by 1 px and passed u_pad = 1, so the rect shader never took its solid path, which only runs with no radius, no stroke and no pad, and antialiased every rectangle over a band from −1 to +1 px around its edge. A pixel along an edge, its centre half a pixel inside, was covered at 84 % even when the edge lay on a whole pixel, so two rectangles that met there each left 16 % of what lay beneath showing through, which over a dark background reads as a line. The software backend does not show it, since tiny-skia covers a pixel-aligned edge fully. A rectangle with square corners now gets no pad, which takes the shader's hard-edged path, as tiny-skia fills it. Rounded rectangles keep the pad and their antialiased edges. A square rectangle whose edges fall between pixels now has a hard edge where it had a soft one. admin 2026-10-17 20:04:40 +02:00
• cacf871ddd An Android backend, a platform layer that keeps Wayland out of the runtime, the built-in keyboard for an app's own text input, and APKs packaged with Debian's own tools ltk only ran on a Wayland compositor: the runtime, the input handlers and the draw paths named smithay-client-toolkit's types throughout, so no other windowing system could be added without touching all of them. Prompt, the Eydos terminal, has to run on an Android phone, with its sessions and its sharing, and needs a toolkit that runs there. The platform layer. Input reaches the runtime as platform-neutral events: input/event.rs defines KeyInput, PointerInput and TouchInput, and the pointer, touch and keyboard handlers take them through a few entry points (pointer_input, touch_input, key_press, key_release, key_repeated, modifiers_changed, keyboard_enter, keyboard_leave, set_repeat_info). The sctk handler implementations moved to platform/wayland/input.rs, which records the serials later requests need, resolves surfaces and translates. What the runtime asks of the windowing system (moving, resizing, minimising and fullscreening the window, a bare frame request, the cursor's shape, the input method, publishing the clipboard and the primary selection, preparing a canvas, presenting it and its damage) forms the platform::Platform trait, with its surface type as Platform::Surface. The protocol state moved from AppData into platform::wayland::WaylandPlatform, held as AppData::platform, and each surface's Wayland half (its kind, SHM pool, EGL window surface and what the compositor was last told) from SurfaceState into WaylandSurfaceState, held as SurfaceState::platform. The compositor, shell, seat and output handlers, the data device, the primary selection, the run loop, overlay and subsurface reconciliation, session management, output probing and window fitting moved from event_loop/ to platform/wayland/. Drawing is split from presenting: draw/paint.rs paints a surface in full or under its dirty rects, the same for the software and GPU canvases, in place of the four near-identical paths of draw/software.rs and draw/gles.rs, and the backend presents it (platform/wayland/present.rs, which also took the opaque and input regions and pick_shm_format). The runtime is generic over the platform, AppData<A, P: Platform = NativePlatform<A>> and SurfaceState<Msg, S = NativeSurface>, resolved at compile time. The backend-neutral half of a loop iteration is event_loop/step.rs (process_messages, draw_due, next_wakeup, before_draw, after_draw), and event_loop/setup.rs builds the state and the event sources every backend has; the accessibility tree and its actions moved to event_loop/a11y.rs. platform/mock.rs is a platform that logs what is asked of it, and event_loop/tests.rs drives the runtime on it through input, update, painting and presentation. The behaviour on Wayland is unchanged, except that a frame whose presentation fails leaves the next one to repaint in full. ltk::Keysym now comes from xkeysym, the crate sctk re-exported it from, so it is the same type. Features. wayland, on by default, brings the Wayland backend and its dependencies, now optional, AT-SPI2 accessibility among them. android brings android-activity 0.6, ndk 0.9 and jni 0.21. A new build.rs refuses both at once and sets cfg( backend ) when one is on, which builds the runtime behind run and try_run. Without a backend only the runtime-free core builds: UiSurface, widgets, layout, theming and rendering. The Android backend. ltk::run runs inside a NativeActivity once android_main has handed its AndroidApp, re-exported as ltk::AndroidApp, to the new ltk::set_android_app; without it run fails with RunError::NoAndroidApp. The first call in the process sends standard output and error, panics included, to logcat, sets HOME to the app's internal storage and, unless set, SSL_CERT_DIR to Android's CA certificates and LANG to the device's language, and unpacks the bundled resources; every call keeps the latest activity, since Android starts the next one in the same process. The backend draws through EGL on the activity's window, or in software into a locked window buffer, and sizes the main surface at the display's density in whole multiples of 160 dpi. Fingers and styluses become touches, a mouse the pointer, and key events keysyms and text through the device's character map. calloop's descriptor rides on the activity's ALooper, so the app's channel and timers keep working. Text is typed on ltk's own keyboard, since a NativeActivity gets only key events from the system's. Through JNI on the activity (platform/android/java.rs): copies go to ClipboardManager and its text is read back whenever the app gains the focus; back with nothing left to go back to minimises the app with moveTaskToBack or closes it, as App::back_at_root says, which the new Platform::back_leaves decides per backend; and the window's insets come from getRootWindowInsets() on Android 11 and later, the status bar and any cutout on top and only bars that take taps on the other edges, so there is no gap above the view nor below it in gesture navigation, and a bar of buttons still keeps its room; earlier releases fall back to the content rect. When the app's last surface closes, ltk calls finishAndRemoveTask and waits for the activity to be destroyed, since a second activity started in a process whose android_main has returned never came up; an app should end the process after run returns. ltk::keep_running( Some( text ) ) starts a foreground service with text on an ongoing notification, so Android does not freeze the app once it leaves the screen, and None stops it. Surface insets. SurfaceState::insets holds the logical pixels the system covers along each edge; the view is laid out inside them while the background fills the whole surface, and positions stay absolute, so hit testing is unchanged. The built-in keyboard is placed inside them too, above a bar of navigation buttons. On Wayland they stay zero. Resources in a package. ltk::set_resource_dir( dir ) names an app's own copy of ltk's resources and ltk::resource_dir() returns it, so an app also finds its own bundled files there. Its themes/ is searched after the user's themes and before /usr/share/ltk/themes, its keyboards/ before /usr/share, and a font a theme names by an absolute path that does not exist is read from its fonts/ by file name, so a theme written against Debian's paths works unchanged. On Android set_android_app unpacks assets/ltk/ into the internal storage and uses it as the resource directory; assets/ltk/MANIFEST lists the tree, since the asset manager cannot list subdirectories, and its first line, a hash of the contents, decides whether to unpack again. On Android the per-script fallback fonts come from /system/fonts and the primary face is the embedded Sora. APKs. scripts/android-assets.sh builds that tree from installed themes, without their cursors, with the fonts each theme.json names and ltk's keyboard layouts. scripts/android-apk.sh OUT.apk LIB.so PACKAGE LABEL [ASSETS_DIR] packages an app built as a cdylib with Debian's aapt, zipalign and apksigner, with no Gradle and no SDK download: it writes the manifest, with the library loaded as libmain.so, optional permissions and a theme without an action bar, which the content rect would otherwise leave room for; links it against android-framework-res; adds the assets and the library; aligns and signs, creating a debug keystore when there is none. ICON takes an SVG, rasterised with rsvg-convert for every density, or a PNG. KEEP_ALIVE=1 compiles java/net/liberux/ltk/KeepAlive.java with javac and dx from art-standalone against the platform 34 android.jar, against which aapt then links too, since Debian's framework-res predates the specialUse service type, and declares the service with KEEP_ALIVE_USE as its reason and the permissions it needs. examples/android_hello.rs is the smoke test: make android-check typechecks the backend with Debian's rustc, rust-src and NDK through -Zbuild-std, make android-apk and make android-install package and install the example, make deps and make android-deps install what the targets need, and make install now copies examples, scripts, java and build.rs into the registry. The built-in keyboard for an app's own text input. While App::external_text_input asks for text and no ltk text field has the focus, the built-in keyboard shows with App::external_text_purpose, so a terminal gets its row of Escape, Tab, Ctrl, Alt and arrows, comes back when the serial changes and hides when the request ends. Its keys reach the app as physical ones, pressed and released through App::on_raw_key_event with the panel's Ctrl and Alt held for them. Before, it only served ltk's text fields, so such an app had no keyboard where the compositor offers no input method. Clippy. make clippy is clean again: derived Defaults replace the hand-written ones, div_ceil, then_some, struct update syntax for strokes, the map entry API in the text renderer, function paths in place of closures in the examples and tests, and fewer casts and explicit lifetimes. README.md, docs/architecture.md and CHANGELOG.md describe the features, the backend, the events and their units, and what stays with a backend. Not done. On Android there are no overlays, secondary surfaces or subsurfaces, no dead keys from a physical keyboard and no saved state for the activity. Why a second activity in the same process never comes up was not found. The keep-alive service does not ask for the notification permission, so on Android 13 and later its notification may not show until it is granted in the app's settings. admin 2026-10-16 23:46:50 +02:00
• 85aa85a357 The GLES backend keeps one glyph atlas per GL context, split into pages, so a surface that is created again does not rasterise and upload its text again Every GLES canvas and sub-canvas had a glyph atlas of its own, a 2048×2048 texture created empty with the canvas, so every surface that was torn down and built again, and every scroll viewport inside it, rasterised and uploaded all of its glyphs on its first frame. crustace's app launcher pays this on every opening: the sliding subsurface and its scroll sub-canvas are destroyed when the launcher closes, and the interactive overlay that replaces the subsurface at the top has scroll sub-canvases of its own. With LTK_PERF_RASTER=1 on a PinePhone Pro (RK3399, Mali-T860, panfrost) the first raster of the subsurface took 175 to 330 ms of CPU and the first full raster of the overlay 175 to 260 ms, on every opening, with the GPU done 3 ms later; the user saw a delay of two or three tenths of a second before the launcher followed the finger and a stall of about one more when it reached the top. On a Librem 5 (i.MX8MQ, GC7000L, etnaviv) the same rasters took 18 to 40 ms. Panfrost makes each glyph upload expensive. The glyphs of a line are written into the atlas with glTexSubImage2D after earlier lines were drawn from it, and when a pending batch still samples a texture that is written to, Mesa 25.0 allocates a new buffer for the texture and copies the whole old one into it with the CPU (panfrost_ptr_map in pan_resource.c), 4 MiB for the old atlas, read from write-combined memory. Etnaviv flushes and waits for the GPU instead (etna_transfer_map), whose cost does not depend on the size of the texture. The new gles_render/glyph_atlas.rs holds one GlyphAtlas per GL context, found through shared_glyph_atlas as the image cache is through shared_image_cache, and every canvas and sub-canvas keeps an Rc to it, so glyphs rasterised by one surface are resident for the next. The context is held as a Weak, so the atlas of a context that was dropped is forgotten instead of being found again by a new context allocated at the same address. The atlas is made of 512×512 pages, created as glyphs need them, up to 8 MiB in all; a glyph larger than a page gets a page of its own, up to the 2048 px of the old atlas, and those pages are freed when the atlas is reset, the regular ones kept and rewound. A write into a page that a pending draw samples then costs panfrost a copy of 256 KiB, not of 4 MiB. The glyph cache moves into the atlas with GlyphEntry, which records the page of each glyph, and its key; the cap of 8192 glyphs before a reset is now for the context as a whole, not for each canvas. draw_text uploads through the atlas and groups the quads of a line by page, one draw call per page instead of one per line, which only differs when the glyphs of a line are split across pages. GlesCanvas::new and sub_canvas no longer create an atlas texture each, and dropping a canvas no longer deletes one. docs/architecture.md says that glyphs are cached per GL context too and how the atlas is paged. Measured with LTK_PERF_RASTER=1, opening and closing the launcher a dozen times. On the PinePhone Pro the subsurface raster of the first opening went from 330 to 95 ms and of the later ones from 175–215 ms to 2–10 ms, with peaks of 17 and 35 ms, and the first raster of the overlay from 175–260 ms to under 1.5 ms; the other frames stay at 2 to 13 ms. On the Librem 5 the subsurface raster went from 22.7 ms on average, 85.6 ms on the first opening and over 15 ms in 9 of 14 openings, to 13.2 ms, 69.7 ms and 3 of 14, and the other frames from 7.7 ms on average and 43 ms at most to 6.8 ms and 28.5 ms. Not done. The first raster of a session still uploads its glyphs interleaved with the draws that sample them; uploading all of them before the first draw would need a second pass over the view on every frame. There are no tests for the atlas. The image cache still identifies its context by address only. admin 2026-10-15 22:34:03 +02:00
• 3edd822918 Toplevel events name the window, apps hear the pointer hover a surface and where their blurred cards were laid out, and rows can align to the bottom A shell could not tell the windows of an app apart, follow the mouse over one of its overlays, or tell its compositor where the translucent cards of a surface ended up. crustace's floating dock needs all three, to activate and close single windows, to magnify the icons under the pointer and to have forge blur behind its pill and its Quick Settings cards. ToplevelEvent::Opened carries the handle's identifier, the compositor's token for that one window, and its title, both from ForeignToplevelInfo; toplevel_opened builds the event for the new and the updated handle. Matches on Opened { id, app_id } have to add the fields or ... App::on_pointer_hover( SurfaceTarget, Option<( x, y )> ) is called on every mouse motion over a surface, in its physical pixels, and with None from the pointer's leave, which ltk did not handle before. SurfaceFocus::target gives the SurfaceTarget of a focus. Container::blur_behind() marks a container whose rect and largest corner radius, capped at half its shorter side, the layout pass records in surface coordinates through the DrawCtx::origin offset of the sub-canvases, clipped by the viewports it sits in. commit_draw_ctx keeps them in FrameState, and after a frame where they changed draw_frame hands them to App::on_blur_regions( SurfaceTarget, &[ ( Rect, f32 ) ] ), for the main surface and each overlay. Row::align_bottom() pins the children to the bottom edge, so taller siblings grow upward. docs/architecture.md lists on_pointer_hover among the input hooks. Not done. on_blur_regions, blur_behind and align_bottom are not in the documentation, and there are no tests for them. The regions are reported after the frame is committed, so a compositor that receives them over IPC is one frame behind a surface whose cards move. admin 2026-10-15 14:49:25 +02:00
• 35ab8ac2b0 The tab strip example in make examples make examples ran every example but tab_strip, added with the widget, so it never came up among the others. It now runs last, after clip_path, with the repository's themes as the rest. admin 2026-10-15 11:25:03 +02:00
• a63e905a7a A text field keeps the cursor where an edit left it unless it asks to be pinned to the end, which only the time picker does, and a hook for a window that loses the keyboard A field built with select_on_focus( true ) kept its cursor at the end of the value after every insertion and deletion. That was meant for the time picker, whose on_change normalises what was typed, "2" becoming "02", so that a cursor placed at the end of the typed text would land in the middle of the normalised one. But the flag was also the only way to have a field select its whole value on focus, so every field that wanted that got the pinning too, and in an address bar it is a defect: tapping inside the address to correct a word, the cursor was placed where the finger was, and the first character typed sent it to the end, so the rest of the edit went to the wrong place. The two behaviours are now separate. select_on_focus only selects the value when the field takes the focus. The new TextEdit::pin_cursor_to_end( bool ), false by default, keeps the cursor at the end of the displayed value through the usize::MAX sentinel, as before, for fields whose on_change rewrites the value. It reaches the runtime in a new pin_cursor_to_end field of WidgetHandlers::TextEdit, set where the snapshot is built in Element and copied in its Clone, and the four places in insert_delete.rs that anchored the cursor, for an insertion, a delete forward, the deletion of a selection and the move after a replacement, read it instead of select_on_focus. The time picker's value fields ask for it, so they behave as they did. A field that uses select_on_focus only to select on focus now edits with an ordinary cursor. The one other user known is a dialog in crate, which gets the ordinary behaviour; if its on_change normalises the text it has to ask for pin_cursor_to_end( true ) as the time picker does. Documentation of the previous commit and of what building crate showed. docs/widgets.md says that a pressable loses the tap and the right click to an interactive widget inside it even when that widget has no handler, as a list_item without on_press, so its content should be built from pieces that take no input; and that the hint of Button::tooltip is an xdg-popup beside the button in a window, placed by the compositor and taking no grab, and an overlay spanning the output on a layer surface. docs/theming.md gains "Application icons": a desktop entry can point at an installed theme icon, the Figma glass effects resvg does not reproduce, a backdrop-filter in a <foreignObject> ignored and plus-lighter rewritten to screen by decode_svg_bytes, and the advice to flatten them; the table row of decode_svg_bytes mentions the rewrite and that its pixels come back premultiplied. docs/cookbook.md says that requesting the focus for the text field that already has it puts the cursor at the end of its value without a second on_focus, which is how an application moves the cursor after replacing the value, and that Tab and the vertical arrows reach App::on_key_with_modifiers before the field, while Escape reaches it after ltk has closed any transient UI and taken the focus off the field. Losing the keyboard. An application that repeats keys on its own timer, as prompt does for its terminal, never heard that the window lost the keyboard, so a key held while the focus went elsewhere kept repeating until the next key, since its release went to the other window. The new App::on_keyboard_leave(), a no-op by default, is called from the keyboard's leave, right after ltk stops its own repeat, for the application to stop its repeat and forget the modifiers it kept. Documentation of the previous commit's hooks and widgets. docs/architecture.md lists on_mouse_button with MouseButtonEvent and MouseButton, on_modifiers and on_keyboard_leave among the input hooks. docs/widgets.md describes ListItem::ink( label, secondary ), which draws a row's label, subtitle, trailing text and hover and press tints in colours of its own for a surface the theme does not know about, and says that icon_button keeps a bitmap's proportions, fitting one that is not square into its size and centring it rather than stretching it. Not done. There is no test for the new flag, as select_on_focus has one in text_edit/tests.rs for its builder and its propagation to the handler, and the documentation of the widget does not mention it. admin 2026-10-15 11:22:01 +02:00
• 312fb7e0fd Tooltips in a window are popups beside their widget, theme SVGs with plus-lighter highlights are no longer painted grey, and the folder-files icon is shaped as a folder A tooltip was a layer-shell surface spanning the output, placed at the coordinates of its widget in the main surface. In a layer-shell shell the two share an origin, but an xdg-shell window does not know where it sits on screen, so in a window the tooltip appeared shifted by the window's position, wherever that put it. The application icons of the default theme, exported from Figma, light their glass with feBlend mode="plus-lighter", which resvg does not know and paints as normal, so the highlights came out as grey edges; at dock size those edges cover whole pixels and the icon looks dirty. And archives/folder-files, the icon applications show for a folder, was a clipboard and a sheet rather than a folder. Tooltips. tooltip_popup tells when the tooltip must be an xdg-popup, that is when the main surface is a window and the widget is on it, and gives its anchor rect and logical size. reconcile_overlays then creates the tooltip's overlay as a popup child of the window, anchored to the widget's rect, above it with a 6 px gap (TOOLTIP_GAP), flipped below or slid sideways when it does not fit, so the compositor puts it beside the widget. It takes no grab and keeps the empty input region, so it never takes the pointer from the widget it describes. Its view is the pill centred in the popup. Layer-shell surfaces keep the previous placement, now in tooltip_on_screen. tooltip_id and tooltip_size hold the id and the estimated size both paths share. OverlaySpec is unchanged, so applications that build overlays need no change. Blend modes. decode_svg_bytes replaces plus-lighter with screen, the closest mode resvg supports, before parsing; a document without it is parsed as it comes, without a copy. A test covers both cases. The folder icon. Both variants of archives/folder-files are now the outline of folder-empty with the sheet of the previous icon inside, placed and sized as the lock of folder-locked: drawn in strokes in line, cut out of the filled folder in filled. admin 2026-10-15 10:32:50 +02:00
• dcb1c7dff3 A tab strip that scrolls to the selected tab and while a tab is dragged against its edge, and hooks for every mouse button and for the modifiers, for an application that hands the mouse on A strip with more tabs than fit left the selected one wherever it was, so a tab opened at the end or chosen with the keyboard could stay out of sight, and a tab could only be dragged as far as the visible part reached. A terminal that passes the mouse to the program in it, as xterm does, also needs every click with its modifiers, which ltk kept to itself apart from the middle button, and the modifiers held while the wheel turns, which the wheel does not carry. Scrolling to the selected tab. TabRow now knows the key of the selected tab, and in the layout it asks the TabMotion where the scroll of the tabs should go before drawing it; the answer is written into the scroll's own offset, which is keyed by the same index. When the selection changes the strip scrolls just enough to show that tab, through the scroll's offset_into_view, and keeps following it while it grows from nothing, so a new tab at the end is shown whole once it has opened. After that the strip is left where the user scrolls it. Dragging against the edge. While a tab is dragged and its lifted copy touches either edge of the visible part, the strip scrolls 8 widget pixels further that way on each frame (EDGE_SCROLL), and every layout places the dragged tab under the pointer again, so it travels with the strip although the pointer holds still and drops among the tabs that come into view. Pointer coordinates. A scroll and a viewport draw their child on a canvas of their own, so the tabs were laid out in coordinates that no longer matched the pointer once the strip scrolled. DrawCtx.origin now holds where the canvas being drawn on sits on the surface, set around the child of every Scroll and Viewport, and TabCells and TabCards hand it to the TabMotion, which takes it off the pointer in drag_move. The mouse. App::on_mouse_button( &MouseButtonEvent ) reports every press and release of the left, middle and right buttons, with the position in physical pixels and Ctrl, Shift and Alt, before ltk handles it; MouseButton and MouseButtonEvent are exported. App::on_modifiers( ctrl, shift, alt ) is called whenever the modifiers held change. Both do nothing by default. Tests cover a selected tab scrolled into view once and back, and a tab dragged against the edge scrolling the strip. The documentation of tab_strip describes the scrolling. admin 2026-10-15 10:25:31 +02:00
• ce98c7b82c TabStrip, the open documents of an application as a browser or a terminal shows them, with tabs that grow, shrink and can be dragged, an overview of cards for a phone, a widget anchored under another one and list items in colours of their own Trust and prompt each drew their own strip of tabs, their own phone bar with a counter and their own grid of cards, and neither animated anything nor let a tab move. tab_strip does all of it once, in colours the application chooses, so the same widget serves a black terminal and a browser that follows the theme. Two things the menus of those applications needed come with it: a way to place a menu under the button that opens it, and list items that are not drawn in the theme's colours. The widget. tab_strip( tabs ) takes TabItems, made with tab( key, label ), where the key stays the same while the tab is open, plus .image( ImageData ) for a page's icon, .symbol( name ) for a theme icon drawn in the tab's ink, and .closable( bool ). The builder sets the selected tab, on_select, on_close, on_overview, the buttons before the tabs (leading), right after the last one (after_tabs) and at the far right (trailing), the phone bar's mobile_center, the TabStripColors, the TabLayout, reorderable and the TabMotion. TabStripColors sets the strip's background and ink and the fill, edge and ink of the active tab and of the others; the default follows the theme. On a desktop. [leading] [tabs…][after_tabs] clear [trailing]. The tabs share the width between 90 widget pixels and a fifth of the screen's width and scroll sideways when even the minimum does not fit, and 7.5 % of the width between the leading and trailing buttons is always left clear, also while they scroll. A horizontal scroll measures its child with no width limit, so the tabs inside it cannot see how much room there is; two new elements solve that. TabRow, outside the scroll, works the tab width out of its own rect, less the clear part and the buttons after the tabs, and hands it to the TabMotion; TabCells, inside the scroll, places the tabs, the gaps of closing ones and the buttons where the motion says. Each tab is clipped by a viewport, so it can grow from nothing and shrink away. On a phone. TabLayout::Mobile is a bar with the leading buttons, the active tab's icon and title or the application's mobile_center, a counter that sends on_overview and the trailing buttons. tab_overview( tabs ) is the grid of cards it opens, with a title, a back message and header actions: build gives the whole page, header and scrolling cards, and cards the grid alone for an application that lays its page out itself. The cards are placed by a third new element, TabCards, every one as tall as the tallest, so a dragged card can follow the finger. The motion. TabMotion is the only state, kept by the application, handed to every view and reported from App::is_animating; it is an Arc<Mutex> because view only gets &self, and clones share it. A tab that opens grows from nothing while the others narrow, and one that closes leaves a gap that shrinks away while the others keep their width for a second, so the close button of the tab that slides in lands under the pointer; another close starts the second again. Changes take 180 ms, ease-out. The first layout and a resize alone place the tabs without moving them. Reordering. With reorderable( true ) each tab, and each card of the overview, carries its select message as on_drag_start, so it is dragged after 24 px of mouse motion or a long press, and dragging a tab selects it. The drag reaches the application, which forwards App::on_drag_move to TabMotion::drag_move and answers App::on_drop with the ( from, to ) that TabMotion::drag_end reports. The motion remembers where it drew every tab: the first move takes the tab under it and returns false when there is none, the tab then follows the pointer within the tabs and is drawn on top, and the others slide out of its way as its centre passes theirs, or as it enters another cell of the overview. On release it slides into its place. A strip and its overview are never shown at once and may share one motion. Anchored. AnchoredOverlay, which only the combo used, is public as anchored( child, id ): it draws its child under the widget built with that WidgetId, as it was laid out on the previous frame. align lines it up with the anchor's left edge, its right edge or its middle, gap sets the space under it, and the child is now kept within the rect its parent gives it, which also keeps a combo's list inside the window. List items and icons. ListItem::ink( label, secondary ) draws the label, the subtitle and the trailing text in colours of the application's own and tints hover and press with the label's, for rows on a surface that is not the theme's. A button's icon is now fitted into its square without being stretched: a wide icon such as actions/remove, a 25 by 4 minus, was drawn as a block as tall as it was wide. Documentation, example and tests. docs/widgets.md describes tab_strip and anchored and the new ink. cargo run --example tab_strip opens three documents that can be added, closed and dragged, on a desktop strip or a phone bar with its overview. The tests cover the share of the width, its limits and the clear part, the buttons after the tabs, the drawing order of a dragged tab, the builder's defaults, the overview's rows, and in motion.rs the growth, the gap, the wait and its restart, a resize, and dragging a tab and a card; anchored and the icon fit have tests of their own. Not done. A strip that scrolls does not scroll to the active tab or follow a tab dragged towards its edge, and the overview does not scroll while a card is dragged to the edge of the screen. admin 2026-10-15 08:22:41 +02:00
• 99b195ea13 The primary selection is kept in step with other applications, an application can paste either selection and hear the middle button, raw keys carry the text dead keys compose, and an application can ask for a cursor where the pointer is A terminal drawn by the application itself needed four things ltk did not give it: the selection the middle button pastes, a way to read the clipboard, the text a key types once dead keys are applied, and a text cursor over its text area that does not hide the window's resize cursors. Text fields gain the primary selection along the way, and the symbol fallback and a missed field in the previous commit are fixed. The primary selection. event_loop/primary_selection.rs binds zwp_primary_selection_device_manager_v1 when the compositor offers it, creates the device with the data device in new_seat, and holds the manager, the device, our source while we own the selection, its text and the inbox the reader threads post to. A selection offered by another client is read on a thread of its own as the clipboard is; a peer asking for ours is served from the cached text, and a cancelled source is dropped. data_device.rs gives both the pieces they share: pick_text_mime, read_selection and write_selection, so the clipboard behaves as before. Text fields. Once a press ends, sync_text_field publishes a new selection in the focused text field as the primary selection; password fields never publish theirs. It remembers what it last published rather than comparing with the current primary selection, so a selection made in another application is not taken back. A middle-button press on a text field focuses it, puts the cursor where it landed and inserts the primary selection there. The application's side. App::take_primary_request makes a text the primary selection, as take_clipboard_request does for the clipboard. App::take_paste_request names a SelectionKind, Clipboard or Primary, and the runtime answers with App::on_paste and that selection's text, never with an empty one. App::on_pointer_middle reports a middle-button press anywhere but on a text field. All default to doing nothing. Raw keys. App::on_raw_key_with_alt gives way to App::on_raw_key_event, which takes a RawKey with the keysym, the keycode, the press, Ctrl, Shift and Alt, and text: what sctk reports the key types once dead keys and compose sequences are applied, None on release, halfway through a sequence and for keys that type nothing. A terminal that took the character from the keysym typed a for an acute accent followed by a. The default still forwards to on_raw_key, and prompt was the only application overriding the old hook. Every key press now also records its serial in last_input_serial, so a selection set from a keyboard shortcut carries a serial a strict compositor accepts rather than the last click's. The cursor. App::cursor_at( x, y ) is the cursor the application wants at a point of the main surface. It comes after the resize edges and cursor_override, and before the cursor of the widget under the pointer, so a terminal shows the text cursor over its cells and the resize cursors still show at the window's edges, which a cursor_override would hide. Fonts. Noto Sans Symbols 2 and Noto Sans Symbols follow DejaVu Sans in the fallback chain, for the media controls, arrows and shapes DejaVu lacks, which drew as the missing glyph. TextEdit::map_msg now carries pad_h over: the previous commit added the field but left it out there, and ltk did not build. admin 2026-10-14 16:41:54 +02:00
• e3b76423fb A text field can take its horizontal padding from its host, the primary finger reaches the pointer hooks, and the screen probe left out of the previous commit is added The previous commit described the size hint fitted to the screen before the first commit and the pointer hooks being called for the primary finger, but left out the files that do it, so run.rs called an output_probe module that did not exist. They are here, together with a text field option that a host laying out its own padding needs. Text field padding. A single-line TextEdit insets its text by PAD_H scaled with the field height, so a tall and narrow field has almost no room left for its text: rustdroid's Android fields, which already subtract the padding the Android view asked for, showed a verification code digit in a 24 px wide gap minus ltk's own inset, scrolled it as if it overflowed and clipped half of it. TextEdit::padding_h( px ) sets that inset in physical pixels; 0 lets the text use the whole rect. Without it nothing changes. single_line_pad_h takes the override and every single-line consumer passes it: the draw path, single_line_scroll_x, single_line_align_offset and byte_offset_at, so a click still lands on the glyph that is drawn. The runtime sees it through a new pad_h field in WidgetHandlers::TextEdit, read by text_input_pad where a click is turned into a text position (pointer down, word selection, drag selection and the context menu's paste offset). The password toggle zone keeps the theme inset. The screen probe. output_probe::output_logical_size reads the logical size of the first output on an event queue of its own, before any surface exists: xdg_output's logical size when the compositor offers it, else the current mode over the scale; the objects it binds are destroyed or released before it returns. window_fit::output_share gives the part of an output a window may take, the same 90 % the fit after the first configure uses, which now goes through it too. When the size hint is unpinned on the first configure the minimum size is released along with the maximum, as the documentation of window_resizable says. Touch as pointer. The primary finger's down, motion and up are also reported through App::on_pointer_move and App::on_pointer_button, as the left mouse button is, so an application that handles the pointer gets the touch without a separate path. The module documentation says so. admin 2026-10-13 20:36:29 +02:00
• c385605de0 An application can keep the keyboard to itself and see Alt, an external field declares what it is for, and the size hint is fitted to the screen before the first commit A terminal takes every key and turns it into bytes for its program, which ltk's key handling got in the way of in three ways. Enter and Space pressed the widget that had the focus, or the one hovered, as well as reaching the application: in prompt a tap on the extra keys row's up arrow left that button focused, so the next Enter ran the command and then pressed the arrow again, bringing the command back on the prompt. The field held by external_text_input was always enabled with the normal purpose, so the on-screen keyboard never offered its row of terminal keys to an application that draws its own text area. And on_raw_key reports Ctrl and Shift but not Alt, which a terminal sends as a prefix or a parameter. Keeping the keyboard. App::claims_keyboard, false by default, makes press_key stop after on_raw_key while it is true: the key is not dispatched to the widgets, so neither Enter nor Space presses anything and arrows do not move the keyboard hover, and ltk does not start its own repeat; a repeat already running is stopped as before. XF86_Back still goes through the dispatch and on_back. An application returns it while its own surface has the keys, and false when one of its menus is up, which then behaves as before. The external field's purpose. App::external_text_purpose, Purpose::Normal by default, is what sync_external_text_input enables the text-input with, and what it renews it with when the serial changes, so Purpose::Terminal reaches the compositor as ContentPurpose::Terminal and forge shows the terminal row above the layout. Alt. AppData gains alt_pressed, kept by update_modifiers with the other two. The runtime now calls App::on_raw_key_with_alt, on press and on release, with the same arguments as on_raw_key plus Alt; its default forwards to on_raw_key, so the applications that implement only that one see no change, and an application that needs Alt overrides the new one instead. The size hint. A window size hint bigger than the screen used to be fitted only after the first configure, so the first commit asked the compositor for a size it could not give, and a mobile compositor would rescale the window to honour it. Before the first commit try_run now reads the logical size of the first output through output_probe, on an event queue of its own, and fits the hint within window_fit::output_share of it, the same 90 % the later fit uses; that size is what the toplevel is pinned to and what fitted_size_hint starts with, and the fit after the first configure is skipped when it was done. The documentation of window_resizable now says both the minimum and the maximum are released from the first configure, since a minimum left in place has the same effect on a mobile compositor. Pointer hooks. The documentation of on_pointer_move and of the left-button hook now says they are also called for the primary finger's touch down, motion and up. Not done. A key held when the window loses the keyboard is stopped by ltk's own repeat but not by an application that repeats keys itself, since there is no hook for the keyboard leaving. Logo and AltGr are still not reported to on_raw_key_with_alt. admin 2026-10-13 20:31:51 +02:00
• 6e4bf83c91 The default theme declares Noto Serif as a font family theme.json gains a noto-serif family with its Light 300, Regular 400, Medium 500 and Bold 700 weights, read from the fonts-noto-core files that ltk-theme-default already depends on, and falling back to Sora. Only the families declared in the theme resolve through Text::font, so a widget that wants a serif face, such as the crustace clock with its bold time over a regular date, needs the family to be listed here. admin 2026-10-11 16:26:01 +02:00
• 0d492f7c1d Text measuring for hosts, colour emoji, caller-supplied faces, aligned rich text and a wheel hook in detents A host that lays text out with its own measurement (rustdroid sizes Android views from it before ltk draws them) needs ltk to measure exactly as it renders. Several gaps made the two disagree; this closes them and adds what such a host needs from the pointer and the paragraph widgets. Shaping. shape_line shaped the first bidi paragraph only, so any text after a line break measured zero width; it now shapes every paragraph. Shaped glyphs keep the cluster rustybuzz reports (ShapedGlyph::cluster, and PositionedGlyph::cluster as a byte offset into the line), which caret_offsets uses to give one x per char boundary, splitting a cluster's advance evenly across its chars. caret_offsets, caret_offsets_with_font (the same with a given face leading the resolver) and line_metrics are exported. The per-codepoint resolver shared by measure_text and the new functions is default_resolver: primary font, then the system fallback chain, then the primary again for .notdef, the same choice the renderers make. Caller-supplied faces. draw_text_with_font and measure_text_with_font built a FontHandle with empty bytes for a face that was not the canvas default, so HarfBuzz could not shape it and the text silently fell back to the system chain. FontFace now exposes the file it was parsed from (data, face_index) and FontHandle::of builds a complete handle from a face; both renderers use it. The GLES renderer also registers the preferred face in its glyph font list so its glyphs are rasterised. Colour emoji. FontFace::color_glyph decodes, once per glyph, the PNG strike a CBDT or sbix font draws a glyph with, as a ColorGlyph (straight RGBA plus its box in ems). Both renderers draw such glyphs as images at the pen position, scaled by the text size and faded by the text colour's alpha, instead of rasterising an empty outline. NotoColorEmoji joins the fallback chain after DejaVu Sans. ColorGlyph is exported. Rich text alignment. RichText gains align( TextAlign ), applied per wrapped line; link hit rects follow the aligned line, so a centred paragraph with links stays tappable where it is drawn. Wrap pad. A wrapping Text wraps its lines to the rect less 4 px and insets a left-aligned line by it. The constant is now public as ltk::TEXT_WRAP_PAD, documented as the extra width a host must add when it sizes a label's rect from its own measurement; without it a label sized to its text wrapped its last word. Wheel. App::on_pointer_wheel( x, y, notches_x, notches_y ) -> bool is called before on_pointer_axis for a scroll outside any ltk viewport that carries discrete detents (value120, or discrete on older compositors), with the number of detents per axis, fractional on high-resolution wheels. Returning true consumes the event; the default false keeps the previous behaviour, where on_pointer_axis receives the raw axis value scaled by 10 for wheels. A host that maps detents to its own unit (Android's AXIS_VSCROLL is one unit per detent) no longer has to guess the compositor's axis scale. debian/changelog gains the 0.3.0-4 entry describing the shaping, caret and caller-supplied face changes. admin 2026-10-08 22:03:10 +02:00
• 4a6ec797a2 Wrapped text breaks a word wider than the line instead of letting it overflow wrap_lines broke lines only on whitespace, so a word wider than max_width (a long path, URL or file name) was laid out whole on its own line and painted past the right edge of its widget. In the notifier it ran out of the notification card. Such a word is now broken between characters into pieces that fit the line, each piece continuing on the next line. The last piece stays the current line, so the following word can still share it. Breaking on char boundaries keeps multi-byte UTF-8 sequences intact. preferred_size already reported the height of every resulting line, so the widget grows by as many lines as the break produces. The wrap width also leaves room for the left inset. draw indents each wrapped line by 4.0_f32.min( slack ), which drops to zero for a line that fills the full width, so such a line started a few pixels left of its neighbours. Breaking long words makes full-width lines common. preferred_size and draw now wrap to the width minus the new WRAP_PAD constant (4 px), and draw takes the inset from the same constant, so every line keeps it. As a consequence, every wrapped text has 4 px less usable width per line. The new test wrap_breaks_words_wider_than_the_line checks that a word wider than the line is split over several lines, that no line is wider than the wrap width, and that the lines together hold the whole text. admin 2026-10-08 12:48:29 +02:00
• 17e649dd32 The on-screen keyboard is capped at 40 % of the screen height, and the runtime publishes the logical size of the output the main surface is on The keyboard. The keys of the on-screen panel are as tall as one unit of the widest row is wide, so the panel's height follows its width. On a portrait phone that is about a quarter of the screen; turned to landscape the width becomes the long side, the keys grow with it and the six rows of a terminal keyboard take more than the screen. Panel::height_within( width, scale, screen_height ) keeps height within 40 % of the screen height, the new MAX_HEIGHT_FRACTION, and place_osk uses it for the keyboard of a surface of ltk's own. set_rect no longer assumes it was given the natural height: the key height is the smaller of the unit and what the rectangle left after the padding and the gaps shares among the rows, so a capped panel gets wide and low keys, as the keyboards of other platforms have in landscape, while the key widths and the centring of the narrower rows are as before. A portrait screen is not affected, the natural height being below the cap there. A host that lays the panel out itself, as a compositor does, calls height_within for the height it reserves and set_rect with the rectangle it gets, so both agree. The output's size. ltk::output_logical_size() returns the logical size of the screen the main surface is on, or None before the compositor has described one, and set_output_logical_size records it. viewport_size follows the window, which is the wrong reference for a thing that has to be sized relative to the display, such as a window that must not be wider than the screen. The runtime now publishes the size when an output appears, changes or goes away, and when the main surface enters one, preferring the output of the main surface to the first one listed, and taking the current mode over the scale when the compositor sent no logical size. window_fit shares that lookup, output_logical_size, with what it did before, so the bounds it keeps a window size hint inside are unchanged. Not done. The 40 % is a constant and not a setting, the key labels are not scaled to the lower keys, and nothing offers the keyboard at the side of the screen in landscape, which would give the application more room on a wide display. admin 2026-10-06 23:09:43 +02:00
• 1ad9898f66 A subsurface maps with the main surface's first buffer, not a frame after it The run loop drew the main surface first and reconciled the subsurfaces afterwards, in every iteration including the first. On the first frame the main surface was therefore committed and mapped on its own, and the subsurfaces only got created, rastered and placed in a later parent commit. The lockscreen shows the problem: its main surface always holds the unlock form, and the idle clock panel that covers it lives on a subsurface, so at greeter startup and whenever a forge session locked, the form was visible for a moment before the idle panel appeared on top. In the greeter, on_first_frame_committed also sent the daemon its readiness byte with that frame, so the VT switch showed the form. Until the main surface has committed its first frame, reconcile_subsurfaces now also runs before draw_frame. It creates each subsurface, rasters it and commits its buffer, which a desynchronised subsurface applies on its own commit, and sets its position, which waits for the parent. In that pass it no longer commits a Main parent itself: a bufferless commit is a protocol error on an ext-session-lock surface, and the main surface's first buffer commit, made right after by draw_frame, applies the placement anyway, so the main surface and its subsurfaces reach the screen in the same commit. Overlay parents and the reconcile after the draw are unchanged, and once the first frame is out the loop behaves as before. admin 2026-10-02 18:30:29 +02:00
• 0fd23acd2b A Length::dp font size keeps its logical size on a scaled output instead of growing with the scale On a 14.1" 2560x1440 laptop, where forge picks a 2.25 output scale and ltk draws at buffer scale 3, the title of every settings screen but the first came out about three times its design size, while on a 1920x1080 laptop at scale 1 the same title was smaller than the 28 px heading of the home screen. That title is a list_item with .font_size( Length::widget( 20.0 ) ), which in WidgetScaling::Physical is Length::dp( 20.0 ). Canvas::resolve_font resolved a Dp length with the canvas' density, which the runtime sets to the output scale, and returned it as a font size. Font sizes are logical: the raster path multiplies them by dpi_scale. A Dp font size was therefore scaled twice, 20 × 3 = 60 logical px and 180 physical, against 20 at scale 1. Geometry did not have the problem, because resolve_geom returns physical pixels that nothing scales again, and neither did a stock widget without an override, because font_px already divided by dpi_scale in Physical mode. The same dp value thus gave one size through font_px and another through an explicit override. resolve_font now resolves Dp with density / dpi_scale, so that × dpi_scale at raster yields n × density physical pixels, the same as resolve_geom gives the same length. Pixel, viewport and fluid lengths are untouched, since they do not depend on the density. The Physical branch of font_px now delegates to resolve_font( Length::dp( design_px ) ), which is the formula it carried on its own. Every caller of resolve_font is affected: the font_size overrides of button, text_edit and list_item, and the size of text and rich_text when given a Dp or, in Physical mode, a Length::widget. At scale 1 nothing changes. The new test dp_font_matches_dp_geometry_on_hidpi checks at scale 3 that a 20 dp font resolves to 20 logical px, equals font_px( 20 ) for Length::widget, and times the scale equals the same length resolved as geometry. admin 2026-10-02 07:55:23 +02:00
• 88f69ebffe A horizontal swipe commits on a fling; App::overlay_namespace; flat Quick Settings slots in the default theme; the on-screen keyboard's rows twice as far apart, with presses between keys kept; LTK_PERF_RASTER Flings. A horizontal swipe committed only past swipe_horizontal_threshold of the surface width, so a quick flick that stopped short, the usual way to turn a page on a phone, snapped back. The new input/gesture/fling.rs holds a FlingTracker that measures the finger's speed along one axis over the last 100 ms from the events' own timestamps, so a finger that rested before lifting reads as still. GestureState keeps one for the x axis, fling_x, cleared on every press; the touch handler feeds it on down, motion and up with the wl_touch time, which it used to ignore. On release a horizontal swipe also commits when the finger leaves at 500 logical px/s or more in the direction of travel after at least 24 px, and does not commit when it leaves that fast the other way, whatever the distance; both thresholds scale with the surface. Pointer drags and the vertical swipes keep the distance rule, and the gesture tests, which never feed the tracker, are unchanged. Two tests cover the speed and a rest before lifting. App::overlay_namespace. Every layer overlay was created with the namespace ltk-overlay, so a compositor could not tell one panel from another. The new method returns the namespace of overlay id, read when its surface is created, and None, the default, keeps ltk-overlay. It follows overlay_title and overlay_opaque_region and breaks no app. Crustace names its Quick Settings and launcher overlays with it, and forge draws a blurred backdrop behind them. Flat Quick Settings slots. The default theme gains surface-qs-tile, surface-qs-tile-active, surface-qs-slider-track and surface-qs-slider-fill in both modes: a solid translucent fill, white or navy for the tiles and tracks and cyan for the active tile and the fill, with no shadows, no inset shadows and no gradients. The glass slots the panel used put a blurred shadow, one to five inset shadows, some with blend modes, and a gradient under each of its nineteen surfaces, all rasterised on every frame of its slide. The shared slots are untouched, so the dock and other applications look as before. The on-screen keyboard. The rows are now ROW_GAP, twice GAP, apart, 12 logical px against the 6 between keys; height counts it, so the panel grows by 18 to 24 px depending on its rows and a host that reserves its height follows. A press between keys, which the wider gap would have made more common, no longer goes nowhere: key_at gives it to the nearest key within one row gap. LTK_PERF_RASTER. With it set, every GLES raster, full, partial or subsurface, logs its surface size, the time to submit and, after a glFinish, the time until the GPU finished. The glFinish stalls the pipeline, so it is for measuring only; it gave the cost of the old Quick Settings panel, 27 to 40 ms a raster on the Librem 5 with peaks of 57 to 143 ms. admin 2026-09-30 10:17:22 +02:00
• a0ceef51ef WallpaperBundle::blurred; the on-screen keyboard at the right size on a scaled output, keys as tall as they are wide, a terminal row that fits and a Spanish symbols layer that does not squeeze the rest The keyboard of the previous commit was drawn and tried on a desktop at scale 1. On the Librem 5, at scale 2 and hosted by forge, it showed what that could not: letters twice their size, a terminal row whose modifier labels did not fit, keys shorter than they were wide, and a Spanish numbers layer with a gap at each side. This fixes those, and adds the wallpaper helper the shell and the compositor now use for their frosted panels. A frosted wallpaper. Crustace decoded the theme's lockscreen image at full size a second time for the launcher and the quick settings, and forge decoded it again for the app switcher, blurred it with a floating-point Gaussian at 1920 px and composed a copy per panel size; the switcher's decode alone left some 60 MB in a thread arena that glibc never gives back. A backdrop that is blurred needs no resolution. WallpaperBundle::blurred( divisor, sigma ) returns a bundle divisor times smaller on each side, reduced with a triangle filter and blurred with imageops::fast_blur, the box approximation that works in place on the 8-bit pixels; the renderer scales it back up with linear filtering, and the blur hides what the reduction lost. It is an ordinary bundle, so for_size crops it for portrait as it does the original. Two tests: the size is divided and never reaches zero, and a flat colour stays that colour. docs/architecture.md mentions it next to for_size. Text twice its size. Panel::draw passed the canvas a font size already multiplied by the output scale, and the canvas multiplies every font size by its dpi_scale once more, as it must for widget text, which is sized in font space. At scale 1 the two agree; at 2 the labels came out at four times the area. The keys and the variants popup now pass TEXT_SIZE and ACTION_SIZE unscaled, and draw_centred computes the baseline offset from the size in physical pixels, size * dpi_scale(), so the label stays centred on the key. Radii, key geometry and icons were already right: they are physical pixels and never go through dpi_scale. The runtime's built-in panel and forge's both draw through Panel::draw, so both had it. Keys as tall as they are wide. Rows were a fixed 46 px high whatever the width, so on a phone the keys came out wide and flat. The new key_unit( width, scale ) is the width one key unit takes when the widest row of the layer fills the panel, the width of a q; set_rect uses it as both the width unit and the height of every row, the terminal row included, and the variants popup, which was already as tall as its key, follows. The panel's height therefore depends on its width: height( scale ) becomes height( width, scale ), place_osk passes the surface width, and KEY_HEIGHT goes. The architecture document says so. In landscape the keys grow with the screen's width; a cap on the height has not been needed yet. The terminal row. Esc, Tab, Ctrl and Alt were one unit wide and their labels did not fit. They are 1.5 units now, and to keep the row at 13 units \ and ~ leave it: the row is Esc, Tab, Ctrl, Alt, the four arrows, -, / and |. Neither is lost: \ is a long press on /, next to ?, and ~ one on -, next to _ and –; | takes over the variants \ had, ` `, ^, $, # and *, beside its own & and !. The arrows are drawn at 14 instead of the 22 of the other action icons, which filled the narrow key. The built-in bar's test checks | in the row and \ and ~ among the variants. The Spanish symbols layer. Its third row carried ¡, !, ¿ and ?, 12 units against the 10 of every other row; since all rows share the key unit of the widest, the numbers and @ # € % rows came out narrower and centred, with a gap at each side, and switching to English and back looked right only because that layout's row has 10. ¡ and ¿ leave the row and become long presses on ! and ?, as on Android, and stay among the variants of . where they already were. The new test shipped_layers_are_no_wider_than_their_base reads en.json and es.json` and fails when any row of any layer is wider than the widest row of the base layer, so a layout file cannot bring this back unnoticed. admin 2026-09-27 21:43:33 +02:00
• a1a4d51677 An on-screen keyboard of ltk's own, driven by layout files; TextEdit::purpose for the row a terminal needs; the wheel scrolls a multiline field; a notebook page fills its height Text entry on a phone comes from zwp_text_input_v3: a focused field enables the protocol and the compositor's input method, squeekboard today, draws a keyboard and commits text through it. Eydos wants to drop that process, so the keyboard has to come from somewhere else, and the natural place is the toolkit that already draws everything else and knows which field has the focus and what it is for. This commit puts one in ltk, as data files plus a panel any host can drive: ltk's runtime shows it under a focused text field when no input method is there, and forge will draw the same panel in its chrome and deliver the keys to the focused client, which is the second half and is not in this commit. Along the way the demo that exercises it exposed two gaps in the widgets, fixed here too. Layouts are data. keyboards/<language>.json, one file per layout, searched in LTK_KEYBOARDS_DIR when set, then $XDG_DATA_HOME/ltk/keyboards or ~/.local/share/ltk/keyboards, then /usr/share/ltk/keyboards; osk::layout::search_paths(), available() and load( name ) are the API, and the English layout is compiled in as the last resort. A file has name, a label for the layout-switch key, layers and variants. A layer is a list of rows; a row a list of keys; a key is a bare string for the text it types, or an object with an action (shift, backspace, enter, space, layer, layout, hide), the target layer, a label, and a width in key units, 1 by default, which share the row's width so a row of nine keys comes out centred under one of ten. base is mandatory; a missing shift layer is derived from it by uppercasing. variants maps a key's text to what a long press offers, and the shifted form of a key uses its base's, uppercased. A key may also be a named key, { "key": "Escape" }, Tab, the arrows, Home, End, Page_Up, Page_Down, Delete, Insert, F1 to F12, or a sticky modifier, { "modifier": "ctrl" } or alt. en.json and es.json ship, with symbol layers and the accented variants each language needs. The files go into the registry copy through make install and into ltk-theme-default under /usr/share/ltk/keyboards. The terminal row. A terminal needs Escape, Tab, Ctrl, Alt, the arrows and the shell's symbols, and no other application does, so those are not a layout but a row laid above any language's layout: keyboards/bar-terminal.json, made of the named keys and modifiers above plus -, /, |, \ and ~ with their variants. Files named bar-*.json are rows, not layouts, and available() leaves them out, so the layout-switch key does not cycle onto one; the first version listed it and a tap on that key made the keyboard vanish behind a duplicated bar. Which applications get the row is decided by what the field says it is for: TextEdit::purpose( InputPurpose::Terminal ), snapshotted into the handlers like secure, which the built-in panel reads through set_purpose and which also goes out as the terminal content purpose of zwp_text_input_v3, the same one VTE-based terminals declare, so a compositor hosting the panel can pick the row from the protocol; for a client that declares nothing it can decide by app_id. osk::Panel is a state machine a host drives. It holds the loaded layouts, the current layer, shift as off, one-shot or locked, the sticky modifiers, the purpose and its extra row, the geometry of all of it inside the rectangle the host gave it with set_rect( rect, scale ), and the press in flight. The host feeds it press_down, press_move, press_up and, from its own timer, tick, each returning an Event: Text, Backspace, Enter, Hide, Key( keysym, modifiers ) for what text cannot carry, an arrow, Escape, Tab, or a character while Ctrl or Alt is held, or Changed when only the panel's look changed. A key types on release; a press held 450 ms opens its variants, which the finger slides onto and the release picks; backspace fires on press and repeats every 60 ms after the same delay; shift is one-shot and locks on a double tap within 350 ms; a modifier stays down for the next key and a character typed under it goes out as a Key, since text cannot carry Ctrl. next_deadline() says when tick next has work, height( scale ) what the panel needs, press_down answers None for a press outside it so the host treats that as its own. draw( canvas ) paints it with the active palette; the action keys show theme icons rather than glyphs, keyboard/shift, keyboard/backspace, keyboard/enter, general/down-simple for hide, accessibility/languages for the layout key, the general arrows for the terminal row, rasterised once per size and tint, because the first version drew ⇧ and 🌐 and the fallback chain has no glyph for the latter, which showed as a question mark; a layout key with no label of its own shows the active layout's. Nothing in Panel knows about text fields or Wayland, which is what lets a compositor host it. Fifteen tests cover the layout parser, the derived shift layer, variants following case, the bar filtering, and the panel's taps, one-shot and locked shift, variants, repeat, layer and layout switches and the terminal row. The runtime shows it. event_loop/osk.rs puts a Panel on a surface when a text field takes the focus and builtin_osk holds: the compositor advertised no zwp_text_input_manager_v3, or LTK_BUILTIN_OSK=1 is set, which is how to try it on a desktop that has an input method, or the app returns true from the new App::builtin_keyboard(). The panel is placed at the bottom of the surface by both renderers, and the widget tree is laid out in what is left above it, so the focused field is never covered. Presses, motion and releases from the pointer and from touch are offered to the panel before the gesture machine, a press on the already focused field brings a hidden panel back, and the run loop's timeout now takes the minimum of the long-press, tooltip and panel wakeups so variants and repeat fire on time. Text goes through the same insertion as a physical key, Key through the same dispatch, with Ctrl applied for its duration, Enter submits or inserts a newline in a multiline field, Hide keeps the focus and takes the panel away; losing the focus removes it. The layout is picked from $LANG. ltk::InputPurpose is exported, and docs/architecture.md gains the section that says all of this, with the compositor's part sketched. The demo. examples/inputs becomes a notebook with the login page it had and a Shell page: one multiline field that holds a transcript, prompt included, declared a terminal, so the row appears; Enter runs the line under the last prompt (echo, ls, pwd, clear), the arrows move through the transcript, and a Ctrl combination interrupts the line the way a terminal shows it. Escape quits only from the login page, because a key the app answers never reaches the field, which is what first made the arrows dead. Two widget gaps the demo found. Notebook gave its page the page's preferred height, so a page that fills its space, a scrolled list or a flex, got none and showed nothing: the active page is now wrapped in flex and gets the height under the strip. And the multiline field had no way to scroll: it chose its first visible line from the cursor alone on every draw, so the transcript ran under the keyboard and the wheel did nothing. text_edit/scroll.rs gives it a TextScroll the runtime keeps per field beside the cursor and the selection, in the frame state, the draw context and the core runtime alike: the first line asked for by hand and the cursor at that moment. The view holds there while the cursor stays put and, once it moves, follows it by the least it has to, as an editor does; without a request the result is exactly the old rule. Window::resolve computes the visible lines once for drawing, hit testing and the wheel, so they cannot disagree, and replaces the copy each of the first two had. In on_pointer_axis the vertical motion is offered to the multiline field under the pointer first, three lines per notch from value120 or discrete, touchpad pixels accumulated until they add up to a line, and only when the field cannot move that way does it go to a scroll around it. TextScroll is public but opaque, since Element::draw is public and needs it; Default is the cursor-following behaviour. Six tests cover the hold, the follow, the clamping, the notch and the accumulation. A read-only field is not interactive and does not take the wheel; touch drags inside a field do not scroll it yet. Not done. Forge does not host the panel yet, so on the phone squeekboard is still what appears. The panel's look is a first pass, sized in logical units with the theme's palette, to be restyled from mockups. Only en and es ship. admin 2026-09-25 12:50:58 +02:00
• b591950f67 Glyphs on demand: FontFace replaces fontdue, DejaVu ahead of the CJK collection in the fallback chain; App::take_clipboard_request and App::on_pointer_secondary Every face fontdue opened was parsed whole: Font::from_bytes walks the cmap and builds the outline of every glyph before returning. For the theme's Sora that is a few hundred glyphs and nobody notices. For a fallback it is the whole file: the first string with one arrow or one bullet resolved through the chain to NotoSansCJK-Regular.ttc, and a compositor or a notification daemon that had drawn a dozen labels was suddenly holding 330 MB of outlines for 44 810 glyphs, after 1.7 s of CPU, to paint the hundred or so glyphs a screen ever shows. Measured on forge: 240 MB before the first app-switcher label, 542 MB after it, and never given back, because the table is live, not garbage. FontFace. The new src/font_face.rs is the face type the whole crate now rasterises with, built on the ttf-parser that rustybuzz already brings in and on tiny-skia, which already fills paths. from_bytes( data, index ) keeps the bytes and reads only what a face needs up front: units per em and the vertical line metrics. A ttf_parser::Face is rebuilt on every use rather than kept, since parsing one is table-offset arithmetic, in the noise next to the outline work it guards. Each glyph's outline is extracted the first time it is asked for, through Outliner, into a tiny_skia::Path, and cached for the process lifetime in a HashMap<u16, Arc<Outline>>; codepoint lookups are cached the same way. Rasterising fills that path into a Mask and hands back the 8-bit coverage, top row first, which is what both canvases stored before. The metrics keep fontdue's conventions, so no widget changed: sizes scale by px / units_per_em, Metrics::xmin / ymin are whole-pixel placements with the fractional remainder folded into the raster offset, bounds is the outline box in subpixels, LineMetrics carries ascent, descent, line gap and their sum. One thing is deliberately not what glyf declares: the box comes from the points the outline actually reaches, quadratic and cubic extrema included, because declared boxes may be loose and a box wider than the ink shifts the glyph on the pixel grid. Tests cover the turning-point arithmetic and the line-metric scaling. FontFace, Metrics, LineMetrics and OutlineBounds are exported, since Canvas::font and font_for hand them out. What changed around it. fontdue leaves Cargo.toml. The two canvases, their text and setup modules, the registry, the rich text and text widgets swap Arc<Font> for Arc<FontFace> and nothing else; the glyph caches still key on (glyph_id, size_bits, font_id). FontRegistry now reads a source into an Arc<Vec<u8>> and gives the face the bytes it will pull outlines from, so the registry no longer owns a second copy; its parse error names the file rather than a library message. FontHandle keeps font and bytes side by side, now naming the same buffer, so shaping needs no second read and the comment that explained the duplication is gone. system_fonts builds fallback faces from the bytes each slot already holds, and the slot stays two-staged: the bytes are read once to probe coverage with ttf-parser, the face is built only when a glyph in that slot is needed, and a face that is built no longer costs anything until it draws. The chain. DejaVu Sans moves from last resort to just before the CJK collection. It owns the geometric shapes, arrows and box-drawing blocks, which are what a user interface most often needs outside its own family; behind the collection, every one of those pulled the 19 MB file in, since probing a slot for coverage reads it whole. The CJK entries stay last for the same reason. The two hooks are for a host that embeds another UI, trust in this case, and complete the ones App already had. take_clipboard_request is the counterpart of nothing: an app could paste from the system clipboard through its text fields but had no way to put text into it. Return Some( text ) once and the run loop stores it and publishes it as the seat's selection through the data device, the same path handle_copy takes for Ctrl+C in a text field, so other applications see it. on_pointer_secondary reports a right-button press that no widget of ltk's own answered, in physical pixels like on_pointer_button: on_pointer_right_click already dispatched a widget's on_long_press and the built-in text menu, and in the remaining case only dismissed an open menu; it now also tells the app, which can forward the press to an embedded view that has a context menu of its own. Not changed. Variable fonts are read at their default instance, as before. Colour glyphs, COLR or bitmap, are not rendered by either rasteriser; the outline path draws what it can. The glyph caches are still unbounded per face, but they now hold what was drawn, not what the file contains. admin 2026-09-25 07:43:47 +02:00
• 494fb26f9e README: ltk is not mobile-first, its surfaces adapt to any screen Two lines carried the mobile-first framing that Eydos is dropping across its components. "mobile-first Linux shells" appeared among the cases the toolkit is especially relevant for, and "attention to mobile power usage" among the priorities its origin explains. Neither describes what ltk does. There is no mobile edition and no desktop edition of anything built with it: the same widgets are designed to work at any size and with any input, touch or pointer, and the layout is chosen per screen at run time. A reader who takes "mobile-first" at face value concludes that a desktop application is a secondary use of the toolkit, which is the opposite of the intent. The same framing is being dropped from forge and crustace. The power usage line is imprecise for a second reason. What makes a toolkit care about wakeups, redraws and idle cost is that the device runs on a battery, not that it is a phone: a laptop has the same constraint and a board on mains power has neither. "attention to power usage on battery-powered devices" states what the priority is actually about and still covers the phones it was written for. Documentation only. No code and no public API is touched, and these were the only two occurrences of the word in the file. admin 2026-09-23 20:55:07 +02:00
• 919df60681 App::take_blur_request, and a press on a focused select_on_focus field positions the cursor Two gaps found while using trust's address box on a phone, both about what happens to a text field once it holds the focus. Dropping the focus. An app could ask for the focus of a widget, through App::take_focus_request, but had no way to give it up. A browser needs to: once an address is submitted the field has done its job, yet it kept the focus, so the on-screen keyboard stayed over the page that had just been asked for, and came back whenever the window was raised, since ltk enables the input method again on the text-input enter that follows while a text field holds the focus. App::take_blur_request is the counterpart: return true once and the run loop calls set_focus( keyboard_focus, None ), the same call the back request already uses to blur a text field, so the text-input disable and on_text_input_focused( false ) come with it. It is handled just before the focus request, so an app that asks for both in one cycle ends up focused, which is what "open a new tab and type" needs; a pending focus_retry from an earlier cycle is cleared, or it would hand the focus straight back to the widget it was taken from. Positioning the cursor in a select_on_focus field. handle_text_pointer_down and handle_text_pointer_drag returned at once for a field built with .select_on_focus( true ), so that the press that focuses it keeps the whole-value selection set_focus has just installed. The guard did not distinguish that press from a later one: in a field that already had the focus, no press ever placed the cursor and no drag ever selected a range, with a finger or with a mouse. That suits a numeric picker poorly and an address box not at all, where correcting one character of a long URL meant retyping it. AppData gains press_on_focused, computed in both press paths, touch and pointer, right before their set_focus: whether the press landed on the widget that already held the focus. The two guards now apply only when it did not. The first press on such a field selects everything, as before; a press on it while focused collapses the selection to the byte offset under it, and a drag from there extends the selection. Not changed. handle_text_select_word keeps its select_on_focus guard, so a double press on such a field still leaves the whole value selected rather than a word. The right-button path, which opens the context menu without touching the selection, never reached these functions and is unaffected. set_focus still moves the cursor to the end and reselects when it is called for the widget that already has the focus; a programmatic focus request on a focused select_on_focus field therefore selects everything again, which is what an address-box shortcut wants. admin 2026-09-21 22:45:16 +02:00
• 1db7a026c9 Default theme: navigation/close-small drew nothing, in either variant Both close-small.svg files, line and filled, held the two diagonals of the cross as bare segments, M785 3221L799 3235 and its mirror, painted with fill="#000000" and no stroke. A straight segment encloses no area, so filling it paints no pixel, and stroke defaults to none: the file is valid SVG that renders as a fully transparent image, in ltk's rasteriser and in Inkscape alike. The rest of the catalogue is drawn as closed outlines, which is what lets an icon be filled and tinted without depending on a line width; this one looks like it was exported with its strokes never converted to paths. A scan of the 432 icons of the catalogue for the same pattern, no stroke and no closed subpath, turns up no other icon with the defect. Each diagonal is now a closed shape: two parallel sides 1.5 units apart joined by a half circle at each end, the rounded ends close.svg has. The width is a little heavier in proportion than that icon's (2 units on a 23.6 box), since this one exists to be drawn small. The viewBox, each variant's own translate and the visual extent of the original drawing, 0.5 to 14.5, are kept: the axes are inset by the half width so the caps end where the tips of the segments were. Both diagonals are subpaths of a single path filled with the default nonzero rule, on purpose: the evenodd that close.svg carries would punch a hole where they overlap. line and filled share the shape, as they do for close.svg. The outlines use elliptical arc commands, which no other icon of the catalogue does; they were checked by rasterising both files with Inkscape. admin 2026-09-21 13:53:49 +02:00
• 2af281520b External text input for fields ltk does not own; TextEdit::color and TextEdit::on_focus Two additions driven by apps that host another UI inside an ltk surface: trust, whose pages have their own form fields, and rustdroid, which projects Android views into ltk widgets. External text input. ltk only ever enabled zwp_text_input_v3 for its own TextEdits, so nothing told the compositor that an editable inside an embedded web view had the focus: the on-screen keyboard never came up inside a page, which makes a browser unusable on a phone without a hardware keyboard. Three hooks on App close that. external_text_input() -> Option<u64> asks for the input method on behalf of such a field: while it returns Some( serial ) and no ltk text widget holds the focus, the runtime keeps a text-input enabled, and the compositor raises its keyboard. on_external_text_commit( text ) and on_external_text_delete( before, after ) receive what the input method sends, the latter in UTF-8 bytes as the protocol counts them. Keys such as Backspace and Enter keep arriving as key events, which hosts already forward. The request is a serial rather than a bool so that it can be renewed. A compositor that folds its keyboard while the field keeps the focus, which forge does on back, has nothing to observe when the user taps that same field again, because the text-input never stopped being active; a change of serial makes the runtime send enable again through reenable_text_input, the same signal ltk now sends for its own fields. The host chooses what bumps it; trust counts taps on the page, so dragging to scroll does not bring a folded keyboard back. AppData::sync_external_text_input, in text_editing/ime.rs, is polled after every batch of updates next to sync_fullscreen. An ltk text widget always wins: while one has the focus the function only clears its record, and set_focus manages the text-input as before. When that widget loses the focus set_focus destroys the text-input, and the next poll finds the request still standing with no text-input and enables a new one, so the two owners hand it back and forth without either knowing about the other. The zwp_text_input_v3 dispatch routes commit_string and delete_surrounding_text to the app only when the external request is held and no ltk text field is focused; that second check covers the one iteration between a widget taking the focus and the next poll. The empty-string filter on commit_string is folded into the Option it already lived in. TextEdit::color( c ). The colour of a field's value always came from the theme. A field placed over a surface the theme knows nothing about, an Android EditText with its own text colour on its own background, could end up unreadable. color sets the value's colour in both draw paths, single-line and multiline; the placeholder keeps the theme's, and a field without it draws exactly as before. TextEdit::on_focus( msg ). App::on_text_input_focused( bool ) says that some text field is focused, not which. An app that mirrors focus into another model needs to know which: rustdroid keeps Android's single focused view in step, and could only learn the field from its first on_change, so View.isFocused() stayed false until the user typed. A WidgetId cannot carry that, being a &'static str while such handles are created at run time. A per-widget message can, since the app builds it and puts in it whatever it needs. It rides the WidgetHandlers::TextEdit snapshot, and set_focus pushes it when the focus actually moves to the field, from a press, Tab or App::take_focus_request, and not again for a press on the field that already holds it. Every other match on that handler variant uses .., so the new field touches its definition, its clone and the snapshot in element.rs. Documented in the App rustdoc, the trait surface list of docs/architecture.md, the text_edit entry of docs/widgets.md and the changelog. Neither path has a test: both need a live Wayland connection and a compositor to exercise. admin 2026-09-21 12:45:09 +02:00
• 96a9e88051 Back as a navigation request: App::on_back, BackAtRoot, NavStack and docs/navigation.md; renew the text-input enable on a press; fit an oversized window_size_hint to the screen Three changes that came out of making the shell's back button work across Eydos the way it does on Android. The first is the feature; the other two are gaps it exposed. Back is no longer Escape. forge turns its back gesture and button into the XF86Back key for the focused client, and ltk treated that key as an alias of Escape: close transient UI, else drop the focus and reach on_key_with_modifiers. That is "cancel", and it is all an app could get: nothing navigated, and nothing ever left the app. XF86Back is now a back request with its own order, one layer per request, top-most first: transient UI the runtime owns (open xdg-popup overlays, the built-in context menu, a text selection, the top-most pressable carrying an on_escape, i.e. a dialog's cancel), then text-input focus, then the new App::on_back, then on_key_with_modifiers( XF86_Back ) so an app that bound the key itself keeps receiving it (crustace does, for its launcher), then App::back_at_root. The first step is what Escape already did; it moves out of handle_key_escape into AppData::dismiss_transient in the new input/keyboard/back.rs, which both paths call, so Escape behaves exactly as before. Text focus comes before the app on purpose: with a keyboard covering half the screen, back means "put the keyboard away", and navigating instead would discard what the user was typing. A compositor that folds its keyboard itself, as forge now does, only lets the next request through, which makes this step the fallback for the ones that do not. App::on_back returns a BackResponse: Message( msg ) with the message that undoes the top-most piece of navigation state, Unhandled at the root, or Consumed for a host whose back stack lives elsewhere and cannot be inspected ahead of time. Consumed exists for rustdroid: an Android app keeps its activities, fragments and back callbacks in its own code, so the host can only hand the request over. App::back_at_root then picks Minimize (the default), Close (through on_close_requested, which can still veto) or Ignore. Minimising is what a root activity does on Android since version 12 and what suits an app the user comes back to: a browser keeps its tabs, a call goes on. It is also the single point where the two stacks meet: the navigation stack belongs to the app's model, the task stack to the compositor, and xdg_toplevel.set_minimized is the one standard request between them, so no custom protocol carries navigation state out of the process and clients that are not ltk apps keep working. Only ShellMode::Window surfaces react at the root; a panel or a lock screen that minimised itself would be a bug. Three consequences of back being a navigation request rather than input: the key leaves the default App::key_repeats set, since a held button would empty the whole stack; it is no longer reported through App::on_raw_key, so a host forwarding raw keys into an embedded web view or guest toolkit stops leaking it as a keystroke; and the mouse's back button (BTN_SIDE / BTN_BACK) enters through the same handle_back. focused_text_input becomes pub( crate ) for the new module. The answer is derived, not recorded, and that is the design decision worth writing down. The runtime keeps no navigation stack of its own. Its entries would have to be messages, which are not serialisable (the trait puts no serde bound on Message, by design), so it could not survive a relaunch; and a list of "things to undo" drifts the first time the user leaves a screen some other way, through its own close button or a link, leaving a back press that does nothing visible. An answer computed from the model cannot disagree with it. This is also what ties back to the session persistence added earlier: navigation state is both what on_back reads and what save_state should persist, and keeping the two the same is what makes back retrace the same places after a session restore or a crash, with nothing extra to serialise. Persist less and a restored app opens on the right screen with nothing behind it; persist more and it restores a menu the user had closed. NavStack<R> packages that rule for the common case, an app made of screens. It is a plain value the app keeps in its model, never seen by the runtime: push, pop, replace (the sideways move back should not retrace), pop_to_root, reset, current, current_mut, iter, depth, can_pop, and back( msg ), which answers on_back directly. It is stored as a root plus the routes above it rather than as a Vec, so "never empty" holds by construction, including after deserialising an old or damaged state file, and it derives serde whenever R does. Six unit tests cover it, a serde round trip among them, and its rustdoc example is a complete App where one object answers on_back, save_state and restore_state. Documentation, since the point is for app authors to take navigation state into account. The new docs/navigation.md is the reference: transient UI versus navigation state and the test that separates them, the back order and the reason for each step, why the answer is derived, how it lines up with session state, NavStack, apps that embed a web view (whose page history is navigation state too, to be persisted with ltk-webkit's session_state), hosts with a foreign back stack, the root, who owns which stack, and an author's checklist. architecture.md gains a group in the trait surface and a paragraph in the state patterns, onboarding.md and the README index link to it, and in the cookbook the multi-screen recipe now uses NavStack with on_back and persists the stack without serde, which keeps it compiled by the Markdown doctest harness (that harness links ltk alone, so the serde example in navigation.md is marked ignore and compiled as NavStack's own doctest instead). BackResponse, BackAtRoot and NavStack are exported at the crate root and in the ltk::window facade. Behaviour change for existing apps, also recorded under Changed: a window app that implements neither on_back nor the key is now minimised on back at its root, where nothing happened before; BackAtRoot::Ignore restores that. With a text input focused, back only drops the focus and the app sees the next request, where it used to get the key in the same press. Renew the text-input enable on a press. Moving the focus between two text fields, or pressing the one already focused, only committed the refreshed content type on the existing zwp_text_input_v3. activate_text_input now sends enable first, as GTK does when a focused entry is clicked. A compositor that folded its on-screen keyboard while the field kept the focus, which is what back now does, has no other way to learn that the user wants it again: the text-input never stopped being active, so there was nothing for it to observe. ltk sends neither surrounding text nor a cursor rectangle, so the only state enable resets is the content type set right after it. Fit an oversized window_size_hint to the screen. The hint is pinned as min_size == max_size before the first commit, when no output is known yet, so an app asking for a phone-shaped 720x1440 window on a 1080p desktop got a toplevel taller than the screen; rustdroid carried a dead branch that tried to avoid this from a screen size nothing could give it. The first configure is the earliest point the hint can be checked, and the protocol has the right input for it: xdg_toplevel.configure_bounds, exposed by sctk as WindowConfigure::suggested_bounds and ignored until now. The new event_loop/window_fit.rs holds fit_within, which scales a size down keeping its aspect ratio until it fits and leaves one that fits untouched (four unit tests), and AppData::fit_size_hint, run once behind the new pending_size_hint_fit latch: it uses the compositor's bounds when sent and otherwise 90 % of the first output's logical size, since panels and decorations are unknown from the client side. When the hint has to shrink, min_size (and max_size for a non-resizable window) is re-pinned to the fitted size, which is kept in fitted_size_hint and replaces the app's hint as the fallback for later configures that carry no size; without that the window would grow back on the next one. On that one configure the fitted size wins over the compositor's new_size, which was derived from the oversized pin. App::window_size_hint documents the rule with the worked example (720x1440 opens as 486x972 on a 1080p output). The back order needs a live Wayland connection to exercise and has no test; the unit tests cover NavStack and fit_within. admin 2026-09-20 23:23:26 +02:00
• 2252a63f16 App: claim raw touch per press with claims_raw_touch_at, and toggle fullscreen at runtime with fullscreen Two additions to the App trait, both needed by an application that embeds a self-contained input consumer next to regular widgets. The case at hand is trust, the Eydos browser: an ltk-webkit WebView below a toolbar built from stock widgets, with an F11 fullscreen toggle. Raw touch per press. App::claims_raw_touch is all or nothing: once it returns true every finger, the primary included, bypasses the gesture machine, so widget presses, taps and swipes stop working on touch. That suits an app whose whole surface is one WebView (the eydos-settings portal), but not one that shows the view under its own chrome: claiming raw touch made the address box and the toolbar buttons dead to the finger, and not claiming it fed the page a mouse-like primary slot, so a drag selected text instead of scrolling and pinch-zoom was impossible. The new App::claims_raw_touch_at( x, y ) is consulted on wl_touch.down with the press position in physical pixels of the main surface; a finger landing where it returns true goes through the raw on_touch_down / on_touch_move / on_touch_up stream while fingers landing elsewhere keep driving the gesture machine. The default is false, so existing apps are unaffected, and it is only consulted for the main surface: overlays have their own coordinate space and the hook carries no surface argument. The implementation reuses the auxiliary-slot path instead of adding a second notion of raw ownership. In TouchHandler::down the position is now resolved before the takeover check; a claimed finger is recorded in touch_slots without becoming primary_touch_id, which is precisely the state of a second finger today, so motion, up and reset_touch_state already route it to the app and report its release point with no change. A claimed press skips the plain-press takeover (it must not commit a tap in progress on the chrome) and calls set_focus( focus, None, qh ), mirroring what a pointer press outside any widget does: without it a focused text field would keep the text-input protocol, the on-screen keyboard and the key stream after the user had moved on to the page. pointer_pos is still assigned after the takeover, since release_primary uses it as the release point of the finger being committed. Runtime fullscreen. App::start_fullscreen only covers the first commit; there was no way to enter or leave fullscreen afterwards. App::fullscreen() -> Option<bool> declares the desired state and is polled after every batch of updates, next to requested_exit. AppData::sync_fullscreen compares it with applied_fullscreen, the last value sent, and calls xdg_toplevel.set_fullscreen( None ) or unset_fullscreen only on a change; None, the default, leaves the window state alone. applied_fullscreen is seeded with start_fullscreen(), so an app that starts fullscreen and reports Some( true ) does not send a redundant request, and one that reports Some( false ) is not pushed out of a fullscreen it asked for a moment earlier. It is a no-op for layer-shell and session-lock surfaces, which have no toplevel. The configure handler now also zeroes titlebar_height while WindowConfigure::is_fullscreen() holds, as it already did for server-side decorations. The built-in titlebar was otherwise painted over a fullscreen surface, which is what the start_fullscreen doc comment described as happening "unless the app opts out" without there being a way to opt out. The height follows the compositor's reported state rather than the app's request, so it stays correct when the compositor refuses the request or leaves fullscreen on its own. Both hooks are documented on the trait and listed in the changelog under Unreleased. admin 2026-09-20 08:22:46 +02:00
• eaf88754f3 text_edit: scale the single-line horizontal padding with the field height The previous commit put the password eye, the caret and the whole multiline layout in physical pixels, but the single-line variant still inset its text by the raw theme::PAD_H: 20 physical px whatever the scale. On a scale-2 panel a field 88 px tall, drawn as a pill of radius 44, kept a 20 px inset, so the first glyph sat inside the rounded end while everything else in the field had grown. The padding now follows the field height, like the eye already did: metrics::single_line_pad_h( rect ) is PAD_H × rect.height / theme::HEIGHT, built on single_line_scale, which replaces the private password_toggle_scale of draw.rs. The height is the right reference rather than canvas.geom_px( PAD_H ): the inset exists to clear the pill's rounded end, whose radius is half the height. With the default height the two agree, since that height is itself geom_px( HEIGHT ); when the app pins the height the padding follows that choice instead of the fluid mode, which on a large surface would push it to 1.5 times the design value next to a field the app deliberately kept smaller. It also needs no canvas, so password_toggle_hit_zone( rect ) keeps its signature. draw resolves the padding once and uses it for the narrowed text rect, the inner clip, the selection band, the placeholder, the text and the caret; password_toggle_hit_zone uses it for the half padding beside the eye. single_line_scroll_x, single_line_align_offset and the single-line branch of byte_offset_at use the same helper, so a click still maps to the glyph that was drawn. hit_test.rs no longer references theme and drops the import. A field HEIGHT tall at scale 1 keeps exactly the previous geometry. admin 2026-09-19 16:14:21 +02:00
• 495968fca5 text_edit: size the password eye and the caret in physical pixels, and resolve the multiline layout through the canvas Canvas coordinates are physical pixels while font sizes are handed to the raster path in font space and multiplied by dpi_scale there. TextEdit mixed both: on a 2560×1440 panel at scale 2 a field 44 logical px tall measures 88 physical px and its text 32, yet the eye of password_toggle was rasterised at the 20 px of PASSWORD_TOGGLE_SIZE and the caret was font_size + 4 = 20 px tall and 2 px wide, so both came out at less than half their intended size next to a field that otherwise scaled correctly. Password toggle. The icon, the slop around it and the column reserved for it on the right edge now follow the field height, which is already physical: password_toggle_scale is rect.height / theme::HEIGHT and password_toggle_reserve applies it to the icon plus its slop. password_toggle_hit_zone( rect ) keeps its signature and is built from the same helpers, so the zone that handle_password_toggle_press tests still matches what draw paints. A field HEIGHT tall at scale 1 gives exactly the previous geometry, which is what the existing hit-zone tests cover. Caret. The single-line caret multiplies its height and width by canvas.dpi_scale(), the same factor the glyphs are rasterised with. The literals become theme::CARET_W and theme::CARET_OVERHANG, shared with the multiline variant. Multiline. The multiline variant had the same defect throughout: preferred_size, draw_multiline, the multiline branch of byte_offset_at and the cursor_visual_* helpers all used theme::FONT_SIZE, LINE_H_MULT, PAD_V_MULTI and PAD_H as raw numbers. The text was rasterised at 16 × dpi_scale but the line pitch stayed at 22.4 physical px, so at scale 2 the rows overlapped, the first one was clipped at the top, the caret was half height and the box claimed half the height its rows needed. It also ignored .font_size( … ) and the widget-scaling mode, which the single-line variant honours. The new metrics.rs holds MultilineMetrics, resolved once per call from the canvas and the field's font_size: the font through resolve_font_size, the glyph and line heights from it times dpi_scale, the paddings through canvas.geom_px like the other stock widgets, and the caret size. It also owns the inner width, the visible row count and the first visible row, which draw_multiline and byte_offset_at each computed on their own. Sizing, drawing, hit-testing and vertical caret navigation now agree by construction. cursor_visual_up, cursor_visual_down, cursor_visual_home and cursor_visual_end gain a font_size: Option<Length> parameter; their callers in event_loop/text_editing/cursor.rs already received it from text_input_geometry and discarded it. One visible change at scale 1: the multiline paddings and the default multiline font now go through geom_px and font_px, so in fluid mode they scale with the surface between 0.7 and 1.5 times the design value instead of staying at 20 / 12 / 16 px. The horizontal padding of the single-line variant is still the raw PAD_H. admin 2026-09-19 16:00:58 +02:00
• 53e7ccc46e Keep the GLES path when the scale arrives first, stop re-rendering what does not change, and let the compositor skip what the surface covers Measured on a Librem 5 (Cortex-A53, GC7000Lite, 720×1440 at scale 2) with a frame trace on both sides of the socket: the shell's main surface repainted in 110 to 136 ms, quick settings drew at 20 fps with the GPU saturated, and every panel open uploaded its wallpaper and icons again. Most of it was the toolkit doing work the frame did not need. Backend choice. When the compositor announces the output scale before the first configure, scale_factor_changed allocated an SHM pool for the surface and on_configure took that pool as the sign that the software path had been chosen, locking the surface to tiny-skia for its whole life. Every ltk main surface on a scale-2 phone ran in software while its overlays, which inherit the scale from the main and never receive that event, ran on the GPU. The scale handler now only reallocates a pool that already exists; before the first configure neither path is chosen. Wallpapers. WallpaperBundle::for_size returned the crop at the source resolution, a 1103×2160 slice of a 4K image for a 720×1440 panel, 10 MB uploaded per texture and a hundred milliseconds each time. The crop is now downscaled to the surface (bilinear, once per size, cached), also for landscape surfaces smaller than the source. Viewport. Element::Viewport created a fresh sub-canvas every frame, on GLES a framebuffer, a 2048² glyph atlas and empty image and glyph caches, so a panel clipped to a height that animates re-uploaded its wallpaper and re-rasterised every glyph on every frame. Without a bottom fade the clip is now a scissor on the parent canvas (a mask on the software backend): no offscreen pass, no blit, and the child's textures stay in the parent's caches. local_viewport is honoured through a temporary override of the layout viewport. Viewports with a fade keep their sub-canvas, which, like the scroll sub-canvases, is now kept across frames and resized in place instead of reallocated when its size changes. Caches. The image texture cache moves from the canvas to the GL context: every canvas and sub-canvas shares one content-keyed LRU (32 MiB), so an overlay or subsurface that is destroyed and recreated finds its images resident. A GLES canvas dropped with an overlay is pooled in AppData::canvas_pool and handed to the next overlay, with its compiled programs and glyph atlas, which took 130 to 290 ms to build on that GPU. Subsurface slots keep their scroll and viewport sub-canvases between rasters. Surfaces. A container.surface() with shadows costs a Gaussian drop-shadow pass, a fill and one pass per inset shadow, all full-quad fragment shaders; a dozen glass cards were 40 ms of GPU per frame for chrome that never changes. Canvas::fill_surface on GLES now renders the chrome once per size, corners and style into a texture held by the context cache (gles_render/surface_cache.rs, 16 MiB LRU) and blits it, drawing directly only for surfaces with PlusLighter or Overlay insets, which depend on the backdrop. Opaque regions. ltk never called wl_surface.set_opaque_region, so the compositor blended every ltk surface and repainted everything underneath a full-screen homescreen. A surface whose background_color is opaque now declares itself opaque, and the new App::overlay_opaque_region( id ) lets an overlay declare the physical rects it paints opaque, such as a panel column over an opaque wallpaper. sync_opaque_region sends the rects only when they change. Frame pacing. eglSwapBuffers blocked 13 to 37 ms per frame waiting for Mesa's own throttle callback; ltk paces itself on wl_surface.frame, so make_current sets the swap interval to 0. A subsurface move is now applied only when its parent has no frame callback outstanding, and the parent commit that applies it requests the next callback: a drag commits once per vblank with the latest finger position instead of once per input sample, without the app throttling samples itself. While the app reports subsurface_motion_only, the main's callback, and the callback of an overlay that hosts a subsurface, no longer force a full repaint; they mark the surface and the reconcile keeps the cadence with a bare commit when nothing moved. Swipe releases arm a settle the same way instead of dirtying every cache. Two hooks, on_overlay_frame_committed and on_subsurface_committed, let an app hand a panel over between its host and a sliding subsurface on real commits rather than loop ticks. Lines. A diagonal draw_line on GLES stamped one fill_rect per pixel of length, 190 draw calls for a spinner and over 2000 for a pattern-lock stroke; it is now a single rotated quad through the rect shader, with round caps and antialiased edges. A pixel test covers the scissor viewport, for_size gets a downscale test, and docs/architecture.md, docs/widgets.md and docs/backends.md describe the new hook, the viewport paths, the shared caches and the line rasteriser. admin 2026-09-18 09:55:09 +02:00
• 03bb7eeede button: elide the label against a minimal inset instead of the horizontal padding draw_text_button elided the label against the granted width less twice PAD_H. That padding is 24 design px resolved through the widget-scaling mode, up to 36 logical px in fluid mode, so on a scale-2 laptop each side took 72 physical px off the label area. A PIN key pinned at 80 logical px kept 16 px for its digit: "1" fitted, "2" onwards did not, and elide returned "..." although that did not fit either. loginmanager's keys, at 56 dp, ended with a negative area and drew no digit at all. Icon buttons never went through that cut, which is why backspace and OK still showed. The padding belongs to the preferred size of an auto-width button, whose granted rect already contains it, so it has nothing to protect at draw time. A pinned width, or a row shrunk below its preferred width, may leave less than the padding; the label now keeps only LABEL_INSET, 4 design px, off the frame and uses the rest of the rect before eliding. admin 2026-09-16 22:12:14 +02:00
• 58b8dd7b90 Focus requests reach widgets clipped by a scroll viewport, and stop retrying after a few frames A scroll viewport keeps in widget_rects only the widgets at least partly inside its visible area (draw/layout.rs, the translation of the sub-canvas rects to surface space). A focus request whose target sits below the fold therefore never finds it: App::take_focus_request was honoured only for widgets already laid out on screen. The Wi-Fi page of settings is one such case by construction: tapping a secured network inserts the password form under the row and asks for focus on the field, so for a row in the lower part of the list the field is born outside the viewport and the request misses. Worse, the miss branch parked the id in focus_retry, marked the view dirty and requested a redraw on every iteration, so the application rebuilt and repainted at the compositor's frame rate for as long as the widget stayed hidden. The layout pass now records the widgets it drops for carrying a WidgetId: DrawCtx::scroll_clipped holds (id, scroll flat_idx, rect) with the rect in the scroll's content coordinates, the same frame the navigable-item list uses, and draw_frame hands it to FrameState. When a focus request misses, AppData::reveal_clipped_widget looks the id up in that list on the main surface and the overlays, finds the viewport in scroll_rects, and moves its offset on the axes the scroll allows so the rect lands inside; the next frame lays the widget out and the retry focuses it. Nested scrolls resolve one viewport per frame. The rule that computes the new offset is scroll::offset_into_view, extracted from the keyboard navigation in input/keyboard/nav.rs, which now calls it instead of carrying its own copy; unit tests cover the three cases. focus_retry carries a budget of drawn frames (FOCUS_RETRY_FRAMES, four), decremented only on iterations that actually drew, so a request made while a frame callback is pending does not lose its chance. A fresh request from the application replaces a pending retry with a full budget. When the budget runs out the request is dropped, which ends the redraw loop for a widget that never appears. Documented in the take_focus_request doc comment, the cookbook and the changelog; Debian revision 0.3.0-3. admin 2026-09-14 11:50:27 +02:00
• 5b8ae35830 [ltk — src/input/gesture/mod.rs, src/input/gesture/tests.rs, src/widget/handlers.rs, src/input/keyboard/dispatch.rs, src/render/image.rs, docs/architecture.md, CHANGELOG.md] Keep a tap on a button while the finger rolls inside it, treat XF86Back like Escape, and convert ARGB8888 by whole pixels Any travel past the slop turned a press into a vertical or horizontal drag and its release skipped the button, so a thumb that rolled on a large key lost the tap. GestureState::on_move now stays idle while the pressed widget fires on press (the new WidgetHandlers::has_press) and the finger is still inside its rect; the swipe machinery takes over from the original press point once the finger leaves. Presses inside a scroll viewport are unaffected, since a list of full-width rows is scrolled by dragging on them. Two tests cover the tap that survives motion inside the button and the swipe that arms once the finger leaves it; the architecture notes and the changelog describe the rule. The compositor now sends XF86Back for the Android back gesture, an inward swipe from either side edge. With a text input focused that keysym fell into handle_key_default and was swallowed, so an app never saw it. XF86Back now dispatches through handle_key_escape, so every ltk app gets the back gesture with Escape's layering: open popups, then the context menu, then a selection, then a dialog's cancel, and finally the focus drop and on_key_with_modifiers with the keysym, where an app can act on it. SoftwareCanvas::write_to_wayland_buf swapped red and blue with a byte-by-byte loop, unrolled by hand over sixteen bytes. It now reads each pixel as a u32, exchanges the two channels with masks and shifts, and leaves the vectorisation to the compiler. Compositors that offer ABGR8888 never took this path. admin 2026-09-14 10:57:10 +02:00
• 75be800390 input, render: keep fast touch typing whole, fire pattern nodes once, and make the software image path cheap Two ways a tap was lost on a phone. The gesture machine serves one finger: a second finger landing while the first was still down went to the auxiliary slot and never reached it, so with two thumbs every overlapping tap on a keypad vanished. A finger landing on a primary that is still a plain press (GestureState::is_plain_press: no drag, scroll, swipe or slider in flight) now commits that press as a tap at its last position and takes the primary slot; the earlier finger's release reports through on_touch_up, and a second finger during a pattern stroke or a slider drag stays out as before. The touch-up body moves to release_primary so both paths share it. The other loss needed one finger: the 8 px travel that turns a press into a scroll, swipe or drag, and the 6 px stray that cancels a touch long-press, were compared against physical coordinates, so at buffer scale 2 they were 4 and 3 logical px and an ordinary thumb tap became a vertical drag whose release skipped the button. SwipeConfig carries the surface's scale and the machine reads the thresholds through slop() and stray(), which are logical. Pattern grids fired on_node on every motion event within a node's snap radius, and the Slider move outcome requested a repaint each time, so drawing a pattern rebuilt and re-rastered the surface at the touchscreen's motion rate. The machine remembers the node under the finger (last_pattern_node) and emits only on change; the handlers split pattern_node_at from pattern_msg, with pattern_node_msg kept on top of them; a move outcome without a message no longer requests a redraw. SoftwareCanvas::draw_image_data premultiplied the whole source in floating point on every call, so a full-surface backdrop paid a pass over every pixel per frame before the blit. Premultiplied copies now live in a 32 MiB least-recently-drawn cache keyed by size, content fingerprint and alpha, the key the GLES texture cache already used; fingerprint_rgba moves to render::helpers and both backends share it. The entry records whether the source was fully opaque, and an opaque image drawn 1:1 with no clip and full alpha is copied row by row into the canvas instead of going through tiny-skia's bilinear pipeline. docs/architecture.md describes the primary-slot hand-over, docs/widgets.md the once-per-node contract, and the CHANGELOG lists the five fixes. admin 2026-09-12 10:43:51 +02:00
• 0a4afd8f81 tree, text_edit, render: hit-test only the visible part of scrolled widgets; keep the clip when a text field's interior misses the dirty region Two partial-repaint bugs seen in Settings. A row scrolled half out of a scroll viewport kept its full layout rect for hit testing: only paint_rect is clamped to the viewport, and find_widget_at tested rect alone. The row whose bottom sliver showed just below the search field therefore owned, for the pointer, its whole height above the viewport, so hovering the field showed the hand cursor and highlighted that row, and a click opened it. find_widget_at now requires the point to lie in paint_rect as well. Inside a scroll or viewport that is the visible part; elsewhere paint_rect always encloses rect, so nothing else changes. rect is left intact because sliders, focus scrolling, the IME rect and tooltips need the full geometry. Two tests cover a clipped row and an unclipped button. The search field's placeholder darkened as the pointer moved over the list, until a full repaint restored it. TextEdit::draw composes its interior clip as the intersection of the parent clip with the inner rect; during a hover repaint of a row the intersection is empty, and set_clip_rects with an empty list means "no clip", so the placeholder was painted unclipped over the previous pixels on every partial frame. With text_secondary being text_primary at 0.6 alpha, two or three passes read as bold. interior_clip now returns a zero-area rect for an empty intersection, shared by the single-line and multiline paths, which the GLES backend already turns into a zero scissor; the software backend gains the matching rule, keeping an all-zero mask when the rect list is non-empty but has no area instead of dropping the clip. A test pins the three cases. admin 2026-09-11 19:24:49 +02:00
• 92b090a441 App: fix the on_main_frame_committed doc, the hook orders a swap, it does not make it atomic The comment promised that a subsurface mounted or retired from the hook lands in the same flush as the main frame. It does not: the main buffer goes out with its swap, which flushes the connection at once, and the subsurfaces are reconciled afterwards. What the hook guarantees is ordering, the main frame is already sent when it fires, which is enough to retire a subsurface safely but not to mount one without a gap. admin 2026-09-10 22:57:30 +02:00
• 87f52565c3 App: add on_main_frame_committed, called after every main-surface commit A host that hands part of its content to input-transparent subsurfaces has no way to know when the main frame that replaces that content has actually been sent: view() runs when the tree is dirty, but the draw can be deferred by a pending frame callback, so a subsurface dropped on the strength of the rebuild alone can vanish a frame before the main paints its replacement. The new hook fires in draw_frame right after the main buffer is rendered and committed, before the subsurfaces are reconciled for the same iteration, so the host can retire a subsurface knowing the main frame behind it is already out. on_first_frame_committed keeps its one-shot role. admin 2026-09-10 22:54:27 +02:00
• c9ae5438f8 pattern_grid: explicit side through PatternGrid::size The grid's preferred size was the theme's fluid constant (264 px at the reference surface) capped by the width the parent allocates, so a caller could only shrink it: a lock screen that wants the grid to span most of a phone's width had no way to ask for it, and a container's max_width did nothing past the default. PatternGrid gains a size field with a size( impl Into<Length> ) builder; preferred_size resolves it through Canvas::resolve_geom like the other geometry overrides and still caps it at max_width, and map_msg carries it across. Without the builder the fluid default applies as before. docs/widgets.md describes the builder next to hide_stroke and error; CHANGELOG lists it under Unreleased. admin 2026-09-10 21:33:55 +02:00
• 7c1ef86afe Resolve fluid geometry bounds in logical space and let the runtime set the density from the buffer scale Stock widgets size themselves with Length::fluid, whose auto-clamp [0.7·px, 1.5·px] is documented as logical px, yet Canvas::resolve_geom resolved it against the physical viewport and applied the bounds to the physical value. On any HiDPI surface whose physical short side exceeds 618 px (412 × 1.5) the cap engaged: a 1080 × 1920 phone at scale 2 got its geometry at 1.5 physical px per design px, that is 0.75 logical, while fonts, resolved by font_px against the logical viewport and scaled at raster time, kept growing to 2.62. Rows, paddings and icons came out at 60 % of their intended size with the text overflowing them; at scale 1 physical and logical coincide, so a winit session never showed it. Length::resolve_physical takes the buffer scale and multiplies min_px / max_px by it before clamping; resolve_with_density delegates to it with scale 1. Canvas::resolve_geom passes its dpi_scale, so every stock-widget geometry shares the surface factor of the fonts, and overlays_reconcile does the same for OverlaySpec::size, which had the same mix. A zero scale falls back to unscaled bounds. The event loop now calls set_density( sf ) right before App::on_scale_changed, both on configure and on scale_factor_changed of the main surface, so Length::dp( n ) means n logical px in every app without plumbing; an app wanting a DPI-derived density still overrides it from that callback, and crustace already sets the same value there. Two tests cover the clamp at scale 2 and the geometry/font parity on a 1080 × 2460 canvas. admin 2026-09-10 21:18:24 +02:00
• 2cee9a1c57 event_loop: drop the text-input focus when the focused field vanishes from a rebuilt view A view rebuild that no longer contains the focused text field left focused_idx pointing at a stale index and the zwp_text_input_v3 object enabled. The compositor kept seeing an active text-input, so the on-screen keyboard stayed up over a screen with nothing to type into. The lockscreen's inactivity return from the password form to the idle screen is the visible case: the form disappears, the keyboard does not. focus.rs gains surface_focused_text_input, which resolves the focused widget by id when it has one and by index otherwise and reports whether it is a text input, and reconcile_text_focus, which clears the focus, deactivates the text-input and calls on_text_input_focused( false ) when it no longer resolves to one. draw_frame notes, before drawing the main surface and each overlay, whether its focus was a text input, and reconciles those surfaces once every draw is done and no view borrow is live. Focus that lands on the field again through take_focus_request re-enables the text-input as before. admin 2026-09-10 21:12:45 +02:00
• 492553829e widgets, input: PatternGrid for pattern unlock, framed icon buttons, and text keys that bubble past a focused non-text widget; Debian 0.3.0-2 PatternGrid is a 3×3 drag widget for the unlock pattern. It is stateless: the app owns the visited nodes and passes them back in for drawing; a press or a drag that reaches a node within the snap radius fires on_node with the index, 0 to 8 row-major, and release fires on_release, so the crossing and minimum-length rules stay in the app. Geometry lives in widget/pattern_grid/theme.rs (size, dot and node radii, stroke width, snap radius, ring alpha), and the snap radius is resolved through the widget-scaling mode at layout time like the slider thumb (set_pattern_snap_px). The gesture machine reuses the slider's drag ownership: WidgetHandlers::is_drag_target covers both, so hover painting, pointer capture and release behave the same, and hover_affects_paint no longer special-cases sliders. The a11y tree maps it to GenericContainer, since a drawn gesture has no assistive equivalent and the app must offer another method. Exported as pattern_grid / PatternGrid, documented in widgets.md, theming.md and architecture.md, with tests for node centres, a wide rect, snapping, the builders, the handler snapshot and map_msg, and a Security tab in examples/widgets.rs that shows the drawn path. Icon buttons given a width or height are framed keys: preferred_size honours the explicit size instead of the icon size, and drawing paints the variant's background, border and focus ring, shared with text buttons through paint_frame, then centres the icon. An icon button without a size keeps the circular hover overlay it had. This is what lets the PIN keypad's backspace and OK keys sit in the same circles as the digits. Keyboard routing now matches what App::on_key documents. handle_key_default, Backspace, Delete and Space checked focused_idx.is_some() and sent the key into text insertion whenever any widget had focus, which is a no-op on a button, so a focused button or pressable swallowed typed characters. focused_text_input replaces the five copies of that check; characters, Backspace and Delete stay in a focused text input and reach the app otherwise, Return and Space still go to the focused widget's submit or press message when it has one, and the arrow, Home and End handlers use the same helper. The lockscreen relies on this to take PIN digits with its dots row focused. debian/changelog: 0.3.0-2. admin 2026-09-09 17:27:42 +02:00
• a2752a5bd3 Handle SIGTERM/SIGINT with a sigaction self-pipe instead of a signalfd, and clear the signal mask of spawned children The signalfd-based source (calloop's signals feature) needs SIGTERM and SIGINT blocked in every thread of the process, since the kernel hands a process-directed signal to any thread that does not block it. calloop only blocks them in the thread that creates the source, so the runtime depended on ltk::run being entered before the app spawned any thread — a constraint apps do not honour: crustace-notifier builds its tokio runtime and its D-Bus thread first, and in that configuration a SIGTERM lands on a tokio worker and kills the process outright, skipping the clean exit (save_state, mark_clean_exit) entirely. The blocked mask had a second consequence: it is inherited across fork and exec, and Rust's std deliberately does not reset it in the child. Every process an ltk app spawns from a thread created after ltk::run therefore started with SIGTERM blocked. For the gsettings monitor child of the text-scale watcher this meant it never died on systemd's stop, so the unit's cgroup stayed populated until TimeoutStopSec (90 s) expired and systemd resorted to SIGKILL — visible as a stop job holding up every session shutdown. install_signal_source now installs a sigaction handler for SIGTERM and SIGINT that writes the signal number to a non-blocking O_CLOEXEC pipe (an atomic load and a write, errno preserved); the read end is a calloop Generic source that drains the pipe and sets exit_requested. A handler is process-wide, so the clean exit works no matter which thread receives the signal or when it was created, and no thread blocks anything, so children inherit a clean mask. SA_RESTART keeps the handler from injecting spurious EINTRs into the app's own threads; the pipe wakes the event loop regardless. text_scale additionally clears the child's mask in pre_exec before running gsettings, as a guard against a mask already dirty when the process was launched. The save_state docs drop the caveat about threads started before run, the ordering comment at the call site goes with the constraint it described, and the signals feature is dropped from calloop. libc becomes a direct dependency for sigaction, pipe2 and sigprocmask. Tests: child_starts_with_clear_signal_mask blocks SIGTERM in the test thread, spawns a child through the helper and checks its SigBlk in /proc, with the inverse control asserting that std really does inherit the mask (the reason the helper exists); handler_writes_signal_to_pipe exercises the handler directly and through a real sigaction + raise, then restores SIG_DFL. admin 2026-08-25 09:47:08 +02:00
• 902e23e7f2 Fallback fonts: probe glyph coverage with ttf-parser before building the fontdue face The first string containing a glyph outside Sora stalled the caller for over a second, even on a desktop i7. system_fonts::lookup_handle walked the fallback chain building a fontdue::Font for every slot just to consult its cmap, and fontdue parses the whole face up front: reaching a dingbat such as U+2733 meant paying for NotoSansCJK-Regular.ttc (19 MB) although the glyph is not even there and only DejaVu, the last slot, carries it. In forge that showed as the app switcher taking more than a second to appear the first time a window title carried such a symbol; the top bar never triggered it because its text is all Latin. Each slot now has two lazily resolved stages: the file bytes, read once, and the fontdue face. Coverage is answered from the bytes alone with rustybuzz::ttf_parser::Face::parse(...).glyph_index(ch), which only touches the tables it is asked for, and the fontdue face is built solely for the slot that actually owns the glyph. A CJK codepoint still pays the CJK parse, since it has to be rasterised, but a symbol that lives in DejaVu no longer drags the collection into memory. The sticky negative results are kept at both stages, and the shaping-side bytes in FontHandle now share the Arc with the coverage stage instead of a second copy. admin 2026-08-18 11:36:28 +02:00
• 3046d86337 Layer::Window overlays: an OverlaySpec can now be an ordinary xdg toplevel, named through App::overlay_title; showcase persists the last pressed button too A shell built on ltk had no way to show something as a regular window: every overlay is a layer-shell surface, and layer-shell surfaces are either below all application windows or above all of them. crustace's "closing applications…" card ran into exactly that — on the overlay layer it covered the applications' own "save changes?" prompts, on the bottom layer it vanished behind their windows — and what that card wants is to be one window among the others: decorated by the compositor, stackable, listed in the switcher and the dock. Layer gains a Window variant. An OverlaySpec carrying it is materialised by the reconciler as an xdg_toplevel (sctk Window, server-side decorations) instead of a layer surface: size is its fixed size, applied through min/max size (a zero component falls back to a default, since a toplevel cannot "fill"); anchor, exclusive zone and keyboard exclusivity are ignored. The window's app_id is App::app_id() and its title comes from the new, defaulted App::overlay_title( id ), so the compositor's window lists show something meaningful. WindowHandler::configure and request_close now resolve which surface a window belongs to: the main window keeps its behaviour, an overlay window is configured through its own SurfaceState (with the window geometry set to the configured size) and the compositor's close button delivers the spec's on_dismiss instead of exiting the app. Layer-shell applications now bind xdg_wm_base when the compositor offers it, so they can open such a window later. Adding a variant keeps every existing OverlaySpec literal compiling; the new trait method has a default. The showcase example now also saves and restores last_pressed, bumping its private state format to version 2 with the note kept last so its line breaks survive. admin 2026-08-15 17:56:06 +02:00
• ccf07de593 Session management: xdg-session-management-v1 client, mandatory App::app_id / save_state / restore_state, runtime-managed state persistence and clean exit on signals (0.3.0) Applications built on ltk had no way to come back where the user left them: the toolkit hardcoded app_id = "ltk" on every toplevel, never wrote anything to disk, and died on SIGTERM without a chance to save. This release gives the runtime the whole plumbing and asks each application only for the bytes worth keeping, in the spirit of Android's saved-instance state. The App trait gains three mandatory methods, deliberately without default bodies so every application states its position: app_id() (reverse-DNS, used for xdg_toplevel.set_app_id, the AccessKit application name and the state directory — the app_id element of the deprecated window_config tuple is now ignored and a one-time warning reports a mismatch), save_state() -> Option<Vec<u8>> and restore_state(Vec<u8>). The bytes are opaque; the trait carries no serde bound. Their rustdoc is the contract: when the runtime saves, where the files live, when the bytes come back and when they do not, what must never go in them, and a worked serde_json example. The runtime persists under $XDG_STATE_HOME/<app_id>/ (falling back to ~/.local/state): session.json holds the compositor session id, a clean-exit marker and the writer's pid; state.bin holds the application bytes. Writes are atomic (temp file + rename, mode 0600, directory 0700) and best-effort. State is saved every 30 s when the bytes changed, once after the event loop exits (which covers on_close_requested, requested_exit and lost connections), and on SIGTERM/SIGINT — a calloop signal source, installed before any thread exists, now turns those into a clean exit of the loop instead of process death. restore_state runs synchronously in try_run before the window is created and before the first view(), and only when the process is relaunched as part of a session restore (LTK_SESSION_RESTORE=1, removed from the environment before the app can spawn children) or when the previous run left clean_exit: false; a plain launch starts fresh. A second concurrent instance detects the live pid and runs with persistence disabled rather than clobbering the first. The compositor side of geometry restore goes through xdg-session-management-v1. Neither wayland-protocols nor sctk ship generated code for it yet, so the XML is vendored under protocols/ and wayland-scanner generates the client module in-tree (src/protocol/), resolving the crate names through sctk's reexports so the bindings stay on the crate instances sctk links. Before the first commit of a ShellMode::Window toplevel the runtime binds xdg_session_manager_v1, calls get_session(reason, stored_id) and restore_toplevel(toplevel, "main"); the three window-creation paths in run.rs are folded into one make_window helper so the attach always sits immediately before commit(). created persists the id, replaced destroys the objects and stops persisting. Compositors without the global lose only the geometry half. Layer-shell and session-lock surfaces skip the whole machinery. Every App implementor in the tree is updated: the twelve examples (showcase, scroll and mini_shell persist real state; the rest return None), both integration tests (event_loop_flow gains save_restore_round_trip), the in-source and markdown doctests, README, onboarding, cookbook (new recipe "Surviving relaunch: session state") and architecture docs, and the changelog. src/session_state.rs carries unit tests over a temporary state directory. Makefile install now copies protocols/ into the cargo registry — without it downstream builds would fail inside the proc-macro — and debian/copyright covers the vendored XML. The trait change is breaking, hence 0.3.0. Also fixes the pre-existing viewport_tests module in render/mod.rs, which used Length without importing it and broke cargo test. admin 2026-08-15 10:16:30 +02:00
• 78053b8b01 Cover every output from a background shell: the session-lock secondary machinery generalizes to layer surfaces The runtime already covered outputs beyond the first, but only for ShellMode::SessionLock: locked created one ext-session-lock surface per output, tracked in lock_extras, rendered from App::lock_secondary_view, excluded from pointer/touch routing and repainted through the shared invalidation path. A background shell had nothing equivalent, so on a multi-monitor session its wallpaper simply did not exist on the extended screens — the compositor had to fake one by cover-scaling the primary's background, wrong scale and wrong crop included. The machinery is shared rather than duplicated. The state and the hook lose their lock-specific names — lock_extras becomes secondaries, main_lock_output becomes main_output, App::lock_secondary_view becomes App::secondary_view — and everything downstream of creation (the draw loop in frame.rs, invalidation, per-surface scale handling, the input exclusion in pointer/touch, redraw scheduling in run.rs) is the same single copy serving both kinds. What is genuinely new is the second creation site: in new_output, when the app's shell mode is Layer( Background ), every output beyond the main surface's gets its own background layer surface — anchored to all four edges with size delegated to the compositor, exclusive zone 0, no keyboard interactivity — bound to that output at creation and torn down in output_destroyed. The main surface's output is now recorded when it materializes so the runtime knows which output not to cover. Layer-shell events learn about secondaries too, and the configure branch is not optional: secondaries live outside the focus map, so their configure used to fall into the None arm and resize the main surface. closed on a secondary now just drops it instead of asking the app to exit. secondary_view keeps its default of None (surface filled with background_color), so nothing changes for apps that do not opt in; the session-lock behaviour is unchanged aside from the renames. admin 2026-08-14 23:20:58 +02:00
• 99a4767815 event_loop: cover every output with a session-lock surface, with the app's backdrop on the secondary ones ext-session-lock-v1 obliges the compositor to blank any output that has no lock surface, and the runtime only ever created one, on the first output — so on a multi-monitor session the extended screens went black the moment the lock engaged. The lock grant now creates one lock surface per advertised output: the first keeps hosting the app's main surface exactly as before, and each remaining output gets its own surface tracked in lock_extras, paired with its WlOutput so configure, scale and teardown can be routed per surface. What those extra surfaces show is up to the app: a new App::lock_secondary_view( width, height ) returns the content for a secondary output of that physical size, and the default None paints the surface with background_color(). The draw pass renders them without requesting frame callbacks — their content is static between invalidations, and a callback that is never re-requested would leave frame_pending stuck — and invalidations that touch the main surface also mark the extras, so a backdrop that follows main-surface state (wallpaper swaps, theme changes) stays in sync. The per-surface plumbing that only ever knew about the main surface learns to route: SessionLockHandler::configure matches the surface against main and the extras instead of assuming main (an extra's configure used to resize the main surface's target), and the scale-change resize moves into an apply_surface_scale helper shared by main, overlays and the lock extras, so a HiDPI secondary gets a correctly scaled buffer instead of staying at factor 1. new_output creates a lock surface for an output hotplugged while locked — the compositor would blank it otherwise — and output_destroyed drops the matching extra. Input on the extras is deliberately inert, with one asymmetry: pointer and touch events landing on them are discarded rather than falling back to Main, because their coordinates would hit-test the main surface's widgets and a click on a secondary screen could press whatever sits at those coordinates on the form — the power button included. Keyboard keeps its existing fall-through to Main, so typing works wherever the compositor decides to put the lock focus. admin 2026-08-14 13:01:15 +02:00
• adbbc0248b render: pre-scale font_line_metrics by dpi_scale The text pipeline works in physical pixels: measure_text and draw_text multiply the font size by dpi_scale internally, and the layout rects widgets receive are physical too. font_line_metrics was the one exception — it returned line metrics at the logical size — so the line height and ascent the text and rich_text widgets derive from it came out divided by the surface scale factor. On any output with a scale other than 1 (e.g. a 200% display, or any fractional setting the compositor rounds up to buffer scale 2), wrapped lines overlapped, baselines sat too high, and preferred_size reported half the real text height. Scale the size handed to horizontal_line_metrics by dpi_scale in both the Canvas wrapper and the GLES backend, matching the already pre-scaled font_metrics. At scale 1 the behaviour is unchanged. admin 2026-08-11 22:04:22 +02:00
• 98c82385c7 tooltip: compute the hover pill in the overlay's physical space, drop it on scale change Layout runs in the physical pixels of each surface's buffer, but tooltip_overlay positioned the pill in logical ones: the anchor was divided by the source surface's scale and clamped against the logical screen size, and the resulting x/y were then applied verbatim as a physical stack translation. At scale 1 the two spaces coincide and the mix is invisible; at scale 2 the tooltip painted at half its position, towards the top-left corner and away from its icon. The whole computation now lives in the overlay's physical space: the anchor converts logical → physical with the tooltip overlay's own scale (falling back to the main surface's before the overlay exists), and the pill's estimated size folds in that scale plus the accessibility text_scale, which the text raster path already applied but the estimate ignored — the reason centring and edge clamping drifted even at scale 1 on long labels. Padding, radius, the gap above the anchor and the screen margins scale along, so the pill no longer renders with shrunken chrome around full-size text on scaled outputs. scale_factor_changed additionally cancels any pending or visible tooltip — its anchor rect was captured in the previous scale's physical pixels and nothing invalidated it; hovering re-arms it at the now-correct position — and marks overlays_dirty so overlay specs rebuild with the new scale instead of keeping geometry baked under the old one. admin 2026-08-11 15:40:23 +02:00
• 477ef13ff4 toggle, widget: scale the pill with an explicit row height, and give elide a half-pixel tolerance Toggle::height used to adjust only the row: the resolved value was floored at the theme track height and the pill kept its theme size, so a toggle capped below the fluid row height still rendered a full-size pill — on large surfaces, visibly out of scale next to controls that honour their cap. The floor is gone; when the resolved height falls below the theme row height, track and thumb now scale down proportionally (never up — the factor is capped at 1), and preferred_size reports the scaled track width so layout, focus ring and centring stay consistent. A toggle without an explicit height is untouched. elide compared measure( text ) <= max_w strictly, which breaks when the caller sized itself from the same measurement: a button reports text + 2×pad as its preferred width, the layout grants exactly that, and draw hands elide back rect.width − 2×pad. In f32 the add-then-subtract round-trip can land a few ULP under the original measurement, the strict comparison fails, and the truncation branch then costs the full width of the ellipsis — a sub-pixel deficit turned "Empezar" into "Empez...". The fit check now allows half a pixel of slack, which absorbs any mismatch of this class while leaving genuine overflows to truncate as before. admin 2026-08-09 12:07:35 +02:00
• 1290f9400e row, button, widget: distribute a row's width shortfall instead of overflowing, elide button labels into the rect they are granted, icon_size takes a Length Row deficit distribution (layout/row.rs). Row knew how to hand out leftover width but had no notion of a shortfall: leftover was floored at zero and every child was laid out at its preferred width, so a cluster wider than its rect simply overflowed — and symmetrically, because the no-spacer branch centres the block, which is why both end labels of a segmented control were clipped at once rather than only the trailing one. The shortfall now comes off the widest children first, by water filling: width_cap sorts the flexible widths and returns the largest per-child cap c for which sum( min( w, c ) ) <= available, so a long title absorbs the whole deficit while an icon button beside it keeps its size, and equal siblings — a segmented control — share it evenly. A uniform scale-down, which was the first attempt, was wrong precisely there: it thinned a header's back arrow along with the title it sat next to. Spacers and flex children stay out of the flexible set, so a pinned gap keeps the width it was given — an explicit spacer is a decision, not slack — and Row::no_shrink() opts a row out entirely, for strips deliberately wider than their viewport such as a carousel rail meant to be scrolled. align_right and the centring branch now measure the laid width rather than the preferred one, so a shrunken row is positioned against what it actually occupies. Button label elision (widget/button/mod.rs, widget/mod.rs, widget/list_item/mod.rs). Shrinking a row is only half the fix: a leaf handed less width than it asked for still painted its full string, so the deficit came out clipped instead of truncated. draw_text_button now elides the label against the rect the layout granted, less the horizontal padding, for all three variants. The truncation rule moves out of ListItem, where it was a private helper, into a single crate-internal widget::elide the two share. Text keeps its own inline copy for now: it measures through an optional font override that this signature does not carry, and folding the two together is a separate change. icon_size as a Length (widget/button/mod.rs). Button::icon_size was the one geometry setter that ignored the widget-scaling mode — it took a bare f32, pinned it, and used 0.0 as the "unset" sentinel. It now takes impl Into<Length> behind an Option and resolves through Canvas::resolve_geom, the way height, width and font_size already do. A bare number still means Length::px, so every existing call keeps its exact size; what it adds is Length::widget( n ), which follows the active mode the way stock icons do. Without it a back arrow pinned at 21 px sat next to a list_item chevron that fluid sizing had grown well past 21, and read as visibly smaller on the same row. admin 2026-08-05 12:37:03 +02:00
• 530a5696b9 event_loop, slider, list_item: overlay exclusive zones follow the surface, on_release for sliders, list labels elide against the trailing slot Exclusive zones (event_loop/overlays_reconcile.rs, event_loop/surface.rs). OverlaySpec::size is documented as physical pixels and converted to logical for layer_surface.set_size by dividing by the parent's integer scale; exclusive_zone sat right beside it in the same LayerConfig and was passed through raw, so at scale 2 the reserved band was expressed in a unit twice as coarse as the surface it is meant to match. Worse, set_exclusive_zone appeared exactly once in the whole crate — at materialize time — while the reconcile loop propagated later size changes through last_requested_size, so an overlay whose size kept being recomputed carried a reservation frozen at whatever the first frame produced. Crustace's dock is the visible case: it derives both numbers from the same desktop_pill_height, and with the zone stuck at the density-1 value (icon at its 40 px floor, 40 × 1.70 = 68 logical) while the surface grew to 87, a maximized window overlapped the top fifth of the dock — measured on a 1.75 output as 151 physical px of painted dock against a 120 px reserved band. The zone now goes through the same divisor as the size, with -1 (ignore other zones) and 0 (reserve nothing) passing through untouched as the sentinels they are, and SurfaceState tracks last_requested_zone so the reconcile loop re-sends it whenever the spec moves, committing once for both. Slider::on_release / VSlider::on_release (widget/slider, widget/vslider, widget/handlers.rs, widget/element.rs, input/gesture). Sliders only had on_change, which fires on every motion event, so an app whose commit is expensive — a subprocess, a D-Bus round trip, a compositor reconfigure — paid for it per pixel of travel: dragging the text-scale slider in Eydos Settings wrote gsettings once per motion and swept the whole desktop through a repaint each time. The new builder fires once with the final value when the drag ends, leaving on_change to move the thumb and nothing else; on_change alone behaves exactly as before, and the mapped variant propagates through map_msg like its sibling. The handler snapshot carries the callback next to on_change and exposes slider_release_msg; the gesture machine's slider branch of on_release, which previously returned an empty event list, now resolves the widget through find_widget, recomputes the value from the release position with the same slider_value_from_pos the drag path uses, and pushes ReleaseEvent::PushMsg — the variant whose documentation already described "button press or final slider value on release". A unit test covers the new emission; the existing one asserting an empty release still holds, because it passes an empty widget list and the lookup finds nothing. ListItem elision (widget/list_item/mod.rs). The label and subtitle were painted with draw_text and no width budget, so a row title longer than its width ran under the trailing text or the disclosure icon instead of truncating. The trailing slots are now measured and positioned before the text is painted — their extent is what decides how much room the label has — and both lines are elided with an ellipsis against the space left over, accumulating per-character widths the way Text already did, with one icon gap kept between the text and whatever follows it. Text keeps its own inline copy of that algorithm for now; folding the two into a single crate-internal helper is the natural follow-up, and a precondition for teaching Button to elide once Row learns to distribute a width deficit instead of only leftover space. admin 2026-08-04 18:44:21 +02:00
• d9652dce98 accessibility text scale: global font multiplier synced to the desktop's text-scaling-factor New set_text_scale / text_scale process global (clamped [0.5, 3.0]) multiplied into every resolved font size — Canvas::resolve_font for explicit Lengths and the Physical branch of font_px (the Fluid branch routes through resolve_font) — so the whole tree's text follows the accessibility "large text" factor while geometry stays untouched, mirroring GNOME's text-scaling-factor semantics. Unit test covers fonts-scale-geometry-doesn't. The run loop keeps the factor synced on its own: a watcher thread (event_loop/text_scale.rs) reads org.gnome.desktop.interface text-scaling-factor via gsettings get at startup and streams external changes from gsettings monitor into a calloop channel; on a change the loop stores the factor, invalidates the view caches and repaints main and overlays. Since fonts resolve at paint time nothing else needs rebuilding. Every ltk app tracks the settings slider live with zero app-side wiring, the same way GTK apps follow the key; missing gsettings degrades silently to a fixed 1.0. Embedders driving core::UiSurface (forge) call set_text_scale themselves — the multiplication only runs at widget font resolution, so raw Canvas::draw_text callers keep hand-computed sizes. architecture.md documents the multiplier in the font-space paragraph and CHANGELOG gains the entry. admin 2026-08-02 22:50:19 +02:00
• e343142347 viewport: local_viewport() opt-out of root-viewport inheritance; list_item: height/font_size builders Viewport::local_viewport() resolves the child's viewport-relative (vw / vh / vmin) and fluid Lengths against the viewport's own rect instead of the root layout viewport the sub-canvas inherits since the fluid-resolution inheritance change. That inheritance is right for scroll-like clips (content renders the same size inside and outside), but it is exactly wrong for a fixed-size floating mini-UI — crustace's phone-shaped quick-settings pill pinned to a corner of a desktop-wide surface resolved its vw text and fluid stock geometry against the whole monitor, inflating the content past the pill's fixed clip and cutting off the bottom stripe. The flag pins the sub-canvas's layout viewport to its own size via the new crate-internal Canvas::set_local_layout_viewport, nested sub-canvases keep propagating the pinned value, and a unit test covers the override plus propagation. ListItem::height( impl Into<Length> ) and ListItem::font_size( impl Into<Length> ) mirror the Toggle / Radio height() builders: override the theme row height (floored at the label's rendered height so the text never clips) and the primary-label font size (subtitle and trailing keep their theme sizes), letting dense context menus trade the stock touch-target generosity for row density. Docs: widgets.md gains both builder sets, architecture.md documents the layout-viewport inheritance model next to the per-canvas density it parallels, the cookbook slide-in panel recipe notes when the pill needs local_viewport(), and the toggle / radio height() rustdoc demotes its private theme::HEIGHT link to a code span so cargo doc is warning-free again. CHANGELOG entries added. admin 2026-08-02 13:38:16 +02:00
• 4247613bb0 widget/toggle, widget/radio: height() builder to override the theme row height, floored at the control's visual so it never clips Toggle and Radio report a fixed preferred height of 48 design px (theme::HEIGHT), which the fluid widget-scaling mode inflates to 72 px on large surfaces. That makes dense settings-style lists — several rows of label + control — the dominant consumer of vertical space on short landscape windows, with no way for the application to trade the built-in touch-target generosity for row density. Both widgets gain a height( impl Into<Length> ) builder storing an optional override that preferred_size() resolves through canvas.resolve_geom(), so callers can pass viewport-relative lengths (e.g. Length::vh( 5.0 ).clamp( 30.0, 48.0 )) and have the row height track the surface. The resolved value is floored at the control's visual size — the track height for Toggle, the outer circle for Radio — so the pill or ring never clips regardless of how aggressive the override is; the visual itself keeps its theme size and stays vertically centred in whatever rect the layout assigns, exactly as before. Without the builder both widgets behave identically to the previous fixed-height code. admin 2026-08-01 12:07:56 +02:00
• 806dee5167 render, types, ci: resolution-time dp with per-canvas density, bounded GLES image cache, clippy gate, backend capability matrix Length::dp no longer collapses to absolute pixels at construction: the design value travels in a new LengthBase::Dp variant and the density multiplication happens when the length is resolved. Previously dp( n ) baked in whatever density() returned at view-build time, so correctness across output changes depended on the view being rebuilt after set_density and in that order; now a density change is picked up by the very next paint with no reconstruction. Length::resolve keeps its signature (process density), and the new Length::resolve_with_density takes an explicit factor. dp becomes const in the bargain. Density also becomes overridable per canvas, the first step towards surface-local responsive state. SoftwareCanvas and GlesCanvas carry a density: Option<f32> analogous to the layout_viewport introduced for sub-canvas fluid resolution: None means "use the process global", Canvas::set_density pins a local factor, and sub-canvases inherit it. All canvas-routed resolution honours it — geom_px / font_px for stock-widget design pixels, and the new Canvas::resolve_geom / resolve_font for explicit Length values, which every widget now uses in place of the raw l.resolve( canvas.viewport_layout(), EM ) pattern (row, column, wrap_grid, spacer, container, separator, button, text, rich_text, text_edit, list_item, vslider, image, and the container draw path). Overlay sizing keeps resolving against the main surface with the global density, which is what it describes. New tests cover explicit-density resolution, resolution-time application, the local-over-global override and sub-canvas inheritance. The GLES image texture cache is now bounded. It was content-keyed but unbounded and never evicted, so a stream of distinct buffers — a photo carousel, video thumbnails — grew GPU memory for the lifetime of the canvas. The cache now tracks an estimated byte total (RGBA8, w × h × 4) against a 32 MiB budget and evicts least-recently-drawn textures on insert; the most recent entry is never evicted, so a single texture larger than the whole budget still draws and simply owns the cache until replaced. Drop-time cleanup is unchanged: drain deletes whatever the map holds. CI gains a Clippy step (workspace, all targets, test-support, -D warnings) sharing the build cache of the test job, with make clippy mirroring the invocation locally and CONTRIBUTING listing it. Run make clippy locally before pushing the first time — the gate has not seen the tree yet and pre-existing lints will fail CI until addressed. docs/backends.md formalises the software/GLES capability matrix that was previously scattered across per-method rustdoc: parity set (fills, strokes, text, images, paths, path clips), graceful degradations on software (flat-fill gradients, no shadows, no backdrop blur, hard bottom edge), GPU-only features (external textures), the shared Oklab-fallback limitation, and the cross-backend blit panic. Linked from README, onboarding and architecture's known-gaps list, which now states the parity gaps explicitly. The dp/density prose in architecture.md, lib.rs and the Length rustdoc is updated for resolution-time semantics and the per-canvas override. admin 2026-08-01 10:17:00 +02:00
• a7f953ca42 layout: adaptive grid and vertical flex; enforce the mechanical style rules grid_min_cell( width ) adds the adaptive mode WrapGrid was missing: instead of a fixed column count, the count is derived at layout time from the available width so every cell is at least width wide (any Length, so a fluid threshold works; never fewer than one column), re-derived on every resize. Cells then share the width equally, and WrapGrid::max_columns( n ) caps the derived count so cells grow instead of multiplying on very wide surfaces — the cap only applies to the adaptive mode, grid( n ) keeps the fixed behaviour untouched. Four new layout tests cover width derivation, spacing accounting, the one-column floor and the cap; the row-wrap assertions check X positions rather than Y because zero-height spacer children produce zero-height rows. flex( child ) now distributes leftover height inside a Column, mirroring its leftover-width behaviour in a Row: flex children join the weight pool alongside weight-only spacers and y-scrolls, draw their child inside the allocated share at full inner width, and contribute zero to the column's natural height exactly like a row counts flex width. This closes the documented "vertical flex is not yet implemented" gap; the Flex rustdoc and the widgets.md entry now describe both axes. Add scripts/style-check.sh and a make stylecheck target, wired into CI: mechanical verification of the grep-checkable subset of code_style_guide.md — tab indentation and spaces inside attribute brackets — with comment lines skipped so prose may cite raw attribute syntax. To turn the check on green, the 82 unspaced attribute sites across 24 files (#[test], #[derive(...)], #[cfg(...)], #[allow(...)]) were normalized to the spaced form. CONTRIBUTING and the style guide reference the new target; brace placement and paren spacing remain review concerns. admin 2026-07-30 22:20:21 +02:00
• 1fd697aa6d docs overhaul, orientation API, fluid-sizing fixes, examples made honest Documentation pass: every claim in docs/ and the meta files was audited against the source and the drift fixed — around ninety corrections. CONTRIBUTING and the CI workflow now run cargo test with --features test-support (the gated test_support module made both the documented commands and the CI build fail to compile), make example becomes make examples, make doctest-md and the debhelper requirement of make clean are documented, and patch shape asks for a CHANGELOG entry. theming.md loses the nonexistent surface.backdrop, gains the real gradient defaults (linear-rgb, oklab), the six slot variants including typography, the ten-field palette, a truthful effects-consumer table, the ThemePreference/from_hour API and a responsive-sizing note; the stale docstrings in src/theme that fed the drift are fixed too. architecture.md's "Known gaps" section is rewritten against reality (multi-touch slots, xdg-activation, a11y live regions and SetValue/Increment/Decrement are implemented), gains a module map, subsurfaces and window-lifecycle coverage, and correct crustace/loginmanager paths. widgets.md fixes the ten factual errors (stateless spinner, toast/combo via overlays(), tooltip hover contract, row has no max_width, scroll axes, multiline text_edit, dialog panic wording) and now states the column() 16 px default padding — the recurring ambush — plus row's differing 0 default and dialog's max_width. onboarding, README and cookbook get the remaining sweep: build/test instructions, complete example lists, img_widget, clipping-parity honesty, ~30 Hz software cap, read_rgba_pixels signature, tab indentation in snippets, and rustdoc-style links that rendered literally are gone everywhere. CHANGELOG is restructured per Keep a Changelog with the missing entries (window_resizable, claims_raw_touch, Row::align_top/fill_height, caret fixes, dependency pins) and the pad_v Added/Changed contradiction resolved. New adaptive-layout API: ltk::orientation() with the Orientation enum, backed by viewport_size()/set_viewport_size — the runtime records the main surface's physical dimensions on every configure, before App::on_resize, so view() can branch a layout on portrait vs landscape without hand-tracking resizes. The portrait rule matches Length::orient (square counts as portrait); embedders driving core::UiSurface call set_viewport_size themselves. Documented in the crate root's responsive-design section and architecture.md. Fluid-vs-fixed sizing fixes in widgets, all the same disease — fluid content inside a fixed-pixel box. TextEdit::fixed_width takes impl Into<Length> (f32 call sites keep compiling as px) and the time picker's digit fields move to Length::fluid( 72.0 ), matching their fluid font so digits can no longer outgrow the box. Dialog::max_width takes impl Into<Length> with a Length::fluid( 480.0 ) default so the card scales with the stock buttons inside it, and the card's interior no longer stacks the column() default 16 px padding on top of CARD_PADDING — that double inset squeezed the action row until its buttons clipped on narrow windows. App::on_pointer_axis now triggers a view rebuild and repaint; previously state mutated in the hook did not paint until the next unrelated event. Examples reworked to be honest demos: responsive's mode/density controls become stock buttons in a grid/column so they follow the modes they demonstrate instead of overflowing; dialog's openers stack vertically, and the example gains the app-level ESC handler so the ESC chain closes an open dialog first and quits second; widgets' tab strip now switches real per-tab pages; carousel gains pointer/touch drag through the horizontal-swipe hooks (crustace's pager pattern), one-tile-per-detent mouse wheel, and snap math driven by the real surface width from on_resize instead of a hardcoded 800; clip_path arranges its cells by ltk::orientation() and sizes them from the counter-axis of the flow. admin 2026-07-30 19:28:26 +02:00
• 14572ebfb6 render: sub-canvases inherit the root layout viewport for fluid resolution Content drawn inside a scroll rendered smaller than identical content outside it: the scroll viewport draws its child into a sub-canvas sized to the viewport rect, and Canvas::viewport_layout / viewport_logical — the viewports that geom_px and font_px resolve fluid Lengths against — returned the canvas's own size. Inside a 312 px sub-canvas on a 360 px surface every fluid geometry (icon sizes, row heights, paddings) and font size resolved against 312 instead of 360, shrinking the scroll content by the width ratio, ~13 % in a phone-sized window with 24 px margins. First observed in Eydos Settings' Wi-Fi list, where the connected network row sits outside the scroll and the rest inside: the same full-fan signal icon measured 21x18 px outside and 18x16 px inside. Add a layout_viewport field to SoftwareCanvas and GlesCanvas, None on root canvases and set by sub_canvas to the parent's effective layout viewport, so nested sub-canvases keep propagating the root surface size. viewport_layout and viewport_logical consult the inherited value before falling back to the canvas size. Root canvases are untouched, and the GLES clip layers, which reuse sub_canvas, get the same correction. admin 2026-07-30 15:23:52 +02:00
• 9b99a18e26 style guide: rewrite for Rust, guard against cargo fmt code_style_guide.md was the generic C++ formulation of the Modified Allman style: it mandated camelCase for functions (every function in this crate is Rust snake_case, and rustc warns otherwise), three of its five examples taught try/catch brace placement for a construct Rust does not have, all examples were C++, and it instructed saving a .clang-format that does not exist and would not format Rust anyway. Its final YAML block was also missing the closing fence, so renderers swallowed the tail of the document. Since README defers to CONTRIBUTING and CONTRIBUTING defers here for the full rules, the contributor path terminated in the one document that contradicted the code. Rewrite it for Rust: same principles (tabs, opening brace on its own line, compact "} else {", spaces inside non-empty parentheses), plus the rules the code follows but no document stated — snake_case for functions and variables, spaces inside non-empty attribute brackets, no spaces inside generics, aligned columns, comments in English. Examples are now idiomatic Rust: if/else, match, Result with the ? operator in place of try/catch, if let, struct + impl with attributes. The file declares itself the canonical reference, with CONTRIBUTING's bullets as the summary. Replace the .clang-format section with the verified rustfmt situation: rustfmt cannot express this style (no option exists for spaces inside parentheses or attribute brackets, the brace-style options are nightly-only, and even on nightly Allman opening braces cannot combine with a compact "} else {"). Ship a rustfmt.toml with disable_all_formatting = true — a stable option, verified a no-op on rustfmt 1.8.0 — so an accidental cargo fmt or editor format-on-save can no longer rewrite the tree. admin 2026-07-30 11:37:34 +02:00
• d31e7222da list_item: trailing icon slot and horizontal inset override Disclosure arrows in list rows could only be text: the trailing slot draws a string, so apps fell back to the "›" glyph at 14 px, which cannot use the theme's arrow SVGs and looks thin next to 24 px leading icons. Add ListItem::trailing_icon( rgba, w, h ): a right-aligned icon drawn at the new theme::TRAILING_ICON_SIZE (21 px, 1.5x the old glyph em box), vertically centered. It coexists with trailing text, which shifts to the icon's left. Like the leading icon, symbolic assets are pre-tinted by the caller (tint_symbolic), so the widget stays colour-agnostic. Add ListItem::pad_h( impl Into<Length> ), a per-item override of the horizontal inset between the row edge and its content (leading icon/label on the left, trailing text/icon on the right). Resolution follows the Separator pattern: an explicit Length wins, otherwise the theme default (16 px through geom_px) applies, so existing rows are unaffected. This lets an app whose enclosing view already provides the margin bring row content flush instead of stacking both insets. Document both builders in docs/widgets.md and the changelog, and rework the list_item rustdoc example to point at trailing_icon with a theme icon for disclosure arrows instead of the text glyph. admin 2026-07-30 11:19:37 +02:00
• 16c04f4159 event_loop, text_edit, layout: focus-time cursor as an end-of-value sentinel, caret height tied to the text line, row align_top/fill_height modes Focus-time cursor (event_loop/focus.rs): focusing a text input pinned the cursor to a concrete value.len() snapshot. When the value keeps growing after focus without the widget seeing keystrokes — crustace's launcher search field is fed over IPC while forge routes the type-to-search keys around Wayland — that snapshot goes stale, and the first key delivered normally afterwards inserts mid-string. The cursor is now seeded with the usize::MAX sentinel ("end of whatever value is rendered"), the same convention select_on_focus fields already rely on; every consumer (insert/delete, arrow keys, draw, hit-test, context-menu paste offset, a11y tree) clamps via cursor.min( value.len() ), so the cursor tracks external growth and collapses to a concrete position on the first real keystroke or click. Click placement is untouched — the pointer path writes its own hit-tested offset. Caret height (widget/text_edit/draw.rs): the single-line caret spanned rect.height - 16, so a field taller than its text line (the launcher's borderless search pill) grew a caret about twice the glyph height. It now measures font_size + 4, vertically centered like the text — matching what the multiline caret already did. Row alignment modes (layout/row.rs): Row gains align_top() (children pinned to the top edge instead of the default vertical centering) and fill_height() (every non-spacer child stretched to the row's inner height, the row itself still sized by its tallest child). Both exist for siblings whose natural heights differ by a few font-metric pixels — like the QS media card next to the wifi/bluetooth chip column — where equal-height layouts cannot be achieved by estimating text heights: new_line_size is font-dependent, so px arithmetic in the app always drifts. Containers paint their chrome over the full rect they receive and columns absorb the extra in weighted spacers, so a stretched card keeps its content anchored where its internal spacers put it. admin 2026-07-30 01:02:30 +02:00
• 1234943e86 Pin fontdue to =0.9.3 — 0.9.4 requires Rust 1.87 and the toolchain is 1.85 fontdue 0.9.4 started using u{8,16,32}::cast_signed, stabilised only in Rust 1.87, so any lockfile regeneration that floats the "0.9" requirement to 0.9.4 breaks the build on the project's rustc 1.85 with E0658 (integer_sign_cast). The exact pin keeps 0.9.3 — the version everything has been building against — and also protects downstream consumers of ltk (crustace, forge) whose own lockfiles re-resolve against this requirement. Relax back to "0.9" once the toolchain moves to 1.87 or newer. admin 2026-07-29 13:43:57 +02:00
• 0062bc565c app, event_loop/run: add App::window_resizable() so a window_size_hint can declare a permanently fixed-size toplevel window_size_hint() pins min_size == max_size before the first commit so the compositor's first configure honours the requested size, and the runtime then releases max_size from the first configure handler (the pending_size_hint_unpin latch) to leave the surface user-resizable. That release is wrong for kiosk-style windows such as the installer's --windowsize test mode: the moment the pin is gone the compositor is free to resize the toplevel, and a compositor with per-app geometry persistence (forge, eydos #7) will happily restore a remembered rect over the requested one — which is exactly how the installer kept opening at 1600x900 after a single make start-desktop run had been recorded, no matter what --windowsize asked for. New defaulted trait method App::window_resizable() -> bool (default true, existing apps unaffected). When it returns false and a window_size_hint is set, the unpin latch is never armed: the min == max pin stays in place for the lifetime of the toplevel, declaring a fixed-size window that compositors must not resize or restore a remembered geometry over. Ignored when window_size_hint() is None — fullscreen and compositor-sized windows keep their current behaviour. Pairs with the forge-side change that makes both the geometry-restore hook skip windows whose current constraints report min == max and the reparenting XWM aware of them; ltk keeping the pin alive is what makes that detection possible past the first configure. admin 2026-07-29 10:20:45 +02:00
• 142096827e event_loop: drop the built-in titlebar when the compositor decorates ltk already asked for server-side decorations through SCTK (WindowDecorations::RequestServer on window creation) but painted its 36 px titlebar unconditionally, so under forge an xdg window carried two stacked bars: forge's SSD on top of ltk's own. The WindowHandler configure now honours the negotiated decoration_mode: Server zeroes titlebar_height, Client — which is also what SCTK reports when the compositor lacks xdg-decoration, e.g. GNOME — restores it from the new titlebar_base field. Every titlebar consumer (draw, close-button hit test, drag-move) already guards on the height being positive, so the suppressed bar costs nothing and the fallback path is unchanged. admin 2026-07-24 23:20:16 +02:00
• 3d7f3c53de ltk: opt-in raw touch stream for apps that consume input themselves Add App::claims_raw_touch(), an opt-in hook that routes the primary finger through the raw on_touch_down/move/up callbacks instead of the built-in single-slot gesture machine. Until now the primary finger was consumed entirely by the widget gesture machine (taps, swipes, presses) and never reached the app, which made it impossible to drive a self-contained input consumer like an embedded WebView or a game canvas from a touchscreen: the widget tree saw the taps, the embedded content never did. With the hook active every finger surfaces verbatim through the raw stream, widget gestures never arm, and per-finger positions are cached in SurfaceState::touch_slots for all slots so wl_touch.up (which carries no coordinates) can still report a release point. The touch module doc and the on_touch_down docs are updated to describe the new contract; the default remains unchanged for every existing app. Pin the transitive dependency ignore to 0.4.23: rust-i18n pulls it via globwalk, 0.4.24+ requires a rustc newer than Debian's 1.85, and its manifest does not declare that MSRV, so a fresh resolution breaks the build on stable. admin 2026-07-21 09:56:05 +02:00
• 8762ab9ce0 text_edit font sizing on Length; add Button::width and Text::line_height Unify TextEdit's font size with the button label. The button resolved its font_size Length in font space (viewport_logical, so the × dpi_scale at raster lands the right physical size), while TextEdit::font_size took a raw f32 that the draw / hit-test paths treated as a logical size. A caller that resolved a Length against the physical surface and passed the result as that f32 therefore double-counted dpi_scale and got a font that rendered too large. TextEdit::font_size now takes impl Into<Length> and is resolved against viewport_logical exactly like the button, so the two paths agree. The field stores Option<Length> (None follows the widget-scaling mode at the theme default), retiring the old f32 sentinel (0.0 = mode, negative = fluid design px). font_size_fluid becomes shorthand for Length::fluid( n ). The Option<Length> flows through the WidgetHandlers::TextEdit snapshot and text_input_geometry and is resolved at draw / hit-test time, both of which carry a canvas; the inner measure helpers (wrapping, hit_test) keep f32 because they receive the already-resolved value. Backward compatible: f32 call sites still compile via f32: Into<Length> (→ Length::px), with the same result as before. Add Button::width( impl Into<Length> ). Text buttons size to their label plus padding; some layouts need a pinned width instead — a full-width or surface-proportional button. The new builder mirrors height: resolved in physical layout space, clamped to the available max_width, propagated through map_msg, and a no-op for icon buttons. Add Text::line_height( mult ). Wrapped multi-line text used the font's declared leading (new_line_size), which is tight for some labels; the multiplier scales the gap between wrapped lines (1.0, the default, keeps the natural leading — every other text is unchanged — and a 0.5 floor keeps lines from overlapping). Applied uniformly in preferred_size and draw so the reported height and the drawn baselines stay consistent. Tests: button gains a pinned-width and a size-to-content case; text gains a line-height default / clamp test and a check that doubling the line height doubles a wrapped block's reported height. Docs: docs/widgets.md text / button / separator sections updated for the new builders, and a CHANGELOG.md "Unreleased" section covering this batch alongside the responsive work already landed. admin 2026-07-10 10:38:30 +02:00
• ce893ac776 responsive fluid/physical scaling, widget-API stabilization, and perf guardrails Responsive scaling. ltk now offers two first-class ways to size a UI so it adapts across screens, chosen per process via WidgetScaling { Fluid, Physical } (set_widget_scaling / widget_scaling, default Fluid). Fluid sizing (Length::fluid( px )) makes a design pixel a proportion of the surface's smaller side, calibrated against a reference width (set_fluid_reference / fluid_reference, 412 px default) and bounded by FLUID_MIN / FLUID_MAX; physical sizing (Length::dp( px )) is a constant-physical-size pixel scaled by display density (set_density / density). Length gains orient( portrait, landscape ) — resolve one value in portrait, another in landscape — plus widget( px ), which picks fluid or dp per the active mode. Canvas exposes geom_px (geometry, resolved in physical layout space) and font_px (font size, bridging logical / physical per mode) so widgets and apps share one resolution path. Note the rename: set_design_reference / design_reference became set_fluid_reference / fluid_reference, and Length::dp changed meaning — the old surface-proportional behaviour now lives on Length::fluid. Widgets. Every stock widget resolves its default geometry and font through the widget-scaling mode instead of frozen pixels, so a whole UI scales coherently without per-call units. New size builders where they were missing: button gains font_size / height, text_edit gains height / font_size_fluid, separator gains pad_v, and assorted widgets accept a Length where they previously took only f32. Overlays. OverlaySpec::size is now ( Length, Length ) instead of ( u32, u32 ), resolved against the main surface when the overlay is materialized, so overlays can scale with the display; Length::px( … ) reproduces the old fixed sizing. API stabilization (toward 1.0). Widget struct fields are now pub( crate ) — they are configured through builders, not field access — except the value / state types apps genuinely read or construct (Time, Date, ComboState), which stay public. The internal test_support helpers move behind a test-support Cargo feature (off by default, so third-party builds never see them; ltk's own make test enables it). Separator drops its 0.0-means-mode sentinel for Option<Length>, so an explicit pad_v( 0.0 ) is a real flush divider distinct from the mode-following default. Performance guardrails. Opt-in diagnostics via LTK_PERF_WARN=1 warn about stuck animations, sustained software-render animation, and low poll_interval; software-rendered animation is capped near 30 Hz to spare CPU on machines that fall back off EGL. Apps can override the cap with App::cap_software_animation. Docs and build. The two scaling modes are documented in README, onboarding and architecture, with the earlier gradient / backdrop doc drift cleaned up. The Makefile now ships the locales/ directory into the packaged crate (fixing i18n keys rendering raw for downstreams), builds the new responsive example, and runs tests with --features test-support. admin 2026-07-07 17:40:33 +02:00
• d4d7ee742e Bump to 0.2.0: SW/GLES paint parity, shared font resolution, FrameState refactor, docs and packaging fixes Rendering parity (software ↔ GLES). The software backend now rounds glyph pen positions and image destinations to the nearest integer pixel, matching what the GLES backend already did; previously it truncated, so text and 1:1 images could land up to half a pixel off between the two backends and the bilinear sample read ~1 px softer than the source. Gradients and shadows are deliberately left unimplemented on the software backend, and the GLES multi-rect glScissor clip is left coarse on purpose: making it exact would need stencil bits the EGL config does not carry, or routing the partial-redraw path through the offscreen clip layer, which would break its fill / clear_rects_transparent scissor semantics. Adds software-backend pixel tests covering the snapping. Font resolution unification. The system-font candidate chain, find_font_opt and load_default_font_bytes lived in two copies (render/helpers and gles_render/helpers) that had already diverged — one resolved through find_font_opt, the other inlined the candidate loop — and now live once in system_fonts. The two per-backend OnceLock default-font caches and primary_handle collapse into a single system_fonts::default_handle. Module docs and the font_registry caller are updated accordingly. Shared image validation and rect inflation. draw_image_data's dimension check and its one-line warning were byte-duplicated across both backends and are now render::helpers::validate_rgba_dims. The six manual symmetric Rect-inflate literals in the GLES primitives reuse the existing Rect::expand. FrameState and DrawCtx de-duplication. The eleven SurfaceState fields the draw pass owns and threads through DrawCtx — widget_rects, the cursor / selection maps, the scroll state, accessible_extras, prev_focused / prev_hovered / prev_pressed — move into a FrameState sub-struct. The per-frame build_draw_ctx / commit_draw_ctx helpers can then borrow &mut ss.frame, disjoint from ss.canvas and ss.pool, so the four frame paths (software / GLES × full / partial) replace their duplicated DrawCtx construction and write-back with a single helper call each. A whole-SurfaceState borrow could not express this (partial borrows do not cross function boundaries), which is why the helpers take the sub-struct. content_dirty stays on SurfaceState — it is an invalidation flag, not frame state — and is reset at the call site. rich_text tests. Adds the previously-missing tests.rs for the RichText widget: one hit rect per visual line a link spans (the widget's core invariant), the single-line and no-link cases, preferred-size growth with hard line breaks, and map_msg range preservation — all headless against a software Canvas, with line counts forced by \n so they do not depend on any system font's measured width. Documentation. Fills the rustdoc gaps on the embedder-facing surface: core::UiSurface accessors, the egl_context public API, the GlesCanvas methods, theme::typography and theme::error, and the RichText / Text builders; adds a crate-level "Rendering backends" overview. CHANGELOG.md is added (0.2.0 / 0.1.0), and docs/widgets.md / docs/cookbook.md gain rich_text, external, and the CPU-draw / path-clip / externally-laid-out-tree recipes. debian/changelog gets the 0.2.0-1 entry. Private intra-doc links to system_fonts are demoted to code spans so cargo doc is warning-free. Packaging. The libltk-dev registry crate shipped a Cargo.toml declaring the lookup bench while the Makefile install copied only src/, so Cargo refused to parse the manifest over a missing benches/lookup.rs; the install now ships benches/ as well (the file alone satisfies the parse — criterion is a dev-dependency and is not resolved when the crate is consumed as a library). Cargo.toml is bumped to 0.2.0 to match the package version and the ltk-0.2.0 registry directory. admin 2026-06-25 12:43:40 +02:00
• fb3552e9f7 Embedder primitives: placed-child clipping, offscreen RGBA readback, standalone text measurement Three additions an embedder needs to drive ltk as the render backend for a retained, externally-owned widget tree, each kept general rather than tied to one consumer. Stack placed-child clipping. Stack::push_placed_clipped(e, rect, clip) places a child at an exact rect like push_placed but clips its subtree's drawing to clip (in the Stack's coordinate space) — Android's clipChildren: content that overflows, such as a scrolled list row reaching above the list or an inner card past a rounded bubble, is not painted. The Stack child tuple grows an 8th Option<Rect> for the clip, and layout_and_draw brackets a clipped child with set_clip_rects/restore around the recursion. The clip is shifted by the Stack's own origin to match the placed rect (which Stack::layout already offsets), so a Stack laid out at a non-zero origin clips in the right place rather than off by that origin. Offscreen RGBA readback. Canvas::read_rgba_pixels(out) reads any canvas into tightly packed straight-alpha RGBA8, top-left row first. Unlike read_gles_rgba_pixels it also serves the software backend, un-premultiplying its pixmap, so an offscreen software canvas (an embedder's scratch bitmap) can be read back into a straight-alpha buffer. Canvas::is_software() lets a caller branch on the backend — e.g. to honour a real path clip on software but only a bounding rect on GLES. Standalone text measurement. measure_text(text, size), re-exported at the crate root, measures one line with the default UI font and the system fallback chain, returning (width, line_height) in pixels without a live Canvas — for an embedder's measure pass that must produce the same metrics the renderer will later use. It is backed by system_fonts::primary_handle(), a process-wide cached handle for the primary UI font (the same default a canvas loads, with the bundled-font fallback), which widens render::helpers::load_default_font_bytes to pub(crate). admin 2026-06-24 22:42:50 +02:00
• 8809313be1 theme: replace Figma-exported launcher SVGs with renderer-compatible versions yamabush1 2026-06-21 11:27:03 +02:00
• 588a3f7e36 Fix vertically-flipped content in the GLES path-clip composite The clip-layer composite shader sampled the offscreen layer at the wrong vertical position, so path-clipped content (e.g. a circular avatar) came out upside down on the GLES backend. v_uv.y runs bottom-to-top in screen space — the layer FBO has GL's lower-left origin, and ortho_rect plus the texture shader's flip establish that v_uv.y == 1 is the top edge. The composite computed the fragment's screen Y as bbox.y + v_uv.y * bbox.h, which is the inverted Y, so it read the layer mirrored about the horizontal axis. Compute it as bbox.y + (1 - v_uv.y) * bbox.h instead. The mask sampling was already correct (and a symmetric circle hid the flip in the example; a photo reveals it). The software backend is unaffected — it clips through a coverage mask with no layer round-trip. admin 2026-06-19 00:04:24 +02:00
• f8c45f0e30 Add Canvas::set_clip_path — anti-aliased arbitrary-path clipping on both backends Add Canvas::set_clip_path(&[PathCmd]), clipping subsequent draws to an arbitrary vector path with an anti-aliased edge, on both the software and GLES backends. It complements the existing rect clip (set_clip_rects) and is what an embedder needs to render a shaped clip — a circular avatar, a rounded card, a VectorDrawable mask — rather than a bounding box. Kept general rather than tied to any one consumer. Software backend: rasterise the path into an anti-aliased tiny-skia coverage Mask (Winding fill) and install it as the active clip mask. Every software primitive already threads clip_mask through tiny-skia (fills, strokes, lines, paths, images, text, blit), so the path clip applies uniformly with smooth edges. clip_bounds reports the path's bounding box while it is active. GLES backend: a 1-bit stencil would clip exactly but leave a hard, aliased edge, so instead the clipped draws are captured into an offscreen layer and composited back through an anti-aliased coverage mask. set_clip_path rasterises the path coverage (tiny-skia, anti-aliased), uploads it as a mask texture, allocates a full-canvas layer FBO on first use, and redirects subsequent draws to it via activate_target. Ending the clip (clear_clip / set_clip_rects / a new set_clip_path) composites the layer back onto the canvas FBO with a new two-sampler program (CLIP_COMPOSITE_FRAG_SRC) that multiplies the layer colour by the mask coverage and blends it premultiplied-over. The layer attaches to the canvas's own shadow FBO, so it needs no stencil bits in the EGL config; it is freed and reallocated on resize and freed on drop, and shared programs/uniforms are copied to sub-canvases like the rest. Usage: a path clip is bracketed — set_clip_path then, after the clipped draws, clear_clip or set_clip_rects to flush it (on GLES this is when the layer is composited). Snapshot the prior clip with clip_bounds beforehand and restore it with set_clip_rects to compose with an outer clip without leaking state. Add an examples/clip_path.rs demo (rounded rect, circle, triangle — same smooth result on both backends) and software-backend unit tests covering the bounding box, the empty-path clear, and a pixel-level check that a triangular clip masks a fill to the path silhouette rather than its bounding box. The GLES layer-composite path needs a live GL context and is exercised by the example. Also fix three rustdoc intra-doc-link warnings surfaced along the way: a private-item link in app.rs (scroll) and the new GLES doc (SoftwareCanvas::set_clip_path) demoted to code spans, and a redundant explicit link target in chassis.rs. admin 2026-06-18 23:59:38 +02:00
• b00cf460bb Mature ltk to host an externally-laid-out Android view tree Add the primitives rustdroid needs to project an Android view hierarchy onto an ltk surface, all kept general rather than Android-specific. Canvas gains arbitrary vector path fill and stroke: Canvas::fill_path / stroke_path over a new PathCmd command list (MoveTo/LineTo/QuadTo/CubicTo/Close in surface coordinates). The software backend rasterises directly with tiny-skia; the GLES backend rasterises into a tiny-skia pixmap and blits it (CPU fallback, no GPU path shader). This is what renders an Android Path, a VectorDrawable, or a Lottie frame. ExternalSource::Cpu (and the External::cpu constructor) adds an immediate-mode CPU drawing closure, invoked once per frame with the canvas and the widget's laid-out rect, working on both the GLES and software backends. It hosts a custom View.onDraw straight onto the ltk canvas without a GL texture round-trip, unlike the existing Texture source which only renders on GLES. Stack::push_placed appends a child at an exact rect, bypassing alignment and intrinsic sizing. This lets a view tree whose geometry is computed elsewhere — Android's measure/layout pass, which yields an absolute rect per view — be projected onto a Stack in paint order. New RichText widget: wrapped paragraph text carrying a message per clickable link range, with the layout pass emitting one hit rect per link line so taps land on the link rather than the whole paragraph. It is the ltk side of an Android Spanned carrying URLSpan / ClickableSpan. gesture: only drive the horizontal pager once the axis locks horizontal on_move emitted horizontal swipe progress whenever swipe_axis != Vertical, which includes the pre-lock window where swipe_axis is still None (the first ~8 px of travel). But horizontal_drag_started only flips once dx.abs() > 8. A vertical gesture that opened with a few pixels of lateral drift — a swipe-up to the launcher, a scroll — therefore emitted a tiny horizontal progress sample, which armed the consumer's pager, then locked vertical without dx ever passing 8, so horizontal_drag_started stayed false. On release the horizontal branch was skipped, no on_swipe_horizontal_progress(0.0) fired, and the pager stayed stuck active — on the crustace homescreen that froze the surface (the main stays motion-only behind stale page subsurfaces) until an unrelated gesture reset it. Emit horizontal progress only once swipe_axis == Some(Horizontal). Locking onto the horizontal axis already implies dx.abs() > 8, so horizontal_drag_started is set in the same step, restoring the invariant that a frame which drives the pager always has a matching release event to settle it. The cost is that the first ~8 px of a horizontal drag no longer move the page, which is the same deadband the axis lock already imposes on the vertical panels. Adds pre_lock_lateral_drift_does_not_drive_horizontal_pager. admin 2026-06-12 22:14:02 +02:00
• df8fcbf757 app: client-side xdg-activation token requests Adds an outbound path so an app can obtain an xdg-activation-v1 token from the compositor and hand it to a child it is about to launch (the $XDG_ACTIVATION_TOKEN convention). Until now ltk only honoured inbound activation (self-activating the main surface from an inherited token); requesting a token for another app was out of scope. Two new App trait methods, both defaulting to no-op: take_activation_requests returns the tags the app wants tokens for this iteration, and on_activation_token delivers the issued token paired with its tag. The run loop drains the requests right after poll_external and calls ActivationState::request_token, carrying the tag in RequestData::app_id; ActivationHandler::new_token reads the tag back out and routes the token to the app through on_activation_token. When the compositor never advertised the activation global, each request is answered immediately with an empty token so the caller still proceeds and can fall back to its own matching instead of stalling. admin 2026-06-09 23:53:31 +02:00
• cfa0faff26 ltk: subsurface slides over overlays, axis-locked swipes, physical-space layout, touch reset on resume Subsurfaces can now be parented to an overlay surface, not just the main surface. SubsurfaceSpec gains parent: SubsurfaceParent { Main, Overlay(id) } so a sliding panel can ride above app windows the way an overlay panel does, and an optional gpu: bool so content that uses the surface-panel backdrop-filter glass (a GLES-only pass) keeps it while sliding instead of dropping to the software rasteriser. reconcile_subsurfaces resolves each spec's parent independently — skipping an Overlay parent that is absent, unconfigured, or zero-sized — tracks the rastered size on the slot, and commits each touched parent once per frame. The ~14 GLES shader programs are compiled once into a shared AppData::subsurface_gles_canvas reused across every subsurface, so a lazily re-created sliding panel never recompiles them (hundreds of ms on a mobile GPU). Vertical and horizontal swipes are now mutually exclusive: a gesture locks onto its dominant axis within the first 8 px of travel (new SwipeAxis) and ignores the perpendicular axis for the rest of the gesture, so a vertical swipe that drifts sideways no longer also drives the pager (and vice-versa). The upward swipe progress is no longer clamped at 1.0 — follow-the-finger panels can keep tracking the finger past the commit threshold — and a release below threshold delivers a final progress = 0.0 cancellation pulse. A vertical swipe also no longer re-rasters the full-screen main surface on every motion event: only the overlays it drives are refreshed, while the horizontal pager (which does move the main surface) still redraws it. Re-rastering the main on every frame of a vertical drag was wasted work that stalled the loop and made the gesture feel laggy to start on a slow GPU. Layout-affecting Length values (widths, paddings, gaps, widget sizes, including Vw / Vh) now resolve against the physical viewport via the new Canvas::viewport_layout() — the space the layout tree is actually computed in — so a Vw(100) fills the surface on a HiDPI (scale 2) output instead of covering half of it. Font sizes are unchanged: they still resolve against the logical viewport and are scaled at raster time. Switched column, row, spacer, wrap_grid, container, image, and vslider over to it; img_widget and vslider now document Length::vw / vh sizing and the showcase example demonstrates a viewport-relative image. Touch gesture state is reset when the touch capability is added or removed — suspend / resume on devices that power the touchscreen down. A yanked capability never delivers the pending up / cancel, so the shared reset_touch_state() (also used by the wl_touch.cancel handler) drops the stranded primary_touch_id / slot state across the main surface and every overlay, keeping the first post-resume gesture clean. Also drops an accidental duplicate on_scale_changed call from the scale-change handler. admin 2026-06-07 16:45:59 +02:00
• 68c6a87bf6 Support viewport-relative widget sizing yamabush1 2026-06-04 12:38:59 +02:00
• ae8380b1ac event_loop: retry focus requests that land before the view is rebuilt take_focus_request() looks up the target widget by WidgetId in widget_rects. Read-only TextEdit widgets are not tracked as interactive and therefore absent from widget_rects. A swipe-reveal flips the fields from read-only to interactive on SlideRevealed, but an intervening input event (e.g. the touch-up at the end of the swipe) can cause dispatch() to return before the vblank frame callback clears frame_pending, skipping the draw that would have rebuilt the widget tree. When the focus request fires in that same iteration it finds nothing and is consumed without effect. AppData gains a focus_retry field. When take_focus_request() (or a previous retry) returns an id but the widget is not in widget_rects, the id is stored in focus_retry, view_dirty is set and a redraw is requested. The next time around the view has been rebuilt with interactive fields and the widget is present. admin 2026-06-02 14:10:37 +02:00
• e40ab637a6 bench: add missing LaidOutWidget accessibility fields to lookup bench yamabush1 2026-06-02 08:43:13 +02:00
• d221d5a0cd app: add App::subsurface_motion_only so a slide-to-reveal panel animates without re-rastering the main surface An app whose gesture/animation only moves an input-transparent subsurface (a slide-to-reveal panel over a static main surface) still paid a full main-surface re-raster on every frame of the slide, because the runtime force-dirties the main view on two paths it cannot tell apart from a real content change: MoveOutcome::Swipe calls dirty_caches() + request_redraw() per motion sample, and the WlCallback Main handler sets view_dirty + request_redraw() on every frame callback while is_animating. The subsurface reconcile already repositions the panel with a cheap set_position + bare parent commit, so the main re-raster is wasted work — and on slow targets (Librem5) it competes with the reposition and makes the slide stutter. New opt-in App::subsurface_motion_only (default false, so existing apps are unaffected). When it returns true: - the swipe dispatch (input/dispatch/outcomes.rs) still calls the on_swipe_progress family but skips dirty_caches() / request_redraw(); incoming motion events pump the loop and the per-iteration reconcile_subsurfaces carries the move. - the frame-callback animation pump (event_loop/handlers.rs) keeps the vsync cadence without a re-raster by requesting a bare wl.frame() + commit() on the main surface (no buffer attach) instead of dirtying the view; poll_external advances the animation and the reconcile repositions each frame. The main surface still redraws for genuine content changes (messages, resize, the one-shot redraw on swipe release) — only the per-frame slide raster is dropped. admin 2026-06-01 21:53:40 +02:00
• b8a32cfb96 Added pkg-config debian dependency admin 2026-06-01 20:51:45 +02:00
• 34b3e76ac1 test: make button-paints-content render check theme-robust yamabush1 2026-06-01 11:33:35 +02:00
• 48c5a89712 touch: treat a compositor re-grab down as a drag continuation When the surface that owns a touch drag is destroyed mid-gesture, the compositor re-opens the touch grab by issuing a fresh down on the surface now under the finger (smithay pins touch focus at down and won't re-target on motion). That down arrives for a slot the main surface already holds as its primary, with the drag state already migrated here. Handling it through the normal down path would either restart the gesture or, since the slot is taken, demote it to an auxiliary touch — both abandon the in-flight drag. TouchHandler::down now early-returns when the focused surface's primary_touch_id already equals the incoming slot, so the redundant down is a no-op and the following motion/up keep driving the migrated drag. Completes the cross-surface drag fix whose other half (migrating primary_touch_id on overlay teardown) already landed. admin 2026-06-01 00:19:49 +02:00