kr580 1.1.0

Desktop KR580VM80 / Intel 8080 emulator.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use super::styles::{dropdown_anchor_style, dropdown_option_style, dropdown_panel_style};
use crate::app::Message;
use crate::view::icons;
use crate::view::theme::{tokyo_muted, tokyo_text, ui_text};
use crate::view::widgets::anchored_overlay;
use iced::widget::{Space, button, column, container, row, scrollable, svg};
use iced::{Element, Length, alignment};

const OPTION_HEIGHT: f32 = 32.0;
const MENU_MAX_HEIGHT: f32 = 192.0;
const MENU_GAP: f32 = 6.0;

pub(super) struct DropdownItem {
    pub(super) label: String,
    pub(super) selected: bool,
    pub(super) message: Message,
}

pub(super) struct DropdownControl {
    pub(super) opened: bool,
    pub(super) enabled: bool,
    pub(super) focused: bool,
    pub(super) toggle: Message,
    pub(super) dismiss: Message,
    pub(super) highlighted: Option<usize>,
}

pub(super) fn control(
    label: String,
    items: Vec<DropdownItem>,
    control: DropdownControl,
) -> Element<'static, Message> {
    let chevron = svg(icons::chevron_down())
        .width(Length::Fixed(14.0))
        .height(Length::Fixed(14.0))
        .style(|_theme, _status| svg::Style {
            color: Some(tokyo_muted()),
        });
    let anchor = button(
        container(
            row![
                ui_text(label, 13, tokyo_text()),
                Space::new().width(Length::Fill),
                chevron,
            ]
            .spacing(10)
            .align_y(alignment::Vertical::Center),
        )
        .padding([8, 12])
        .width(Length::Fill),
    )
    .padding(0)
    .width(Length::Fill)
    .on_press_maybe((control.enabled && !items.is_empty()).then_some(control.toggle))
    .style(move |_theme, status| dropdown_anchor_style(status, control.opened, control.focused));

    let item_count = items.len();
    let options = column(
        items
            .into_iter()
            .enumerate()
            .map(|(index, item)| {
                let emphasized = control
                    .highlighted
                    .map_or(item.selected, |value| value == index);
                dropdown_option(item, emphasized)
            })
            .collect::<Vec<_>>(),
    )
    .spacing(0)
    .width(Length::Fill);
    let options = scrollable(options)
        .direction(scrollable::Direction::Vertical(
            scrollable::Scrollbar::hidden(),
        ))
        .height(Length::Fixed(
            (item_count as f32 * OPTION_HEIGHT).min(MENU_MAX_HEIGHT),
        ));
    let panel = container(options)
        .padding(4)
        .width(Length::Fill)
        .style(dropdown_panel_style);

    anchored_overlay(
        anchor,
        panel,
        control.opened && item_count > 0,
        MENU_GAP,
        control.dismiss,
    )
}

fn dropdown_option(item: DropdownItem, emphasized: bool) -> Element<'static, Message> {
    button(
        container(ui_text(item.label, 13, tokyo_text()))
            .padding([6, 10])
            .width(Length::Fill)
            .height(Length::Fixed(OPTION_HEIGHT))
            .align_y(alignment::Vertical::Center),
    )
    .on_press(item.message)
    .padding(0)
    .width(Length::Fill)
    .style(move |_theme, status| dropdown_option_style(status, emphasized))
    .into()
}