Comprendre les fenêtres enfants dans Rust avec WinAPI

Créer des fenêtres enfants dans Rust avec WinAPI : un guide pratique

Ce script démontre une approche corrigée et optimisée pour créer une fenêtre parent avec des contrôles enfants dans Rust à l'aide de l'API Windows. Il comprend des commentaires détaillés pour une meilleure compréhension et modularité.

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

Test du rendu GUI dans Rust avec WinAPI

Ce script de test unitaire vérifie la création et la visibilité correctes de la fenêtre principale et des contrôles enfants dans un environnement simulé.

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

Foire aux questions sur WinAPI et l'interface graphique Rust

1. Pourquoi mes fenêtres enfants ne s’affichent-elles pas correctement ?
2. Assurez-vous que la fenêtre parent est visible et que les contrôles enfants ont le WS_VISIBLE style appliqué. Si ce style est manquant, les contrôles restent souvent masqués.
3. Comment puis-je gérer le redimensionnement des fenêtres enfants ?
4. Répondre au WM_SIZE message dans le WndProc fonction et ajustez dynamiquement les positions des fenêtres enfants en fonction des nouvelles dimensions parent.
5. Pourquoi le texte de mon bouton est-il tronqué ?
6. Utiliser SendMessageW avec WM_SETFONT pour appliquer une police personnalisée adaptée à la taille de votre contrôle bouton.
7. Comment puis-je gérer les événements de clic sur un bouton ?
8. Capturer WM_COMMAND messages dans le WndProc fonction et utilisez les ID de contrôle pour identifier le bouton sur lequel vous avez cliqué.
9. Quels sont les styles courants pour les contrôles enfants ?
10. Styles comme WS_CHILD, WS_VISIBLE, et WS_BORDER sont couramment utilisés. Combinez-les selon vos besoins pour des comportements spécifiques.

Réflexions finales sur la création d'interfaces graphiques Rust

Développer des interfaces graphiques avec l'API Windows dans Rust peut sembler fastidieux, mais avec une approche structurée, cela devient gérable. Comprendre le fonctionnement des fenêtres enfants et prêter attention aux styles tels que WS_VISIBLE garantit que vos contrôles sont affichés correctement. Il s'agit avant tout de peaufiner les petits détails ! 💡

En maîtrisant des techniques telles que répondre à WM_COMMAND messages et redimensionnement dynamique des contrôles, vous créez une application professionnelle et réactive. Ces compétences, bien que techniques, sont essentielles pour fournir des logiciels performants. Continuez à expérimenter et n'hésitez pas à déboguer patiemment : cela en vaut la peine ! 🚀