dwm-custom/config.h

/* See LICENSE file for copyright and license details. */

#define TERM "st"
#define TERM_FLAG_NAME "-n"
#define TERM_FLAG_EXEC "-e"
#define TERM_FLAG_CLASS "-c"

#define BROWSER "firefox"
#define BROWSER_FLAG_INCOG "--private-window"
#define BROWSER_FLAG_1 "--disable-pinch"

#define STATUSBAR "dwmblocks"

/* appearance */
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 */
static const int focusonwheel            = 0;
static int floatposgrid_x                = 5;  /* float grid columns */
static int floatposgrid_y                = 5;  /* float grid rows */
/* Status is to be shown on: -1 (all monitors), 0 (a specific monitor by index), 'A' (active monitor) */

/* Indicators: see patch/bar_indicators.h for options */
static int tagindicatortype              = INDICATOR_NONE;
static int tiledindicatortype            = INDICATOR_NONE;
static int floatindicatortype            = INDICATOR_NONE;
static const int quit_empty_window_count = 0;   /* only allow dwm to quit if no (<= count) windows are open */
static const char font[]                 = "FiraCode Nerd Font 12";

#define BLACK "#15161E"
#define RED "#f7768e"
#define GREEN "#9ece6a"
#define ORANGE "#e0af68"
#define BLUE "#7aa2f7"
#define MAGENTA "#bb9af7"
#define CYAN "#7dcfff"
#define LIGHT_GRAY "#a9b1d6"
#define GRAY "#414868"
#define WHITE "#c0caf5"
#define UNDEFINED "#ff0000"

static char undefined[]                  = UNDEFINED; // placeholder value

static char normfgcolor[]                = WHITE;
static char normbgcolor[]                = BLACK;
static char normbordercolor[]            = GRAY;
static char normfloatcolor[]             = GRAY;

static char selfgcolor[]                 = UNDEFINED;
static char selbgcolor[]                 = UNDEFINED;
static char selbordercolor[]             = BLUE;
static char selfloatcolor[]              = BLUE;

static char titlenormfgcolor[]           = WHITE;
static char titlenormbgcolor[]           = BLACK;
static char titlenormbordercolor[]       = UNDEFINED;
static char titlenormfloatcolor[]        = UNDEFINED;

static char titleselfgcolor[]            = LIGHT_GRAY;
static char titleselbgcolor[]            = BLACK;
static char titleselbordercolor[]        = UNDEFINED;
static char titleselfloatcolor[]         = UNDEFINED;

static char tagsnormfgcolor[]            = LIGHT_GRAY;
static char tagsnormbgcolor[]            = BLACK;
static char tagsnormbordercolor[]        = UNDEFINED;
static char tagsnormfloatcolor[]         = UNDEFINED;

static char tagsselfgcolor[]             = BLACK;
static char tagsselbgcolor[]             = BLUE;
static char tagsselbordercolor[]         = UNDEFINED;
static char tagsselfloatcolor[]          = UNDEFINED;

static char hidnormfgcolor[]             = UNDEFINED;
static char hidselfgcolor[]              = UNDEFINED;
static char hidnormbgcolor[]             = UNDEFINED;
static char hidselbgcolor[]              = UNDEFINED;

static char urgfgcolor[]                 = BLACK;
static char urgbgcolor[]                 = RED;
static char urgbordercolor[]             = RED;
static char urgfloatcolor[]              = RED;

static char scratchselfgcolor[]          = UNDEFINED;
static char scratchselbgcolor[]          = UNDEFINED;
static char scratchselbordercolor[]      = BLUE;
static char scratchselfloatcolor[]       = BLUE;

static char scratchnormfgcolor[]         = UNDEFINED;
static char scratchnormbgcolor[]         = UNDEFINED;
static char scratchnormbordercolor[]     = GRAY;
static char scratchnormfloatcolor[]      = GRAY;

static char *colors[][ColCount] = {
	/*                       fg                bg                border                float */
	[SchemeNorm]         = { normfgcolor,      normbgcolor,      normbordercolor,      normfloatcolor },
	[SchemeSel]          = { selfgcolor,       selbgcolor,       selbordercolor,       selfloatcolor },
	[SchemeTitleNorm]    = { titlenormfgcolor, titlenormbgcolor, titlenormbordercolor, titlenormfloatcolor },
	[SchemeTitleSel]     = { titleselfgcolor,  titleselbgcolor,  titleselbordercolor,  titleselfloatcolor },
	[SchemeTagsNorm]     = { tagsnormfgcolor,  tagsnormbgcolor,  tagsnormbordercolor,  tagsnormfloatcolor },
	[SchemeTagsSel]      = { tagsselfgcolor,   tagsselbgcolor,   tagsselbordercolor,   tagsselfloatcolor },
	[SchemeHidNorm]      = { hidnormfgcolor,   hidnormbgcolor,   undefined,              undefined },
	[SchemeHidSel]       = { hidselfgcolor,    hidselbgcolor,    undefined,              undefined },
	[SchemeUrg]          = { urgfgcolor,       urgbgcolor,       urgbordercolor,       urgfloatcolor },
	[SchemeScratchSel]  = { scratchselfgcolor, scratchselbgcolor, scratchselbordercolor, scratchselfloatcolor },
	[SchemeScratchNorm] = { scratchnormfgcolor, scratchnormbgcolor, scratchnormbordercolor, scratchnormfloatcolor },
};

static char *tagicons[][NUMTAGS] =
{
	[DEFAULT_TAGS]        = { "1", "2", "3", "4", "5", "6", "7", "8", "9" },
};

static const int autostart_kill_signal = SIGHUP;
static const char *const autostart[] = {
    "/bin/sh", "-c", "exec run-parts \"${XDG_CONFIG_HOME}/dwm/autorun.d\"", NULL,
    "/bin/sh", "-c", "exec runsvdir \"${SVDIR}\"", NULL,
    NULL
};

static const char *spterm[] = { "t", TERM, TERM_FLAG_CLASS, "spterm", NULL };
static const char *spfile[] = { "f", TERM, TERM_FLAG_CLASS, "spfile", TERM_FLAG_EXEC, "lfX", NULL };
static const char *spproc[] = { "p", TERM, TERM_FLAG_CLASS, "spproc", TERM_FLAG_EXEC, "btm", NULL };
static const char *spdisk[] = { "d", TERM, TERM_FLAG_CLASS, "spdisk", TERM_FLAG_EXEC, "dua", "i", "/", NULL };
static const char *spvolm[] = { "v", TERM, TERM_FLAG_CLASS, "spvolm", TERM_FLAG_EXEC, "ncpamixer", NULL };
static const char *sphelp[] = { "h", TERM, TERM_FLAG_CLASS, "sphelp", TERM_FLAG_EXEC, "/bin/sh", "-c", "glow -p -s $XDG_CONFIG_HOME/glow/style.json /usr/share/dwm/dwm.md", NULL };
static const char *spnetm[] = { "m", TERM, TERM_FLAG_CLASS, "spnetm", TERM_FLAG_EXEC, "nmtui", NULL };
static const char *spnetu[] = { "u", TERM, TERM_FLAG_CLASS, "spnetu", TERM_FLAG_EXEC, "bandwhich", NULL };
static const char *spwiki[] = { "w", TERM, TERM_FLAG_CLASS, "spwiki", TERM_FLAG_EXEC, "zk", "edit", "-i", NULL };
static const char *spcalc[] = { "c", TERM, TERM_FLAG_CLASS, "spcalc", TERM_FLAG_EXEC, "bc", "-li", NULL };

static const Rule rules[] = {
    /* xprop(1):
     *  WM_CLASS(STRING) = instance, class
     *  WM_NAME(STRING) = title
     *  WM_WINDOW_ROLE(STRING) = role
     *  _NET_WM_WINDOW_TYPE(ATOM) = wintype
     */
    RULE(.wintype = WTYPE "DIALOG", .isfloating = 1)
    RULE(.wintype = WTYPE "UTILITY", .isfloating = 1)
    RULE(.wintype = WTYPE "TOOLBAR", .isfloating = 1)
    RULE(.wintype = WTYPE "SPLASH", .isfloating = 1)
    RULE(.role = "pop-up", .isfloating = 1)
    RULE(.class = "Dragon-drop", .isfloating = 1, .iscentered = 1)
    RULE(.class = "St", .isfloating = 0)
    RULE(.class = "mpv", .isfloating = 0)
    RULE(.class = "Ferdium", .monitor = 1, .tags = 1 << 0)
    RULE(.class = "Thunderbird", .monitor = 1, .tags = 1 << 1)
    RULE(.class = "sphelp", .scratchkey = 'h', .isfloating = 1, .iscentered = 1, .floatpos = "50% 50% 50% 90%")
    RULE(.class = "spcalc", .scratchkey = 'c', .isfloating = 1, .iscentered = 1, .floatpos = "50% 50% 50% 90%")
    RULE(.class = "spwiki", .scratchkey = 'w', .isfloating = 1, .iscentered = 1, .floatpos = "50% 50% 50% 90%")
    RULE(.class = "spterm", .scratchkey = 't', .isfloating = 1, .iscentered = 1, .floatpos = "50% 50% 90% 90%")
    RULE(.class = "spfile", .scratchkey = 'f', .isfloating = 1, .iscentered = 1, .floatpos = "50% 50% 90% 90%")
    RULE(.class = "spdisk", .scratchkey = 'd', .isfloating = 1, .iscentered = 1, .floatpos = "50% 50% 90% 90%")
    RULE(.class = "spproc", .scratchkey = 'p', .isfloating = 1, .iscentered = 1, .floatpos = "50% 50% 90% 90%")
    RULE(.class = "spnetu", .scratchkey = 'u', .isfloating = 1, .iscentered = 1, .floatpos = "50% 50% 90% 90%")
    RULE(.class = "spvolm", .scratchkey = 'v', .isfloating = 1, .floatpos = "100% 100% 900W 500H")
    RULE(.class = "spnetm", .scratchkey = 'm', .isfloating = 1, .floatpos = "100% 100% 900W 900H")
};

static const BarRule barrules[] = {
	/* monitor   bar    alignment         widthfunc                 drawfunc                clickfunc                hoverfunc                name */
	{ -1,        0,     BAR_ALIGN_LEFT,   width_tags,               draw_tags,              click_tags,              hover_tags,              "tags" },
	{ 'A',       0,     BAR_ALIGN_RIGHT,  width_status,             draw_status,            click_status,            NULL,                    "status" },
	{ -1,        0,     BAR_ALIGN_NONE,   width_wintitle,           draw_wintitle,          click_wintitle,          NULL,                    "wintitle" },
};

/* layout(s) */
static const float mfact     = 0.50; /* factor of master area size [0.05..0.95] */
static const int nmaster     = 1;    /* number of clients in master area */
static const int resizehints = 0;    /* 1 means respect size hints in tiled resizals */
static const int lockfullscreen = 1; /* 1 will force focus on the fullscreen window */

static const Layout layouts[] = {
	/* symbol     arrange function */
	{ "[]=",      tile },    /* first entry is default */
	{ "[M]",      monocle },
	{ "TTT",      bstack },
	{ "|M|",      centeredmaster },
	{ "[D]",      deck },
	{ ":::",      gaplessgrid },
	{ "><>",      NULL },    /* no layout function means floating behavior */
};


/* key definitions */
#define MODKEY Mod4Mask
#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 const char *termcmd[]  = { TERM, NULL };

#include <X11/XF86keysym.h>
static const Key keys[] = {
    /* modifier            key                 function            argument */
    { MODKEY,              XK_F1,              togglescratch,      {.v = sphelp} },
    // { MODKEY | ShiftMask,  XK_F1,              spawn,              {.v = (const char *[]){NULL}} },
    { MODKEY,              XK_F2,              spawn,              SHCMD("$HOME/.local/libexec/dwm/dmenuhandler") },
    // { MODKEY | ShiftMask,  XK_F2,              spawn,              {.v = (const char *[]){NULL}} },
    { MODKEY,              XK_F3,              spawn,              SHCMD("$HOME/.local/libexec/dwm/togtouchpad") },
    // { MODKEY | ShiftMask,  XK_F3,              spawn,              {.v = (const char *[]){NULL}} },
    { MODKEY,              XK_F4,              spawn,              SHCMD("$HOME/.local/libexec/dwm/togcompositor") },
    // { MODKEY | ShiftMask,  XK_F4,              spawn,              {.v = (const char *[]){NULL}} },
    { MODKEY,              XK_F5,              spawn,              {.v = (const char *[]){"clipmenu", NULL}} },
    // { MODKEY | ShiftMask,  XK_F5,              spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY,              XK_F6,              spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY | ShiftMask,  XK_F6,              spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY,              XK_F7,              spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY | ShiftMask,  XK_F7,              spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY,              XK_F8,              spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY | ShiftMask,  XK_F8,              spawn,              {.v = (const char *[]){NULL}} },
    { MODKEY,              XK_F9,              spawn,              SHCMD("$HOME/.local/libexec/dwm/dmenumount") },
    // { MODKEY | ShiftMask,  XK_F9,              spawn,              {.v = (const char *[]){NULL}} },
    { MODKEY,              XK_F10,             spawn,              SHCMD("$HOME/.local/libexec/dwm/dmenuumount") },
    // { MODKEY | ShiftMask,  XK_F10,             spawn,              {.v = (const char *[]){NULL}} },
    { MODKEY,              XK_F11,             spawn,              SHCMD("$HOME/.local/libexec/dwm/displayselect") },
    // { MODKEY | ShiftMask,  XK_F11,             spawn,              {.v = (const char *[]){NULL}} },
    { MODKEY,              XK_F12,             spawn,              {.v = (const char *[]){"remaps", NULL}} },
    // { MODKEY | ShiftMask,  XK_F12,             spawn,              {.v = (const char *[]){NULL}} },
    { MODKEY,              XK_grave,           spawn,              SHCMD("$HOME/.local/libexec/dwm/dmenuunicode --nocopy") },
    { MODKEY | ShiftMask,  XK_grave,           spawn,              SHCMD("$HOME/.local/libexec/dwm/dmenuunicode") },
    TAGKEYS(               XK_1,                                   0),
    TAGKEYS(               XK_2,                                   1),
    TAGKEYS(               XK_3,                                   2),
    TAGKEYS(               XK_4,                                   3),
    TAGKEYS(               XK_5,                                   4),
    TAGKEYS(               XK_6,                                   5),
    TAGKEYS(               XK_7,                                   6),
    TAGKEYS(               XK_8,                                   7),
    TAGKEYS(               XK_9,                                   8),
    { MODKEY,              XK_0,               view,          {.ui = ~0} },
    { MODKEY | ShiftMask,  XK_0,               tag,           {.ui = ~0} },
    // { MODKEY | ShiftMask,  XK_0,               spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY,              XK_bracketleft,     spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY | ShiftMask,  XK_bracketleft,     spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY,              XK_bracketright,    spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY | ShiftMask,  XK_bracketright,    spawn,              {.v = (const char *[]){NULL}} },
    { MODKEY,              XK_BackSpace,       spawn,              SHCMD("$HOME/.local/libexec/dwm/dmenusys") },
    // { MODKEY | ShiftMask,  XK_BackSpace,       spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY,              XK_Tab,             spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY | ShiftMask,  XK_Tab,             spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY,              XK_apostrophe,      spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY | ShiftMask,  XK_apostrophe,      spawn,              {.v = (const char *[]){NULL}} },
    { MODKEY,              XK_comma,           focusmon,           {.i = +1} },
    { MODKEY | ShiftMask,  XK_comma,           tagmon,             {.i = +1} },
    { MODKEY,              XK_period,          focusmon,           {.i = -1} },
    { MODKEY | ShiftMask,  XK_period,          tagmon,             {.i = -1} },
    { MODKEY,              XK_p,               spawn,              {.v = (const char *[]){"playerctl", "play-pause", NULL}} },
    // { MODKEY | ShiftMask,  XK_p,               spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY,              XK_y,               spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY | ShiftMask,  XK_y,               spawn,              {.v = (const char *[]){NULL}} },
    { MODKEY,              XK_f,               togglefullscreen,      {0} },
    { MODKEY | ShiftMask,  XK_f,               setlayout,          {.v = &layouts[6]} },
    { MODKEY,              XK_g,               setlayout,          {.v = &layouts[0]} },
    { MODKEY | ShiftMask,  XK_g,               setlayout,          {.v = &layouts[1]} },
    { MODKEY,              XK_c,               setlayout,          {.v = &layouts[2]} },
    { MODKEY | ShiftMask,  XK_c,               setlayout,          {.v = &layouts[3]} },
    { MODKEY,              XK_r,               setlayout,          {.v = &layouts[4]} },
    { MODKEY | ShiftMask,  XK_r,               setlayout,          {.v = &layouts[5]} },
    { MODKEY,              XK_l,               focusdir,           {.i = 1} },
    { MODKEY | ShiftMask,  XK_l,               pushstack,          {.i = INC(+1)} },
    // { MODKEY,              XK_slash,           spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY | ShiftMask,  XK_slash,           spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY,              XK_equal,           spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY | ShiftMask,  XK_equal,           spawn,              {.v = (const char *[]){NULL}} },
    { MODKEY,              XK_a,               togglescratch,      {.v = spdisk} },
    // { MODKEY | ShiftMask,  XK_a,               spawn,              {.v = (const char *[]){NULL}} },
    { MODKEY,              XK_o,               togglescratch,      {.v = spproc} },
    { MODKEY | ShiftMask,  XK_o,               togglescratch,      {.v = spnetu} },
    { MODKEY,              XK_e,               togglescratch,      {.v = spfile} },
    // { MODKEY | ShiftMask,  XK_e,               spawn,              {.v = (const char *[]){NULL}} },
    { MODKEY,              XK_u,               spawn,              {.v = (const char *[]){"dmenu_run", NULL}} },
    // { MODKEY | ShiftMask,  XK_u,               spawn,              {.v = (const char *[]){NULL}} },
    { MODKEY,              XK_i,               spawn,              {.v = (const char *[]){"dunstctl", "close", NULL}} },
    { MODKEY | ShiftMask,  XK_i,               spawn,              {.v = (const char *[]){"dunstctl", "history-pop", NULL}} },
    { MODKEY,              XK_d,               spawn,              {.v = (const char *[]){"dunstctl", "context", NULL}} },
    { MODKEY | ShiftMask,  XK_d,               spawn,              {.v = (const char *[]){"dunstctl", "action", "0", NULL}} },
    { MODKEY,              XK_h,               focusdir,           {.i = 0 } },
    { MODKEY | ShiftMask,  XK_h,               pushstack,          {.i = INC(-1)} },
    { MODKEY,              XK_t,               spawn,              {.v = (const char *[]){BROWSER, BROWSER_FLAG_1, NULL}} },
    { MODKEY | ShiftMask,  XK_t,               spawn,              {.v = (const char *[]){BROWSER, BROWSER_FLAG_1, BROWSER_FLAG_INCOG, NULL}} },
    { MODKEY,              XK_n,               focusstack,         {.i = PREVSEL} },
    { MODKEY | ShiftMask,  XK_n,               focusstack,         {.i = 0} },
    { MODKEY,              XK_s,               setmfact,           {.f = +0.05} },
    { MODKEY | ShiftMask,  XK_s,               setmfact,           {.f = -0.05} },
    // { MODKEY | ShiftMask,  XK_s,               spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY,              XK_minus,           spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY | ShiftMask,  XK_minus,           spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY,              XK_backslash,       spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY | ShiftMask,  XK_backslash,       spawn,              {.v = (const char *[]){NULL}} },
    { MODKEY,              XK_Return,           zoom,              {0} },
    // { MODKEY | ShiftMask,  XK_Return,           spawn,             {.v = (const char *[]){NULL}} },
    // { MODKEY,              XK_semicolon,       spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY | ShiftMask,  XK_semicolon,       spawn,              {.v = (const char *[]){NULL}} },
    { MODKEY,              XK_q,               killclient,         {0} },
    // { MODKEY | ShiftMask,  XK_q,               spawn,              {.v = (const char *[]){NULL}} },
    { MODKEY,              XK_j,               focusdir,           {.i = 3} },
    { MODKEY | ShiftMask,  XK_j,               focusstack,         {.i = INC(+1) } },
    { MODKEY,              XK_k,               focusdir,           {.i = 2} },
    { MODKEY | ShiftMask,  XK_k,               focusstack,         {.i = INC(-1) } },
    { MODKEY,              XK_x,               togglefloating,     {0} },
    { MODKEY | ShiftMask,  XK_x,               unfloatvisible,     {0} },
    { MODKEY,              XK_b,               togglescratch,      {.v = spnetm} },
    // { MODKEY | ShiftMask,  XK_b,               spawn,              {.v = (const char *[]){NULL}} },
    { MODKEY,              XK_m,               togglescratch,      {.v = spvolm} },
    { MODKEY | ShiftMask,  XK_m,               spawn,              SHCMD("$HOME/.local/libexec/dwm/pamixer-notify -t") },
    { MODKEY,              XK_w,               togglescratch,      {.v = spwiki} },
    // { MODKEY | ShiftMask,  XK_w,               spawn,              {.v = (const char *[]){NULL}} },
    { MODKEY,              XK_v,               togglescratch,      {.v = spcalc} },
    // { MODKEY | ShiftMask,  XK_v,               spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY,              XK_z,               spawn,              {.v = (const char *[]){NULL}} }, TODO: Maybe oatmeal scratchpad?
    // { MODKEY | ShiftMask,  XK_z,               spawn,              {.v = (const char *[]){NULL}} },
    { MODKEY,              XK_space,           spawn,              {.v = termcmd} },
    { MODKEY | ShiftMask,  XK_space,           togglescratch,      {.v = spterm} },
    { MODKEY,              XK_Print,           spawn,              SHCMD("$HOME/.local/libexec/dwm/dmenurecord") },
    { MODKEY | ShiftMask,  XK_Print,           spawn,              SHCMD("$HOME/.local/libexec/dwm/dmenurecord kill") },
    { 0,                   XK_Print,           spawn,              SHCMD("$HOME/.local/libexec/dwm/dmenumaim full") },
    { ShiftMask,           XK_Print,           spawn,              SHCMD("$HOME/.local/libexec/dwm/dmenumaim") },
    // { MODKEY,              XK_Scroll_Lock,     spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY | ShiftMask,  XK_Scroll_Lock,     spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY,              XK_Pause,           spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY | ShiftMask,  XK_Pause,           spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY,              XK_Insert,          spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY | ShiftMask,  XK_Insert,          spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY,              XK_Home,            spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY | ShiftMask,  XK_Home,            spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY,              XK_Page_Up,         spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY | ShiftMask,  XK_Page_Up,         spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY,              XK_Delete,          spawn,              {.v = (const char *[]){NULL}} },
    { MODKEY | ShiftMask,  XK_Delete,          quit,              {0} },
    // { MODKEY,              XK_End,             spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY | ShiftMask,  XK_End,             spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY,              XK_Page_Down,       spawn,              {.v = (const char *[]){NULL}} },
    // { MODKEY | ShiftMask,  XK_Page_Down,       spawn,              {.v = (const char *[]){NULL}} },
    { MODKEY,              XK_Left,            spawn,              {.v = (const char *[]){"playerctl", "position", "5-", NULL}} },
    { MODKEY | ShiftMask,  XK_Left,            spawn,              {.v = (const char *[]){"playerctl", "previous", NULL}} },
    { MODKEY,              XK_Right,           spawn,              {.v = (const char *[]){"playerctl", "position", "5+", NULL}} },
    { MODKEY | ShiftMask,  XK_Right,           spawn,              {.v = (const char *[]){"playerctl", "next", NULL}} },
    { MODKEY,              XK_Up,              spawn,              SHCMD("$HOME/.local/libexec/dwm/pamixer-notify --allow-boost -i 5") },
    { MODKEY | ShiftMask,  XK_Up,              spawn,              {.v = (const char *[]){"playerctl", "volume", "5+", NULL}} },
    { MODKEY,              XK_Down,            spawn,              SHCMD("$HOME/.local/libexec/dwm/pamixer-notify --allow-boost -d 5") },
    { MODKEY | ShiftMask,  XK_Down,            spawn,              {.v = (const char *[]){"playerctl", "volume", "5-", NULL}} },

    { 0,             XF86XK_AudioMute,         spawn,              SHCMD("$HOME/.local/libexec/dwm/pamixer-notify -t") },
    { 0,             XF86XK_AudioRaiseVolume,  spawn,              SHCMD("$HOME/.local/libexec/dwm/pamixer-notify --allow-boost -i 5") },
    { 0,             XF86XK_AudioLowerVolume,  spawn,              SHCMD("$HOME/.local/libexec/dwm/pamixer-notify --allow-boost -d 5") },
    { 0,             XF86XK_AudioPrev,         spawn,              {.v = (const char *[]){"playerctl", "previous", NULL}} },
    { 0,             XF86XK_AudioNext,         spawn,              {.v = (const char *[]){"playerctl", "next", NULL}} },
    { 0,             XF86XK_AudioPause,        spawn,              {.v = (const char *[]){"playerctl", "pause", NULL}} },
    { 0,             XF86XK_AudioPlay,         spawn,              {.v = (const char *[]){"playerctl", "play-pause", NULL}} }, // Most keyboards only have a play button
    { 0,             XF86XK_AudioStop,         spawn,              {.v = (const char *[]){"playerctl", "stop", NULL}} },
    { 0,             XF86XK_AudioRewind,       spawn,              {.v = (const char *[]){"playerctl", "position", "5-", NULL}} },
    { 0,             XF86XK_AudioForward,      spawn,              {.v = (const char *[]){"playerctl", "position", "5+", NULL}} },
    // {             0, XF86XK_AudioMedia,        spawn,              {.v = (const char *[]){NULL}} },
    { 0,             XF86XK_AudioMicMute,      spawn,              {.v = (const char *[]){"pactl", "set-source-mute", "@DEFAULT_SOURCE@", "toggle", NULL}} }, /* TODO: Test this */
    { 0,             XF86XK_PowerOff,          spawn,              {.v = (const char *[]){"dmenusys", NULL}} },
    { 0,             XF86XK_Calculator,        spawn,              {.v = (const char *[]){TERM, "-e", "bc", "-li", NULL}} },
    { 0,             XF86XK_Sleep,             spawn,              {.v = (const char *[]){"loginctl", "suspend", "-i", NULL}} },
    { 0,             XF86XK_WWW,               spawn,              {.v = (const char *[]){BROWSER, BROWSER_FLAG_1, NULL}} },
    // {             0, XF86XK_WLAN,              spawn,              {.v = (const char *[]){NULL}} },
    { 0,             XF86XK_DOS,               spawn,              {.v = (const char *[]){TERM, NULL}} },
    { 0,             XF86XK_ScreenSaver,       spawn,              {.v = (const char *[]){"xset", "s", "activate", NULL}} },
    { 0,             XF86XK_TaskPane,          spawn,              {.v = (const char *[]){TERM, "-e", "htop", NULL}} },
    // {             0, XF86XK_Mail,              spawn,              {.v = (const char *[]){NULL}} },
    { 0,             XF86XK_MyComputer,        spawn,              {.v = (const char *[]){TERM, "-e", "lfX", "/", NULL}} },
    // {             0, XF86XK_Battery,           spawn,              {.v = (const char *[]){NULL}} },
    // {             0, XF86XK_Launch1,           spawn,              {.v = (const char *[]){NULL}} },
    { 0,             XF86XK_TouchpadToggle,    spawn,              SHCMD("$HOME/.local/libexec/dwm/togtouchpad") },
    { 0,             XF86XK_TouchpadOff,       spawn,              SHCMD("$HOME/.local/libexec/dwm/togtouchpad -n") },
    { 0,             XF86XK_TouchpadOn,        spawn,              SHCMD("$HOME/.local/libexec/dwm/togtouchpad -y") },
    { 0,             XF86XK_MonBrightnessUp,   spawn,              SHCMD("$HOME/.local/libexec/dwm/brightness-notify +5") },
    { 0,             XF86XK_MonBrightnessDown, spawn,              SHCMD("$HOME/.local/libexec/dwm/brightness-notify -5") },
    /* WARN: If you have multiple backlight controllers this will fail */
};


/* button definitions */
/* click can be ClkTagBar, ClkLtSymbol, ClkStatusText, ClkWinTitle, ClkClientWin, or ClkRootWin */
static const Button buttons[] = {
	/* click                event mask           button          function        argument */
	/*{ ClkLtSymbol,          0,                   Button1,        setlayout,      {0} },*/
	/*{ ClkLtSymbol,          0,                   Button3,        setlayout,      {.v = &layouts[2]} },*/
	/*{ ClkWinTitle,          0,                   Button2,        zoom,           {0} },*/
	{ 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} },
};