Entendre les finestres infantils a Rust amb WinAPI

Creació de finestres infantils a Rust amb WinAPI: una guia pràctica

Aquest script demostra un enfocament corregit i optimitzat per crear una finestra principal amb controls secundaris a Rust mitjançant l'API de Windows. Inclou comentaris detallats per a una millor comprensió i modularitat.

#![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),
        }
    }
}

Prova de renderització de la GUI a Rust amb WinAPI

Aquest script de prova d'unitat comprova la correcta creació i visibilitat de la finestra principal i dels controls secundaris en un entorn simulat.

#[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());
        }
    }
}

Preguntes freqüents sobre WinAPI i Rust GUI

1. Per què les finestres del meu fill no es mostren correctament?
2. Assegureu-vos que la finestra principal sigui visible i que els controls secundaris tinguin el WS_VISIBLE estil aplicat. Perdre aquest estil sovint fa que els controls romanguin ocults.
3. Com puc gestionar el canvi de mida de les finestres secundàries?
4. Respon a la WM_SIZE missatge al WndProc funcionar i ajustar dinàmicament les posicions de la finestra secundària en funció de les noves dimensions del pare.
5. Per què es retalla el text del meu botó?
6. Ús SendMessageW amb WM_SETFONT per aplicar un tipus de lletra personalitzat que s'ajusti a la mida del control del botó.
7. Com puc gestionar els esdeveniments de clic de botons?
8. Captura WM_COMMAND missatges al WndProc funció i utilitzeu els ID de control per identificar quin botó s'ha fet clic.
9. Quins són els estils habituals dels controls infantils?
10. Estils com WS_CHILD, WS_VISIBLE, i WS_BORDER s'utilitzen habitualment. Combineu-los segons sigui necessari per a comportaments específics.

Consideracions finals sobre l'elaboració de GUI Rust

El desenvolupament de GUI amb l'API de Windows a Rust pot resultar aclaparador, però amb un enfocament estructurat, es fa manejable. Entendre com funcionen les finestres infantils i prestar atenció a estils com ara WS_VISIBLE garanteix que els vostres controls es mostrin correctament. Es tracta de clavar els petits detalls! 💡

Dominant tècniques com respondre a WM_COMMAND missatges i controls de redimensionament dinàmics, creeu una aplicació professional i sensible. Aquestes habilitats, tot i que són tècniques, són essencials per oferir un programari polit. Continueu experimentant i no dubteu a depurar pacientment: val la pena l'esforç! 🚀