Vaikų langų rūdyje supratimas naudojant WinAPI

Vaikų langų kūrimas rūdyje naudojant WinAPI: praktinis vadovas

Šis scenarijus parodo pataisytą ir optimizuotą metodą, kaip sukurti pagrindinį langą su antriniais valdikliais „Rust“, naudojant „Windows API“. Jame pateikiami išsamūs komentarai, siekiant geresnio supratimo ir moduliškumo.

#![allow(non_snake_case)]
use windows::
    core::*,
    Win32::Foundation::*,
    Win32::Graphics::Gdi::*,
    Win32::System::LibraryLoader::GetModuleHandleA,
    Win32::UI::WindowsAndMessaging::*;

fn main() -> Result<()> {
    unsafe {
        // Load the current instance
        let instance = GetModuleHandleA(None)?;

        // Define the window class
        let window_class = s!("window");
        let wc = WNDCLASSA {
            hCursor: LoadCursorW(None, IDC_ARROW)?,
            hInstance: instance.into(),
            lpszClassName: window_class,
            style: CS_HREDRAW | CS_VREDRAW,
            lpfnWndProc: Some(wndproc),
            ..Default::default()
        };

        // Register the window class
        let atom = RegisterClassA(&wc);
        debug_assert!(atom != 0);

        // Create the main parent window
        let _hwnd = CreateWindowExA(
            WINDOW_EX_STYLE::default(),
            window_class,
            s!("Rust WinAPI Form"),
            WS_OVERLAPPEDWINDOW | WS_VISIBLE,
            CW_USEDEFAULT,
            CW_USEDEFAULT,
            500,
            400,
            None,
            None,
            instance,
            None,
        )?;

        // Add child controls with proper styles
        CreateWindowExA(
            WINDOW_EX_STYLE::default(),
            s!("static"),
            s!("Enter your name:"),
            WS_CHILD | WS_VISIBLE,
            20,
            50,
            150,
            25,
            _hwnd,
            None,
            instance,
            None,
        );

        CreateWindowExA(
            WINDOW_EX_STYLE::default(),
            s!("edit"),
            None,
            WS_CHILD | WS_VISIBLE | WS_BORDER,
            180,
            50,
            200,
            25,
            _hwnd,
            None,
            instance,
            None,
        );

        CreateWindowExA(
            WINDOW_EX_STYLE::default(),
            s!("button"),
            s!("Submit"),
            WS_CHILD | WS_VISIBLE,
            200,
            100,
            100,
            30,
            _hwnd,
            None,
            instance,
            None,
        );

        // Display and update the main window
        ShowWindow(_hwnd, SW_SHOW);
        UpdateWindow(_hwnd);

        // Run the message loop
        let mut message = MSG::default();
        while GetMessageA(&mut message, None, 0, 0).into() {
            DispatchMessageA(&message);
        }
    }
    Ok(())
}

extern "system" fn wndproc(window: HWND, message: u32, wparam: WPARAM, lparam: LPARAM) -> LRESULT {
    unsafe {
        match message {
            WM_PAINT => {
                println!("WM_PAINT triggered");
                ValidateRect(window, None);
                LRESULT(0)
            }
            WM_DESTROY => {
                PostQuitMessage(0);
                LRESULT(0)
            }
            _ => DefWindowProcA(window, message, wparam, lparam),
        }
    }
}

GUI atvaizdavimo rūdyje testavimas naudojant WinAPI

Šis vieneto bandymo scenarijus tikrina, ar tinkamai sukurtas ir matomas pagrindinis langas ir antriniai valdikliai imituotoje aplinkoje.

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_window_creation() {
        unsafe {
            let instance = GetModuleHandleA(None).unwrap();
            let window_class = s!("test_window");
            let wc = WNDCLASSA {
                hCursor: LoadCursorW(None, IDC_ARROW).unwrap(),
                hInstance: instance.into(),
                lpszClassName: window_class,
                ..Default::default()
            };
            let atom = RegisterClassA(&wc);
            assert!(atom != 0);

            let _hwnd = CreateWindowExA(
                WINDOW_EX_STYLE::default(),
                window_class,
                s!("Test Form"),
                WS_OVERLAPPEDWINDOW,
                CW_USEDEFAULT,
                CW_USEDEFAULT,
                400,
                300,
                None,
                None,
                instance,
                None,
            );
            assert!(!_hwnd.is_invalid());
        }
    }
}

Dažnai užduodami klausimai apie WinAPI ir Rust GUI

1. Kodėl mano vaiko langai nerodomi tinkamai?
2. Įsitikinkite, kad pirminis langas yra matomas ir antriniai valdikliai turi WS_VISIBLE pritaikytas stilius. Jei trūksta šio stiliaus, valdikliai dažnai lieka paslėpti.
3. Kaip galiu pakeisti vaikų langų dydį?
4. Atsakykite į WM_SIZE pranešimą WndProc funkciją ir dinamiškai koreguoti antrinio lango pozicijas pagal naujus pirminius matmenis.
5. Kodėl mano mygtuko tekstas nukirptas?
6. Naudokite SendMessageW su WM_SETFONT pritaikyti pasirinktinį šriftą, atitinkantį mygtuko valdiklio dydį.
7. Kaip galiu tvarkyti mygtukų paspaudimų įvykius?
8. Užfiksuoti WM_COMMAND pranešimus WndProc funkciją ir naudokite valdymo ID, kad nustatytumėte, kuris mygtukas buvo spustelėtas.
9. Kokie yra įprasti vaikų valdymo stiliai?
10. Stiliai kaip WS_CHILD, WS_VISIBLE, ir WS_BORDER yra dažniausiai naudojami. Derinkite juos, jei reikia konkrečiam elgesiui.

Paskutinės mintys apie Rust GUI kūrimą

GUI kūrimas naudojant „Windows“ API „Rust“ gali jaustis didžiulis, tačiau taikant struktūrinį metodą tai tampa valdoma. Suprasti, kaip veikia vaikų langai, ir atkreipti dėmesį į tokius stilius kaip WS_VISIBLE užtikrina, kad jūsų valdikliai būtų rodomi tinkamai. Viskas apie smulkių detalių prikalimą! 💡

Įvaldydami tokius metodus kaip atsakymas į WM_COMMAND pranešimus ir dinamiškai keičiant valdiklius, sukuriate profesionalią, reaguojančią programą. Šie įgūdžiai, nors ir techniniai, yra būtini norint pateikti patobulintą programinę įrangą. Eksperimentuokite toliau ir nedvejodami kantriai derinkite – verta pastangų! 🚀