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

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 :

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 , 

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

Mise en page de la messagerie instantanée pour Skype

Afin de créer une disposition de messagerie instantanée pour les nouvelles versions de Skype, le code suivant peut être utilisé : 

xmonad.hs
}
myIMLayout = withIM (1%7) skype Grid
    where
      skype = And (ClassName "Skype") (Role "")

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.
  • 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 ⓘ]

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