From 5d3c8e21d2d79a6ed3e324b833002a9bb0317b34 Mon Sep 17 00:00:00 2001 From: Patryk Niedźwiedziński Date: Tue, 29 Sep 2020 22:12:48 +0200 Subject: Linux config --- platforms/common-packages.nix | 2 +- platforms/linux/aliases.nix | 2 +- platforms/linux/default.nix | 15 +- platforms/linux/gtk.nix | 2 +- platforms/linux/xorg.nix | 38 -- platforms/linux/xorg/default.nix | 55 +++ platforms/linux/xorg/dwm-apps.diff | 30 ++ platforms/linux/xorg/dwm-autostart.diff | 12 + platforms/linux/xorg/dwm-center.diff | 83 ++++ platforms/linux/xorg/dwm-rounded.diff | 114 +++++ platforms/linux/xorg/dwm-systray.diff | 731 ++++++++++++++++++++++++++++++++ platforms/linux/xorg/dwmblocks.diff | 26 ++ 12 files changed, 1063 insertions(+), 47 deletions(-) delete mode 100644 platforms/linux/xorg.nix create mode 100644 platforms/linux/xorg/default.nix create mode 100644 platforms/linux/xorg/dwm-apps.diff create mode 100644 platforms/linux/xorg/dwm-autostart.diff create mode 100644 platforms/linux/xorg/dwm-center.diff create mode 100644 platforms/linux/xorg/dwm-rounded.diff create mode 100644 platforms/linux/xorg/dwm-systray.diff create mode 100644 platforms/linux/xorg/dwmblocks.diff (limited to 'platforms') diff --git a/platforms/common-packages.nix b/platforms/common-packages.nix index e9c36fd..0114a84 100644 --- a/platforms/common-packages.nix +++ b/platforms/common-packages.nix @@ -9,6 +9,6 @@ with pkgs; zip unzip ripgrep - jq + # jq file ] diff --git a/platforms/linux/aliases.nix b/platforms/linux/aliases.nix index e9b5878..3cee519 100644 --- a/platforms/linux/aliases.nix +++ b/platforms/linux/aliases.nix @@ -1,3 +1,3 @@ { - nixos-rebuild = "nixos-rebuild -I nixos-config=$HOME/.config/nixpkgs/platforms/linux/configuration.nix"; + nixos-rebuild = "sudo nixos-rebuild -I nixos-config=$HOME/.config/nixpkgs/platforms/linux/configuration.nix"; } diff --git a/platforms/linux/default.nix b/platforms/linux/default.nix index 281f8c2..f624fb3 100644 --- a/platforms/linux/default.nix +++ b/platforms/linux/default.nix @@ -1,13 +1,16 @@ +{ pkgs, ... }: { + home.packages = with pkgs; [ + spotify + discord + python37Packages.pywal + ]; + imports = [ + ./xorg ./user-dirs.nix ./gtk.nix - ./xorg.nix ]; - home.packages = [ - spotify - discord - python37Packages.pywal - ]; + } diff --git a/platforms/linux/gtk.nix b/platforms/linux/gtk.nix index c16725b..e1712ed 100644 --- a/platforms/linux/gtk.nix +++ b/platforms/linux/gtk.nix @@ -1,4 +1,4 @@ -pkgs: +{ pkgs, ... }: { home.packages = with pkgs; [ capitaine-cursors diff --git a/platforms/linux/xorg.nix b/platforms/linux/xorg.nix deleted file mode 100644 index c8e9222..0000000 --- a/platforms/linux/xorg.nix +++ /dev/null @@ -1,38 +0,0 @@ -pkgs: -{ - home.packages = with pkgs; [ - nur.repos.pn.pndwm - mpd - xcompmgr - picom - dunst - unclutter - nur.repos.pn.dockd - ]; - - xsession = { - enable = true; - windowManager.command = "dbus-run-session -- dwm"; - profileExtra = '' - # Fix Gnome Apps Slow Start due to failing services - # Add this when you include flatpak in your system - dbus-update-activation-environment --systemd DBUS_SESSION_BUS_ADDRESS DISPLAY XAUTHORITY - - mpd & # music player daemon-you might prefer it as a service though - remaps & # run the remaps script, switching caps/esc and more; check it for more info - setbg & # set the background with the `setbg` script - #xrdb $\{XDG_CONFIG_HOME:-$HOME/.config}/Xresources & # Uncomment to use Xresources colors/settings on startup - picom & - dunst & # dunst for notifications - xset r rate 300 50 & # Speed xrate up - unclutter & # Remove mouse when idle - #sxhkd & - dockd --daemon & - screen-orient & - for app in `ls ~/.config/autostart/*.desktop`; do - $(grep '^Exec' $app | sed 's/^Exec=//') & - done - ''; - scriptPath = ".xinitrc"; - }; -} diff --git a/platforms/linux/xorg/default.nix b/platforms/linux/xorg/default.nix new file mode 100644 index 0000000..21bb4de --- /dev/null +++ b/platforms/linux/xorg/default.nix @@ -0,0 +1,55 @@ +{ pkgs, ... }: +let + pndwmblocks = pkgs.nur.repos.pn.dwmblocks.override { + patches = [ + ./dwmblocks.diff + ]; + }; + pndwm = pkgs.nur.repos.pn.dwm.override { + patches = [ + ./dwm-systray.diff + ./dwm-center.diff + ./dwm-apps.diff + ./dwm-autostart.diff + # ./dwm-rounded.diff - Resize dont work + ]; + }; +in +{ + home.packages = with pkgs; [ + mpd + xcompmgr + picom + dunst + unclutter + nur.repos.pn.dockd + pndwmblocks + pndwm + ]; + + xsession = { + enable = true; + windowManager.command = "dbus-run-session -- dwm"; + profileExtra = '' + # Fix Gnome Apps Slow Start due to failing services + # Add this when you include flatpak in your system + dbus-update-activation-environment --systemd DBUS_SESSION_BUS_ADDRESS DISPLAY XAUTHORITY + + mpd & # music player daemon-you might prefer it as a service though + remaps & # run the remaps script, switching caps/esc and more; check it for more info + setbg & # set the background with the `setbg` script + #xrdb $\{XDG_CONFIG_HOME:-$HOME/.config}/Xresources & # Uncomment to use Xresources colors/settings on startup + picom & + dunst & # dunst for notifications + xset r rate 300 50 & # Speed xrate up + unclutter & # Remove mouse when idle + #sxhkd & + dockd --daemon & + for app in `ls ~/.config/autostart/*.desktop`; do + $(grep '^Exec' $app | sed 's/^Exec=//') & + done + sleep .5 && screen-orient & + ''; + scriptPath = ".xinitrc"; + }; +} diff --git a/platforms/linux/xorg/dwm-apps.diff b/platforms/linux/xorg/dwm-apps.diff new file mode 100644 index 0000000..b5d7474 --- /dev/null +++ b/platforms/linux/xorg/dwm-apps.diff @@ -0,0 +1,30 @@ +diff --git a/config.h b/config.h +index 780550a..e8d3805 100644 +--- a/config.h ++++ b/config.h +@@ -55,6 +55,7 @@ static const Rule rules[] = { + { NULL, NULL, "Event Tester", 0, 0, 0, 0, 1, -1 }, + { NULL, "spterm", NULL, SPTAG(0), 0, 1, 1, 0, -1 }, + { NULL, "spcalc", NULL, SPTAG(1), 0, 1, 1, 0, -1 }, ++ { NULL, "telegram-desktop", NULL, 0, 1, 1, 0, 0, -1 }, + }; + + /* layout(s) */ +@@ -102,7 +103,7 @@ static const Layout layouts[] = { + + /* 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 *dmenucmd[] = { "dmenu_run", "-i", "-m", dmenumon, "-fn", dmenufont, "-nb", normbgcolor, "-nf", normfgcolor, "-sb", selbgcolor, "-sf", selfgcolor, "-c", "-bw", "2", "-l", "15", NULL }; + static const char *termcmd[] = { TERMINAL, NULL }; + + #include +@@ -158,7 +159,7 @@ static Key keys[] = { + { MODKEY|ShiftMask, XK_bracketleft, spawn, SHCMD("mpc seek -60") }, + { MODKEY, XK_bracketright, spawn, SHCMD("mpc seek +10") }, + { MODKEY|ShiftMask, XK_bracketright, spawn, SHCMD("mpc seek +60") }, +- { MODKEY, XK_backslash, view, {0} }, ++ { MODKEY, XK_backslash, spawn, SHCMD("telegram-desktop") }, + /* { MODKEY|ShiftMask, XK_backslash, spawn, SHCMD("") }, */ + + { MODKEY, XK_a, togglegaps, {0} }, diff --git a/platforms/linux/xorg/dwm-autostart.diff b/platforms/linux/xorg/dwm-autostart.diff new file mode 100644 index 0000000..1df1fa8 --- /dev/null +++ b/platforms/linux/xorg/dwm-autostart.diff @@ -0,0 +1,12 @@ +diff --git a/dwm.c b/dwm.c +index 127ab8a..44c85ed 100644 +--- a/dwm.c ++++ b/dwm.c +@@ -1773,6 +1773,7 @@ run(void) + void + runAutostart(void) { + system("killall -q dwmblocks; dwmblocks &"); ++ system("for app in `ls ~/.config/autostart/*.desktop`; do $(grep '^Exec' $app | sed 's/^Exec=//') &; done"); + } + + void diff --git a/platforms/linux/xorg/dwm-center.diff b/platforms/linux/xorg/dwm-center.diff new file mode 100644 index 0000000..1bacb63 --- /dev/null +++ b/platforms/linux/xorg/dwm-center.diff @@ -0,0 +1,83 @@ +diff --git a/config.h b/config.h +index 747d9a0..780550a 100644 +--- a/config.h ++++ b/config.h +@@ -49,12 +49,12 @@ static const Rule rules[] = { + * WM_CLASS(STRING) = instance, class + * WM_NAME(STRING) = title + */ +- /* class instance title tags mask isfloating isterminal noswallow monitor */ +- { "Gimp", NULL, NULL, 1 << 8, 0, 0, 0, -1 }, +- { TERMCLASS, NULL, NULL, 0, 0, 1, 0, -1 }, +- { NULL, NULL, "Event Tester", 0, 0, 0, 1, -1 }, +- { NULL, "spterm", NULL, SPTAG(0), 1, 1, 0, -1 }, +- { NULL, "spcalc", NULL, SPTAG(1), 1, 1, 0, -1 }, ++ /* class instance title tags mask iscentered isfloating isterminal noswallow monitor */ ++ { "Gimp", NULL, NULL, 1 << 8, 0, 0, 0, 0, -1 }, ++ { TERMCLASS, NULL, NULL, 0, 0, 0, 1, 0, -1 }, ++ { NULL, NULL, "Event Tester", 0, 0, 0, 0, 1, -1 }, ++ { NULL, "spterm", NULL, SPTAG(0), 0, 1, 1, 0, -1 }, ++ { NULL, "spcalc", NULL, SPTAG(1), 0, 1, 1, 0, -1 }, + }; + + /* layout(s) */ +diff --git a/dwm.c b/dwm.c +index 2e43282..4220f87 100644 +--- a/dwm.c ++++ b/dwm.c +@@ -119,7 +119,7 @@ struct Client { + int basew, baseh, incw, inch, maxw, maxh, minw, minh; + int bw, oldbw; + unsigned int tags; +- int isfixed, isfloating, isurgent, neverfocus, oldstate, isfullscreen, isterminal, noswallow, issticky; ++ int isfixed, iscentered, isfloating, isurgent, neverfocus, oldstate, isfullscreen, isterminal, noswallow, issticky; + pid_t pid; + Client *next; + Client *snext; +@@ -170,6 +170,7 @@ typedef struct { + const char *instance; + const char *title; + unsigned int tags; ++ int iscentered; + int isfloating; + int isterminal; + int noswallow; +@@ -348,6 +349,7 @@ applyrules(Client *c) + XClassHint ch = { NULL, NULL }; + + /* rule matching */ ++ c->iscentered = 0; + c->isfloating = 0; + c->tags = 0; + XGetClassHint(dpy, c->win, &ch); +@@ -361,6 +363,7 @@ applyrules(Client *c) + && (!r->instance || strstr(instance, r->instance))) + { + c->isterminal = r->isterminal; ++ c->iscentered = r->iscentered; + c->isfloating = r->isfloating; + c->noswallow = r->noswallow; + c->tags |= r->tags; +@@ -1250,6 +1253,10 @@ manage(Window w, XWindowAttributes *wa) + updatewindowtype(c); + updatesizehints(c); + updatewmhints(c); ++ if (c->iscentered) { ++ c->x = c->mon->mx + (c->mon->mw - WIDTH(c)) / 2; ++ c->y = c->mon->my + (c->mon->mh - HEIGHT(c)) / 2; ++ } + XSelectInput(dpy, w, EnterWindowMask|FocusChangeMask|PropertyChangeMask|StructureNotifyMask); + grabbuttons(c, 0); + if (!c->isfloating) +@@ -2339,8 +2346,10 @@ updatewindowtype(Client *c) + + if (state == netatom[NetWMFullscreen]) + setfullscreen(c, 1); +- if (wtype == netatom[NetWMWindowTypeDialog]) ++ if (wtype == netatom[NetWMWindowTypeDialog]) { ++ c->iscentered = 1; + c->isfloating = 1; ++ } + } + + void diff --git a/platforms/linux/xorg/dwm-rounded.diff b/platforms/linux/xorg/dwm-rounded.diff new file mode 100644 index 0000000..6ad2b53 --- /dev/null +++ b/platforms/linux/xorg/dwm-rounded.diff @@ -0,0 +1,114 @@ +diff --git a/config.h b/config.h +index dffae22..ed83f31 100644 +--- a/config.h ++++ b/config.h +@@ -32,6 +32,7 @@ static char *colors[][3] = { + [SchemeNorm] = { normfgcolor, normbgcolor, normbordercolor }, + [SchemeSel] = { selfgcolor, selbgcolor, selbordercolor }, + }; ++#define CORNER_RADIUS 5 + + typedef struct { + const char *name; +diff --git a/dwm.c b/dwm.c +index 290dc2d..f3e70c9 100644 +--- a/dwm.c ++++ b/dwm.c +@@ -40,6 +40,7 @@ + #ifdef XINERAMA + #include + #endif /* XINERAMA */ ++#include + #include + #include + #include +@@ -315,6 +316,7 @@ static Client *wintosystrayicon(Window w); + static int xerror(Display *dpy, XErrorEvent *ee); + static int xerrordummy(Display *dpy, XErrorEvent *ee); + static int xerrorstart(Display *dpy, XErrorEvent *ee); ++static void drawroundedcorners(Client *c); + static void xrdb(const Arg *arg); + static void zoom(const Arg *arg); + +@@ -1391,6 +1393,9 @@ manage(Window w, XWindowAttributes *wa) + unfocus(selmon->sel, 0); + c->mon->sel = c; + arrange(c->mon); ++ ++ drawroundedcorners(c); ++ + XMapWindow(dpy, c->win); + if (term) + swallow(term, c); +@@ -1508,6 +1513,7 @@ movemouse(const Arg *arg) + togglefloating(NULL); + if (!selmon->lt[selmon->sellt]->arrange || c->isfloating) + resize(c, nx, ny, c->w, c->h, 1); ++ drawroundedcorners(c); + break; + } + } while (ev.type != ButtonRelease); +@@ -1671,6 +1677,55 @@ resizeclient(Client *c, int x, int y, int w, int h) + XSync(dpy, False); + } + ++void drawroundedcorners(Client *c) { ++ // if set to zero in config.h, do not attempt to round ++ if(CORNER_RADIUS < 0) return; ++ ++ // NOTE: this is extremely hacky and surely could be optimized. ++ // Any X wizards out there reading this, please pull request. ++ if (CORNER_RADIUS > 0 && c && !c->isfullscreen) { ++ Window win; ++ win = c->win; ++ if(!win) return; ++ ++ XWindowAttributes win_attr; ++ if(!XGetWindowAttributes(dpy, win, &win_attr)) return; ++ ++ // set in config.h: ++ int dia = 2 * CORNER_RADIUS; ++ int w = c->w; ++ int h = c->h; ++ if(w < dia || h < dia) return; ++ ++ Pixmap mask; ++ mask = XCreatePixmap(dpy, win, w, h, 1); ++ if(!mask) return; ++ ++ XGCValues xgcv; ++ GC shape_gc; ++ shape_gc = XCreateGC(dpy, mask, 0, &xgcv); ++ ++ if(!shape_gc) { ++ XFreePixmap(dpy, mask); ++ free(shape_gc); ++ return; ++ } ++ ++ XSetForeground(dpy, shape_gc, 0); ++ XFillRectangle(dpy, mask, shape_gc, 0, 0, w, h); ++ XSetForeground(dpy, shape_gc, 1); ++ XFillArc(dpy, mask, shape_gc, 0, 0, dia, dia, 0, 23040); ++ XFillArc(dpy, mask, shape_gc, w-dia-1, 0, dia, dia, 0, 23040); ++ XFillArc(dpy, mask, shape_gc, 0, h-dia-1, dia, dia, 0, 23040); ++ XFillArc(dpy, mask, shape_gc, w-dia-1, h-dia-1, dia, dia, 0, 23040); ++ XFillRectangle(dpy, mask, shape_gc, CORNER_RADIUS, 0, w-dia, h); ++ XFillRectangle(dpy, mask, shape_gc, 0, CORNER_RADIUS, w, h-dia); ++ XShapeCombineMask(dpy, win, ShapeBounding, 0, 0, mask, ShapeSet); ++ XFreePixmap(dpy, mask); ++ XFreeGC(dpy, shape_gc); ++ } ++} ++ + void + resizemouse(const Arg *arg) + { +@@ -1726,6 +1781,7 @@ resizemouse(const Arg *arg) + selmon = m; + focus(NULL); + } ++ drawroundedcorners(c); + } + + void diff --git a/platforms/linux/xorg/dwm-systray.diff b/platforms/linux/xorg/dwm-systray.diff new file mode 100644 index 0000000..4abfa93 --- /dev/null +++ b/platforms/linux/xorg/dwm-systray.diff @@ -0,0 +1,731 @@ +diff --git a/config.h b/config.h +index 771e7a1..bb053d8 100644 +--- a/config.h ++++ b/config.h +@@ -3,6 +3,10 @@ + /* appearance */ + static const unsigned int borderpx = 3; /* border pixel of windows */ + static const unsigned int snap = 32; /* snap pixel */ ++static const unsigned int systraypinning = 0; /* 0: sloppy systray follows selected monitor, >0: pin systray to monitor X */ ++static const unsigned int systrayspacing = 2; /* systray spacing */ ++static const int systraypinningfailfirst = 1; /* 1: if pinning fails, display systray on the first monitor, False: display systray on the last monitor*/ ++static const int showsystray = 1; /* 0 means no systray */ + static const unsigned int gappih = 20; /* horiz inner gap between windows */ + static const unsigned int gappiv = 10; /* vert inner gap between windows */ + static const unsigned int gappoh = 10; /* horiz outer gap between windows and screen edge */ +diff --git a/dwm.c b/dwm.c +index 2e43282..127ab8a 100644 +--- a/dwm.c ++++ b/dwm.c +@@ -84,12 +84,30 @@ + } \ + } + ++#define SYSTEM_TRAY_REQUEST_DOCK 0 ++ ++/* XEMBED messages */ ++#define XEMBED_EMBEDDED_NOTIFY 0 ++#define XEMBED_WINDOW_ACTIVATE 1 ++#define XEMBED_FOCUS_IN 4 ++#define XEMBED_MODALITY_ON 10 ++ ++#define XEMBED_MAPPED (1 << 0) ++#define XEMBED_WINDOW_ACTIVATE 1 ++#define XEMBED_WINDOW_DEACTIVATE 2 ++ ++#define VERSION_MAJOR 0 ++#define VERSION_MINOR 0 ++#define XEMBED_EMBEDDED_VERSION (VERSION_MAJOR << 16) | VERSION_MINOR ++ + /* enums */ + enum { CurNormal, CurResize, CurMove, CurLast }; /* cursor */ + enum { SchemeNorm, SchemeSel }; /* color schemes */ + enum { NetSupported, NetWMName, NetWMState, NetWMCheck, ++ NetSystemTray, NetSystemTrayOP, NetSystemTrayOrientation, NetSystemTrayOrientationHorz, + NetWMFullscreen, NetActiveWindow, NetWMWindowType, + NetWMWindowTypeDialog, NetClientList, NetLast }; /* EWMH atoms */ ++enum { Manager, Xembed, XembedInfo, XLast }; /* Xembed atoms */ + enum { WMProtocols, WMDelete, WMState, WMTakeFocus, WMLast }; /* default atoms */ + enum { ClkTagBar, ClkLtSymbol, ClkStatusText, ClkWinTitle, + ClkClientWin, ClkRootWin, ClkLast }; /* clicks */ +@@ -176,6 +194,12 @@ typedef struct { + int monitor; + } Rule; + ++typedef struct Systray Systray; ++struct Systray { ++ Window win; ++ Client *icons; ++}; ++ + /* function declarations */ + static void applyrules(Client *c); + static int applysizehints(Client *c, int *x, int *y, int *w, int *h, int interact); +@@ -208,6 +232,7 @@ static void focusstack(const Arg *arg); + static Atom getatomprop(Client *c, Atom prop); + static int getrootptr(int *x, int *y); + static long getstate(Window w); ++static unsigned int getsystraywidth(); + static int gettextprop(Window w, Atom atom, char *text, unsigned int size); + static void grabbuttons(Client *c, int focused); + static void grabkeys(void); +@@ -227,14 +252,17 @@ static void propertynotify(XEvent *e); + static void pushstack(const Arg *arg); + static void quit(const Arg *arg); + static Monitor *recttomon(int x, int y, int w, int h); ++static void removesystrayicon(Client *i); + static void resize(Client *c, int x, int y, int w, int h, int interact); ++static void resizebarwin(Monitor *m); + static void resizeclient(Client *c, int x, int y, int w, int h); + static void resizemouse(const Arg *arg); ++static void resizerequest(XEvent *e); + static void restack(Monitor *m); + static void run(void); + static void runAutostart(void); + static void scan(void); +-static int sendevent(Client *c, Atom proto); ++static int sendevent(Window w, Atom proto, int m, long d0, long d1, long d2, long d3, long d4); + static void sendmon(Client *c, Monitor *m); + static void setclientstate(Client *c, long state); + static void setfocus(Client *c); +@@ -253,6 +281,7 @@ static void sighup(int unused); + static void sigterm(int unused); + static void spawn(const Arg *arg); + static int stackpos(const Arg *arg); ++static Monitor *systraytomon(Monitor *m); + static void tag(const Arg *arg); + static void tagmon(const Arg *arg); + static void togglebar(const Arg *arg); +@@ -272,12 +301,16 @@ static int updategeom(void); + static void updatenumlockmask(void); + static void updatesizehints(Client *c); + static void updatestatus(void); ++static void updatesystray(void); ++static void updatesystrayicongeom(Client *i, int w, int h); ++static void updatesystrayiconstate(Client *i, XPropertyEvent *ev); + static void updatetitle(Client *c); + static void updatewindowtype(Client *c); + static void updatewmhints(Client *c); + static void view(const Arg *arg); + static Client *wintoclient(Window w); + static Monitor *wintomon(Window w); ++static Client *wintosystrayicon(Window w); + static int xerror(Display *dpy, XErrorEvent *ee); + static int xerrordummy(Display *dpy, XErrorEvent *ee); + static int xerrorstart(Display *dpy, XErrorEvent *ee); +@@ -292,6 +325,7 @@ static pid_t winpid(Window w); + + + /* variables */ ++static Systray *systray = NULL; + static const char broken[] = "broken"; + static char stext[256]; + static char rawstext[256]; +@@ -317,9 +351,10 @@ static void (*handler[LASTEvent]) (XEvent *) = { + [MapRequest] = maprequest, + [MotionNotify] = motionnotify, + [PropertyNotify] = propertynotify, ++ [ResizeRequest] = resizerequest, + [UnmapNotify] = unmapnotify + }; +-static Atom wmatom[WMLast], netatom[NetLast]; ++static Atom wmatom[WMLast], netatom[NetLast], xatom[XLast]; + static int restart = 0; + static int running = 1; + static Cur *cursor[CurLast]; +@@ -560,7 +595,7 @@ buttonpress(XEvent *e) + arg.ui = 1 << i; + } else if (ev->x < x + blw) + click = ClkLtSymbol; +- else if (ev->x > (x = selmon->ww - TEXTW(stext) + lrpad)) { ++ else if (ev->x > (x = selmon->ww - TEXTW(stext) - getsystraywidth() + lrpad)) { + click = ClkStatusText; + + char *text = rawstext; +@@ -620,6 +655,11 @@ cleanup(void) + XUngrabKey(dpy, AnyKey, AnyModifier, root); + while (mons) + cleanupmon(mons); ++ if (showsystray) { ++ XUnmapWindow(dpy, systray->win); ++ XDestroyWindow(dpy, systray->win); ++ free(systray); ++ } + for (i = 0; i < CurLast; i++) + drw_cur_free(drw, cursor[i]); + for (i = 0; i < LENGTH(colors); i++) +@@ -650,9 +690,57 @@ cleanupmon(Monitor *mon) + void + clientmessage(XEvent *e) + { ++ XWindowAttributes wa; ++ XSetWindowAttributes swa; + XClientMessageEvent *cme = &e->xclient; + Client *c = wintoclient(cme->window); + ++ if (showsystray && cme->window == systray->win && cme->message_type == netatom[NetSystemTrayOP]) { ++ /* add systray icons */ ++ if (cme->data.l[1] == SYSTEM_TRAY_REQUEST_DOCK) { ++ if (!(c = (Client *)calloc(1, sizeof(Client)))) ++ die("fatal: could not malloc() %u bytes\n", sizeof(Client)); ++ if (!(c->win = cme->data.l[2])) { ++ free(c); ++ return; ++ } ++ c->mon = selmon; ++ c->next = systray->icons; ++ systray->icons = c; ++ if (!XGetWindowAttributes(dpy, c->win, &wa)) { ++ /* use sane defaults */ ++ wa.width = bh; ++ wa.height = bh; ++ wa.border_width = 0; ++ } ++ c->x = c->oldx = c->y = c->oldy = 0; ++ c->w = c->oldw = wa.width; ++ c->h = c->oldh = wa.height; ++ c->oldbw = wa.border_width; ++ c->bw = 0; ++ c->isfloating = True; ++ /* reuse tags field as mapped status */ ++ c->tags = 1; ++ updatesizehints(c); ++ updatesystrayicongeom(c, wa.width, wa.height); ++ XAddToSaveSet(dpy, c->win); ++ XSelectInput(dpy, c->win, StructureNotifyMask | PropertyChangeMask | ResizeRedirectMask); ++ XReparentWindow(dpy, c->win, systray->win, 0, 0); ++ /* use parents background color */ ++ swa.background_pixel = scheme[SchemeNorm][ColBg].pixel; ++ XChangeWindowAttributes(dpy, c->win, CWBackPixel, &swa); ++ sendevent(c->win, netatom[Xembed], StructureNotifyMask, CurrentTime, XEMBED_EMBEDDED_NOTIFY, 0 , systray->win, XEMBED_EMBEDDED_VERSION); ++ /* FIXME not sure if I have to send these events, too */ ++ sendevent(c->win, netatom[Xembed], StructureNotifyMask, CurrentTime, XEMBED_FOCUS_IN, 0 , systray->win, XEMBED_EMBEDDED_VERSION); ++ sendevent(c->win, netatom[Xembed], StructureNotifyMask, CurrentTime, XEMBED_WINDOW_ACTIVATE, 0 , systray->win, XEMBED_EMBEDDED_VERSION); ++ sendevent(c->win, netatom[Xembed], StructureNotifyMask, CurrentTime, XEMBED_MODALITY_ON, 0 , systray->win, XEMBED_EMBEDDED_VERSION); ++ XSync(dpy, False); ++ resizebarwin(selmon); ++ updatesystray(); ++ setclientstate(c, NormalState); ++ } ++ return; ++ } + if (!c) + return; + if (cme->message_type == netatom[NetWMState]) { +@@ -705,7 +793,7 @@ configurenotify(XEvent *e) + for (c = m->clients; c; c = c->next) + if (c->isfullscreen) + resizeclient(c, m->mx, m->my, m->mw, m->mh); +- XMoveResizeWindow(dpy, m->barwin, m->wx, m->by, m->ww, bh); ++ resizebarwin(m); + } + focus(NULL); + arrange(NULL); +@@ -810,6 +898,12 @@ destroynotify(XEvent *e) + + else if ((c = swallowingclient(ev->window))) + unmanage(c->swallowing, 1); ++ ++ else if ((c = wintosystrayicon(ev->window))) { ++ removesystrayicon(c); ++ resizebarwin(selmon); ++ updatesystray(); ++ } + } + + void +@@ -853,19 +947,23 @@ dirtomon(int dir) + void + drawbar(Monitor *m) + { +- int x, w, tw = 0; ++ int x, w, tw = 0, stw = 0; + int boxs = drw->fonts->h / 9; + int boxw = drw->fonts->h / 6 + 2; + unsigned int i, occ = 0, urg = 0; + Client *c; + ++ if(showsystray && m == systraytomon(m)) ++ stw = getsystraywidth(); ++ + /* draw status first so it can be overdrawn by tags later */ + if (m == selmon) { /* status is only drawn on selected monitor */ + drw_setscheme(drw, scheme[SchemeNorm]); +- tw = TEXTW(stext) - lrpad + 2; /* 2px right padding */ +- drw_text(drw, m->ww - tw, 0, tw, bh, 0, stext, 0); ++ tw = TEXTW(stext) - lrpad / 2 + 2; /* 2px right padding */ ++ drw_text(drw, m->ww - tw - stw, 0, tw, bh, lrpad / 2 - 2, stext, 0); + } + ++ resizebarwin(m); + for (c = m->clients; c; c = c->next) { + occ |= c->tags == 255 ? 0 : c->tags; + if (c->isurgent) +@@ -886,7 +984,7 @@ drawbar(Monitor *m) + drw_setscheme(drw, scheme[SchemeNorm]); + x = drw_text(drw, x, 0, w, bh, lrpad / 2, m->ltsymbol, 0); + +- if ((w = m->ww - tw - x) > bh) { ++ if ((w = m->ww - tw - stw - x) > bh) { + if (m->sel) { + drw_setscheme(drw, scheme[m == selmon ? SchemeSel : SchemeNorm]); + drw_text(drw, x, 0, w, bh, lrpad / 2, m->sel->name, 0); +@@ -897,7 +995,7 @@ drawbar(Monitor *m) + drw_rect(drw, x, 0, w, bh, 1, 1); + } + } +- drw_map(drw, m->barwin, 0, 0, m->ww, bh); ++ drw_map(drw, m->barwin, 0, 0, m->ww - stw, bh); + } + + void +@@ -934,8 +1032,11 @@ expose(XEvent *e) + Monitor *m; + XExposeEvent *ev = &e->xexpose; + +- if (ev->count == 0 && (m = wintomon(ev->window))) ++ if (ev->count == 0 && (m = wintomon(ev->window))) { + drawbar(m); ++ if (m == selmon) ++ updatesystray(); ++ } + } + + void +@@ -1009,10 +1110,17 @@ getatomprop(Client *c, Atom prop) + unsigned long dl; + unsigned char *p = NULL; + Atom da, atom = None; ++ /* FIXME getatomprop should return the number of items and a pointer to ++ * the stored data instead of this workaround */ ++ Atom req = XA_ATOM; ++ if (prop == xatom[XembedInfo]) ++ req = xatom[XembedInfo]; + +- if (XGetWindowProperty(dpy, c->win, prop, 0L, sizeof atom, False, XA_ATOM, ++ if (XGetWindowProperty(dpy, c->win, prop, 0L, sizeof atom, False, req, + &da, &di, &dl, &dl, &p) == Success && p) { + atom = *(Atom *)p; ++ if (da == xatom[XembedInfo] && dl == 2) ++ atom = ((Atom *)p)[1]; + XFree(p); + } + return atom; +@@ -1060,6 +1168,16 @@ getstate(Window w) + return result; + } + ++unsigned int ++getsystraywidth() ++{ ++ unsigned int w = 0; ++ Client *i; ++ if(showsystray) ++ for(i = systray->icons; i; w += i->w + systrayspacing, i = i->next) ; ++ return w ? w + systrayspacing : 1; ++} ++ + int + gettextprop(Window w, Atom atom, char *text, unsigned int size) + { +@@ -1164,7 +1282,7 @@ killclient(const Arg *arg) + { + if (!selmon->sel) + return; +- if (!sendevent(selmon->sel, wmatom[WMDelete])) { ++ if (!sendevent(selmon->sel->win, wmatom[WMDelete], NoEventMask, wmatom[WMDelete], CurrentTime, 0 , 0, 0)) { + XGrabServer(dpy); + XSetErrorHandler(xerrordummy); + XSetCloseDownMode(dpy, DestroyAll); +@@ -1287,6 +1405,12 @@ maprequest(XEvent *e) + { + static XWindowAttributes wa; + XMapRequestEvent *ev = &e->xmaprequest; ++ Client *i; ++ if ((i = wintosystrayicon(ev->window))) { ++ sendevent(i->win, netatom[Xembed], StructureNotifyMask, CurrentTime, XEMBED_WINDOW_ACTIVATE, 0, systray->win, XEMBED_EMBEDDED_VERSION); ++ resizebarwin(selmon); ++ updatesystray(); ++ } + + if (!XGetWindowAttributes(dpy, ev->window, &wa)) + return; +@@ -1434,6 +1558,17 @@ propertynotify(XEvent *e) + Window trans; + XPropertyEvent *ev = &e->xproperty; + ++ ++ if ((c = wintosystrayicon(ev->window))) { ++ if (ev->atom == XA_WM_NORMAL_HINTS) { ++ updatesizehints(c); ++ updatesystrayicongeom(c, c->w, c->h); ++ } ++ else ++ updatesystrayiconstate(c, ev); ++ resizebarwin(selmon); ++ updatesystray(); ++ } + if ((ev->window == root) && (ev->atom == XA_WM_NAME)) { + updatestatus(); + } else if (ev->state == PropertyDelete) { +@@ -1485,6 +1620,20 @@ recttomon(int x, int y, int w, int h) + return r; + } + ++void ++removesystrayicon(Client *i) ++{ ++ Client **ii; ++ ++ if (!showsystray || !i) ++ return; ++ for (ii = &systray->icons; *ii && *ii != i; ii = &(*ii)->next); ++ if (ii) ++ *ii = i->next; ++ free(i); ++} ++ ++ + void + resize(Client *c, int x, int y, int w, int h, int interact) + { +@@ -1492,6 +1641,14 @@ resize(Client *c, int x, int y, int w, int h, int interact) + resizeclient(c, x, y, w, h); + } + ++void ++resizebarwin(Monitor *m) { ++ unsigned int w = m->ww; ++ if (showsystray && m == systraytomon(m)) ++ w -= getsystraywidth(); ++ XMoveResizeWindow(dpy, m->barwin, m->wx, m->by, w, bh); ++} ++ + void + resizeclient(Client *c, int x, int y, int w, int h) + { +@@ -1564,6 +1721,19 @@ resizemouse(const Arg *arg) + } + } + ++void ++resizerequest(XEvent *e) ++{ ++ XResizeRequestEvent *ev = &e->xresizerequest; ++ Client *i; ++ ++ if ((i = wintosystrayicon(ev->window))) { ++ updatesystrayicongeom(i, ev->width, ev->height); ++ resizebarwin(selmon); ++ updatesystray(); ++ } ++} ++ + void + restack(Monitor *m) + { +@@ -1658,26 +1828,36 @@ setclientstate(Client *c, long state) + } + + int +-sendevent(Client *c, Atom proto) ++sendevent(Window w, Atom proto, int mask, long d0, long d1, long d2, long d3, long d4) + { + int n; +- Atom *protocols; ++ Atom *protocols, mt; + int exists = 0; + XEvent ev; + +- if (XGetWMProtocols(dpy, c->win, &protocols, &n)) { +- while (!exists && n--) +- exists = protocols[n] == proto; +- XFree(protocols); ++ if (proto == wmatom[WMTakeFocus] || proto == wmatom[WMDelete]) { ++ mt = wmatom[WMProtocols]; ++ if (XGetWMProtocols(dpy, w, &protocols, &n)) { ++ while (!exists && n--) ++ exists = protocols[n] == proto; ++ XFree(protocols); ++ } ++ } ++ else { ++ exists = True; ++ mt = proto; + } + if (exists) { + ev.type = ClientMessage; +- ev.xclient.window = c->win; +- ev.xclient.message_type = wmatom[WMProtocols]; ++ ev.xclient.window = w; ++ ev.xclient.message_type = mt; + ev.xclient.format = 32; +- ev.xclient.data.l[0] = proto; +- ev.xclient.data.l[1] = CurrentTime; +- XSendEvent(dpy, c->win, False, NoEventMask, &ev); ++ ev.xclient.data.l[0] = d0; ++ ev.xclient.data.l[1] = d1; ++ ev.xclient.data.l[2] = d2; ++ ev.xclient.data.l[3] = d3; ++ ev.xclient.data.l[4] = d4; ++ XSendEvent(dpy, w, False, mask, &ev); + } + return exists; + } +@@ -1691,7 +1871,7 @@ setfocus(Client *c) + XA_WINDOW, 32, PropModeReplace, + (unsigned char *) &(c->win), 1); + } +- sendevent(c, wmatom[WMTakeFocus]); ++ sendevent(c->win, wmatom[WMTakeFocus], NoEventMask, wmatom[WMTakeFocus], CurrentTime, 0, 0, 0); + } + + void +@@ -1813,6 +1993,10 @@ setup(void) + wmatom[WMTakeFocus] = XInternAtom(dpy, "WM_TAKE_FOCUS", False); + netatom[NetActiveWindow] = XInternAtom(dpy, "_NET_ACTIVE_WINDOW", False); + netatom[NetSupported] = XInternAtom(dpy, "_NET_SUPPORTED", False); ++ netatom[NetSystemTray] = XInternAtom(dpy, "_NET_SYSTEM_TRAY_S0", False); ++ netatom[NetSystemTrayOP] = XInternAtom(dpy, "_NET_SYSTEM_TRAY_OPCODE", False); ++ netatom[NetSystemTrayOrientation] = XInternAtom(dpy, "_NET_SYSTEM_TRAY_ORIENTATION", False); ++ netatom[NetSystemTrayOrientationHorz] = XInternAtom(dpy, "_NET_SYSTEM_TRAY_ORIENTATION_HORZ", False); + netatom[NetWMName] = XInternAtom(dpy, "_NET_WM_NAME", False); + netatom[NetWMState] = XInternAtom(dpy, "_NET_WM_STATE", False); + netatom[NetWMCheck] = XInternAtom(dpy, "_NET_SUPPORTING_WM_CHECK", False); +@@ -1820,6 +2004,9 @@ setup(void) + netatom[NetWMWindowType] = XInternAtom(dpy, "_NET_WM_WINDOW_TYPE", False); + netatom[NetWMWindowTypeDialog] = XInternAtom(dpy, "_NET_WM_WINDOW_TYPE_DIALOG", False); + netatom[NetClientList] = XInternAtom(dpy, "_NET_CLIENT_LIST", False); ++ xatom[Manager] = XInternAtom(dpy, "MANAGER", False); ++ xatom[Xembed] = XInternAtom(dpy, "_XEMBED", False); ++ xatom[XembedInfo] = XInternAtom(dpy, "_XEMBED_INFO", False); + /* init cursors */ + cursor[CurNormal] = drw_cur_create(drw, XC_left_ptr); + cursor[CurResize] = drw_cur_create(drw, XC_sizing); +@@ -1828,6 +2015,8 @@ setup(void) + scheme = ecalloc(LENGTH(colors), sizeof(Clr *)); + for (i = 0; i < LENGTH(colors); i++) + scheme[i] = drw_scm_create(drw, colors[i], 3); ++ /* init system tray */ ++ updatesystray(); + /* init bars */ + updatebars(); + updatestatus(); +@@ -1970,7 +2159,18 @@ togglebar(const Arg *arg) + { + selmon->showbar = !selmon->showbar; + updatebarpos(selmon); +- XMoveResizeWindow(dpy, selmon->barwin, selmon->wx, selmon->by, selmon->ww, bh); ++ resizebarwin(selmon); ++ if (showsystray) { ++ XWindowChanges wc; ++ if (!selmon->showbar) ++ wc.y = -bh; ++ else if (selmon->showbar) { ++ wc.y = 0; ++ if (!selmon->topbar) ++ wc.y = selmon->mh - bh; ++ } ++ XConfigureWindow(dpy, systray->win, CWY, &wc); ++ } + arrange(selmon); + } + +@@ -2124,11 +2324,18 @@ unmapnotify(XEvent *e) + else + unmanage(c, 0); + } ++ else if ((c = wintosystrayicon(ev->window))) { ++ /* KLUDGE! sometimes icons occasionally unmap their windows, but do ++ * _not_ destroy them. We map those windows back */ ++ XMapRaised(dpy, c->win); ++ updatesystray(); ++ } + } + + void + updatebars(void) + { ++ unsigned int w; + Monitor *m; + XSetWindowAttributes wa = { + .override_redirect = True, +@@ -2139,10 +2346,15 @@ updatebars(void) + for (m = mons; m; m = m->next) { + if (m->barwin) + continue; +- m->barwin = XCreateWindow(dpy, root, m->wx, m->by, m->ww, bh, 0, DefaultDepth(dpy, screen), ++ w = m->ww; ++ if (showsystray && m == systraytomon(m)) ++ w -= getsystraywidth(); ++ m->barwin = XCreateWindow(dpy, root, m->wx, m->by, w, bh, 0, DefaultDepth(dpy, screen), + CopyFromParent, DefaultVisual(dpy, screen), + CWOverrideRedirect|CWBackPixmap|CWEventMask, &wa); + XDefineCursor(dpy, m->barwin, cursor[CurNormal]->cursor); ++ if (showsystray && m == systraytomon(m)) ++ XMapRaised(dpy, systray->win); + XMapRaised(dpy, m->barwin); + XSetClassHint(dpy, m->barwin, &ch); + } +@@ -2320,6 +2532,121 @@ updatestatus(void) + else + copyvalidchars(stext, rawstext); + drawbar(selmon); ++ updatesystray(); ++} ++ ++void ++updatesystrayicongeom(Client *i, int w, int h) ++{ ++ if (i) { ++ i->h = bh; ++ if (w == h) ++ i->w = bh; ++ else if (h == bh) ++ i->w = w; ++ else ++ i->w = (int) ((float)bh * ((float)w / (float)h)); ++ applysizehints(i, &(i->x), &(i->y), &(i->w), &(i->h), False); ++ /* force icons into the systray dimensions if they don't want to */ ++ if (i->h > bh) { ++ if (i->w == i->h) ++ i->w = bh; ++ else ++ i->w = (int) ((float)bh * ((float)i->w / (float)i->h)); ++ i->h = bh; ++ } ++ } ++} ++ ++void ++updatesystrayiconstate(Client *i, XPropertyEvent *ev) ++{ ++ long flags; ++ int code = 0; ++ ++ if (!showsystray || !i || ev->atom != xatom[XembedInfo] || ++ !(flags = getatomprop(i, xatom[XembedInfo]))) ++ return; ++ ++ if (flags & XEMBED_MAPPED && !i->tags) { ++ i->tags = 1; ++ code = XEMBED_WINDOW_ACTIVATE; ++ XMapRaised(dpy, i->win); ++ setclientstate(i, NormalState); ++ } ++ else if (!(flags & XEMBED_MAPPED) && i->tags) { ++ i->tags = 0; ++ code = XEMBED_WINDOW_DEACTIVATE; ++ XUnmapWindow(dpy, i->win); ++ setclientstate(i, WithdrawnState); ++ } ++ else ++ return; ++ sendevent(i->win, xatom[Xembed], StructureNotifyMask, CurrentTime, code, 0, ++ systray->win, XEMBED_EMBEDDED_VERSION); ++} ++ ++void ++updatesystray(void) ++{ ++ XSetWindowAttributes wa; ++ XWindowChanges wc; ++ Client *i; ++ Monitor *m = systraytomon(NULL); ++ unsigned int x = m->mx + m->mw; ++ unsigned int w = 1; ++ ++ if (!showsystray) ++ return; ++ if (!systray) { ++ /* init systray */ ++ if (!(systray = (Systray *)calloc(1, sizeof(Systray)))) ++ die("fatal: could not malloc() %u bytes\n", sizeof(Systray)); ++ systray->win = XCreateSimpleWindow(dpy, root, x, m->by, w, bh, 0, 0, scheme[SchemeSel][ColBg].pixel); ++ wa.event_mask = ButtonPressMask | ExposureMask; ++ wa.override_redirect = True; ++ wa.background_pixel = scheme[SchemeNorm][ColBg].pixel; ++ XSelectInput(dpy, systray->win, SubstructureNotifyMask); ++ XChangeProperty(dpy, systray->win, netatom[NetSystemTrayOrientation], XA_CARDINAL, 32, ++ PropModeReplace, (unsigned char *)&netatom[NetSystemTrayOrientationHorz], 1); ++ XChangeWindowAttributes(dpy, systray->win, CWEventMask|CWOverrideRedirect|CWBackPixel, &wa); ++ XMapRaised(dpy, systray->win); ++ XSetSelectionOwner(dpy, netatom[NetSystemTray], systray->win, CurrentTime); ++ if (XGetSelectionOwner(dpy, netatom[NetSystemTray]) == systray->win) { ++ sendevent(root, xatom[Manager], StructureNotifyMask, CurrentTime, netatom[NetSystemTray], systray->win, 0, 0); ++ XSync(dpy, False); ++ } ++ else { ++ fprintf(stderr, "dwm: unable to obtain system tray.\n"); ++ free(systray); ++ systray = NULL; ++ return; ++ } ++ } ++ for (w = 0, i = systray->icons; i; i = i->next) { ++ /* make sure the background color stays the same */ ++ wa.background_pixel = scheme[SchemeNorm][ColBg].pixel; ++ XChangeWindowAttributes(dpy, i->win, CWBackPixel, &wa); ++ XMapRaised(dpy, i->win); ++ w += systrayspacing; ++ i->x = w; ++ XMoveResizeWindow(dpy, i->win, i->x, 0, i->w, i->h); ++ w += i->w; ++ if (i->mon != m) ++ i->mon = m; ++ } ++ w = w ? w + systrayspacing : 1; ++ x -= w; ++ XMoveResizeWindow(dpy, systray->win, x, m->by, w, bh); ++ wc.x = x; wc.y = m->by; wc.width = w; wc.height = bh; ++ wc.stack_mode = Above; wc.sibling = m->barwin; ++ XConfigureWindow(dpy, systray->win, CWX|CWY|CWWidth|CWHeight|CWSibling|CWStackMode, &wc); ++ XMapWindow(dpy, systray->win); ++ XMapSubwindows(dpy, systray->win); ++ /* redraw background */ ++ XSetForeground(dpy, drw->gc, scheme[SchemeNorm][ColBg].pixel); ++ XFillRectangle(dpy, systray->win, drw->gc, 0, 0, w, bh); ++ XSync(dpy, False); + } + + void +@@ -2491,6 +2818,16 @@ wintoclient(Window w) + return NULL; + } + ++Client * ++wintosystrayicon(Window w) { ++ Client *i = NULL; ++ ++ if (!showsystray || !w) ++ return i; ++ for (i = systray->icons; i && i->win != w; i = i->next) ; ++ return i; ++} ++ + Monitor * + wintomon(Window w) + { +@@ -2555,6 +2892,22 @@ xrdb(const Arg *arg) + arrange(NULL); + } + ++Monitor * ++systraytomon(Monitor *m) { ++ Monitor *t; ++ int i, n; ++ if(!systraypinning) { ++ if(!m) ++ return selmon; ++ return m == selmon ? m : NULL; ++ } ++ for(n = 1, t = mons; t && t->next; n++, t = t->next) ; ++ for(i = 1, t = mons; t && t->next && i < systraypinning; i++, t = t->next) ; ++ if(systraypinningfailfirst && n < systraypinning) ++ return mons; ++ return t; ++} ++ + void + zoom(const Arg *arg) + { diff --git a/platforms/linux/xorg/dwmblocks.diff b/platforms/linux/xorg/dwmblocks.diff new file mode 100644 index 0000000..ad22dac --- /dev/null +++ b/platforms/linux/xorg/dwmblocks.diff @@ -0,0 +1,26 @@ +diff --git a/config.h b/config.h +index cc9281b..3df46fc 100644 +--- a/config.h ++++ b/config.h +@@ -10,17 +10,17 @@ static const Block blocks[] = { + /* {"", "price btc Bitcoin 💰", 0, 21}, */ + /* {"", "price lbc \"LBRY Token\" 📚", 0, 22}, */ + {"", "torrent", 20, 7}, +- /* {"", "memory", 10, 14}, */ +- /* {"", "cpu", 10, 18}, */ ++ {"", "memory", 10, 14}, ++ {"", "cpu", 10, 18}, + /* {"", "moonphase", 18000, 17}, */ + {"", "weather", 18000, 5}, + {"", "mailbox", 180, 12}, +- /* {"", "nettraf", 1, 16}, */ ++ {"", "nettraf", 1, 16}, + {"", "volume", 0, 10}, + {"", "battery", 5, 3}, + {"", "clock", 60, 1}, + {"", "internet", 5, 4}, +- {"", "help-icon", 0, 15}, ++ /* {"", "help-icon", 0, 15}, */ + }; + + //Sets delimiter between status commands. NULL character ('\0') means no delimiter. -- cgit 1.4.1