win64 0.0.25

Hand-crafted, idiomatic Rust wrappers for Win32
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::{
    MessageLoopQueue,
    Msg,
  },
  crate::{
    Handle,
    get_last_error,
    reset_last_error,
    user::{
      Message,
      PeekMessageFlags,
    },
  },
  std::ops::RangeInclusive,
  windows_result::Error,
  windows_sys::Win32::UI::WindowsAndMessaging::{
    MSG,
    PeekMessageW,
  },
};

pub fn peek_message(
  queue: MessageLoopQueue,
  filter: Option<RangeInclusive<u32>>,
  flags: PeekMessageFlags,
) -> PeekResult {
  let (min, max) = filter.map(RangeInclusive::into_inner).unwrap_or_default();
  let mut msg = MSG::default();
  reset_last_error();
  let result =
    unsafe { PeekMessageW(&mut msg, queue.unwrap_or_default().to_ptr(), min, max, flags.to_raw()) };
  // If a message is available, the return value is nonzero.
  // If no messages are available, the return value is zero.
  match (result, get_last_error()) {
    (0, None) => PeekResult::None,
    (0, Some(error)) => PeekResult::Err(error),
    _ => PeekResult::Msg(Msg::from(msg)),
  }
}

pub enum PeekMessageIterator {
  Iterating { queue: MessageLoopQueue, filter: Option<RangeInclusive<u32>>, flags: PeekMessageFlags },
  Quitting,
}

#[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum PeekResult {
  Msg(Msg),
  #[default]
  None,
  Err(Error),
}

impl PeekResult {
  pub fn ok(self) -> Option<Msg> {
    match self {
      Self::Msg(msg) => Some(msg),
      _ => None,
    }
  }

  pub fn take(&mut self) -> PeekResult {
    std::mem::replace(self, PeekResult::None)
  }
}

pub struct PeekMessageResultIntoIterator {
  pm: PeekResult,
}

impl Iterator for PeekMessageResultIntoIterator {
  type Item = Msg;

  fn next(&mut self) -> Option<Self::Item> {
    self.pm.take().ok()
  }
}

impl IntoIterator for PeekResult {
  type IntoIter = PeekMessageResultIntoIterator;
  type Item = Msg;

  fn into_iter(self) -> Self::IntoIter {
    PeekMessageResultIntoIterator { pm: self }
  }
}

impl Iterator for PeekMessageIterator {
  type Item = PeekResult;

  fn next(&mut self) -> Option<Self::Item> {
    match self {
      PeekMessageIterator::Iterating { queue, filter, flags } => {
        let message = peek_message(*queue, filter.clone(), *flags);

        if let PeekResult::Msg(Msg { message: Message::Quit(_), .. }) = message {
          *self = PeekMessageIterator::Quitting;
        }

        Some(message)
      },
      PeekMessageIterator::Quitting => None,
    }
  }
}