Jump to content

# xmonad (Français)

From ArchWiki

État de la traduction: Cet article est la version francophone de Xmonad. Date de la dernière traduction: 2022-10-03. Vous pouvez aider à synchroniser la traduction s'il y a eu des changements dans la version anglaise.

Related articles

- xmobar
- Window manager (Français)

xmonad est un gestionnaire de fenêtres pour X. Les fenêtres sont disposées automatiquement de manière à recouvrir l'écran sans espace ni chevauchement, ce qui optimise l'utilisation de l'écran. Les fonctionnalités du gestionnaire de fenêtres sont accessibles à partir du clavier : une souris est optionnelle.

xmonad est écrit, configuré et extensible en Haskell. Des algorithmes de mise en page personnalisés, des liaisons de touches et d'autres extensions peuvent être écrits par l'utilisateur dans des fichiers de configuration.

Les mises en page sont appliquées dynamiquement, et différentes mises en page peuvent être utilisées sur chaque espace de travail. Xinerama est entièrement pris en charge, permettant aux fenêtres d'être empilées sur plusieurs écrans physiques.

## Installation

Installez le paquet xmonad qui fournit une configuration très basique, idéalement installez aussi xmonad-contrib pour une configuration de bureau plus utile ainsi que des algorithmes de tuilage, des configurations, des scripts, etc. supplémentaires.

Sinon, installez xmonad-gitAUR, la version de développement, avec quelques dépendances supplémentaires ; et de même xmonad-contrib-gitAUR.

Note N'oubliez pas d'exécuter `xmonad --recompile` après avoir mis à jour xmonad, sinon il pourrait avoir des problèmes pour trouver les bibliothèques partagées la prochaine fois que vous le lancerez. Pour automatiser ce processus, consultez #Problèmes pour trouver les bibliothèques partagées après la mise à jour.

## Démarrage

Lancez `xmonad` avec xinit.

Alternativement, sélectionnez Xmonad depuis le menu de la session dans le gestionnaire d'affichage de votre choix.

Assurez-vous que le paquet xterm est installé ou que vous avez changé l'émulateur de terminal dans la configuration. Sinon, vous ne pourrez rien faire dans xmonad.

Note Par défaut, xmonad ne définit pas de curseur, donc une "croix" est généralement affiché. Pour définir le pointeur de gauche attendu, consultez Cursor themes#Change X shaped default cursor.

## Configuration

Créez le répertoire `~/.xmonad` et le fichier `~/.xmonad/xmonad.hs` et éditez-le comme décrit ci-dessous.

Après avoir apporté des modifications à `~/.xmonad/xmonad.hs`, utilisez le raccourci `Mod+q` pour recompiler et faire en sorte qu'elles prennent effet.

Astuce La configuration par défaut de xmonad est tout à fait utilisable et elle est obtenue simplement en exécutant entièrement sans `xmonad.hs`.

Comme le fichier de configuration de xmonad est écrit en Haskell, les non-programmeurs peuvent avoir du mal à ajuster les paramètres. Pour un HOWTO détaillé et des exemples de configurations, nous vous renvoyons aux ressources suivantes :

- wiki de xmonad
- archive des configurations de xmonad
- FAQ de xmonad
- discussion sur le forum d'Arch Linux

La meilleure approche est de ne placer vos modifications et personnalisations que dans `~/.xmonad/xmonad.hs` et de l'écrire de telle sorte que tous les paramètres non définis soient récupérés dans la fonction intégrée def.

Pour ce faire, écrivez un `xmonad.hs` comme ceci :

    import XMonad

    main = xmonad def
        { terminal    = "urxvt"
        , modMask     = mod4Mask
        , borderWidth = 3
        }

Ceci remplace simplement le terminal et la largeur de bordure par défaut tout en laissant tous les autres paramètres à leurs valeurs par défaut (héritées de la valeur def de XConfig).

Lorsque les choses deviennent plus compliquées, il peut être pratique d'appeler les options de configuration par nom de fonction à l'intérieur de la fonction principale, et de les définir séparément dans leurs propres sections de votre `~/.xmonad/xmonad.hs`. Cela rend les grandes personnalisations comme la mise en page et les hooks de gestion plus faciles à visualiser et à maintenir.

Le `xmonad.hs` simple ci-dessus aurait pu être écrit comme ceci :

    import XMonad

    main = do
      xmonad $ def
        { terminal    = myTerminal
        , modMask     = myModMask
        , borderWidth = myBorderWidth
        }

    myTerminal    = "urxvt"
    myModMask     = mod4Mask -- Win key or Super_L
    myBorderWidth = 3

De plus, l'ordre au niveau supérieur (main, myTerminal, myModMask etc.), ou à l'intérieur des {} n'a pas d'importance en Haskell, tant que les importations viennent en premier.

L'exemple suivant est tiré du modèle de fichier de configuration de la version 0.9. Il s'agit d'un exemple des fonctions les plus courantes que l'on peut vouloir définir dans son bloc principal.

    {
      terminal           = myTerminal,
      focusFollowsMouse  = myFocusFollowsMouse,
      borderWidth        = myBorderWidth,
      modMask            = myModMask,
      -- numlockMask deprecated in 0.9.1
      -- numlockMask        = myNumlockMask,
      workspaces         = myWorkspaces,
      normalBorderColor  = myNormalBorderColor,
      focusedBorderColor = myFocusedBorderColor,

      -- key bindings
      keys               = myKeys,
      mouseBindings      = myMouseBindings,

      -- hooks, layouts
      layoutHook         = myLayout,
      manageHook         = myManageHook,
      handleEventHook    = myEventHook,
      logHook            = myLogHook,
      startupHook        = myStartupHook
    }

Le paquet lui-même comprend également un `xmonad.hs`, qui est le dernier exemple officiel `xmonad.hs` fourni avec le module Haskell xmonad comme exemple de la façon de tout remplacer. Il ne doit pas être utilisé comme un modèle de configuration, mais comme des exemples de parties que vous pouvez choisir d'utiliser dans votre propre configuration. Il est situé dans un répertoire dépendant de l'architecture et de la version dans `/usr/share/`. (par exemple, `find /usr/share -name xmonad.hs`).

### Une configuration de base du bureau

Dans xmonad-contrib se trouve une meilleure configuration par défaut pour une utilisation moyenne du bureau. Elle aide également à résoudre les problèmes de certains programmes modernes comme Chromium.

Elle peut être ajoutée comme suit

    import XMonad
    import XMonad.Config.Desktop

    main = xmonad desktopConfig
        { terminal    = "urxvt"
        , modMask     = mod4Mask
        }

## Quitter xmonad

Pour terminer la session xmonad en cours, appuyez sur `Mod+Shift+Q`. Par défaut, `Mod` est la touche `Alt`. Pour confirmer la sortie à chaque fois,

    xmonad.hs

    ...
    import XMonad.Prompt.ConfirmPrompt
    ...

    myKeys :: [(String, X ())]
    myKeys =
        ...
        ("M-S-q", confirmPrompt defaultXPConfig "exit" $ io exitSuccess)
        ...

## Trucs et astuces

### X-Selection-Paste

L'utilisation de xmonad centrée sur le clavier peut être accompagnée par un raccourci clavier pour coller la sélection de X.

De plus, il existe une fonction `pasteSelection` dans `XMonad.Util.Paste` qui peut être liée à une touche en utilisant une ligne comme :

    xmonad.hs

      import XMonad.Util.Paste -- Remember to include this line

      -- X-selection-paste buffer
      , ((0, xK_Insert), pasteSelection)

En appuyant sur la touche `Insert`, le tampon de la souris est maintenant collé dans la fenêtre active.

Attention

- Notez que `pasteSelection` utilise `getSelection` de `XMonad.Util.XSelection` et est donc héritier de ses défauts.
- `getSelection` "est fondamentalement implémenté de manière incorrecte et peut, entre autres modes d'échec possibles, provoquer un blocage ou un crash". Pour plus de détails, consultez [1].
- Ces erreurs sont généralement très rares en pratique, mais elles existent quand même.

Astuce Pour en savoir plus, consultez [2].

### Raccourcis clavier

Les raccourcis clavier par défaut sont listés dans xmonad(1).

### Utiliser des touches sans raccourcis

Si vous utilisez xmonad comme un gestionnaire de fenêtre autonome, vous pouvez modifier le fichier `xmonad.hs` pour ajouter des touches de clavier sans raccourcis. Il vous suffit de trouver le nom Xf86 de la touche (comme `XF86PowerDown`) et de le rechercher dans `/usr/include/X11/XF86keysym.h`. Cela vous donnera un code de touche (comme `0x1008FF2A`) que vous pouvez utiliser pour ajouter une ligne comme la suivante dans la liste des liaisons de touches de votre `xmonad.hs` :

     ((0,               0x1008FF2A), spawn "sudo systemctl suspend")

Vous pouvez également rechercher le nom de la touche Xf86 dans le module Graphics.X11.ExtraTypes.XF86, et utiliser sa constante `KeySym` (telle que `xF86XK_PowerDown`) au lieu d'un code de touche comme indiqué dans l'exemple précédent. Vous devrez également importer le module dans votre `xmonad.hs` pour que la constante key soit disponible. Consultez un exemple plus élaboré avec plusieurs clés au format utilisé par la fonction `additionalKeys` :

    import Graphics.X11.ExtraTypes.XF86

    ...

    myKeys = [
       ((0, xF86XK_PowerDown),         spawn "sudo systemctl suspend")
     , ((0, xF86XK_AudioRaiseVolume),  spawn "amixer -D pulse sset Master 10%+")
     , ((0, xF86XK_AudioLowerVolume),  spawn "amixer -D pulse sset Master 10%-")
     , ((0, xF86XK_AudioMute),         spawn "amixer -D pulse sset Master toggle")
     , ((0, xF86XK_MonBrightnessUp),   spawn "brightnessctl set +10%")
     , ((0, xF86XK_MonBrightnessDown), spawn "brightnessctl set 10%-")
     ...
     ]

### Exécuter des actions X () en touchant le bord de votre écran avec votre souris

Avec XMonad.Hooks.ScreenCorners, les utilisateurs peuvent avoir des coins d'écran de type KDE avec XMonad.

#### Changer d'espace de travail avec ScreenCorners (semblable à KDE)

Définissez une série d'opérations dans le startupHook :

    xmonad.hs

    ...
    import XMonad.Hooks.ScreenCorners
    ...

    mystartupHook = do
    ...
    ... example ...
         addScreenCorners [ (SCLowerLeft,  prevWS)
                            , (SCLowerRight, nextWS)
                            , (SCUpperLeft, spawnSelected' myAppGrid)
                            , (SCUpperRight, goToSelected $ mygridConfig' myColorizer)
                          ]
    ...

Puis ajouter screenCornerEventHook à handleEventHook :

       myConfig = def {
       ...
           handleEventHook = ... <+> screenCornerEventHook <+> ...
       ...
       }

Enfin, ajoutez screenCornerLayoutHook :

       ...
       myLayoutHook = screenCornerLayoutHook $ ......
       ...
       myConfig = def {
       ...
       layoutHook = myLayoutHook
       ...
       }

Note

- Cette extension ajoute des coins d'écran de type KDE à XMonad.
- En déplaçant votre curseur dans l'un de vos coins d'écran, vous pouvez déclencher une action X (), par exemple XMonad.Actions.GridSelect.goToSelected ou XMonad.Actions.CycleWS.nextWS, etc.

### Augmenter le nombre d'espaces de travail

Par défaut, xmonad utilise un ensemble de 9 espaces de travail. Vous pouvez changer cela en modifiant le paramètre workspaces :

    xmonad.hs

    import XMonad
    import XMonad.Util.EZConfig (additionalKeys)

    main=do
      xmonad $ def
        { ...
        , workspaces = myWorkspaces
        , ...
        } `additionalKeys` myAdditionalKeys

    myWorkspaces = ["1","2","3","4","5","6","7","8","9"] ++ (map snd myExtraWorkspaces) -- you can customize the names of the default workspaces by changing the list

    myExtraWorkspaces = [(xK_0, "0")] -- list of (key, name)

    myAdditionalKeys =
        [ -- ... your other hotkeys ...
        ] ++ [
            ((myModMask, key), (windows $ W.greedyView ws))
            | (key, ws) <- myExtraWorkspaces
        ] ++ [
            ((myModMask .|. shiftMask, key), (windows $ W.shift ws))
            | (key, ws) <- myExtraWorkspaces
        ]

### Vérification des raccourcis clavier en double

Le paquet XMonad.Util.EZConfig fournit une fonction `checkKeymap` pour vérifier les raccourcis en double, sinon ceux-ci seront ignorés.

    xmonad.hs

    main = xmonad $ myConfig

    myKeymap = [("S-M-c", kill), ...]
    myConfig = def {
        ...
        startupHook = do
            return () >> checkKeymap myConfig myKeymap
            ...other operation you defined here...
        ...
    } `additionalKeysP` myKeymap

Note

- `return ()` dans l'exemple ci-dessus est très important ! Sinon, vous pourriez rencontrer des problèmes de récursion mutuelle infinie.
- `return ()` introduit suffisamment de paresse pour sortir de l'impasse : la définition de myConfig dépend de la définition de startupHook, qui dépend de la définition de myConfig, ..., etc.

### Faire de la place pour les docks/panneaux/plateaux (Xmobar, Tint2, Conky, etc)

Enveloppez vos mises en page avec avoidStruts de XMonad.Hooks.ManageDocks pour un espacement automatique des docks/panneaux/tablettes :

    import XMonad
    import XMonad.Hooks.ManageDocks

    main=do
      xmonad $ docks def
        { ...
        , layoutHook=avoidStruts $ layoutHook def
        , manageHook=manageHook def <+> manageDocks
        , ...
        }

Si jamais vous voulez basculer les écarts, cette action peut être ajoutée à vos liaisons de touches :

    ,((modMask x, xK_b ), sendMessage ToggleStruts)

### Ajout de balises aux fenêtres

Avec XMonad.Actions.TagWindows, les utilisateurs peuvent opérer sur des fenêtres ayant les mêmes balises.

    xmonad.hs

    ...
    import XMonad.Actions.TagWindows
    ...

    myKeys =
    ... other key bindings ...
    -- Tag
             --  , ("M-C-t", withFocused (addTag "abc")) -- add a specific tag "abc"
             --  , ("M-C-d", withFocused (delTag "abc")) -- delete the tag "abc" from the focused window
             --  , ("M-C-h", withTaggedGlobalP "abc" shiftHere) -- shift windows with tag "abc" here
                 , ("M-C-a", tagPrompt defaultXPConfig $ withFocused . addTag ) -- prompt for inputs of tag names
                 , ("M-C-h", tagPrompt defaultXPConfig (`withTaggedGlobalP` shiftHere))  -- shift windows with user defined tags (input) here
                 , ("M-C-d", tagDelPrompt defaultXPConfig)  -- delete a user-defined tag (input)
                 , ("M-C-t", tagPrompt defaultXPConfig  focusUpTaggedGlobal)  -- switch between windows in all workspaces with user-defined tags (input)
                 , ("M-C-f", tagPrompt defaultXPConfig (`withTaggedGlobal` float)) -- float windows with user-defined tags (input)

### Espaces de taille égale entre les fenêtres

Si votre objectif est d'avoir des espaces de taille égale entre les fenêtres individuelles et l'écran, le code suivant ne fonctionnera pas comme prévu :

    layoutHook = spacing 10 $ Tall (1 (3/100) (1/2)) ||| Full

Ainsi, chaque fenêtre dispose de son propre espacement dans chaque direction. Si vous avez deux fenêtres côte à côte, l'espacement au milieu sera combiné, créant un espace deux fois plus grand que nécessaire.

Une solution consiste à spécifier à la fois un espacement pour l'écran et pour la fenêtre, mais à n'utiliser que les marges supérieure et gauche pour l'écran et les marges inférieure et droite pour les fenêtres. Pour ce faire, modifiez le code ci-dessus en :

    layoutHook = spacingRaw False (Border 10 0 10 0) True (Border 0 10 0 10) True $ Tall (1 (3/100) (1/2)) ||| Full

### Utilisation de xmobar avec xmonad

xmobar est une barre de texte légère et minimaliste, conçue pour fonctionner avec xmonad. Pour utiliser xmobar avec xmonad, vous aurez besoin de deux paquets en plus du paquet xmonad. Ces paquets sont xmonad-contrib et xmobar, ou vous pouvez utiliser xmobar-gitAUR.

Ici, nous allons lancer xmobar depuis xmonad, qui recharge xmobar à chaque fois que vous rechargez xmonad.

Ouvrez `~/.xmonad/xmonad.hs` dans votre éditeur préféré, et choisissez l'une des deux options suivantes :

#### Rapide, moins flexible

Note Il existe également dzen2 que vous pouvez substituer à xmobar dans les deux cas.

Importations courantes :

    import XMonad
    import XMonad.Hooks.DynamicLog

L'action xmobar lance xmobar et renvoie une configuration modifiée qui inclut toutes les options décrites dans #Plus configurable.

    main = xmonad =<< xmobar def { modMask = mod4Mask {- ou toute autre configuration ici ... -}}

#### Plus configurable

À partir de xmonad(-contrib) 0.9, il existe une nouvelle fonction statusBar dans XMonad.Hooks.DynamicLog. Elle vous permet d'utiliser votre propre configuration pour :

- la commande utilisée pour exécuter la barre
- Le PP qui détermine ce qui est écrit dans la barre.
- La liaison des touches pour basculer l'écart de la barre.

L'exemple suivant montre comment l'utiliser :

    ~/.xmonad/xmonad.hs

    -- Imports.
    import XMonad
    import XMonad.Hooks.DynamicLog

    -- The main function.
    main = xmonad =<< statusBar myBar myPP toggleStrutsKey myConfig

    -- Command to launch the bar.
    myBar = "xmobar"

    -- Custom PP, configure it as you like. It determines what is being written to the bar.
    myPP = xmobarPP { ppCurrent = xmobarColor "#429942" "" . wrap "<" ">" }

    -- Key binding to toggle the gap for the bar.
    toggleStrutsKey XConfig {XMonad.modMask = modMask} = (modMask, xK_b)

    -- Main configuration, override the defaults to your liking.
    myConfig = def { modMask = mod4Mask }

#### Vérifier la configuration de XMobar

Le modèle et le xmobarrc par défaut contiennent ceci.

Enfin, ouvrez `~/.xmobarrc` et vérifiez que vous avez `StdinReader` dans le modèle et lancez le plugin. Par exemple

    ~/.xmobarrc

    Config { ...
           , commands = [ Run StdinReader .... ]
             ...
           , template = " %StdinReader% ... "
           }

Maintenant, tout ce que vous avez à faire est de démarrer, ou de redémarrer, xmonad.

### Contrôler xmonad avec des scripts externes

Voici quelques façons de le faire ,

- utiliser l'extension xmonad suivante, XMonad.Hooks.ServerMode.

- simuler des événements de pression de touche en utilisant xdotool ou des programmes similaires. Consultez ce fil de discussion sur les forums Ubuntu. La commande suivante simulerait l'appui sur la touche `Super+n` :

    xdotool key Super+n

- wmctrl -Si vous avez configuré desktopConfig ou EwmhDesktops, c'est un utilitaire standard très facile à utiliser.

### Lancement d'un autre gestionnaire de fenêtres dans xmonad

Si vous utilisez xmonad-gitAUR, à partir de Janvier 2011, vous pouvez redémarrer un autre gestionnaire de fenêtre depuis xmonad. Vous devez juste écrire un petit script, et ajouter des choses à votre `~/.xmonad/xmonad.hs`. Voici le script.

    ~/bin/obtoxmd

    #!/bin/sh
    openbox
    xmonad

Et voici les modifications que vous devez ajouter à votre `~/.xmonad/xmonad.hs` :

    ~/.xmonad/xmonad.hs

    import XMonad
    --You need to add this import
    import XMonad.Util.Replace

    main do
        -- And this "replace"
        replace
        xmonad $ def
        {
        --Add the usual here
        }

Vous devez également ajouter le key binding suivant :

    ~/xmonad/xmonad.hs

    --Ajouter un raccourci clavier comme suit :
    ((modm .|. shiftMask, xK_o ), restart "/home/abijr/bin/obtoxmd" True)

N'oubliez pas d'ajouter une virgule avant ou après et de changer le chemin pour votre chemin de script réel. Maintenant, il suffit de `Mod+q` (redémarrez xmonad pour rafraîchir la configuration), puis tapez `Mod+Shift+o` et vous devriez avoir Openbox en fonctionnement avec les mêmes fenêtres ouvertes que dans xmonad. Pour revenir à xmonad, il vous suffit de quitter Openbox. Voici un lien vers `~/.xmonad/xmonad.hs` d'adamvo qui utilise cette configuration Adamvo's xmonad.hs

### KDE et xmonad

Le wiki xmonad contient des instructions sur la façon de lancer xmonad dans KDE.

C'est aussi une bonne idée de définir un raccourci clavier global dans KDE pour lancer xmonad au cas où il serait accidentellement tué ou fermé.

#### Désactiver plasmashell

Vous pourriez vouloir désactiver plasmashell (le truc de KDE5 responsable du fond d'écran, de la barre des tâches, de la zone de notification, etc.)

      cp /etc/xdg/autostart/plasmashell.desktop ~/.config/autostart/

Puis éditez `~/.config/autostart/plasmashell.desktop` et remplacez `Exec=plasmashell` par `Exec=`. Le résultat ressemblera à ceci :

    ~/.config/autostart/plasmashell.desktop

    [Desktop Entry]
    Exec=
    Name=Plasma Desktop Workspace
    ... # plus de choses

### Exemples de configurations

Vous trouverez ci-dessous quelques exemples de configurations provenant d'autres utilisateurs de xmonad. N'hésitez pas à ajouter des liens vers les vôtres.

- brisbin33 : : simple, utile, lisible : : config screenshot
- jelly : : Configuration avec invite, différentes mises en page, twinview avec xmobar : : xmonad.hs
- MrElendig : : Configuration simple, avec xmobar : : xmonad.hs, .xmobarrc, screenshot.
- thayer : : Une configuration minimale pour la souris, idéale pour les netbooks : : configs screenshot
- vicfryzel : : Une configuration de xmonad belle et utilisable, avec la configuration de xmobar, xinitrc, dmenu, et d'autres scripts qui rendent xmonad plus utilisable : : git repository, screenshot.
- vogt : : Regardez la configuration d'adamvo et beaucoup d'autres dans l'archive officielle Xmonad/Config.
- wulax : : Exemple d'utilisation de xmonad dans Xfce. : : xmonad.hs, screenshot.
- alex-courtis : : Un xmonad propre, xmobar, media keys, screenshot, j4/dmenu ; polices rendues au DPI rapporté par le moniteur : : xmonad.hs, screenshot.
- TobbeBob123 : : Config pour TobbeBob123 où vous pouvez voir tous les keybinding avec un simple keybinding (`Mod4+s`). Si vous voulez un Xmonad complet avec un thème et tout ce que vous voyez dans l'image en lien. Vous pouvez utiliser le script appelé TobbeOS. : : TobbeOS. Xmonad repository, Screenshot[dead link 2025-08-16—HTTP 404].
- AzureOrange : : Configuration divisée pour xmonad construite avec stack (gaps, layouts, scratchpads, gestion des fenêtres et avalement des fenêtres etc.) avec xmobar, trayer et dmenu. : : xmonad.hs screenshot[dead link 2023-05-06—HTTP 404]

## Dépannage

### Xfce 4 et xmonad

Utilisez `xfceConfig` au lieu de `def` après avoir importé `XMonad.Config.Xfce` dans `~/.xmonad/xmonad.hs`, par exemple en adaptant la configuration minimale ci-dessus :

    import XMonad
    Importation de XMonad.Config.Xfce

    main = xmonad xfceConfig
        { terminal = "urxvt"
        , modMask = mod4Mask
        }

Ajoutez également une entrée dans Settings > Session and Startup > Application Autostart qui exécute `xmonad --replace`.

### Manque xmonad-x86_64-linux

xmonad devrait automatiquement créer le fichier `xmonad-x86_64-linux` (dans `~/.xmonad/`). Si ce n'est pas le cas, récupérez un fichier de configuration sur le xmonad wiki ou créez votre own. Mettez le fichier `.hs` et tous les autres fichiers dans `~/.xmonad/` et lancez cette commande depuis le répertoire :

    xmonad --recompile

Maintenant vous devriez consulter le fichier.

Note Une raison pour laquelle vous pouvez obtenir un message d'erreur disant que xmonad-x86_64-linux est manquant est que xmonad-contrib n'est pas installé.

### Problèmes avec les applications Java

Si vous rencontrez des problèmes, comme des fenêtres d'applications Java qui ne se redimensionnent pas, ou des menus qui se ferment immédiatement après un clic, consultez Java#Gray window, applications not resizing with WM, menus immediately closing.

### Espace vide en bas de gvim ou des terminaux

Consultez Vim#Empty space at the bottom of gVim windows pour une solution qui fait correspondre la zone à la couleur de fond.

Pour rxvt-unicode, vous pouvez utiliser rxvt-unicode-patchedAUR[broken link: package not found].

Vous pouvez également configurer xmonad pour qu'il respecte les indications de taille, mais cela laissera un vide à la place. Consultez la documentation sur Xmonad.Layout.LayoutHints.

### Chromium/Chrome ne passe pas en plein écran

Si Chrome ne passe pas en plein écran lorsque vous appuyez sur `F11`, vous pouvez utiliser l'extension XMonad.Hooks.EwmhDesktops qui se trouve dans le paquet xmonad-contrib. Ajoutez simplement l'instruction `import` à votre `~/.xmonad/xmonad.hs` :

    import XMonad.Hooks.EwmhDesktops

puis ajoutez `ewmhFullscreen . ewmh` à l'endroit approprié ; par exemple :

    ...
            main = xmonad $ ewmhFullscreen . ewmh $ def
    ...

Après une recompilation/redémarrage de xmonad, Chrome devrait maintenant répondre à `F11` (plein écran) comme prévu.

### Multitouch / touchegg

Touchégg interroge le gestionnaire de fenêtre pour la propriété `_NET_CLIENT_LIST`. (afin de récupérer la liste des fenêtres sur lesquelles il doit écouter les événements souris). Par défaut, xmonad ne fournit pas cette propriété. Pour l'activer, utilisez l'extension XMonad.Hooks.EwmhDesktops trouvée dans le paquet xmonad-contrib.

### Problèmes raccourcis avec une disposition de clavier azerty

Les utilisateurs disposant d'un clavier à disposition azerty peuvent rencontrer des problèmes avec certains raccourcis. L'utilisation du paquet XMonad.Config.Azerty résoudra ce problème.

### GNOME 3 mod4+p change la configuration de l'affichage au lieu de lancer dmenu

Si vous n'avez pas besoin de la possibilité de changer la configuration de l'affichage dans le centre de contrôle de gnome, exécutez simplement

    dconf write /org/gnome/settings-daemon/plugins/xrandr/active false

en tant qu'utilisateur, pour désactiver le plugin xrandr qui récupère `Super+p`.

### Chrome/Chromium n'affichant pas la couleur de bordure de fenêtre définie

Les fenêtres des navigateurs Chrome et Chromium n'ont pas la couleur de bordure définie par défaut mais une couleur transparente et floue. Ce problème est connu depuis longtemps time mais facile à corriger. L'activation de l'option "Utiliser la barre de titre et les bordures du système" dans les options du navigateur devrait le résoudre immédiatement.

### Problèmes de bordure focalisée dans VirtualBox

Un problème connu avec Virtualbox (Ticket #6479) peut causer des problèmes avec la bordure de la fenêtre focalisée. Une solution peut être trouvée en installant un gestionnaire de composition comme xcompmgr qui remplace le comportement incorrect de vboxvideo.

### Jeux Steam (Half-Life, Left 4 Dead, ...) et xmonad

Il semble y avoir quelques problèmes avec xmonad et les jeux basés sur le moteur Source comme Half-Life. S'ils ne démarrent pas ou restent bloqués avec un écran noir, une solution de contournement est de les démarrer en mode fenêtré. Pour ce faire, faites un clic droit sur le jeu dans votre bibliothèque Steam et choisissez Propriétés, cliquez sur Options de lancement et entrez [3] :

    -windowed

Une autre solution consiste à faire flotter la fenêtre du jeu à l'aide du hook manage. Par exemple, la ligne suivante peut être utilisée pour Half-Life :

     className = ? "hl_linux" --> doFloat

Ceci peut également être contourné en faisant en sorte que xmonad prête attention aux indications de l'EWMH et en incluant son hook fullscreen [4] :

      main = xmonad $ ewmh def{ handleEventHook =
               handleEventHook def <+> fullscreenEventHook }

Ceci a quelques autres effets et le fait se comporter de manière plus proche des applications plein écran dans d'autres WMs.

### LibreOffice - le focus bascule entre la fenêtre principale et la boîte de dialogue

L'interface utilisateur de LibreOffice utilise par défaut le moteur Gtk en dehors d'un environnement de bureau. Cela peut causer des problèmes avec certaines configurations de xmonad, ce qui fait que le focus bascule rapidement entre la fenêtre principale de LibreOffice et toute fenêtre de dialogue ouverte de LibreOffice. Verrouillage effectif de l'application. Dans ce cas, la variable d'environnement `SAL_USE_VCLPLUGIN` peut être définie pour forcer explicitement LibreOffice à utiliser un autre thème d'interface utilisateur comme indiqué dans LibreOffice#Theme. Par exemple

      export SAL_USE_VCLPLUGIN=gen lowriter

pour utiliser l'interface utilisateur générale (QT).

### IntelliJ IDEA et xmonad

#### Fenêtres de dialogue

IntelliJ IDEA prend mieux en charge les gestionnaires de fenêtres en pavage. Cependant, il y a encore quelques problèmes ennuyeux, dont certains ont des solutions simples :

- La fenêtre de dialogue Find In Files se ferme immédiatement si le pointeur de la souris sort des limites de la fenêtre de dialogue. Cela ne se produit qu'avec la fenêtre de dialogue Find In Files, et n'est pas reproductible avec la fenêtre de dialogue Navigate to.... Le comportement de Find In Files est attendu, en supposant que la logique par défaut de xmonad est focus follows mouse. La fenêtre Find In Files se ferme lorsqu'elle perd le focus sur tous les systèmes.

Solution : Vous pouvez le changer en "épinglant" la fenêtre contextuelle — il y a un bouton correspondant dans le coin supérieur droit [5].

- Lors de l'affichage des fichiers modifiés entre les commits Git (en utilisant la boîte de dialogue Changes Between aaaa and local version bbbb), la fenêtre avec les différences au niveau du fichier s'ouvre derrière la fenêtre de dialogue.

  'Solution : Inconnue

### Problèmes pour trouver les bibliothèques partagées après la mise à jour

L'exécutable de xmonad est situé dans `~/.xmonad/`. Après la mise à jour de xmonad, un ancien exécutable peut persister et doit dans ce cas être supprimé pour que xmonad compile un nouvel exécutable. Alternativement, utilisez `xmonad --recompile`.

La recompilation peut être automatisée en ajoutant un hook pacman comme le suivant à `/etc/pacman.d/hooks/xmonad.hook`. (vous devrez peut-être d'abord créer le répertoire `hooks`) :

    [Trigger]
    Operation = Upgrade
    Type = Package
    Target = xmonad

    [Action]
    Description = Recompiling xmonad...
    When = PostTransaction
    Exec = /usr/bin/sudo -u YOUR_USERNAME /usr/bin/xmonad --recompile

Où `YOUR_USERNAME` est le nom d'utilisateur à partir duquel vous exécutez xmonad.

Dans le cas où `xmonad --recompile` ne trouve aucun module (y compris `XMonad` lui-même), essayez de régénérer le cache de la base de données des paquets

    sudo ghc-pkg recache

### Décorations cassées/manquantes de XMonad.Prompt et des fenêtres

XMonad utilise par défaut la police `-misc-fixed-*-*-*-*-10-*-*-*-*-*-*-*`. [6]. Si cette police est absente, ces fenêtres ne s'affichent pas du tout. La solution la plus simple est d'installer xorg-fonts-misc.

## Voir aussi

- xmonad - Le site officiel de xmonad
- xmonad.hs - Modèle xmonad.hs
- xmonad : une visite guidée
- dzen - Programme de messagerie et de notification d'usage général
- dmenu - Menu dynamique X pour le lancement rapide de programmes
- Comparison of tiling window managers - Article anglais du wiki fournissant une vue d'ensemble des principaux gestionnaires de fenêtres en pavage
- Partagez votre bureau xmonad]
- discussion sur le bidouillage de xmonad
- xmonad-log-applet - Une applet pour le panneau GNOME, MATE ou Xfce.

Category:

- Tiling WMs (Français)

Hidden categories:

- Pages with dead links
- Pages with broken package links

xmonad (Français)
Add topic