Struct Toggle 

pub struct Toggle {
    id: Id,
    rect: Rectangle,
    children: Vec<Box<dyn View>>,
    enabled: bool,
    event: Event,
    left_label_index: usize,
    right_label_index: usize,
    selection_box_index: usize,
    left_text_width: i32,
    right_text_width: i32,
}

A toggle component that displays two options side-by-side, separated by a vertical line.

The Toggle component provides a binary choice control where one option is highlighted with a minimal border box while the other appears without highlighting. Tapping either label toggles the state and emits a configured event.

Implementation Note

Toggle uses a child view approach for the selection box. The SelectionBox is added as the 4th child and renders on top of the labels (due to z-order). When the toggle state changes, the SelectionBox is updated to reposition around the selected label.

Visual Layout

┌─────────────────────────┐
│ ┌─────────┐ │           │
│ │Option A │ │ Option B  │ ← enabled = true (A selected)
│ └─────────┘ │           │
└─────────────────────────┘
     ↑             ↑
  Selected      Normal
  (border)   (no border)

Event Flow

1. User taps on either label
2. Label emits its configured event (bubbles to parent via bus)
3. Toggle intercepts this event in its handle_event()
4. Toggle updates internal state (flips enabled)
5. Toggle updates the SelectionBox child to reposition
6. Toggle triggers a re-render
7. Toggle re-emits the event to continue bubbling up

Example

use cadmus_core::view::toggle::Toggle;
use cadmus_core::view::{Align, Event, ViewId, ToggleEvent};
use cadmus_core::font::Fonts;
use cadmus_core::rect;
use std::env;
use std::path::PathBuf;

let fonts = &mut Fonts::load_from(PathBuf::from(env::var("TEST_ROOT_DIR").unwrap())).unwrap();

let rect = rect![10, 100, 410, 160];
let wifi_toggle = Toggle::new(
    rect,
    "On",       // First option text
    "Off",      // Second option text
    true,       // Initial state (On selected)
    Event::Toggle(ToggleEvent::View(ViewId::SettingsMenu)),
    fonts,
    Align::Right(10)
);

Alignment Behavior

The right label uses the provided alignment, while the left label remains centered to avoid crowding the separator. This keeps the toggle right-aligned with other setting values while maintaining consistent padding to the edge.

Fields

• id - Unique identifier for this view
• rect - The rectangular bounds of the toggle
• children - Contains 4 children: [Label, Filler, Label, SelectionBox]
• enabled - true = first option selected, false = second option selected
• event - Event to emit and intercept when toggling
• left_label_index - Index of left label in children vec
• right_label_index - Index of right label in children vec
• selection_box_index - Index of selection box in children vec

Fields

id: Id

rect: Rectangle

children: Vec<Box<dyn View>>

enabled: bool

event: Event

left_label_index: usize

right_label_index: usize

selection_box_index: usize

left_text_width: i32

right_text_width: i32

Implementations

impl Toggle

pub fn new( rect: Rectangle, text_enabled: &str, text_disabled: &str, enabled: bool, event: Event, fonts: &mut Fonts, align: Align, ) -> Toggle

Creates a new Toggle component.

Arguments

• rect - The rectangular bounds for the toggle
• text_enabled - Text for the first option (shown with border when enabled=true)
• text_disabled - Text for the second option (shown with border when enabled=false)
• enabled - Initial state (true = first option selected)
• event - Event to emit when toggled
• align - Alignment to apply to the right label

Returns

A new Toggle instance with two labels separated by a vertical line, right-aligned

fn request_rerender(&mut self, rq: &mut RenderQueue)

fn update_selection_box(&mut self, rq: &mut RenderQueue)

Trait Implementations

impl View for Toggle

fn handle_event( &mut self, evt: &Event, _hub: &Hub, bus: &mut Bus, rq: &mut RenderQueue, _context: &mut Context, ) -> bool

fn render( &self, _fb: &mut dyn Framebuffer, _rect: Rectangle, _fonts: &mut Fonts, )

fn rect(&self) -> &Rectangle

fn rect_mut(&mut self) -> &mut Rectangle

fn children(&self) -> &Vec<Box<dyn View>>

fn children_mut(&mut self) -> &mut Vec<Box<dyn View>>

fn id(&self) -> Id

fn render_rect(&self, _rect: &Rectangle) -> Rectangle

fn resize( &mut self, rect: Rectangle, _hub: &Hub, _rq: &mut RenderQueue, _context: &mut Context, )

fn child(&self, index: usize) -> &dyn View

fn child_mut(&mut self, index: usize) -> &mut dyn View

fn len(&self) -> usize

fn might_skip(&self, _evt: &Event) -> bool

fn might_rotate(&self) -> bool

fn is_background(&self) -> bool

fn view_id(&self) -> Option<ViewId>