Struct fltk::menu::Choice

pub struct Choice { /* private fields */ }

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

Formats the value using the given formatter.

impl Default for Choice

fn default() -> Self

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) -> Self::IntoIter

Creates an iterator from a value.

impl MenuExt for Choice

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

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: FnMut(&mut Self) + 'static>( &mut self, idx: i32, name: &str, shortcut: Shortcut, flag: MenuFlag, cb: F ) -> i32

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: 'static + Clone + Send + Sync>( &mut self, label: &str, shortcut: Shortcut, flag: MenuFlag, sender: Sender<T>, msg: T ) -> i32

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: 'static + Clone + Send + Sync>( &mut self, idx: i32, label: &str, shortcut: Shortcut, flag: MenuFlag, sender: Sender<T>, msg: T ) -> i32

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

impl PartialEq for Choice

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

This method tests for self and other values to be equal, and is used by ==.

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

This method 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: Into<Option<&'a str>>>( x: i32, y: i32, width: i32, height: i32, title: T ) -> Choice

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

fn default_fill() -> Self

Constructs a widget with the size of its parent

fn delete(wid: Self)

Deletes widgets and their children.

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

transforms a widget pointer to a Widget, for internal use

unsafe fn from_widget<W: WidgetExt>(w: W) -> Self

Get a widget from base widget

fn handle<F: FnMut(&mut Self, Event) -> bool + 'static>(&mut self, cb: F)

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: FnMut(&mut Self) + 'static>(&mut self, cb: F)

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: FnMut(&mut Self, i32, i32, i32, i32) + 'static>( &mut self, cb: F )

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: WidgetExt>(w: &W) -> Option<Self>

Cast a type-erased widget back to its original widget

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

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

impl WidgetExt for Choice

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

Initialize center of another widget

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

Initialize center of another widget

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

Initialize to a position x, y

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

Initialize to size width, height

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

Initialize with a label

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

Initialize with alignment

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

Initialize with type

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

Initialize at bottom of another widget

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

Initialize above of another widget

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

Initialize right of another widget

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

Initialize left of another widget

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

Initialize center of another widget

fn center_of_parent(self) -> Self

Initialize center of parent

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

Initialize to the size of another widget

fn size_of_parent(self) -> Self

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: WidgetExt>(&self, wid: &W) -> bool

Checks whether the self widget is inside another widget

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

Returns the widget type when applicable

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

Sets the widget type

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

Sets the image of the widget

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

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: ImageExt>(&mut self, image: Option<I>)

Sets the deactivated image of the widget

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

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: FnMut(&mut Self) + 'static>(&mut self, cb: F)

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

fn emit<T: 'static + Clone + Send + Sync>(&mut self, sender: Sender<T>, msg: T)

Emits a message on callback using a sender

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

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: WidgetExt>(&self, other: &W) -> bool

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

Available on non-crate feature single-threaded only.

impl Sync for Choice

Available on non-crate feature single-threaded only.