Struct AppState

Source

pub struct AppState {Show 63 fields
    pub compositor_state: CompositorState,
    pub fractional_scale_state: FractionalScaleManagerState,
    pub viewporter_state: ViewporterState,
    pub presentation_state: PresentationState,
    pub shm_state: ShmState,
    pub single_pixel_buffer: SinglePixelBufferState,
    pub dmabuf_state: DmabufState,
    pub dmabuf_global: Option<DmabufGlobal>,
    pub ext_data_control_state: DataControlState,
    pub cursor_shape_state: CursorShapeManagerState,
    pub image_capture_source_state: ImageCaptureSourceState,
    pub output_capture_source_state: OutputCaptureSourceState,
    pub image_copy_capture_state: ImageCopyCaptureState,
    pub copy_sessions: Vec<OutputCopySession>,
    pub output_state: OutputManagerState,
    pub seat_state: SeatState<AppState>,
    pub shell_state: XdgShellState,
    pub layer_shell_state: WlrLayerShellState,
    pub space: Space<Window>,
    pub data_device_state: DataDeviceState,
    pub data_control_state: DataControlState,
    pub dh: DisplayHandle,
    pub seat: Seat<AppState>,
    pub output_nodes: Vec<OutputNode>,
    pub pending_windows: Vec<Window>,
    pub foreign_toplevel_list: ForeignToplevelListState,
    pub xdg_decoration_state: XdgDecorationState,
    pub xdg_activation_state: XdgActivationState,
    pub primary_selection_state: PrimarySelectionState,
    pub popups: PopupManager,
    pub gles_renderer: Option<GlesRenderer>,
    pub pixman_renderer: Option<PixmanRenderer>,
    pub gbm_device: Option<Device<File>>,
    pub settings: RustCaptureSettings,
    pub cursor_callback_set: bool,
    pub cursor_tx: Sender<CursorJob>,
    pub clipboard_callback: Option<Py<PyAny>>,
    pub pending_clipboard_read: Option<String>,
    pub current_selection_mime: Option<String>,
    pub last_log_time: Instant,
    pub start_time: Instant,
    pub clock: Clock<Monotonic>,
    pub use_gpu: bool,
    pub cursor_helper: Cursor,
    pub keymap_policy: KeymapPolicy,
    pub host: Option<HostSession>,
    pub host_layout_pending: HashMap<u32, PendingHostLayout>,
    pub current_cursor_icon: Option<CursorImageStatus>,
    pub cursor_surface_pending: bool,
    pub cursor_buffer: Option<WlBuffer>,
    pub render_cursor_on_framebuffer: bool,
    pub pointer_warp_state: PointerWarpManager,
    pub relative_pointer_state: RelativePointerManagerState,
    pub pointer_constraints_state: PointerConstraintsState,
    pub render_node_path: String,
    pub auto_gpu_selected: bool,
    pub pending_screenshot: Option<ScreenshotRequest>,
    pub command_rx: Option<Channel<ThreadCommand>>,
    pub last_input_at: Option<Instant>,
    pub frame_idle_long: bool,
    pub last_idle_service_at: Option<Instant>,
    pub deliver_reaper: Vec<JoinHandle<()>>,
    pub encode_reaper: Vec<JoinHandle<Option<GpuEncoder>>>,
}

Expand description

Central context threaded through every Smithay handler; owns the Wayland globals, the GBM/EGL (or pixman) renderer state, and the capture/encode pipeline state.

A single AppState lives for the whole compositor thread and is mutated in place by the calloop event sources (client dispatch, input injection, the capture timer). The frame pipeline is instantiated PER DISPLAY: each OutputNode in output_nodes owns its output, damage tracker, and render targets, and its optional WlCapture owns that display’s encoder set and delivery. The non-obvious WlCapture/OutputNode fields encode the pipeline’s threading and buffer strategy:

Render / encode targets (per display):
- video_encoder: the zero-copy GPU session only (GLES render + same-GPU dmabuf encode). Its EGL/dmabuf handles are calloop-affine, so this encoder runs inline on the calloop thread; it is None whenever a readback path is active.
- encode_pool / encode_join: the readback capture||encode split. The calloop renders and reads back into a pooled host buffer and publishes it, while a separate encode thread owns the CPU / cross-GPU / pixman-HW encoders. encode_join returns that thread’s hardware session on shutdown so a restart can reconfigure it in place rather than rebuild it. Both are None while a zero-copy GPU session runs.
- frame_buffer: scratch render target used only by the pixman memory-throttle path; the normal readback path renders and reads back into the pooled buffers instead.
- pool_last_render / render_seq: buffer-age bookkeeping for the pixman path, which renders directly into the pooled buffers (an age is “renders since this slot was last the target”). The GLES path renders into one fixed offscreen buffer and never consults these.
- pool_content_gen / content_gen: staleness bookkeeping for the GLES readback path, which skips the GPU readback on no-damage ticks. content_gen advances whenever a render reports damage; a pooled buffer whose stamp lags it holds pre-damage pixels and must be read back once before publishing, so the encoder’s paint-over / burst / recovery sends never ship stale content.
Delivery (deliver_tx / deliver_join): encoded frames go to a dedicated delivery thread over a capacity-1 rendezvous channel, mirroring the X11 single-slot FramePool (non-dropping, ordered, at most one frame of blocking backpressure), so a slow GIL-holding Python callback can never stall input/control dispatch on the calloop thread.
Keyframes (pending_force_idr): set by an IDR request (client reconnect / decoder reset) and consumed once on the next captured frame to force an immediate keyframe.
Clipboard (pending_clipboard_read): stages the mime chosen in new_selection; the loop drains it only after the dispatch that stores the new client source, so the read targets the new selection rather than the previous one.
GPU selection (auto_gpu_selected): records that automatic (not explicit) selection picked render_node_path, so StartCapture aims the encoder at that same node unless a device was chosen explicitly.

Fields§

§compositor_state: CompositorState§fractional_scale_state: FractionalScaleManagerState§viewporter_state: ViewporterState§presentation_state: PresentationState§shm_state: ShmState§single_pixel_buffer: SinglePixelBufferState§dmabuf_state: DmabufState§dmabuf_global: Option<DmabufGlobal>§ext_data_control_state: DataControlState§cursor_shape_state: CursorShapeManagerState§image_capture_source_state: ImageCaptureSourceState§output_capture_source_state: OutputCaptureSourceState§image_copy_capture_state: ImageCopyCaptureState§copy_sessions: Vec<OutputCopySession>§output_state: OutputManagerState§seat_state: SeatState<AppState>§shell_state: XdgShellState§layer_shell_state: WlrLayerShellState§space: Space<Window>§data_device_state: DataDeviceState§data_control_state: DataControlState§dh: DisplayHandle§seat: Seat<AppState>§output_nodes: Vec<OutputNode>

Every live output with its per-display render/capture state; index 0 is the primary (display id 0), which is never destroyed.

§pending_windows: Vec<Window>§foreign_toplevel_list: ForeignToplevelListState§xdg_decoration_state: XdgDecorationState§xdg_activation_state: XdgActivationState§primary_selection_state: PrimarySelectionState§popups: PopupManager§gles_renderer: Option<GlesRenderer>§pixman_renderer: Option<PixmanRenderer>§gbm_device: Option<Device<File>>§settings: RustCaptureSettings

Mirror of the PRIMARY display’s capture settings (geometry fallbacks, computer-use info); per-display settings live on each capture.

§cursor_callback_set: bool

A cursor callback is registered on the wl-cursor worker (which owns the actual Py object); tracked here so sprite resolution is skipped while nobody listens.

§cursor_tx: Sender<CursorJob>

Cursor delivery jobs to the wl-cursor worker (PNG encode + Python call off-thread).

§clipboard_callback: Option<Py<PyAny>>§pending_clipboard_read: Option<String>§current_selection_mime: Option<String>

Preferred mime of the current CLIENT-owned clipboard selection, recorded even while no callback is registered so SetClipboardCallback can re-stage a read of a copy made in the gap; None when the selection is cleared or compositor-owned.

§last_log_time: Instant§start_time: Instant§clock: Clock<Monotonic>§use_gpu: bool§cursor_helper: Cursor§keymap_policy: KeymapPolicy

Seat keymap owner: base layout plus batched overlay binds. Every seat keymap swap flows through this policy, so keymap identity has exactly one writer.

§host: Option<HostSession>

Host-capture session when pixelflux captures an EXTERNAL compositor: frames arrive by screencopy and input routes to its virtual devices.

§host_layout_pending: HashMap<u32, PendingHostLayout>

Per display, the layout request the host has not answered yet. A capture start submits its mode and carries on at that size; the render tick polls the verdict and re-sizes the capture to the host’s own mode when the host kept it. Emptied with the host session.

§current_cursor_icon: Option<CursorImageStatus>§cursor_surface_pending: bool

A surface-backed cursor set during the dispatch in progress and not delivered yet: clients commit the sprite’s buffer after set_cursor in the same batch, so delivery waits for that commit, or for the end of the dispatch when none comes, rather than shipping the surface’s previous sprite under the new hotspot.

§cursor_buffer: Option<WlBuffer>§render_cursor_on_framebuffer: bool§pointer_warp_state: PointerWarpManager§relative_pointer_state: RelativePointerManagerState§pointer_constraints_state: PointerConstraintsState§render_node_path: String§auto_gpu_selected: bool§pending_screenshot: Option<ScreenshotRequest>

Computer-use screenshot request; served from that output’s next render (the id was validated live when the request was queued).

§command_rx: Option<Channel<ThreadCommand>>

The command channel, drained in place (wakeups arrive on a separate ping channel) so the render tick can apply every queued command BEFORE starting a long render/encode — queued input is never starved behind the tick it arrived during.

§last_input_at: Option<Instant>

When the last input command landed: the no-capture tick speeds up right after input so apps pacing on frame callbacks respond promptly (they are the ones noticing the idle rate while nobody encodes).

§frame_idle_long: bool

Whether the frame timer is armed at the long idle interval: input arriving then must not wait that deadline out, so the wake handler sends the idle frame callbacks itself (frame-paced via last_idle_service_at) instead of waiting for the timer.

§last_idle_service_at: Option<Instant>

When idle frame callbacks were last serviced, bounding the wake handler’s servicing to frame pace under an input storm.

§deliver_reaper: Vec<JoinHandle<()>>

Deliver threads of stopped captures, joined without blocking the event loop: the timer tick reaps the finished ones, and the shutdown Barrier drains the rest so nothing that can attach to Python outlives it.

§encode_reaper: Vec<JoinHandle<Option<GpuEncoder>>>

Encode threads whose teardown-time harvest expired (wedged behind a consumer inside Python); reaped like the deliver threads, with the unclaimed encoder dropped here on the event loop — its usual home.

Struct AppState Copy item path

Fields§

Implementations§

impl AppState

pub fn copy_frame_pending_for(&self, output: &Output) -> bool

Trait Implementations§

impl BufferHandler for AppState

fn buffer_destroyed(&mut self, _buffer: &WlBuffer)

impl CompositorHandler for AppState

fn commit(&mut self, surface: &WlSurface)

fn compositor_state(&mut self) -> &mut CompositorState

fn client_compositor_state<'a>( &self, client: &'a Client, ) -> &'a CompositorClientState

fn new_surface(&mut self, surface: &WlSurface)

fn new_subsurface(&mut self, surface: &WlSurface, parent: &WlSurface)

fn destroyed(&mut self, _surface: &WlSurface)

impl DataControlHandler for AppState

fn data_control_state(&mut self) -> &mut DataControlState

impl DataControlHandler for AppState

fn data_control_state(&mut self) -> &mut ExtDataControlState

impl DataDeviceHandler for AppState

fn data_device_state(&mut self) -> &mut DataDeviceState

fn action_choice( &mut self, available: DndAction, preferred: DndAction, ) -> DndAction

impl Dispatch<ExtForeignToplevelHandleV1, ForeignToplevelHandle> for AppState

fn request( state: &mut Self, client: &Client, resource: &ExtForeignToplevelHandleV1, request: <ExtForeignToplevelHandleV1 as Resource>::Request, data: &ForeignToplevelHandle, dhandle: &DisplayHandle, data_init: &mut DataInit<'_, Self>, )

fn destroyed( state: &mut Self, client: ClientId, resource: &ExtForeignToplevelHandleV1, data: &ForeignToplevelHandle, )

impl Dispatch<ExtForeignToplevelListV1, ()> for AppState

fn request( state: &mut Self, client: &Client, resource: &ExtForeignToplevelListV1, request: <ExtForeignToplevelListV1 as Resource>::Request, data: &(), dhandle: &DisplayHandle, data_init: &mut DataInit<'_, Self>, )

fn destroyed( state: &mut Self, client: ClientId, resource: &ExtForeignToplevelListV1, data: &(), )

impl Dispatch<ExtImageCaptureSourceV1, ImageCaptureSourceData> for AppState

fn request( state: &mut Self, client: &Client, resource: &ExtImageCaptureSourceV1, request: <ExtImageCaptureSourceV1 as Resource>::Request, data: &ImageCaptureSourceData, dhandle: &DisplayHandle, data_init: &mut DataInit<'_, Self>, )

fn destroyed( state: &mut Self, client: ClientId, resource: &ExtImageCaptureSourceV1, data: &ImageCaptureSourceData, )

impl Dispatch<ExtImageCopyCaptureManagerV1, ()> for AppState

fn request( state: &mut Self, client: &Client, resource: &ExtImageCopyCaptureManagerV1, request: <ExtImageCopyCaptureManagerV1 as Resource>::Request, data: &(), dhandle: &DisplayHandle, data_init: &mut DataInit<'_, Self>, )

fn destroyed( state: &mut Self, client: ClientId, resource: &ExtImageCopyCaptureManagerV1, data: &(), )

impl Dispatch<ExtOutputImageCaptureSourceManagerV1, ()> for AppState

fn request( state: &mut Self, client: &Client, resource: &ExtOutputImageCaptureSourceManagerV1, request: <ExtOutputImageCaptureSourceManagerV1 as Resource>::Request, data: &(), dhandle: &DisplayHandle, data_init: &mut DataInit<'_, Self>, )

fn destroyed( state: &mut Self, client: ClientId, resource: &ExtOutputImageCaptureSourceManagerV1, data: &(), )

impl Dispatch<WlBuffer, Dmabuf> for AppState

fn request( state: &mut Self, client: &Client, resource: &WlBuffer, request: <WlBuffer as Resource>::Request, data: &Dmabuf, dhandle: &DisplayHandle, data_init: &mut DataInit<'_, Self>, )

fn destroyed( state: &mut Self, client: ClientId, resource: &WlBuffer, data: &Dmabuf, )

impl Dispatch<WlBuffer, ShmBufferUserData> for AppState

fn request( state: &mut Self, client: &Client, resource: &WlBuffer, request: <WlBuffer as Resource>::Request, data: &ShmBufferUserData, dhandle: &DisplayHandle, data_init: &mut DataInit<'_, Self>, )

fn destroyed( state: &mut Self, client: ClientId, resource: &WlBuffer, data: &ShmBufferUserData, )

impl Dispatch<WlBuffer, SinglePixelBufferUserData> for AppState

fn request( state: &mut Self, client: &Client, resource: &WlBuffer, request: <WlBuffer as Resource>::Request, data: &SinglePixelBufferUserData, dhandle: &DisplayHandle, data_init: &mut DataInit<'_, Self>, )

fn destroyed( state: &mut Self, client: ClientId, resource: &WlBuffer, data: &SinglePixelBufferUserData, )

impl Dispatch<WlCallback, ()> for AppState

fn request( state: &mut Self, client: &Client, resource: &WlCallback, request: <WlCallback as Resource>::Request, data: &(), dhandle: &DisplayHandle, data_init: &mut DataInit<'_, Self>, )

fn destroyed( state: &mut Self, client: ClientId, resource: &WlCallback, data: &(), )

impl Dispatch<WlCompositor, ()> for AppState

fn request( state: &mut Self, client: &Client, resource: &WlCompositor, request: <WlCompositor as Resource>::Request, data: &(), dhandle: &DisplayHandle, data_init: &mut DataInit<'_, Self>, )

fn destroyed( state: &mut Self, client: ClientId, resource: &WlCompositor, data: &(), )

impl Dispatch<WlDataDeviceManager, ()> for AppState

fn request( state: &mut Self, client: &Client, resource: &WlDataDeviceManager, request: <WlDataDeviceManager as Resource>::Request, data: &(), dhandle: &DisplayHandle, data_init: &mut DataInit<'_, Self>, )

fn destroyed( state: &mut Self, client: ClientId, resource: &WlDataDeviceManager, data: &(), )

impl Dispatch<WlKeyboard, KeyboardUserData<AppState>> for AppState

fn request( state: &mut Self, client: &Client, resource: &WlKeyboard, request: <WlKeyboard as Resource>::Request, data: &KeyboardUserData<AppState>, dhandle: &DisplayHandle, data_init: &mut DataInit<'_, Self>, )

fn destroyed( state: &mut Self, client: ClientId, resource: &WlKeyboard, data: &KeyboardUserData<AppState>, )

impl Dispatch<WlOutput, OutputUserData> for AppState

fn request( state: &mut Self, client: &Client, resource: &WlOutput, request: <WlOutput as Resource>::Request, data: &OutputUserData, dhandle: &DisplayHandle, data_init: &mut DataInit<'_, Self>, )

fn destroyed( state: &mut Self, client: ClientId, resource: &WlOutput, data: &OutputUserData, )

impl Dispatch<WlPointer, PointerUserData<AppState>> for AppState

fn request( state: &mut Self, client: &Client, resource: &WlPointer, request: <WlPointer as Resource>::Request, data: &PointerUserData<AppState>, dhandle: &DisplayHandle, data_init: &mut DataInit<'_, Self>, )

fn destroyed( state: &mut Self, client: ClientId, resource: &WlPointer, data: &PointerUserData<AppState>, )

impl Dispatch<WlRegion, RegionUserData> for AppState

fn request( state: &mut Self, client: &Client, resource: &WlRegion, request: <WlRegion as Resource>::Request, data: &RegionUserData, dhandle: &DisplayHandle, data_init: &mut DataInit<'_, Self>, )

fn destroyed( state: &mut Self, client: ClientId, resource: &WlRegion, data: &RegionUserData, )

impl Dispatch<WlSeat, SeatUserData<AppState>> for AppState

fn request( state: &mut Self, client: &Client, resource: &WlSeat, request: <WlSeat as Resource>::Request, data: &SeatUserData<AppState>, dhandle: &DisplayHandle, data_init: &mut DataInit<'_, Self>, )

fn destroyed( state: &mut Self, client: ClientId, resource: &WlSeat, data: &SeatUserData<AppState>, )

impl Dispatch<WlShm, ()> for AppState

fn request( state: &mut Self, client: &Client, resource: &WlShm, request: <WlShm as Resource>::Request, data: &(), dhandle: &DisplayHandle, data_init: &mut DataInit<'_, Self>, )

fn destroyed(state: &mut Self, client: ClientId, resource: &WlShm, data: &())

impl Dispatch<WlShmPool, ShmPoolUserData> for AppState

fn request( state: &mut Self, client: &Client, resource: &WlShmPool, request: <WlShmPool as Resource>::Request, data: &ShmPoolUserData, dhandle: &DisplayHandle, data_init: &mut DataInit<'_, Self>, )

fn destroyed( state: &mut Self, client: ClientId, resource: &WlShmPool, data: &ShmPoolUserData, )

impl Dispatch<WlSubcompositor, ()> for AppState

fn request( state: &mut Self, client: &Client, resource: &WlSubcompositor, request: <WlSubcompositor as Resource>::Request, data: &(), dhandle: &DisplayHandle, data_init: &mut DataInit<'_, Self>, )

fn destroyed( state: &mut Self, client: ClientId, resource: &WlSubcompositor, data: &(), )

impl Dispatch<WlSubsurface, SubsurfaceUserData> for AppState

Struct AppState