Struct Choice

pub struct Choice { /* private fields */ }

Available on crate feature dep_fltk only.

Creates a menu choice

The set_frame method styles the dropdown menu. Choice does not expose it’s uderlying widget (a DownBox). It can only be changed via the app scheme or by globally changin the draw function of DownBox:

use fltk::{enums::*, prelude::*, *};

fn my_down_box(x: i32, y: i32, w: i32, h: i32, col: Color) {
   draw::draw_rect_fill(x, y, w, h, Color::Red);
   draw::draw_rect_fill(x + 1, y + 1, w - 2, h - 2, Color::BackGround2); // change values to change thickness
}

fn main() {
    let a = app::App::default();
    app::set_frame_type_cb(FrameType::DownBox, my_down_box, 0, 0, 0, 0);
    let mut win = window::Window::new(100, 100, 400, 300, None);
    win.set_color(Color::from_rgb(211, 211, 211));
    let mut inp = input::Input::new(50, 10, 100, 30, None); // would work for any widget which has a DownBox frame type
    let mut choice = menu::Choice::new(50, 100, 100, 30, None);
    choice.add_choice("Choice 1| Choice 2| choice 3");
    win.end();
    win.show();
    a.run().unwrap();
}

For more extensive options see the custom_choice example.

Trait Implementations

impl Clone for Choice

fn clone(&self) -> Choice

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Choice

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for Choice

fn default() -> Choice

Returns the “default value” for a type.

impl IntoIterator for Choice

type Item = MenuItem

The type of the elements being iterated over.

type IntoIter = IntoIter<<Choice as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Choice as IntoIterator>::IntoIter

Creates an iterator from a value.

impl MenuExt for Choice

fn add<F>( &mut self, name: &str, shortcut: Shortcut, flag: MenuFlag, cb: F, ) -> i32

where F: FnMut(&mut Choice) + 'static,

Add a menu item along with its callback. The characters “&”, “/”, “\”, and “_” (underscore) are treated as special characters in the label string. The “&” character specifies that the following character is an accelerator and will be underlined. The “\” character is used to escape the next character in the string. Labels starting with the “_” (underscore) character cause a divider to be placed after that menu item. Takes the menu item as a closure argument

fn insert<F>( &mut self, idx: i32, name: &str, shortcut: Shortcut, flag: MenuFlag, cb: F, ) -> i32

where F: FnMut(&mut Choice) + 'static,

Inserts a menu item at an index along with its callback. The characters “&”, “/”, “\”, and “_” (underscore) are treated as special characters in the label string. The “&” character specifies that the following character is an accelerator and will be underlined. The “\” character is used to escape the next character in the string. Labels starting with the “_” (underscore) character cause a divider to be placed after that menu item. Takes the menu item as a closure argument

fn add_emit<T>( &mut self, label: &str, shortcut: Shortcut, flag: MenuFlag, sender: Sender<T>, msg: T, ) -> i32

where T: 'static + Clone + Send + Sync,

Add a menu item along with an emit (sender and message). The characters “&”, “/”, “\”, and “_” (underscore) are treated as special characters in the label string. The “&” character specifies that the following character is an accelerator and will be underlined. The “\” character is used to escape the next character in the string. Labels starting with the “_” (underscore) character cause a divider to be placed after that menu item.

fn insert_emit<T>( &mut self, idx: i32, label: &str, shortcut: Shortcut, flag: MenuFlag, sender: Sender<T>, msg: T, ) -> i32

where T: 'static + Clone + Send + Sync,

Inserts a menu item along with an emit (sender and message). The characters “&”, “/”, “\”, and “_” (underscore) are treated as special characters in the label string. The “&” character specifies that the following character is an accelerator and will be underlined. The “\” character is used to escape the next character in the string. Labels starting with the “_” (underscore) character cause a divider to be placed after that menu item.

fn remove(&mut self, idx: i32)

Remove a menu item by index

fn find_item(&self, name: &str) -> Option<MenuItem>

Get a menu item by name

fn set_item(&mut self, item: &MenuItem) -> bool

Set selected item

fn find_index(&self, label: &str) -> i32

Find an item’s index by its label

fn text_font(&self) -> Font

Return the text font

fn set_text_font(&mut self, c: Font)

Sets the text font

fn text_size(&self) -> i32

Return the text size

fn set_text_size(&mut self, c: i32)

Sets the text size

fn text_color(&self) -> Color

Return the text color

fn set_text_color(&mut self, c: Color)

Sets the text color

fn add_choice(&mut self, text: &str) -> i32

Adds a simple text option to the Choice and MenuButton widgets. The characters “&”, “/”, “\”, “|”, and “_” (underscore) are treated as special characters in the label string. The “&” character specifies that the following character is an accelerator and will be underlined. The “\” character is used to escape the next character in the string. Labels starting with the “_” (underscore) character cause a divider to be placed after that menu item.

fn choice(&self) -> Option<String>

Gets the user choice from the Choice and MenuButton widgets

fn value(&self) -> i32

Get index into menu of the last item chosen, returns -1 if no item was chosen

fn set_value(&mut self, v: i32) -> bool

Set index into menu of the last item chosen,return true if the new value is different than the old one

fn clear(&mut self)

Clears the items in a menu, effectively deleting them.

unsafe fn unsafe_clear(&mut self)

Clears the items in a menu, effectively deleting them, and recursively force-cleans capturing callbacks

fn clear_submenu(&mut self, idx: i32) -> Result<(), FltkError>

Clears a submenu by index

fn size(&self) -> i32

Get the size of the menu widget

fn text(&self, idx: i32) -> Option<String>

Get the text label of the menu item at index idx

fn at(&self, idx: i32) -> Option<MenuItem>

Get the menu item at an index

fn mode(&self, idx: i32) -> MenuFlag

Get the mode of a menu item by index and flag

fn set_mode(&mut self, idx: i32, flag: MenuFlag)

Set the mode of a menu item

fn end(&mut self)

End the menu

fn set_down_frame(&mut self, f: FrameType)

Set the down_box of the widget

fn down_frame(&self) -> FrameType

Get the down frame type of the widget

fn global(&mut self)

Make a menu globally accessible from any window

fn menu(&self) -> Option<MenuItem>

Get the menu element

unsafe fn set_menu(&mut self, item: MenuItem)

Set the menu element

fn item_pathname(&self, item: Option<&MenuItem>) -> Result<String, FltkError>

Get an item’s pathname

fn set_menu_frame(&mut self, f: FrameType)

Set the menu’s popup frame type

fn menu_frame(&self) -> FrameType

Get the menu’s popup frame type

fn mvalue(&self) -> Option<MenuItem>

Get the selected menu item

fn prev_mvalue(&self) -> Option<MenuItem>

Get the previously selected menu item

impl PartialEq for Choice

fn eq(&self, other: &Choice) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl WidgetBase for Choice

fn new<'a, T>(x: i32, y: i32, width: i32, height: i32, title: T) -> Choice

where T: Into<Option<&'a str>>,

Creates a new widget, takes an x, y coordinates, as well as a width and height, plus a title

fn default_fill() -> Choice

Constructs a widget with the size of its parent

fn delete(wid: Choice)

Deletes widgets and their children.

unsafe fn from_widget_ptr(ptr: *mut Fl_Widget) -> Choice

transforms a widget pointer to a Widget, for internal use

unsafe fn from_widget<W>(w: W) -> Choice

where W: WidgetExt,

Get a widget from base widget

fn handle<F>(&mut self, cb: F)

where F: FnMut(&mut Choice, Event) -> bool + 'static,

Set a custom handler, where events are managed manually, akin to Fl_Widget::handle(int). Handled or ignored events should return true, unhandled events should return false. takes the widget as a closure argument. The ability to handle an event might depend on handling other events, as explained here

fn draw<F>(&mut self, cb: F)

where F: FnMut(&mut Choice) + 'static,

Set a custom draw method. takes the widget as a closure argument. macOS requires that WidgetBase::draw actually calls drawing functions

fn resize_callback<F>(&mut self, cb: F)

where F: FnMut(&mut Choice, i32, i32, i32, i32) + 'static,

Perform a callback on resize. Avoid resizing the parent or the same widget to avoid infinite recursion

unsafe fn assume_derived(&mut self)

Makes the widget derived

fn from_dyn_widget<W>(w: &W) -> Option<Choice>

where W: WidgetExt,

Cast a type-erased widget back to its original widget

fn from_dyn_widget_ptr(w: *mut Fl_Widget) -> Option<Choice>

Cast a type-erased widget pointer back to its original widget

impl WidgetExt for Choice

fn center_x<W>(self, w: &W) -> Choice

where W: WidgetExt,

Initialize center of another widget

fn center_y<W>(self, w: &W) -> Choice

where W: WidgetExt,

Initialize center of another widget

fn with_pos(self, x: i32, y: i32) -> Choice

Initialize to a position x, y

fn with_size(self, width: i32, height: i32) -> Choice

Initialize to size width, height

fn with_label(self, title: &str) -> Choice

Initialize with a label

fn with_align(self, align: Align) -> Choice

Initialize with alignment

fn with_type<T>(self, typ: T) -> Choice

where T: WidgetType,

Initialize with type

fn below_of<W>(self, wid: &W, padding: i32) -> Choice

where W: WidgetExt,

Initialize at bottom of another widget

fn above_of<W>(self, wid: &W, padding: i32) -> Choice

where W: WidgetExt,

Initialize above of another widget

fn right_of<W>(self, wid: &W, padding: i32) -> Choice

where W: WidgetExt,

Initialize right of another widget

fn left_of<W>(self, wid: &W, padding: i32) -> Choice

where W: WidgetExt,

Initialize left of another widget

fn center_of<W>(self, w: &W) -> Choice

where W: WidgetExt,

Initialize center of another widget

fn center_of_parent(self) -> Choice

Initialize center of parent

fn size_of<W>(self, w: &W) -> Choice

where W: WidgetExt,

Initialize to the size of another widget

fn size_of_parent(self) -> Choice

Initialize to the size of the parent

fn set_pos(&mut self, x: i32, y: i32)

Set to position x, y

fn set_size(&mut self, width: i32, height: i32)

Set to dimensions width and height

fn set_label(&mut self, title: &str)

Sets the widget’s label. labels support special symbols preceded by an @ sign. and for the associated formatting.

fn redraw(&mut self)

Redraws a widget, necessary for resizing and changing positions

fn show(&mut self)

Shows the widget

fn hide(&mut self)

Hides the widget

fn x(&self) -> i32

Returns the x coordinate of the widget

fn y(&self) -> i32

Returns the y coordinate of the widget

fn width(&self) -> i32

Returns the width of the widget

fn height(&self) -> i32

Returns the height of the widget

fn w(&self) -> i32

Returns the width of the widget

fn h(&self) -> i32

Returns the height of the widget

fn label(&self) -> String

Returns the label of the widget

fn measure_label(&self) -> (i32, i32)

Measures the label’s width and height

fn as_widget_ptr(&self) -> *mut Fl_Widget

transforms a widget to a base Fl_Widget, for internal use

fn activate(&mut self)

Activates the widget

fn deactivate(&mut self)

Deactivates the widget

fn redraw_label(&mut self)

Redraws the label of the widget

fn resize(&mut self, x: i32, y: i32, width: i32, height: i32)

Resizes and/or moves the widget, takes x, y, width and height

fn widget_resize(&mut self, x: i32, y: i32, width: i32, height: i32)

Does a simple resize ignoring class-specific resize functionality

fn tooltip(&self) -> Option<String>

Returns the tooltip text

fn set_tooltip(&mut self, txt: &str)

Sets the tooltip text

fn color(&self) -> Color

Returns the widget color

fn set_color(&mut self, color: Color)

Sets the widget’s color

fn label_color(&self) -> Color

Returns the widget label’s color

fn set_label_color(&mut self, color: Color)

Sets the widget label’s color

fn label_font(&self) -> Font

Returns the widget label’s font

fn set_label_font(&mut self, font: Font)

Sets the widget label’s font

fn label_size(&self) -> i32

Returns the widget label’s size

fn set_label_size(&mut self, sz: i32)

Sets the widget label’s size

fn label_type(&self) -> LabelType

Returns the widget label’s type

fn set_label_type(&mut self, typ: LabelType)

Sets the widget label’s type

fn frame(&self) -> FrameType

Returns the widget’s frame type

fn set_frame(&mut self, typ: FrameType)

Sets the widget’s frame type

fn changed(&self) -> bool

Returns whether the widget was changed

fn set_changed(&mut self)

Mark the widget as changed

fn clear_changed(&mut self)

Clears the changed status of the widget

fn align(&self) -> Align

Returns the alignment of the widget

fn set_align(&mut self, align: Align)

Sets the alignment of the widget

fn set_trigger(&mut self, trigger: CallbackTrigger)

Sets the default callback trigger for a widget, equivalent to when()

fn trigger(&self) -> CallbackTrigger

Return the callback trigger, equivalent to when()

fn parent(&self) -> Option<Group>

Returns the parent of the widget

fn selection_color(&self) -> Color

Gets the selection color of the widget

fn set_selection_color(&mut self, color: Color)

Sets the selection color of the widget

fn do_callback(&mut self)

Runs the already registered callback

fn window(&self) -> Option<Box<dyn WindowExt>>

Returns the direct window holding the widget

fn top_window(&self) -> Option<Box<dyn WindowExt>>

Returns the topmost window holding the widget

fn takes_events(&self) -> bool

Checks whether a widget is capable of taking events

fn take_focus(&mut self) -> Result<(), FltkError>

Make the widget take focus

fn set_visible_focus(&mut self)

Set the widget to have visible focus

fn clear_visible_focus(&mut self)

Clear visible focus

fn visible_focus(&mut self, v: bool)

Set the visible focus using a flag

fn has_visible_focus(&self) -> bool

Return whether the widget has visible focus

fn has_focus(&self) -> bool

Return whether the widget has focus

fn was_deleted(&self) -> bool

Check if a widget was deleted

fn damage(&self) -> bool

Return whether the widget was damaged

fn set_damage(&mut self, flag: bool)

Signal the widget as damaged and it should be redrawn in the next event loop cycle

fn damage_type(&self) -> Damage

Return the damage mask

fn set_damage_type(&mut self, mask: Damage)

Signal the type of damage a widget received

fn set_damage_area(&mut self, mask: Damage, x: i32, y: i32, w: i32, h: i32)

Signal damage for an area inside the widget

fn clear_damage(&mut self)

Clear the damaged flag

fn as_window(&self) -> Option<Box<dyn WindowExt>>

Return the widget as a window if it’s a window

fn as_group(&self) -> Option<Group>

Return the widget as a group widget if it’s a group widget

fn inside<W>(&self, wid: &W) -> bool

where W: WidgetExt,

Checks whether the self widget is inside another widget

fn get_type<T>(&self) -> T

where T: WidgetType,

Returns the widget type when applicable

fn set_type<T>(&mut self, typ: T)

where T: WidgetType,

Sets the widget type

fn set_image<I>(&mut self, image: Option<I>)

where I: ImageExt,

Sets the image of the widget

fn set_image_scaled<I>(&mut self, image: Option<I>)

where I: ImageExt,

Sets the image of the widget scaled to the widget’s size

fn image(&self) -> Option<Box<dyn ImageExt>>

Gets the image associated with the widget

unsafe fn image_mut(&self) -> Option<&mut Image>

Get a reference type of the widget’s image

fn set_deimage<I>(&mut self, image: Option<I>)

where I: ImageExt,

Sets the deactivated image of the widget

fn set_deimage_scaled<I>(&mut self, image: Option<I>)

where I: ImageExt,

Sets the deactivated image of the widget scaled to the widget’s size

fn deimage(&self) -> Option<Box<dyn ImageExt>>

Gets the deactivated image associated with the widget

unsafe fn deimage_mut(&self) -> Option<&mut Image>

Get a reference type of the widget’s deactivated image

fn set_callback<F>(&mut self, cb: F)

where F: FnMut(&mut Choice) + 'static,

Sets the callback when the widget is triggered (clicks for example) takes the widget as a closure argument

fn emit<T>(&mut self, sender: Sender<T>, msg: T)

where T: 'static + Clone + Send + Sync,

Emits a message on callback using a sender

unsafe fn into_widget<W>(&self) -> W

where W: WidgetBase,

Upcast a WidgetExt to some widget type

fn visible(&self) -> bool

Returns whether a widget is visible

fn visible_r(&self) -> bool

Returns whether a widget or any of its parents are visible (recursively)

fn is_same<W>(&self, other: &W) -> bool

where W: WidgetExt,

Return whether two widgets object point to the same widget

fn active(&self) -> bool

Returns whether a widget is active

fn active_r(&self) -> bool

Returns whether a widget or any of its parents are active (recursively)

fn handle_event(&mut self, event: Event) -> bool

Handle a specific event

fn is_derived(&self) -> bool

Check whether a widget is derived

fn as_base_widget(&self) -> Widget

where Self: Sized,

Upcast a WidgetExt to a Widget

impl Eq for Choice

impl Send for Choice

impl Sync for Choice