Rendez-vous sur Arrakis, Le site perso d'un hacker libriste curieux crêpophile étourdi
Le 19/06/2019 à 15:43 dans /Journal/2016/

Configuration de dwm sous OpenBSD

Voilà un article un peu plus geek, où vous trouverez la configuration permettant de configurer le gestionnaire de fenêtres dwm sur openbsd.

Tout d'abord, la capture d'écran obligatoire :

Une fois ceci fait, voici le fichier de configuration pour dwm. C'est une configuration très épurée, qui permet entre autres les choses suivantes :

* Fermeture d'une fenêtre avec un clic-milieu sur le titre de celle-ci
* Augmentation/réduction du volume sonore en actionnant la molette sur la barre de status
* Plusieurs raccourcis clavier bien pratiques (pour mpd, firefox, lanceur dmenu...)

 /* See LICENSE file for copyright and license details. */
 
 /* appearance */
 static const char *fonts[] = {
    "LiberationMono:size=9"
 };
 static const char dmenufont[]       = "LiberationMono:size=9";
 static const char normbordercolor[] = "#08090a";
 static const char normbgcolor[]     = "#08090a";
 static const char normfgcolor[]     = "#606c78";
 static const char selbordercolor[]  = "#606c78";
 static const char selbgcolor[]      = "#606c78";
 static const char selfgcolor[]      = "#08090a";
 static const unsigned int borderpx  = 2;        /* border pixel of windows */
 static const unsigned int snap      = 32;       /* snap pixel */
 static const int showbar            = 1;        /* 0 means no bar */
 static const int topbar             = 1;        /* 0 means bottom bar */
 
 /* tagging */
 static const char *tags[] = { "*", "w", "@", ";", "+" };
 
 static const Rule rules[] = {
    /* xprop(1):
     *  WM_CLASS(STRING) = instance, class
     *  WM_NAME(STRING) = title
     */
    /* class      instance    title       tags mask     isfloating   monitor */
    { "Crawl-tiles",     NULL,       NULL,       0,            True,        -1 },
    { NULL,     NULL,       "Jabber",       1<<2,            False,        -1 },
    { NULL,     NULL,       "Mutt",       1<<2,            False,        -1 },
    { "Firefox",     NULL,       NULL,       1<<1,            False,        -1 },
    { "surf",     NULL,       NULL,       1<<1,            False,        -1 },
    { "Surf",     NULL,       NULL,       1<<1,            False,        -1 },
    { "tabbed-surf",     NULL,       NULL,       1<<1,            False,        -1 },
    { "tabbed",     NULL,       NULL,       1<<1,            False,        -1 },
    { "Gimp",     NULL,       NULL,       1<<4 ,            False,        -1 },
    { "stalonetray", NULL, NULL, 0, True, -1 },
    { "menu", NULL,        NULL,      0,          True,            -1 },
 };
 
 /* layout(s) */
 static const float mfact     = 0.55; /* factor of master area size [0.05..0.95] */
 static const int nmaster     = 1;    /* number of clients in master area */
 static const int resizehints = 1;    /* 1 means respect size hints in tiled resizals */
 
 static const Layout layouts[] = {
    /* symbol     arrange function */
    { "[]=",      tile },    /* first entry is default */
    { "><>",      NULL },    /* no layout function means floating behavior */
    { "[M]",      monocle },
 };
 
 /* key definitions */
 #define MODKEY Mod1Mask
 #define TAGKEYS(KEY,TAG) \
    { MODKEY,                       KEY,      view,           {.ui = 1 << TAG} }, \
    { MODKEY|ControlMask,           KEY,      toggleview,     {.ui = 1 << TAG} }, \
    { MODKEY|ShiftMask,             KEY,      tag,            {.ui = 1 << TAG} }, \
    { MODKEY|ControlMask|ShiftMask, KEY,      toggletag,      {.ui = 1 << TAG} },
 
 /* helper for spawning shell commands in the pre dwm-5.0 fashion */
 #define SHCMD(cmd) { .v = (const char*[]){ "/bin/sh", "-c", cmd, NULL } }
 
 /* commands */
 static char dmenumon[2] = "0"; /* component of dmenucmd, manipulated in spawn() */
 static const char *dmenucmd[] = { "dmenu_run", "-m", dmenumon, "-fn", dmenufont, "-nb", normbgcolor, "-nf", normfgcolor, "-sb", selbgcolor, "-sf", selfgcolor, NULL };
 static const char *termcmd[]  = { "st", NULL };
 
 static Key keys[] = {
    /* modifier                     key        function        argument */
    { MODKEY,                       XK_p,      spawn,          {.v = dmenucmd } },
    { MODKEY|ShiftMask,             XK_Return, spawn,          {.v = termcmd } },
    { MODKEY,                       XK_b,      togglebar,      {0} },
    { MODKEY,                       XK_j,      focusstack,     {.i = +1 } },
    { MODKEY,                       XK_k,      focusstack,     {.i = -1 } },
    { MODKEY,                       XK_i,      incnmaster,     {.i = +1 } },
    { MODKEY,                       XK_d,      incnmaster,     {.i = -1 } },
    { MODKEY,                       XK_h,      setmfact,       {.f = -0.05} },
    { MODKEY,                       XK_l,      setmfact,       {.f = +0.05} },
    { MODKEY,                       XK_Return, zoom,           {0} },
    { MODKEY,                       XK_Tab,    view,           {0} },
    { MODKEY|ShiftMask,             XK_c,      killclient,     {0} },
    { MODKEY,                       XK_t,      setlayout,      {.v = &layouts[0]} },
    { MODKEY,                       XK_f,      setlayout,      {.v = &layouts[1]} },
    { MODKEY,                       XK_m,      setlayout,      {.v = &layouts[2]} },
    { MODKEY,                       XK_space,  setlayout,      {0} },
    { MODKEY|ShiftMask,             XK_space,  togglefloating, {0} },
    { MODKEY,                       XK_agrave,      view,           {.ui = ~0 } },
    { MODKEY|ShiftMask,             XK_agrave,      tag,            {.ui = ~0 } },
    { MODKEY,                       XK_comma,  focusmon,       {.i = -1 } },
    { MODKEY,                       XK_semicolon, focusmon,       {.i = +1 } },
    { MODKEY|ShiftMask,             XK_comma,  tagmon,         {.i = -1 } },
    { MODKEY|ShiftMask,             XK_semicolon, tagmon,         {.i = +1 } },
    TAGKEYS(                        XK_ampersand,                     0)
    TAGKEYS(                        XK_eacute,                        1)
    TAGKEYS(                        XK_quotedbl,                      2)
    TAGKEYS(                        XK_apostrophe,                    3)
    TAGKEYS(                        XK_parenleft,                     4)
    TAGKEYS(                        XK_minus,                         5)
    TAGKEYS(                        XK_egrave,                        6)
    TAGKEYS(                        XK_underscore,                    7)
    TAGKEYS(                        XK_ccedilla,                      8)
     { MODKEY,                       XK_w,      spawn,          SHCMD("firefox") },
     { MODKEY,                       XK_a,      spawn,          SHCMD("~/.dmenu/actions") },
    { MODKEY,                       XK_s,      spawn,          SHCMD("sch") },
    { MODKEY,                       XK_x,      spawn,          SHCMD("~/.dmenu/dmlaunch") },
    { MODKEY,                       XK_z,      spawn,          SHCMD("~/.dmenu/dmpc") },
    { MODKEY|ShiftMask,             XK_l,      spawn,          SHCMD("mpc next") },
    { MODKEY|ShiftMask,             XK_h,      spawn,          SHCMD("mpc prev") },
    { MODKEY|ShiftMask,             XK_n,      spawn,          SHCMD("mpc toggle") },
    { 0,                        0x1008ff13,    spawn,          SHCMD("mixerctl outputs.master=+10") },
    { 0,                        0x1008ff11,    spawn,          SHCMD("mixerctl outputs.master=-10") },
    { 0,                        0x1008ff12,    spawn,          SHCMD("mixerctl outputs.master.mute=toggle") },
    { MODKEY|ShiftMask,             XK_q,      quit,           {0} },
 };
 
 /* button definitions */
 /* click can be ClkLtSymbol, ClkStatusText, ClkWinTitle, ClkClientWin, or ClkRootWin */
 static Button buttons[] = {
    /* click                event mask      button          function        argument */
    { ClkLtSymbol,          0,              Button1,        setlayout,      {0} },
    { ClkLtSymbol,          0,              Button3,        setlayout,      {.v = &layouts[2]} },
    { ClkWinTitle,          0,              Button2,        killclient,     {0} },
    { ClkWinTitle,          0,              Button4,        focusstack,     {.i = +1 } },
    { ClkWinTitle,          0,              Button5,        focusstack,     {.i = -1 } },
    { ClkStatusText,        0,              Button2,        spawn,          {.v = termcmd } },
    { ClkClientWin,         MODKEY,         Button1,        movemouse,      {0} },
    { ClkClientWin,         MODKEY,         Button2,        togglefloating, {0} },
    { ClkClientWin,         MODKEY,         Button3,        resizemouse,    {0} },
    { ClkTagBar,            0,              Button1,        view,           {0} },
    { ClkTagBar,            0,              Button3,        toggleview,     {0} },
    { ClkTagBar,            MODKEY,         Button1,        tag,            {0} },
    { ClkTagBar,            MODKEY,         Button3,        toggletag,      {0} },
    { ClkStatusText,        0,              Button3,        spawn,          SHCMD("~/.dmenu/dwm_menu/dwm_menu.sh") },
    { ClkRootWin,           0,              Button3,        spawn,          SHCMD("~/.dmenu/dwm_menu/dwm_menu.sh") },
    { ClkStatusText,        0,              Button4,        spawn,          SHCMD("mixerctl outputs.master=+10") },
    { ClkStatusText,        0,              Button5,        spawn,          SHCMD("mixerctl outputs.master=-12") },
 };
 

Ensuite, si vous avez bien observé, vous aurez remarqué que la barre de status est un peu spéciale. Il y a à l'intérieur des barres de niveau par exemple. Le tout est en plus entièrement codé en C, c'est très léger et rapide! Je me suis nettement inspiré de dstat, que l'on trouve sur la page de dwmstatus. Parmis ses fonctionnalités :

* Informartions sur la musique jouée par le lecteur MPD
* Affichage du nombre de messages dans vos dossiers Maildir
* Utilisation CPU
* Status de la batterie
* Volume sonore
* Date et heure

Voici donc le code pour le compiler :

config.mk

 NAME = dwmstatus
 VERSION = 1.2
 
 # Customize below to fit your system
 
 # paths
 PREFIX = /usr/local
 MANPREFIX = ${PREFIX}/share/man
 
 X11INC = /usr/X11R6/include
 X11LIB = /usr/X11R6/lib
 
 # mpd + openbsd
 MPDFLAG  =  -DMPD
 LOCALINCLUDE = /usr/local/include
 LOCALLIB = /usr/local/lib
 
 # includes and libs
 INCS = -I. -I/usr/include -I${LOCALINCLUDE} -I${X11INC} 
 LIBS = -L/usr/lib -lc -L${X11LIB} -lX11 -L${LOCALLIB} -lmpdclient
 
 # flags
 CPPFLAGS = ${MPDFLAG} -DVERSION=\"${VERSION}\"
 CFLAGS = -g -std=c99 -pedantic -Wall -O0 ${INCS} ${CPPFLAGS}
 #CFLAGS = -std=c99 -pedantic -Wall -Os ${INCS} ${CPPFLAGS}
 LDFLAGS = -g ${LIBS}
 #LDFLAGS = -s ${LIBS}
 
 # Solaris
 #CFLAGS = -fast ${INCS} -DVERSION=\"${VERSION}\"
 #LDFLAGS = ${LIBS}
 
 # compiler and linker
 CC = cc
 

le dwmstatus.c

 #define _BSD_SOURCE
 #define _GNU_SOURCE
 #include <unistd.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <string.h>
 #include <strings.h>
 #include <sys/time.h>
 #include <time.h>
 #include <err.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <sys/ioctl.h>
 #include <sys/param.h>
 #include <sys/audioio.h>
 #include <sys/sched.h>
 #include <sys/resource.h>
 #include <sys/sensors.h>
 #include <sys/sched.h>
 #include <sys/socket.h>
 #include <sys/sysctl.h>
 #include <machine/apmvar.h>
 #include <dirent.h>
 #include <fcntl.h>
 #include <limits.h>
 #include <mpd/client.h>
 
 #include <X11/Xlib.h>
 
 #define D_BUF 64
 
 char *tzparis = "Europe/Paris";
 static Display *dpy;
 
 char *
 smprintf(char *fmt, ...)
 {
    va_list fmtargs;
    char *buf = NULL;
 
    va_start(fmtargs, fmt);
    if (vasprintf(&buf, fmt, fmtargs) == -1){
        fprintf(stderr, "malloc vasprintf\n");
        exit(1);
     }
    va_end(fmtargs);
 
    return buf;
 }
 
 int 
 runevery(time_t *ltime, int sec){
     /* return 1 if sec elapsed since last run
      * else return 0 
     */
     time_t now = time(NULL);
     
     if ( difftime(now, *ltime ) >= sec)
     {
         *ltime = now;
         return(1);
     }
     else 
         return(0);
 }
 
 
 
 void
 setstatus(char *str)
 {
    XStoreName(dpy, DefaultRootWindow(dpy), str);
    XSync(dpy, False);
 }
 
 void
 settz(char *tzname)
 {
    setenv("TZ", tzname, 1);
 }
 
 char *
 mktimes(char *fmt, char *tzname)
 {
    char buf[129];
    time_t tim;
    struct tm *timtm;
 
    memset(buf, 0, sizeof(buf));
    settz(tzname);
    tim = time(NULL);
    timtm = localtime(&tim);
    if (timtm == NULL) {
        perror("localtime");
        exit(1);
    }
 
    if (!strftime(buf, sizeof(buf)-1, fmt, timtm)) {
        fprintf(stderr, "strftime == 0\n");
        exit(1);
    }
 
    return smprintf(buf);
 }
 
 
 char *get_nmail(char *directory, char *label)
 {
     /* directory : Maildir path 
     * return label : number_of_new_mails
     */
     
     int n = 0;
     DIR* dir = NULL;
     struct dirent* rf = NULL;
 
     dir = opendir(directory); /* try to open directory */
     if (dir == NULL)
         perror("");
 
     while ((rf = readdir(dir)) != NULL) /*count number of file*/
     {
         if (strcmp(rf->d_name, ".") != 0 &&
             strcmp(rf->d_name, "..") != 0)
             n++;
     }
     closedir(dir);
 
     if (n == 0) 
        return smprintf("");
     else 
        return smprintf("%s%d",label, n);
 
 }
 
 static const char *d_bar(unsigned char p) {
     const char *s[] = { "▁", "▂", "▃", "▄", "▅", "▆", "▇", "█", "█" };
 
     return s[((8 * p) / 100)];
 }
 
 static char *d_cpu(void) {
     static long cpu[CPUSTATES];
     int mib[2] = { CTL_KERN, KERN_CPTIME }, p;
     long c[CPUSTATES];
     size_t sz = sizeof(c);
 
     if (sysctl(mib, 2, &c, &sz, NULL, 0) == -1)
         return smprintf("sysctl failed");
     p = (c[CP_USER] - cpu[CP_USER] + c[CP_SYS] - cpu[CP_SYS] +
          c[CP_NICE] - cpu[CP_NICE]) / (double)
         (c[CP_USER] - cpu[CP_USER] + c[CP_SYS] - cpu[CP_SYS] +
          c[CP_NICE] - cpu[CP_NICE] + c[CP_IDLE] - cpu[CP_IDLE]) * 100;
     memmove(cpu, c, sizeof(cpu));
     return smprintf("CPU %d%% %s", p, d_bar(p));
 }
 
 static char *d_bat(int fd) {
     struct apm_power_info api;
 
     if (ioctl(fd, APM_IOC_GETPOWER, &api) == -1)
         return smprintf("ioctl failed");
     return (api.ac_state == APM_AC_ON) ?
         smprintf("⚡ %d%% %s A/C",
             api.battery_life, d_bar(api.battery_life)) :
         smprintf("⚡ %d%% %s %u:%02u",
             api.battery_life, d_bar(api.battery_life),
             api.minutes_left / 60, api.minutes_left % 60);
 }
 
 static char *d_vol(int fd) {
     static int cls = -1;
     struct mixer_devinfo mdi;
     struct mixer_ctrl mc;
     int v = -1, p;
 
     for (mdi.index = 0; cls == -1; mdi.index++) {
         if (ioctl(fd, AUDIO_MIXER_DEVINFO, &mdi) == -1)
             return smprintf("ioctl failed");
         if (mdi.type == AUDIO_MIXER_CLASS &&
             !strcmp(mdi.label.name, AudioCoutputs))
                 cls = mdi.index;
     }
     for (mdi.index = 0; v == -1; mdi.index++) {
         if (ioctl(fd, AUDIO_MIXER_DEVINFO, &mdi) == -1)
             return smprintf("ioctl failed");
         if (mdi.type == AUDIO_MIXER_VALUE && mdi.prev == AUDIO_MIXER_LAST &&
             mdi.mixer_class == cls && !strcmp(mdi.label.name, AudioNmaster)) {
             mc.dev = mdi.index;
             if (ioctl(fd, AUDIO_MIXER_READ, &mc) == -1)
                 return smprintf("ioctl failed");
             v = mc.un.value.num_channels == 1 ?
                 mc.un.value.level[AUDIO_MIXER_LEVEL_MONO] :
                 (mc.un.value.level[AUDIO_MIXER_LEVEL_LEFT] >
                  mc.un.value.level[AUDIO_MIXER_LEVEL_RIGHT] ?
                  mc.un.value.level[AUDIO_MIXER_LEVEL_LEFT] :
                  mc.un.value.level[AUDIO_MIXER_LEVEL_RIGHT]);
         } /* todo: handle mute */
     }
     return v == -1 ? "volume failed" :
         (p = (v * 100) / 255, smprintf("♫ %d%% %s", p, d_bar(p)));
 }
 
 /* simple function to retrieve mpd status */
 char *
 getmpdstat() {
     struct mpd_song * song = NULL;
    const char * title = NULL;
    const char * artist = NULL;
    char * retstr = NULL;
    int elapsed = 0, total = 0;
     struct mpd_connection * conn ;
     if (!(conn = mpd_connection_new("localhost", 0, 30000)) ||
         mpd_connection_get_error(conn)){
             return smprintf("");
     }
 
     mpd_command_list_begin(conn, true);
     mpd_send_status(conn);
     mpd_send_current_song(conn);
     mpd_command_list_end(conn);
 
     struct mpd_status* theStatus = mpd_recv_status(conn);
         if ((theStatus) && (mpd_status_get_state(theStatus) == MPD_STATE_PLAY)) {
                 mpd_response_next(conn);
                 song = mpd_recv_song(conn);
                 title = smprintf("%s",mpd_song_get_tag(song, MPD_TAG_TITLE, 0));
                 artist = smprintf("%s",mpd_song_get_tag(song, MPD_TAG_ARTIST, 0));
 
                 elapsed = mpd_status_get_elapsed_time(theStatus);
                 total = mpd_status_get_total_time(theStatus);
                 mpd_song_free(song);
                 retstr = smprintf("[♪ %s - %s - %.2d:%.2d/%.2d:%.2d ♪]",
                                 artist, title,
                                 elapsed/60, elapsed%60,
                                 total/60, total%60);
                 free((char*)title);
                 free((char*)artist);
         }
         else retstr = smprintf("");
        mpd_response_finish(conn);
        mpd_connection_free(conn);
        return retstr;
 }
 
 
 
 
 int
 main(void)
 {
     int a = -1, m = -1;
    char *status;
    char *tmprs = NULL;
     char *mail_laposte = NULL;
     char *mail_educ = NULL;
     char *mail_yt = NULL;
     char *mail_y = NULL;
     char *mail_p = NULL;
     char *cpu = NULL;
     char *bat = NULL;
     char *vol = NULL;
     char *mpd = NULL;
     time_t count5min = 0;
     time_t count60 = 0;
     
    if (!(dpy = XOpenDisplay(NULL))) {
        fprintf(stderr, "dwmstatus: cannot open display.\n");
        return 1;
    }
 
     if ((a = open("/dev/apm", O_RDONLY)) == -1 ||
         (m = open("/dev/mixer", O_RDONLY)) == -1)
         err(1, "open failed");
 
    for (;;sleep(1)) {
        /* checks every minutes */
        if ( runevery(&count60, 60) )
         {
             free(tmprs);
             free(bat);
             tmprs = mktimes("%d/%m/%y %H:%M", tzparis);
             bat = d_bat(a);
         }
         /* checks mail every 5 minutes */
         if (runevery(&count5min, 300) )
         {
             free(mail_laposte);
             free(mail_educ);
             free(mail_yt);
             free(mail_y);
             free(mail_p);
             mail_laposte = get_nmail("/home/thuban/Maildir/laposte/new", " LP:");
             mail_educ = get_nmail("/home/thuban/Maildir/educ/new", " LP:");
             mail_yt = get_nmail("/home/thuban/Maildir/ythuban/new", " LP:");
             mail_y = get_nmail("/home/thuban/Maildir/y/new", " LP:");
             mail_p = get_nmail("/home/thuban/Maildir/physique/new", " LP:");
         }
         /* checks every second */
             free(cpu);
             free(vol);
             free(mpd);
             cpu = d_cpu();
             vol = d_vol(m);
             mpd = getmpdstat();
 
        status = smprintf("%s [✉ :%s%s%s%s%s] [%s | %s | %s] [%s]",
                mpd,
                mail_laposte, mail_educ, mail_yt, mail_y, mail_p, 
                cpu, bat, vol,
                tmprs);
        setstatus(status);
 
        free(status);
    }
 
    XCloseDisplay(dpy);
 
    return 0;
 }
 
 
 

La commande "make" vous donnera l'éxécutable dwmstatus à lancer en début de session.

Que c'est bon d'avoir un vrai environnement de travail!