---
title: Fenêtres
type: docs
weight: 3
---

Les fenêtres sont des panneaux UI pour afficher et gérer les conteneurs d'inventaire, les interfaces de crafting et autres interactions basées sur les objets.

**Package:** `com.hypixel.hytale.server.core.entity.entities.player.windows`

## Types de Fenêtres

| Type | Description |
|------|-------------|
| `WindowType.Container` | Vue standard inventaire/conteneur |
| `WindowType.PocketCrafting` | Petite grille de crafting (2x2) |
| `WindowType.BasicCrafting` | Table de crafting basique (3x3) |
| `WindowType.DiagramCrafting` | Crafting basé sur des diagrammes |
| `WindowType.StructuralCrafting` | Crafting structurel/construction |
| `WindowType.Processing` | Interface de traitement/fonte |
| `WindowType.Memories` | Interface de stockage des Mémoires |

## Gestionnaire de Fenêtres

Chaque joueur a un `WindowManager` qui gère les fenêtres ouvertes :

```java
Player player = ...;
WindowManager windowManager = player.getWindowManager();
```

## Classes de Fenêtres

### ContainerWindow

Pour les interfaces de conteneur standard :

```java
import com.hypixel.hytale.server.core.entity.entities.player.windows.ContainerWindow;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;

// Ouvrir une fenêtre de conteneur - prend juste l'ItemContainer
ContainerWindow window = new ContainerWindow(itemContainer);
```

{{< callout type="info" >}}
`ContainerWindow` utilise automatiquement `WindowType.Container`. L'ID de fenêtre est assigné en interne.
{{< /callout >}}

### BlockWindow

`BlockWindow` est une classe abstraite pour les conteneurs liés aux blocs. Elle est typiquement utilisée via les interactions intégrées plutôt qu'instanciée directement.

```java
// BlockWindow est abstraite - utilisée en interne par les interactions de blocs
// Constructeur: BlockWindow(WindowType, x, y, z, rotationIndex, BlockType)
```

### ItemStackContainerWindow

Pour les conteneurs basés sur ItemStack :

```java
import com.hypixel.hytale.server.core.entity.entities.player.windows.ItemStackContainerWindow;
import com.hypixel.hytale.server.core.inventory.container.ItemStackItemContainer;

// Prend un ItemStackItemContainer
ItemStackContainerWindow window = new ItemStackContainerWindow(itemStackItemContainer);
```

## Ouvrir des Fenêtres

Utilisez `PageManager.setPageWithWindows()` ou `openCustomPageWithWindows()` :

```java
Player player = ...;
PageManager pageManager = player.getPageManager();
Ref<EntityStore> ref = player.getReference();
Store<EntityStore> store = ref.getStore();

// Ouvrir une page avec des fenêtres d'inventaire
ContainerWindow chestWindow = new ContainerWindow(chestContainer);

boolean success = pageManager.setPageWithWindows(
    ref, store,
    Page.None,  // ou Page.Bench, Page.Inventory, etc.
    true,       // canCloseThroughInteraction
    chestWindow
);
```

## Avec des Pages Personnalisées

Combiner les fenêtres avec des pages UI personnalisées :

```java
// UI de crafting personnalisée avec fenêtres
CraftingPage craftingPage = new CraftingPage(player.getPlayerRef());
ContainerWindow inputWindow = new ContainerWindow(inputContainer);
ContainerWindow outputWindow = new ContainerWindow(outputContainer);

pageManager.openCustomPageWithWindows(
    ref, store,
    craftingPage,
    inputWindow,
    outputWindow
);
```

## Événements de Fenêtre

Les fenêtres interagissent avec le système d'inventaire. Gérez les changements d'inventaire via les événements et handlers appropriés.

## Exemple Pratique

### UI de Conteneur Coffre

```java
public void openChest(Player player, ItemContainer chestContainer) {
    PageManager pageManager = player.getPageManager();
    Ref<EntityStore> ref = player.getReference();
    Store<EntityStore> store = ref.getStore();

    ContainerWindow window = new ContainerWindow(chestContainer);

    pageManager.setPageWithWindows(
        ref, store,
        Page.Bench,  // Utiliser Page.Bench pour l'UI de conteneur
        true,        // Permettre la fermeture via interaction
        window
    );
}
```

### Ouvrir Plusieurs Fenêtres

```java
public void openCraftingUI(Player player, ItemContainer inputContainer,
                           ItemContainer outputContainer) {
    PageManager pageManager = player.getPageManager();
    Ref<EntityStore> ref = player.getReference();
    Store<EntityStore> store = ref.getStore();

    // Créer plusieurs fenêtres
    ContainerWindow inputWindow = new ContainerWindow(inputContainer);
    ContainerWindow outputWindow = new ContainerWindow(outputContainer);

    pageManager.setPageWithWindows(
        ref, store,
        Page.Bench,
        true,
        inputWindow,
        outputWindow
    );
}
```

{{< callout type="info" >}}
**Note :** `BlockWindow` est abstraite et utilisée en interne par les interactions de blocs. Pour des UI de crafting personnalisées, utilisez `ContainerWindow` avec vos propres conteneurs.
{{< /callout >}}

## Bonnes Pratiques

{{< callout type="info" >}}
**Directives des Fenêtres :**
- Utilisez des IDs de fenêtre uniques pour chaque fenêtre ouverte
- Faites correspondre `WindowType` à l'interface prévue
- Nettoyez les conteneurs quand les fenêtres sont fermées
- Utilisez `canCloseThroughInteraction` de manière appropriée
{{< /callout >}}

{{< callout type="warning" >}}
**Important :** Les fenêtres sont liées à l'état du conteneur. Assurez-vous que les conteneurs persistent pendant toute la durée d'ouverture de la fenêtre.
{{< /callout >}}
