fr/en

#

## noDE -- i3wm -- doc

noDE aka no Desktop Environment ...
quelques informations à propos de i3wm.
sources : doc officielle.

## i3wm sur nakeDeb

- raccourcis clavier sur i3wm
- polybar : afficher vos informations système
- conky, i3status & i3blocks : affichages alternatifs des informations système
- reset de la configuration utilisateur
- traduction complète du manuel utilisateur i3wm

nakeDeb vous livre une session pré-configurée de i3 : utilisation de la font forkawesome pour les icônes, raccourcis clavier pour vos applications, affectation des applications aux espaces de travail, nord theme colorscheme, utilisation de polybar pour la barre de status...
tout est consigné dans le fichier de configuration principal de i3 `~/.config/i3/config` entièrement commenté.

### raccourcis clavier sur i3wm

Afin de prendre en main votre session rapidemenet et avant de vous lancer dans la lecture de la documentation, voici les principaux raccourcis clavier utilisés sur la session i3 de nakeDeb (notez que dans les fichiers de configuration, les touches de modification sont identifiées ainsi : Mod1 = Alt, Mod4 = Super) :

raccourcis | action
--- | ---
`Super`+`Enter` | afficher/masquer le scratchpad (terminal flottant)
`Super`+`Shift`+`Enter` | relancer le scratchpad (terminal flottant)
`Alt`+`Enter` | ouvrir un terminal
`Super`+`r` | ouvrir le filer ranger (CLI)
`Super`+`Shift`+`r` | ouvrir le filer pcmanfm (GUI)
`Super`+`e` | ouvrir l'éditeur geany
`Super`+`x` | ouvrir le client IRC weechat
`Super`+`w` | ouvrir le navigateur w3m (CLI)
`Super`+`m` | ouvrir le monitor htop (CLI)
`Super`+`v` | ouvrir le contrôleur de volume alsamixer
`Super`+`z` | ouvrir le lecteur audio mocp (CLI)
`Alt`+`d` | ouvrir le menu rofi en mode 'run'
`Alt`+`p` | ouvrir le menu rofi en mode 'drun'
`Super`+`f` | lancer une recherche
`Super`+`BackSpace` | lancer l'outil de nettoyage (corbeille, cache, aperçus) 'dotcleaner'
`Super`+`Shift`+`f` | lancer le rofi-file-manager
`Super`+`Ctrl`+`w` | lance le nakedwalls pour sélectionner le fond d'écran
`Alt`+`1`/`2`/`3`... | afficher l'espace de travail portant le n° indiqué
`Alt`+`Shift`+`1`/`2`/`3`... | déplacer la fenêtre sur l'espace de travail indiqué
`Alt`+`↑`/`↓`/`←`/`→` | déplacer le focus entre les fenêtres
`Super`+`←`/`→` | navigue entre les espaces de travail utilisés
`Ctrl`+`Alt`+`←`/`→`
`Alt`+`r` | des/activer le mode 'redimensionnement'
`Alt`+`Shift`+`c` | relire le fichier de configuration i3
`Alt`+`Shift`+`r` | relancer i3
`Super`+`l` | verrouiller l'écran
`Alt`+`Shift`+`e` | quitter i3

### polybar : afficher vos informations système

la session i3 utilise polybar par défaut pour afficher les informations système.
polybar est une application qui permet de formater une série de modules afin d'afficher un menu, les espaces de travail, du texte, mais aussi des barres de progression, des pourcentages, des glyphes et le tout en couleur.
la configuration sur nakeDeb est principalement basée sur des glyphes pour un rendu graphique optimal. cepandant, si vous préférez le mode texte, vous pourrez profiter de la configuration alternative préconfigurée, modifier la configuration à votre guise ou utiliser `i3status`, `i3blocks` ou `conky` détaillés au chapitre suivant.

polybar en mode glyphe sur nakeDeb.

polybar en mode texte sur nakeDeb.

la configuration de polybar passe par l'édition de son fichier principal `~/.config/polybar/config` / `~/.config/polybar/configtxt`.
sur nakeDeb, la configuration de polybar est organisée ainsi pour le mode icon (pour le mode texte, la date est reportée sur le module de droite) :

- module de gauche :
  - popmenu géré par rofi activé au clic-gauche
  - indicateurs de session ssh et de connexion ftp
  - icônes des espaces de travail i3 actifs
  - indicateur de resize-mode
  - mini-menu en ligne activé au clic-gauche avec différents lanceurs :
    - terminal (seulement en mode icon)
    - ranger (seulement en mode icon)
    - web browser (seulement en mode icon)
    - pcmanfm (seulement en mode icon)
    - torbrowser (seulement en mode icon)
    - nakedlocate (seulement en mode icon)
    - config polybar
    - restart polybar
    - polybar mode texte/icon
    - nakedhelp
    - nakedquit
  - indicateur de verrouillage capslock/numlock/scrollock
  - titre de la fenêtre active
- module central : heure affichée par défaut, date lors d'un clic-gauche :
- module de droite :
  - charge processeur avec `htop` déclenché au clic-gauche sur l'icône
  - température processeur (à configurer)
  - consommation mémoire avec `htop` déclenché au clic-gauche sur l'icône
  - espace disque principal
  - espace disque secondaire (à configurer)
  - indicateur réseau (à configurer) avec `connman-gtk` déclenché au clic-gauche sur l'icône
  - indicateur de batterie
  - indicateur de luminosité d'écran (à configurer)
  - indicateur de volume
  - indicateur du démon de coloration d'écran redshift (un clic-gauche pour le stopper)
  - indicateur de corbeille avec `dotcleaner` déclenché au clic-droit sur l'icône
  - nakedinfos : neofetch au clic-gauche, htop au clic-droit.
  - zone de notification

pour accéder à la configuration alternative en mode texte, déroulez le menu intégré dans le module de gauche, puis choisissez l'icône en `T`. pour revenir à la configuration en mode icônes, ouvrez à nouveau le menu puis sélectionnez "icon"

tous les modules ne sont pas activés par défaut : il faudra les configurer pour correspondre à votre matériel.

les possibilités de polybar sont multiples... à tel point qu'une page complète de ce wiki lui est consacré.

### conky, i3status & i3blocks

même si polybar est utilisé par défaut pour afficher les informations système, nakeDeb intègre également des pré-configurations pour conky, i3status et i3blocks. les sections correspondantes sont commentées (avec un '#') dans le fichier `~/.config/i3/config`. pour utiliser l'un ou l'autre des outils précités, il suffit de décommenter la section dédiée.

#### conky

conky peut être utilisé pour afficher des informations dans la barre de i3wm, mais il faut pour cela convertir sa sortie au format json utilisé par i3 pour peupler la barre de statut. conky sera lancé en mode console avec l'option `out_to_x = false` : vous ne pourrez donc pas activer les options dédiées à l'affichage graphique.

pour lancer conky, nakeDeb utilise un script `~/.config/i3/i3conkybar` qui va appeler le fichier de configuration conky `~/.config/i3/conkyrc`. c'est ce script qui sera renseigné dans le fichier de configuration de i3wm `~/.config/i3/config` de cette façon :

    bar {
      position top
      status_command $HOME/.config/i3/i3conkybar
      workspace_buttons yes
      binding_mode_indicator yes
      tray_output yes
      font pango:Hack 9
      font pango:forkawesome 9
      colors {
        background #2E3440
        statusline #D8DEE9
        separator  #2E3440
        focused_workspace  #4C566A #5E81AC #D8DEE9
        active_workspace   #4C566A #2E3440 #D8DEE9
        inactive_workspace #2E3440 #2E3440 #888888
        urgent_workspace   #4C566A #BF616A #D8DEE9
        binding_mode       #2E3440 #BF616A #D8DEE9
      }
    }

la barre sera située en haut (top), affichera le résultat de la commande i3conkybar, avec les boutons des espaces de travail, l'indicateur de mode i3wm et la zone de notification. cette section est commentée par défaut sur nakeDeb.

i3bar par conky sur nakeDeb.

le conkyrc associé utilise les options classiques mais il est prévu pour envoyer les informations au format json pour i3bar. les options de conky sont formatées selon un schéma du type : `{ "full_text":"uptime: ${uptime_short}", "color":"\#81a1c1" },`.
voici le conkyrc par défaut pour i3wm sur nakeDeb. notez que certaines options sont commentées afin d'être éditées avant d'être intégrées dans l'affichage final :

    --[[
      i3wm conkyrc arpinux@2020©WTFPL
      use with forkawesome fonts
      nord colors :
        #2e3440 – default dark background
        #3b4252 – black
        #434c5e - black lighter
        #4c566a – bright black
        #d8dee9 – default clear foreground
        #e5e9f0 – white
        #eceff4 – bright white
        #8fbcbb – bright cyan
        #88c0d0 – cyan
        #81a1c1 – blue
        #5e81ac - bright blue
        #bf616a – red
        #d08770 – orange
        #ebcb8b – yellow
        #a3be8c – green
        #b48ead – purple8fbcbb

      extra infos -- exemples
      - notifier un volume externe monté
      { "full_text": "${font forkawesome:size=9}${if_mounted /media/arp/nak3dback} ${fs_used_perc /media/arp/nak3dback}%${endif}" , "color": "\#d8dee9" },
      - cpu 4 cœurs
      { "full_text": "${font forkawesome:size=9}  ${cpu cpu1}% ${cpu cpu2}% ${cpu cpu3}% ${cpu cpu4}%" ,\
       "color": ${if_match ${cpu}>80}"\#bf616a"${else}"\#81a1c1"${endif} },
      - température du processeur
      { "full_text": "${font forkawesome:size=9} ${texeci 5 sensors|grep "Core 2"| awk '{print $3}'|cut -c2-}" ,\
       "color": ${if_match "${texeci 5 sensors|grep "Core 2"|awk '{print $3}'|cut -d"+" -f 2|sed s/.0°C//g}" > "75"}"\#bf616a"${else}"\#81a1c1"${endif} },
      - volume interne en auto-mounting
      { "full_text": "      ${font forkawesome:size=9} ${fs_used_perc /media/arp/Xtra}% ${fs_free /media/arp/Xtra}" , "color": "\#d08770" },
      - activité réseau
      { "full_text": "      ${font forkawesome:size=9}${if_up wlp3s0} ${upspeedf wlp3s0}k/s ${downspeedf wlp3s0}k/s${else}${if_up enp2s0} ${upspeedf enp2s0}k/s ${downspeedf enp2s0}k/s${else}net ${endif}${endif}" , "color": ${if_gw}"\#88c0d0"${else}"\#bf616a"${endif} },
      - gestion de l'alimentation
      { "full_text": "      ${font forkawesome:size=9}${if_match ${battery_percent}<5}${blink   }${else}${if_match "${acpiacadapter}" == "on-line"}  ${battery_percent}%${else} ${battery_percent}% ${battery_time}${endif}${endif}" , "color": ${if_match ${battery_percent}<10}"\#bf616a"${else}"\#ebcb8b"${endif} },

    ]]

    conky.config = {
      out_to_x = false,
      out_to_console = true,
      background = false,
      update_interval = 2.0,
      total_run_times = 0,
      top_name_width = 10,
      use_spacer = 'none',
      double_buffer = yes,
      cpu_avg_samples = 2,
      short_units = true,
      text_buffer_size = 2048,
      if_up_strictness = 'address'
    }

    conky.text = [[
    [
      { "full_text": "${font forkawesome:size=9}  ${cpu}%" , "color": ${if_match ${cpu}>80}"\#bf616a"${else}"\#81a1c1"${endif} },
      { "full_text": ">${loadavg 1}" , "color": "\#81a1c1" },
      { "full_text": "      ${font forkawesome:size=9} ${memperc}% ${mem}" , "color": ${if_match ${memperc} > 50}"\#bf616a"${else}"\#a3be8c"${endif} },
      { "full_text": "      ${font forkawesome:size=9} ${fs_used_perc /}% ${fs_free /}" , "color": "\#d08770" },
      { "full_text": "      ${font forkawesome:size=9}${if_pa_sink_muted} x${else} ${pa_sink_volume}%${endif}" , "color": ${if_pa_sink_muted}"\#bf616a"${else}"\#b48ead"${endif} },
      { "full_text": "      ${font forkawesome:size=9} ${uptime_short}" , "color": "\#81a1c1" },
      { "full_text": "      ${font forkawesome:size=9} ${time %a%d/%m}" , "color": "\#d8dee9" },
      { "full_text": "${font forkawesome:size=9} ${time %I:%M} " , "color": "\#ffffff" }
    ],
    ]];

en dehors du formatage spécifique en json, vous pouvez configurer votre conky comme vous le désirez et comme vous en avez l'habitude. comme toujours, un petit `man conky` pour trouver votre bonheur.

#### i3status

i3status est l'application par défaut prévue pour i3wm. pour l'activer, il faut décommenter la section correspondante dans `~/.config/i3/config` de cette façon :

    bar {
      position top
      status_command i3status
      workspace_buttons yes
      binding_mode_indicator yes
      tray_output yes
      font pango:Hack 9
      font pango:forkawesome 9
      separator_symbol "  "
      colors {
        background #2E3440
        statusline #D8DEE9
        separator  #D8DEE9
        focused_workspace  #4C566A #5E81AC #D8DEE9
        active_workspace   #4C566A #2E3440 #D8DEE9
        inactive_workspace #2E3440 #2E3440 #888888
        urgent_workspace   #4C566A #BF616A #D8DEE9
        binding_mode       #2E3440 #BF616A #D8DEE9
      }
    }

i3status délivre une sortie minimaliste découpée en sections. sa configuration passe par le fichier `~/.config/i3status/config`. ce fichier s'organise autour d'une section générale, l'ordre des sections d'informations à afficher et les sections des informations proprement dites. le manuel est particulièrement bien réalisé avec des exemples, ce qui le rend tout à fait utilisable par un non-anglophone : `man i3status`.

voici le rendu par défaut de i3status sur nakeDeb ainsi que le fichier de configuration associé :

i3bar par i3status sur nakeDeb.

    # i3status configuration file.
    # see "man i3status" for documentation.

    # It is important that this file is edited as UTF-8.
    # The following line should contain a sharp s:
    # ß
    # If the above line is not correctly displayed, fix your editor first!

    general {
            colors = true
            color_good = '#a3be8c'
            color_degraded = '#ebcb8b'
            color_bad = '#bf616a'
            interval = 5
    }

    order += "cpu_usage"
    order += "load"
    order += "disk /"
    #order += "ipv6"
    order += "wireless _first_"
    order += "ethernet _first_"
    order += "battery all"
    order += "volume master"
    order += "tztime local"

    wireless _first_ {
            format_up = " %quality %essid"
            format_down = " down"
    }

    ethernet _first_ {
            # if you use %speed, i3status requires root privileges
            format_up = " %ip"
            format_down = " down"
    }

    battery all {
            format = " %status %percentage"
    }

    tztime local {
            format = " %d/%m  %H:%M "
    }

    cpu_usage {
            format = " %usage"
    }

    load {
            format = " %1min"
    }

    volume master {
            format = " %volume"
            format_muted = " muted"
            device = "default"
            mixer = "Master"
            mixer_idx = 0
    }

    disk "/" {
            format = " %percentage_used [%avail]"
    }

i3status est particulièrement léger si vous n'utilisez pas de scripts externes. il est donc tout à fait adapté aux configurations matérielles ultra-minimales (là où chaque Mo compte.)

#### i3blocks

i3blocks fournit un affichage configurable et cliquable pour i3bar. comme son nom l'indique, il assemble des blocks afin d'afficher les informations système dans la statusbar d'i3. chaque block récupère la sortie d'un script dédié. la cofiguration et les scripts utilisés sont situés dans `~/.config/i3blocks/`.
nakeDeb utilise une série de scripts rassemblés par Anachron et publiés sous licence GPLv3.

i3bar par i3blocks sur nakeDeb.

tous les scripts sont en bash, ce qui rend leur personnalisation simplifiée.
afin de connaître les quelques options de i3blocks, comme d'habitude, `man i3blocks` pour trouver votre bonheur. vous comprendrez vite que la configuration fine passe par l'édition des scripts dédiés.

polybar, conky, i3status ou i3blocks... nakeDeb vous offre le choix pour afficher vos informations système.

## reset de la configuration utilisateur

si vous avez modifié votre configuration et que vous souhaitez revenir à la configuration par défaut de Debian ou celle de nakeDeb, suivez ces méthodes.

revenir à la configuration Debian :
- sauvegardez votre configuration personnelle : `mv $HOME/.config/i3 $HOME/.config/i3.back`
- quittez i3 depuis son raccourci : `Alt`+`Shift`+`e` puis clic sur 'Exit'
- au redémarrage de votre session, i3 vous proposera de créer le fichier de configuration et vous pourrez utiliser une configuration vierge.

revenir à la configuration nakeDeb :
- sauvegardez votre configuration personnelle : `mv $HOME/.config/i3 $HOME/.config/i3.back`
- copiez la configuration nakeDeb par défaut : `cp -R /etc/skel/.config/i3 $HOME/.config/i3`
- nettoyer les fichiers inutiles : `rm $HOME/.config/i3/config-fr $HOME/.config/i3/config-en`
- quittez i3 depuis son raccourci : `Alt`+`Shift`+`e` puis clic sur 'Exit'
- au redémarrage de votre session, i3 sera configuré comme au premier lancement de nakeDeb.

les configurations par défaut sont situées dans `/etc/i3` pour Debian et dans `/etc/skel/.config/i3` pour nakeDeb.

je vous laisse maintenant avec la traduction du guide de l'utilisateur i3wm.

notez que certains raccourcis ou fichiers ont été modifié sur nakeDeb par défaut. par exemple, la disposition par défaut sur nakeDeb est définie sur "tabbed" : lorsque vous ouvrez deux clients, il s'affichent en onglets sur le même écran. pour revenir à la disposition par défaut sur i3 ("split"), utilisez le raccourci `Alt`+`e`.

[début de la traduction > >

## i3 - Guide de l'utilisateur

Ce document contient toutes les informations dont vous avez besoin pour configurer et utiliser le gestionnaire de fenêtres i3. Si ce n'est pas le cas, veuillez d'abord vérifier sur reddit (https://www.reddit.com/r/i3wm/), puis contactez-nous sur IRC (de préférence) ou postez vos questions sur la liste de diffusion.

### Sommaire

- 1. Raccourcis clavier par défaut
- 2. Utiliser i3
  - 2.1. Ouverture de terminaux et déplacement
  - 2.2. Changer la disposition (layout) du "container"
  - 2.3. Passer une fenêtre en plein écran
  - 2.4. Ouvrir d'autres applications
  - 2.5. Fermer les fenêtres
  - 2.6. Utiliser les espaces de travail
  - 2.7. Déplacer les fenêtres sur des espaces de travail
  - 2.8. Redimensionnement
  - 2.9. Relancer i3
  - 2.10. Quitter i3
  - 2.11. Mode flottant
  - 2.12. Déplacement des containers pavés avec la souris
- 3. L'arbre i3
  - 3.1. L'arbre est composé de containers
  - 3.2. Orienter et diviser les Containers
  - 3.3. Passer le focus au container parent
  - 3.4. Containers implicites
- 4. Configurer i3
  - 4.1. Directives externes
  - 4.2. Commentaires
  - 4.3. Polices
  - 4.4. Raccourcis clavier
  - 4.5. Raccourcis souris
  - 4.6. Chaînes de raccourcis
  - 4.7. Le modifier flottant
  - 4.8. Fixer les dimensions des fenêtres flottantes
  - 4.9. Orientation des espaces de travail
  - 4.10. Disposition des nouveaux containers
  - 4.11. Alignement des tritres des fenêtres
  - 4.12. Bordures des fenêtres par défaut
  - 4.13. Masquer les bordures en bord d'écran
  - 4.14. Bordures intelligentes
  - 4.15. Commandes selon les fenêtres (for_window)
  - 4.16. Ne pas donner le focus aux nouvelles fenêtres
  - 4.17. Variables
  - 4.18. X resources
  - 4.19. Placement automatique des fenêtres sur les espaces de travail
  - 4.20. Applications automatiques au lancement d'i3
  - 4.21. Placement automatique des espaces de travail sur les écrans
  - 4.22. Changer les couleurs
  - 4.23. Communication avec i3
  - 4.24. Le focus suit la souris
  - 4.25. Captation de la souris
  - 4.26. Les popups en mode plein écran
  - 4.27. Retour de focus
  - 4.28. Forcer Xinerama
  - 4.29. Aller-retour automatique lors du passage sur un espace de travail
  - 4.30. Retarder la réinitialisation de l'indicateur d'urgence lors d'un changement d'espace de travail
  - 4.31. Captation du Focus lors de l'activation d'une fenêtre
  - 4.32. Afficher les marques sur les décorations des fenêtres
  - 4.33. Continuité des lignes
  - 4.34. Configurer le glisser-déposer des containers pavés
  - 4.35. Marges
- 5. Configurer i3bar
  - 5.1. Commande i3bar
  - 5.2. Commande Statusline
  - 5.3. Mode d'affichage
  - 5.4. Commandes lors d'un clic
  - 5.5. ID de la Bar
  - 5.6. Position
  - 5.7. Écran(s)
  - 5.8. Zone de notification
  - 5.9. Marges de la zone de notification
  - 5.10. Police
  - 5.11. Séparateur personnalisé
  - 5.12. Boutons d'espace de travail
  - 5.13. Largeur minimale des boutons d'espace de travail
  - 5.14. Masquer le nom/numéro de l'espace de travail
  - 5.15. Indicateur de chaine de raccourcis
  - 5.16. Couleurs
  - 5.17. Transparence
  - 5.18. Marges i3bar
- 6. Liste des commandes
  - 6.1. Exécuter des applications (exec)
  - 6.2. diviser les containers
  - 6.3. Manipuler les dispositions (layout)
  - 6.4. Donner le focus aux containers
  - 6.5. Déplacer les containers
  - 6.6. Échanger les containers
  - 6.7. Épingler une fenêtre flottante
  - 6.8. Changer (renommer) un espace de travail / déplacer vers un espace de travail
  - 6.9. Déplacer les espaces de travail sur un écran différent
  - 6.10. Déplacer des containers/espaces de travail vers un écran RandR
  - 6.11. Déplacer des containers/fenêtres vers une marque
  - 6.12. Redimensionner les containers/fenêtres
  - 6.13. Rejoindre une fenêtre spécifique
  - 6.14. Marquer comme VIM (mark/goto)
  - 6.15. Format du titre des fenêtres
  - 6.16. Icône de la barre de titre
  - 6.17. Changer le style de bordure
  - 6.18. Activation de la journalisation
  - 6.19. Activation de la journalisation du débogage
  - 6.20. Recharger/Relancer/Quitter
  - 6.21. Scratchpad
  - 6.22. Nop / Ne rien faire
  - 6.23. Controler i3bar
  - 6.24. Modifier les marges en cours de session
- 7. Multi-écran
  - 7.1. Configurer vos écrans
  - 7.2. Configurations intéressantes en mode multi-écran
- 8. i3 et le reste de vos applications
  - 8.1. Afficher une barre d'état
  - 8.2. Réaliser des présentations (multi-monitor)
  - 8.3. Écran haute définition (aka HIDPI displays)

## 1. Raccourcis clavier par défaut

Pour les adeptes du "c'est trop long, je vais pas lire tout ça", voici un aperçu des raccourcis par défaut (cliquez pour voir l'image en pleine résolution) :

[les rassourcis présentés sont adaptés au clavier qwerty anglais : à adapter à votre disposition clavier]

Les touches à utiliser avec $mod (Alt) :

Les touches à utiliser avec Shift+$mod :

Les touches rouges sont les modificateurs sur lesquels vous devez appuyer (par défaut), les touches bleues sont votre ligne de départ (`homerow`).

Notez que lors du démarrage d'i3 sans fichier de configuration, i3-config-wizard vous proposera de créer un fichier de configuration dans lequel les positions des touches correspondent à ce que vous voyez dans l'image ci-dessus, quelle que soit la disposition du clavier que vous utilisez. Si vous préférez utiliser un fichier de configuration où les lettres clés correspondent à ce que vous voyez ci-dessus, refusez simplement l'offre de i3-config-wizard et basez votre configuration sur `/etc/i3/config`.

## 2. Utiliser i3

Tout au long de ce guide, le mot-clé `$mod` sera utiliser pour désigner la touche de modification par défaut. C'est la touche `Alt` (`Mod1`) par défaut, la touche `Super` (windows `Mod4`) étant une alternative populaire qui permet d'éviter les conflits avec les autres raccourcis des applications.

### 2.1. Ouverture de terminaux et déplacement

Pour commencer avec une opération basique, ouvrons un terminal. Par défaut, vous devez utiliser le raccourcis clavier `$mod+Enter` pour y parvenir, c'est à dire `Alt`+`Enter`. En pressant `$mod+Enter`, une nouvelle fenêtre de terminal s'ouvre. Elle remplira la totalité de votre écran.

Si vous ouvrez maintenant un autre terminal, i3 le placera à côté du terminal actuel, divisant la taille de l'écran en deux. En fonction de votre moniteur, i3 placera la fenêtre créée à côté de la fenêtre existante (sur les écrans larges) ou sous la fenêtre existante (écrans pivotés).

Pour déplacer le focus entre les deux terminaux, vous pouvez utiliser les touches de direction que vous connaissez peut-être dans l'éditeur `vi`. Cependant, dans i3, c'est votre ligne de départ qui est utilisé pour ces touches (dans vi, les touches sont décalées vers la gauche de un pour la compatibilité avec la plupart des dispositions de clavier).
Par conséquent, sur un clavier azerty-fr `$mod+j` déplace le focus à gauche, `$mod+k` en bas, `$mod+l` en haut et `$mod+m` à droite. Donc, pour basculer entre les terminaux, utilisez `$mod+k` ou `$mod+l`. Bien sûr, vous pouvez également utiliser `$mod` + les touches fléchées.

Pour le moment, votre espace de travail est divisé (il contient deux terminaux) dans une direction spécifique (horizontale par défaut). Chaque fenêtre peut à nouveau être divisée horizontalement ou verticalement, tout comme l'espace de travail. La terminologie est "fenêtre" pour un container qui contient en fait une fenêtre X11 (comme un terminal ou un navigateur) et "split container" (container fractionné) pour les "contenairs" qui se composent d'une ou plusieurs fenêtres..

TODO: picture of the tree

Pour diviser une fenêtre verticalement, pressez `$mod+v` avant de créer une nouvelle fenêtre. Pour la diviser horizontalement, pressez `$mod+h`.

### 2.2. Changer la disposition (layout) du "container"

Un container divisé peut adopter plusieurs dispositions :

splith/splitv

  Les fenêtres sont dimensionnées de telle sorte que chaque fenêtre dispose d'une quantité égale d'espace dans le container. `splith` distribue les fenêtres horizontalement (les fenêtres sont à côté les unes des autres), `splitv` les distribue verticalement (les fenêtres sont les unes au-dessus des autres).

stacking

  Seule la fenêtre ayant le focus dans le container est affichée. Une liste des fenêtres s'affiche en haut du container.

tabbed

  Le même principe que `stacking`, mais la liste des fenêtres s'affiche en haut du container sous forme d'onglets.

Pour passer d'un mode à l'autre : pressez `$mod+e` pour les modes 'splith/splitv', `$mod+s` pour le mode 'stacking' et `$mod+t` pour le mode 'tabbed'.

### 2.3. Passer une fenêtre en plein écran

Pour afficher une fenêtre en plein écran (fullscreen) ou pour revenir à l'affichage normal, pressez `$mod+f`.

Il existe aussi un mode "fullscreen global" dans lequel i3 affiche le client sur tous les moniteurs disponibles. (la commande est `fullscreen toggle global`).

### 2.4. Ouvrir d'autres applications

Vous pouvez utiliser votre terminal pour lancer vos applications, mais vous pouvez aussi utiliser le menu `dmenu` qui s'ouvre par défaut grâce au raccourcis `$mod+d`.

[Notez que sur nakeDeb, dmenu est remplacé par rofi]. Entrez le nom d'une application ou seulement quelques lettres. Les applications correspondantes seront listées si elles sont dans votre `$PATH`.

Si vous utilisez certaines applications de manière fréquente, vous pouvez leur attribuer des raccourcis clavier. Voir la section [configuration] pour plus de détails.

### 2.5. Fermer une fenêtre

Si une application ne dispose pas de raccourcis clavier dédié à sa fermeture (la plupart des applications peuvent se fermer depuis leur menu ou depuis les raccourcis `Control+w` ou `Control+q`), vous pouvez presser `$mod+Shift+q` pour tuer une fenêtre. Pour une application qui supporte le protocole WM_DELETE, cela fermera correctement l'application (sauvegarde des modifications et nettoyage du cache). Si l'application ne supporte pas le protocole WM_DELETE, le serveur X tuera l'application. Le comportement dépend de l'application.

### 2.6. Utiliser les espaces de travail

Les espaces de travail sont un moyen simple de regrouper un ensemble de fenêtres. Par défaut, vous êtes sur le premier espace de travail, comme l'indique la barre en bas à gauche. Pour passer à un autre espace de travail, appuyez sur `$mod+num` avec `num` correspondant au numéro de l'espace de travail à atteindre. Si l'espace de travail n'existe pas, il sera créé.

Une organisationn classique est de lancer le navigateur sur le premier espace de travail, puis les applications de communication (`mutt`, `irssi`, …) sur un deuxième et enfin, travailler sur le troisième espace de travail. Mais vous n'êtes pas obligé d'utiliser cette approche.

Si vous disposez de plusieurs écrans, un espace de travail sera créé sur chaque écran au démarrage. Si vous ouvrez un nouvel espace de travail, il sera lié à l'écran sur lequel vous l'avez créé. Lorsque vous passez à un espace de travail sur un autre écran, i3 donne le focus sur cet écran.

### 2.7. Déplacer une fenêtre sur un esace de travail

Pour déplacer une fenêtre sur un espace de travail donné, pressez simplement `$mod+Shift+num` avec `num` correspondant au numéro de l'espace de travail visé. Comme pour le changement d'espace de travail, s'il n'existe pas, il sera créé.

### 2.8. Redimensionnement

Le moyen le plus simple de redimensionner un container est d'utiliser la souris : saisissez la bordure et déplacez-la à la taille souhaitée.

Vous pouvez également utiliser le clavier et les [binding_modes] pour redimensionner un container. Pour un exemple, consultez la configuration par défaut fournit par i3.

### 2.9. Relancer i3

Pour relancer i3 (afin de repartir sur de bonnes bases après avoir résolu un bug ou pour prendre en compte une mise à jour de i3) vous pouvez utiliser le raccourcis `$mod+Shift+r`.

### 2.10. Quitter i3

Pour quitter proprement i3 sans tuer votre serveur X, pressez simplement `$mod+Shift+e`. Par défaut, un message sera affiché afin de confirmer que vous désirez réellement quitter i3.

### 2.11. Mode flottant

Le mode flottant est l'opposé du mode mosaïque (tiling). La position et la taille d'une fenêtre ne sont pas gérées automatiquement par i3, mais manuellement par vous. L'utilisation de ce mode peut être utile pour certains cas particuliers comme les fenêtres de dialogue "Enregistrer sous" ou les fenêtres de barre d'outils (GIMP ou similaire). Ces fenêtres s'identifient généralement de façon appropriée et sont ouvertes en mode flottant par défaut.

Vous pouvez désactiver le mode flottant en pressant `$mod+Shift+Space`. En faisant glisser la barre de titre de la fenêtre avec votre souris, vous pouvez déplacer la fenêtre. En saisissant les bordures et en les déplaçant, vous pouvez redimensionner la fenêtre. Vous pouvez aussi faire tout ça grâce au [floating_modifier]. Une autre façon de redimensionner les fenêtres flottantes à l'aide de la souris consiste à cliquer avec le bouton droit sur la barre de titre et à faire glisser.

Pour redimensionner les fenêtres flottantes avec votre clavier, voir les raccourcis de redimensionnement prévus dans la configuration par défaut de i3.

Les fenêtres flottantes sont toujours affichées par dessus les autres.

### 2.12. Déplacement des containers pavés avec la souris

Depuis i3 4.21, il est possible de faire glisser des containers pavés à l'aide de la souris.
Le glissement peut être lancé soit en faisant glisser la barre de titre de la fenêtre, soit en pressant le [floating_modifier] et en faisant glisser le container tout en maintenant le bouton de clic gauche enfoncé.

Une fois que le déplacement est initié et que le curseur a quitté le container d'origine, des 'indicateurs de dépôt' sont créés en fonction de la position du curseur par rapport au container cible. Ces indicateurs vous aident à comprendre ce que sera la disposition [arborescente] résultante après avoir relâché le bouton de la souris.

Les différentes positions de dépôt sont :

- Déposer sur le container :
  Cela se produit lorsque la souris est relativement proche du centre d'un container. Si la souris est relâchée, le résultat est exactement comme si vous aviez exécuté la commande "déplacer le conteneur vers la marque". Voir [move_to_mark].
- Déposer comme frère :
  Cela se produit lorsque la souris est relativement proche du bord d'un container. Si la souris est relâchée, le container glissé deviendra un frère du container cible, placé à gauche/droite/haut/bas selon la position de l'indicateur.
  Cela peut ou non créer un nouveau v-split ou h-split selon la disposition précédente du container cible. Par exemple, si le conteneur cible est dans un h-split et que vous déposez le conteneur glissé en dessous, la nouvelle disposition devra être un v-split.
- Déposer au parent :
  Cela se produit lorsque la souris est relativement proche du bord d'un container (mais encore plus proche de la bordure par rapport au cas "frère" ci-dessus) et si ce bord est également le bord du container parent. Par exemple, si trois containers sont dans une disposition horizontale, les bords où cela peut se produire sont le bord gauche du container gauche, le bord droit du container droit et tous les bords inférieur et supérieur des trois containers. Si la souris est relâchée, le container est d'abord déposé en tant que frère du container cible, comme dans le cas ci-dessus, puis est déplacé dans la direction comme avec la commande `move left|right|down|up`. Voir [move_direction].

La couleur de l'indicateur correspond au paramètre `client.focused`. Voir [client_colors].

## 3. L'arbre i3

i3 stocke toutes les informations sur les sorties X11, les espaces de travail et la disposition des fenêtres dans un arbre. Le nœud racine est la fenêtre racine X11, suivie des sorties X11, puis des zones d'ancrage et d'un container de contenu, puis des espaces de travail et enfin des fenêtres elles-mêmes. Dans les versions précédentes d'i3, nous avions plusieurs listes (de sorties, d'espaces de travail) et une table pour chaque espace de travail. Cette approche s'est avérée compliquée à utiliser (snapping), à comprendre et à mettre en œuvre.

### 3.1. L'arbre est composé de containers

Les éléments constitutifs de notre arbre sont les `Containers`. Un `Container` peut héberger une fenêtre (c'est-à-dire une fenêtre X11, que vous pouvez réellement voir et utiliser, comme un navigateur). Sinon, il peut contenir un ou plusieurs containers. Un exemple simple est l'espace de travail : lorsque vous démarrez i3 avec un seul moniteur, un seul espace de travail et que vous ouvrez deux fenêtres de terminal, vous vous retrouverez avec une arborescence comme celle-ci :

Figure 1. Deux terminaux sur un espace de travail classique

### 3.2. Orienter et diviser les containers

Il est logique d'utiliser des containers divisés (`Split Containers`) afin de créer une organisation lorsque vous utilisez un arbre comme structure de données. Dans i3, chaque container a une orientation (horizontale, verticale ou non spécifiée) et l'orientation dépend de la disposition dans laquelle se trouve le container (vertical pour splitv et stacking, horizontal pour splith et tabbed). Ainsi, dans notre exemple avec l'espace de travail, la disposition par défaut de l'espace de travail `Container` est splith (la plupart des moniteurs sont à écran large de nos jours). Si vous changez la disposition en splitv (`$mod+v` dans la configuration par défaut) puis ouvrez deux terminaux, i3 configurera vos fenêtres comme ceci :

Figure 2. Orientation verticale de l'espace de travail

Une nouvelle fonctionnalité intéressante d'i3 depuis la version 4 est la possibilité de tout diviser : supposons que vous ayez deux terminaux sur un espace de travail (avec une disposition splith, c'est-à-dire une orientation horizontale), le focus est sur le terminal de droite. Vous souhaitez maintenant ouvrir une autre fenêtre de terminal sous la fenêtre actuelle. Si vous ouvrez simplement une nouvelle fenêtre de terminal, elle apparaîtra à droite en raison de la disposition splith. Au lieu de cela, appuyez sur `$mod+v` pour diviser le container avec la disposition splitv (pour ouvrir un container de fractionnement horizontal, utilisez `$mod+h`). Vous pouvez maintenant ouvrir un nouveau terminal et il s'ouvrira en dessous de l'actuel :

Figure 3. Container divisé verticalement

Vous l'avez probablement déjà deviné : il n'y a pas de limite à la profondeur de votre hiérarchie de divisions.

### 3.3. Passer le focus au container parent

Restons avec notre exemple ci-dessus. Nous avons un terminal à gauche et deux terminaux divisés verticalement à droite, le focus est sur celui en bas à droite. Lorsque vous ouvrez un nouveau terminal, il s'ouvrira sous le terminal actuel.

Comment ouvrir un terminal à droite du terminal courant ? La solution est d'utiliser `le focus au container parent`, qui passera le focus au `Parent Container` du `Container` courant. Dans la configuration par défaut, utilisez le raccourcis `$mod+a` pour remonter le focus dans l'arborescence du `Container` (vous pouvez répéter l'opération jusqu'à atteindre le `Workspace Container`). Dans ce cas, le focus sera donné au `Vertical Split Container` (container divisé verticalement) qui est lui-même à l'intérieur de l'espace de travail orienté horizontalement. Désormais, une nouvelle fenêtre s'ouvrira à droite du container divisé verticalement (`Vertical Split Container`) :

Figure 4. Le focus au parent, puis ouvrir un nouveau terminal

### 3.4. Containers implicites

Dans certains cas, i3 doit créer implicitement un container pour exécuter votre commande.

Un exemple avec le scénario suivant : Vous démarrez i3 avec un seul moniteur et un seul espace de travail sur lequel vous ouvrez trois fenêtres de terminal. Toutes ces fenêtres de terminal sont directement attachées à un nœud dans l’arborescence de disposition d’i3, le nœud de l’espace de travail. Par défaut, l’orientation du nœud de l’espace de travail est `horizontale`.

Maintenant, vous déplacez l'un de ces terminaux vers le bas (`$mod+Shift+k` par défaut). L’orientation du nœud de l’espace de travail devient verticale. La fenêtre de terminal que vous avez déplacée vers le bas est directement attachée à l'espace de travail et apparaît en bas de l'écran. Un nouveau container (horizontal) a été créé pour accueillir les deux autres fenêtres de terminal. Vous le remarquerez lors du passage en mode tabulé (par exemple). Vous finiriez par avoir un onglet avec une représentation du container divisé (par exemple, "H [urxvt firefox]") et l'autre étant la fenêtre de terminal que vous avez déplacée vers le bas.

## 4. Configurer i3

C'est là que l'on commence à s'amuser ;-). La plupart des choses dépendent beaucoup de votre idéal en matière d'environnement de travail, nous ne pouvons donc pas les définir par défaut..

Bien que n'utilisant pas de langage de programmation pour la configuration, i3 reste assez flexible en ce qui concerne les choses que vous voulez généralement que votre gestionnaire de fenêtres fasse.

Par exemple, vous pouvez configurer des raccourcis pour accéder à des fenêtres spécifiques, vous pouvez définir des applications pour qu'elles démarrent sur des espaces de travail spécifiques, vous pouvez démarrer automatiquement des applications, vous pouvez changer les couleurs d'i3 et vous pouvez créer vos raccourcis clavier.

Pour configurer i3, copiez `/etc/i3/config` dans `~/.i3/config` (ou `~/.config/i3/config` si vous préférez le format XDG) puis éditez le avec un éditeur de texte.

Lors du premier démarrage (et lors des autres lancements tant vous n'avez pas de fichier de configuration pour votre utilisateur), i3 vous proposera de créer un fichier de configuration. Vous pouvez spécifier à l'assistant d'utiliser Alt (`Mod1`) ou Windows (`Mod4`) comme touche principale de modification. En outre, l'assistant utilisera la disposition clavier de votre système. Pour lancer l'assistant de configuration, entrez `i3-config-wizard` depuis votre terminal. Notez que si un fichier `~/.i3/config` existe déjà, l'assistant quittera.

Depuis i3 4.0, un nouveau format de configuration est utilisé. i3 essaiera de détecter automatiquement la version de format d'un fichier de configuration en fonction de quelques mots-clés différents, mais si vous voulez vous assurer que votre configuration est lue avec le nouveau format, incluez la ligne suivante dans votre fichier de configuration :

    # i3 config file (v4)

### 4.1. Directives externes

Depuis i3 v4.20, il est possible d'inclure d'autres fichiers de configuration à partir de votre configuration i3.
Syntaxe :

    include pattern

i3 accepte les extensions shell-like selon la fonction wordexp(3) C standard library.
Exemples :

    # Tilde expands to the user’s home directory:
    include ~/.config/i3/assignments.conf

    # Environment variables are expanded:
    include $HOME/.config/i3/assignments.conf

    # Wildcards are expanded:
    include ~/.config/i3/config.d/*.conf

    # Command substitution:
    include ~/.config/i3/`hostname`.conf

    # i3 loads each path only once, so including the i3 config will not result
    # in an endless loop, but in an error:
    include ~/.config/i3/config

    # i3 changes the working directory while parsing a config file
    # so that relative paths are interpreted relative to the directory
    # of the config file that contains the path:
    include assignments.conf

Si un fichier spécifié ne peut pas être lu, par exemple en raison d'un manque d'autorisations de fichier ou d'un lien symbolique, i3 signalera une erreur et continuera à traiter votre configuration restante.
Pour répertorier tous les fichiers de configuration chargés, exécutez `i3 --moreversion` :

    % i3 --moreversion
    Binary i3 version:  4.19.2-87-gfcae64f7+ © 2009 Michael Stapelberg and contributors
    Running i3 version: 4.19.2-87-gfcae64f7+ (pid 963940)
    Loaded i3 config:
      /tmp/i3.cfg (main) (last modified: 2021-05-13T16:42:31 CEST, 463 seconds ago)
      /tmp/included.cfg (included) (last modified: 2021-05-13T16:42:43 CEST, 451 seconds ago)
      /tmp/another.cfg (included) (last modified: 2021-05-13T16:42:46 CEST, 448 seconds ago)

Les variables sont partagées entre tous les fichiers de configuration sous certaines conditions :

- Vous pouvez définir une variable et l'utiliser dans un fichier inclus.
- Vous ne pouvez pas utiliser (dans le fichier parent) une variable qui a été définie dans un fichier inclus.

Il s'agit d'une limitation technique : l'expansion des variables se produit dans une étape distincte avant l'analyse des directives d'inclusion.

Conceptuellement, les fichiers inclus ne peuvent qu'ajouter à la configuration, pas annuler les effets de la configuration déjà traitée. Par exemple, vous pouvez uniquement ajouter de nouvelles combinaisons de touches, et non écraser ou supprimer des combinaisons de touches existantes.
Ça signifie :

- La directive `include` convient à l'organisation de grandes configurations dans des fichiers séparés, en sélectionnant éventuellement des fichiers basés sur des conditions.
- La directive `include` n'est pas adaptée pour exprimer "utiliser la configuration par défaut avec les modifications suivantes". Dans ce cas, nous recommandons toujours de copier et de modifier la configuration par défaut.

### 4.2. Commentaires

Il est possible et recommandé d'utiliser des commentaires dans votre fichier de configuration pour documenter correctement votre configuration pour référence ultérieure. Les commentaires commencent par un `#` et ne peuvent être utilisés qu'au début d'une ligne:

Exemple :

    # Ceci est un commentaire

### 4.3. Polices

i3 supporte les polices X core fonts et FreeType fonts (grâce à Pango) pour afficher les titres des fenêtres.

Pour générer la description d'une police X core font, vous pouvez utiliser `xfontsel(1)`. Pour afficher es caractères spéciaux, vous devez utiliser une police qui supporte l'encodage ISO-10646.

Une description de police FreeType est composée d'une famille de polices, d'un style, d'un poids, d'une variante, d'un étirement et d'une taille. Les polices FreeType prennent en charge le rendu de droite à gauche et contiennent souvent plus de glyphes Unicode que les polices X core.

Si i3 ne peut pas ouvrir la police configurée, il affichera une erreur dans le fichier journal et reviendra à une police fonctionnelle.

Syntaxe :

    font <X core font description>
    font pango:<family list> [<style options>] <size>

Exemples :

    font -misc-fixed-medium-r-normal--13-120-75-75-C-70-iso10646-1
    font pango:DejaVu Sans Mono 10
    font pango:DejaVu Sans Mono, Terminus Bold Semi-Condensed 11
    font pango:Terminus 11px

### 4.4. Raccourcis clavier

Un raccourcis clavier demandera à i3 d'exécuter une commande en pressant certaines touches. i3 vous permet d'utiliser les `keycodes` ou les `keysyms` (vous pouvez même utiliser les deux car i3 ne vous empêche pas d'écraser les raccourcis par défaut).

- Un keysym (symbole de la touche) est une description d'un symbole spécifique, comme "a" ou "b", mais aussi des symboles plus étranges comme "underscore" au lieu de "_". Ce sont ceux que vous utilisez dans Xmodmap pour remapper vos clés. Pour obtenir le mappage actuel de vos clés, utilisez `xmodmap -pke`. Pour afficher en temps réel la touche utilisée, utilisez `xev`.
- Les keycodes (code de la touche) n'ont pas besoin d'avoir un symbole attribué (pratique pour les raccourcis clavier personnalisés sur certains ordinateurs portables) et ils ne changeront pas leur signification lorsque vous passez à une disposition de clavier différente (lors de l'utilisation de `xmodmap`).

Ma recommandation est la suivante : si vous changez souvent de disposition de clavier mais que vous souhaitez conserver vos raccourcis au même emplacement physique sur le clavier, utilisez des codes clavier (keycodes). Si vous ne changez pas de disposition et que vous voulez un fichier de configuration propre et simple, utilisez les mots clés (keysym).

Certains outils (comme `import` ou `xdotool`) pourrait ne pas répondre à la pression d'un touche (KeyPress event), car le clavier/souris est encore en fonction. Pour ces cas de figure, l'option `--release` peut être utilisée afin que la commande soit lancée une fois les touches relachées.

Syntaxe :

    bindsym [--release] [<Group>+][<Modifiers>+]<keysym> command
    bindcode [--release] [<Group>+][<Modifiers>+]<keycode> command

Exemples :

    # Fullscreen
    bindsym $mod+f fullscreen toggle

    # Restart
    bindsym $mod+Shift+r restart

    # Notebook-specific hotkeys
    bindcode 214 exec --no-startup-id /home/michael/toggle_beamer.sh

    # Simulate ctrl+v upon pressing $mod+x
    bindsym --release $mod+x exec --no-startup-id xdotool key --clearmodifiers ctrl+v

    # Take a screenshot upon pressing $mod+x (select an area)
    bindsym --release $mod+x exec --no-startup-id import /tmp/latest-screenshot.png

Touches de modification :

Mod1-Mod5, Shift, Control

  Modificateur standard, voir `xmodmap(1)`

Group1, Group2, Group3, Group4

  Lorsque vous utilisez plusieurs dispositions de clavier (par exemple avec `setxkbmap -layout us, ru`), vous pouvez spécifier dans quel groupe XKB (également appelé «layout») une combinaison de touches doit être active. Par défaut, les raccourcis clavier sont traduits dans Group1 et sont actifs dans tous les groupes. Si vous souhaitez remplacer les combinaisons de touches dans l'un de vos layout, spécifiez le groupe correspondant. Pour une compatibilité descendante, le groupe «Mode_switch» est un alias pour Group2.

### 4.5. Raccourcis à la souris

Un raccourcis à la souris permet à i3 d'exécuter une action sur le container dans lequel se trouve le pointeur à la pression d'un bouton (voir [command_criteria]). Vous pouvez configurer vos raccourcis à la souris comme vos raccourcis clavier.

Syntaxe :

    bindsym [--release] [--border] [--whole-window] [--exclude-titlebar] [<Modifiers>+]button<n> command

Par défaut, le raccourcis ne fonctionnera que si vous cliquez sur la barre de titre d'une fenêtre. Si l'option `--release` est utilisée, l'action sera exécutée en relâchant le bouton de la souris.

Si l'option `--whole-window` est utilisée, l'action sera exécutée quel que soit l'endroit où le pointeur se trouve, exception faite des bordures. Pour une action exécutée depuis une bordure, utilisez l'option `--border`.

Si l'option `--exclude-titlebar` est utilisée, la barre de titre ne sera pas active pour exécuter un raccourcis.

Exemples :

    # The middle button over a titlebar kills the window
    bindsym --release button2 kill

    # The middle button and a modifer over any part of the window kills the window
    bindsym --whole-window $mod+button2 kill

    # The right button toggles floating
    bindsym button3 floating toggle
    bindsym $mod+button3 floating toggle

    # The side buttons move the window around
    bindsym button9 move left
    bindsym button8 move right

### 4.6. Chaines de raccourcis

Vous pouvez avoir plusieurs ensembles de raccourcis en utilisant différentes chaines de raccoucis. Lorsque vous passez à une autre chaine de raccourcis, tous les raccourcis de la chaine actuelle sont libérées et seuls les raccourcis définis dans la nouvelle chaine sont valides tant que vous restez dans cette chaine de raccoucis. La seule chaine préconfigurée est `default`, qui est le mode dans lequel i3 démarre et dans lequel tous les raccourcis sont configurés.

Travailler avec les chaines de raccourcis comporte deux parties : définir une chaine de raccourcis et l'activer. Pour cela, il existe une directive de configuration et une commande, toutes deux appelées `mode`. La directive est utilisée pour définir les raccourcis appartenant à une certaine chaine de raccourcis, tandis que la commande passera sur la chaine spécifiée.

Il est recommandé d'utiliser les chaines de raccourcis en combinaison avec les [variables] pour favoriser la maintenance. Voici en exemple d'utilisation des chaines de raccourcis.

Notez qu'il est conseillé de définir des raccourcis pour revenir au mode par défaut.

Notez qu'il est possible d'utiliser [pango_markup] pour les raccourcis clavier, mais vous devrez explicitement utiliser l'option `--pango_markup` pour activer le mode.

Syntaxe :

    # config directive
    mode [--pango_markup] <name>

    # command
    mode <name>

Exemple :

    # Press $mod+o followed by either f, t, Escape or Return to launch firefox,
    # thunderbird or return to the default mode, respectively.
    set $mode_launcher Launch: [f]irefox [t]hunderbird
    bindsym $mod+o mode "$mode_launcher"

    mode "$mode_launcher" {
        bindsym f exec firefox
        bindsym t exec thunderbird

        bindsym Escape mode "default"
        bindsym Return mode "default"
    }

### 4.7. La touche de modification flottante

Pour déplacer des fenêtres flottantes avec votre souris, vous pouvez soit saisir leur barre de titre, soit configurer le `modificateur flottant` sur lequel vous pouvez ensuite appuyer et cliquer n'importe où dans la fenêtre elle-même pour la déplacer. La configuration la plus courante consiste à utiliser la même touche que celle que vous utilisez pour gérer les fenêtres (Mod1, Alt par exemple). Ensuite, vous pouvez appuyer sur Mod1, cliquer dans une fenêtre à l'aide du bouton gauche de la souris et le faire glisser vers la position souhaitée.

Lorsque vous maintenez le modificateur flottant, vous pouvez redimensionner une fenêtre flottante en appuyant sur le bouton droit de la souris et en vous déplaçant tout en le maintenant. Si vous maintenez également le bouton Shift enfoncé, le redimensionnement sera proportionnel (le rapport hauteur/largeur sera conservé).

Syntaxe :

    floating_modifier <Modifier>

Exemple :

    floating_modifier Mod1

### 4.8. Forcer les dimensions d'un fenêtre flottante

Les dimensions maximales et minimales des fenêtres flottantes peuvent être spécifiées. Si une dimension `floating_maximum_size` est spécifiée à -1, cette dimensions ne sera pas contrainte et respectera sa valeur par défaut. Si une dimension `floating_maximum_size` est indéninie ou specifiée à 0, i3 utilisera une valeur par défaut pour contraindre les dimensions de la fenêtre. `floating_minimum_size` fonctionne comme `floating_maximum_size`.

Syntaxe :

    floating_minimum_size <width> x <height>
    floating_maximum_size <width> x <height>

Exemple :

    floating_minimum_size 75 x 50
    floating_maximum_size -1 x -1

### 4.9. Orientation des espaces de travail

Les nouveaux espaces de travail ont une orientation logique par défaut : les moniteurs à écran large (tout ce qui est plus large que haut) ont une orientation horizontale, les moniteurs pivotés (tout ce qui est plus haut que large) ont une orientation verticale.

Grâce à l'option `default_orientation`, vous pouvez modifier ce comportement.

Syntaxe :

    default_orientation horizontal|vertical|auto

Exemple :

    default_orientation vertical

### 4.10. Disposition des nouveaux containers

Cette option détermine la disposition par défaut des nouveaux containers dans l'espace de travail.

Syntaxe :

    workspace_layout default|stacking|tabbed

Exemple :

    workspace_layout tabbed

### 4.11. Position du titre de la fenêtre

Cette option détermine la position du titre d'une fenêtre (par défaut à gauche).

Syntaxe :

    title_align left|center|right

### 4.12. Bordure par défaut pour les nouvelles fenêtres

Cette option détermine l'apparence des bordures par défaut pour les fenêtres. Par default, c'est `normal`. Notez que `default_floating_border` ne s'applique qu'aux fenêtres ouvertes déjà flottantes comme les fenêtres de dialogue, mais pas aux fenêtres que vous passez en mode flottant.

Définir le style de bordure sur `pixel` élimine la barre de titre. Le style `normal` vous permet d'ajuster l'épaisseur des bordures tout en gardant la barre de titre.

Syntaxe :

    default_border normal|none|pixel
    default_border normal|pixel <px>
    default_floating_border normal|none|pixel
    default_floating_border normal|pixel <px>

Notez que les options `new_window` et `new_float` sont dépréciées en faveur des options ci-dessous et seront supprimées dans une prochaine version.

Exemple :

    default_border pixel

Les styles de bordure "normal" et "pixel" supportent une option additionnelle en pixels :

Exemple :

    # The same as default_border none
    default_border pixel 0

    # A 3 px border
    default_border pixel 3

### 4.13. Masquer les bordures adjacentes aux bords d'écran

Vous pouvez masquer les bordures des fenêtres sur les bords d'écran avec l'option `hide_edge_borders`. Ceci est utile si vous utilisez des barres de défilement ou si vous ne voulez pas gaspiller deux pixels de votre écran. Le paramètre "smart" masque les bordures des espaces de travail avec une seule fenêtre visible, mais les garde sur les espaces de travail avec plusieurs fenêtres visibles. La valeur par défaut est "none".

Syntaxe :

    hide_edge_borders none|vertical|horizontal|both|smart

Exemple :

    hide_edge_borders vertical

### 4.14 Bordures intelligentes

Les smart borders dessineront des bordures sur les fenêtres uniquement s'il y a plus d'une fenêtre dans un espace de travail. Cette fonctionnalité peut également être activée uniquement si la taille de l'espace entre la fenêtre et le bord de l'écran est de 0.

Syntaxe :

    smart_borders on|off|no_gaps

Exemple :

    # Activate smart borders (always)
    smart_borders on

    # Activate smart borders (only when there are effectively no gaps)
    smart_borders no_gaps

### 4.15. Commandes associées à une fenêtre spécifique (for_window)

Avec la directive `for_window`, vous pouvez demander à i3 d'exécuter n'importe quelle commande au lancement d'une fenêtre spécifique. Ceci peut être utile pour forcer une fenêtre flottante ou pour changer le style de bordure, par exemple.

Syntaxe :

    for_window <criteria> <command>

Exemples :

    # enable floating mode for all XTerm windows
    for_window [class="XTerm"] floating enable

    # Make all urxvts use a 1-pixel border:
    for_window [class="urxvt"] border pixel 1

    # A less useful, but rather funny example:
    # makes the window floating as soon as I change
    # directory to ~/work
    for_window [title="x200: ~/work"] floating enable

Les options sont les mêmes que pour la fonction "commande", voir [command_criteria]. Seules des commandes peuvent être exécutées, pas des directives, voir [list_of_commands].

### 4.16. Ne pas donner le focus aux nouvelles fenêtres

Lorsqu'une nouvelle fenêtre s'affiche, elle capte le focus. La directive `no_focus` permet d'éviter ce comportement et doit être utilisée en combinaison avec une commande [command_criteria].

Notez que cela ne s'applique pas dans tous les cas, par exemple, si une fenêtre s'active lors d'une action, elle obtiendra la focus. Pour configurer le comportement dans un tel cas, utilisez [focus_on_window_activation].

`no_focus` sera aussi ignoré lorsqu'une seule fenêtre s'ouvre sur un espace de travail, car elle n'a aucune raison de ne pas obtenir le focus. Cela permet une meilleure utilisation en conbinaison avec `workspace_layout`.

Syntaxe :

    no_focus <criteria>

Exemple :

    no_focus [window_role="pop-up"]

### 4.17. Variables

Comme vous l'avez appris dans la section sur les raccourcis clavier, vous pouvez configurer de nombreux raccourcis contenant des touches de modification. Si vous souhaitez vous épargner de la saisie et pouvoir changer le modificateur que vous utilisez plus tard, les variables peuvent être utiles.

Syntaxe :

    set $<name> <value>

Exemple :

    set $m Mod1
    bindsym $m+Shift+r restart

Les variables sont directement remplacées dans le fichier lors de l'analyse. Le développement des variables n'est pas récursif, il n'est donc pas possible de définir une variable avec une valeur contenant une autre variable. Il n'y a pas de manipulation sophistiquée et il n'est absolument pas prévu de changer cela. Si vous avez besoin d'une configuration plus dynamique, vous devez créer un petit script qui génère un fichier de configuration et l'exécuter avant de démarrer i3 (par exemple dans votre fichier `~/.xsession`).

Voir aussi le chapitre [xresources] pour apprendre à créer des variables basées sur des ressources chargées à partir de la base de données de ressources X (section suivante).

### 4.18. X resources

[variables] peuvent également être créées à l'aide d'une valeur configurée dans la base de données Xressources. Ceci est utile, par exemple, pour éviter de configurer des valeurs de couleur dans la configuration i3. Au lieu de cela, les valeurs peuvent être configurées, une fois, dans la base de données de Xressources pour obtenir un thème de couleur cohérent et facilement maintenable dans de nombreuses applications X.

La définition d'une ressource chargera cette ressource à partir de la base de données et attribuera sa valeur à la variable spécifiée. Cela se fait textuellement et la valeur doit donc être au format utilisé par i3. Une solution de rechange doit être spécifiée au cas où la ressource ne puisse pas être chargée à partir de la base de données.

Syntaxe :

    set_from_resource $<name> <resource_name> <fallback>

Exemple :

    # The ~/.Xresources should contain a line such as
    #     *color0: #121212
    # and must be loaded properly, e.g., by using
    #     xrdb ~/.Xresources
    # This value is picked up on by other applications (e.g., the URxvt terminal
    # emulator) and can be used in i3 like this:
    set_from_resource $black i3wm.color0 #000000

### 4.19. Placement automatique des clients dans un espace de travail

Pour placer une fenêtre spécifique sur un espace de travail donné, vous utiliserez l'option assignment. Vous pouvez désigner une fenêtre en utilisant un ou plusieurs critères, voir[command_criteria]. La différence entre `assign` et `for_window <criteria> move to workspace` est que l'action ne s'applique pas uniquement à l'ouverture de le fenêtre, mais aussi lorsqu'une fenêtre change ses propriétés et correspond à un des critères spécifiés.

Ainsi, il est recommandé de faire correspondre les classes de fenêtre (et les instances, le cas échéant) au lieu des titres de fenêtre chaque fois que possible car certaines applications créent d'abord leur fenêtre, puis s'inquiètent de définir le titre correct. Firefox et Vimperator par exemple : la fenêtre s'ouvre sous le nom de Firefox, et ce n'est que lorsque Vimperator est chargé que le titre change. Comme i3 recevra le titre dès que l'application affichera la fenêtre, vous devrez dans ce cas faire correspondre `Firefox`. Un autre problème connu concerne Spotify, qui ne définit pas les indices de classe lors de l'affichage de la fenêtre, ce qui signifie que vous devrez utiliser une règle `for_window` pour attribuer Spotify à un espace de travail spécifique. Pour finir, utiliser `assign [tiling]` et `assign [floating]` n'est pas supporté.

Vous pouvez aussi désigner une fenêtre pour qu'elle s'affiche sur un écran spécifique. Vous pouvez utiliser le nom `RandR` comme `VGA1` ou un nom relatif à l'éran contenant la fenêtre détenant actuellement le focus comme `left` et `down`.

Les assignations sont traitées par i3 dans l'ordre dans lequel elles apparaissent dans le fichier de configuration. Le premier qui correspond à la fenêtre gagne et les affectations ultérieures ne sont pas prises en compte.

Syntaxe :

    assign <criteria> [→] [workspace] [number] <workspace>
    assign <criteria> [→] output left|right|up|down|primary|<output>

Exemples :

    # Assign URxvt terminals to workspace 2
    assign [class="URxvt"] 2

    # Same thing, but more precise (exact match instead of substring)
    assign [class="^URxvt$"] 2

    # Same thing, but with a beautiful arrow :)
    assign [class="^URxvt$"] → 2

    # Assignment to a named workspace
    assign [class="^URxvt$"] → work

    # Assign to the workspace with number 2, regardless of name
    assign [class="^URxvt$"] → number 2

    # You can also specify a number + name. If the workspace with number 2 exists,
    # assign will skip the text part.
    assign [class="^URxvt$"] → number "2: work"

    # Start urxvt -name irssi
    assign [class="^URxvt$" instance="^irssi$"] → 3

    # Assign urxvt to the output right of the current one
    assign [class="^URxvt$"] → output right

    # Assign urxvt to the primary output
    assign [class="^URxvt$"] → output primary

Notez que vous n'avez peut-être pas encore configuré d'écran principal. Pour ce faire, exécutez :

    xrandr --output <output> --primary

La petite flêche n'est pas obligatoire, c'est simplement pour faire joli :-). Si vous voulez l'employer, prenez soin d'utiliser une flêche encodée en UTF-8, pas `->` ou un truc du genre.

Pour obtenir la class et l'instance, vous pouvez utiliser `xprop`. Après avoir cliqué sur une fenêtre, vous obtiendrez ses informations dans ce style :

xprop :

    WM_CLASS(STRING) = "irssi", "URxvt"

La première partie de WM_CLASS est l'instance ("irssi" dans notre exemple), la seconde partie est la class ("URxvt" dans notre exemple).

Si vous avez le moindre soucis avec les assignements, vérifiez tout d'abord le fichier de log i3 (voir https://i3wm.org/docs/debugging.html). Il contient plus de détails à propos du processus d'assignement et les renseignements sur la class, l'instance et le titre des fenêtres.

Notez que si vous souhaitez démarrer une application une seule fois sur un espace de travail spécifique, mais que vous ne souhaitez pas attribuer ce comportement à toutes les instances de manière permanente, vous pouvez utiliser la prise en charge des notifications de démarrage d'i3 (voir [exec]) dans votre fichier de configuration de la manière suivante :

Lancer iceweasel sur l'espace de travail 3 (une seule fois) :

    # Start iceweasel on workspace 3, then switch back to workspace 1
    # (Being a command-line utility, i3-msg does not support startup notifications,
    #  hence the exec --no-startup-id.)
    # (Starting iceweasel with i3’s exec command is important in order to make i3
    #  create a startup notification context, without which the iceweasel window(s)
    #  cannot be matched onto the workspace on which the command was started.)
    exec --no-startup-id i3-msg 'workspace 3; exec iceweasel; workspace 1'

### 4.20. Lancement d'applications au démarrage d'i3

En utilisant la commande `exec` en dehors du contexte des raccourcis clavier, vous pouvez configurer quelles applications seront lancées au démarrage d'i3. `exec` ne sera pas actif lors d'un rechargement d'i3, si vous désirez que la commande soit exécutée de nouveau lors du rechargement d'i3, utilisez `exec_always`. Ces commandes seront lancées dans l'ordre d'apparition dans le fichier de configuration.

Voir la section [command_chaining] pour plus de détails sur l'utilisation de `;` (semicolon) et `,` (comma) : ils lient les commandes sur i3, donc vous devez utiliser des guillemets `""` si une commande les contient (voir [exec_quoting]).

Syntaxe :

    exec [--no-startup-id] <command>
    exec_always [--no-startup-id] <command>

Exemples :

    exec chromium
    exec_always ~/my_script.sh

    # Execute the terminal emulator urxvt, which is not yet startup-notification aware.
    exec --no-startup-id urxvt

L'option `--no-startup-id` est expliquée ici : [exec].

### 4.21. Placer automatiquement une espace de travail sur un écran

Si vous affectez des clients à des espaces de travail, il peut être pratique de placer les espaces de travail sur des écrans spécifiques. En outre, l'assignation d'espaces de travail aux écrans déterminera quel espace de travail i3 utilise lors du branchement d'un écran ou au démarrage (par exemple, il utilisera 1 pour le premier écran, 2 pour le deuxième écran et ainsi de suite).

Syntaxe :

    workspace <workspace> output <output1> [output2]…

L'écran output est le nom que `RandR` donne à votre écran. Pour un ordinateur portable, vous devriez utiliser VGA1 et LVDS1 comme noms d'écran. Vous pouvez lister les écrans actifs avec `xrandr --current`.

Si votre serveur X supporte RandR 1.5 ou supérieur, i3 utilisera la fonction `monitor` de RandR au lieu de la fonction `output`. Utilisez `xrandr --listmonitors` pour afficher la liste. En général, un `monitor` contient un seul `output` et a le même nom; mais si ce n'est pas le cas, vous pouvez spécifier le nom du moniteur ou de la sortie dans la configuration d'i3. Par exemple, le Dell UP2414Q utilise deux dénominations en interne, de sorte que ses noms de sortie peuvent être «DP1» et «DP2», mais le nom du moniteur est «Dell UP2414Q».

(Notez que même si vous spécifiez le nom d'une sortie qui ne couvre pas tout le moniteur, i3 utilisera toujours la zone entière du moniteur contenant plutôt que celle de la sortie uniquement.)

Vous pouvez spécifiez plusieurs écrans. Le premier disponible sera utilisé.

Si vous utilisez le nom des espaces de travail, vous devez utiliser des guillements :

Exemples :

    workspace 1 output LVDS1
    workspace 2 output primary
    workspace 5 output VGA1 LVDS1
    workspace "2: vim" output VGA1

### 4.22. Changer les couleurs

Vous pouvez modifier chaque couleur utilisée par i3 pour décorer les fenêtres.

Syntaxe :

    <colorclass> <border> <background> <text> <indicator> <child_border>

Avec `colorclass` pouvant être un de ceux-ci :

client.focused

  Un client possédant le focus.

client.focused_inactive

  Un client qui a le focus dans son container, mais qui ne l'a pas pour l'instant.

client.unfocused

  Un client qui n'a pas le focus dans son container.

client.urgent

  Un client qui demande l'attention avec le tag 'urgent'.

client.placeholder

  L'arrière-plan et la couleur du texte sont utilisés pour dessiner le l'espace réservé par le contenu de la fenêtre (lors de la restauration du layout). La bordure et l'indicateur sont ignorés

client.background

  Couleur d'arrière-plan qui sera utilisée pour peindre l'arrière-plan de la fenêtre client au-dessus de laquelle le client sera rendu. Seuls les clients qui ne couvrent pas toute la zone de cette fenêtre exposent la couleur. Notez que cette classe de couleurs ne prend qu'une seule couleur.

Les couleurs sont indiquées au format HTML (#rrggbb), voir l'exemple suivant :

Exemples (couleurs par défaut) :

    # class                 border  backgr. text    indicator child_border
    client.focused          #4c7899 #285577 #ffffff #2e9ef4   #285577
    client.focused_inactive #333333 #5f676a #ffffff #484e50   #5f676a
    client.unfocused        #333333 #222222 #888888 #292d2e   #222222
    client.urgent           #2f343a #900000 #ffffff #900000   #900000
    client.placeholder      #000000 #0c0c0c #ffffff #000000   #0c0c0c

    client.background       #ffffff

Notez que pour les décorations de fenêtre, la couleur autour de la fenêtre enfant est "child_border", et la couleur "border" représente les deux fines lignes autour de la barre de titre.

La couleur de l'indicateur est utilisée pour indiquer où une nouvelle fenêtre sera ouverte. Pour les containers fractionnés horizontaux, la bordure droite sera peinte dans la couleur de l'indicateur, pour les containers fractionnés verticaux, la bordure inférieure. Cela ne s'applique qu'aux fenêtres simples dans un container divisé, qui sont autrement impossibles à distinguer des fenêtres simples à l'extérieur d'un container divisé.

### 4.23. Communication avec i3

i3 utilise des sockets Unix pour fournir une interface IPC. Cela permet à des programmes tiers d'obtenir des informations d'i3, telles que les espaces de travail actuels (pour afficher une barre d'espace de travail), et de contrôler i3.

Le socket IPC est activé par défaut et sera créée dans `$XDG_RUNTIME_DIR/i3/ipc-socket.%p` si le répertoire est disponible, en revenant à `/tmp/i3-%u.XXXXXX/ipc-socket.%p`, où `%u` est votre nom d'utilisateur UNIX, `%p` est le PID de i3 et XXXXXX est une chaîne de caractères aléatoires du jeu de caractères du nom de fichier portable (voir mkdtemp(3)).

Vous pouvez modifier le chemin par défaut via la variable d'environnement `I3SOCK` ou en spécifiant la directive `ipc-socket`. Ceci n'est pas encouragé, car i3 se comporte correctement par défaut. Si vous décidez de le changer, il est fortement recommandé de le définir sur un emplacement dans votre répertoire personnel afin qu'aucun autre utilisateur ne puisse créer ce répertoire.

Exemples :

    ipc-socket ~/.i3/i3-ipc.sock

Vous pouvez utiliser l'application `i3-msg` pour exécuter les commandes listées dans [list_of_commands].

### 4.24. Le focus suit la souris

Par défaut, le focus suit les mouvements de votre souris lorsque le pointeur traverse les bordures de la fenêtre. Cependant, si vous avez une configuration où votre souris est trop sur votre chemin (comme un pavé tactile sur otre ordinateur portable que vous ne souhaitez pas désactiver complètement), vous pouvez désactiver focus_follow_mouse et contrôler le focus uniquement en utilisant votre clavier. La souris sera toujours utile dans la fenêtre active (par exemple pour cliquer sur des liens dans la fenêtre de votre navigateur).

Syntaxe :

    focus_follows_mouse yes|no

Exemple :

    focus_follows_mouse no

### 4.25. Captation de la souris

Par défaut, lors du passage du focus à une fenêtre sur un écran différente (par exemple, focalisation d'une fenêtre sur l'espace de travail 3 sur la sortie VGA-1, provenant de l'espace de travail 2 sur LVDS-1), le curseur de la souris est capté et s'affiche au centre de cette fenêtre.

Avec l'option `mouse_warping` , vous pouvez décider quand votre pointeur sera capté. `none` désactive totalement la captation, quel que soit le `output` par défaut défini ci-dessous.

Syntaxe :

    mouse_warping output|none

Exemple :

    mouse_warping none

### 4.26. Les popups en mode plein écran

Lorsque vous êtes en mode plein écran, certaines applications ouvrent encore des fenêtres contextuelles (comme Xpdf par exemple). Cela est dû au fait que ces applications peuvent ne pas savoir qu'elles sont en mode plein écran (elles ne vérifient pas l'indication correspondante). Il y a trois choses à faire dans cette situation:

1. Afficher la popup uniquement si elle appartient à l'application plein écran. Il s'agit de la valeur par défaut et devrait être un comportement raisonnable pour la plupart des utilisateurs.
2. Ignorez simplement la fenêtre contextuelle (ne la mappez pas). Cela ne vous interrompra pas pendant que vous êtes en plein écran. Cependant, certaines applications peuvent mal réagir à cela (blocage jusqu'à ce que vous sortiez du plein écran).
3. Quitter le plein écran.

Syntaxe :

    popup_during_fullscreen smart|ignore|leave_fullscreen

Exemple :

    popup_during_fullscreen smart

### 4.27. Retour de focus

Par défaut, dans un container avec plusieurs fenêtres ou containers enfants, la fenêtre opposée sera focalisée lors de la tentative de déplacer le focus sur le bord d'un container (et qu'il n'y a aucun autre container dans cette direction) - le focus repart dans un cycle.

Vous pouvez modifier ce comportement en configurant l'option `focus_wrapping` sur `no`.

Lorsqu'il est activé, `focus_wrapping` ne se produit pas par défaut s'il existe une autre fenêtre ou container dans la direction spécifiée, et le focus sera à la place définie sur cette fenêtre ou ce container. Il s'agit du comportement par défaut afin que vous puissiez accéder à toutes vos fenêtres sans avoir à utiliser le `focus parent`.

Si vous désirez activer le `focus_wrapping` de façon permanente et que vous êtes à l'aise avec la fonction `focus parent` pour vous déplacer dans les containers, vous pouvez définir l'option `focus_wrapping` sur `force`.

Pour restreindre le focus à l'intérieur d'un espace de travail, vous devez configurez l'option `focus_wrapping` sur `workspace`. Vous devrez alors utiliser `focus parent` pour remonter le focus jusqu'au niveau d'un espace de travail pour ensuite déplacer le focus sur un autre espace de travail avec la commande de focus. (la commande `workspace` fonctionnera toujours comme prévu).

Syntaxe :

    focus_wrapping yes|no|force|workspace

    # Legacy syntax, equivalent to "focus_wrapping force"
    force_focus_wrapping yes

Exemples :

    # Disable focus wrapping
    focus_wrapping no

    # Force focus wrapping
    focus_wrapping force

### 4.28. Forcer Xinerama

Comme expliqué ici https://i3wm.org/docs/multi-monitor.html, certains drivers X11 (particulièrement les drivers nVidia) supportent uniquement Xinerama et non RandR. Dans cette situation, i3 doit être prévenu explicitement afin d'utiliser le support inférieur pour l'API Xinerama et de ne pas recharger les écrans à la volée (ils seront configurés une seule fois au lancement d'i3).

Pour les personnes ne pouvant pas utiliser le fichier `~/.xsession` pour y ajouter `--force-xinerama`, i3 propose une option :

Syntaxe :

    force_xinerama yes|no

Exemple :

    force_xinerama yes

Notez que vos écrans ne seront pas nommés avec Xinerama (comme `HDMI1`), ils sont numérotés en commençant par 0 : `xinerama-0`, `xinerama-1`, …

### 4.29. Aller-retour automatique lors du passage sur un espace de travail

La configuration permet d'activer le retour automatique sur le dernier espace de travail (`workspace back_and_forth` voir [back_and_forth]) lorsqu'on visite un autre espace de travail.

Par exemple : imaginons que vous êtes sur l'espace de travail "1: www" et que vous passez sur l'espace de travail "2: IM" en utilisant mod+2 car un humain vous a envoyé un message. Vous n'avez pas besoin de vous souvenir sur quel espace de travail vous étiez, il vous suffit de presser $mod+2 une nouvelle fois pour revenir sur l'espace de travail "1: www".

Syntaxe :

    workspace_auto_back_and_forth yes|no

Exemple :

    workspace_auto_back_and_forth yes

### 4.30. Retarder la réinitialisation de l'indicateur d'urgence lors d'un changement d'espace de travail

Si une application sur un autre espace de travail envoie un indice d'urgence, le passage à cet espace de travail peut conduire à un focus immédiat de l'application, ce qui signifie également que la couleur de la décoration de la fenêtre serait immédiatement réinitialisée sur `client.focused`. Cela peut rendre inutilement difficile de dire quelle fenêtre a déclenché l'urgence à l'origine.

Afin d'éviter cela, vous pouvez dire à i3 de retarder la réinitialisation de l'état d'urgence d'un certain temps en utilisant la directive `force_display_urgency_hint`. La définition de la valeur sur 0 désactive cette fonction.

Par défaut, l'urgence disparaît au bout de 500ms.

Syntaxe :

    force_display_urgency_hint <timeout> ms

Exemple :

    force_display_urgency_hint 500 ms

### 4.31. Captation du Focus lors de l'activation d'une fenêtre

Lorsqu'une fenêtre est activée, par exemple via `firefox nakedeb.arpinux.org`, elle va demander à capter le focus. Si vous désirez modifier ce comportement, plusieurs options existent.

Notez que cela n'affecte pas les fenêtres qui se lancent. Pour empêcher une fenêtre qui s'ouvre de réclamer le focus, voir [no_focus].

Syntaxe :

    focus_on_window_activation smart|urgent|focus|none

Explications des différents modes :

smart

  Le comportement par défaut : si la fenêtre demandant le focus est sur l'espace de travail actif, elle recevra le focus. Sinon, l'indication d'urgence sera envoyée.

urgent

  La fenêtre sera marquée comme urgente, mais le focus ne sera pas capté.

focus

  La fenêtre recevra le focus et ne sera pas marque comme urgente.

none

  La fenêtre ne recevra pas le focus et ne sera pas marquée comme urgente.

### 4.32. Afficher les marques sur les décoration des fenêtres

Si activé, les marques (voir [vim_like_marks]) sur les fenêtres sont dessinées dans leur décoration de fenêtre. Cependant, toute marque commençant par un underscore dans son nom (`_`) ne sera pas dessinée même si cette option est activée.

L'option par défaut est `yes`.

Syntaxe :

    show_marks yes|no

Exemple :

    show_marks yes

### 4.33. Continuité des lignes

Les fichiers de configuration prennent en charge la continuation de ligne, ce qui signifie que lorsque vous terminez une ligne par une barre oblique inverse (`\`), le saut de ligne sera ignoré par l'analyseur. Cette fonctionnalité peut être utilisée pour créer des fichiers de configuration plus lisibles. Les lignes commentées ne sont pas poursuivies.

Exemples :

    bindsym Mod1+f \
    fullscreen toggle

    # this line is not continued \
    bindsym Mod1+F fullscreen toggle

### Configurer le glisser-déposer des containers pavés

Vous pouvez configurer comment initier la fonction de glissement des containers pavés (voir [tiling_drag]).

Syntaxe :

    tiling_drag off
    tiling_drag modifier|titlebar [modifier|titlebar]

Exemples :

    # Only initiate a tiling drag when the modifier is held:
    tiling_drag modifier

    # Initiate a tiling drag on either titlebar click or held modifier:
    tiling_drag modifier titlebar

    # Disable tiling drag altogether
    tiling_drag off

### Marges

Depuis i3 4.22, vous pouvez configurer des marges entre les fenêtres. Les gaps sont des espacements ajoutés entre les fenêtres (ou les containers divisés) et aux bords de l'écran (ici 10px inner gaps, 20px outer gaps) :

Figure 5. Gaps enabled (10 px inner gaps, 20 px outer gaps)

Vous pouvez configurer deux types de marges :

- Inner gaps sont les espaces entre deux fenêtres adjacentes (ou deux containers pavés).
- Outer gaps sont les espaces aux bords de l'ecran. Vous pouvez configurer chaque côté (gauce/droite/haut/bas) séparément.

Si vous êtes familier avec HTML et CSS, vous pouvez considérer les espaces intérieurs comme un padding et les espaces extérieurs comme une margin, appliqués à une div autour de votre fenêtre ou d'un container pavé.
Notez que les espaces extérieurs sont ajoutés aux espaces intérieurs, ce qui signifie que la taille totale de l'espace entre un bord d'écran et une fenêtre (ou un container pavé) sera la somme des espaces extérieurs et intérieurs.

Vous pouvez définir des espaces globalement ou par espace de travail à l'aide de la syntaxe suivante.

Syntaxe :

    # Inner gaps for all windows: space between two adjacent windows (or split containers).
    gaps inner [px]

    # Outer gaps for all windows: space along the screen edges.
    gaps outer|horizontal|vertical|top|left|bottom|right [px]

    # Inner and outer gaps for all windows on a specific workspace.
    #  can be a workspace number or name.
    workspace  gaps inner [px]
    workspace  gaps outer|horizontal|vertical|top|left|bottom|right [px]

    # Enabling “Smart Gaps” means no gaps will be shown when there is
    # precisely one window or split container on the workspace.
    #
    # inverse_outer only enables outer gaps when there is exactly one
    # window or split container on the workspace.
    smart_gaps on|off|inverse_outer

Les espaces extérieurs peuvent être configurés pour chaque côté individuellement avec la directive haut, gauche, bas et droite. horizontal et vertical sont des raccourcis pour gauche/droite et haut/bas, respectivement.

Exemples :

    # Configure 5px of space between windows and to the screen edges.
    gaps inner 5

    # Configure an additional 5px of extra space to the screen edges,
    # for a total gap of 10px to the screen edges, and 5px between windows.
    gaps outer 5

    # Overwrite gaps to 0, I need all the space I can get on workspace 3.
    workspace 3 gaps inner 0
    workspace 3 gaps outer 0

    # Only enable outer gaps when there is exactly one window or split container on the workspace.
    smart_gaps inverse_outer

Astuce : Les espaces peuvent en outre être modifiés lors de l'exécution avec la commande gaps, voir [changing_gaps].
Vous pouvez trouver un exemple de configuration qui utilise des modes pour illustrer diverses configurations d'écart.

## 5. Configurer i3bar

La barre en bas de votre moniteur est dessinée par un processus distinct appelé i3bar. Avoir cette partie de «l'interface utilisateur i3» dans un processus séparé présente plusieurs avantages:

1. C'est une approche modulaire. Si vous n'avez pas du tout besoin d'une barre d'espace de travail, ou si vous préférez une autre (dzen2, xmobar, peut-être même gnome-panel ?), vous pouvez simplement supprimer la configuration de l'i3bar et démarrer votre barre préférée à la place.

2. Il suit la philosophie UNIX de "Faire en sorte que chaque programme fasse bien une chose". Alors que i3 gère vos fenêtres, i3bar est là pour afficher une barre sur chaque moniteur (sauf si vous le configurez autrement).

3. Cela conduit à deux bases de code distinctes et propres. Si vous voulez comprendre i3, vous n’avez pas besoin de vous soucier des détails de la i3bar et vice versa.

Cela dit, i3bar est configuré dans le même fichier de configuration que i3. C'est parce qu'il est étroitement couplé avec i3 (contrairement à i3lock ou i3status qui sont utiles pour les personnes utilisant d'autres gestionnaires de fenêtres). Par conséquent, cela n'a aucun sens d'utiliser un emplacement de configuration différent lorsque nous avons déjà une bonne infrastructure de configuration en place.

La configuration de la barre de votre espace de travail commence par l'ouverture d'un bloc `bar`. Vous pouvez avoir plusieurs blocs de barres pour utiliser différents paramètres pour différentes sorties (moniteurs) ou pour avoir plusieurs barres sur le même écran :

Exemple :

    bar {
        status_command i3status
    }

### 5.1. Commande i3bar

Par défaut, i3 passera simplement `i3bar` et laissera votre shell gérer l'exécution, en recherchant dans votre `$PATH` pour une version exploitable. Si vous avez une autre version d'`i3bar` quelque part ou si le binaire n'est pas dans votre `$PATH`, vous pouvez indiquer à i3 quelle commande exécuter.

La commande spécifiée sera transmise à `sh -c`, vous pouvez donc utiliser le globbing et avoir des guillemets corrects etc.

Syntaxe :

    i3bar_command <command>

Exemple :

    bar {
        i3bar_command /home/user/bin/i3bar
    }

### 5.2. Commande Statusline

i3bar peut exécuter un programme et afficher chaque ligne de sa sortie `stdout` sur le côté droit de la barre. Ceci est utile pour afficher les informations système telles que votre adresse IP actuelle, l'état de la batterie ou la date et l'heure.

La commande spécifiée sera transmise à `sh -c`, vous pouvez donc utiliser le globbing et avoir des guillemets corrects etc. Notez que pour la gestion du signal, en fonction de votre shell (les utilisateurs de dash(1) sont connus pour être affecté), vous devez utiliser la commande `exec` du shell pour que les signaux soient transmis à votre programme, pas au shell.

Syntaxe :

    status_command <command>

Exemple :

    bar {
        status_command i3status --config ~/.i3status.conf

        # For dash(1) users who want signal handling to work:
        status_command exec ~/.bin/my_status_command
    }

### 5.3. Mode d'affichage

Vous pouvez soit avoir i3bar soit visible en permanence sur un bord de l'écran (mode `dock`) ou le faire apparaître lorsque vous appuyez sur votre touche de modification (mode `hide`). Il est également possible de forcer i3bar à toujours rester caché (mode `invisible`). La touche de modification peut être configurée à l'aide de l'option `modifier`.

Le mode d'affichage peut être modifié pendant l'exécution via la commande `bar mode`. Au rechargement, le mode reviendra à sa valeur configurée.

Le mode `hide` maximise l'espace d'écran qui peut être utilisé pour les fenêtres réelles. En outre, i3bar envoie les signaux `SIGSTOP` et `SIGCONT` au processus de la barre d'état pour économiser l'énergie de la batterie.

Le mode `invisible` permet de maximiser en permanence l'espace de l'écran, car la barre n'est jamais affichée. Ainsi, vous pouvez configurer i3bar pour ne pas vous déranger en apparaissant à cause d'un indice d'urgence ou parce que la touche de modification est enfoncée.

Afin de contrôler si i3bar est masqué ou affiché en mode `hide`, il existe l'option `hidden_state`, qui n'a aucun effet en mode dock ou en mode invisible. Il indique l'état caché actuel de la barre : (1) La barre agit comme en mode caché normal, elle est cachée et n'est affichée qu'en cas d'indices d'urgence ou en appuyant sur la touche de modification (état `hide`), ou (2) il est dessiné sur l'espace de travail actuellement visible (état `show`).

Comme le mode, `hidden_state` peut également être contrôlé via i3, en utilisant la commande `bar hidden_state`.

Le mode par défaut est le mode dock; en mode hide, le modificateur par défaut est Mod4 (généralement la touche Windows). La valeur par défaut de hidden_state est hide.

Syntaxe :

    mode dock|hide|invisible
    hidden_state hide|show
    modifier <Modifier>|none

Exemple :

    bar {
        mode hide
        hidden_state hide
        modifier Mod1
    }

Les modificateurs disponibles sont Mod1-Mod5, Shift, Control (voir `xmodmap (1)`). Vous pouvez également utiliser "none" si vous ne souhaitez pas qu'un modificateur déclenche ce comportement.

### 5.4. Commandes lors d'un clic

Spécifier une commande à exécuter lors d'un clic sur i3bar pour remplacer le comportement par défaut peut être utile, par exemple, pour désactiver l'action de la molette de défilement ou exécuter des scripts qui implémentent un comportement personnalisé pour ces boutons.

Un bouton est toujours nommé `button<1-5>`, où 1 à 5 sont les boutons par défaut comme suit et les nombres plus élevés peuvent être des boutons spéciaux sur les appareils offrant plus de boutons:

button1

  clic gauche.

button2

  clic central.

button3

  clic droit.

button4

  molette vers le haut.

button5

  molette vers le bas.

Veuillez noter que les anciennes commandes `wheel_up_cmd` et `wheel_down_cmd` sont obsolètes et seront supprimées dans une prochaine version. Nous vous recommandons fortement d'utiliser plutôt le `bindsym` plus général avec `button4` et `button5`.

Syntaxe :

    bindsym [--release] button<n> <command>

Exemple :

    bar {
        # disable clicking on workspace buttons
        bindsym button1 nop
        # Take a screenshot by right clicking on the bar
        bindsym --release button3 exec --no-startup-id import /tmp/latest-screenshot.png
        # execute custom script when scrolling downwards
        bindsym button5 exec ~/.i3/scripts/custom_wheel_down
    }

### 5.5. ID de la barre

Spécifie l'ID de barre pour l'instance de barre configurée. Si cette option est manquante, l'ID est défini sur bar-x, où x correspond à la position du bloc de barres dans le fichier de configuration (bar-0, bar-1, etc).

Syntaxe :

    id <bar_id>

Exemple :

    bar {
        id bar-1
    }

### 5.6. Position

Cette option détermine l'emplacement de la barre sur l'écran.

Par défaut : bottom.

Syntaxe :

    position top|bottom

Exemple :

    bar {
        position top
    }

### 5.7. Écran(s)

Vous pouvez restreindre i3bar à une ou plusieurs sorties (moniteurs). La valeur par défaut est de gérer toutes les sorties. La limitation des sorties est utile pour utiliser différentes options pour différentes sorties un utilisant plusieurs blocs bar.

Pour qu'une instance i3bar particulière gère plusieurs sorties, spécifiez la directive de sortie plusieurs fois.

Syntaxe :

    output primary|<output>

Exemple :

    # big monitor: everything
    bar {
        # The display is connected either via HDMI or via DisplayPort
        output HDMI2
        output DP2
        status_command i3status
    }

    # laptop monitor: bright colors and i3status with less modules.
    bar {
        output LVDS1
        status_command i3status --config ~/.i3status-small.conf
        colors {
            background #000000
            statusline #ffffff
        }
    }

    # show bar on the primary monitor and on HDMI2
    bar {
        output primary
        output HDMI2
        status_command i3status
    }

Notez que vous n'avez peut-être pas encore configuré de sortie principale. Pour ce faire, exécutez :

    xrandr --output <output> --primary

### 5.8. Zone de notification

i3bar par défaut fournit une zone de notification où des programmes tels que NetworkManager, VLC, Pidgin, etc. peuvent placer de petites icônes.

Vous pouvez configurer sur quelle sortie (moniteur) les icônes doivent être affichées ou vous pouvez désactiver complètement la fonctionnalité.

Vous pouvez utiliser plusieurs directives `tray_output` dans votre configuration pour spécifier une liste de sorties sur lesquelles vous voulez que la zone apparaisse. La première sortie disponible dans cette liste telle que définie par l'ordre des directives sera utilisée pour la zone de notification.

Syntaxe :

    tray_output none|primary|<output>

Exemple :

    # disable system tray
    bar {
        tray_output none
    }

    # show tray icons on the primary monitor
    bar {
        tray_output primary
    }

    # show tray icons on the big monitor
    bar {
        tray_output HDMI2
    }

Notez que vous n'avez peut-être pas encore configuré de sortie principale. Pour ce faire, exécutez :

    xrandr --output <output> --primary

Notez que lorsque vous utilisez plusieurs blocs de configuration de barres, spécifiez `tray_output primary` dans chacun d'eux ou spécifiez explicitement `tray_output none` dans les barres qui ne doivent pas afficher la barre d'état, sinon les différentes instances peuvent se concurrencer en essayant d'afficher les icônes de la barre d'état.

### 5.9. Marges dans la zone de notification

La zone de notification est affichées sur le côté droit de la barre. Par défaut, une marge de 2 pixels est utilisée pour le côté supérieur, inférieur et droit de la zone de notification et entre les icônes.

Syntaxe :

    tray_padding <px> [px]

Exemple :

    # Obey Fitts's law
    tray_padding 0

### 5.10. Police de caractère

Spécifie la police à utiliser dans la barre. Voir [fonts].

Syntaxe :

    font <font>

Exemple :

    bar {
        font -misc-fixed-medium-r-normal--13-120-75-75-C-70-iso10646-1
        font pango:DejaVu Sans Mono 10
    }

### 5.11. Séparateur personnalisé

Spécifie un symbole personnalisé à utiliser pour le séparateur par opposition au séparateur vertical d'un pixel par défaut.

Syntaxe :

    separator_symbol <symbol>

Exemple :

    bar {
        separator_symbol ":|:"
    }

### 5.12. Boutons d'espace de travail

Spécifie si les boutons de l'espace de travail doivent être affichés ou non. Ceci est utile si vous souhaitez afficher une barre d'état contenant uniquement des informations supplémentaires.

Par défaut, les boutons des espaces de travail sont affichés.

Syntaxe :

    workspace_buttons yes|no

Exemple :

    bar {
        workspace_buttons no
    }

### 5.13. Largeur minimale pour les boutons d'i3bar

Par défaut, la largeur d'un bouton d'espace de travail est déterminée par la largeur du texte affichant le nom de l'espace de travail. Si le nom est trop court (par exemple, une lettre), le bouton de l'espace de travail peut paraître trop petit.

Cette option spécifie la largeur minimale des boutons de l'espace de travail. Si le nom d'un espace de travail est trop court pour couvrir le bouton, un remplissage supplémentaire est ajouté des deux côtés du bouton afin que le texte soit centré.

La valeur par défaut de zéro signifie qu'aucun remplissage supplémentaire n'est ajouté.

Le réglage s'applique également à l'indicateur de mode de raccourcis actif.

Notez que les pixels spécifiés font référence à des pixels logiques, ce qui peut se traduire par plus de pixels sur les écrans HiDPI.

Syntaxe :

    workspace_min_width <px> [px]

Exemple :

    bar {
        workspace_min_width 40
    }

### 5.14. Affichage du nom ou du numéro des espaces de travail

Spécifie si les numéros d'espace de travail doivent être affichés dans les boutons de l'espace de travail. Ceci est utile si vous souhaitez avoir un espace de travail nommé qui reste dans l'ordre sur la barre en fonction de son numéro sans afficher le préfixe numérique.

Lorsque `strip_workspace_numbers` est défini sur `yes`, tout espace de travail dont le nom est de la forme "[n] [:] [NAME]" affichera uniquement le nom. Vous pouvez utiliser ceci, par exemple, pour afficher des chiffres romains plutôt que des chiffres en nommant vos espaces de travail «1: I», «2: II», «3: III», «4: IV», etc.

Lorsque `strip_workspace_name` est défini sur `yes`, tout espace de travail dont le nom est de la forme "[n] [:] [NAME]" affichera uniquement le numéro.

La valeur par défaut est d'afficher le nom complet dans le bouton de l'espace de travail. Sachez que les deux points dans le nom de l'espace de travail sont facultatifs, donc `[n] [NAME]` aura également le nom et le numéro de l'espace de travail supprimés correctement.

Syntaxe :

    strip_workspace_numbers yes|no
    strip_workspace_name yes|no

Exemple :

    bar {
        strip_workspace_numbers yes
    }

### 5.15. Indicateur du mode de raccourcis

Spécifie si l'indicateur de mode de raccourcis actif doit être affiché ou non. Cela est utile si vous souhaitez masquer les boutons de l'espace de travail tout en continuant à voir l'indicateur de mode de raccourcis. Voir [binding_modes] pour découvrir ce que sont les modes et comment les utiliser.

Par défaut, l'indicateur est affiché.

Syntaxe :

    binding_mode_indicator yes|no

Exemple :

    bar {
        binding_mode_indicator no
    }

### 5.16. Couleurs

Sur i3, les couleurs sont au format HTML hexadécimal (#rrggbb). Les couleurs suivantes peuvent être configurées :

background

  couleur de fond de la barre.

statusline

  couleur du texte de la statusline.

separator

  couleur du texte pour les séparateurs.

focused_background

  couleur de fond de la barre du moniteur focalisée. S'il n'est pas utilisé, la couleur sera tirée de `background`.

focused_statusline

  couleur du texte de la statusline du moniteur focalisé. S'il n'est pas utilisé, la couleur sera tirée de `statusline`.

focused_separator

  couleur du texte des séparateurs du moniteur focalisé. S'il n'est pas utilisé, la couleur sera tirée de `separator`.

focused_workspace

  couleur de la bordure, du fond et du texte du bouton d'espace de travail lorsque l'espace de travail est focalisé.

active_workspace

  couleur de la bordure, du fond et du texte pour un bouton d'espace de travail lorsque l'espace de travail est actif (visible) sur une sortie, mais que le focus est sur une autre. Vous ne pouvez distinguer cela de l'espace de travail actif que lorsque vous utilisez plusieurs moniteurs.

inactive_workspace

  couleur de la bordure, du fond et du texte d'un bouton d'espace de travail lorsque l'espace de travail n'a pas le focus et n'est pas actif (visible) sur une sortie. Ce sera le cas pour la plupart des espaces de travail.

urgent_workspace

  couleur de la bordure, du fond et du texte pour un bouton d'espace de travail lorsque l'espace de travail contient une fenêtre avec l'indication d'urgence.

binding_mode

  couleur de la bordure, du fond et du texte pour l'indicateur de mode de raccourcis. Si elles ne sont pas utilisées, les couleurs seront extraites de `urgent_workspace`.

Syntaxe :

    colors {
        background <color>
        statusline <color>
        separator <color>

        <colorclass> <border> <background> <text>
    }

Exemple (couleurs par défaut) :

    bar {
        colors {
            background #000000
            statusline #ffffff
            separator #666666

            focused_workspace  #4c7899 #285577 #ffffff
            active_workspace   #333333 #5f676a #ffffff
            inactive_workspace #333333 #222222 #888888
            urgent_workspace   #2f343a #900000 #ffffff
            binding_mode       #2f343a #900000 #ffffff
        }
    }

### 5.17. Transparence

i3bar peut prendre en charge la transparence en passant l'indicateur `--transparency` dans la configuration :

Syntaxe :

    bar {
        i3bar_command i3bar --transparency
    }

Dans la configuration des couleurs i3bar et l'attribut de couleur du bloc d'état i3bar, vous pouvez ensuite utiliser des couleurs au format RGBA, c'est-à-dire que les deux derniers chiffres (hexadécimaux) spécifient l'opacité. Par exemple, `#00000000` sera complètement transparent, tandis que `#000000FF` sera un noir complètement opaque (le même que `#000000`).

Veuillez noter qu'en raison du fonctionnement de la zone de notification, l'activation de cet indicateur fera en sorte que toutes les icônes de la zone auront un arrière-plan transparent.

### 5.18. Marges i3bar

Pour rendre i3bar plus haute (sans augmenter la taille de la police) et/ou ajouter un espace à gauche et à droite de i3bar, vous pouvez utiliser la directive padding :

Syntaxe :

    bar {
        # 2px left/right and 2px top/bottom padding
        padding 2px

        # 2px top/bottom padding, no left/right padding
        padding 2px 0

        # 2px top padding, no left/right padding, 4px bottom padding
        padding 2px 0 4px

        # four value syntax
        padding top[px] right[px] bottom[px] left[px]
    }

Remarque : Pour des raisons de commodité pour les utilisateurs qui migrent d'i3-gaps vers i3, la directive height d'i3-gaps est prise en charge par i3, mais doit être remplacée par padding.

## 6. Liste des commandes

Les commandes sont ce que vous liez à des touches spécifiques. Vous pouvez également lancer des commandes au moment de l'exécution sans appuyer sur une touche à l'aide de l'interface IPC. Un moyen simple de le faire est d'utiliser l'utilitaire `i3-msg` :

Exemple :

    # execute this on your shell to make the current container borderless
    i3-msg border none

Les commandes peuvent être enchainées grâce à `;` (a semicolon). Donc pour déplacer une fenêtre sur un espace de travail spécifique puis afficher cet espace de travail :

Example:

    bindsym $mod+x move container to workspace 3; workspace 3

En outre, vous pouvez modifier la portée d'une commande, c'est-à-dire quels containers doivent être affectés par cette commande, en utilisant divers critères. Les critères sont spécifiés avant toute commande entre crochets et sont séparés par un espace.

Lorsque vous utilisez plusieurs commandes, séparez-les en utilisant une `,` (une virgule) au lieu d'un point-virgule. Les critères s'appliquent uniquement jusqu'au point-virgule suivant, donc si vous utilisez un point-virgule pour séparer les commandes, seule la première sera exécutée pour la ou les fenêtres correspondantes.

Exemple :

    # if you want to kill all windows which have the class Firefox, use:
    bindsym $mod+x [class="Firefox"] kill

    # same thing, but case-insensitive
    bindsym $mod+x [class="(?i)firefox"] kill

    # kill only the About dialog from Firefox
    bindsym $mod+x [class="Firefox" window_role="About"] kill

    # enable floating mode and move container to workspace 4
    for_window [class="^evil-app$"] floating enable, move container to workspace 4

    # move all floating windows to the scratchpad
    bindsym $mod+x [floating] move scratchpad

Les critères disponibles :

class

  Compare la classe de fenêtre (la deuxième partie de WM_CLASS). Utilisez la valeur spéciale `__focused__` pour faire correspondre toutes les fenêtres ayant la même classe de fenêtre que la fenêtre actuellement focalisée.

instance

  Compare l'instance de fenêtre (la première partie de WM_CLASS). Utilisez la valeur spéciale `__focused__` pour faire correspondre toutes les fenêtres ayant la même instance de fenêtre que la fenêtre actuellement focalisée.

window_role

  Compare le rôle de fenêtre (WM_WINDOW_ROLE). Utilisez la valeur spéciale `__focused__` pour faire correspondre toutes les fenêtres ayant le même rôle de fenêtre que la fenêtre actuellement focalisée.

window_type

  Compare le type de fenêtre (_NET_WM_WINDOW_TYPE). Les valeurs possibles sont `normal`, `dialog`, `utility`, `toolbar`, `splash`, `menu`, `dropdown_menu`, `popup_menu`, `tooltip` et `notification`.

id

  Compare l'ID de fenêtre X11, que vous pouvez obtenir via `xwininfo` par exemple.

title

  Compare le titre de la fenêtre X11 (_NET_WM_NAME ou WM_NAME comme solution de secours). Utilisez la valeur spéciale `__focused__` pour faire correspondre toutes les fenêtres ayant le même titre de fenêtre que la fenêtre actuellement focalisée.

urgent

  Compare l'état d'urgence de la fenêtre. Peut être «le plus récent» ou «le plus ancien». Correspond à la fenêtre urgente la plus récente ou la plus ancienne, respectivement. (Les alias suivants sont également disponibles : plus récent, dernier, récent, premier)

workspace

  Compare le nom de l'espace de travail de l'espace de travail auquel appartient la fenêtre. Utilisez la valeur spéciale `__focused__` pour faire correspondre toutes les fenêtres de l'espace de travail actuellement ciblé.

con_mark

  Compare les marques définies pour ce container, voir [vim_like_marks]. Une correspondance est établie si l'une des marques du container correspond à la marque spécifiée.

con_id

  Compare l'ID de container interne à l'i3, que vous pouvez obtenir via l'interface IPC. Pratique pour la rédaction de scripts. Utilisez la valeur spéciale `__focused__` pour correspondre uniquement à la fenêtre actuellement focalisée.

floating

  Correspond uniquement aux fenêtres flottantes. Ce critère ne requiert aucune valeur.

tiling

  Correspond uniquement aux fenêtres pavées. Ce critère ne requiert aucune valeur.

Les critères `class`, `instance`, `role`, `title`, `workspace` et `mark` sont en fait des expressions régulières (PCRE). Voir `pcresyntax (3)` ou `perldoc perlre` pour savoir comment les utiliser.

### 6.1. Exécuter des applications (exec)

À quoi sert un gestionnaire de fenêtres si vous ne pouvez pas démarrer d’applications ? La commande exec démarre une application en passant la commande que vous spécifiez à un shell. Cela implique que vous pouvez utiliser le globbing (caractères génériques) et que les programmes seront recherchés dans votre `$PATH`.

Voir [command_chaining] pour savoir comment utiliser `;` (semicolon) et `,` (comma) : ils lient les commandes sur i3, donc vous devrez utiliser des guillemets (voir [exec_quoting]) si vous les utilisez dans vos commandes.

Syntaxe :

    exec [--no-startup-id] <command>

Exemple :

    # Start the GIMP
    bindsym $mod+g exec gimp

    # Start the terminal emulator urxvt which is not yet startup-notification-aware
    bindsym $mod+Return exec --no-startup-id urxvt

Le paramètre `--no-startup-id` désactive la prise en charge de la notification de démarrage pour cette commande exec particulière. Avec la notification de démarrage, i3 peut s'assurer qu'une fenêtre apparaît sur l'espace de travail sur lequel vous avez utilisé la commande exec. De plus, cela changera le curseur X11 en `watch` (horloge) pendant le lancement de l'application. Donc, si une application ne prend pas en charge les notifications de démarrage (la plupart des applications utilisant GTK et Qt semblent l'être), vous vous retrouverez avec un curseur en horloge pendant 60 secondes.

Si la commande à exécuter contient un `;` (point-virgule) et/ou un `,` (virgule), la commande entière doit être entre guillemets. Par exemple, pour avoir un raccourci clavier pour la commande shell `notify-send Hello, i3`, vous ajouteriez une entrée à votre fichier de configuration comme ceci :

Exemple :

    # Execute a command with a comma in it
    bindsym $mod+p exec "notify-send Hello, i3"

Si toutefois une commande avec une virgule et/ou un point-virgule nécessite elle-même des guillemets, vous devez échapper les guillemets internes avec des doubles barres obliques inverses, comme ceci :

Exemple :

    # Execute a command with a comma, semicolon and internal quotes
    bindsym $mod+p exec "notify-send \\"Hello, i3; from $USER\\""

### 6.2. Diviser les containers

La commande de division fait de la fenêtre courante un container divisé. Les containers divisés peuvent contenir plusieurs fenêtres. Selon la disposition du container divisé, les nouvelles fenêtres sont placées à droite de celle actuelle (splith) ou les nouvelles fenêtres sont placées sous la fenêtre actuelle (splitv).

Si vous appliquez cette commande à un container divisé avec la même orientation, rien ne se passera. Si vous utilisez une orientation différente, l’orientation du container divisé sera modifiée (s’il n’a pas plus d’une fenêtre). L'option `toggle` changera l'orientation du container divisé s'il contient une seule fenêtre. Sinon, cela fait de la fenêtre actuelle un container divisé avec une orientation opposée par rapport au container parent. Utilisez `layout toggle split` pour changer la disposition de tout container divisé de splitv à splith ou vice-versa. Vous pouvez également définir une séquence personnalisée de layout à parcourir avec `layout toggle`, voir [manipulating_layout].

Syntaxe :

    split vertical|horizontal|toggle

Exemple :

    bindsym $mod+v split vertical
    bindsym $mod+h split horizontal
    bindsym $mod+t split toggle

### 6.3. Manipuler la disposition

Utilisez `layout toggle split`, `layout stacking`, `layout tabbed`, `layout splitv` ou `layout splith` pour changer la disposition actuelle du container en splith/splitv, stacking, tabbed layout, splitv ou splith, respectivement.

Vous pouvez spécifier jusqu'à 4 layouts après `layout toggle` pour les parcourir. Chaque fois que la commande est exécutée, la mise en page spécifiée après celle actuellement active sera appliquée. Si la mise en page actuellement active n'est pas dans la liste, la première mise en page de la liste sera activée.

Pour afficher la fenêtre active en plein écran, utilisez `fullscreen enable` (ou `fullscreen enable global` pour le mode global), pour quitter l'un ou l'autre des modes plein écran, utilisez `fullscreen disable`, et pour basculer entre ces deux états, utilisez `fullscreen toggle` (ou `fullscreen toggle global`).

De la même façon, pour libérer une fenêtre, ou la paver, utilisez `floating enable` ou `floating disable` respectivement. (ou `floating toggle`):

Syntaxe :

    layout default|tabbed|stacking|splitv|splith
    layout toggle [split|all]
    layout toggle [split|tabbed|stacking|splitv|splith] [split|tabbed|stacking|splitv|splith]…

Exemples :

    bindsym $mod+s layout stacking
    bindsym $mod+l layout toggle split
    bindsym $mod+w layout tabbed

    # Toggle between stacking/tabbed/split:
    bindsym $mod+x layout toggle

    # Toggle between stacking/tabbed/splith/splitv:
    bindsym $mod+x layout toggle all

    # Toggle between stacking/tabbed/splith:
    bindsym $mod+x layout toggle stacking tabbed splith

    # Toggle between splitv/tabbed
    bindsym $mod+x layout toggle splitv tabbed

    # Toggle between last split layout/tabbed/stacking
    bindsym $mod+x layout toggle split tabbed stacking

    # Toggle fullscreen
    bindsym $mod+f fullscreen toggle

    # Toggle floating/tiling
    bindsym $mod+t floating toggle

### 6.4. Container et Focus

Pour passer le focus, utilisez la commande `focus`. Les options suivantes sont disponibles :

<criteria>

  Donne le focus au container qui correspond aux critères spécifiés. Voir [command_criteria].

left|right|up|down

  Donne le focus au container le plus proche dans la direction indiquée.

parent

  Donne le focus au container parent de celui actuellement focalisé.

child

  L'opposé de `focus parent`, donne lefocus au dernier container enfant focalisé.

next|prev

  Définit automatiquement le focus sur le container adjacent. Si `sibling` est spécifié, la commande focalisera le container frère exact, y compris les containers non pavés comme les containers divisé. Sinon, il s'agit d'une version automatique de `focus left|right|up|down` dans l'orientation du container parent.

floating

  Donne le focus au dernier container flottant focalisé.

tiling

  Donne le focus au dernier container pavé focalisé.

mode_toggle

  Navigue entre les containers flottants/pavés.

output

  Suivi d'une direction ou d'un moniteur, ceci donnera le focus au moniteur correspondant.

Syntaxe :

    <criteria> focus
    focus left|right|down|up
    focus parent|child|floating|tiling|mode_toggle
    focus next|prev [sibling]
    focus output left|right|up|down|primary|<output>

Exemples :

    # Focus firefox
    bindsym $mod+F1 [class="Firefox"] focus

    # Focus container on the left, bottom, top, right
    bindsym $mod+j focus left
    bindsym $mod+k focus down
    bindsym $mod+l focus up
    bindsym $mod+semicolon focus right

    # Focus parent container
    bindsym $mod+u focus parent

    # Focus last floating/tiling container
    bindsym $mod+g focus mode_toggle

    # Focus the output right to the current one
    bindsym $mod+x focus output right

    # Focus the big output
    bindsym $mod+x focus output HDMI-2

    # Focus the primary output
    bindsym $mod+x focus output primary

Notez que vous n'avez peut-être pas encore configuré de sortie principale. Pour ce faire, exécutez:

    xrandr --output <output> --primary

### 6.5. Déplacer les containers

Utilisez la commande `move` pour déplacer un container.

Syntaxe :

    # Moves the container into the given direction.
    # The optional pixel argument specifies how far the
    # container should be moved if it is floating and
    # defaults to 10 pixels.
    move <left|right|down|up> [<px> px]

    # Moves the container to the specified pos_x and pos_y
    # coordinates on the screen.
    move position <pos_x> [px] <pos_y> [px]

    # Moves the container to the center of the screen.
    # If 'absolute' is used, it is moved to the center of
    # all outputs.
    move [absolute] position center

    # Moves the container to the current position of the
    # mouse cursor. Only affects floating containers.
    move position mouse

Exemples :

    # Move container to the left, bottom, top, right
    bindsym $mod+j move left
    bindsym $mod+k move down
    bindsym $mod+l move up
    bindsym $mod+semicolon move right

    # Move container, but make floating containers
    # move more than the default
    bindsym $mod+j move left 20 px

    # Move floating container to the center of all outputs
    bindsym $mod+c move absolute position center

    # Move container to the current position of the cursor
    bindsym $mod+m move position mouse

### 6.6. Échanger les containers

Deux containers peuvent être échangés (c'est-à-dire se déplacer l'un vers l'autre) en utilisant la commande `swap`. Ils prendront la position et la géométrie du container avec lequel ils sont échangés.

Le premier container à participer à l'échange peut être sélectionné via le processus de critères de commande normal, la fenêtre focalisée étant la solution de secours habituelle si aucun critère n'est spécifié. Le deuxième container peut être sélectionné à l'aide de l'une des méthodes suivantes :

`id`

  L'ID X11 d'une fenêtre.

`con_id`

  L'ID du container i3.

`mark`

  Un container marqué, voir [vim_like_marks].

Notez que l'échange ne fonctionne pas avec tous les containers. Plus particulièrement, l'échange de containers qui ont une relation parent-enfant entre eux ne fonctionne pas.

Syntaxe :

    swap container with id|con_id|mark <arg>

Exemples :

    # Swaps the focused container with the container marked »swapee«.
    swap container with mark swapee

    # Swaps container marked »A« and »B«
    [con_mark="^A$"] swap container with mark B

### 6.7. Épingler une fenêtre flottante

Si vous voulez qu'une fenêtre "colle à la vitre", c'est-à-dire qu'elle reste à l'écran même si vous passez à un autre espace de travail, vous pouvez utiliser la commande `sticky`. Par exemple, cela peut être utile pour les blocs-notes, un lecteur multimédia ou une fenêtre de chat vidéo.

Notez que même si n'importe quelle fenêtre peut être rendue collante grâce à cette commande, elle ne prendra effet que si la fenêtre est flottante.

Syntaxe :

    sticky enable|disable|toggle

Exemples :

    # make a terminal sticky that was started as a notepad
    for_window [instance=notepad] sticky enable

### 6.8. Changer (renommer) un espace de travail / déplacer vers un espace de travail

Pour afficher un espace de travail spécifique, utilisez la commande `workspace`, suivie du numéro ou du nom de l'espace de travail. Utilisez l'option facultative `--no-auto-back-and-out` pour désactiver [workspace_auto_back_and_forth] sur cette commande uniquement.

Pour déplacer un container sur un espace de travail spécifique, utilisez `move container to workspace`.

Vous pouvez aussi afficher l'espace de travail suivant ou précédent avec les commandes `workspace next` et `workspace prev`, ce qui est pratique si vous activez les espaces de travail 1, 3, 4 et 9 et que vous désirez les afficher à la suite avec un simple raccourcis clavier. Pour restreindre ce comportement au moniteur actif, utilisez `workspace next_on_output` et `workspace prev_on_output`. De la même façon, vous pouvez utiliser `move container to workspace next`, `move container to workspace prev` pour déplacer un container sur l'espace de travail suivant/précédent et `move container to workspace current` (Le dernier n'a de sens que s'il est utilisé avec des critères).

`workspace next` fait défiler les espaces de travail numérotés ou nommés. Mais lorsqu'il atteint le dernier espace de travail numéroté/nommé, il recherche les espaces de travail nommés après avoir épuisé les espaces numérotés et recherche les espaces numérotés après avoir épuisé les espaces nommés.

Voir [move_to_outputs] pour savoir comment déplacer un container sur un moniteur RandR différent.

Les espaces de travail sont lus par i3bar selon Pango markup.

Pour revenir au dernier espace de travail focalisé, utilisez `workspace back_and_forth`; Grâce à ça, vous pouvez déplacer un container vers le dernier espace de travail focalisé avec la commande `move container to workspace back_and_forth`.

Syntaxe :

    workspace next|prev|next_on_output|prev_on_output
    workspace back_and_forth
    workspace [--no-auto-back-and-forth] <name>
    workspace [--no-auto-back-and-forth] number <name>

    move [--no-auto-back-and-forth] [window|container] [to] workspace <name>
    move [--no-auto-back-and-forth] [window|container] [to] workspace number <name>
    move [window|container] [to] workspace prev|next|current

Exemples :

    bindsym $mod+1 workspace 1
    bindsym $mod+2 workspace 2
    bindsym $mod+3 workspace 3:<span foreground="red">vim</span>
    ...

    bindsym $mod+Shift+1 move container to workspace 1
    bindsym $mod+Shift+2 move container to workspace 2
    ...

    # switch between the current and the previously focused one
    bindsym $mod+b workspace back_and_forth
    bindsym $mod+Shift+b move container to workspace back_and_forth

    # move the whole workspace to the next output
    bindsym $mod+x move workspace to output right

    # move firefox to current workspace
    bindsym $mod+F1 [class="Firefox"] move workspace current

#### 6.8.1. Nom des espaces de travail

Les espaces de travail sont identifiés par leur nom. Ainsi, au lieu d'utiliser des nombres dans la commande 'workspace', vous pouvez utiliser un nom :

Exemple :

    bindsym $mod+1 workspace mail
    ...

Si vous voulez un espace de travail avec un numéro et un nom, ajouter le numéro au début comme ceci :

Exemple :

    bindsym $mod+1 workspace 1: mail
    bindsym $mod+2 workspace 2: www
    ...

Notez que l'espace de travail sera vraiment nommé "1: mail". i3 traite les noms d'espace de travail commençant par un nombre d'une manière légèrement spéciale. Normalement, les espaces de travail nommés sont classés comme ils sont apparus. Lorsqu'ils commencent par un nombre, i3 les classe par ordre numérique. De plus, vous pourrez utiliser `workspace number 1` pour basculer vers l'espace de travail qui commence par le numéro 1, quel que soit son nom. Ceci est utile si vous modifiez le nom de l’espace de travail de manière dynamique. Pour combiner les deux commandes, vous pouvez utiliser `workspace number 1: mail` pour spécifier un nom par défaut s'il n'y a actuellement aucun espace de travail commençant par un "1".

#### 6.8.2. Renommer les espaces de travail

Vous pouvez renommer les espaces de travail. Cela peut être utile pour commencer avec les espaces de travail numérotés par défaut, faire votre travail et renommer les espaces de travail par la suite pour refléter ce qu'ils contiennent réellement. Vous pouvez également omettre l'ancien nom pour renommer l'espace de travail actuellement sélectionné. Ceci est pratique si vous souhaitez utiliser la commande renommer avec `i3-input`.

Syntaxe :

    rename workspace <old_name> to <new_name>
    rename workspace to <new_name>

Exemples :

    i3-msg 'rename workspace 5 to 6'
    i3-msg 'rename workspace 1 to "1: www"'
    i3-msg 'rename workspace "1: www" to "10: www"'
    i3-msg 'rename workspace to "2: mail"'
    bindsym $mod+r exec i3-input -F 'rename workspace to "%s"' -P 'New name: '

Si vous souhaitez renommer les espaces de travail à la demande tout en gardant la navigation stable, vous pouvez utiliser une configuration comme celle-ci :

Exemple :

    bindsym $mod+1 workspace number "1: www"
    bindsym $mod+2 workspace number "2: mail"
    ...

Si l'espace de travail n'existe pas, la commande `workspace number "1: mail"` va créer un espace de travail "1: mail".

Si un espace de travail avec le numéro 1 existe déjà, la commande basculera vers cet espace de travail et ignorera la partie de texte. Ainsi, même lorsque l’espace de travail a été renommé en «1: web», la commande ci-dessus y basculera toujours.

### 6.9. Déplacer un espace de travail sur un autre écran

Voir [move_to_outputs] pour découvrir comment déplacer un espace de travail sur un moniteur RandR différent.

### 6.10. Déplacer des containers/espaces de travail vers un écran RandR

Pour déplacer un container vers une autre sortie RandR (identifiée par des noms comme `LVDS1` ou `VGA1`) ou vers une sortie RandR identifiée par une direction spécifique (comme `left`, `right`, `up` ou `down`), il y a deux commandes :

Syntaxe :

    move container to output left|right|down|up|current|primary|<output>
    move workspace to output left|right|down|up|current|primary|<output>

Exemples :

    # Move the current workspace to the next output
    # (effectively toggles when you only have two outputs)
    bindsym $mod+x move workspace to output right

    # Put this window on the presentation output.
    bindsym $mod+x move container to output VGA1

    # Put this window on the primary output.
    bindsym $mod+x move container to output primary

Notez que vous n'avez peut-être pas encore configuré de sortie principale. Pour ce faire, exécutez :

    xrandr --output <output> --primary

### 6.11. Déplacer des containers/fenêtres vers une marque

Pour déplacer un container vers une marque (voir [vim_like_marks]), vous pouvez la commande suivante.

La fenêtre sera déplacée juste après le container marqué dans l'arborescence, c'est à dire qu'elle se terminera dans la même position que si vous aviez ouvert une nouvelle fenêtre lorsque le container marqué était sélectionné. Si la marque est sur un container divisé, la fenêtre apparaîtra comme un nouvel enfant après l'enfant actuellement focalisé dans ce container.

Syntaxe :

    move window|container to mark <mark>

Exemple :

    for_window [instance="tabme"] move window to mark target

### 6.12. Redimensionner les containers/fenêtres

Si vous désirez redimensionner un container ou une fenêtre depuis votre clavier, vous pouvez utiliser la commande `resize` :

Syntaxe :

    resize grow|shrink <direction> [<px> px [or <ppt> ppt]]
    resize set [width] <width> [px | ppt]
    resize set height <height> [px | ppt]
    resize set [width] <width> [px | ppt] [height] <height> [px | ppt]

La direction peut être `up`, `down`, `left` ou `right`. Ou peut être moins spécifique et utiliser `width` ou `height`, au quel cas, i3 prendra/rendra l'espace sur les autres containers. L'option additionnelle 'pixel' détermine la taille du redimensionnement (par défaut 10 pixels). L'argument facultatif 'ppt' signifie "points de pourcentage", et s'il est spécifié, il indique qu'un tiling container doit être agrandi ou réduit de autant de points, au lieu de la valeur `px`.

À propos de `resize set` : 0 pour <width> ou <height> signifie "ne pas redomensionner dans cette direction".

Il est recommandé d'utiliser une chaine de raccourcis pour le redimensionnement. Voir [binding_modes] et l'exemple dans la configuration d'i3.

Exemple :

    for_window [class="urxvt"] resize set 640 480

### 6.13. Rejoindre une fenêtre spécifique

Souvent, dans un environnement à plusieurs moniteurs, vous souhaitez accéder rapidement à une fenêtre spécifique. Par exemple, lorsque vous travaillez sur l’espace de travail 3, vous souhaiterez peut-être accéder à votre client de messagerie pour envoyer un e-mail à votre patron à propos d'un objectif important. Au lieu de savoir comment accéder à votre client de messagerie, il serait plus pratique d'avoir un raccourci. Vous pouvez utiliser la commande `focus` avec des critères pour cela.

Syntaxe :

    [class="class"] focus
    [title="title"] focus

Exemples :

    # Get me to the next open VIM instance
    bindsym $mod+a [class="urxvt" title="VIM"] focus

### 6.14. Marquer comme VIM (mark/goto)

Cette fonctionnalité est comme la fonction de saut : elle vous permet de sauter directement à une fenêtre spécifique (cela signifie passer à l'espace de travail approprié et définir le focus sur la fenêtre). Vous pouvez directement marquer une fenêtre spécifique avec une étiquette arbitraire et l'utiliser ensuite. Vous pouvez décocher l'étiquette de la même manière, à l'aide de la commande `unmark`. Si vous ne spécifiez pas d'étiquette, `unmark` supprime toutes les marques. Vous n'avez pas besoin de vous assurer que vos fenêtres ont des classes ou des titres uniques, et vous n'avez pas besoin de modifier votre fichier de configuration.

Comme la commande doit inclure l'étiquette avec laquelle vous souhaitez marquer la fenêtre, vous ne pouvez pas simplement la lier à une clé. `i3-input` est un outil créé à cet effet : il vous permet de saisir une commande et d'envoyer la commande à i3. Il peut également préfixer cette commande et afficher une invite personnalisée pour la boîte de dialogue de saisie.

L'option supplémentaire `--toggle` supprimera la marque si la fenêtre a déjà cette marque ou l'ajoutera autrement. Notez que vous devrez peut-être l'utiliser en combinaison avec `--add` (voir ci-dessous) car toute autre marque sera sinon supprimée.

L'indicateur `--replace` oblige i3 à supprimer toutes les marques existantes, ce qui est également le comportement par défaut. Vous pouvez utiliser l'indicateur `--add` pour mettre plus d'une marque sur une fenêtre.

Reportez-vous à [show_marks] si vous ne voulez pas que les marques soient affichées dans la décoration de la fenêtre.

Syntaxe :

    mark [--add|--replace] [--toggle] <identifier>
    [con_mark="identifier"] focus
    unmark <identifier>

Vous pouvez utiliser `i3-input` pour demander un nom de marque, puis utiliser les commandes `mark` et `focus` pour créer et accéder aux marques personnalisées :

Exemples :

    # read 1 character and mark the current window with this character
    bindsym $mod+m exec i3-input -F 'mark %s' -l 1 -P 'Mark: '

    # read 1 character and go to the window with the character
    bindsym $mod+g exec i3-input -F '[con_mark="%s"] focus' -l 1 -P 'Goto: '

Sinon, si vous ne voulez pas jouer avec `i3-input`, vous pouvez créer des raccourcis distincts pour un ensemble spécifique d'étiquettes, puis n'utiliser que ces étiquettes:

Exemple (dans un terminal) :

    # marks the focused container
    mark irssi

    # focus the container with the mark "irssi"
    '[con_mark="irssi"] focus'

    # remove the mark "irssi" from whichever container has it
    unmark irssi

    # remove all marks on all firefox windows
    [class="(?i)firefox"] unmark

### 6.15. Format du titre des fenêtres

Par défaut, i3 imprimera simplement le titre de la fenêtre X11. En utilisant `title_format`, cela peut être personnalisé en définissant le format sur la sortie souhaitée. Cette option supporte Pango markup :

`%title`

  Pour les fenêtres normales, il s'agit du titre de la fenêtre X11 (_NET_WM_NAME ou WM_NAME comme solution de secours). Lorsqu'il est utilisé sur des containers sans fenêtre (par exemple, un conteneur divisé dans un layout tabbed/stacked), ce sera la représentation arborescente du conteneur (par exemple, "H [xterm xterm]").

`%class`

  La class de la fenêtre (seconde partie de WM_CLASS). Correspond au critère `class`, voir [command_criteria].

`%instance`

  L'instance de la fenêtre (première partie de WM_CLASS). Correspond au critère `instance`, voir [command_criteria].

En utilisant la commande [for_window], vous pouvez modifier les titres de fenêtres en vous basant sur [command_criteria].

Syntaxe :

    title_format <format>

Exemples :

    # give the focused window a prefix
    bindsym $mod+p title_format "Important | %title"

    # print all window titles bold
    for_window [class=".*"] title_format "<b>%title</b>"

    # print window titles of firefox windows red
    for_window [class="(?i)firefox"] title_format "<span foreground='red'>%title</span>"

### 6.16. Icône de la barre de titre

Par défaut, i3 n'affiche pas l'icône de la fenêtre dans la barre de titre.
À partir de i3 v4.20, vous pouvez éventuellement activer les icônes de fenêtre pour des fenêtres spécifiques ou pour toutes les fenêtres (à l'aide de la directive [for_window]).

Syntaxe :

    title_window_icon yes|no|toggle
    title_window_icon padding|toggle px

Exemples :

    # show the window icon for the focused window to make it stand out
    bindsym $mod+p title_window_icon on

    # enable window icons for all windows
    for_window [all] title_window_icon on

    # enable window icons for all windows with extra horizontal padding
    for_window [all] title_window_icon padding 3px

### 6.17. Changer le style de bordure

Pour changer la bordure du client actuel, vous pouvez utiliser `border normal` pour utiliser la bordure normale (y compris le titre de la fenêtre), `border pixel 1` pour utiliser une bordure de 1 pixel (aucun titre de fenêtre) et `border none` pour supprimer toute bordure.

Il existe également `border toggle` qui permet de basculer les différents styles de bordure. L'argument pixel facultatif peut être utilisé pour spécifier la largeur de la bordure lors du passage aux styles normal et pixel.

Notez que «pixel» fait référence à un pixel logique. Sur les écrans HiDPI, un pixel logique peut être représenté par plusieurs pixels physiques, de sorte que le `pixel 1` peut ne pas nécessairement se traduire en une seule ligne de 1 pixel.

Syntaxe :

    border normal|pixel|toggle [<n>]
    border none

    # legacy syntax, equivalent to "border pixel 1"
    border 1pixel

Exemples :

    # use window title, but no border
    bindsym $mod+t border normal 0
    # use no window title and a thick border
    bindsym $mod+y border pixel 3
    # use neither window title nor border
    bindsym $mod+u border none

### 6.18. Activation de la journalisation

Comme décrit dans https://i3wm.org/docs/debugging.html, i3 peut se connecter à une mémoire tampon partagée, que vous pouvez vider en utilisant `i3-dump-log`. La commande `shmlog` vous permet d'activer ou de désactiver la journalisation de la mémoire partagée lors de l'exécution.

Notez que lorsque vous utilisez `shmlog <size_in_bytes>`, le log courant est supprimé et un nouveau est créé.

Syntaxe :

    shmlog <size_in_bytes>
    shmlog on|off|toggle

Exemples :

    # Enable/disable logging
    bindsym $mod+x shmlog toggle

    # or, from a terminal:
    # increase the shared memory log buffer to 50 MiB
    i3-msg shmlog $((50*1024*1024))

### 6.19. Activation de la journalisation du débogage

La commande `debuglog` vous permet d'activer ou de désactiver la journalisation du débogage lors de l'exécution. La journalisation du débogage est beaucoup plus détaillée que la journalisation sans débogage. Cette commande n'active pas la journalisation de la mémoire partagée (shmlog) et, en tant que telle, est très probablement utile en combinaison avec la commande [shmlog] décrite ci-dessus.

Syntaxe :

    debuglog on|off|toggle

Exemples :

    # Enable/disable logging
    bindsym $mod+x debuglog toggle

### 6.20. Recharger/Relancer/Quitter

Vous pouvez recharger i3 (relire le fichier de configuration) avec `reload`. Vous pouvez également redémarrer i3 avec la commande `restart` pour le sortir d'un état étrange (si cela devait arriver) ou pour effectuer une mise à niveau sans avoir à redémarrer votre session X. Pour quitter correctement i3, vous pouvez utiliser la commande `exit`, mais vous n’avez pas besoin de le faire (il suffit de tuer votre session X).

Exemples :

    bindsym $mod+Shift+r restart
    bindsym $mod+Shift+w reload
    bindsym $mod+Shift+e exit

### 6.21. Scratchpad

Il existe deux commandes pour utiliser n'importe quelle fenêtre existante comme scratchpad. `scratchpad move` déplacera une fenêtre vers l'espace de travail scratchpad. Cela le rendra invisible jusqu'à ce que vous le montriez à nouveau. Il n'y a aucun moyen d'ouvrir cet espace de travail. Au lieu de cela, lorsque vous utilisez `scratchpad show`, la fenêtre sera à nouveau affichée, sous la forme d'une fenêtre flottante, centrée sur votre espace de travail actuel (l'utilisation de `scratchpad show` sur une fenêtre de scratchpad visible le fera masqué à nouveau, vous pouvez donc avoir un raccourcis). Notez qu'il ne s'agit que d'une fenêtre flottante normale, donc si vous voulez "la supprimer du scratchpad", vous pouvez simplement la placer en mosaïque (`floating toggle`).

Comme son nom l'indique, c'est utile pour avoir une fenêtre avec votre éditeur préféré toujours à portée de main. Cependant, vous pouvez également l'utiliser pour d'autres applications fonctionnant en permanence que vous ne souhaitez pas voir tout le temps : votre lecteur de musique, alsamixer, peut-être même votre client de messagerie…?

Syntaxe :

    move scratchpad

    scratchpad show

Exemples :

    # Make the currently focused window a scratchpad
    bindsym $mod+Shift+minus move scratchpad

    # Show the first scratchpad window
    bindsym $mod+minus scratchpad show

    # Show the sup-mail scratchpad window, if any.
    bindsym mod4+s [title="^Sup ::"] scratchpad show

### 6.22. Nop / ne rien faire

i3 possède une commande qui ne fait rien, "no operation command" `nop` qui vous permet d'écraser un comportement par défaut. Cela peut être pratique pour, par exemple, désactiver le passage du focus avec le bouton central de la souris.

L'argument optionnel `comment` est ignoré, mais sera reporté dans le journal pour debogage.

Syntaxe :

    nop [<comment>]

Exemple :

    # Disable focus change for clicks on titlebars
    # with the middle mouse button
    bindsym button2 nop

### 6.23. Contrôler i3bar

Il existe deux options dans la configuration de chaque instance i3bar qui peuvent être modifiées pendant l'exécution en appelant une commande via i3. Les commandes `bar hidden_state` et `bar mode` permettent de paramétrer respectivement l'état hidden_state actuel et le mode de chaque barre. Il est également possible de basculer entre l'état hide et l'état show, ainsi qu'entre le mode dock et le mode hide. Chaque instance i3bar peut être contrôlée individuellement en spécifiant un bar_id, si aucun n'est donné, la commande est exécutée pour toutes les instances de barre.

Syntaxe :

    bar hidden_state hide|show|toggle [<bar_id>]

    bar mode dock|hide|invisible|toggle [<bar_id>]

Exemples :

    # Toggle between hide state and show state
    bindsym $mod+m bar hidden_state toggle

    # Toggle between dock mode and hide mode
    bindsym $mod+n bar mode toggle

    # Set the bar instance with id 'bar-1' to switch to hide mode
    bindsym $mod+b bar mode hide bar-1

    # Set the bar instance with id 'bar-1' to always stay hidden
    bindsym $mod+Shift+b bar mode invisible bar-1

### 6.24. Modifier les marges en cours de session

Les marges peuvent être modifiées lors de l'exécution avec la syntaxe de commande suivante :

Syntaxe :

    # Inner gaps: space between two adjacent windows (or split containers).
    gaps inner current|all set|plus|minus|toggle gap_size_in_px
    # Outer gaps: space along the screen edges.
    gaps outer|horizontal|vertical|top|right|bottom|left current|all set|plus|minus|toggle gap_size_in_px

Avec `current` ou `all`, vous pouvez modifier les marges uniquement pour l'espace de travail actuellement ciblé ou pour tous les espaces de travail actuellement existants (notez que cela n'affecte pas la configuration globale elle-même).

Exemples :

    gaps inner all set 20
    gaps outer current plus 5
    gaps horizontal current plus 40
    gaps outer current toggle 60

    for_window [class="vlc"] gaps inner 0, gaps outer 0

Pour modifier les marges pour toutes les fenêtres, consultez la directive de configuration [gaps].

## 7. Multi-écran

Comme vous avez pu le voir dans la liste des objectifs sur le site Web, i3 a été spécifiquement développé en gardant à l'esprit le support du multi-écran. Cette section explique comment gérer plusieurs moniteurs.

Lorsque vous n'avez qu'un seul moniteur, les choses sont simples. Vous commencez généralement avec l'espace de travail 1 sur votre moniteur et en ouvrez de nouveaux selon vos besoins.

Lorsque vous avez plus d'un moniteur, chaque moniteur aura un espace de travail initial. Le premier moniteur obtient 1, le second obtient 2 et un troisième possible en aura 3. Lorsque vous basculez vers un espace de travail sur un autre moniteur, i3 basculera vers ce moniteur, puis basculera vers l'espace de travail. De cette façon, vous n’avez pas besoin de raccourcis pour passer à un moniteur spécifique et vous n’avez pas besoin de vous rappeler où vous avez placé tel ou tel espace de travail. De nouveaux espaces de travail seront ouverts sur le moniteur actuellement actif. Il n'est pas possible d'avoir un moniteur sans espace de travail.

L'idée de rendre les espaces de travail 'globaux' est basée sur le constat que la plupart des utilisateurs disposent d'un ensemble très limité d'espaces de travail sur leurs moniteurs supplémentaires. Ils sont souvent utilisés pour une tâche spécifique (navigateur, shell) ou pour surveiller plusieurs choses (mail, IRC, syslog,…). Ainsi, utiliser un espace de travail sur un moniteur et «le reste» sur les autres moniteurs a souvent du sens. Cependant, comme vous pouvez créer un nombre illimité d'espaces de travail dans i3 et les lier à des écrans spécifiques, vous pouvez avoir l'approche «traditionnelle» d'avoir X espaces de travail par écran en modifiant votre configuration (en utilisant des modes, par exemple).

### 7.1. Configurer vos écrans

Pour vous aider à démarrer si vous n'avez jamais utilisé plusieurs moniteurs auparavant, voici un bref aperçu des options xrandr qui vous intéresseront probablement. Il est toujours utile d'avoir une vue d'ensemble de la configuration actuelle de l'écran. Exécutez simplement "xrandr" et vous obtiendrez une sortie comme celle-ci :

    $ xrandr
    Screen 0: minimum 320 x 200, current 1280 x 800, maximum 8192 x 8192
    VGA1 disconnected (normal left inverted right x axis y axis)
    LVDS1 connected 1280x800+0+0 (normal left inverted right x axis y axis) 261mm x 163mm
       1280x800       60.0*+   50.0
       1024x768       85.0     75.0     70.1     60.0
       832x624        74.6
       800x600        85.1     72.2     75.0     60.3     56.2
       640x480        85.0     72.8     75.0     59.9
       720x400        85.0
       640x400        85.1
       640x350        85.1

Plusieurs choses sont importantes ici : vous pouvez voir que `LVDS1` est connecté (bien sûr, c'est l'écran interne) mais que `VGA1` ne l'est pas. Si vous avez un moniteur connecté à l'un des ports mais que xrandr dit toujours «déconnecté», vous devriez vérifier votre câble, moniteur ou pilote graphique.

La résolution maximale que vous pouvez voir à la fin de la première ligne est la résolution combinée maximale de vos moniteurs. Par défaut, il est généralement trop bas et doit être augmenté en éditant `/etc/X11/xorg.conf`.

Donc, disons que vous avez connecté VGA1 et que vous souhaitez l'utiliser comme écran supplémentaire :

    xrandr --output VGA1 --auto --left-of LVDS1

Cette commande oblige xrandr à essayer de trouver la résolution native de l'appareil connecté à `VGA1` et la configure à gauche de votre écran plat interne. Lorsque vous exécutez à nouveau "xrandr", la sortie ressemble à ceci :

    $ xrandr
    Screen 0: minimum 320 x 200, current 2560 x 1024, maximum 8192 x 8192
    VGA1 connected 1280x1024+0+0 (normal left inverted right x axis y axis) 338mm x 270mm
       1280x1024      60.0*+   75.0
       1280x960       60.0
       1152x864       75.0
       1024x768       75.1     70.1     60.0
       832x624        74.6
       800x600        72.2     75.0     60.3     56.2
       640x480        72.8     75.0     66.7     60.0
       720x400        70.1
    LVDS1 connected 1280x800+1280+0 (normal left inverted right x axis y axis) 261mm x 163mm
       1280x800       60.0*+   50.0
       1024x768       85.0     75.0     70.1     60.0
       832x624        74.6
       800x600        85.1     72.2     75.0     60.3     56.2
       640x480        85.0     72.8     75.0     59.9
       720x400        85.0
       640x400        85.1
       640x350        85.1

Veuillez noter que i3 utilise exactement la même API que xrandr, donc il ne verra que ce que vous pouvez voir dans xrandr.

Voir aussi [presentations] pour plus d'exemples de configuration en mode multi-écran.

### 7.2. Configurations intéressantes en mode multi-écran

Il y a plusieurs choses à configurer dans i3 qui peuvent être intéressantes si vous avez plus d'un moniteur:

1. Vous pouvez spécifier quel espace de travail doit être placé sur quel écran. Cela vous permet d'avoir un ensemble d'espaces de travail différent lors du démarrage au lieu de 1 pour le premier moniteur, 2 pour le second et ainsi de suite. Voir [workspace_screen].

2. Si vous souhaitez que certaines applications s'ouvrent sur un écran plus grand (MPlayer, Firefox,…), vous pouvez les affecter à un espace de travail spécifique, voir [assign_workspace].

3. Si vous avez de nombreux espaces de travail sur de nombreux moniteurs, il peut être difficile de savoir quelle fenêtre sont placées et où. Aussi, vous pouvez utiliser des marques de type vim pour basculer rapidement entre les fenêtres. Voir [vim_like_marks].

4. Pour plus d'informations sur la façon de déplacer des espaces de travail existants entre des moniteurs, consultez [move_to_outputs].

## 8. i3 et le reste de vos applications

### 8.1. Afficher une barre d'état

Une chose très courante parmi les utilisateurs de gestionnaires de fenêtres exotiques est une barre d'état dans un coin de l'écran. C'est un remplacement souvent supérieur à l'approche "widget" que vous avez dans la barre des tâches d'un environnement de bureau traditionnel.

Si vous n’avez pas encore votre méthode préférée pour générer une telle barre d’état (scripts auto-écrits, conky,…), alors i3status est l’outil recommandé pour cette tâche. Il a été écrit en C dans le but d'utiliser le moins d'appels système possible pour réduire le temps de réveil de votre CPU. Parce que i3status ne produit que du texte, vous devez le combiner avec un autre outil, comme i3bar. Voir [status_command] pour savoir comment afficher i3status dans i3bar.

Quelle que soit l'application que vous utilisez pour afficher la barre d'état, vous voulez vous assurer qu'elle s'enregistre en tant que dock à l'aide du support EWMH. i3 positionnera la fenêtre en haut ou en bas de l'écran, en fonction de l'option définie par l'application. Avec i3bar, vous pouvez configurer sa position, voir [i3bar_position].

### 8.2. Réaliser des présentations (multi-monitor)

Lorsque vous donnez une présentation, vous voulez généralement que le public voie ce que vous voyez sur votre écran, puis passe par une série de diapositives (si la présentation est simple). Pour des présentations plus complexes, vous voudrez peut-être avoir des notes que vous seul pouvez voir sur votre écran, tandis que le public ne peut voir que les diapositives.

#### 8.2.1. Cas 1: tout le monde voit la même chose

C'est le cas simple. Vous connectez votre ordinateur au vidéoprojecteur, allumez les deux (ordinateur et vidéoprojecteur) et configurez votre serveur X pour cloner l'écran plat interne de votre ordinateur vers la sortie vidéo :

    xrandr --output VGA1 --mode 1024x768 --same-as LVDS1

i3 utilisera alors le sous-ensemble commun le plus bas de résolutions d'écran, le reste de votre écran ne sera pas touché (il affichera l'arrière-plan X). Donc, dans notre exemple, ce serait 1024x768 (mon ordinateur portable est en 1280x800).

#### 8.2.2. Cas 2: vous pouvez voir plus que votre public

Cette affaire est un peu plus délicat. Tout d'abord, vous devez configurer la sortie VGA quelque part près de votre écran plat interne, disons à droite :

    xrandr --output VGA1 --mode 1024x768 --right-of LVDS1

Maintenant, i3 va afficher un nouvel espace de travail (en fonction de vos paramètres) sur le nouvel écran et vous êtes en mode multi-moniteurs (voir [multi_monitor]).

Étant donné que i3 n'est pas un gestionnaire de fenêtres de composition, il n'est pas possible d'afficher une fenêtre sur deux écrans en même temps. Au lieu de cela, votre logiciel de présentation doit faire ce travail (c'est-à-dire ouvrir une fenêtre sur chaque écran).

### 8.3. Écran haute définition (aka HIDPI displays)

Voir https://wiki.archlinux.org/index.php/HiDPI pour plus de détails sur l'activation de la mise à l'échelle dans diverses parties du bureau Linux. i3 lira le DPI souhaité à partir de la propriété `Xft.dpi`. La propriété est définie par défaut sur 96 PPP, donc pour obtenir une mise à l'échelle de 200%, vous devez définir `Xft.dpi: 192` dans `~/.Xresources`.

Si vous êtes un utilisateur i3 de longue date et que vous venez de recevoir un nouveau moniteur, vérifiez que :

- Vous utilisez une police scalable (commençant par «pango:») dans votre configuration i3.

- Vous utilisez un émulateur de terminal qui prend en charge la mise à l'échelle. Vous pouvez passer temporairement à gnome-terminal, qui est connu pour prendre en charge la mise à l'échelle, jusqu'à ce que vous compreniez comment ajuster la taille de la police dans votre émulateur de terminal préféré.

auteur : Michael Stapelberg michael [at] i3wm [dot] org

< < fin de la traduction]
by arpinux.

## liens

- site officiel [GB]
- user guide officiel [GB]
- i3wm colorscheme configurator
- wiki debian-facile
- config perso SuShY
- config perso arpinux

↑