kr580 2.0.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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use super::super::{PrinterPropertiesDialog, PrinterPropertyDropdown};
use crate::app::{DesktopApp, Message};
use iced::Task;
use k580_ui::devices::printer::PrinterPropertyChange;

impl DesktopApp {
    pub(super) fn toggle_property_dropdown(&mut self, dropdown: PrinterPropertyDropdown) {
        let selected = self
            .properties()
            .and_then(|properties| selected_index(properties, &dropdown));
        let Some(properties) = self.properties_mut() else {
            return;
        };
        if properties.open_dropdown.as_ref() == Some(&dropdown) {
            properties.open_dropdown = None;
            properties.dropdown_highlight = None;
            return;
        }
        properties.open_dropdown = Some(dropdown);
        properties.dropdown_highlight = selected;
    }

    pub(super) fn move_property_dropdown_highlight(&mut self, direction: i32) {
        let Some(properties) = self.properties_mut() else {
            return;
        };
        let Some(dropdown) = properties.open_dropdown.clone() else {
            return;
        };
        let count = option_count(properties, &dropdown);
        if count == 0 {
            return;
        }
        let current = properties
            .dropdown_highlight
            .or_else(|| selected_index(properties, &dropdown))
            .unwrap_or(0) as i32;
        properties.dropdown_highlight =
            Some((current - direction).clamp(0, count as i32 - 1) as usize);
    }

    pub(super) fn activate_property_dropdown(&self) -> Task<Message> {
        self.properties()
            .and_then(highlighted_message)
            .map_or_else(Task::none, Task::done)
    }
}

fn option_count(properties: &PrinterPropertiesDialog, dropdown: &PrinterPropertyDropdown) -> usize {
    match dropdown {
        PrinterPropertyDropdown::Feature(name) => properties
            .sheet
            .as_ref()
            .and_then(|sheet| sheet.features.iter().find(|feature| feature.name == *name))
            .map_or(0, |feature| feature.options.len()),
        PrinterPropertyDropdown::Paper => properties
            .sheet
            .as_ref()
            .map_or(0, |sheet| sheet.configuration.papers.len()),
        PrinterPropertyDropdown::Source => properties
            .sheet
            .as_ref()
            .map_or(0, |sheet| sheet.configuration.sources.len()),
        PrinterPropertyDropdown::Preset => properties.presets.len(),
    }
}

fn selected_index(
    properties: &PrinterPropertiesDialog,
    dropdown: &PrinterPropertyDropdown,
) -> Option<usize> {
    match dropdown {
        PrinterPropertyDropdown::Feature(name) => {
            let feature = properties
                .sheet
                .as_ref()?
                .features
                .iter()
                .find(|feature| feature.name == *name)?;
            let selected = feature.selected_option.as_deref()?;
            feature
                .options
                .iter()
                .position(|option| option.name == selected)
        }
        PrinterPropertyDropdown::Paper => {
            let configuration = &properties.sheet.as_ref()?.configuration;
            let selected = configuration.settings.paper_id?;
            configuration
                .papers
                .iter()
                .position(|paper| paper.id == selected)
        }
        PrinterPropertyDropdown::Source => {
            let configuration = &properties.sheet.as_ref()?.configuration;
            let selected = configuration.settings.source_id?;
            configuration
                .sources
                .iter()
                .position(|source| source.id == selected)
        }
        PrinterPropertyDropdown::Preset => {
            let selected = properties.selected_preset.as_deref()?;
            properties
                .presets
                .iter()
                .position(|preset| preset.name == selected)
        }
    }
}

fn highlighted_message(properties: &PrinterPropertiesDialog) -> Option<Message> {
    let dropdown = properties.open_dropdown.as_ref()?;
    let index = properties
        .dropdown_highlight
        .or_else(|| selected_index(properties, dropdown))?;
    match dropdown {
        PrinterPropertyDropdown::Feature(name) => {
            let feature = properties
                .sheet
                .as_ref()?
                .features
                .iter()
                .find(|feature| feature.name == *name)?;
            let option = feature.options.get(index)?;
            Some(Message::PrinterPropertyFeatureSelected(
                PrinterPropertyChange::Feature {
                    feature_name: feature.name.clone(),
                    option_name: option.name.clone(),
                },
            ))
        }
        PrinterPropertyDropdown::Paper => properties
            .sheet
            .as_ref()?
            .configuration
            .papers
            .get(index)
            .map(|paper| Message::PrinterPropertyPaperSelected(paper.id)),
        PrinterPropertyDropdown::Source => properties
            .sheet
            .as_ref()?
            .configuration
            .sources
            .get(index)
            .map(|source| Message::PrinterPropertySourceSelected(source.id)),
        PrinterPropertyDropdown::Preset => properties
            .presets
            .get(index)
            .map(|preset| Message::PrinterPropertyPresetSelected(preset.name.clone())),
    }
}