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

use iced::{Task, window};

use super::{DesktopApp, Message, TOOL_WINDOWS};
use crate::app::PendingAction;
use crate::platform;

impl DesktopApp {
    pub(super) fn window_opened(&mut self, id: window::Id) -> Task<Message> {
        if self.printer_properties_window_id == Some(id) {
            return self.finish_detached_printer_properties_window_open(id);
        }
        if self.printer_setup_window_id == Some(id) {
            return self.finish_detached_printer_setup_window_open(id);
        }
        if let Some(kind) = self.tool_window_kind(id) {
            let detached = {
                let state = self.tool_window_mut(kind);
                state.ready = true;
                state.detached
            };
            let prepare = window::run(id, platform::set_rounded_corners).discard();
            return if detached {
                prepare.chain(self.show_tool_window(kind, id))
            } else {
                prepare
            };
        }
        if self.main_window_id != Some(id) {
            return Task::none();
        }
        Task::batch([
            window::run(id, |window| platform::cloak_window(window, true)).discard(),
            window::run(id, platform::set_rounded_corners).discard(),
            window::set_mode(id, window::Mode::Windowed),
            window::is_maximized(id).map(Message::WindowMaximizedChanged),
        ])
    }

    pub(super) fn window_closed(&mut self, id: window::Id) -> Task<Message> {
        if self.detached_printer_properties_window_closed(id) {
            return self
                .printer_setup_window_id
                .map_or_else(Task::none, window::gain_focus);
        }
        if self.detached_printer_setup_window_closed(id) {
            return self.close_detached_printer_setup_window();
        }
        if let Some(kind) = self.tool_window_kind(id) {
            *self.tool_window_mut(kind) = Default::default();
            self.reset_tool_window_presentation(kind);
            return Task::none();
        }
        if self.main_window_id != Some(id) {
            return Task::none();
        }
        self.main_window_id = None;
        let close_setup = self.cancel_detached_printer_setup();
        let close_windows = TOOL_WINDOWS.into_iter().filter_map(|kind| {
            self.reset_tool_window_presentation(kind);
            self.tool_window_mut(kind).id.take().map(window::close)
        });
        Task::batch(close_windows)
            .chain(close_setup)
            .chain(iced::exit())
    }

    pub(super) fn window_close_requested(&mut self, id: window::Id) -> Task<Message> {
        if self.printer_properties_window_id == Some(id) {
            return Task::done(Message::ClosePrinterProperties);
        }
        if self.printer_setup_window_id == Some(id) {
            if self.printer_properties_window_id.is_some() {
                return self.request_printer_properties_attention();
            }
            return self.cancel_detached_printer_setup();
        }
        if let Some(kind) = self.tool_window_kind(id) {
            return self.close_tool_window(kind);
        }
        if self.main_window_id != Some(id) {
            return Task::none();
        }
        if self.dirty {
            self.open_discard_modal(PendingAction::CloseWindow);
            Task::none()
        } else {
            window::close(id)
        }
    }

    pub(super) fn frame_rendered(&mut self) -> Task<Message> {
        let sync_drag_cursor = if self.file_drag_hovered {
            self.main_window_id.map_or_else(Task::none, |id| {
                window::run(id, platform::cursor_position_in_window)
                    .map(Message::FileDragCursorPosition)
            })
        } else {
            Task::none()
        };
        if self.startup_frames_seen < u8::MAX {
            self.startup_frames_seen = self.startup_frames_seen.saturating_add(1);
        }
        if self.startup_frames_seen != 2 {
            return sync_drag_cursor;
        }
        let reveal = self.main_window_id.map_or_else(Task::none, |id| {
            window::run(id, |window| platform::cloak_window(window, false)).discard()
        });
        Task::batch([sync_drag_cursor, reveal])
    }
}