winctx 0.0.20

A minimal window context for Rust on Windows.
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

use std::char::decode_utf16;
use std::char::DecodeUtf16Error;
use std::ffi::{OsStr, OsString};

use crate::windows::{OsStrExt, OsStringExt};
use crate::Result;

/// Copy a wide string from a source to a destination, truncating if necessary.
pub(crate) fn copy_wstring_lossy(dest: &mut [u16], source: &str) {
    let mut n = 0;

    for c in source.encode_utf16().take(dest.len()) {
        dest[n] = c;
        n += 1;
    }

    if dest.len() > n {
        dest[n] = 0;
    } else {
        dest[n - 1] = 0;
    }
}

pub(crate) trait ToWide {
    /// Encode into a null-terminated wide string.
    fn to_wide_null(&self) -> Vec<u16>;
}

impl<T> ToWide for T
where
    T: AsRef<OsStr>,
{
    #[inline]
    fn to_wide_null(&self) -> Vec<u16> {
        self.as_ref().encode_wide().chain(Some(0)).collect()
    }
}

pub(crate) trait FromWide
where
    Self: Sized,
{
    fn from_wide(wide: &[u16]) -> Self;
}

impl FromWide for std::ffi::OsString {
    fn from_wide(wide: &[u16]) -> OsString {
        OsStringExt::from_wide(wide)
    }
}

pub(super) fn encode_escaped_os_str(
    out: &mut String,
    input: &OsStr,
) -> Result<(), DecodeUtf16Error> {
    let mut escape = false;

    for c in input.encode_wide() {
        // ' '
        if c == 0x00000020 {
            escape = true;
            break;
        }
    }

    if escape {
        out.push('"');

        for c in decode_utf16(input.encode_wide()) {
            out.push(c?);
        }

        out.push('"');
    } else {
        // No escaping needed.
        for c in decode_utf16(input.encode_wide()) {
            out.push(c?);
        }
    }

    Ok(())
}