winr 0.0.1

A cross-platform windowing framework.
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

// Copyright (c) 2026 Jacob Green
// SPDX-License-Identifier: MIT OR Apache-2.0

// Application Builder

use crate::*;

use crate::application::*;

use crate::platform::windows::*;
use crate::platform::*;

pub struct Win32ApplicationBuilder<C: ApplicationCallbacks = ()> {
    callbacks: C,
}

impl<C: ApplicationCallbacks> PlatformApplicationBuilder<C> for Win32ApplicationBuilder<C> {
    type Application = Win32Application<C>;

    fn new(callbacks: C) -> Self {
        Self { callbacks }
    }

    fn with_callbacks<D: ApplicationCallbacks>(self, callbacks: D) -> Win32ApplicationBuilder<D> {
        Win32ApplicationBuilder { callbacks }
    }

    fn build(self) -> WingmanResult<Self::Application> {
        Ok(Self::Application {
            callbacks: self.callbacks,
        })
    }
}

// Application

pub struct Win32Application<C: ApplicationCallbacks> {
    callbacks: C,
}

impl<C: ApplicationCallbacks> PlatformApplication<C> for Win32Application<C> {
    type Running = Win32ApplicationRunning<C>;

    fn run(self) -> Result<C::Exit, C::Error> {
        let mut this = crate::application::ApplicationRunning {
            platform: Self::Running {
                callbacks: self.callbacks,
            },
        };

        C::on_startup(&mut this, &EventStartup {})?;

        while this.platform.dispatch_events() {
            C::on_events_handled(&mut this, &EventHandled {})?;
        }

        C::on_shutdown(&mut this, &EventShutdown {})
    }
}

// Application Running

pub struct Win32ApplicationRunning<C: ApplicationCallbacks> {
    callbacks: C,
}

impl<C: ApplicationCallbacks> Win32ApplicationRunning<C> {
    /// Returns `true` if out of events to dispatch, `false` if the quit msg is received.
    fn dispatch_events(&self) -> bool {
        let mut msg = win32::MSG::default();

        while unsafe { win32::PeekMessageW(&mut msg, None, 0, 0, win32::PM_REMOVE) }.as_bool() {
            if msg.message == win32::WM_QUIT {
                return false;
            }
            let _ = unsafe { win32::TranslateMessage(&msg) };
            let _result = unsafe { win32::DispatchMessageW(&msg) };
        }

        true
    }

    /// Returns `true` if an event is in queue, `false` if the wait timed out.
    fn do_wait(&self, millis: u32) -> WingmanResult<bool> {
        match unsafe { win32::MsgWaitForMultipleObjects(None, false, millis, win32::QS_ALLINPUT) } {
            win32::WAIT_FAILED => Err(win32::Error::from_thread().into()),
            win32::WAIT_TIMEOUT => Ok(false),
            _ => Ok(true),
        }
    }
}

impl<C: ApplicationCallbacks> PlatformApplicationRunning<C> for Win32ApplicationRunning<C> {
    fn shutdown(&mut self) -> WingmanResult<()> {
        unsafe { win32::PostQuitMessage(0) }
        Ok(())
    }

    fn wait_for_events(&mut self) -> WingmanResult<()> {
        unsafe { win32::WaitMessage() }.map_err(Into::into)
    }

    fn wait_for_events_timeout(&mut self, timeout: std::time::Duration) -> WingmanResult<bool> {
        const MAX_WAIT_MS: u32 = u32::MAX - 1;

        let mut millis = timeout.as_millis();
        while millis > MAX_WAIT_MS as u128 {
            if self.do_wait(MAX_WAIT_MS)? {
                return Ok(true);
            }
            millis -= MAX_WAIT_MS as u128;
        }
        self.do_wait(millis as u32)
    }

    fn callbacks(&self) -> &C {
        &self.callbacks
    }

    fn callbacks_mut(&mut self) -> &mut C {
        &mut self.callbacks
    }
}