Faisant suite à ce topic :http://forum.debian-fr.org/viewtopic.php?f=8&t=20904&hilit=xmonad,
une courte description de l’utilisation d’un tiling wm en mode grand débutant,
à savoir intégré dans un environnement de bureau
en remplacement du gestionnaire de fenêtre de ce dernier,
Pour ceux qui n’ont jamais entendu parler de tiling wm, ce sont des gestionnaires de fenêtre qui utilisent en permanence tout l’espace disponible sur l’écran en réarrangeant dynamiquement la disposition quand de nouvelles fenêtres apparaîssent ou disparaîssent.
l’utilisateur peut aussi changer lui-même la disposition et en trois frappes de clavier
réarranger tout son/ses écran(s) à sa convenance.
j’ai choisi xmonad intégré dans l’environnment de bureau installé par défaut par Debian : Gnome.
Mais sachez que c’est tout aussi possible de le faire dans KDE et Xfce.
Ces deux liens sont en anglais mais contiennent de précieuses informations :
http://www.haskell.org/haskellwiki/Xmonad/Using_xmonad_in_KDE
http://www.haskell.org/haskellwiki/Xmonad/Using_xmonad_in_XFCE
Pour pouvoir être pleinement et simplement intégré dans un environnement de bureau,
Xmonad à besoin de ses bibliothèques d’extensions et de leur compilateur,
ceci prend de la place sur le disque mais n’alourdi pas le système.
Je vous propose d’installer par les sources, j’utilise celle de chez Sid mais ça devrait
se passer pareil avec celle de chez Lenny.
En root :
# aptitude install dpkg-dev(décompresse les sources après qu’ apt-get source les a ramenées)
# aptitude install ghc6(le compilateur, c’est le gros morceau)
Quelques bibliothèques :
[code]# aptitude install libghc6-mtl-dev
aptitude install libghc6-utf-8-string-dev
aptitude install libghc6-x11-dev
aptitude install libghc6-x11-xft-dev[/code]
[code]# aptitude install dwm-tools
aptitude install xdotool[/code](des petits utilitaires qui nous serviront plus tard)
Retour en simple utilisateur, puis :
$ mkdir sources && cd sources
$ apt-get source xmonad
$ apt-get source xmonad-contrib
Vous obtiennez un répertoire
xmonad-n°_de_version et xmonad-contrib-n°_de_version qui constituent les sources décompressées, ce sont eux qui nous intéressent.
L’étape suivante est facultative, elle est même inutile si vous n’avez pas réglé vos panels
pour qu’ils se cachent automatiquement lorsqu’ils ne sont pas utilisés.
Dans ce cas passez directement à Compilation
Je vous propose de modifier très légèrement un des modules avant la compilation,
afin que quand les panels sont en mode auto-hide (disparaîssent automatiquement quand non utilisé), ils apparaîssent par dessus les autres fenêtre quand on les appelle
(le comportement par défaut ne prend pas en compte le mode auto-hide et les panels
apparaîssaient en dessous des autres fenêtres, ce qui n’était pas pratique. :smt003 )
Il va falloir dans le fichier xmonad-contrib-0.9/XMonad/Hooks/ManageDocks.hs aller à la ligne 128 et remplacer :[code] struts <- (filter careAbout . concat) fmap mapM getStrut wins
-- we grab the window attributes of the root window rather than checking
-- the width of the screen because xlib caches this info and it tends to
-- be incorrect after RAndR
wa <- io $ getWindowAttributes dpy rootw
let screen = r2c $ Rectangle (fi $ wa_x wa) (fi $ wa_y wa) (fi $ wa_width wa) (fi $ wa_height wa)
return $ \r -> c2r $ foldr (reduce screen) (r2c r) struts
where careAbout (s,,,_) = s S.member ss
[/code]par[code] (strutWins,struts) <- do
stss <- mapM getStrut wins
let (ws, s) = unzip [ (w,st) | (w,sts) <- zip wins stss, st <- sts, careAbout st ]
return (unique ws, unique s)
-- move all the struts to the top of X's stacking order.
sequence_ $ map (\w -> io $ raiseWindow dpy w) strutWins
-- we grab the window attributes of the root window rather than checking
-- the width of the screen because xlib caches this info and it tends to
-- be incorrect after RAndR
wa <- io $ getWindowAttributes dpy rootw
let screen = r2c $ Rectangle (fi $ wa_x wa) (fi $ wa_y wa) (fi $ wa_width wa) (fi $ wa_height wa)
return $ \r -> c2r $ foldr (reduce screen) (r2c r) struts
where careAbout (s,,,_) = s S.member ss
unique [] = []
unique (x:xs) = x : unique (filter (/=x) xs)
[/code]Attention, l’indentation est importante, n’utiliser pas de tab!
Dans le morceau à coller, on voit trois niveau d’indentation :
le premier à 2 espaces,
le deuxième à 4 espaces,
le troisième à 8 espaces.
De toute façon, s’il y a un souci à la compile, les erreurs seront précisées.
Compilation
Il faudra lancer dans chacun des deux répertoires les commandes suivantes :
$ runhaskell Setup.lhs configure --user --prefix=$HOME
$ runhaskell Setup.lhs build
$ runhaskell Setup.lhs install --user
ce qui nous construira Xmonad et ses extensions, dans des répertoires bin, lib et share de notre répertoire utilisateur.
après chaque éventuelle modification des sources, il faudra lancer :$ runhaskell Setup clean avant de relancer les trois commandes du dessus.
Assurez vous que ~/bin est dans votre path par la présence de ces lignes dans ~/.profile# set PATH so it includes user's private bin if it exists
if [ -d "$HOME/bin" ] ; then
PATH="$HOME/bin:$PATH"
fi
Xmonad se configure avec le fichier ~/.xmonad/xmonad.hs dont voici un exemple minimal,
mais néanmoins déjà confortable pour s’intégrer à gnome :
EDIT: Il est aussi gunzippé en pièce jointe de ce message, il ne restera plus qu’à l’extraire dans votre ~/.xmonad/ et d’appuyer sur alt-q ou mod4-q (touche_windows-q) selon votre situation pour le prendre en compte.
L’utilisation de la version gunzippée permet d’éviter d’éventuels problème d’indentation dus à un mauvais copié-collé (Le Haskell est très sensible à l’indentation).
[code]import XMonad
import Data.Monoid
import System.Exit
import XMonad.Actions.DwmPromote
import XMonad.Actions.CycleWS
import XMonad.Config.Gnome
import XMonad.Layout.NoBorders
import XMonad.Hooks.ManageDocks
import qualified XMonad.StackSet as W
import qualified Data.Map as M
myFocusFollowsMouse :: Bool
myFocusFollowsMouse = True
myNormalBorderColor = "#000000"
myFocusedBorderColor = “#00ff00”
myKeys conf@(XConfig {XMonad.modMask = modm}) = M.fromList $
[ ((modm .|. shiftMask, xK_Return), spawn $ XMonad.terminal conf)
, ((modm, xK_p ), spawn "exe=`dmenu_path | dmenu` && eval \"exec $exe\"")
, ((mod1Mask, xK_F1), spawn "swarp 0 0 && sleep 0.2s && swarp 50 10 && xdotool click 1")
, ((mod1Mask, xK_F2 ), gnomeRun)
, ((modm, xK_w ), kill)
, ((modm, xK_Tab ), windows W.focusDown)
, ((modm, xK_j ), windows W.focusDown)
, ((modm, xK_k ), windows W.focusUp )
, ((modm, xK_Return), dwmpromote )
, ((modm, xK_h ), sendMessage Shrink)
, ((modm, xK_Left ), sendMessage Shrink)
, ((modm, xK_l ), sendMessage Expand)
, ((modm, xK_Right ), sendMessage Expand)
, ((modm, xK_comma ), sendMessage (IncMasterN 1))
, ((modm, xK_semicolon ), sendMessage (IncMasterN (-1)))
, ((modm, xK_Down), nextWS)
, ((modm, xK_Up), prevWS)
, ((modm .|. shiftMask, xK_Down), shiftToNext)
, ((modm .|. shiftMask, xK_Up), shiftToPrev)
, ((modm .|. controlMask, xK_Down), shiftToNext >> nextWS)
, ((modm .|. controlMask, xK_Up), shiftToPrev >> prevWS)
, ((modm, xK_space ), sendMessage NextLayout)
, ((modm .|. shiftMask, xK_space ), setLayout $ XMonad.layoutHook conf)
, ((modm .|. shiftMask, xK_q ), spawn "gnome-session-save --logout-dialog")
, ((modm , xK_q ), spawn "xmonad --recompile; xmonad --restart")
]
++
[((m .|. modm, k), windows $ f i)
| (i, k) <- zip (XMonad.workspaces conf) [0x26,0xe9,0x22,0x27,0x28,0x2d,0xe8,0x5f,0xe7]
, (f, m) <- [(W.greedyView, 0), (W.shift, shiftMask)
, (\i -> W.greedyView i . W.shift i, controlMask)]]
++
-- mod-{a,z,e}, Switch to physical/Xinerama screens 1, 2, or 3
-- mod-shift-{a,z,e}, Move client to screen 1, 2, or 3
--
[((m .|. modm, key), screenWorkspace sc >>= flip whenJust (windows . f))
| (key, sc) <- zip [xK_a, xK_z, xK_e] [0..]
, (f, m) <- [(W.view, 0), (W.shift, shiftMask)]]
myLayout = smartBorders $ avoidStruts (tiled ||| Mirror tiled ||| Full)
where
– default tiling algorithm partitions the screen into two panes
tiled = Tall nmaster delta ratio
-- The default number of windows in the master pane
nmaster = 1
-- Default proportion of screen occupied by master pane
ratio = 31/50 -- approximation du nombre d'or
-- Percent of screen to increment by when resizing panes
delta = 3/100
main = xmonad gnomeConfig {
modMask = mod4Mask,
focusFollowsMouse = myFocusFollowsMouse,
normalBorderColor = myNormalBorderColor,
focusedBorderColor = myFocusedBorderColor,
keys = myKeys,
layoutHook = myLayout
}[/code]Quelques précisions sur ce fichier :
- Il existe une archive de configs d’utilisateur dont il fortement conseillé de s’inspirer : haskell.org/haskellwiki/Xmon … ig_archive
- le raccourcis alt-F1 du menu gnome ne sera fonctionnel tel quel que si le menu est placé à gauche du panel du haut (la configuration gnome par défaut) et avec dwm-tools et xdotool d’installé (ou avec la souris)
Raccourcis clavier de ce fichier :
pour plus de rapidité :
s pour Méta (touche majuscule)
a pour alt
c pour control
m pour le modificateur (touche windows dans notre exemple)
m-s-Return :lance un terminal
m-p : lance dmenu (lanceur de programme ultra léger)
a-F1 : lance le menu de gnome
a-F2 : lance gmrun
m-w : ferme la fenêtre ayant le focus
m-tab ou m-j : focus la fenêtre suivante
m-k : focus la fenêtre précédente
m-Return : échange la fenêtre ayant le focus avec la fenêtre de la zone principale
m-h ou m-Left : diminue la taille de la zone principale
m-l ou m-Right : augmente la taille de la zone principale
m-comma (virgule) : augmente d’1 le nombre de fenêtre dans la zone principale
m-semicolon (point-virgule) : diminue d’1 le nombre de fenêtre dans la zone principale
m-Down : passe au bureau suivant
m-s-Down : envoie la fenêtre ayant le focus dans le bureau suivant
m-c-Down : envoie la fenêtre ayant le focus dans le bureau suivant et y va avec
m-Up : passe au bureau précédent
m-s-Up : envoie la fenêtre ayant le focus dans le bureau précédent
m-c-UP : envoie la fenêtre ayant le focus dans le bureau précédent et y va avec
m-space : passe en revue les différentes disposition possible des fenêtres (trois dans cette conf.)
m-s-space : remet la disposition de fenêtre par défaut
m-q : recompile et redémarre xmonad (nécessaire après chaque changement au fichier ~/.xmonad/xmonad.hs pour que les changements soit pris en compte)La recompilation dure ~5 secondes, le redémarrage n’affecte pas les applications en cours ni la disposition des fenêtre, s’il vous avez fait une erreur en éditant le fichier, une fenêtre xmessage apparaît avec des indices pour résoudre les erreurs.
m-s-q : lance le dialogue fin de session gnome.
Nous allons maintenant créer dans notre répertoire utilisateur un fichier .xsession qui nous permettra de lancer Xmonad dans Gnome.
export WINDOW_MANAGER="~/.xmonad/xmonad-i386-linux"
gnome-settings-daemon &
dbus-launch --exit-with-session xmonad
Une fois ce fichier crée, vous pouvez quitter votre session gnome actuelle et dans gdm,
vous choisirez exécuter le script xclient ce qui devrez vous lancer dans gnome avec Xmonad.
Si tout s’est bien passé, sauvegardez la session et aux prochain login choisissez dernière session dans gdm.
Si quelque chose ne marche pas comme prévu, c’est peut-être dû à un oubli de ma part. Vous pouvez postez ici, ça me permettra sûrement d’améliorer et clarifier ce post.
et je suis intérressé par les wm léger pour mon portable alors je potasse l’édition de texte et je tente de suivre …
