Struct ComboBox 

pub struct ComboBox { /* private fields */ }

A field showing one choice, with a drop-down list of the alternatives.

Implementations

impl ComboBox

pub fn new(bounds: Rect, id: u16) -> Self

Create an empty combo box registered under id.

The id identifies this control to the drop-down popup and must be unique among the combo boxes alive at the same time. Reusing a live id replaces the earlier registration, which leaves the earlier control unable to open its list.

pub fn with_items(bounds: Rect, id: u16, items: Vec<String>) -> Self

Create a combo box already holding items, with the first selected.

pub fn id(&self) -> u16

Registration id, as passed to ComboBox::new.

pub fn state(&self) -> Rc<RefCell<ComboState>>

Shared state, for callers that want to read the choice later without holding on to the control.

pub fn set_items(&mut self, items: Vec<String>)

Replace the item list. Selects the first item when there was no previous choice, and clamps an existing choice to the new list.

pub fn add_item(&mut self, item: impl Into<String>)

Append one item.

pub fn item_count(&self) -> usize

Number of items in the list.

pub fn selected(&self) -> Option<usize>

Index of the current choice.

pub fn set_selected(&mut self, index: Option<usize>)

Set the current choice. Out-of-range indices are ignored, so a stale index never silently selects the wrong item.

pub fn selected_text(&self) -> Option<String>

Text of the current choice.

pub fn set_on_change(&mut self, command: CommandId)

Command broadcast when the choice changes. Zero, the default, sends none.

Trait Implementations

impl Drop for ComboBox

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl View for ComboBox

fn core(&self) -> &ViewCore

Base fields shared by every view (Borland: the TView data members).

fn core_mut(&mut self) -> &mut ViewCore

fn set_bounds(&mut self, bounds: Rect)

fn can_focus(&self) -> bool

fn state(&self) -> StateFlags

Get view state flags

fn set_state(&mut self, state: StateFlags)

Set view state flags

fn draw(&mut self, terminal: &mut Terminal)

fn handle_event(&mut self, event: &mut Event)

fn get_palette(&self) -> Option<Palette>

Get this view’s palette for the Borland indirect palette system Matches Borland: TView::getPalette()

fn as_any(&self) -> &dyn Any

Downcast to concrete type (immutable) Allows accessing specific view type methods from trait object

fn as_any_mut(&mut self) -> &mut dyn Any

Downcast to concrete type (mutable) Allows accessing specific view type methods from trait object

fn bounds(&self) -> Rect

The rectangle this view occupies in its owner’s coordinate space (Borland: origin and size). A child at (2, 3) stays at (2, 3) however its owner moves.

fn extent(&self) -> Rect

The view’s own coordinate space, (0, 0) to its size (Borland: TView::getExtent). This is the rectangle draw writes into and the space mouse positions arrive in.

fn set_focus(&mut self, focused: bool)

Set focus state - default implementation uses State::FOCUSED flag Views should override only if they need custom focus behavior

fn window_number(&self) -> Option<u8>

Window number for Alt+1..9 selection (Borland: TWindow::number).

fn is_focused(&self) -> bool

Check if view is focused - reads State::FOCUSED flag

fn options(&self) -> Options

Get view option flags (Options::SELECTABLE, Options::PRE_PROCESS, Options::POST_PROCESS, etc.)

fn set_options(&mut self, options: Options)

Set view option flags

fn grow_mode(&self) -> GrowFlags

Get this view’s grow mode flags (Borland: TView::growMode).

fn set_grow_mode(&mut self, grow_mode: GrowFlags)

Set this view’s grow mode flags (Borland: TView::growMode).

fn set_state_flag(&mut self, flag: StateFlags, enable: bool)

Set or clear specific state flag(s) Matches Borland’s TView::setState(ushort aState, Boolean enable) If enable is true, sets the flag(s), otherwise clears them

fn get_state_flag(&self, flag: StateFlags) -> bool

Check if specific state flag(s) are set Matches Borland’s TView::getState(ushort aState)

fn has_shadow(&self) -> bool

Check if view has shadow enabled

fn shadow_bounds(&self) -> Rect

Get bounds including shadow area

fn update_cursor(&self, _terminal: &mut Terminal)

Update cursor state (called after draw) Views that need to show a cursor when focused should override this

fn zoom(&mut self, _max_bounds: Rect)

Zoom (maximize/restore) the view with given maximum bounds Matches Borland: TWindow::zoom() toggles between current and max size Default implementation does nothing (only windows support zoom)

fn valid(&mut self, _command: CommandId) -> bool

Validate the view before performing a command (usually closing) Matches Borland: TView::valid(ushort command) - returns Boolean Returns true if the view’s state is valid for the given command Used for “Save before closing?” type scenarios and input validation

fn idle(&mut self)

Called periodically while the application is idle, so animations and timers can advance (Borland: TProgram::idle, which keeps running during execView). Overlay widgets added with Application::add_overlay_widget get this on every idle tick; the default does nothing.

fn as_group(&self) -> Option<&dyn GroupLike>

The container interface of this view, if it is one (Borland: dynamic_cast<TGroup*>). Containers built on Group return Some; leaf views keep the default None. Application::exec_view uses it to read a modal view’s end state without knowing its concrete type.

fn as_group_mut(&mut self) -> Option<&mut dyn GroupLike>

fn dump_to_file(&self, terminal: &Terminal, path: &str) -> Result<()>

Dump this view’s region of the terminal buffer to an ANSI file for debugging

fn get_redraw_union(&self) -> Option<Rect>

Get the union rect of previous and current bounds for redrawing Matches Borland: TView::locate() calculates union of old and new bounds Returns None if the view hasn’t moved since last redraw Used by Desktop to implement Borland’s drawUnderRect pattern

fn clear_move_tracking(&mut self)

Clear movement tracking after redrawing Matches Borland: Called after drawUnderRect completes

fn make_global(&self, local_x: i16, local_y: i16) -> (i16, i16)

Convert a point in this view’s space to its owner’s space (Borland: TView::makeGlobal, but one hop: there is no owner chain to walk, and a group translates as it dispatches, so one hop is all a view ever needs).

fn make_local(&self, owner_x: i16, owner_y: i16) -> (i16, i16)

Convert a point in the owner’s space to this view’s space (Borland: TView::makeLocal, one hop; see make_global).

fn draw_shadow(&self, terminal: &mut Terminal)

Draw shadow for this view Draws a shadow offset dynamically based on terminal cell aspect ratio Shadow is semi-transparent - darkens the underlying content by 50% This matches the Borland Turbo Vision behavior more closely

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

Get the linked control ViewId for labels Matches Borland: TLabel::link field Returns Some(ViewId) if this is a label with a linked control, None otherwise Used by Group to implement focus transfer when clicking labels

fn init_after_add(&mut self)

Initialize internal owner pointers after view is added to parent and won’t move This is called by parent’s add() method after the view is in its final position Views that contain other views by value should override this to set up owner chains Default implementation does nothing

fn constrain_to_parent_bounds(&mut self)

Constrain view bounds to parent/owner bounds Used after positioning (e.g., centering) to ensure view stays within valid area Matches Borland: TView::locate() constrains position to owner bounds

fn set_palette_chain(&mut self, node: Option<PaletteChainNode>)

Set the QCell-based palette chain node for this view. Called by parent (Group/Window) during draw to establish the safe owner chain.

fn get_palette_chain(&self) -> Option<&PaletteChainNode>

Get the QCell-based palette chain node for this view. Used by map_color() to safely walk the owner chain.

fn set_owner_extent(&mut self, _extent: Rect)

Tell the view how big its owner is, for drag and resize limits (Borland: TFrame::dragWindow reads owner->owner->getExtent()). Called by Desktop when adding windows.

fn map_color(&self, color_index: u8) -> Attr

Map a logical color index to an actual color attribute Matches Borland: TView::mapColor(uchar index)