site
header
Rendez-vous sur Arrakis
Le site perso d'un hacker libriste curieux crêpophile et étourdi

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!

le 22/04/2016 à 17:37:45, Fred Galusik a dit :

Très sympa.

J'utilise i3 depuis très longtemps.

Tu me donnes envie de tester ta configuration. Me manquerai peut être juste un petit indicateur pour le réseau et changer les raccourcis basés sur la souris.

++

le 22/04/2016 à 18:58:42, Thuban a dit :

@Fred Galusik : i3 est chouette en effet. Mais une fois qu'on a goûté à la simplicité de dwm... Tout y est!
Pour l'indicateur réseau, tu as cette fonction dans dstat :

static char *d_net(const char *ifn) {
static char s[D_BUF];
struct ifaddrs *ifas, *ifa;
struct if_data *ifd = NULL;

if (getifaddrs(&ifas) == -1)
return d_warn("getifaddrs failed");
for (ifa = ifas; ifa && !ifd; ifa = ifa->ifa_next)
if (!strcmp(ifa->ifa_name, ifn) && ifa->ifa_data)
ifd = (struct if_data *)ifa->ifa_data;
return !ifd ? "interface failed" :
d_fmt(s, sizeof(s), "↑ %s ↓ %s",
d_out(ifd->ifi_obytes), d_in(ifd->ifi_ibytes));
}

Enfin lis le code de dstat qui est vraiment fait pour une openBSD 😉

le 22/04/2016 à 19:04:09, Fred Galusik a dit :

Cool. Merci.

++

le 23/04/2016 à 12:20:46, David a dit :

Bonjour, je viens d'installer dwm avec pkg_add dwm mais je n'arrive pas à démarrer dwm
( startdwm).

le 23/04/2016 à 14:57:14, Thuban a dit :

@David : Bonjour,
dwm ne se lance pas ainsi.
Il faut créer un fichier ~/.xinitrc puis y mettre
exec dwm

Et enfin, pour ouvrir la session dwm, il faut lancer "startx".

Regarde les tutoriels ici et

le 25/04/2016 à 16:37:43, sogak a dit :

Salut,
Très chouette ton dwmstatus, ça rend bien.
Ça ne te fait pas trop de bizarrerie selon la longueur des titres joués ?

le 25/04/2016 à 18:11:09, Thuban a dit :

@sogak : Salut :)
Non, rien de gênant. Au pire, dans le cas des titres vraiment trèèèèèès longs, ça déplace le reste du texte vers la droite (je ne vois plus l'heure). Mais là, c'est très rare, et il faut revoir les tags des morceaux :)

le 25/04/2016 à 20:53:16, sogal a dit :

@Thuban :
s/sogak/sogal/ tellement naze aujourd'hui que je sais plus comment je m'appelle! (d'ailleurs je suis où là ?)

Bref, ça reste fort sympa, je me l'adapterai bien pour avoir l'équivalent avec MOC ;)

le 25/04/2016 à 21:43:24, Thuban a dit :

@sogal : Héhé, j'avais compris que c'était toi :P
Pas sûr que ça soit aussi simple avec MOC. MPD et sont côté serveur rend les choses tellement plus simples!
Regarde s'il y a une lib' pour MOC. Sinon, il faudra récupérer l'output d'une commande :)

le 26/04/2016 à 08:38:09, sogal a dit :

@Thuban :
Alors ce sera peut-être l'occasion de retester MPD. La première fois je n'avais pas trouvé de client texte/curses qui m'ait séduit mais c'est probablement faute ne n'avoir pas assez cherché :)

En tout cas ta config dwm sur une base openBSD, elle, me séduit diablement. Je pense qu'on doit retrouver cette élégante simplicité que j'avais tant apprécié durant 2 ans avec Debian Wheezy.

le 26/04/2016 à 09:15:36, Thuban a dit :

@sogal : Tu avais tenté ncmpcpp?

le 26/04/2016 à 10:45:41, sogal a dit :

@Thuban :
De mémoire oui, mais vite fait, ça m'avait paru embrouillé comme interface, je cherchais plus un truc à la MOC mais pour mpd.
Mais si tu m'en dit du bien, il faudrait que je retente en prenant plus le temps.

Concernant dwm, tu l'installes depuis les ports ou depuis les packages ? comment fais-tu pour inclure ta configuration personnalisée et éventuellement des modifs du dwm.c ?
Via les ports, pas moyen d'inclure mon config.def.h (ou je n'ai pas compris comment du moins) et en utilisant le code source tel que j'utilise sous Debian, j'ai des retours d'erreurs relatifs à ISO C.

le 26/04/2016 à 11:18:01, Thuban a dit :

@sogal : Pour dwm, je ne me suis pas embêté, j'ai compilé à la main, façon suckless quoi :)

le 27/04/2016 à 10:01:40, sogal a dit :

@Thuban : :) en effet cela fonctionne mais sans les patches (malgré quelques avertissements toutefois).
Bon ben maintenant, y'a plus qu'à tester tout cela patiemment en réel sur mon pti Thinkpad x201 avec chiffrement du disque (quitte à tester un OS axé sécurité autant nourrir ma parano :p ).
Merci bien pour cette intéressante série d'articles, c'est intéressant de pouvoir tester autre chose qu'une distro basée sur Linux. D'autant qu'on en fait souvent vite le tour car tout se ressemble un peu à la fin. Et les points éthiques que tu as mentionnés dans ton premier article sont pertinents et méritent effectivement réflexion.

le 27/04/2016 à 10:13:51, Thuban a dit :

@sogal : SI ce ne sont que des "warnings" du compilateurs, ce n'est pas très grave.
Pour les patches, tu es sûr de bien les avoir pris pour la version que tu tentes de compiler? (la 6.1?)

OpenBSD est un plaisir à découvrir. Et il y a déjà un tas de choses évidentes de prêtes : sauvegarde quotidienne, personnalisation d'installation...

le 27/04/2016 à 11:25:50, sogal a dit :

En fait, j'ai pigé le truc. Par habitude je récupérais la version du dépôt git. Et là j'ai des erreurs bloquantes relatives à Xft/Freetype.
Mais en utilisant la 6.1 "stable" (i.e. celle de l'archive tar.gz), ça passe, quelques "warnings" en effet mais c'est tout bon.
Les patches sont corrects je les utilise avec la 6.1 sous Debian GNU/Linux. Mais pas bien grave, je m'en passerai :)

C'est quand vraiment différent, beaucoup de repères changent radicalement. Y'a pas une heure je cherchais la commande "lsblk" juste pour savoir sous quel nom apparaissait ma clé USB ! Ben y'a pas, faut faire autrement :)

le 27/04/2016 à 11:49:14, Thuban a dit :

Héhé, oui, mais on trouve vite l'équivalent ^^

le 04/07/2017 à 19:56:38, antse a dit :

@Thuban : peut etre suis-je mauvais, mais j'ai du mal dans dwm à trouver les combinaisons clavier pour basculer d'un espace à un autre :(

le 05/07/2017 à 10:53:15, thuban a dit :

@antse : Alt-n (où n est un chiffre)
Selon si tu es sur un clavier azerty ou qwerty, tu devras peut-être modifier les touches par défaut ;)

le 06/07/2017 à 20:39:31, antse a dit :

@thuban : hello est-ce que quelqu'un sais pourquoi j'ai ce genre d'erreur à la compilation ?

/usr/X11R6/include/X11/Xfuncproto.h:173:24: warning: ISO C does not permit named variadic macros

le 08/07/2017 à 10:51:38, thuban a dit :

@antse : C'est un warning envoyé par le compilateur, pas de quoi s'inquiéter outre mesure ;)
Après, pour les détails, je ne vais pas prendre le risque de me ridiculiser.