Vanity gaps not working

[0xGodspeed]

I installed dwm after enabling vanity gaps and some other patches. Everything except the gaps seem to be working. I think the patch has been applied since there are keybindings related to increasing and decreasing gaps in the config but they don't work either.
How do I fix this?
Thank you

config.h

/* See LICENSE file for copyright and license details. */
#include <X11/XF86keysym.h>
/* appearance */
static const unsigned int borderpx       = 3;   /* border pixel of windows */
static const unsigned int snap           = 32;  /* snap pixel */
static const unsigned int gappih         = 50;  /* horiz inner gap between windows */
static const unsigned int gappiv         = 50;  /* vert inner gap between windows */
static const unsigned int gappoh         = 50;  /* horiz outer gap between windows and screen edge */
static const unsigned int gappov         = 50;  /* vert outer gap between windows and screen edge */
static const int smartgaps_fact          = 1;   /* gap factor when there is only one client; 0 = no gaps, 3 = 3x outer gaps */
static const int showbar                 = 1;   /* 0 means no bar */
static const int topbar                  = 1;   /* 0 means bottom bar */
static const unsigned int systrayspacing = 2;   /* systray spacing */
static const int showsystray             = 1;   /* 0 means no systray */
/* Indicators: see patch/bar_indicators.h for options */
static int tagindicatortype              = INDICATOR_TOP_LEFT_SQUARE;
static int tiledindicatortype            = INDICATOR_NONE;
static int floatindicatortype            = INDICATOR_TOP_LEFT_SQUARE;
// static const char *fonts[]               = { "monospace:size=10" };
static const char *fonts[]          = { "saucecodepro nerd font:size=10","siji:10", "MesloLGS NF:size=10","font awesome:size=10"};
static const char dmenufont[]            = "saucecodepro nerd font:size=10";
// static const char dmenufont[]            = "monospace:size=10";

static char normfgcolor[]                = "#bbbbbb";
static char normbgcolor[]                = "#222222";
static char normbordercolor[]            = "#444444";
static char normfloatcolor[]             = "#db8fd9";

static char selfgcolor[]                 = "#eeeeee";
static char selbgcolor[]                 = "#005577";
static char selbordercolor[]             = "#005577";
static char selfloatcolor[]              = "#005577";

static char titlenormfgcolor[]           = "#bbbbbb";
static char titlenormbgcolor[]           = "#222222";
static char titlenormbordercolor[]       = "#444444";
static char titlenormfloatcolor[]        = "#db8fd9";

static char titleselfgcolor[]            = "#eeeeee";
static char titleselbgcolor[]            = "#005577";
static char titleselbordercolor[]        = "#005577";
static char titleselfloatcolor[]         = "#005577";

static char tagsnormfgcolor[]            = "#bbbbbb";
static char tagsnormbgcolor[]            = "#222222";
static char tagsnormbordercolor[]        = "#444444";
static char tagsnormfloatcolor[]         = "#db8fd9";

static char tagsselfgcolor[]             = "#eeeeee";
static char tagsselbgcolor[]             = "#005577";
static char tagsselbordercolor[]         = "#005577";
static char tagsselfloatcolor[]          = "#005577";

static char hidfgcolor[]                 = "#005577";
static char hidbgcolor[]                 = "#222222";
static char hidbordercolor[]             = "#005577";
static char hidfloatcolor[]              = "#f76e0c";

static char urgfgcolor[]                 = "#bbbbbb";
static char urgbgcolor[]                 = "#222222";
static char urgbordercolor[]             = "#ff0000";
static char urgfloatcolor[]              = "#db8fd9";


static const unsigned int baralpha = 180;
static const unsigned int borderalpha = OPAQUE;
static const unsigned int alphas[][3] = {
	/*                       fg      bg        border     */
	[SchemeNorm]         = { OPAQUE, baralpha, borderalpha },
	[SchemeSel]          = { OPAQUE, baralpha, borderalpha },
	[SchemeTitleNorm]    = { OPAQUE, baralpha, borderalpha },
	[SchemeTitleSel]     = { OPAQUE, baralpha, borderalpha },
	[SchemeTagsNorm]     = { OPAQUE, baralpha, borderalpha },
	[SchemeTagsSel]      = { OPAQUE, baralpha, borderalpha },
	[SchemeHid]          = { OPAQUE, baralpha, borderalpha },
	[SchemeUrg]          = { OPAQUE, baralpha, borderalpha },
};

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 },
	[SchemeHid]          = { hidfgcolor,       hidbgcolor,       hidbordercolor,       hidfloatcolor },
	[SchemeUrg]          = { urgfgcolor,       urgbgcolor,       urgbordercolor,       urgfloatcolor },
};





/* Tags
 * In a traditional dwm the number of tags in use can be changed simply by changing the number
 * of strings in the tags array. This build does things a bit different which has some added
 * benefits. If you need to change the number of tags here then change the NUMTAGS macro in dwm.c.
 *
 * Examples:
 *
 *  1) static char *tagicons[][NUMTAGS*2] = {
 *         [DEFAULT_TAGS] = { "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "I" },
 *     }
 *
 *  2) static char *tagicons[][1] = {
 *         [DEFAULT_TAGS] = { "•" },
 *     }
 *
 * The first example would result in the tags on the first monitor to be 1 through 9, while the
 * tags for the second monitor would be named A through I. A third monitor would start again at
 * 1 through 9 while the tags on a fourth monitor would also be named A through I. Note the tags
 * count of NUMTAGS*2 in the array initialiser which defines how many tag text / icon exists in
 * the array. This can be changed to *3 to add separate icons for a third monitor.
 *
 * For the second example each tag would be represented as a bullet point. Both cases work the
 * same from a technical standpoint - the icon index is derived from the tag index and the monitor
 * index. If the icon index is is greater than the number of tag icons then it will wrap around
 * until it an icon matches. Similarly if there are two tag icons then it would alternate between
 * them. This works seamlessly with alternative tags and alttagsdecoration patches.
 */
static char *tagicons[][NUMTAGS] = {
	[DEFAULT_TAGS]        = { "1", "2", "3", "4", "5", "6", "7", "8", "9" },
	[ALTERNATIVE_TAGS]    = { "A", "B", "C", "D", "E", "F", "G", "H", "I" },
	[ALT_TAGS_DECORATION] = { "<1>", "<2>", "<3>", "<4>", "<5>", "<6>", "<7>", "<8>", "<9>" },
};


/* There are two options when it comes to per-client rules:
 *  - a typical struct table or
 *  - using the RULE macro
 *
 * A traditional struct table looks like this:
 *    // class      instance  title  wintype  tags mask  isfloating  monitor
 *    { "Gimp",     NULL,     NULL,  NULL,    1 << 4,    0,          -1 },
 *    { "Firefox",  NULL,     NULL,  NULL,    1 << 7,    0,          -1 },
 *
 * The RULE macro has the default values set for each field allowing you to only
 * specify the values that are relevant for your rule, e.g.
 *
 *    RULE(.class = "Gimp", .tags = 1 << 4)
 *    RULE(.class = "Firefox", .tags = 1 << 7)
 *
 * Refer to the Rule struct definition for the list of available fields depending on
 * the patches you enable.
 */
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(.class = "Gimp", .tags = 1 << 4)
	RULE(.class = "Firefox", .tags = 1 << 7)
};



/* Bar rules allow you to configure what is shown where on the bar, as well as
 * introducing your own bar modules.
 *
 *    monitor:
 *      -1  show on all monitors
 *       0  show on monitor 0
 *      'A' show on active monitor (i.e. focused / selected) (or just -1 for active?)
 *    bar - bar index, 0 is default, 1 is extrabar
 *    alignment - how the module is aligned compared to other modules
 *    widthfunc, drawfunc, clickfunc - providing bar module width, draw and click functions
 *    name - does nothing, intended for visual clue and for logging / debugging
 */
static const BarRule barrules[] = {
	/* monitor  bar    alignment         widthfunc                drawfunc                clickfunc                name */
	{ -1,       0,     BAR_ALIGN_LEFT,   width_tags,              draw_tags,              click_tags,              "tags" },
	{  0,       0,     BAR_ALIGN_RIGHT,  width_systray,           draw_systray,           click_systray,           "systray" },
	{ -1,       0,     BAR_ALIGN_LEFT,   width_ltsymbol,          draw_ltsymbol,          click_ltsymbol,          "layout" },
	{ 'A',      0,     BAR_ALIGN_RIGHT,  width_status,            draw_status,            click_status,            "status" },
	{ -1,       0,     BAR_ALIGN_NONE,   width_awesomebar,        draw_awesomebar,        click_awesomebar,        "awesomebar" },
};

/* layout(s) */
static const float mfact     = 0.5; /* factor of master area size [0.05..0.95] */
static const int nmaster     = 1;    /* number of clients in master area */
static const int nstack      = 0;    /* number of clients in primary stack area */
static const int resizehints = 0;    /* 1 means respect size hints in tiled resizals */



static const Layout layouts[] = {
	/* symbol     arrange function, { nmaster, nstack, layout, master axis, stack axis, secondary stack axis, symbol func } */
	{ "[]=",      flextile,         { -1, -1, SPLIT_VERTICAL, TOP_TO_BOTTOM, TOP_TO_BOTTOM, 0, NULL } }, // default tile layout
 	{ "><>",      NULL,             {0} },    /* no layout function means floating behavior */
	{ "[M]",      flextile,         { -1, -1, NO_SPLIT, MONOCLE, MONOCLE, 0, NULL } }, // monocle
	// { "|||",      flextile,         { -1, -1, SPLIT_VERTICAL, LEFT_TO_RIGHT, TOP_TO_BOTTOM, 0, NULL } }, // columns (col) layout
	{ "[D]",      flextile,         { -1, -1, SPLIT_VERTICAL, TOP_TO_BOTTOM, MONOCLE, 0, NULL } }, // deck
	{ "TTT",      flextile,         { -1, -1, SPLIT_HORIZONTAL, LEFT_TO_RIGHT, LEFT_TO_RIGHT, 0, NULL } }, // bstack
	// { "===",      flextile,         { -1, -1, SPLIT_HORIZONTAL, LEFT_TO_RIGHT, TOP_TO_BOTTOM, 0, NULL } }, // bstackhoriz
	// { "|M|",      flextile,         { -1, -1, SPLIT_CENTERED_VERTICAL, LEFT_TO_RIGHT, TOP_TO_BOTTOM, TOP_TO_BOTTOM, NULL } }, // centeredmaster
	// { "-M-",      flextile,         { -1, -1, SPLIT_CENTERED_HORIZONTAL, TOP_TO_BOTTOM, LEFT_TO_RIGHT, LEFT_TO_RIGHT, NULL } }, // centeredmaster horiz
	// { ":::",      flextile,         { -1, -1, NO_SPLIT, GAPPLESSGRID, GAPPLESSGRID, 0, NULL } }, // gappless grid
	// { "[\\]",     flextile,         { -1, -1, NO_SPLIT, DWINDLE, DWINDLE, 0, NULL } }, // fibonacci dwindle
	// { "(@)",      flextile,         { -1, -1, NO_SPLIT, SPIRAL, SPIRAL, 0, NULL } }, // fibonacci spiral
	{ "[T]",      flextile,         { -1, -1, SPLIT_VERTICAL, LEFT_TO_RIGHT, TATAMI, 0, NULL } }, // tatami mats
	{ "[]=",      tile,             {0} },
	{ "[M]",      monocle,          {0} },
	{ "TTT",      bstack,           {0} },
	{ NULL,       NULL,             {0} },
};


/* 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 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[]  = { "alacritty", NULL };
static const char *firefox[]  = { "firefox", NULL };
static const char *subl[]  = { "subl", NULL };
static const char *pcmanfm[]  = { "pcmanfm", NULL };
static const char *volinc[] = {"/home/sophos/volume-notification-dunst/volume.sh", "up"};
static const char *voldec[] = {"/home/sophos/volume-notification-dunst/volume.sh", "down"};
static const char *volmute[] = {"/home/sophos/volume-notification-dunst/volume.sh",  "mute"};
static Key keys[] = {
	/* modifier                     key            function                argument */

	{ 0,                       XF86XK_AudioRaiseVolume, spawn, {.v = volinc   } },
    { 0,                       XF86XK_AudioLowerVolume, spawn, {.v = voldec } },
	{ 0,                       XF86XK_AudioMute, spawn,        {.v = volmute } },
	{ MODKEY,                       XK_Return,     spawn, 		           {.v = termcmd } },
	{ MODKEY|ShiftMask,             XK_Return,     spawn,                  {.v = dmenucmd } },
	{ MODKEY,		                XK_f,      	   spawn,          		   {.v = firefox } },
	{ MODKEY,		                XK_s,      	   spawn,          		   {.v = subl } },
	{ MODKEY,		                XK_e,      	   spawn,          		   {.v = pcmanfm } },
	{ MODKEY,                       XK_b,          togglebar,              {0} },
	{ MODKEY,                       XK_j,          focusstack,             {.i = +1 } },
	{ MODKEY,                       XK_k,          focusstack,             {.i = -1 } },
	{ MODKEY,                       XK_Left,       focusdir,               {.i = 0 } }, // left
	{ MODKEY,                       XK_Right,      focusdir,               {.i = 1 } }, // right
	{ MODKEY,                       XK_Up,         focusdir,               {.i = 2 } }, // up
	{ MODKEY,                       XK_Down,       focusdir,               {.i = 3 } }, // down
	{ Mod1Mask,                       XK_Tab,          swapfocus,              {.i = -1 } },
	{ MODKEY,                       XK_i,          incnmaster,             {.i = +1 } },
	{ MODKEY,                       XK_d,          incnmaster,             {.i = -1 } },
	{ MODKEY|ControlMask,           XK_i,          incnstack,              {.i = +1 } },
	{ MODKEY|ControlMask,           XK_u,          incnstack,              {.i = -1 } },
	{ MODKEY,                       XK_h,          setmfact,               {.f = -0.05} },
	{ MODKEY,                       XK_l,          setmfact,               {.f = +0.05} },
	{ MODKEY|ShiftMask,             XK_h,          setcfact,               {.f = +0.25} },
	{ MODKEY|ShiftMask,             XK_l,          setcfact,               {.f = -0.25} },
	{ MODKEY|ShiftMask,             XK_o,          setcfact,               {0} },
	{ MODKEY|Mod4Mask,              XK_Down,       moveresize,             {.v = "0x 25y 0w 0h" } },
	{ MODKEY|Mod4Mask,              XK_Up,         moveresize,             {.v = "0x -25y 0w 0h" } },
	{ MODKEY|Mod4Mask,              XK_Right,      moveresize,             {.v = "25x 0y 0w 0h" } },
	{ MODKEY|Mod4Mask,              XK_Left,       moveresize,             {.v = "-25x 0y 0w 0h" } },
	{ MODKEY|Mod4Mask|ShiftMask,    XK_Down,       moveresize,             {.v = "0x 0y 0w 25h" } },
	{ MODKEY|Mod4Mask|ShiftMask,    XK_Up,         moveresize,             {.v = "0x 0y 0w -25h" } },
	{ MODKEY|Mod4Mask|ShiftMask,    XK_Right,      moveresize,             {.v = "0x 0y 25w 0h" } },
	{ MODKEY|Mod4Mask|ShiftMask,    XK_Left,       moveresize,             {.v = "0x 0y -25w 0h" } },
	{ MODKEY|ShiftMask,             XK_j,          movestack,              {.i = +1 } },
	{ MODKEY|ShiftMask,             XK_k,          movestack,              {.i = -1 } },
	{ MODKEY|Mod1Mask,              XK_u,          incrgaps,               {.i = +1 } },
	{ MODKEY|Mod1Mask|ShiftMask,    XK_u,          incrgaps,               {.i = -1 } },
	{ MODKEY|Mod1Mask,              XK_i,          incrigaps,              {.i = +1 } },
	{ MODKEY|Mod1Mask|ShiftMask,    XK_i,          incrigaps,              {.i = -1 } },
	{ MODKEY|Mod1Mask,              XK_o,          incrogaps,              {.i = +1 } },
	{ MODKEY|Mod1Mask|ShiftMask,    XK_o,          incrogaps,              {.i = -1 } },
	{ MODKEY|Mod1Mask,              XK_6,          incrihgaps,             {.i = +1 } },
	{ MODKEY|Mod1Mask|ShiftMask,    XK_6,          incrihgaps,             {.i = -1 } },
	{ MODKEY|Mod1Mask,              XK_7,          incrivgaps,             {.i = +1 } },
	{ MODKEY|Mod1Mask|ShiftMask,    XK_7,          incrivgaps,             {.i = -1 } },
	{ MODKEY|Mod1Mask,              XK_8,          incrohgaps,             {.i = +1 } },
	{ MODKEY|Mod1Mask|ShiftMask,    XK_8,          incrohgaps,             {.i = -1 } },
	{ MODKEY|Mod1Mask,              XK_9,          incrovgaps,             {.i = +1 } },
	{ MODKEY|Mod1Mask|ShiftMask,    XK_9,          incrovgaps,             {.i = -1 } },
	{ MODKEY|Mod1Mask,              XK_0,          togglegaps,             {0} },
	{ MODKEY|Mod1Mask|ShiftMask,    XK_0,          defaultgaps,            {0} },
	{ MODKEY,                       XK_Tab,        view,                   {0} },
	{ MODKEY|ControlMask,           XK_z,          showhideclient,         {0} },
	{ MODKEY, 			            XK_w,          killclient,             {0} },
	{ MODKEY|ShiftMask,             XK_q,          quit,                   {0} },
	{ MODKEY,                       XK_t,          setlayout,              {.v = &layouts[0]} },
	{ MODKEY,                       XK_f,          setlayout,              {.v = &layouts[1]} },
	{ MODKEY,                       XK_m,          setlayout,              {.v = &layouts[2]} },
	{ MODKEY|ControlMask,           XK_t,          rotatelayoutaxis,       {.i = +1 } },   /* flextile, 1 = layout axis */
	{ MODKEY|ControlMask,           XK_Tab,        rotatelayoutaxis,       {.i = +2 } },   /* flextile, 2 = master axis */
	{ MODKEY|ControlMask|ShiftMask, XK_Tab,        rotatelayoutaxis,       {.i = +3 } },   /* flextile, 3 = stack axis */
	{ MODKEY|ControlMask|Mod1Mask,  XK_Tab,        rotatelayoutaxis,       {.i = +4 } },   /* flextile, 4 = secondary stack axis */
	{ MODKEY|Mod5Mask,              XK_t,          rotatelayoutaxis,       {.i = -1 } },   /* flextile, 1 = layout axis */
	{ MODKEY|Mod5Mask,              XK_Tab,        rotatelayoutaxis,       {.i = -2 } },   /* flextile, 2 = master axis */
	{ MODKEY|Mod5Mask|ShiftMask,    XK_Tab,        rotatelayoutaxis,       {.i = -3 } },   /* flextile, 3 = stack axis */
	{ MODKEY|Mod5Mask|Mod1Mask,     XK_Tab,        rotatelayoutaxis,       {.i = -4 } },   /* flextile, 4 = secondary stack axis */
	{ MODKEY|ControlMask,           XK_Return,     mirrorlayout,           {0} },          /* flextile, flip master and stack areas */
	{ MODKEY,                       XK_space,      setlayout,              {0} },
	{ MODKEY|ShiftMask,             XK_space,      togglefloating,         {0} },
	{ MODKEY,                       XK_0,          view,                   {.ui = ~0 } },
	{ MODKEY|ShiftMask,             XK_0,          tag,                    {.ui = ~0 } },
	{ MODKEY,                       XK_comma,      focusmon,               {.i = -1 } },
	{ MODKEY,                       XK_period,     focusmon,               {.i = +1 } },
	{ MODKEY|ShiftMask,             XK_comma,      tagmon,                 {.i = -1 } },
	{ MODKEY|ShiftMask,             XK_period,     tagmon,                 {.i = +1 } },
	{ MODKEY|ControlMask,           XK_comma,      cyclelayout,            {.i = -1 } },
	{ MODKEY|ControlMask,           XK_period,     cyclelayout,            {.i = +1 } },
	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)
};


/* button definitions */
/* click can be ClkTagBar, 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,                   Button1,        togglewin,      {0} },
	{ ClkWinTitle,          0,                   Button3,        showhideclient, {0} },
	{ 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} },
	{ ClkClientWin,         MODKEY|ShiftMask,    Button3,        dragcfact,      {0} },
	{ ClkClientWin,         MODKEY|ShiftMask,    Button1,        dragmfact,      {0} },
	{ ClkTagBar,            0,                   Button1,        view,           {0} },
	{ ClkTagBar,            0,                   Button3,        toggleview,     {0} },
	{ ClkTagBar,            MODKEY,              Button1,        tag,            {0} },
	{ ClkTagBar,            MODKEY,              Button3,        toggletag,      {0} },
};

patches.h

 * This file contains patch control flags.
 *
 * In principle you should be able to mix and match any patches
 * you may want. In cases where patches are logically incompatible
 * one patch may take precedence over the other as noted in the
 * relevant descriptions.
 *
 * Although layouts typically come as patches they are differentiated
 * here for grouping purposes.
 */

/**
 * Bar modules
 */

/* Enhanced taskbar that shows the titles of all visible windows in the status bar
 * and allows focus / hiding / unhiding of windows by clicking on the status bar.
 * Awesomebar takes precedence over fancybar.
 * https://dwm.suckless.org/patches/awesomebar/
 */
#define BAR_AWESOMEBAR_PATCH 1

/* This patch depends on statuscmd patch and adds integration with a (patched)
 * dwmblocks instance to give a clickable status bar. One must not necessarily
 * have to use dwmblocks for this feature, any status updater that has support
 * for real-time signals (SIGRTMIN) can be used.
 *
 * dwmblocks: https://github.com/torrinfail/dwmblocks
 * https://dwm.suckless.org/patches/statuscmd/
 */
#define BAR_DWMBLOCKS_PATCH 0

/* Originally the dwmblocks + statuscmd patch used a user defined signal (SIGUSR1)
 * for communicating with dwmblocks to indicate update signal and what button was
 * pressed. The signalling was later changed to SIGRTMIN instead.
 *
 * Ultimately this makes dwmblocks instances that were patched with the old patch
 * are incompatible with the new dwm patch and vice versa.
 *
 * This is a compatibility patch that makes dwm use SIGUSR1 instead of SIGRTMIN so
 * if button clicks are not working then you may want to try enabling this.
 *
 * If dwmblocks happen to die like this when clicking on a status
 *
 *    [1]    54355 user-defined signal 1  dwmblocks
 *
 * then it suggests that dwmblocks does not support user defined signals and this
 * patch should be left disabled.
 *
 * Patch: https://gist.github.com/danbyl/54f7c1d57fc6507242a95b71c3d8fdea
 * https://dwm.suckless.org/patches/statuscmd/
 */
#define BAR_DWMBLOCKS_SIGUSR1_PATCH 0

/* This patch shows the titles of all visible windows in the status bar
 * (as opposed to showing only the selected one).
 * Awesomebar takes precedence over fancybar. Fancybar takes precedence over
 * the centeredwindowname patch.
 * https://dwm.suckless.org/patches/fancybar/
 */
#define BAR_FANCYBAR_PATCH 0

/* Being an evolution of the bartabgroups patch the flexwintitle patch specifically
 * taps into the many layout options that flextile-deluxe offers to produce a window
 * title section in the bar that is representative of what is shown on screen.
 */
#define BAR_FLEXWINTITLE_PATCH 0

/* This patch adds a context menu for layout switching.
 *   - xmenu needs to be installed.
 *   - Edit layoutmenu.sh with the installed layouts and with correct indexes.
 *   - Place layoutmenu.sh in PATH.
 *   - The text of the menu items is for display only. Name them however you want.
 * https://dwm.suckless.org/patches/layoutmenu/
 */
#define BAR_LAYOUTMENU_PATCH 0

/* Show layout symbol in bar */
#define BAR_LTSYMBOL_PATCH 1

/* Adds powerline arrows for the status.
 * This uses statuscolors logic for choosing colors for the powerline. As these markers
 * are also control characters there is no explicit statuscmd support for this patch.
 *
 * Powerline separators are defined as:
 *    |\xXX  (creates a hard edge)
 *    <\xXX  (creates a less than arrow)
 *    /\xXX  (creates a diagonal line)
 *
 * Examples:
 *    xsetroot -name "$(echo -e '<\x01a<\x02b<\x03c')"
 *    xsetroot -name "$(echo -e '/\x01d/\x02d/\x03f')"
 *
 * https://gitlab.com/udiboy1209-suckless/dwm/-/commit/071f5063e8ac4280666828179f92788d893eea40#4b1a539194be7467cefbda22f675a3b7c19ceca7
 * https://dwm.suckless.org/patches/statuscolors/
 */
#define BAR_POWERLINE_STATUS_PATCH 0

/* Adds powerline arrows for the tags.
 * https://gitlab.com/udiboy1209-suckless/dwm/-/commit/071f5063e8ac4280666828179f92788d893eea40#4b1a539194be7467cefbda22f675a3b7c19ceca7
 */
#define BAR_POWERLINE_TAGS_PATCH 0

/* Alters the tags powerline to use forward slash instead of arrows */
#define BAR_POWERLINE_TAGS_SLASH_PATCH 0

/* This patch turns the titlebar area into a mfact-respecting tabbar showing each client's title.
 * https://dwm.suckless.org/patches/bartabgroups/
 */
#define BAR_TABGROUPS_PATCH 0

/* This patch adds an option to place tags in rows like in many other window managers.
 * https://dwm.suckless.org/patches/taggrid/
 */
#define BAR_TAGGRID_PATCH 0

/* Show status in bar */
#define BAR_STATUS_PATCH 1

/* This patch adds a clickable button to the left hand side of the statusbar.
 * https://dwm.suckless.org/patches/statusbutton/
 */
#define BAR_STATUSBUTTON_PATCH 0

/* This patch adds the ability to execute shell commands based on the mouse button and position
 * when clicking the status bar. Refer to the website for usage.
 * https://dwm.suckless.org/patches/statuscmd/
 */
#define BAR_STATUSCMD_PATCH 0

/* Status2d allows colors and rectangle drawing in your dwm status bar.
 * This patch is incompatible with the statuscolors patch which takes precedence.
 * This patch is incompatible with the extrabar patch.
 * https://dwm.suckless.org/patches/status2d/
 */
#define BAR_STATUS2D_PATCH 0

/* Supplementary patch should you want to disable alpha for the status2d section */
#define BAR_STATUS2D_NO_ALPHA_PATCH 0

/* Addition to the status2d patch that allows the use of terminal colors (color0 through color15)
 * from xrdb in the status, allowing programs like pywal to change statusbar colors.
 * This adds the C and B codes to use terminal foreground and background colors respectively.
 * E.g. ^B5^ would use color5 as the background color.
 * https://dwm.suckless.org/patches/status2d/
 */
#define BAR_STATUS2D_XRDB_TERMCOLORS_PATCH 0

/* The systray patch adds systray for the status bar.
 * https://dwm.suckless.org/patches/systray/
 */
#define BAR_SYSTRAY_PATCH 1

/* Show tag symbols in bar */
#define BAR_TAGS_PATCH 1

/* Show window title in bar */
#define BAR_WINTITLE_PATCH 1

/* Shows window titles in the bar, but only for floating clients.
 * This depends on code from the flexwintitle patch.
 * Note that the configuration in config.def.h for this is merely an example. If combined
 * with the corresponding hidden patch then these two will overlap unless the width of the
 * modules are controlled.
 */
#define BAR_WINTITLE_FLOATING_PATCH 0

/* Shows window titles in the bar, but only for floating clients.
 * This depends on code from the flexwintitle patch.
 * Note that the configuration in config.def.h for this is merely an example. If combined
 * with the corresponding floating patch then these two will overlap unless the width of the
 * modules are controlled.
 */
#define BAR_WINTITLE_HIDDEN_PATCH 0

/* Title bar modules such as wintitle (default), fancybar and awesomebar
 * do not by default add left and/or right padding as they take up the
 * remaining space. These options allow you explicitly add padding should
 * you need it.
 */
#define BAR_TITLE_RIGHT_PAD_PATCH 0
#define BAR_TITLE_LEFT_PAD_PATCH 1

/**
 * Bar options
 */

/* This patch changes the rectangle indicating if a tag is used by a client into a bar
 * above the tag name for better visibility.
 * Set the tagindicatortype variable in config.h to INDICATOR_TOP_BAR to enable this.
 * https://dwm.suckless.org/patches/activetagindicatorbar/
 */
#define BAR_ACTIVETAGINDICATORBAR_PATCH N/A

/* Alternative patch to the activetagindicatorbar patch, adds the bar below the tag
 * icon rather than above.
 * Set the tagindicatortype variable in config.h to INDICATOR_BOTTOM_BAR to enable this.
 */
#define BAR_ACTIVETAGINDICATORBAR_ALT1_PATCH N/A

/* The alpha patch adds transparency for the status bar.
 * You need to uncomment the corresponding line in config.mk to use the -lXrender library
 * when including this patch.
 * https://dwm.suckless.org/patches/alpha/
 */
#define BAR_ALPHA_PATCH 1

/* This patch introduces alternative tags which can be switched on the fly for the
 * sole purpose of providing visual aid.
 * https://dwm.suckless.org/patches/alternativetags/
 */
#define BAR_ALTERNATIVE_TAGS_PATCH 0

/* This patches provides the ability to use alternative text for tags which contain at
 * least one window.
 * https://dwm.suckless.org/patches/alttagsdecoration/
 */
#define BAR_ALTTAGSDECORATION_PATCH 0

/* This patch enables dwm to manage external status bars such as lemonbar and polybar.
 * dwm treats the external bar as it would its own, so all regular dwm commands such as
 * togglebar affect the external bar in the same way.
 *
 * NB: Unless you want both anybar + dwm bar(s) then the recommendation is to disable all
 * bar modules and have { -2 } in the barrules.
 *
 * https://dwm.suckless.org/patches/anybar/
 */
#define BAR_ANYBAR_PATCH 0

/* Anybar option to place the next bar depending on previous bar's position (top or bottom) */
#define BAR_ANYBAR_TOP_AND_BOTTOM_BARS_PATCH 0

/* Anybar option to let dwm manage the width of the bar */
#define BAR_ANYBAR_MANAGE_WIDTH_PATCH 0

/* This patch adds a border around the status bar(s) just like the border of client windows.
 * https://codemadness.org/paste/dwm-border-bar.patch
 */
#define BAR_BORDER_PATCH 0

/* This patch centers the WM_NAME of the currently selected window on the status bar.
 * This is compatible with the wintitle, bartabgroups, flexwintitle and awesomebar bar
 * modules.
 * https://dwm.suckless.org/patches/centeredwindowname/
 */
#define BAR_CENTEREDWINDOWNAME_PATCH 0

/* Draws a dot indicator overlayed on each tag icon for each client. The selected client
 * is drawn as a larger horizontal line.
 * Set the tagindicatortype variable in config.h to INDICATOR_CLIENT_DOTS to enable this.
 * https://dwm.suckless.org/patches/clientindicators/
 */
#define BAR_CLIENTINDICATOR_PATCH N/A

/* This patch enables color emoji in dwm by removing a workaround for a BadLength error
 * in the Xft library when color glyphs are used.
 * To enable this you will need an updated Xft library that can handle color glyphs otherwise
 * dwm will crash on encountering such characters. Note that you will also need a font that
 * provides color emojis for this to work.
 */
#define BAR_COLOR_EMOJI_PATCH 0

/* Updates the position of dmenu to match that of the bar. I.e. if topbar is 0 then dmenu
 * will appear at the bottom and if 1 then dmenu will appear at the top.
 * https://dwm.suckless.org/patches/dmenumatchtop
 */
#define BAR_DMENUMATCHTOP_PATCH 0

/* Originally this was the extrabar patch, but as the handling of extra bars is now built-in
 * only the splitting of the status by a designated separator remains. As such this has been
 * renamed to more accurately reflect what it does - creating an extra status.
 * https://dwm.suckless.org/patches/extrabar/
 */
#define BAR_EXTRASTATUS_PATCH 0

/* Adds EWMH support for _NET_NUMBER_OF_DESKTOPS, _NET_CURRENT_DESKTOP, _NET_DESKTOP_NAMES
 * and _NET_DESKTOP_VIEWPORT, which allows for compatibility with other bars and programs
 * that request workspace information. For example polybar's xworkspaces module.
 *
 * This patch also includes support for adding the _IS_FLOATING property for floating windows
 * allowing for compositors to treat floating windows differently to tiled windows.
 *
 * E.g. this setting makes picom only render shadows for floating windows:
 *
 *     shadow-exclude = [ "! _IS_FLOATING@:32c = 1" ];
 *
 * https://github.com/bakkeby/dwm-flexipatch/issues/50 (_IS_FLOATING patch)
 * https://dwm.suckless.org/patches/ewmhtags/
 */
#define BAR_EWMHTAGS_PATCH 0

/* Allows the bar height to be explicitly set rather than being derived from font.
 * https://dwm.suckless.org/patches/bar_height/
 */
#define BAR_HEIGHT_PATCH 0

/* This patch prevents dwm from drawing tags with no clients (i.e. vacant) on the bar.
 * https://dwm.suckless.org/patches/hide_vacant_tags/
 */
#define BAR_HIDEVACANTTAGS_PATCH 0

/* With this patch dwm's built-in status bar is only shown when HOLDKEY is pressed
 * and the bar will now overlay the display.
 * http://dwm.suckless.org/patches/holdbar/
 */
#define BAR_HOLDBAR_PATCH 0

/* Sometimes dwm crashes when it cannot render some glyphs in window titles (usually emoji).
 * This patch is essentially a hack to ignore any errors when drawing text on the status bar.
 * https://groups.google.com/forum/m/#!topic/wmii/7bncCahYIww
 * https://docs.google.com/viewer?a=v&pid=forums&srcid=MDAwODA2MTg0MDQyMjE0OTgzMzMBMDQ3ODQzODkyMTU3NTAyMTMxNTYBX2RUMVNtOUtDQUFKATAuMQEBdjI&authuser=0
 */
#define BAR_IGNORE_XFT_ERRORS_WHEN_DRAWING_TEXT_PATCH 0

/* This patch adds vertical and horizontal space between the statusbar and the edge of the screen.
 * https://dwm.suckless.org/patches/barpadding/
 */
#define BAR_PADDING_PATCH 0

/* This patch adds simple markup for status messages using pango markup.
 * This depends on the pango library v1.44 or greater.
 * You need to uncomment the corresponding lines in config.mk to use the pango libraries
 * when including this patch.
 *
 * Note that the pango patch does not protect against the BadLength error from Xft
 * when color glyphs are used, which means that dwm will crash if color emoji is used.
 *
 * If you need color emoji then you may want to install this patched library from the AUR:
 * https://aur.archlinux.org/packages/libxft-bgra/
 *
 * A long term fix for the libXft library is pending approval of this pull request:
 * https://gitlab.freedesktop.org/xorg/lib/libxft/-/merge_requests/1
 *
 * Also see:
 * https://developer.gnome.org/pygtk/stable/pango-markup-language.html
 * https://lists.suckless.org/hackers/2004/17285.html
 * https://dwm.suckless.org/patches/pango/
 */
#define BAR_PANGO_PATCH 0

/* This patch enables colored text in the status bar. It changes the way colors are defined
 * in config.h allowing multiple color combinations for use in the status script.
 * This patch is incompatible with and takes precedence over the status2d patch.
 * https://dwm.suckless.org/patches/statuscolors/
 */
#define BAR_STATUSCOLORS_PATCH 0

/* This patch adds configuration options for horizontal and vertical padding in the status bar.
 * https://dwm.suckless.org/patches/statuspadding/
 */
#define BAR_STATUSPADDING_PATCH 0

/* This patch adds the ability for dwm to read colors from the linux virtual console.
 *    /sys/module/vt/parameters/default_{red,grn,blu}
 * Essentially this way the colors you use in your regular tty is "mirrored" to dwm.
 * https://dwm.suckless.org/patches/vtcolors/
 */
#define BAR_VTCOLORS_PATCH 0

/* This patch allows client windows to be hidden. This code was originally part of awesomebar,
 * but has been separated out so that other bar modules can take advantage of it.
 * Both awesomebar and bartabgroups patches depend on this patch and it will be auto-enabled
 * during compile time if it is needed. Note that if using flexipatch-finalizer this must be
 * explicitly enabled.
 * https://github.com/bakkeby/patches/blob/master/dwm/dwm-barmodules-wintitleactions-6.2.diff
 */
#define BAR_WINTITLEACTIONS_PATCH BAR_AWESOMEBAR_PATCH || BAR_TABGROUPS_PATCH || BAR_FLEXWINTITLE_PATCH

/***
 * Other patches
 */

/* This patch allows windows to be resized with its aspect ratio remaining constant.
 * https://dwm.suckless.org/patches/aspectresize/
 */
#define ASPECTRESIZE_PATCH 0

/* This patch adds new clients above the selected client, instead of always
 * becoming the new master. This behaviour is known from Xmonad.
 * This patch takes precedence over ATTACHASIDE_PATCH.
 * https://dwm.suckless.org/patches/attachabove/
 */
#define ATTACHABOVE_PATCH 0

/* This patch adds new clients on top of the stack.
 * This patch takes precedence over ATTACHBELOW_PATCH.
 * https://dwm.suckless.org/patches/attachaside/
 */
#define ATTACHASIDE_PATCH 1

/* This patch adds new clients below the selected client.
 * This patch takes precedence over ATTACHBOTTOM_PATCH.
 * https://dwm.suckless.org/patches/attachbelow/
 */
#define ATTACHBELOW_PATCH 0

/* This patch adds new clients at the bottom of the stack.
 * https://dwm.suckless.org/patches/attachbottom/
 */
#define ATTACHBOTTOM_PATCH 0

/* This patch will make dwm run "~/.local/share/dwm/autostart_blocking.sh" and
 * "~/.local/share/dwm/autostart.sh &" before entering the handler loop. One or
 * both of these files can be ommited. Note the path inside .local/share rather
 * than the original ~/.dwm folder.
 * https://dwm.suckless.org/patches/autostart/
 */
#define AUTOSTART_PATCH 0

/* By default, windows that are not visible when requesting a resize/move will not
 * get resized/moved. With this patch, they will.
 * https://dwm.suckless.org/patches/autoresize/
 */
#define AUTORESIZE_PATCH 0

/* This patch adds an iscentered rule to automatically center clients on the current monitor.
 * This patch takes precedence over centeredwindowname and fancybar patches.
 * https://dwm.suckless.org/patches/center/
 */
#define CENTER_PATCH 0

/* A transient window is one that is meant to be short lived and is usually raised by a
 * parent window. Such windows are typically dialog boxes and the like.
 * It should be noted that in dwm transient windows are not subject to normal client rules
 * and they are always floating by default.
 * This patch centers transient windows on the screen like the center patch does. Note that
 * the 6.2 center patch piggy-backed on the updatewindowtype function to ensure that all
 * dialog boxes were centered, transient or not. This function was removed in relation to
 * adding wintype as a client rule filter, hence this no longer works out of the box. This
 * patch restores previous behaviour with the center patch.
 */
#define CENTER_TRANSIENT_WINDOWS_PATCH 0

/* As above, except that the transient window is centered within the position of the parent
 * window, rather than at the center of the screen. This takes precedence over the above patch.
 */
#define CENTER_TRANSIENT_WINDOWS_BY_PARENT_PATCH 0

/* This patch provides the ability to assign different weights to clients in their
 * respective stack in tiled layout.
 * https://dwm.suckless.org/patches/cfacts/
 */
#define CFACTS_PATCH 1

/* This patch allows color attributes to be set through the command line.
 * https://dwm.suckless.org/patches/cmdcustomize/
 */
#define CMDCUSTOMIZE_PATCH 0

/* This patch tweaks the tagging interface so that you can select multiple tags for tag
 * or view by pressing all the right keys as a combo. For example to view tags 1 and 3,
 * hold MOD and then press and hold 1 and 3 together.
 * https://dwm.suckless.org/patches/combo/
 */
#define COMBO_PATCH 0

/* Allow dwm to execute commands from autostart array in your config.h file. When dwm exits
 * then all processes from autostart array will be killed.
 * https://dwm.suckless.org/patches/cool_autostart/
 */
#define COOL_AUTOSTART_PATCH 0

/* The cyclelayouts patch lets you cycle through all your layouts.
 * https://dwm.suckless.org/patches/cyclelayouts/
 */
#define CYCLELAYOUTS_PATCH 1

/* Make dwm respect _MOTIF_WM_HINTS property, and not draw borders around windows requesting
 * for it. Some applications use this property to notify window managers to not draw window
 * decorations.
 * Not respecting this property leads to issues with applications that draw their own borders,
 * like chromium (with "Use system title bar and borders" turned off) or vlc in fullscreen mode.
 * https://dwm.suckless.org/patches/decoration_hints/
 */
#define DECORATION_HINTS_PATCH 0

/* This feature distributes all clients on the current monitor evenly across all tags.
 * It is a variant of the reorganizetags patch.
 * https://dwm.suckless.org/patches/reorganizetags/
 */
#define DISTRIBUTETAGS_PATCH 0

/* Similarly to the dragmfact patch this allows you to click and drag clients to change the
 * cfact to adjust the client's size in the stack. This patch depends on the cfacts patch.
 */
#define DRAGCFACT_PATCH 1

/* This patch lets you resize the split in the tile layout (i.e. modify mfact) by holding
 * the modkey and dragging the mouse.
 * This patch can be a bit wonky with other layouts, but generally works.
 * https://dwm.suckless.org/patches/dragmfact/
 */
#define DRAGMFACT_PATCH 1

/* Simple dwmc client using a fork of fsignal to communicate with dwm.
 * To use this either copy the patch/dwmc shell script to somewhere in your path or
 * uncomment the following line in Makefile:
 *    #cp -f patch/dwmc ${DESTDIR}${PREFIX}/bin
 * http://dwm.suckless.org/patches/dwmc/
 */
#define DWMC_PATCH 0

/* This patch allows no tag at all to be selected. The result is that dwm will start with
 * no tag selected and when you start a client with no tag rule and no tag selected then
 * it will be opened on the first tag.
 * https://dwm.suckless.org/patches/emptyview/
 */
#define EMPTYVIEW_PATCH 0

/* This patch allows the user to change size and placement of floating windows using only the
 * keyboard. It also allows for temporary vertical and horizontal extension of windows similar
 * to other WMs fill command.
 * https://dwm.suckless.org/patches/exresize/
 */
#define EXRESIZE_PATCH 0

/* Only allow clients to "fullscreen" into the space currently given to them.
 * As an example, this will allow you to view a fullscreen video in your browser on
 * one half of the screen, while having the other half available for other tasks.
 * This patch takes precedence over the fakefullscreen client patch below.
 * https://dwm.suckless.org/patches/fakefullscreen/
 */
#define FAKEFULLSCREEN_PATCH 0

/* Similarly to the fakefullscreen patch this patch only allows clients to "fullscreen" into
 * the space currently given to them.
 * The "twist" with this patch is that fake fullscreen can be toggled on a per client basis
 * rather than applying to all clients globally.
 * Also see the selectivefakefullscreen option that adds a rule option to enabled this on client
 * startup.
 */
#define FAKEFULLSCREEN_CLIENT_PATCH 0

/* This patch adds a float rule allowing the size and position of floating windows to be specified
 * It also allows the size and position of floating windows to be controlled similar to the
 * exresize, moveresize, and moveplace patches.
 * The size and position can be specified using absolute, relative or fixed co-ordinates and
 * https://github.com/bakkeby/patches/wiki/floatpos/
 */
#define FLOATPOS_PATCH 0

/* Add-on functionality for the above: make the float positions respect outer (vanity)gaps. */
#define FLOATPOS_RESPECT_GAPS_PATCH 0

/* This patch provides the ability to focus the tag on the immediate left or right of the
 * currently focused tag. It also allows to send the focused window either on the left or
 * the right tag.
 * http://dwm.suckless.org/patches/focusadjacenttag/
 */
#define FOCUSADJACENTTAG_PATCH 0

/* Allows focusing on clients based on direction (up, down, left, right) instead of client order.
 * https://github.com/bakkeby/patches/wiki/focusdir/
 */
#define FOCUSDIR_PATCH 1

/* A simple patch that just puts focus back to the master client.
 * https://dwm.suckless.org/patches/focusmaster/
 */
#define FOCUSMASTER_PATCH 0

/* Switch focus only by mouse click and not sloppy (focus follows mouse pointer).
 * https://dwm.suckless.org/patches/focusonclick/
 */
#define FOCUSONCLICK_PATCH 0

/* Selects the next window having the urgent flag regardless of the tag it is on.
 * The urgent flag can be artificially set with the following xdotool command on any window:
 *   xdotool selectwindow -- set_window --urgency 1
 * https://dwm.suckless.org/patches/focusurgent/
 */
#define FOCUSURGENT_PATCH 0

/* By default, dwm responds to _NET_ACTIVE_WINDOW client messages by setting
 * the urgency bit on the named window. This patch activates the window instead.
 * https://dwm.suckless.org/patches/focusonnetactive/
 */
#define FOCUSONNETACTIVE_PATCH 0

/* Send "fake signals" to dwm for handling, using xsetroot. This will not conflict with the
 * status bar, which also is managed using xsetroot.
 * Also see the dwmc patch, which takes precedence over this patch.
 * https://dwm.suckless.org/patches/fsignal/
 */
#define FSIGNAL_PATCH 0

/* Applies the monocle layout with the focused client on top and hides the bar. When pressed
 * again it shows the bar and restores the layout that was active before going fullscreen.
 * https://dwm.suckless.org/patches/fullscreen/
 */
#define FULLSCREEN_PATCH 0

/* This patch provides a keybinding to rotate all clients in the currently selected
 * area (master or stack) without affecting the other area.
 * https://dwm.suckless.org/patches/inplacerotate/
 */
#define INPLACEROTATE_PATCH 0

/* This patch lets you define custom insets from each edge of the screen. One use case would be
 * to arrange space for an external bar.
 * https://dwm.suckless.org/patches/insets/
 */
#define INSETS_PATCH 0

/* This patch (v1.5.7) implements inter-process communication through a UNIX socket for dwm. This
 * allows for the window manager to be queried for information, e.g. listen for events such as tag
 * or layout changes, as well as send commands to control the window manager via other programs.
 *
 * You need to uncomment the corresponding lines in config.mk to use the -lyajl library
 * when including this patch.
 * This patch depends on the following additional library:
 *    - yajl
 *
 * https://github.com/mihirlad55/dwm-ipc
 * https://dwm.suckless.org/patches/ipc/
 */
#define IPC_PATCH 0

/* Adds rule option for clients to avoid accidental termination by killclient for sticky windows.
 * https://dwm.suckless.org/patches/ispermanent/
 */
#define ISPERMANENT_PATCH 0

/* This patch adds key modes (like in vim or emacs) where chains of keyboard shortcuts
 * can be performed.
 * https://dwm.suckless.org/patches/keymodes/
 */
#define KEYMODES_PATCH 0

/* This patch adds a keybinding to kills all visible clients that are not selected.
 * https://dwm.suckless.org/patches/killunsel/
 */
#define KILLUNSEL_PATCH 0

/* This changes the window manager name to LG3d instead of dwm as a workaround for Java
 * applications that assume that the window manager is using window reparenting.
 * Refer to the ISSUES secton of the dwm man page for more details.
 */
#define LG3D_PATCH 0

/* By default in dwm it is possible to make an application fullscreen, then use
 * the focusstack keybindings to focus on other windows beneath the current window.
 * It is also possible to spawn new windows (e.g. a terminal) that end up getting
 * focus while the previous window remains in fullscreen. This patch ensures that
 * in such scenarios the previous window loses fullscreen.
 * https://github.com/bakkeby/patches/blob/master/dwm/dwm-losefullscreen-6.2.diff
 */
#define LOSEFULLSCREEN_PATCH 0

/* This patch adds helper functions for maximizing, horizontally and vertically, floating
 * windows using keybindings.
 * https://dwm.suckless.org/patches/maximize/
 */
#define MAXIMIZE_PATCH 0

/* Control Music Player Daemon via keybinds.
 * You need to uncomment the corresponding line in config.mk to use the -lmpdclient library
 * when including this patch.
 * This patch depends on the following additional library:
 *    - libmpdclient
 * https://dwm.suckless.org/patches/mpdcontrol/
 */
#define MPDCONTROL_PATCH 0

/* Adds rules per monitor, e.g. have default layouts per monitor.
 * The use case for this is if the second monitor is vertical (i.e. rotated) then
 * you may want to use a different default layout for this monitor than what is
 * used for the main monitor. E.g. normal vertical split for main monitor and
 * horizontal split for the second.
 */
#define MONITOR_RULES_PATCH 0

/* Always display the the monocle-symbol as defined in config.h if the monocle-layout
 * is activated. Do not display the number of open clients in the current tag.
 * https://dwm.suckless.org/patches/monoclesymbol/
 */
#define MONOCLESYMBOL_PATCH 0

/* Makes a window floating and 1/3rd the height and 1/3rd the width of the screen and is
 * positioned in either the center or one of the 8 cardinal directions depending on which
 * key is pressed.
 * https://dwm.suckless.org/patches/moveplace/
 */
#define MOVEPLACE_PATCH 0

/* This patch allows you to move and resize dwm's clients using keyboard bindings.
 * https://dwm.suckless.org/patches/moveresize/
 */
#define MOVERESIZE_PATCH 1

/* This patch allows you to move clients around in the stack and swap them with the master.
 * https://dwm.suckless.org/patches/movestack/
 */
#define MOVESTACK_PATCH 1

/* Adds support for the _NET_CLIENT_LIST_STACKING atom, needed by certain applications like the
 * Zoom video conferencing application.
 * https://github.com/bakkeby/patches/wiki/netclientliststacking/
 */
#define NET_CLIENT_LIST_STACKING_PATCH 0

/* Removes the border when there is only one window visible.
 * https://dwm.suckless.org/patches/noborder/
 */
#define NOBORDER_PATCH 1

/* Enable modifying or removing dmenu in config.def.h which resulted previously in a
 * compilation error because two lines of code hardcode dmenu into dwm.
 * https://dwm.suckless.org/patches/nodmenu/
 */
#define NODMENU_PATCH 0

/* This patch allows for toggleable client button bindings that have no modifiers.
 * This can, for example, allow you to move or resize using the mouse alone without holding
 * down a modifier key. This can be practical if you have extra buttons on your mouse.
 * While you can use button bindings with no modifiers without this patch in a bare dwm,
 * those buttons are then unavailable for use within the application itself so being able to
 * toggle these on and off can be necessary in certain situations (e.g. being able to use
 * back and forward buttons in a browser).

 * Example bindings:
 *     { ClkClientWin,              0,              Button8,        movemouse,      {0} },
 *     { ClkClientWin,              0,              Button9,        resizemouse,    {0} },
 */
#define NO_MOD_BUTTONS_PATCH 0

/* When terminals have transparency then their borders also become transparent.
 * This patch ensures that borders have no transparency. Note that this patch is
 * only relevant if you are not using the alpha patch.
 * https://github.com/szatanjl/dwm/commit/1529909466206016f2101457bbf37c67195714c8
 * https://dwm.suckless.org/patches/alpha/dwm-fixborders-6.2.diff
 */
#define NO_TRANSPARENT_BORDERS_PATCH 0

/* Port of InstantVM's on_empty_keys functionality allowing keybindings that apply only when
 * a tag is empty. An example use case is being able to launch applications with first hand
 * keys like "f" to launch firefox.
 *
 * https://github.com/instantOS/instantWM/
 * https://github.com/bakkeby/dwm-flexipatch/issues/51
 */
#define ON_EMPTY_KEYS_PATCH 0

/* Minor patch that prevents more than one rule being matched for a given client. */
#define ONLY_ONE_RULE_MATCH_PATCH 0

/* This patch makes it so dwm will only exit via quit() if no windows are open.
 * This is to prevent you accidentally losing all your work.
 * https://dwm.suckless.org/patches/onlyquitonempty/
 */
#define ONLYQUITONEMPTY_PATCH 0

/* The pertag patch adds nmaster, mfacts and layouts per tag rather than per
 * monitor (default).
 * https://dwm.suckless.org/patches/pertag/
 */
#define PERTAG_PATCH 1

/* Option to store gaps on a per tag basis rather than on a per monitor basis.
 * Depends on both pertag and vanitygaps patches being enabled.
 */
#define PERTAG_VANITYGAPS_PATCH 0

/* This controls whether or not to also store bar position on a per
 * tag basis, or leave it as one bar per monitor.
 */
#define PERTAGBAR_PATCH 0

/* This patch lets you change the position of a client in the stack using the mouse.
 * https://github.com/bakkeby/patches/wiki/placemouse
 */
#define PLACEMOUSE_PATCH 0

/* This patch provides a way to move clients up and down inside the client list.
 * https://dwm.suckless.org/patches/push/
 */
#define PUSH_PATCH 0

/* This patch provides a way to move clients up and down inside the client list,
 * but does not push up or down into the master area (except that it does not take
 * nmaster into account).
 * This takes precedence over the push patch above.
 * https://dwm.suckless.org/patches/push/
 */
#define PUSH_NO_MASTER_PATCH 0

/* Shifts all clients per tag to leftmost unoccupied tags.
 *
 * For example, if clients A, B, C are tagged on tags 1, 5, 9 respectively, when
 * this function is called, they will now be on 1, 2, and 3. The focused client
 * will also remain focused.
 *
 * Clients on multiple tags will be treated as if they only were only on their
 * leftmost tag, and will be reduced to one tag after the operation is complete.
 * https://dwm.suckless.org/patches/reorganizetags/
 */
#define REORGANIZETAGS_PATCH 0

/* By default, windows only resize from the bottom right corner. With this
 * patch the mouse is warped to the nearest corner and you resize from there.
 * https://dwm.suckless.org/patches/resizecorners/
 */
#define RESIZECORNERS_PATCH 0

/* Practically the same as resizecorners, but the cursor does not warp to corners.
 * This takes precedence over the resizecorners patch.
 * https://github.com/bakkeby/patches/blob/master/dwm/dwm-resizepoint-6.2.diff
 */
#define RESIZEPOINT_PATCH 0

/* Adds a keyboard shortcut to restart dwm or alternatively by using kill -HUP dwmpid.
 * Additionally dwm can quit cleanly by using kill -TERM dwmpid.
 * https://dwm.suckless.org/patches/restartsig/
 */
#define RESTARTSIG_PATCH 0

/* Adds rio-like drawing to resize the selected client.
 * This depends on an external tool slop being installed.
 * This patch was backported from instantWM.
 * https://github.com/bakkeby/patches/blob/master/dwm/dwm-riodraw-6.2.diff
 */
#define RIODRAW_PATCH 0

/* This patch let's you rotate through the stack using keyboard shortcuts.
 * https://dwm.suckless.org/patches/rotatestack/
 */
#define ROTATESTACK_PATCH 0

/* This patch adds rounded corners to client windows in dwm.
 * You need to uncomment the corresponding line in config.mk to use the -lXext library
 * when including this patch. You will also want to set "borderpx = 0;" in your config.h.
 * https://github.com/mitchweaver/suckless/blob/master/dwm/patches/mitch-06-rounded_corners-f04cac6d6e39cd9e3fc4fae526e3d1e8df5e34b2.patch
 */
#define ROUNDED_CORNERS_PATCH 0

/* This patch saves size and position of every floating window before it is forced
 * into tiled mode. If the window is made floating again then the old dimensions
 * will be restored.
 * https://dwm.suckless.org/patches/save_floats/
 */
#define SAVEFLOATS_PATCH 0

/* The scratchpad patch allows you to spawn or restore floating terminal windows.
 * It is typically useful when one need to do some short typing.
 *
 * Note that this patch changes TAGMASK to make room for special scratchpad tags,
 * so ~0 does more than select all tags with this patch. Code that relies on ~0 to
 * represent all tags should use ~SPTAGMASK instead.
 *
 * Upgraded to Christian Tenllado's multiple scratchpad version.
 * https://lists.suckless.org/hackers/2004/17205.html
 * https://dwm.suckless.org/patches/scratchpads/
 */
#define SCRATCHPADS_PATCH 0

/* Minor alteration of the above allowing clients to keep their size and position when shown */
#define SCRATCHPADS_KEEP_POSITION_AND_SIZE_PATCH 0

/* This alternative patch enables a scratchpad feature in dwm similar to the scratchpad
 * feature in i3wm.
 * https://github.com/GasparVardanyan/dwm-scratchpad
 */
#define SCRATCHPAD_ALT_1_PATCH 0

/* As opposed to the original patch this only adds a rule option allowing fake fullscreen
 * to be enabled for applications when they start. This is intended to be used in combination
 * with the fakefullscreenclient patch and offers no practical functionality without it.
 * https://dwm.suckless.org/patches/selectivefakefullscreen/
 */
#define SELECTIVEFAKEFULLSCREEN_PATCH 0

/* Allows restarting dwm without the dependency of an external script.
 * https://dwm.suckless.org/patches/selfrestart/
 */
#define SELFRESTART_PATCH 0

/* This patch allow clients to keep focus when being sent to another monitor.
 * https://github.com/bakkeby/patches/blob/master/dwm/dwm-sendmon_keepfocus-6.2.diff
 */
#define SENDMON_KEEPFOCUS_PATCH 0

/* This patch allows border pixels to be changed during runtime.
 * https://dwm.suckless.org/patches/setborderpx/
 */
#define SETBORDERPX_PATCH 0

/* This patch adds keybindings for left and right circular shift through tags.
 * https://github.com/chau-bao-long/dotfiles/blob/master/suckless/dwm/shiftview.diff
 */
#define SHIFTVIEW_PATCH 0

/* This variant of the shiftview patch adds left and right circular shift through tags,
 * but skips tags where there are no clients.
 */
#define SHIFTVIEW_CLIENTS_PATCH 0

/* This patch makes dwm obey even "soft" sizehints for new clients. Any window
 * that requests a specific initial size will be floated and set to that size.
 * Unlike with "fixed size" windows, you are able to resize and/or unfloat these
 * windows freely - only the initial state is affected.
 * This version of the patch is honestly of limited utility since there are many
 * clients that will abuse it.
 * https://dwm.suckless.org/patches/sizehints/
 */
#define SIZEHINTS_PATCH 0

/* This patch makes dwm obey even "soft" sizehints for new clients. This ruled
 * version is essentially the same patch except it obeys the "isfloating" rule
 * if it is available in config.h for the given client.
 * https://dwm.suckless.org/patches/sizehints/
 */
#define SIZEHINTS_RULED_PATCH 0

/* In a multi-head setup monitor 0 is by default the primary screen, with the left and right
 * screen being monitor 1 and 2 respectively. This patch sorts screens left to right (or
 * top to bottom in a vertical layout) which aims to address some inconsistencies when it
 * comes to focusmon, tagmon and similar functionality.
 * https://www.mail-archive.com/hackers@suckless.org/msg09400.html
 */
#define SORTSCREENS_PATCH 0

/* Spawns programs from currently focused client's working directory.
 * https://dwm.suckless.org/patches/spawn_cwd/
 */
#define SPAWNCMD_PATCH 0

/* This patch provides comprehensive utilities for managing the client stack, providing
 * keyboard shortcuts for focusing or placing a client at specific positions in the stack.
 * Note that the default keybindings for this patch have been changed in dwm-flexipatch
 * due to the many conflicts with other patches. As it provides similar functionality to the
 * swapfocus patch it also uses the MOD+s shortcut to focus the previously selected client,
 * thus note a conflict between these two patches.
 * https://dwm.suckless.org/patches/stacker/
 */
#define STACKER_PATCH 0

/* Steam, and steam windows (games), trigger a ConfigureNotify request every time the window
 * gets focus. More so, the configure event passed along from Steam tends to have the wrong
 * x and y co-ordinates which can make the window, if floating, jump around the screen.
 *
 * This patch works around this age-old issue by ignoring the x and y co-ordinates for
 * ConfigureNotify requests relating to Steam windows.
 *
 * https://github.com/bakkeby/patches/wiki/steam
 */
#define STEAM_PATCH 0

/* Adds toggleable keyboard shortcut to make a client 'sticky', i.e. visible on all tags.
 * https://dwm.suckless.org/patches/sticky/
 */
#define STICKY_PATCH 0

/* This patch adds "window swallowing" to dwm as known from Plan 9's windowing system rio.
 * Clients marked with isterminal in config.h swallow a window opened by any child process,
 * e.g. running xclock in a terminal. Closing the xclock window restores the terminal window
 * in the current position.
 *
 * This patch depends on the following additional libraries:
 *    - libxcb
 *    - Xlib-libxcb
 *    - xcb-res
 *
 * You need to uncomment the corresponding line in config.mk to use the above libraries when
 * including this patch.
 *
 * https://dwm.suckless.org/patches/swallow/
 */
#define SWALLOW_PATCH 0

/* This patch depends on the pertag patch and makes it possible to switch focus with a single
 * shortcut (MOD+s) instead of having to think if you should use mod-j or mod-k for reaching
 * the previously used window.
 * https://dwm.suckless.org/patches/swapfocus/
 */
#define SWAPFOCUS_PATCH 1

/* This patch allows swapping the contents of the currently selected tag with another tag using
 * keyboard shortcuts.
 * https://dwm.suckless.org/patches/swaptags/
 */
#define SWAPTAGS_PATCH 0

/* Switch focus between the master and stack columns using a single keybinding.
 * https://dwm.suckless.org/patches/switchcol/
 */
#define SWITCHCOL_PATCH 0

/* By default dwm allow you to set application specific rules so that you can have your browser,
 * for example, start up on tag 9 optionally on a given monitor when you open your browser it is
 * then automatically moved to the configured tag, but you have to manually enable the tag to see
 * the newly opened application.
 * This patch adds an extra configuration option for individual rules where:
 *   0 is default behaviour
 *   1 automatically moves you to the tag of the newly opened application and
 *   2 enables the tag of the newly opened application in addition to your existing enabled tags
 *   3 as 1, but closing that window reverts the view back to what it was previously (*)
 *   4 as 2, but closing that window reverts the view back to what it was previously (*)
 *
 * (*) except if the client has been moved between tags or to another monitor
 *
 * https://github.com/bakkeby/patches/blob/master/dwm/dwm-switchtag-6.2.diff
 * Also see https://dwm.suckless.org/patches/switchtotag
 */
#define SWITCHTAG_PATCH 0

/* This patch transforms the monocle layout into a "tabbed" layout if more than one window is
 * present on the monocle view. This patch has been added for demonstration purposes only and has
 * limited compatibility with other patches. It will conflict space-wise with a second bar.
 * Note that fancybar, awesomebar, bartabgroups and similar patches make the tab patch redundant.
 * https://dwm.suckless.org/patches/tab/
 */
#define TAB_PATCH 0

/* Adds keyboard shortcuts to move all (or only floating) windows from one tag to another.
 * https://dwm.suckless.org/patches/tagall/
 */
#define TAGALL_PATCH 0

/* This patch allows you to move all visible windows on a monitor to an adjacent monitor.
 * https://github.com/bakkeby/patches/blob/master/dwm/dwm-tagallmon-6.2.diff
 */
#define TAGALLMON_PATCH 0

/* This patch makes new clients attach into the stack area when you toggle a new tag into
 * view. This means your master area will remain unchanged when toggling views.
 * The allmaster patch will cause all clients in the master area to be left alone. This patch
 * takes precedence over the onemaster tagintostack patch.
 * https://dwm.suckless.org/patches/tagintostack/
 */
#define TAGINTOSTACK_ALLMASTER_PATCH 0

/* This patch makes new clients attach into the stack area when you toggle a new tag into
 * view. This means your master area will remain unchanged when toggling views.
 * The onemaster patch will cause the first client in the master area to be left alone.
 * https://dwm.suckless.org/patches/tagintostack/
 */
#define TAGINTOSTACK_ONEMASTER_PATCH 0

/* If you try to send a fullscreen window to an adjacent monitor using tagmon then
 * the window is moved behind the scenes, but it remains in fullscreen on the original
 * monitor until you exit fullscreen view (at which point it will appear on the adjacent
 * monitor). This patch allows a fullscreen window to be moved to an adjacent monitor
 * while remaining in fullscreen.
 * https://github.com/bakkeby/patches/blob/master/dwm/dwm-tagmonfixfs-6.2.diff
 */
#define TAGMONFIXFS_PATCH 0

/* Add functions and keybindings to tag a window to a desired tag on the next (right)
 * or previous (left) monitor from the currently selected monitor.
 * https://dwm.suckless.org/patches/tagothermonitor/
 */
#define TAGOTHERMONITOR_PATCH 0

/* This patch allows you to swap all visible windows on one monitor with those of an
 * adjacent monitor.
 * https://github.com/bakkeby/patches/blob/master/dwm/dwm-tagswapmon-6.2.diff
 */
#define TAGSWAPMON_PATCH 0

/* This patch can be useful to the touchpad users because it allows to
 * resize windows using Mod + two-finger scroll. It is useful when
 * two-finger scrolling is configured in libinput.
 * https://dwm.suckless.org/patches/tapresize/
 */
#define TAPRESIZE_PATCH 0

/* This patch allows you to toggle fullscreen on and off using a single shortcut key.
 * https://github.com/bakkeby/patches/blob/master/dwm/dwm-togglefullscreen-6.2.diff
 */
#define TOGGLEFULLSCREEN_PATCH 0

/* Lets you transfer the currently focused client between the master and stack area
 * while increasing or decreasing the master area (nmaster) accordingly.
 * https://dwm.suckless.org/patches/transfer/
 */
#define TRANSFER_PATCH 0

/* Lets you transfer all clients between the master and stack area
 * while increasing or decreasing the master area (nmaster) accordingly.
 * https://dwm.suckless.org/patches/transfer/
 */
#define TRANSFER_ALL_PATCH 0

/* This patch resets isfloating on any visible windows that have it set.
 * Optionally also applies a layout.
 * https://dwm.suckless.org/patches/unfloatvisible/
 */
#define UNFLOATVISIBLE_PATCH 0

/* This patch adds configurable gaps between windows differentiating between outer, inner,
 * horizontal and vertical gaps.
 * https://github.com/bakkeby/patches/blob/master/dwm/dwm-vanitygaps-6.2.diff
 * https://github.com/bakkeby/patches/blob/master/dwm/dwm-cfacts-vanitygaps-6.2.diff
 */
#define VANITYGAPS_PATCH 1

/* This patch adds outer gaps for the monocle layout.
 * Most gaps patches tries to avoid gaps on the monocle layout, as it is often used as a
 * fullscreen mode, hence this is enabled separately from the main vanitygaps patch.
 */
#define VANITYGAPS_MONOCLE_PATCH 0

/* Follow a window to the tag it is being moved to.
 * https://dwm.suckless.org/patches/viewontag/
 */
#define VIEWONTAG_PATCH 0

/* By default tags can be changed using MOD+<num> while MOD+Tab toggles between the current and
 * the previous tag. This patch changes this so that if you hit MOD+<num> for the tag you are
 * currently on, then it works the same as MOD+Tab and switches back to the previous tag.
 * Idea ref.
 * https://www.reddit.com/r/suckless/comments/ik27vd/key_toggle_between_next_and_previous_tag_dwm/
 */
#define VIEW_SAME_TAG_GIVES_PREVIOUS_TAG_PATCH 0

/* This patch warps the mouse cursor to the center of the currently focused window or screen
 * when the mouse cursor is (a) on a different screen or (b) on top of a different window.
 * https://dwm.suckless.org/patches/warp/
 */
#define WARP_PATCH 0

/* Sometimes a single application opens different windows depending on the task
 * at hand and this is often reflected in the WM_WINDOW_ROLE(STRING) x property.
 * This patch adds the role field to the rule configuration so that one can
 * differentiate between, say, Firefox "browser" vs "Preferences" vs "Manager"
 * or Google-chrome "browser" vs "pop-up".
 * https://github.com/bakkeby/patches/blob/master/dwm/dwm-windowrolerule-6.2.diff
 */
#define WINDOWROLERULE_PATCH 0

/* The winview patch allows switching the view to that of a given client from the all-window
 * view (Mod-0) using a keyboard shortcut.
 * http://dwm.suckless.org/patches/winview/
 */
#define WINVIEW_PATCH 0

/* Remember keyboard layout per client.
 * It is recommended that you configure xkb before using this patch as described in
 * https://www.x.org/archive/X11R7.5/doc/input/XKB-Config.html
 * https://dwm.suckless.org/patches/xkb/
 */
#define XKB_PATCH 0

/* Allows dwm to read colors from xrdb (.Xresources) during runtime. Compatible with
 * the float border color, awesomebar, urgentborder and titlecolor patches.
 * https://dwm.suckless.org/patches/xrdb/
 */
#define XRDB_PATCH 0

/* Simple patch that allows floating windows to be zoomed into the master stack position.
 * https://www.reddit.com/r/suckless/comments/ie5fe3/zoomfloating_my_own_simple_original_patch/
 */
#define ZOOMFLOATING_PATCH 0

/* The zoomswap patch allows a master and a stack window to swap places
 * rather than every window on the screen changing position.
 * https://dwm.suckless.org/patches/zoomswap/
 */
#define ZOOMSWAP_PATCH 0

/**
 * Layouts
 */

/* Bottomstack layout.
 * https://dwm.suckless.org/patches/bottomstack/
 */
#define BSTACK_LAYOUT 1

/* Bottomstack horizontal layout.
 * https://dwm.suckless.org/patches/bottomstack/
 */
#define BSTACKHORIZ_LAYOUT 0

/* Centered master layout.
 * https://dwm.suckless.org/patches/centeredmaster/
 */
#define CENTEREDMASTER_LAYOUT 0

/* Centered floating master layout.
 * https://dwm.suckless.org/patches/centeredmaster/
 */
#define CENTEREDFLOATINGMASTER_LAYOUT 0

/* Same as the default tile layout except clients in the master area are arranged in
 * columns (i.e. left to right).
 * https://dwm.suckless.org/patches/columns/
 */
#define COLUMNS_LAYOUT 0

/* Deck layout.
 * https://dwm.suckless.org/patches/deck/
 */
#define DECK_LAYOUT 0

/* Fibonacci dwindle layout.
 * https://dwm.suckless.org/patches/fibonacci/
 */
#define FIBONACCI_DWINDLE_LAYOUT 0

/* Fibonacci spiral layout.
 * https://dwm.suckless.org/patches/fibonacci/
 */
#define FIBONACCI_SPIRAL_LAYOUT 0

/* Flextile deluxe layout.
 * A revamped, more flexible, and over-the-top version of the original flextile layout.
 * https://dwm.suckless.org/patches/flextile/ (original)
 */
#define FLEXTILE_DELUXE_LAYOUT 1

/* Gappless grid layout.
 * https://dwm.suckless.org/patches/gaplessgrid/
 */
#define GAPPLESSGRID_LAYOUT 0

/* Gridmode (grid) layout.
 * https://dwm.suckless.org/patches/gridmode/
 */
#define GRIDMODE_LAYOUT 0

/* Horizontal grid (horizgrid) layout.
 * https://dwm.suckless.org/patches/horizgrid/
 */
#define HORIZGRID_LAYOUT 0

/* Grid layout where nmaster controls the number of rows.
 * https://dwm.suckless.org/patches/nrowgrid/
 */
#define NROWGRID_LAYOUT 0

/* The default tile layout.
 * This can be optionally disabled in favour of other layouts.
 */
#define TILE_LAYOUT 1

/* Monocle layout (default).
 * This can be optionally disabled in favour of other layouts.
 */
#define MONOCLE_LAYOUT 1```

[bakkeby]

Hi @godspeed-x, hmm, I'll have a closer look at why that is. In the meantime enable PERTAG_VANITYGAPS_PATCH as well.

[bakkeby]

Just committed a fix for that, thanks for reporting.

The PERTAG_VANITYGAPS_PATCH is a pertag option to remember gap sizes on a per tag basis. Introducing that led to a bug where the gaps would not be enabled by default (but could be enabled if you were to use togglegaps).

[0xGodspeed]

Thanks! I cloned the repo again and the gaps are working now without PERTAG_VANITYGAPS_PATCH but I can't toggle the gaps on/off.
If I enable the pertag patch as well, then it works.

[bakkeby]

Yes maybe it is better that PERTAG_VANITYGAPS_PATCH controls both remembering gap sizes per tag as well as whether gaps are enabled per tag.

[0xGodspeed]

So there is no way to toggle gaps without the patch?

[bakkeby]

It used to be that if you had vanitygaps and pertag enabled then it would automatically also remember whether gaps were enabled per tag.

Then later the option to remember different gap sizes on a per tag basis was introduced as well. As some may prefer not to have different gap sizes on a per tag basis this was made configurable.

As this was now configurable it wasn't entirely clear whether tags should be toggleable on a per tag basis automatically or not, hence the initial bug you reported.

I think it is more logical that PERTAG_VANITYGAPS_PATCH controls both features.

You will be able to toggle gaps in both cases. It will be similar to the pertag bar patch which allows you to toggle the display of the bar on and off on a per tag basis.

[0xGodspeed]

You will be able to toggle gaps in both cases. It will be similar to the pertag bar patch which allows you to toggle the display of the bar on and off on a per tag basis.

I can't toggle gaps without PERTAG_VANITYGAPS_PATCH

[bakkeby]

You should be able to after the last commit.

[0xGodspeed]

It is working after the last commit. Thanks a lot.

[desprit]

@bakkeby thanks for fixing it!

One question, I'm using three-column layout, any chance to get the gaps there too? I've just started experimenting with dwm and can't wrap my head around it yet :)

[bakkeby]

@desprit how is the three column layout different from the centeredmaster layout?

[desprit]

@bakkeby I haven't tried centeredmaster but from the screenshots it looks like centeredmaster may have a stack of masters while threecolumn layout always has one master in the middle of the screen; new windows are added to the left and right.

[bakkeby]

@desprit I think the three column layout is older than the nmaster patch, hence you can only have one client in the master area. I'd recommend that you try that one out first. You also get all of these layouts with flextile-deluxe, but that's a bit of an overkill.

[desprit]

@bakkeby Works perfectly for me, thank you!