# Chapitre 3 : Architecture du système

GrimOS est conçu pour être aussi lisible qu'un livre ouvert. Son architecture repose sur une séparation stricte entre le noyau (la boucle principale et le bureau), le gestionnaire de fenêtres, et les applications tierces.

L'ensemble du système d'exploitation est structuré dans un dossier unique (`grimos_build`), sans fichiers éparpillés dans le système de fichiers linux.

## 1. Vue d'ensemble de l'architecture

La Fondation de GrimOS est structurée en trois couches principales, emboîtées comme des poupées russes :

1. **La Couche d'Exécution (Le Noyau)**
   * `main.py` : Point d'entrée de l'application. Initialise la fenêtre Tkinter plein écran.
   * `core/desktop.py` : Construit l'environnement visuel (fond d'écran, barre des tâches, horloge).
2. **La Couche de Gestion (Le Chef d'Orchestre)**
   * `core/app_manager.py` : Le moteur qui lance et ferme les applications.
   * `core/window.py` : Génère le "simulacre" de fenêtre (cadre, barre de titre, boutons).
3. **La Couche Applicative (Les Logiciels)**
   * `apps/` : Dossier contenant toutes les applications indépendantes (`editeur`, `terminal`, etc.).
   * `config/applications.json` : Le registre déclarant ces applications pour le menu Démarrer.

L'architecture est construite en 3 couches horizontales :

1.  **La Fondation (Core)** : Gère la boucle graphique Tkinter, le fond d'écran, et la barre des tâches.
2.  **Le Gestionnaire (App Manager & Window)** : Isole chaque application dans une fausse "fenêtre" (puisqu'il n'y a pas de gestionnaire de fenêtres X11 classique).
3.  **Les Applications (Apps)** : Des modules Python indépendants qui se branchent sur le système.

---

## 2. Le Coeur du Système (Dossier `core/`)

Le dossier `core/` contient le "noyau" de GrimOS. Ce sont les fichiers critiques qui maintiennent l'illusion du système d'exploitation. L'approche de GrimOS prend ce concept à rebours : c'est l'interface graphique qui est le cœur du système.

```mermaid
graph TD
    A[Noyau Linux / Shell] -->|Bypass| B[Python / Tkinter main.py]
    B --> C(Gestionnaire de Fenêtres Virtuel)
    B --> D(Services Intégrés)
    D --> E[wpa_cli Wi-Fi]
    D --> F[lsblk USB Mount]
    C --> G[Applications Python apps/]
```

Dès le démarrage, le système Unix lance immédiatement un gigantesque script Python (`main.py`). (À la racine)
C'est l'étincelle qui allume le moteur. Ce fichier initialise Tkinter (`root = tk.Tk()`), force l'affichage en plein écran sans bordures, et appelle le `Desktop`. Il ne contient aucune logique métier.

### `core/desktop.py` (Le Bureau)
C'est le chef d'orchestre visuel.

*   **Rôle** : Il dessine l'environnement (le fond d'écran), crée la barre des tâches en bas de l'écran, gère le bouton "Démarrer", et affiche l'heure ainsi que les widgets système (CPU, RAM).
*   **Fonctionnement** : Il charge le fichier `applications.json` pour construire dynamiquement le menu Démarrer.

### `core/window.py` (Le Simulacre de Fenêtre)
C'est le secret technique de GrimOS.

*   **Rôle** : Étant donné que GrimOS s'exécute sur un serveur X11 "nu" (sans environnement de bureau comme GNOME ou XFCE), **les fenêtres n'existent pas naturellement**.
*   **Fonctionnement** : Ce fichier crée un composant (`Frame`) qui ressemble à une fenêtre (avec une barre de titre bleue, un bouton croix rouge pour fermer, et des bordures). Il gère mathématiquement la logique de "cliquer-glisser" pour permettre à l'utilisateur de déplacer ces fausses fenêtres sur l'écran.

### `core/app_manager.py` (Le Chargeur d'Applications)

*   **Rôle** : C'est lui qui fait le lien entre le Bureau et les Applications.
*   **Fonctionnement** : Quand l'utilisateur clique sur une icône, l'`AppManager` va importer dynamiquement le module Python demandé (par exemple `apps.editeur.app`), instancier un conteneur `Window`, et injecter cette fenêtre dans le module de l'application via la fonction `start(window)`.

### `core/theme.py`, `wifi.py`, `audio.py`
Ces modules sont des assistants (helpers) :

*   `theme.py` : Fournit les codes couleurs et les polices (style "Classic 98" ou "Modern Dark").
*   `wifi.py` & `audio.py` : Sont des ponts (wrappers) qui envoient des commandes silencieuses au système Debian sous-jacent (comme `nmcli` pour le réseau ou `amixer` pour le son) et renvoient le résultat à l'interface Python.

---

## 3. Les Applications (Dossier `apps/`)

Dans GrimOS, une application n'est pas un fichier exécutable binaire (`.exe` ou fichier ELF). C'est un simple dossier contenant un fichier `app.py`.

### Structure d'une application
Si vous explorez `apps/editeur/` ou `apps/explorateur/`, vous y trouverez toujours la même architecture minimale :

*   `app.py` : Le fichier principal.
*   *(optionnel)* Des sous-fichiers Python ou des ressources locales.

### La fonction magique : `start(window)`
Toutes les applications GrimOS obéissent à un "contrat" (une interface). Le fichier `app.py` **doit** contenir une fonction nommée `start` qui prend au moins un argument :
```python
def start(window, app_manager=None, **kwargs):
    # La magie opère ici
```
L'argument `window` n'est pas la fenêtre principale de l'ordinateur, mais le "panneau intérieur" de la fausse fenêtre générée par `window.py`. L'application n'a plus qu'à dessiner ses boutons et ses textes à l'intérieur de ce panneau, sans jamais se soucier de savoir comment elle peut être déplacée ou fermée.

---

## 4. La Configuration (Dossier `config/`)

Pour rester facilement modifiable, GrimOS extrait sa configuration du code source.

### `applications.json`
C'est le registre du système. Il contient une liste de toutes les applications installées sous forme de tableau JSON. 
Pour installer une nouvelle application, il suffit de copier son dossier dans `apps/`, puis d'ajouter quelques lignes dans `applications.json` :
```json
{
  "name": "Éditeur de Code",
  "module": "apps.editeur.app",
  "icon": "icons/editeur.png",
  "category": "Développement"
}
```
Au prochain démarrage, l'application apparaîtra automatiquement dans le menu Démarrer sous la bonne catégorie, avec sa propre icône. C'est cette simplicité absolue qui différencie l'architecture de GrimOS de celle des monstres logiciels de notre époque.

---

## 5. Le Terminal TTY Natif : Un choix architectural

L'une des particularités de GrimOS est son traitement du "Terminal" (la ligne de commande administrateur). Plutôt que de s'enfermer dans un terminal virtuel instable à l'intérieur de l'interface graphique, GrimOS joue la carte de l'architecture Unix pure.

Dans le menu Démarrer, le bouton **"Fermer la session"** ne fait pas qu'éteindre l'ordinateur. Il met fin au processus Python (`main.py`) et tue le serveur graphique X11.

L'écran noir redescend alors brutalement, révélant le véritable terminal maître de Debian (le TTY). Dans ce terminal natif, l'utilisateur possède un accès absolu et inébranlable (`sudo`) pour mettre à jour son système ou installer des paquets complexes (sans aucun bug d'affichage).

Une fois son administration système terminée, il lui suffit de taper `startx` pour relancer instantanément la machine dans le monde coloré et fenêtré de GrimOS, ou de taper `exit` pour déclencher une reconnexion automatique.
