⚙️ Guide de Compilation & Arborescence Rust

1. Prérequis : Installer l'environnement Rust

Pour compiler cette application sur votre ordinateur Windows (64 bits), vous devez installer la chaîne d'outils de développement officielle de Rust (Rustup) ainsi que le compilateur C++ de Microsoft (requis pour lier l'exécutable Windows).

1.1 Étape 1 : Installer le compilateur C++ de Microsoft (MSVC)

Rust a besoin de l'outil de liaison (Linker) officiel de Windows pour générer un fichier .exe.

1. Allez sur le site officiel de Visual Studio de Microsoft.
2. Téléchargez et lancez le Visual Studio Installer (gratuit).
3. Dans l'installateur, sous l'onglet "Charges de travail", cochez impérativement :
   ☑ Développement Desktop en C++ (Desktop development with C++).
4. Cliquez sur "Installer" en bas à droite et attendez la fin de l'installation.

1.2 Étape 2 : Installer la chaîne d'outils Rust

1. Allez sur le site officiel de Rust : https://rustup.rs/.
2. Téléchargez l'installateur pour Windows 64 bits : rustup-init.exe.
3. Lancez le fichier. Une console s'ouvre.
4. Tapez 1 (option par défaut : *Proceed with standard installation*) et appuyez sur Entrée.
5. Une fois l'installation terminée, fermez toutes vos fenêtres d'invite de commande (PowerShell ou CMD) pour appliquer les variables d'environnement.

1.3 Étape 3 : Vérifier l'installation

Ouvrez une nouvelle console PowerShell et saisissez la commande suivante :

rustc --version

Si l'installation a réussi, la console affiche la version active de Rust (ex : rustc 1.80.0 (64-bit)).

2. Arborescence du Projet

Pour que le compilateur Rust localise tous vos fichiers de code source et que l'application s'exécute correctement, vous devez structurer votre dossier de projet de la manière suivante :

icom_controller/
├── Cargo.toml                              # Fichier de configuration des dépendances (egui, rodio, etc.)
├── icon.ico                                # Icône graphique de l'application
├── info.txt                                # Mini-Wiki d'aide lu au démarrage
├── memories.db                             # Base de données SQLite (créée automatiquement)
├── samples/                                # Dossier contenant vos fichiers audio MP3 d'appels
└── src/                                    # Dossier du code source
    ├── main.rs                             # Point d'entrée de l'exécutable (windows_subsystem)
    ├── comm.rs                             # Thread de communication série CI-V & Proxy CAT
    ├── database.rs                         # Interfaçage SQLite et importations CSV/EiBi
    └── gui/                                # Dossier de l'interface graphique (IHM)
        ├── mod.rs                          # Déclaration des sous-modules graphiques
        ├── widgets.rs                      # Primitives de dessin 3D (boutons, VU-mètres, faders)
        ├── dialogs.rs                      # Fenêtres modales de réglages, de mémoires et de COM
        ├── app.rs                          # Modèle Ic7300App et persistance SQL
        ├── view.rs                         # Rendu principal de l'IHM et réception asynchrone
        ├── scope.rs                        # Spectre FFT dynamique de Vert à Rouge et cascade
        └── keyer.rs                        # Lanceur d'appels automatiques (automate audio)
            

3. Commandes de Compilation & d'Exécution

Toutes les commandes de compilation se lancent à partir d'un terminal (PowerShell ou CMD) ouvert à la racine du dossier de votre projet (là où se trouve le fichier Cargo.toml).

3.1 Vérifier le code sans compiler (Vérification ultra-rapide)

Si vous souhaitez simplement vous assurer qu'il n'y a pas d'erreur de syntaxe ou de typage dans votre code sans attendre que le compilateur génère les binaires :

cargo check

3.2 Lancer l'application en mode "Debug"

Le mode Debug compile le code très rapidement sans appliquer d'optimisation. Il conserve toutes les informations de débogage et affiche une console DOS noire en arrière-plan pour afficher vos logs et messages d'erreurs en temps réel.

cargo run

Cette commande télécharge automatiquement les dépendances si nécessaire, compile le projet et lance immédiatement l'IHM à l'écran.

3.3 Générer le binaire optimisé pour l'utilisation ("Release")

Lorsque votre contrôleur CAT est finalisé, vous devez générer la version **Release** définitive. Cette commande applique des optimisations de niveau 3 sur le code : les boucles sont déroulées, le code mort est éliminé et la vitesse d'exécution est démultipliée (le spectre et le waterfall deviennent ultra-fluides).

cargo build --release

Le temps de compilation en mode Release est plus long car le compilateur Rust optimise rigoureusement le binaire de sortie.

4. Où trouver l'exécutable et comment l'exécuter

4.1 Emplacements des fichiers générés

Une fois les compilations terminées, Cargo range les fichiers exécutables générés dans le dossier target/ :

• Exécutable de test (Debug) : icom_controller/target/debug/icom_controller.exe
• Exécutable de production (Release) : icom_controller/target/release/icom_controller.exe

4.2 Masquer la console noire DOS en mode Release

Pour éviter qu'une fenêtre de commande noire (invite de commande Windows) ne s'affiche derrière l'interface graphique de votre application en mode Release, assurez-vous que la ligne suivante est bien présente tout au début de votre fichier `src/main.rs` :

#![cfg_dist(not(debug_assertions))]
#![windows_subsystem = "windows"]

Cette directive indique au compilateur Windows de masquer silencieusement la console pour les versions de production.

4.3 Comment distribuer et déployer votre exécutable

Pour exécuter l'application sur un autre ordinateur Windows sans avoir besoin d'installer Rust, vous avez uniquement besoin de copier le dossier contenant les fichiers indispensables de fonctionnement :