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

/* Helper macros for spawning commands */
#define SHCMD(cmd)                                                             \
  {                                                                            \
    .v = (const char *[]) { "/bin/sh", "-c", cmd, NULL }                       \
  }
#define CMD(...)                                                               \
  {                                                                            \
    .v = (const char *[]) { __VA_ARGS__, NULL }                                \
  }

/* appearance */
#if ROUNDED_CORNERS_PATCH
static const unsigned int borderpx = 0; /* border pixel of windows */
static const int corner_radius = 10;
#else
static const unsigned int borderpx = 2; /* border pixel of windows */
#endif // ROUNDED_CORNERS_PATCH
#if BAR_BORDER_PATCH
/* This allows the bar border size to be explicitly set separately from
 * borderpx. If left as 0 then it will default to the borderpx value of the
 * monitor and will automatically update with setborderpx. */
static const unsigned int barborderpx = 0; /* border pixel of bar */
#endif                                     // BAR_BORDER_PATCH
static const unsigned int snap = 32;       /* snap pixel */
#if SWALLOW_PATCH
static const int swallowfloating =
    0; /* 1 means swallow floating windows by default */
#endif // SWALLOW_PATCH
#if BAR_TAGPREVIEW_PATCH
static const int scalepreview = 4; /* Tag preview scaling */
#endif                             // BAR_TAGPREVIEW_PATCH
#if NO_MOD_BUTTONS_PATCH
static int nomodbuttons =
    1; /* allow client mouse button bindings that have no modifier */
#endif // NO_MOD_BUTTONS_PATCH
#if VANITYGAPS_PATCH
static const unsigned int gappih = 20; /* horiz inner gap between windows */
static const unsigned int gappiv = 10; /* vert inner gap between windows */
static const unsigned int gappoh =
    5; /* horiz outer gap between windows and screen edge */
static const unsigned int gappov =
    5; /* 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 */
#endif // VANITYGAPS_PATCH
#if AUTOSTART_PATCH
static const char autostartblocksh[] = "autostart_blocking.sh";
static const char autostartsh[] = "autostart.sh";
static const char dwmdir[] = "dwm";
static const char localshare[] = ".local/share";
#endif // AUTOSTART_PATCH
#if BAR_ANYBAR_PATCH
static const int usealtbar = 1;             /* 1 means use non-dwm status bar */
static const char *altbarclass = "Polybar"; /* Alternate bar class name */
static const char *altbarcmd =
    "$HOME/bar.sh"; /* Alternate bar launch command */
#endif              // BAR_ANYBAR_PATCH
#if BAR_HOLDBAR_PATCH
static const int showbar = 0; /* 0 means no bar */
#else
static const int showbar = 1; /* 0 means no bar */
#endif                       // BAR_HOLDBAR_PATCH
static const int topbar = 0; /* 0 means bottom bar */
#if TAB_PATCH
/*  Display modes of the tab bar: never shown, always shown, shown only in  */
/*  monocle mode in the presence of several windows.                        */
/*  Modes after showtab_nmodes are disabled.                                */
enum showtab_modes {
  showtab_never,
  showtab_auto,
  showtab_nmodes,
  showtab_always
};
static const int showtab = showtab_auto; /* Default tab bar show mode */
static const int toptab = False;         /* False means bottom tab bar */
#endif                                   // TAB_PATCH
#if BAR_HEIGHT_PATCH
static const int bar_height =
    0; /* 0 means derive from font, >= 1 explicit height */
#endif // BAR_HEIGHT_PATCH
#if BAR_PADDING_PATCH
static const int vertpad = 10; /* vertical padding of bar */
static const int sidepad = 10; /* horizontal padding of bar */
#endif                         // BAR_PADDING_PATCH
#if BAR_WINICON_PATCH
#define ICONSIZE 20   /* icon size */
#define ICONSPACING 5 /* space between icon and title */
#endif                // BAR_WINICON_PATCH
#if FOCUSONCLICK_PATCH
static const int focusonwheel = 0;
#endif // FOCUSONCLICK_PATCH
#if FLOATPOS_PATCH
static int floatposgrid_x = 5; /* float grid columns */
static int floatposgrid_y = 5; /* float grid rows */
#endif                         // FLOATPOS_PATCH
#if RIODRAW_PATCH
static const char slopspawnstyle[] =
    "-t 0 -c 0.92,0.85,0.69,0.3 -o"; /* do NOT define -f (format) here */
static const char slopresizestyle[] =
    "-t 0 -c 0.92,0.85,0.69,0.3"; /* do NOT define -f (format) here */
static const int riodraw_borders =
    0; /* 0 or 1, indicates whether the area drawn using slop includes the
          window borders */
#if SWALLOW_PATCH
static const int riodraw_matchpid =
    1; /* 0 or 1, indicates whether to match the PID of the client that was
          spawned with riospawn */
#endif // SWALLOW_PATCH
#endif // RIODRAW_PATCH
/* Status is to be shown on: -1 (all monitors), 0 (a specific monitor by index),
 * 'A' (active monitor) */
#if BAR_STATUSALLMONS_PATCH
static const int statusmon = -1;
#elif BAR_STATICSTATUS_PATCH
static const int statusmon = 0;
#else
static const int statusmon = 'A';
#endif // BAR_STATUSALLMONS_PATCH | BAR_STATICSTATUS_PATCH
#if BAR_STATUSPADDING_PATCH
static const int horizpadbar = 2; /* horizontal padding for statusbar */
static const int vertpadbar = 0;  /* vertical padding for statusbar */
#endif                            // BAR_STATUSPADDING_PATCH
#if BAR_STATUSBUTTON_PATCH
static const char buttonbar[] = "<O>";
#endif // BAR_STATUSBUTTON_PATCH
#if BAR_SYSTRAY_PATCH
static const unsigned int systrayspacing = 2; /* systray spacing */
static const int showsystray = 1;             /* 0 means no systray */
#endif                                        // BAR_SYSTRAY_PATCH
#if BAR_TAGLABELS_PATCH
static const char ptagf[] = "[%s %s]"; /* format of a tag label */
static const char etagf[] = "[%s]";    /* format of an empty tag */
static const int lcaselbl = 0;         /* 1 means make tag label lowercase */
#endif                                 // BAR_TAGLABELS_PATCH
#if BAR_UNDERLINETAGS_PATCH
static const unsigned int ulinepad =
    5; /* horizontal padding between the underline and tag */
static const unsigned int ulinestroke =
    2; /* thickness / height of the underline */
static const unsigned int ulinevoffset =
    0; /* how far above the bottom of the bar the line should appear */
static const int ulineall =
    0; /* 1 to show underline on all tags, 0 for just the active ones */
#endif // BAR_UNDERLINETAGS_PATCH

#if NAMETAG_PATCH
#if NAMETAG_PREPEND_PATCH
/* The format in which the tag is written when named. E.g. %d: %.12s will write
 * the tag number followed the first 12 characters of the given string. You can
 * also just use "%d: %s" here. */
#define NAMETAG_FORMAT "%d: %.12s"
#else
#define NAMETAG_FORMAT "%s"
#endif // NAMETAG_PREPEND_PATCH
/* The maximum amount of bytes reserved for each tag text. */
#define MAX_TAGLEN 16
/* The command to run (via popen). This can be tailored by adding a prompt,
 * passing other command line arguments or providing name options. Optionally
 * you can use other dmenu like alternatives like rofi -dmenu. */
#define NAMETAG_COMMAND "dmenu < /dev/null"
#endif // NAMETAG_PATCH

#if ALT_TAB_PATCH
/* alt-tab configuration */
static const unsigned int tabmodkey =
    0x40; /* (Alt) when this key is held down the alt-tab functionality stays
             active. Must be the same modifier as used to run alttabstart */
static const unsigned int tabcyclekey =
    0x17; /* (Tab) when this key is hit the menu moves one position forward in
             client stack. Must be the same key as used to run alttabstart */
static const unsigned int tabposy =
    1; /* tab position on Y axis, 0 = top, 1 = center, 2 = bottom */
static const unsigned int tabposx =
    1; /* tab position on X axis, 0 = left, 1 = center, 2 = right */
static const unsigned int maxwtab = 600; /* tab menu width */
static const unsigned int maxhtab = 200; /* tab menu height */
#endif                                   // ALT_TAB_PATCH

/* 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;
#if FAKEFULLSCREEN_CLIENT_PATCH && !FAKEFULLSCREEN_PATCH
static int fakefsindicatortype = INDICATOR_PLUS;
static int floatfakefsindicatortype = INDICATOR_PLUS_AND_LARGER_SQUARE;
#endif // FAKEFULLSCREEN_CLIENT_PATCH
#if ALWAYSONTOP_PATCH
static int aotindicatortype = INDICATOR_TOP_LEFT_LARGER_SQUARE;
#endif // ALWAYSONTOP_PATCH
#if ONLYQUITONEMPTY_PATCH
static const int quit_empty_window_count =
    0; /* only allow dwm to quit if no (<= count) windows are open */
#endif // ONLYQUITONEMPTY_PATCH
#if BAR_EXTRASTATUS_PATCH
static const char statussep = ';'; /* separator between status bars */
#endif                             // BAR_EXTRASTATUS_PATCH
#if BAR_TABGROUPS_PATCH
#if MONOCLE_LAYOUT
static void (*bartabmonfns[])(Monitor *) = {monocle /* , customlayoutfn */};
#else
static void (*bartabmonfns[])(Monitor *) = {NULL /* , customlayoutfn */};
#endif // MONOCLE_LAYOUT
#endif // BAR_TABGROUPS_PATCH
#if BAR_PANGO_PATCH
static const char font[] = "monospace 10";
#else
static const char *fonts[] = {"JetBrainsMono:size=11"};
#endif // BAR_PANGO_PATCH
static const char dmenufont[] = "JetBrainsMono:size=11";

static char c000000[] = "#000000"; // placeholder value

static char normfgcolor[] = "#424153"; // dark grey text for good contrast
static char normbgcolor[] = "#ffffff"; // soft light beige background
static char normbordercolor[] =
    "#999999"; // medium grey border for subtle contrast
static char normfloatcolor[] = "#abbcda"; // soft blue-grey for floating windows

static char selfgcolor[] = "#424153"; // dark grey text for selected window
static char selbgcolor[] =
    "#ffffff"; // pure white for selected window background
static char selbordercolor[] =
    "#abbcda"; // matching light blue-grey border for selected window
static char selfloatcolor[] =
    "#abbcda"; // light blue-grey for selected floating windows

static char titlenormfgcolor[] = "#424153"; // dark grey title text
static char titlenormbgcolor[] =
    "#ffffff"; // soft light beige background for title
static char titlenormbordercolor[] = "#999999"; // medium grey border for title
static char titlenormfloatcolor[] =
    "#abbcda"; // light blue-grey for floating title

static char titleselfgcolor[] = "#424153"; // dark grey text for selected title
static char titleselbgcolor[] =
    "#ffffff"; // pure white for selected title background
static char titleselbordercolor[] =
    "#abbcda"; // matching blue-grey border for selected title
static char titleselfloatcolor[] =
    "#abbcda"; // light blue-grey for floating title

static char tagsnormfgcolor[] = "#424153";     // dark grey text for tags
static char tagsnormbgcolor[] = "#ffffff";     // soft beige background for tags
static char tagsnormbordercolor[] = "#999999"; // medium grey border for tags
static char tagsnormfloatcolor[] =
    "#abbcda"; // light blue-grey for floating tags

static char tagsselfgcolor[] = "#424153"; // dark grey text for selected tags
static char tagsselbgcolor[] =
    "#ffffff"; // pure white for selected tag background
static char tagsselbordercolor[] =
    "#abbcda"; // matching blue-grey border for selected tags
static char tagsselfloatcolor[] =
    "#abbcda"; // light blue-grey for floating selected tags

static char hidnormfgcolor[] =
    "#abbcda"; // soft blue-grey for hidden window text
static char hidselfgcolor[] = "#999999"; // medium grey for hidden window text
static char hidnormbgcolor[] =
    "#ffffff"; // pure white background for hidden windows
static char hidselbgcolor[] =
    "#ffffff"; // white background for selected hidden windows

static char urgfgcolor[] = "#424153"; // dark grey text for urgent windows
static char urgbgcolor[] = "#ff4444"; // bright red for urgent windows
static char urgbordercolor[] =
    "#ff4444"; // matching red border for urgent windows
static char urgfloatcolor[] =
    "#ff6666"; // slightly lighter red for urgent floating windows

#if BAR_LTSYMBOL_SCHEME_PATCH
static char ltsymbolfgcolor[] = "#222222";
static char ltsymbolbgcolor[] = "#fe9877";
#endif // BAR_LTSYMBOL_SCHEME_PATCH

#if RENAMED_SCRATCHPADS_PATCH
static char scratchselfgcolor[] = "#FFF7D4";
static char scratchselbgcolor[] = "#77547E";
static char scratchselbordercolor[] = "#894B9F";
static char scratchselfloatcolor[] = "#894B9F";

static char scratchnormfgcolor[] = "#FFF7D4";
static char scratchnormbgcolor[] = "#664C67";
static char scratchnormbordercolor[] = "#77547E";
static char scratchnormfloatcolor[] = "#77547E";
#endif // RENAMED_SCRATCHPADS_PATCH

#if BAR_FLEXWINTITLE_PATCH
static char normTTBbgcolor[] = "#330000";
static char normLTRbgcolor[] = "#330033";
static char normMONObgcolor[] = "#000033";
static char normGRIDbgcolor[] = "#003300";
static char normGRD1bgcolor[] = "#003300";
static char normGRD2bgcolor[] = "#003300";
static char normGRDMbgcolor[] = "#506600";
static char normHGRDbgcolor[] = "#b96600";
static char normDWDLbgcolor[] = "#003333";
static char normSPRLbgcolor[] = "#333300";
static char normfloatbgcolor[] = "#115577";
static char actTTBbgcolor[] = "#440000";
static char actLTRbgcolor[] = "#440044";
static char actMONObgcolor[] = "#000044";
static char actGRIDbgcolor[] = "#004400";
static char actGRD1bgcolor[] = "#004400";
static char actGRD2bgcolor[] = "#004400";
static char actGRDMbgcolor[] = "#507711";
static char actHGRDbgcolor[] = "#b97711";
static char actDWDLbgcolor[] = "#004444";
static char actSPRLbgcolor[] = "#444400";
static char actfloatbgcolor[] = "#116688";
static char selTTBbgcolor[] = "#550000";
static char selLTRbgcolor[] = "#550055";
static char selMONObgcolor[] = "#212171";
static char selGRIDbgcolor[] = "#005500";
static char selGRD1bgcolor[] = "#005500";
static char selGRD2bgcolor[] = "#005500";
static char selGRDMbgcolor[] = "#508822";
static char selHGRDbgcolor[] = "#b98822";
static char selDWDLbgcolor[] = "#005555";
static char selSPRLbgcolor[] = "#555500";
static char selfloatbgcolor[] = "#117799";
#endif // BAR_FLEXWINTITLE_PATCH

#if BAR_ALPHA_PATCH
static const unsigned int baralpha = 0xd0;
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},
    [SchemeHidNorm] = {OPAQUE, baralpha, borderalpha},
    [SchemeHidSel] = {OPAQUE, baralpha, borderalpha},
    [SchemeUrg] = {OPAQUE, baralpha, borderalpha},
#if BAR_LTSYMBOL_SCHEME_PATCH
    [SchemeLtSymbol] = {OPAQUE, baralpha, borderalpha},
#endif // BAR_LTSYMBOL_SCHEME_PATCH
#if RENAMED_SCRATCHPADS_PATCH
    [SchemeScratchSel] = {OPAQUE, baralpha, borderalpha},
    [SchemeScratchNorm] = {OPAQUE, baralpha, borderalpha},
#endif // RENAMED_SCRATCHPADS_PATCH
#if BAR_FLEXWINTITLE_PATCH
    [SchemeFlexActTTB] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexActLTR] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexActMONO] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexActGRID] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexActGRD1] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexActGRD2] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexActGRDM] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexActHGRD] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexActDWDL] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexActSPRL] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexActFloat] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexInaTTB] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexInaLTR] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexInaMONO] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexInaGRID] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexInaGRD1] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexInaGRD2] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexInaGRDM] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexInaHGRD] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexInaDWDL] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexInaSPRL] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexInaFloat] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexSelTTB] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexSelLTR] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexSelMONO] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexSelGRID] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexSelGRD1] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexSelGRD2] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexSelGRDM] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexSelHGRD] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexSelDWDL] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexSelSPRL] = {OPAQUE, baralpha, borderalpha},
    [SchemeFlexSelFloat] = {OPAQUE, baralpha, borderalpha},
#endif // BAR_FLEXWINTITLE_PATCH
};
#endif // BAR_ALPHA_PATCH
#if BAR_VTCOLORS_PATCH
static const char title_bg_dark[] = "#303030";
static const char title_bg_light[] = "#fdfdfd";
static const int color_ptrs[][ColCount] = {
    /*                       fg      bg      border  float */
    [SchemeNorm] = {-1, -1, 5, 12},      [SchemeSel] = {-1, -1, 11, 13},
    [SchemeTitleNorm] = {6, -1, -1, -1}, [SchemeTitleSel] = {6, -1, -1, -1},
    [SchemeTagsNorm] = {2, 0, 0, -1},    [SchemeTagsSel] = {6, 5, 5, -1},
    [SchemeHidNorm] = {5, 0, 0, -1},     [SchemeHidSel] = {6, -1, -1, -1},
    [SchemeUrg] = {7, 9, 9, 15},
#if BAR_LTSYMBOL_SCHEME_PATCH
    [SchemeLtSymbol] = {-1, 3, 0, 0},
#endif // BAR_LTSYMBOL_SCHEME_PATCH
};
#endif // BAR_VTCOLORS_PATCH

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, c000000, c000000},
    [SchemeHidSel] = {hidselfgcolor, hidselbgcolor, c000000, c000000},
    [SchemeUrg] = {urgfgcolor, urgbgcolor, urgbordercolor, urgfloatcolor},
#if BAR_LTSYMBOL_SCHEME_PATCH
    [SchemeLtSymbol] = {ltsymbolfgcolor, ltsymbolbgcolor, c000000, c000000},
#endif // BAR_LTSYMBOL_SCHEME_PATCH
#if RENAMED_SCRATCHPADS_PATCH
    [SchemeScratchSel] = {scratchselfgcolor, scratchselbgcolor,
                          scratchselbordercolor, scratchselfloatcolor},
    [SchemeScratchNorm] = {scratchnormfgcolor, scratchnormbgcolor,
                           scratchnormbordercolor, scratchnormfloatcolor},
#endif // RENAMED_SCRATCHPADS_PATCH
#if BAR_FLEXWINTITLE_PATCH
    [SchemeFlexActTTB] = {titleselfgcolor, actTTBbgcolor, actTTBbgcolor,
                          c000000},
    [SchemeFlexActLTR] = {titleselfgcolor, actLTRbgcolor, actLTRbgcolor,
                          c000000},
    [SchemeFlexActMONO] = {titleselfgcolor, actMONObgcolor, actMONObgcolor,
                           c000000},
    [SchemeFlexActGRID] = {titleselfgcolor, actGRIDbgcolor, actGRIDbgcolor,
                           c000000},
    [SchemeFlexActGRD1] = {titleselfgcolor, actGRD1bgcolor, actGRD1bgcolor,
                           c000000},
    [SchemeFlexActGRD2] = {titleselfgcolor, actGRD2bgcolor, actGRD2bgcolor,
                           c000000},
    [SchemeFlexActGRDM] = {titleselfgcolor, actGRDMbgcolor, actGRDMbgcolor,
                           c000000},
    [SchemeFlexActHGRD] = {titleselfgcolor, actHGRDbgcolor, actHGRDbgcolor,
                           c000000},
    [SchemeFlexActDWDL] = {titleselfgcolor, actDWDLbgcolor, actDWDLbgcolor,
                           c000000},
    [SchemeFlexActSPRL] = {titleselfgcolor, actSPRLbgcolor, actSPRLbgcolor,
                           c000000},
    [SchemeFlexActFloat] = {titleselfgcolor, actfloatbgcolor, actfloatbgcolor,
                            c000000},
    [SchemeFlexInaTTB] = {titlenormfgcolor, normTTBbgcolor, normTTBbgcolor,
                          c000000},
    [SchemeFlexInaLTR] = {titlenormfgcolor, normLTRbgcolor, normLTRbgcolor,
                          c000000},
    [SchemeFlexInaMONO] = {titlenormfgcolor, normMONObgcolor, normMONObgcolor,
                           c000000},
    [SchemeFlexInaGRID] = {titlenormfgcolor, normGRIDbgcolor, normGRIDbgcolor,
                           c000000},
    [SchemeFlexInaGRD1] = {titlenormfgcolor, normGRD1bgcolor, normGRD1bgcolor,
                           c000000},
    [SchemeFlexInaGRD2] = {titlenormfgcolor, normGRD2bgcolor, normGRD2bgcolor,
                           c000000},
    [SchemeFlexInaGRDM] = {titlenormfgcolor, normGRDMbgcolor, normGRDMbgcolor,
                           c000000},
    [SchemeFlexInaHGRD] = {titlenormfgcolor, normHGRDbgcolor, normHGRDbgcolor,
                           c000000},
    [SchemeFlexInaDWDL] = {titlenormfgcolor, normDWDLbgcolor, normDWDLbgcolor,
                           c000000},
    [SchemeFlexInaSPRL] = {titlenormfgcolor, normSPRLbgcolor, normSPRLbgcolor,
                           c000000},
    [SchemeFlexInaFloat] = {titlenormfgcolor, normfloatbgcolor,
                            normfloatbgcolor, c000000},
    [SchemeFlexSelTTB] = {titleselfgcolor, selTTBbgcolor, selTTBbgcolor,
                          c000000},
    [SchemeFlexSelLTR] = {titleselfgcolor, selLTRbgcolor, selLTRbgcolor,
                          c000000},
    [SchemeFlexSelMONO] = {titleselfgcolor, selMONObgcolor, selMONObgcolor,
                           c000000},
    [SchemeFlexSelGRID] = {titleselfgcolor, selGRIDbgcolor, selGRIDbgcolor,
                           c000000},
    [SchemeFlexSelGRD1] = {titleselfgcolor, selGRD1bgcolor, selGRD1bgcolor,
                           c000000},
    [SchemeFlexSelGRD2] = {titleselfgcolor, selGRD2bgcolor, selGRD2bgcolor,
                           c000000},
    [SchemeFlexSelGRDM] = {titleselfgcolor, selGRDMbgcolor, selGRDMbgcolor,
                           c000000},
    [SchemeFlexSelHGRD] = {titleselfgcolor, selHGRDbgcolor, selHGRDbgcolor,
                           c000000},
    [SchemeFlexSelDWDL] = {titleselfgcolor, selDWDLbgcolor, selDWDLbgcolor,
                           c000000},
    [SchemeFlexSelSPRL] = {titleselfgcolor, selSPRLbgcolor, selSPRLbgcolor,
                           c000000},
    [SchemeFlexSelFloat] = {titleselfgcolor, selfloatbgcolor, selfloatbgcolor,
                            c000000},
#endif // BAR_FLEXWINTITLE_PATCH
};

#if BAR_POWERLINE_STATUS_PATCH
static char *statuscolors[][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, c000000, c000000},
    [SchemeHidSel] = {hidselfgcolor, hidselbgcolor, c000000, c000000},
    [SchemeUrg] = {urgfgcolor, urgbgcolor, urgbordercolor, urgfloatcolor},
};
#endif // BAR_POWERLINE_STATUS_PATCH

#if BAR_LAYOUTMENU_PATCH
static const char *layoutmenu_cmd = "layoutmenu.sh";
#endif

#if BAR_LAUNCHER_PATCH
static const Launcher launchers[] = {
    /* icon to display      command        */
    {"surf", CMD("surf", "duckduckgo.com")},
};
#endif // BAR_LAUNCHER_PATCH

#if COOL_AUTOSTART_PATCH
static const char *const autostart[] = {
    "st", NULL, NULL /* terminate */
};
#endif // COOL_AUTOSTART_PATCH

#if RENAMED_SCRATCHPADS_PATCH
static const char *scratchpadcmd[] = {"s", "st", "-n", "spterm", NULL};
#elif SCRATCHPADS_PATCH
const char *spcmd1[] = {"st", "-n", "spterm", "-g", "120x34", NULL};
static Sp scratchpads[] = {
    /* name          cmd  */
    {"spterm", spcmd1},
};
#endif // SCRATCHPADS_PATCH

/* 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.
 */
#if NAMETAG_PATCH
static char tagicons[][NUMTAGS][MAX_TAGLEN] =
#else
static char *tagicons[][NUMTAGS] =
#endif // NAMETAG_PATCH
    {
        [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>"},
    };

#if BAR_TAGGRID_PATCH
/* grid of tags */
#define SWITCHTAG_UP 1 << 0
#define SWITCHTAG_DOWN 1 << 1
#define SWITCHTAG_LEFT 1 << 2
#define SWITCHTAG_RIGHT 1 << 3
#define SWITCHTAG_TOGGLETAG 1 << 4
#define SWITCHTAG_TAG 1 << 5
#define SWITCHTAG_VIEW 1 << 6
#define SWITCHTAG_TOGGLEVIEW 1 << 7

static const int tagrows = 2;
#endif // BAR_TAGGRID_PATCH

/* 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)
#if RENAMED_SCRATCHPADS_PATCH
                            RULE(.instance = "spterm", .scratchkey = 's',
                                 .isfloating = 1)
#elif SCRATCHPADS_PATCH
                            RULE(.instance = "spterm", .tags = SPTAG(0),
                                 .isfloating = 1)
#endif // SCRATCHPADS_PATCH
};

#if MONITOR_RULES_PATCH
#if PERTAG_PATCH
static const MonitorRule monrules[] = {
    /* monitor  tag   layout  mfact  nmaster  showbar  topbar */
    {1, -1, 2, -1, -1, -1, -1}, // use a different layout for the second monitor
    {-1, -1, 0, -1, -1, -1, -1}, // default
};
#else
static const MonitorRule monrules[] = {
    /* monitor  layout  mfact  nmaster  showbar  topbar */
    {1, 2, -1, -1, -1, -1},  // use a different layout for the second monitor
    {-1, 0, -1, -1, -1, -1}, // default
};
#endif // PERTAG_PATCH
#endif // MONITOR_RULES_PATCH

#if INSETS_PATCH
static const Inset default_inset = {
    .x = 0,
    .y = 30,
    .w = 0,
    .h = 0,
};
#endif // INSETS_PATCH

/* 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                hoverfunc                name */
#if BAR_STATUSBUTTON_PATCH
    {-1, 0, BAR_ALIGN_LEFT, width_stbutton, draw_stbutton, click_stbutton, NULL,
     "statusbutton"},
#endif // BAR_STATUSBUTTON_PATCH
#if BAR_LAUNCHER_PATCH
    {-1, 0, BAR_ALIGN_LEFT, width_launcher, draw_launcher, click_launcher, NULL,
     "launcher"},
#endif // BAR_LAUNCHER_PATCH
#if BAR_POWERLINE_TAGS_PATCH
    {0, 0, BAR_ALIGN_LEFT, width_pwrl_tags, draw_pwrl_tags, click_pwrl_tags,
     hover_pwrl_tags, "powerline_tags"},
#endif // BAR_POWERLINE_TAGS_PATCH
#if BAR_TAGS_PATCH
    {-1, 0, BAR_ALIGN_LEFT, width_tags, draw_tags, click_tags, hover_tags,
     "tags"},
#endif // BAR_TAGS_PATCH
#if BAR_TAGLABELS_PATCH
    {-1, 0, BAR_ALIGN_LEFT, width_taglabels, draw_taglabels, click_taglabels,
     hover_taglabels, "taglabels"},
#endif // BAR_TAGLABELS_PATCH
#if BAR_TAGGRID_PATCH
    {-1, 0, BAR_ALIGN_LEFT, width_taggrid, draw_taggrid, click_taggrid, NULL,
     "taggrid"},
#endif // BAR_TAGGRID_PATCH
#if BAR_SYSTRAY_PATCH
    {0, 0, BAR_ALIGN_RIGHT, width_systray, draw_systray, click_systray, NULL,
     "systray"},
#endif // BAR_SYSTRAY_PATCH
#if BAR_LTSYMBOL_PATCH
    {-1, 0, BAR_ALIGN_LEFT, width_ltsymbol, draw_ltsymbol, click_ltsymbol, NULL,
     "layout"},
#endif // BAR_LTSYMBOL_PATCH
#if BAR_STATUSCOLORS_PATCH && BAR_STATUSCMD_PATCH
    {statusmon, 0, BAR_ALIGN_RIGHT, width_statuscolors, draw_statuscolors,
     click_statuscmd, NULL, "statuscolors"},
#elif BAR_STATUSCOLORS_PATCH
    {statusmon, 0, BAR_ALIGN_RIGHT, width_statuscolors, draw_statuscolors,
     click_statuscolors, NULL, "statuscolors"},
#elif BAR_STATUS2D_PATCH && BAR_STATUSCMD_PATCH
    {statusmon, 0, BAR_ALIGN_RIGHT, width_status2d, draw_status2d,
     click_statuscmd, NULL, "status2d"},
#elif BAR_STATUS2D_PATCH
    {statusmon, 0, BAR_ALIGN_RIGHT, width_status2d, draw_status2d,
     click_status2d, NULL, "status2d"},
#elif BAR_POWERLINE_STATUS_PATCH
    {statusmon, 0, BAR_ALIGN_RIGHT, width_pwrl_status, draw_pwrl_status,
     click_pwrl_status, NULL, "powerline_status"},
#elif BAR_STATUS_PATCH && BAR_STATUSCMD_PATCH
    {statusmon, 0, BAR_ALIGN_RIGHT, width_status, draw_status, click_statuscmd,
     NULL, "status"},
#elif BAR_STATUS_PATCH
    {statusmon, 0, BAR_ALIGN_RIGHT, width_status, draw_status, click_status,
     NULL, "status"},
#endif // BAR_STATUS2D_PATCH | BAR_STATUSCMD_PATCH
#if XKB_PATCH
    {0, 0, BAR_ALIGN_RIGHT, width_xkb, draw_xkb, click_xkb, NULL, "xkb"},
#endif // XKB_PATCH
#if BAR_FLEXWINTITLE_PATCH
    {-1, 0, BAR_ALIGN_NONE, width_flexwintitle, draw_flexwintitle,
     click_flexwintitle, NULL, "flexwintitle"},
#elif BAR_TABGROUPS_PATCH
    {-1, 0, BAR_ALIGN_NONE, width_bartabgroups, draw_bartabgroups,
     click_bartabgroups, NULL, "bartabgroups"},
#elif BAR_AWESOMEBAR_PATCH
    {-1, 0, BAR_ALIGN_NONE, width_awesomebar, draw_awesomebar, click_awesomebar,
     NULL, "awesomebar"},
#elif BAR_FANCYBAR_PATCH
    {-1, 0, BAR_ALIGN_NONE, width_fancybar, draw_fancybar, click_fancybar, NULL,
     "fancybar"},
#elif BAR_WINTITLE_PATCH
    {-1, 0, BAR_ALIGN_NONE, width_wintitle, draw_wintitle, click_wintitle, NULL,
     "wintitle"},
#endif // BAR_TABGROUPS_PATCH | BAR_AWESOMEBAR_PATCH | BAR_FANCYBAR_PATCH |
       // BAR_WINTITLE_PATCH
#if BAR_EXTRASTATUS_PATCH
#if BAR_STATUSCOLORS_PATCH && BAR_STATUSCMD_PATCH
    {statusmon, 1, BAR_ALIGN_CENTER, width_statuscolors_es,
     draw_statuscolors_es, click_statuscmd_es, NULL, "statuscolors_es"},
#elif BAR_STATUSCOLORS_PATCH
    {statusmon, 1, BAR_ALIGN_CENTER, width_statuscolors_es,
     draw_statuscolors_es, click_statuscolors, NULL, "statuscolors_es"},
#elif BAR_STATUS2D_PATCH && BAR_STATUSCMD_PATCH
    {statusmon, 1, BAR_ALIGN_CENTER, width_status2d_es, draw_status2d_es,
     click_statuscmd_es, NULL, "status2d_es"},
#elif BAR_STATUS2D_PATCH
    {statusmon, 1, BAR_ALIGN_CENTER, width_status2d_es, draw_status2d_es,
     click_status2d, NULL, "status2d_es"},
#elif BAR_POWERLINE_STATUS_PATCH
    {statusmon, 1, BAR_ALIGN_RIGHT, width_pwrl_status_es, draw_pwrl_status_es,
     click_pwrl_status, NULL, "powerline_status"},
#elif BAR_STATUSCMD_PATCH && BAR_STATUS_PATCH
    {statusmon, 1, BAR_ALIGN_CENTER, width_status_es, draw_status_es,
     click_statuscmd_es, NULL, "status_es"},
#elif BAR_STATUS_PATCH
    {statusmon, 1, BAR_ALIGN_CENTER, width_status_es, draw_status_es,
     click_status, NULL, "status_es"},
#endif // BAR_STATUS2D_PATCH | BAR_STATUSCMD_PATCH
#endif // BAR_EXTRASTATUS_PATCH
#if BAR_FLEXWINTITLE_PATCH
#if BAR_WINTITLE_HIDDEN_PATCH
    {-1, 1, BAR_ALIGN_RIGHT_RIGHT, width_wintitle_hidden, draw_wintitle_hidden,
     click_wintitle_hidden, NULL, "wintitle_hidden"},
#endif
#if BAR_WINTITLE_FLOATING_PATCH
    {-1, 1, BAR_ALIGN_LEFT, width_wintitle_floating, draw_wintitle_floating,
     click_wintitle_floating, NULL, "wintitle_floating"},
#endif // BAR_WINTITLE_FLOATING_PATCH
#endif // BAR_FLEXWINTITLE_PATCH
};

/* layout(s) */
static const float mfact = 0.55; /* factor of master area size [0.05..0.95] */
static const int nmaster = 1;    /* number of clients in master area */
#if FLEXTILE_DELUXE_LAYOUT
static const int nstack = 0; /* number of clients in primary stack area */
#endif                       // FLEXTILE_DELUXE_LAYOUT
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 int refreshrate =
    120; /* refresh rate (per second) for client move/resize */
#if PLACEMOUSE_PATCH
static const int refreshrate_placemouse =
    60; /* refresh rate (per second) for placemouse */
#endif  // PLACEMOUSE_PATCH
#if DRAGMFACT_PATCH
static const int refreshrate_dragmfact =
    40; /* refresh rate (per second) for dragmfact */
#endif  // DRAGMFACT_PATCH
#if DRAGCFACT_PATCH
static const int refreshrate_dragcfact =
    60; /* refresh rate (per second) for dragcfact */
#endif  // DRAGCFACT_PATCH
#if DECORATION_HINTS_PATCH
static const int decorhints = 1; /* 1 means respect decoration hints */
#endif                           // DECORATION_HINTS_PATCH

#if NROWGRID_LAYOUT
#define FORCE_VSPLIT 1
#endif

#if TAPRESIZE_PATCH
/* mouse scroll resize */
static const int scrollsensetivity =
    30; /* 1 means resize window by 1 pixel for each scroll event */
/* resizemousescroll direction argument list */
static const int scrollargs[][2] = {
    /* width change         height change */
    {+scrollsensetivity, 0},
    {-scrollsensetivity, 0},
    {0, +scrollsensetivity},
    {0, -scrollsensetivity},
};
#endif // TAPRESIZE_PATCH

#if FLEXTILE_DELUXE_LAYOUT
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
    {">M>",
     flextile,
     {-1, -1, FLOATING_MASTER, LEFT_TO_RIGHT, LEFT_TO_RIGHT, 0,
      NULL}}, // floating master
    {"[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
#if TILE_LAYOUT
    {"[]=", tile, {0}},
#endif
#if MONOCLE_LAYOUT
    {"[M]", monocle, {0}},
#endif
#if BSTACK_LAYOUT
    {"TTT", bstack, {0}},
#endif
#if BSTACKHORIZ_LAYOUT
    {"===", bstackhoriz, {0}},
#endif
#if CENTEREDMASTER_LAYOUT
    {"|M|", centeredmaster, {0}},
#endif
#if CENTEREDFLOATINGMASTER_LAYOUT
    {">M>", centeredfloatingmaster, {0}},
#endif
#if COLUMNS_LAYOUT
    {"|||", col, {0}},
#endif
#if DECK_LAYOUT
    {"[D]", deck, {0}},
#endif
#if FIBONACCI_SPIRAL_LAYOUT
    {"(@)", spiral, {0}},
#endif
#if FIBONACCI_DWINDLE_LAYOUT
    {"[\\]", dwindle, {0}},
#endif
#if GRIDMODE_LAYOUT
    {"HHH", grid, {0}},
#endif
#if HORIZGRID_LAYOUT
    {"---", horizgrid, {0}},
#endif
#if GAPPLESSGRID_LAYOUT
    {":::", gaplessgrid, {0}},
#endif
#if NROWGRID_LAYOUT
    {"###", nrowgrid, {0}},
#endif
};
#else
static const Layout layouts[] = {
/* symbol     arrange function */
#if TILE_LAYOUT
    {"[]=", tile}, /* first entry is default */
#endif
    {"><>", NULL}, /* no layout function means floating behavior */
#if MONOCLE_LAYOUT
    {"[M]", monocle},
#endif
#if BSTACK_LAYOUT
    {"TTT", bstack},
#endif
#if BSTACKHORIZ_LAYOUT
    {"===", bstackhoriz},
#endif
#if CENTEREDMASTER_LAYOUT
    {"|M|", centeredmaster},
#endif
#if CENTEREDFLOATINGMASTER_LAYOUT
    {">M>", centeredfloatingmaster},
#endif
#if COLUMNS_LAYOUT
    {"|||", col},
#endif
#if DECK_LAYOUT
    {"[D]", deck},
#endif
#if FIBONACCI_SPIRAL_LAYOUT
    {"(@)", spiral},
#endif
#if FIBONACCI_DWINDLE_LAYOUT
    {"[\\]", dwindle},
#endif
#if GRIDMODE_LAYOUT
    {"HHH", grid},
#endif
#if HORIZGRID_LAYOUT
    {"---", horizgrid},
#endif
#if GAPPLESSGRID_LAYOUT
    {":::", gaplessgrid},
#endif
#if NROWGRID_LAYOUT
    {"###", nrowgrid},
#endif
};
#endif // FLEXTILE_DELUXE_LAYOUT

#if XKB_PATCH
/* xkb frontend */
static const char *xkb_layouts[] = {
    "en",
    "ru",
};
#endif // XKB_PATCH

/* key definitions */
#define MODKEY Mod4Mask
#if COMBO_PATCH && SWAPTAGS_PATCH && TAGOTHERMONITOR_PATCH
#define TAGKEYS(KEY, TAG)                                                      \
  {MODKEY, KEY, comboview, {.ui = 1 << TAG}},                                  \
      {MODKEY | ControlMask, KEY, toggleview, {.ui = 1 << TAG}},               \
      {MODKEY | ShiftMask, KEY, combotag, {.ui = 1 << TAG}},                   \
      {MODKEY | ControlMask | ShiftMask, KEY, toggletag, {.ui = 1 << TAG}},    \
      {MODKEY | Mod4Mask | ShiftMask, KEY, swaptags, {.ui = 1 << TAG}},        \
      {MODKEY | Mod4Mask, KEY, tagnextmon, {.ui = 1 << TAG}},                  \
      {MODKEY | Mod4Mask | ControlMask, KEY, tagprevmon, {.ui = 1 << TAG}},
#elif COMBO_PATCH && SWAPTAGS_PATCH
#define TAGKEYS(KEY, TAG)                                                      \
  {MODKEY, KEY, comboview, {.ui = 1 << TAG}},                                  \
      {MODKEY | ControlMask, KEY, toggleview, {.ui = 1 << TAG}},               \
      {MODKEY | ShiftMask, KEY, combotag, {.ui = 1 << TAG}},                   \
      {MODKEY | ControlMask | ShiftMask, KEY, toggletag, {.ui = 1 << TAG}},    \
      {MODKEY | Mod4Mask | ShiftMask, KEY, swaptags, {.ui = 1 << TAG}},
#elif COMBO_PATCH && TAGOTHERMONITOR_PATCH
#define TAGKEYS(KEY, TAG)                                                      \
  {MODKEY, KEY, comboview, {.ui = 1 << TAG}},                                  \
      {MODKEY | ControlMask, KEY, toggleview, {.ui = 1 << TAG}},               \
      {MODKEY | ShiftMask, KEY, combotag, {.ui = 1 << TAG}},                   \
      {MODKEY | ControlMask | ShiftMask, KEY, toggletag, {.ui = 1 << TAG}},    \
      {MODKEY | Mod4Mask, KEY, tagnextmon, {.ui = 1 << TAG}},                  \
      {MODKEY | Mod4Mask | ControlMask, KEY, tagprevmon, {.ui = 1 << TAG}},
#elif COMBO_PATCH
#define TAGKEYS(KEY, TAG)                                                      \
  {MODKEY, KEY, comboview, {.ui = 1 << TAG}},                                  \
      {MODKEY | ControlMask, KEY, toggleview, {.ui = 1 << TAG}},               \
      {MODKEY | ShiftMask, KEY, combotag, {.ui = 1 << TAG}},                   \
      {MODKEY | ControlMask | ShiftMask, KEY, toggletag, {.ui = 1 << TAG}},
#elif SWAPTAGS_PATCH && TAGOTHERMONITOR_PATCH
#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}},    \
      {MODKEY | Mod4Mask | ShiftMask, KEY, swaptags, {.ui = 1 << TAG}},        \
      {MODKEY | Mod4Mask, KEY, tagnextmon, {.ui = 1 << TAG}},                  \
      {MODKEY | Mod4Mask | ControlMask, KEY, tagprevmon, {.ui = 1 << TAG}},
#elif SWAPTAGS_PATCH
#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}},    \
      {MODKEY | Mod4Mask | ShiftMask, KEY, swaptags, {.ui = 1 << TAG}},
#elif TAGOTHERMONITOR_PATCH
#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}},    \
      {MODKEY | Mod4Mask, KEY, tagnextmon, {.ui = 1 << TAG}},                  \
      {MODKEY | Mod4Mask | ControlMask, KEY, tagprevmon, {.ui = 1 << TAG}},
#else
#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}},
#endif // COMBO_PATCH / SWAPTAGS_PATCH / TAGOTHERMONITOR_PATCH

#if STACKER_PATCH
#define STACKKEYS(MOD, ACTION)                                                 \
  {MOD, XK_j, ACTION##stack, {.i = INC(+1)}},                                  \
      {MOD, XK_k, ACTION##stack, {.i = INC(-1)}},                              \
      {MOD, XK_s, ACTION##stack, {.i = PREVSEL}},                              \
      {MOD, XK_w, ACTION##stack, {.i = 0}},                                    \
      {MOD, XK_e, ACTION##stack, {.i = 1}},                                    \
      {MOD, XK_a, ACTION##stack, {.i = 2}},                                    \
      {MOD, XK_z, ACTION##stack, {.i = -1}},
#endif // STACKER_PATCH

#if BAR_HOLDBAR_PATCH
#define HOLDKEY 0 // replace 0 with the keysym to activate holdbar
#endif            // BAR_HOLDBAR_PATCH

/* commands */
#if !NODMENU_PATCH
static char dmenumon[2] =
    "0"; /* component of dmenucmd, manipulated in spawn() */
#endif   // NODMENU_PATCH
static const char *dmenucmd[] = {"dmenu_run",
#if !NODMENU_PATCH
                                 "-m",
                                 dmenumon,
#endif // NODMENU_PATCH
                                 "-fn",
                                 dmenufont,
                                 "-nb",
                                 normbgcolor,
                                 "-nf",
                                 normfgcolor,
                                 "-sb",
                                 selbgcolor,
                                 "-sf",
                                 selfgcolor,
#if BAR_DMENUMATCHTOP_PATCH
                                 topbar ? NULL : "-b",
#endif // BAR_DMENUMATCHTOP_PATCH
                                 NULL};
static const char *termcmd[] = {"xterm", NULL};

#if BAR_STATUSCMD_PATCH
#if BAR_DWMBLOCKS_PATCH
/* This defines the name of the executable that handles the bar (used for
 * signalling purposes) */
#define STATUSBAR "dwmblocks"
#else
/* commands spawned when clicking statusbar, the mouse button pressed is
 * exported as BUTTON */
static const StatusCmd statuscmds[] = {
    {"notify-send Volume$BUTTON", 1},
    {"notify-send CPU$BUTTON", 2},
    {"notify-send Battery$BUTTON", 3},
};
/* test the above with: xsetroot -name "$(printf '\x01Volume |\x02 CPU |\x03
 * Battery')" */
static const char *statuscmd[] = {"/bin/sh", "-c", NULL, NULL};
#endif // BAR_DWMBLOCKS_PATCH
#endif // BAR_STATUSCMD_PATCH

#if ON_EMPTY_KEYS_PATCH
static const char *firefoxcmd[] = {"firefox", NULL};
static const Key on_empty_keys[] = {
    /* modifier key            function                argument */
    {0, XK_f, spawn, {.v = firefoxcmd}},
};
#endif // ON_EMPTY_KEYS_PATCH

#if XRESOURCES_PATCH
/*
 * Xresources preferences to load at startup.
 *
 *     Name                      Type       Address
 *    ------------------------------------------------
 *     "nmaster"                 INTEGER    &nmaster
 *     "mfact"                   FLOAT      &mfact
 *     "color1"                  STRING     &color1
 *
 * In the Xresources file setting resources shoud be prefixed with "dwm.", e.g.
 *
 *    dwm.nmaster: 1
 *    dwm.mfact: 0.50
 *    dwm.color1: #FA6EFA
 *
 * Note that the const qualifier must be removed from the variables if you plan
 * on overriding them with values from Xresources. While resources can be
 * reloaded using the xrdb function some changes may only take effect following
 * a restart.
 */
ResourcePref resources[] = {
    /* Resource name            Type       Address                */
    {"normfgcolor", STRING, &normfgcolor},
    {"normbgcolor", STRING, &normbgcolor},
    {"normbordercolor", STRING, &normbordercolor},
    {"normfloatcolor", STRING, &normfloatcolor},
    {"selfgcolor", STRING, &selfgcolor},
    {"selbgcolor", STRING, &selbgcolor},
    {"selbordercolor", STRING, &selbordercolor},
    {"selfloatcolor", STRING, &selfloatcolor},
    {"titlenormfgcolor", STRING, &titlenormfgcolor},
    {"titlenormbgcolor", STRING, &titlenormbgcolor},
    {"titlenormbordercolor", STRING, &titlenormbordercolor},
    {"titlenormfloatcolor", STRING, &titlenormfloatcolor},
    {"titleselfgcolor", STRING, &titleselfgcolor},
    {"titleselbgcolor", STRING, &titleselbgcolor},
    {"titleselbordercolor", STRING, &titleselbordercolor},
    {"titleselfloatcolor", STRING, &titleselfloatcolor},
    {"tagsnormfgcolor", STRING, &tagsnormfgcolor},
    {"tagsnormbgcolor", STRING, &tagsnormbgcolor},
    {"tagsnormbordercolor", STRING, &tagsnormbordercolor},
    {"tagsnormfloatcolor", STRING, &tagsnormfloatcolor},
    {"tagsselfgcolor", STRING, &tagsselfgcolor},
    {"tagsselbgcolor", STRING, &tagsselbgcolor},
    {"tagsselbordercolor", STRING, &tagsselbordercolor},
    {"tagsselfloatcolor", STRING, &tagsselfloatcolor},
    {"hidnormfgcolor", STRING, &hidnormfgcolor},
    {"hidnormbgcolor", STRING, &hidnormbgcolor},
    {"hidselfgcolor", STRING, &hidselfgcolor},
    {"hidselbgcolor", STRING, &hidselbgcolor},
    {"urgfgcolor", STRING, &urgfgcolor},
    {"urgbgcolor", STRING, &urgbgcolor},
    {"urgbordercolor", STRING, &urgbordercolor},
    {"urgfloatcolor", STRING, &urgfloatcolor},
#if RENAMED_SCRATCHPADS_PATCH
    {"scratchselfgcolor", STRING, &scratchselfgcolor},
    {"scratchselbgcolor", STRING, &scratchselbgcolor},
    {"scratchselbordercolor", STRING, &scratchselbordercolor},
    {"scratchselfloatcolor", STRING, &scratchselfloatcolor},
    {"scratchnormfgcolor", STRING, &scratchnormfgcolor},
    {"scratchnormbgcolor", STRING, &scratchnormbgcolor},
    {"scratchnormbordercolor", STRING, &scratchnormbordercolor},
    {"scratchnormfloatcolor", STRING, &scratchnormfloatcolor},
#endif // RENAMED_SCRATCHPADS_PATCH
#if BAR_FLEXWINTITLE_PATCH
    {"normTTBbgcolor", STRING, &normTTBbgcolor},
    {"normLTRbgcolor", STRING, &normLTRbgcolor},
    {"normMONObgcolor", STRING, &normMONObgcolor},
    {"normGRIDbgcolor", STRING, &normGRIDbgcolor},
    {"normGRD1bgcolor", STRING, &normGRD1bgcolor},
    {"normGRD2bgcolor", STRING, &normGRD2bgcolor},
    {"normGRDMbgcolor", STRING, &normGRDMbgcolor},
    {"normHGRDbgcolor", STRING, &normHGRDbgcolor},
    {"normDWDLbgcolor", STRING, &normDWDLbgcolor},
    {"normSPRLbgcolor", STRING, &normSPRLbgcolor},
    {"normfloatbgcolor", STRING, &normfloatbgcolor},
    {"actTTBbgcolor", STRING, &actTTBbgcolor},
    {"actLTRbgcolor", STRING, &actLTRbgcolor},
    {"actMONObgcolor", STRING, &actMONObgcolor},
    {"actGRIDbgcolor", STRING, &actGRIDbgcolor},
    {"actGRD1bgcolor", STRING, &actGRD1bgcolor},
    {"actGRD2bgcolor", STRING, &actGRD2bgcolor},
    {"actGRDMbgcolor", STRING, &actGRDMbgcolor},
    {"actHGRDbgcolor", STRING, &actHGRDbgcolor},
    {"actDWDLbgcolor", STRING, &actDWDLbgcolor},
    {"actSPRLbgcolor", STRING, &actSPRLbgcolor},
    {"actfloatbgcolor", STRING, &actfloatbgcolor},
    {"selTTBbgcolor", STRING, &selTTBbgcolor},
    {"selLTRbgcolor", STRING, &selLTRbgcolor},
    {"selMONObgcolor", STRING, &selMONObgcolor},
    {"selGRIDbgcolor", STRING, &selGRIDbgcolor},
    {"selGRD1bgcolor", STRING, &selGRD1bgcolor},
    {"selGRD2bgcolor", STRING, &selGRD2bgcolor},
    {"selGRDMbgcolor", STRING, &selGRDMbgcolor},
    {"selHGRDbgcolor", STRING, &selHGRDbgcolor},
    {"selDWDLbgcolor", STRING, &selDWDLbgcolor},
    {"selSPRLbgcolor", STRING, &selSPRLbgcolor},
    {"selfloatbgcolor", STRING, &selfloatbgcolor},
#endif // BAR_FLEXWINTITLE_PATCH
#if BAR_LTSYMBOL_SCHEME_PATCH
    {"ltsymbolfgcolor", STRING, &ltsymbolfgcolor},
    {"ltsymbolbgcolor", STRING, &ltsymbolbgcolor},
#endif // BAR_LTSYMBOL_SCHEME_PATCH
};
#endif // XRESOURCES_PATCH

static const Key keys[] = {
/* modifier                     key            function                argument
 */
#if KEYMODES_PATCH
    {MODKEY, XK_Escape, setkeymode, {.ui = COMMANDMODE}},
#endif // KEYMODES_PATCH
    {MODKEY, XK_r, spawn, {.v = dmenucmd}},
    {MODKEY, XK_Return, spawn, {.v = termcmd}},
#if RIODRAW_PATCH
    {MODKEY | ControlMask, XK_p, riospawnsync, {.v = dmenucmd}},
    {MODKEY | ControlMask, XK_Return, riospawn, {.v = termcmd}},
    {MODKEY, XK_s, rioresize, {0}},
#endif // RIODRAW_PATCH
    {MODKEY, XK_b, togglebar, {0}},
#if TOGGLETOPBAR_PATCH
    {MODKEY | ShiftMask, XK_b, toggletopbar, {0}},
#endif // TOGGLETOPBAR_PATCH
#if TAB_PATCH
    {MODKEY | ControlMask, XK_b, tabmode, {-1}},
#endif // TAB_PATCH
#if FOCUSMASTER_PATCH || FOCUSMASTER_RETURN_PATCH
    {MODKEY | ControlMask, XK_space, focusmaster, {0}},
#endif // FOCUSMASTER_PATCH / FOCUSMASTER_RETURN_PATCH
#if STACKER_PATCH
    STACKKEYS(MODKEY, focus) STACKKEYS(MODKEY | ShiftMask, push)
#else
    {MODKEY, XK_j, focusstack, {.i = +1}},
    {MODKEY, XK_k, focusstack, {.i = -1}},
#endif // STACKER_PATCH
#if FOCUSDIR_PATCH
        {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
#endif                                         // FOCUSDIR_PATCH
#if PLACEDIR_PATCH
    {MODKEY | ControlMask, XK_Left, placedir, {.i = 0}},  // left
    {MODKEY | ControlMask, XK_Right, placedir, {.i = 1}}, // right
    {MODKEY | ControlMask, XK_Up, placedir, {.i = 2}},    // up
    {MODKEY | ControlMask, XK_Down, placedir, {.i = 3}},  // down
#endif                                                    // PLACEDIR_PATCH
#if SWAPFOCUS_PATCH && PERTAG_PATCH
    {MODKEY, XK_s, swapfocus, {.i = -1}},
#endif // SWAPFOCUS_PATCH
#if SWITCHCOL_PATCH
    {MODKEY, XK_v, switchcol, {0}},
#endif // SWITCHCOL_PATCH
#if ROTATESTACK_PATCH
    {MODKEY | Mod4Mask, XK_j, rotatestack, {.i = +1}},
    {MODKEY | Mod4Mask, XK_k, rotatestack, {.i = -1}},
#endif // ROTATESTACK_PATCH
#if INPLACEROTATE_PATCH
    {MODKEY | Mod4Mask, XK_j, inplacerotate, {.i = +2}}, // same as rotatestack
    {MODKEY | Mod4Mask, XK_k, inplacerotate, {.i = -2}}, // same as reotatestack
    {MODKEY | Mod4Mask | ShiftMask, XK_j, inplacerotate, {.i = +1}},
    {MODKEY | Mod4Mask | ShiftMask, XK_k, inplacerotate, {.i = -1}},
#endif // INPLACEROTATE_PATCH
#if PUSH_PATCH || PUSH_NO_MASTER_PATCH
    {MODKEY | ControlMask, XK_j, pushdown, {0}},
    {MODKEY | ControlMask, XK_k, pushup, {0}},
#endif // PUSH_PATCH / PUSH_NO_MASTER_PATCH
    {MODKEY, XK_i, incnmaster, {.i = +1}},
    {MODKEY, XK_d, incnmaster, {.i = -1}},
#if FLEXTILE_DELUXE_LAYOUT
    {MODKEY | ControlMask, XK_i, incnstack, {.i = +1}},
    {MODKEY | ControlMask, XK_u, incnstack, {.i = -1}},
#endif // FLEXTILE_DELUXE_LAYOUT
    {MODKEY, XK_h, setmfact, {.f = -0.05}},
    {MODKEY, XK_l, setmfact, {.f = +0.05}},
#if CFACTS_PATCH
    {MODKEY | ShiftMask, XK_h, setcfact, {.f = +0.25}},
    {MODKEY | ShiftMask, XK_l, setcfact, {.f = -0.25}},
    {MODKEY | ShiftMask, XK_o, setcfact, {0}},
#endif // CFACTS_PATCH
#if ASPECTRESIZE_PATCH
    {MODKEY | ControlMask | ShiftMask, XK_e, aspectresize, {.i = +24}},
    {MODKEY | ControlMask | ShiftMask, XK_r, aspectresize, {.i = -24}},
#endif // ASPECTRESIZE_PATCH
#if MOVERESIZE_PATCH
    {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"}},
#endif // MOVERESIZE_PATCH
#if MOVESTACK_PATCH
    {MODKEY | ShiftMask, XK_j, movestack, {.i = +1}},
    {MODKEY | ShiftMask, XK_k, movestack, {.i = -1}},
#endif // MOVESTACK_PATCH
#if TRANSFER_PATCH
    {MODKEY, XK_x, transfer, {0}},
#endif // TRANSFER_PATCH
#if TRANSFER_ALL_PATCH
    {MODKEY | ControlMask, XK_x, transferall, {0}},
#endif // TRANSFER_ALL_PATCH
#if REORGANIZETAGS_PATCH
    {MODKEY | ControlMask, XK_r, reorganizetags, {0}},
#endif // REORGANIZETAGS_PATCH
#if DISTRIBUTETAGS_PATCH
    {MODKEY | ControlMask, XK_d, distributetags, {0}},
#endif // DISTRIBUTETAGS_PATCH
#if INSETS_PATCH
    {MODKEY | ShiftMask | ControlMask,
     XK_a,
     updateinset,
     {.v = &default_inset}},
#endif // INSETS_PATCH
    {MODKEY | ShiftMask, XK_Return, zoom, {0}},
#if VANITYGAPS_PATCH
    {MODKEY | Mod4Mask, XK_u, incrgaps, {.i = +1}},
    {MODKEY | Mod4Mask | ShiftMask, XK_u, incrgaps, {.i = -1}},
    {MODKEY | Mod4Mask, XK_i, incrigaps, {.i = +1}},
    {MODKEY | Mod4Mask | ShiftMask, XK_i, incrigaps, {.i = -1}},
    {MODKEY | Mod4Mask, XK_o, incrogaps, {.i = +1}},
    {MODKEY | Mod4Mask | ShiftMask, XK_o, incrogaps, {.i = -1}},
    {MODKEY | Mod4Mask, XK_6, incrihgaps, {.i = +1}},
    {MODKEY | Mod4Mask | ShiftMask, XK_6, incrihgaps, {.i = -1}},
    {MODKEY | Mod4Mask, XK_7, incrivgaps, {.i = +1}},
    {MODKEY | Mod4Mask | ShiftMask, XK_7, incrivgaps, {.i = -1}},
    {MODKEY | Mod4Mask, XK_8, incrohgaps, {.i = +1}},
    {MODKEY | Mod4Mask | ShiftMask, XK_8, incrohgaps, {.i = -1}},
    {MODKEY | Mod4Mask, XK_9, incrovgaps, {.i = +1}},
    {MODKEY | Mod4Mask | ShiftMask, XK_9, incrovgaps, {.i = -1}},
    {MODKEY | Mod4Mask, XK_0, togglegaps, {0}},
    {MODKEY | Mod4Mask | ShiftMask, XK_0, defaultgaps, {0}},
#endif // VANITYGAPS_PATCH
#if ALT_TAB_PATCH
    {Mod1Mask, XK_Tab, alttabstart, {0}},
#else
    {MODKEY, XK_Tab, view, {0}},
#endif // ALT_TAB_PATCH
#if SHIFTTAG_PATCH
    {MODKEY | ShiftMask,
     XK_Left,
     shifttag,
     {.i = -1}}, // note keybinding conflict with focusadjacenttag tagtoleft
    {MODKEY | ShiftMask,
     XK_Right,
     shifttag,
     {.i = +1}}, // note keybinding conflict with focusadjacenttag tagtoright
#endif           // SHIFTTAG_PATCH
#if SHIFTTAGCLIENTS_PATCH
    {MODKEY | ShiftMask | ControlMask, XK_Left, shifttagclients, {.i = -1}},
    {MODKEY | ShiftMask | ControlMask, XK_Right, shifttagclients, {.i = +1}},
#endif // SHIFTTAGCLIENTS_PATCH
#if SHIFTVIEW_PATCH
    {MODKEY | ShiftMask, XK_Tab, shiftview, {.i = -1}},
    {MODKEY | ShiftMask, XK_backslash, shiftview, {.i = +1}},
#endif // SHIFTVIEW_PATCH
#if SHIFTVIEW_CLIENTS_PATCH
    {MODKEY | Mod4Mask, XK_Tab, shiftviewclients, {.i = -1}},
    {MODKEY | Mod4Mask, XK_backslash, shiftviewclients, {.i = +1}},
#endif // SHIFTVIEW_CLIENTS_PATCH
#if SHIFTBOTH_PATCH
    {MODKEY | ControlMask,
     XK_Left,
     shiftboth,
     {.i = -1}}, // note keybinding conflict with focusadjacenttag
                 // tagandviewtoleft placedir
    {MODKEY | ControlMask,
     XK_Right,
     shiftboth,
     {.i = +1}}, // note keybinding conflict with focusadjacenttag
                 // tagandviewtoright placedir
#endif           // SHIFTBOTH_PATCH
#if SHIFTSWAPTAGS_PATCH && SWAPTAGS_PATCH
    {MODKEY | Mod4Mask | ShiftMask, XK_Left, shiftswaptags, {.i = -1}},
    {MODKEY | Mod4Mask | ShiftMask, XK_Right, shiftswaptags, {.i = +1}},
#endif // SHIFTSWAPTAGS_PATCH
#if BAR_WINTITLEACTIONS_PATCH
    {MODKEY | ControlMask, XK_z, showhideclient, {0}},
    {MODKEY | ControlMask, XK_s, unhideall, {0}},
#endif // BAR_WINTITLEACTIONS_PATCH
    {MODKEY, XK_s, killclient, {0}},
#if KILLUNSEL_PATCH
    {MODKEY | ShiftMask, XK_x, killunsel, {0}},
#endif // KILLUNSEL_PATCH
#if SELFRESTART_PATCH
    {MODKEY | ShiftMask, XK_r, self_restart, {0}},
#endif // SELFRESTART_PATCH
    {MODKEY | ShiftMask, XK_q, quit, {0}},
#if RESTARTSIG_PATCH
    {MODKEY | ControlMask | ShiftMask, XK_q, quit, {1}},
#endif // RESTARTSIG_PATCH
#if FOCUSURGENT_PATCH
    {MODKEY, XK_u, focusurgent, {0}},
#endif // FOCUSURGENT_PATCH
#if BAR_HOLDBAR_PATCH
    {0, HOLDKEY, holdbar, {0}},
#endif // BAR_HOLDBAR_PATCH
#if WINVIEW_PATCH
    {MODKEY, XK_o, winview, {0}},
#endif // WINVIEW_PATCH
#if XRDB_PATCH || XRESOURCES_PATCH
    {MODKEY | ShiftMask, XK_F5, xrdb, {.v = NULL}},
#endif // XRDB_PATCH | XRESOURCES_PATCH
    {MODKEY, XK_t, setlayout, {.v = &layouts[0]}},
    {MODKEY, XK_f, setlayout, {.v = &layouts[1]}},
    {MODKEY, XK_m, setlayout, {.v = &layouts[2]}},
#if COLUMNS_LAYOUT
    {MODKEY, XK_c, setlayout, {.v = &layouts[3]}},
#endif // COLUMNS_LAYOUT
#if FLEXTILE_DELUXE_LAYOUT
    {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 */
#endif     // FLEXTILE_DELUXE_LAYOUT
    {MODKEY, XK_space, setlayout, {0}},
    {MODKEY | ShiftMask, XK_space, togglefloating, {0}},
#if ALWAYSONTOP_PATCH
    {MODKEY | ShiftMask, XK_space, togglealwaysontop, {0}},
#endif // ALWAYSONTOP_PATCH
#if MAXIMIZE_PATCH
    {MODKEY | ControlMask | ShiftMask, XK_h, togglehorizontalmax, {0}},
    {MODKEY | ControlMask | ShiftMask, XK_l, togglehorizontalmax, {0}},
    {MODKEY | ControlMask | ShiftMask, XK_j, toggleverticalmax, {0}},
    {MODKEY | ControlMask | ShiftMask, XK_k, toggleverticalmax, {0}},
    {MODKEY | ControlMask, XK_m, togglemax, {0}},
#endif // MAXIMIZE_PATCH
#if NO_MOD_BUTTONS_PATCH
    {MODKEY | ShiftMask, XK_Escape, togglenomodbuttons, {0}},
#endif // NO_MOD_BUTTONS_PATCH
#if RENAMED_SCRATCHPADS_PATCH
    {MODKEY, XK_grave, togglescratch, {.v = scratchpadcmd}},
    {MODKEY | ControlMask, XK_grave, setscratch, {.v = scratchpadcmd}},
    {MODKEY | ShiftMask, XK_grave, removescratch, {.v = scratchpadcmd}},
#elif SCRATCHPADS_PATCH
    {MODKEY, XK_grave, togglescratch, {.ui = 0}},
    {MODKEY | ControlMask, XK_grave, setscratch, {.ui = 0}},
    {MODKEY | ShiftMask, XK_grave, removescratch, {.ui = 0}},
#endif // SCRATCHPADS_PATCH | RENAMED_SCRATCHPADS_PATCH
#if UNFLOATVISIBLE_PATCH
    {MODKEY | Mod4Mask, XK_space, unfloatvisible, {0}},
    {MODKEY | ShiftMask, XK_t, unfloatvisible, {.v = &layouts[0]}},
#endif // UNFLOATVISIBLE_PATCH
#if TOGGLEFULLSCREEN_PATCH
    {MODKEY, XK_y, togglefullscreen, {0}},
#endif // TOGGLEFULLSCREEN_PATCH
#if !FAKEFULLSCREEN_PATCH && FAKEFULLSCREEN_CLIENT_PATCH
    {MODKEY | ShiftMask, XK_y, togglefakefullscreen, {0}},
#endif // FAKEFULLSCREEN_CLIENT_PATCH
#if FULLSCREEN_PATCH
    {MODKEY | ShiftMask, XK_f, fullscreen, {0}},
#endif // FULLSCREEN_PATCH
#if STICKY_PATCH
    {MODKEY | ShiftMask, XK_s, togglesticky, {0}},
#endif // STICKY_PATCH
#if SCRATCHPAD_ALT_1_PATCH
    {MODKEY, XK_minus, scratchpad_show, {0}},
    {MODKEY | ShiftMask, XK_minus, scratchpad_hide, {0}},
    {MODKEY, XK_equal, scratchpad_remove, {0}},
#elif SCRATCHPADS_PATCH && !RENAMED_SCRATCHPADS_PATCH
    {MODKEY, XK_0, view, {.ui = ~SPTAGMASK}},
    {MODKEY | ShiftMask, XK_0, tag, {.ui = ~SPTAGMASK}},
#else
    {MODKEY, XK_0, view, {.ui = ~0}},
    {MODKEY | ShiftMask, XK_0, tag, {.ui = ~0}},
#endif // SCRATCHPAD_ALT_1_PATCH
    {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}},
#if FOCUSADJACENTTAG_PATCH
    {MODKEY,
     XK_Left,
     viewtoleft,
     {0}}, // note keybinding conflict with focusdir
    {MODKEY,
     XK_Right,
     viewtoright,
     {0}}, // note keybinding conflict with focusdir
    {MODKEY | ShiftMask,
     XK_Left,
     tagtoleft,
     {0}}, // note keybinding conflict with shifttag
    {MODKEY | ShiftMask,
     XK_Right,
     tagtoright,
     {0}}, // note keybinding conflict with shifttag
    {MODKEY | ControlMask,
     XK_Left,
     tagandviewtoleft,
     {0}}, // note keybinding conflict with placedir
    {MODKEY | ControlMask,
     XK_Right,
     tagandviewtoright,
     {0}}, // note keybinding conflict with placedir
#endif     // FOCUSADJACENTTAG_PATCH
#if TAGALL_PATCH
    {MODKEY | ShiftMask, XK_F1, tagall, {.v = "F1"}},
    {MODKEY | ShiftMask, XK_F2, tagall, {.v = "F2"}},
    {MODKEY | ShiftMask, XK_F3, tagall, {.v = "F3"}},
    {MODKEY | ShiftMask, XK_F4, tagall, {.v = "F4"}},
    {MODKEY | ShiftMask, XK_F5, tagall, {.v = "F5"}},
    {MODKEY | ShiftMask, XK_F6, tagall, {.v = "F6"}},
    {MODKEY | ShiftMask, XK_F7, tagall, {.v = "F7"}},
    {MODKEY | ShiftMask, XK_F8, tagall, {.v = "F8"}},
    {MODKEY | ShiftMask, XK_F9, tagall, {.v = "F9"}},
    {MODKEY | ControlMask, XK_F1, tagall, {.v = "1"}},
    {MODKEY | ControlMask, XK_F2, tagall, {.v = "2"}},
    {MODKEY | ControlMask, XK_F3, tagall, {.v = "3"}},
    {MODKEY | ControlMask, XK_F4, tagall, {.v = "4"}},
    {MODKEY | ControlMask, XK_F5, tagall, {.v = "5"}},
    {MODKEY | ControlMask, XK_F6, tagall, {.v = "6"}},
    {MODKEY | ControlMask, XK_F7, tagall, {.v = "7"}},
    {MODKEY | ControlMask, XK_F8, tagall, {.v = "8"}},
    {MODKEY | ControlMask, XK_F9, tagall, {.v = "9"}},
#endif // TAGALL_PATCH
#if TAGALLMON_PATCH
    {MODKEY | Mod4Mask | ShiftMask, XK_comma, tagallmon, {.i = +1}},
    {MODKEY | Mod4Mask | ShiftMask, XK_period, tagallmon, {.i = -1}},
#endif // TAGALLMON_PATCH
#if TAGSWAPMON_PATCH
    {MODKEY | Mod4Mask | ControlMask, XK_comma, tagswapmon, {.i = +1}},
    {MODKEY | Mod4Mask | ControlMask, XK_period, tagswapmon, {.i = -1}},
#endif // TAGSWAPMON_PATCH
#if BAR_ALTERNATIVE_TAGS_PATCH
    {MODKEY, XK_n, togglealttag, {0}},
#endif // BAR_ALTERNATIVE_TAGS_PATCH
#if NAMETAG_PATCH
    {MODKEY | ShiftMask, XK_n, nametag, {0}},
#endif // NAMETAG_PATCH
#if BAR_TAGGRID_PATCH
    {MODKEY | ControlMask,
     XK_Up,
     switchtag,
     {.ui = SWITCHTAG_UP | SWITCHTAG_VIEW}},
    {MODKEY | ControlMask,
     XK_Down,
     switchtag,
     {.ui = SWITCHTAG_DOWN | SWITCHTAG_VIEW}},
    {MODKEY | ControlMask,
     XK_Right,
     switchtag,
     {.ui = SWITCHTAG_RIGHT |
            SWITCHTAG_VIEW}}, // note keybinding conflict with placedir
    {MODKEY | ControlMask,
     XK_Left,
     switchtag,
     {.ui = SWITCHTAG_LEFT |
            SWITCHTAG_VIEW}}, // note keybinding conflict with placedir
    {MODKEY | Mod4Mask,
     XK_Up,
     switchtag,
     {.ui = SWITCHTAG_UP | SWITCHTAG_TAG | SWITCHTAG_VIEW}},
    {MODKEY | Mod4Mask,
     XK_Down,
     switchtag,
     {.ui = SWITCHTAG_DOWN | SWITCHTAG_TAG | SWITCHTAG_VIEW}},
    {MODKEY | Mod4Mask,
     XK_Right,
     switchtag,
     {.ui = SWITCHTAG_RIGHT | SWITCHTAG_TAG | SWITCHTAG_VIEW}},
    {MODKEY | Mod4Mask,
     XK_Left,
     switchtag,
     {.ui = SWITCHTAG_LEFT | SWITCHTAG_TAG | SWITCHTAG_VIEW}},
#endif // BAR_TAGGRID_PATCH
#if MOVECENTER_PATCH
    {MODKEY, XK_x, movecenter, {0}}, // note keybinding conflict with killunsel
#endif                               // MOVECENTER_PATCH
#if MOVEPLACE_PATCH
    {MODKEY, XK_KP_7, moveplace, {.ui = WIN_NW}}, /* XK_KP_Home,  */
    {MODKEY, XK_KP_8, moveplace, {.ui = WIN_N}},  /* XK_KP_Up,    */
    {MODKEY, XK_KP_9, moveplace, {.ui = WIN_NE}}, /* XK_KP_Prior, */
    {MODKEY, XK_KP_4, moveplace, {.ui = WIN_W}},  /* XK_KP_Left,  */
    {MODKEY, XK_KP_5, moveplace, {.ui = WIN_C}},  /* XK_KP_Begin, */
    {MODKEY, XK_KP_6, moveplace, {.ui = WIN_E}},  /* XK_KP_Right, */
    {MODKEY, XK_KP_1, moveplace, {.ui = WIN_SW}}, /* XK_KP_End,   */
    {MODKEY, XK_KP_2, moveplace, {.ui = WIN_S}},  /* XK_KP_Down,  */
    {MODKEY, XK_KP_3, moveplace, {.ui = WIN_SE}}, /* XK_KP_Next,  */
#endif                                            // MOVEPLACE_PATCH
#if EXRESIZE_PATCH
    {MODKEY, XK_KP_7, explace, {.ui = EX_NW}}, /* XK_KP_Home,  */
    {MODKEY, XK_KP_8, explace, {.ui = EX_N}},  /* XK_KP_Up,    */
    {MODKEY, XK_KP_9, explace, {.ui = EX_NE}}, /* XK_KP_Prior, */
    {MODKEY, XK_KP_4, explace, {.ui = EX_W}},  /* XK_KP_Left,  */
    {MODKEY, XK_KP_5, explace, {.ui = EX_C}},  /* XK_KP_Begin, */
    {MODKEY, XK_KP_6, explace, {.ui = EX_E}},  /* XK_KP_Right, */
    {MODKEY, XK_KP_1, explace, {.ui = EX_SW}}, /* XK_KP_End,   */
    {MODKEY, XK_KP_2, explace, {.ui = EX_S}},  /* XK_KP_Down,  */
    {MODKEY, XK_KP_3, explace, {.ui = EX_SE}}, /* XK_KP_Next,  */

    {MODKEY | ShiftMask,
     XK_KP_8,
     exresize,
     {.v = (int[]){0, 25}}}, /* XK_KP_Up,    */
    {MODKEY | ShiftMask,
     XK_KP_2,
     exresize,
     {.v = (int[]){0, -25}}}, /* XK_KP_Down,  */
    {MODKEY | ShiftMask,
     XK_KP_6,
     exresize,
     {.v = (int[]){25, 0}}}, /* XK_KP_Right, */
    {MODKEY | ShiftMask,
     XK_KP_4,
     exresize,
     {.v = (int[]){-25, 0}}}, /* XK_KP_Left,  */
    {MODKEY | ShiftMask,
     XK_KP_5,
     exresize,
     {.v = (int[]){25, 25}}}, /* XK_KP_Begin, */
    {MODKEY | ShiftMask | ControlMask,
     XK_KP_5,
     exresize,
     {.v = (int[]){-25, -25}}}, /* XK_KP_Begin, */

    {MODKEY | ControlMask,
     XK_KP_6,
     togglehorizontalexpand,
     {.i = +1}}, /* XK_KP_Right, */
    {MODKEY | ControlMask,
     XK_KP_3,
     togglehorizontalexpand,
     {.i = 0}}, /* XK_KP_Next,  */
    {MODKEY | ControlMask,
     XK_KP_4,
     togglehorizontalexpand,
     {.i = -1}}, /* XK_KP_Left,  */
    {MODKEY | ControlMask,
     XK_KP_8,
     toggleverticalexpand,
     {.i = +1}}, /* XK_KP_Up,    */
    {MODKEY | ControlMask,
     XK_KP_1,
     toggleverticalexpand,
     {.i = 0}}, /* XK_KP_End,   */
    {MODKEY | ControlMask,
     XK_KP_2,
     toggleverticalexpand,
     {.i = -1}}, /* XK_KP_Down,  */
    {MODKEY | ControlMask,
     XK_KP_9,
     togglemaximize,
     {.i = -1}}, /* XK_KP_Prior, */
    {MODKEY | ControlMask,
     XK_KP_7,
     togglemaximize,
     {.i = +1}}, /* XK_KP_Home,  */
    {MODKEY | ControlMask,
     XK_KP_5,
     togglemaximize,
     {.i = 0}}, /* XK_KP_Begin, */
#endif          // EXRESIZE_PATCH
#if FLOATPOS_PATCH
    /* Note that due to key limitations the below example kybindings are defined
     * with a Mod3Mask, which is not always readily available. Refer to the
     * patch wiki for more details. */
    /* Client position is limited to monitor window area */
    {Mod3Mask, XK_u, floatpos, {.v = "-26x -26y"}},      // ↖
    {Mod3Mask, XK_i, floatpos, {.v = "  0x -26y"}},      // ↑
    {Mod3Mask, XK_o, floatpos, {.v = " 26x -26y"}},      // ↗
    {Mod3Mask, XK_j, floatpos, {.v = "-26x   0y"}},      // ←
    {Mod3Mask, XK_l, floatpos, {.v = " 26x   0y"}},      // →
    {Mod3Mask, XK_m, floatpos, {.v = "-26x  26y"}},      // ↙
    {Mod3Mask, XK_comma, floatpos, {.v = "  0x  26y"}},  // ↓
    {Mod3Mask, XK_period, floatpos, {.v = " 26x  26y"}}, // ↘
    /* Absolute positioning (allows moving windows between monitors) */
    {Mod3Mask | ControlMask, XK_u, floatpos, {.v = "-26a -26a"}},      // ↖
    {Mod3Mask | ControlMask, XK_i, floatpos, {.v = "  0a -26a"}},      // ↑
    {Mod3Mask | ControlMask, XK_o, floatpos, {.v = " 26a -26a"}},      // ↗
    {Mod3Mask | ControlMask, XK_j, floatpos, {.v = "-26a   0a"}},      // ←
    {Mod3Mask | ControlMask, XK_l, floatpos, {.v = " 26a   0a"}},      // →
    {Mod3Mask | ControlMask, XK_m, floatpos, {.v = "-26a  26a"}},      // ↙
    {Mod3Mask | ControlMask, XK_comma, floatpos, {.v = "  0a  26a"}},  // ↓
    {Mod3Mask | ControlMask, XK_period, floatpos, {.v = " 26a  26a"}}, // ↘
    /* Resize client, client center position is fixed which means that client
       expands in all directions */
    {Mod3Mask | ShiftMask, XK_u, floatpos, {.v = "-26w -26h"}},      // ↖
    {Mod3Mask | ShiftMask, XK_i, floatpos, {.v = "  0w -26h"}},      // ↑
    {Mod3Mask | ShiftMask, XK_o, floatpos, {.v = " 26w -26h"}},      // ↗
    {Mod3Mask | ShiftMask, XK_j, floatpos, {.v = "-26w   0h"}},      // ←
    {Mod3Mask | ShiftMask, XK_k, floatpos, {.v = "800W 800H"}},      // ·
    {Mod3Mask | ShiftMask, XK_l, floatpos, {.v = " 26w   0h"}},      // →
    {Mod3Mask | ShiftMask, XK_m, floatpos, {.v = "-26w  26h"}},      // ↙
    {Mod3Mask | ShiftMask, XK_comma, floatpos, {.v = "  0w  26h"}},  // ↓
    {Mod3Mask | ShiftMask, XK_period, floatpos, {.v = " 26w  26h"}}, // ↘
    /* Client is positioned in a floating grid, movement is relative to client's
       current position */
    {Mod3Mask | Mod1Mask, XK_u, floatpos, {.v = "-1p -1p"}},      // ↖
    {Mod3Mask | Mod1Mask, XK_i, floatpos, {.v = " 0p -1p"}},      // ↑
    {Mod3Mask | Mod1Mask, XK_o, floatpos, {.v = " 1p -1p"}},      // ↗
    {Mod3Mask | Mod1Mask, XK_j, floatpos, {.v = "-1p  0p"}},      // ←
    {Mod3Mask | Mod1Mask, XK_k, floatpos, {.v = " 0p  0p"}},      // ·
    {Mod3Mask | Mod1Mask, XK_l, floatpos, {.v = " 1p  0p"}},      // →
    {Mod3Mask | Mod1Mask, XK_m, floatpos, {.v = "-1p  1p"}},      // ↙
    {Mod3Mask | Mod1Mask, XK_comma, floatpos, {.v = " 0p  1p"}},  // ↓
    {Mod3Mask | Mod1Mask, XK_period, floatpos, {.v = " 1p  1p"}}, // ↘
#endif // FLOATPOS_PATCH
#if SETBORDERPX_PATCH
    {MODKEY | ControlMask, XK_minus, setborderpx, {.i = -1}},
    {MODKEY | ControlMask, XK_plus, setborderpx, {.i = +1}},
    {MODKEY | ControlMask, XK_numbersign, setborderpx, {.i = 0}},
#endif // SETBORDERPX_PATCH
#if CYCLELAYOUTS_PATCH
    {MODKEY | ControlMask, XK_comma, cyclelayout, {.i = -1}},
    {MODKEY | ControlMask, XK_period, cyclelayout, {.i = +1}},
#endif // CYCLELAYOUTS_PATCH
#if MPDCONTROL_PATCH
    {MODKEY, XK_F1, mpdchange, {.i = -1}},
    {MODKEY, XK_F2, mpdchange, {.i = +1}},
    {MODKEY, XK_Escape, mpdcontrol, {0}},
#endif // MPDCONTROL_PATCH
    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)};

#if KEYMODES_PATCH
static const Key cmdkeys[] = {
    /* modifier                    keys                     function argument */
    {0, XK_Escape, clearcmd, {0}},
    {ControlMask, XK_c, clearcmd, {0}},
    {0, XK_i, setkeymode, {.ui = INSERTMODE}},
};

static const Command commands[] = {
    /* modifier (4 keys)                          keysyms (4 keys) function
       argument */
    {{ControlMask, ShiftMask, 0, 0},
     {XK_w, XK_h, 0, 0},
     setlayout,
     {.v = &layouts[0]}},
    {{ControlMask, 0, 0, 0}, {XK_w, XK_o, 0, 0}, setlayout, {.v = &layouts[2]}},
    {{ControlMask, ShiftMask, 0, 0}, {XK_w, XK_o, 0, 0}, onlyclient, {0}},
    {{ControlMask, 0, 0, 0}, {XK_w, XK_v, 0, 0}, setlayout, {.v = &layouts[0]}},
    {{ControlMask, 0, 0, 0}, {XK_w, XK_less, 0, 0}, setmfact, {.f = -0.05}},
    {{ControlMask, ShiftMask, 0, 0},
     {XK_w, XK_less, 0, 0},
     setmfact,
     {.f = +0.05}},
    {{ControlMask, ShiftMask, 0, 0},
     {XK_w, XK_0, 0, 0},
     setmfact,
     {.f = +1.50}},
    {{ShiftMask, 0, 0, 0}, {XK_period, XK_e, 0, 0}, spawn, {.v = dmenucmd}},
    {{ShiftMask, 0, 0, 0}, {XK_period, XK_o, 0, 0}, spawn, {.v = dmenucmd}},
    {{ShiftMask, 0, 0, 0}, {XK_period, XK_q, XK_Return, 0}, quit, {0}},
    {{ShiftMask, 0, 0, 0}, {XK_period, XK_b, XK_d, XK_Return}, killclient, {0}},
    {{ShiftMask, 0, 0, 0},
     {XK_period, XK_b, XK_n, XK_Return},
     focusstack,
     {.i = +1}},
    {{ShiftMask, 0, ShiftMask, 0},
     {XK_period, XK_b, XK_n, XK_Return},
     focusstack,
     {.i = -1}},
};
#endif // KEYMODES_PATCH

/* button definitions */
#if STATUSBUTTON_PATCH
/* click can be ClkButton, ClkTagBar, ClkLtSymbol, ClkStatusText, ClkWinTitle,
 * ClkClientWin, or ClkRootWin */
#else
/* click can be ClkTagBar, ClkLtSymbol, ClkStatusText, ClkWinTitle,
 * ClkClientWin, or ClkRootWin */
#endif //
static const Button buttons[] = {
/* click                event mask           button          function argument
 */
#if BAR_STATUSBUTTON_PATCH
    {ClkButton, 0, Button1, spawn, {.v = dmenucmd}},
#endif // BAR_STATUSBUTTON_PATCH
    {ClkLtSymbol, 0, Button1, setlayout, {0}},
#if BAR_LAYOUTMENU_PATCH
    {ClkLtSymbol, 0, Button3, layoutmenu, {0}},
#else
    {ClkLtSymbol, 0, Button3, setlayout, {.v = &layouts[2]}},
#endif // BAR_LAYOUTMENU_PATCH
#if BAR_WINTITLEACTIONS_PATCH
    {ClkWinTitle, 0, Button1, togglewin, {0}},
    {ClkWinTitle, 0, Button3, showhideclient, {0}},
#endif // BAR_WINTITLEACTIONS_PATCH
    {ClkWinTitle, 0, Button2, zoom, {0}},
#if BAR_STATUSCMD_PATCH && BAR_DWMBLOCKS_PATCH
    {ClkStatusText, 0, Button1, sigstatusbar, {.i = 1}},
    {ClkStatusText, 0, Button2, sigstatusbar, {.i = 2}},
    {ClkStatusText, 0, Button3, sigstatusbar, {.i = 3}},
#elif BAR_STATUSCMD_PATCH
    {ClkStatusText, 0, Button1, spawn, {.v = statuscmd}},
    {ClkStatusText, 0, Button2, spawn, {.v = statuscmd}},
    {ClkStatusText, 0, Button3, spawn, {.v = statuscmd}},
#else
    {ClkStatusText, 0, Button2, spawn, {.v = termcmd}},
#endif // BAR_STATUSCMD_PATCH
#if PLACEMOUSE_PATCH
    /* placemouse options, choose which feels more natural:
     *    0 - tiled position is relative to mouse cursor
     *    1 - tiled postiion is relative to window center
     *    2 - mouse pointer warps to window center
     *
     * The moveorplace uses movemouse or placemouse depending on the floating
     * state of the selected client. Set up individual keybindings for the two
     * if you want to control these separately (i.e. to retain the feature to
     * move a tiled window into a floating position).
     */
    {ClkClientWin, MODKEY, Button1, moveorplace, {.i = 1}},
#else
    {ClkClientWin, MODKEY, Button1, movemouse, {0}},
#endif // PLACEMOUSE_PATCH
    {ClkClientWin, MODKEY, Button2, togglefloating, {0}},
    {ClkClientWin, MODKEY, Button3, resizemouse, {0}},
#if TAPRESIZE_PATCH
    {ClkClientWin, MODKEY, Button4, resizemousescroll, {.v = &scrollargs[0]}},
    {ClkClientWin, MODKEY, Button5, resizemousescroll, {.v = &scrollargs[1]}},
    {ClkClientWin, MODKEY, Button6, resizemousescroll, {.v = &scrollargs[2]}},
    {ClkClientWin, MODKEY, Button7, resizemousescroll, {.v = &scrollargs[3]}},
#endif // TAPRESIZE_PATCH
#if DRAGCFACT_PATCH && CFACTS_PATCH
    {ClkClientWin, MODKEY | ShiftMask, Button3, dragcfact, {0}},
#endif // DRAGCFACT_PATCH
#if DRAGMFACT_PATCH
    {ClkClientWin, MODKEY | ShiftMask, Button1, dragmfact, {0}},
#endif // DRAGMFACT_PATCH
    {ClkTagBar, 0, Button1, view, {0}},
    {ClkTagBar, 0, Button3, toggleview, {0}},
    {ClkTagBar, MODKEY, Button1, tag, {0}},
    {ClkTagBar, MODKEY, Button3, toggletag, {0}},
#if TAB_PATCH
    {ClkTabBar, 0, Button1, focuswin, {0}},
#endif // TAB_PATCH
};

#if DWMC_PATCH
/* signal definitions */
/* signum must be greater than 0 */
/* trigger signals using `xsetroot -name "fsignal:<signame> [<type> <value>]"`
 */
static const Signal signals[] = {
    /* signum                    function */
    {"focusstack", focusstack},
    {"setmfact", setmfact},
    {"togglebar", togglebar},
#if TOGGLETOPBAR_PATCH
    {"toggletopbar", toggletopbar},
#endif // TOGGLETOPBAR_PATCH
    {"incnmaster", incnmaster},
    {"togglefloating", togglefloating},
    {"focusmon", focusmon},
#if STACKER_PATCH
    {"pushstack", pushstack},
#endif // STACKER_PATCH
#if FLOATPOS_PATCH
    {"floatpos", floatpos},
#endif // FLOATPOS_PATCH
#if FOCUSURGENT_PATCH
    {"focusurgent", focusurgent},
#endif // FOCUSURGENT_PATCH
#if FOCUSADJACENTTAG_PATCH
    {"viewtoleft", viewtoleft},
    {"viewtoright", viewtoright},
    {"tagtoleft", tagtoleft},
    {"tagtoright", tagtoright},
    {"tagandviewtoleft", tagandviewtoleft},
    {"tagandviewtoright", tagandviewtoright},
#endif // FOCUSADJACENTTAG_PATCH
#if SWAPFOCUS_PATCH && PERTAG_PATCH
    {"swapfocus", swapfocus},
#endif // SWAPFOCUS_PATCH
#if SWITCHCOL_PATCH
    {"switchcol", switchcol},
#endif // SWITCHCOL_PATCH
#if ROTATESTACK_PATCH
    {"rotatestack", rotatestack},
#endif // ROTATESTACK_PATCH
#if INPLACEROTATE_PATCH
    {"inplacerotate", inplacerotate},
#endif // INPLACEROTATE_PATCH
#if PUSH_PATCH || PUSH_NO_MASTER_PATCH
    {"pushdown", pushdown},
    {"pushup", pushup},
#endif // PUSH_PATCH / PUSH_NO_MASTER_PATCH
#if FLEXTILE_DELUXE_LAYOUT
    {"incnstack", incnstack},
    {"rotatelayoutaxis", rotatelayoutaxis},
    {"setlayoutaxisex", setlayoutaxisex},
    {"mirrorlayout", mirrorlayout},
#endif // FLEXTILE_DELUXE_LAYOUT
#if CFACTS_PATCH
    {"setcfact", setcfact},
#endif // CFACTS_PATCH
#if MOVECENTER_PATCH
    {"movecenter", movecenter},
#endif // MOVECENTER_PATCH
#if MOVEPLACE_PATCH
    {"moveplace", moveplace},
#endif // MOVEPLACE_PATCH
#if NAMETAG_PATCH
    {"nametag", nametag},
#endif // NAMETAG_PATCH
#if EXRESIZE_PATCH
    {"explace", explace},
    {"togglehorizontalexpand", togglehorizontalexpand},
    {"toggleverticalexpand", toggleverticalexpand},
    {"togglemaximize", togglemaximize},
#endif // EXRESIZE_PATCH
#if KEYMODES_PATCH
    {"setkeymode", setkeymode},
#endif // KEYMODES_PATCH
#if TRANSFER_PATCH
    {"transfer", transfer},
#endif // TRANSFER_PATCH
#if TRANSFER_ALL_PATCH
    {"transferall", transferall},
#endif // TRANSFER_ALL_PATCH
    {"tagmon", tagmon},
    {"zoom", zoom},
#if VANITYGAPS_PATCH
    {"incrgaps", incrgaps},
    {"incrigaps", incrigaps},
    {"incrogaps", incrogaps},
    {"incrihgaps", incrihgaps},
    {"incrivgaps", incrivgaps},
    {"incrohgaps", incrohgaps},
    {"incrovgaps", incrovgaps},
    {"togglegaps", togglegaps},
    {"defaultgaps", defaultgaps},
    {"setgaps", setgapsex},
#endif // VANITYGAPS_PATCH
    {"view", view},
    {"viewall", viewallex},
    {"viewex", viewex},
    {"toggleview", toggleview},
#if BAR_WINTITLEACTIONS_PATCH
    {"showhideclient", showhideclient},
#endif // BAR_WINTITLEACTIONS_PATCH
#if SHIFTBOTH_PATCH
    {"shiftboth", shiftboth},
#endif // SHIFTBOTH_PATCH
#if SHIFTTAG_PATCH
    {"shifttag", shifttag},
#endif // SHIFTTAG_PATCH
#if SHIFTTAGCLIENTS_PATCH
    {"shifttagclients", shifttagclients},
#endif // SHIFTTAGCLIENTS_PATCH
#if SHIFTVIEW_PATCH
    {"shiftview", shiftview},
#endif // SHIFTVIEW_PATCH
#if SHIFTVIEW_CLIENTS_PATCH
    {"shiftviewclients", shiftviewclients},
#endif // SHIFTVIEW_CLIENTS_PATCH
#if SHIFTSWAPTAGS_PATCH && SWAPTAGS_PATCH
    {"shiftswaptags", shiftswaptags},
#endif // SHIFTSWAPTAGS_PATCH
#if SELFRESTART_PATCH
    {"self_restart", self_restart},
#endif // SELFRESTART_PATCH
#if BAR_TAGGRID_PATCH
    {"switchtag", switchtag},
#endif // BAR_TAGGRID_PATCH
#if STICKY_PATCH
    {"togglesticky", togglesticky},
#endif // STICKY_PATCH
#if SETBORDERPX_PATCH
    {"setborderpx", setborderpx},
#endif // SETBORDERPX_PATCH
#if CYCLELAYOUTS_PATCH
    {"cyclelayout", cyclelayout},
#endif // CYCLELAYOUTS_PATCH
#if MPDCONTROL_PATCH
    {"mpdchange", mpdchange},
    {"mpdcontrol", mpdcontrol},
#endif // MPDCONTROL_PATCH
    {"toggleviewex", toggleviewex},
    {"tag", tag},
    {"tagall", tagallex},
    {"tagex", tagex},
    {"toggletag", toggletag},
    {"toggletagex", toggletagex},
#if TAGALLMON_PATCH
    {"tagallmon", tagallmon},
#endif // TAGALLMON_PATCH
#if TAGSWAPMON_PATCH
    {"tagswapmon", tagswapmon},
#endif // TAGSWAPMON_PATCH
#if BAR_ALTERNATIVE_TAGS_PATCH
    {"togglealttag", togglealttag},
#endif // BAR_ALTERNATIVE_TAGS_PATCH
#if TOGGLEFULLSCREEN_PATCH
    {"togglefullscreen", togglefullscreen},
#endif // TOGGLEFULLSCREEN_PATCH
#if !FAKEFULLSCREEN_PATCH && FAKEFULLSCREEN_CLIENT_PATCH
    {"togglefakefullscreen", togglefakefullscreen},
#endif // FAKEFULLSCREEN_CLIENT_PATCH
#if FULLSCREEN_PATCH
    {"fullscreen", fullscreen},
#endif // FULLSCREEN_PATCH
#if MAXIMIZE_PATCH
    {"togglehorizontalmax", togglehorizontalmax},
    {"toggleverticalmax", toggleverticalmax},
    {"togglemax", togglemax},
#endif // MAXIMIZE_PATCH
#if SCRATCHPADS_PATCH && !RENAMED_SCRATCHPADS_PATCH
    {"togglescratch", togglescratch},
#endif // SCRATCHPADS_PATCH
#if UNFLOATVISIBLE_PATCH
    {"unfloatvisible", unfloatvisible},
#endif // UNFLOATVISIBLE_PATCH
    {"killclient", killclient},
#if WINVIEW_PATCH
    {"winview", winview},
#endif // WINVIEW_PATCH
#if XRDB_PATCH || XRESOURCES_PATCH
    {"xrdb", xrdb},
#endif // XRDB_PATCH | XRESOURCES_PATCH
#if TAGOTHERMONITOR_PATCH
    {"tagnextmonex", tagnextmonex},
    {"tagprevmonex", tagprevmonex},
#endif // TAGOTHERMONITOR_PATCH
    {"quit", quit},
    {"setlayout", setlayout},
    {"setlayoutex", setlayoutex},
};
#elif FSIGNAL_PATCH
/* signal definitions */
/* signum must be greater than 0 */
/* trigger signals using `xsetroot -name "fsignal:<signum>"` */
static Signal signals[] = {
    /* signum       function        argument  */
    {1, setlayout, {.v = 0}},
};
#endif // DWMC_PATCH

#if IPC_PATCH
static const char *ipcsockpath = "/tmp/dwm.sock";
static IPCCommand ipccommands[] = {
    IPCCOMMAND(focusmon, 1, {ARG_TYPE_SINT}),
    IPCCOMMAND(focusstack, 1, {ARG_TYPE_SINT}),
    IPCCOMMAND(incnmaster, 1, {ARG_TYPE_SINT}),
    IPCCOMMAND(killclient, 1, {ARG_TYPE_SINT}),
    IPCCOMMAND(quit, 1, {ARG_TYPE_NONE}),
    IPCCOMMAND(setlayoutsafe, 1, {ARG_TYPE_PTR}),
    IPCCOMMAND(setmfact, 1, {ARG_TYPE_FLOAT}),
    IPCCOMMAND(setstatus, 1, {ARG_TYPE_STR}),
    IPCCOMMAND(tag, 1, {ARG_TYPE_UINT}),
    IPCCOMMAND(tagmon, 1, {ARG_TYPE_UINT}),
    IPCCOMMAND(togglebar, 1, {ARG_TYPE_NONE}),
#if TOGGLETOPBAR_PATCH
    IPCCOMMAND(toggletopbar, 1, {ARG_TYPE_NONE}),
#endif // TOGGLETOPBAR_PATCH
    IPCCOMMAND(togglefloating, 1, {ARG_TYPE_NONE}),
    IPCCOMMAND(toggletag, 1, {ARG_TYPE_UINT}),
    IPCCOMMAND(toggleview, 1, {ARG_TYPE_UINT}),
    IPCCOMMAND(view, 1, {ARG_TYPE_UINT}),
    IPCCOMMAND(zoom, 1, {ARG_TYPE_NONE}),
#if BAR_ALTERNATIVE_TAGS_PATCH
    IPCCOMMAND(togglealttag, 1, {ARG_TYPE_NONE}),
#endif // BAR_ALTERNATIVE_TAGS_PATCH
#if BAR_TAGGRID_PATCH
    IPCCOMMAND(switchtag, 1, {ARG_TYPE_UINT}),
#endif // BAR_TAGGRID_PATCH
#if CFACTS_PATCH
    IPCCOMMAND(setcfact, 1, {ARG_TYPE_FLOAT}),
#endif // CFACTS_PATCH
#if CYCLELAYOUTS_PATCH
    IPCCOMMAND(cyclelayout, 1, {ARG_TYPE_SINT}),
#endif // CYCLELAYOUTS_PATCH
#if EXRESIZE_PATCH
    IPCCOMMAND(explace, 1, {ARG_TYPE_UINT}),
    IPCCOMMAND(togglehorizontalexpand, 1, {ARG_TYPE_SINT}),
    IPCCOMMAND(toggleverticalexpand, 1, {ARG_TYPE_SINT}),
    IPCCOMMAND(togglemaximize, 1, {ARG_TYPE_SINT}),
#endif // EXRESIZE_PATCH
#if !FAKEFULLSCREEN_PATCH && FAKEFULLSCREEN_CLIENT_PATCH
    IPCCOMMAND(togglefakefullscreen, 1, {ARG_TYPE_NONE}),
#endif // FAKEFULLSCREEN_CLIENT_PATCH
#if FLOATPOS_PATCH
    IPCCOMMAND(floatpos, 1, {ARG_TYPE_STR}),
#endif // FLOATPOS_PATCH
#if FULLSCREEN_PATCH
    IPCCOMMAND(fullscreen, 1, {ARG_TYPE_NONE}),
#endif // FULLSCREEN_PATCH
#if FLEXTILE_DELUXE_LAYOUT
    IPCCOMMAND(incnstack, 1, {ARG_TYPE_SINT}),
    IPCCOMMAND(rotatelayoutaxis, 1, {ARG_TYPE_SINT}),
    IPCCOMMAND(setlayoutaxisex, 1, {ARG_TYPE_SINT}),
    IPCCOMMAND(mirrorlayout, 1, {ARG_TYPE_NONE}),
#endif // FLEXTILE_DELUXE_LAYOUT
#if FOCUSURGENT_PATCH
    IPCCOMMAND(focusurgent, 1, {ARG_TYPE_NONE}),
#endif // FOCUSURGENT_PATCH
#if FOCUSADJACENTTAG_PATCH
    IPCCOMMAND(viewtoleft, 1, {ARG_TYPE_NONE}),
    IPCCOMMAND(viewtoright, 1, {ARG_TYPE_NONE}),
    IPCCOMMAND(tagtoleft, 1, {ARG_TYPE_NONE}),
    IPCCOMMAND(tagtoright, 1, {ARG_TYPE_NONE}),
    IPCCOMMAND(tagandviewtoleft, 1, {ARG_TYPE_NONE}),
    IPCCOMMAND(tagandviewtoright, 1, {ARG_TYPE_NONE}),
#endif // FOCUSADJACENTTAG_PATCH
#if INPLACEROTATE_PATCH
    IPCCOMMAND(inplacerotate, 1, {ARG_TYPE_SINT}),
#endif // INPLACEROTATE_PATCH
#if KEYMODES_PATCH
    IPCCOMMAND(setkeymode, 1, {ARG_TYPE_UINT}),
#endif // KEYMODES_PATCH
#if MAXIMIZE_PATCH
    IPCCOMMAND(togglehorizontalmax, 1, {ARG_TYPE_NONE}),
    IPCCOMMAND(toggleverticalmax, 1, {ARG_TYPE_NONE}),
    IPCCOMMAND(togglemax, 1, {ARG_TYPE_NONE}),
#endif // MAXIMIZE_PATCH
#if MPDCONTROL_PATCH
    IPCCOMMAND(mpdchange, 1, {ARG_TYPE_SINT}),
    IPCCOMMAND(mpdcontrol, 1, {ARG_TYPE_NONE}),
#endif // MPDCONTROL_PATCH
#if MOVECENTER_PATCH
    IPCCOMMAND(movecenter, 1, {ARG_TYPE_NONE}),
#endif // MOVECENTER_PATCH
#if MOVEPLACE_PATCH
    IPCCOMMAND(moveplace, 1, {ARG_TYPE_UINT}),
#endif // MOVEPLACE_PATCH
#if MOVERESIZE_PATCH
    IPCCOMMAND(moveresize, 1, {ARG_TYPE_STR}),
#endif // MOVERESIZE_PATCH
#if NAMETAG_PATCH
    IPCCOMMAND(nametag, 1, {ARG_TYPE_NONE}),
#endif // NAMETAG_PATCH
#if RIODRAW_PATCH
    IPCCOMMAND(rioresize, 1, {ARG_TYPE_NONE}),
#endif // RIODRAW_PATCH
#if PUSH_PATCH || PUSH_NO_MASTER_PATCH
    IPCCOMMAND(pushdown, 1, {ARG_TYPE_NONE}),
    IPCCOMMAND(pushup, 1, {ARG_TYPE_NONE}),
#endif // PUSH_PATCH / PUSH_NO_MASTER_PATCH
#if ROTATESTACK_PATCH
    IPCCOMMAND(rotatestack, 1, {ARG_TYPE_SINT}),
#endif // ROTATESTACK_PATCH
#if SCRATCHPADS_PATCH && !RENAMED_SCRATCHPADS_PATCH
    IPCCOMMAND(togglescratch, 1, {ARG_TYPE_UINT}),
#endif // SCRATCHPADS_PATCH
#if SELFRESTART_PATCH
    IPCCOMMAND(self_restart, 1, {ARG_TYPE_NONE}),
#endif // SELFRESTART_PATCH
#if SETBORDERPX_PATCH
    IPCCOMMAND(setborderpx, 1, {ARG_TYPE_SINT}),
#endif // SETBORDERPX_PATCH
#if BAR_WINTITLEACTIONS_PATCH
    IPCCOMMAND(showhideclient, 1, {ARG_TYPE_NONE}),
#endif // BAR_WINTITLEACTIONS_PATCH
#if SHIFTBOTH_PATCH
    IPCCOMMAND(shiftboth, 1, {ARG_TYPE_SINT}),
#endif // SHIFTBOTH_PATCH
#if SHIFTTAG_PATCH
    IPCCOMMAND(shifttag, 1, {ARG_TYPE_SINT}),
#endif // SHIFTTAG_PATCH
#if SHIFTTAGCLIENTS_PATCH
    IPCCOMMAND(shifttagclients, 1, {ARG_TYPE_SINT}),
#endif // SHIFTVIEWCLIENTS_PATCH
#if SHIFTVIEW_PATCH
    IPCCOMMAND(shiftview, 1, {ARG_TYPE_SINT}),
#endif // SHIFTVIEW_PATCH
#if SHIFTVIEW_CLIENTS_PATCH
    IPCCOMMAND(shiftviewclients, 1, {ARG_TYPE_SINT}),
#endif // SHIFTVIEW_CLIENTS_PATCH
#if SHIFTSWAPTAGS_PATCH && SWAPTAGS_PATCH
    IPCCOMMAND(shiftswaptags, 1, {ARG_TYPE_SINT}),
#endif // SHIFTSWAPTAGS_PATCH
#if STACKER_PATCH
    IPCCOMMAND(pushstack, 1, {ARG_TYPE_SINT}),
#endif // STACKER_PATCH
#if STICKY_PATCH
    IPCCOMMAND(togglesticky, 1, {ARG_TYPE_NONE}),
#endif // STICKY_PATCH
#if SWAPFOCUS_PATCH && PERTAG_PATCH
    IPCCOMMAND(swapfocus, 1, {ARG_TYPE_SINT}),
#endif // SWAPFOCUS_PATCH
#if SWITCHCOL_PATCH
    IPCCOMMAND(switchcol, 1, {ARG_TYPE_NONE}),
#endif // SWITCHCOL_PATCH
#if TAGALLMON_PATCH
    IPCCOMMAND(tagallmon, 1, {ARG_TYPE_SINT}),
#endif // TAGALLMON_PATCH
#if TAGOTHERMONITOR_PATCH
    IPCCOMMAND(tagnextmonex, 1, {ARG_TYPE_UINT}),
    IPCCOMMAND(tagprevmonex, 1, {ARG_TYPE_UINT}),
#endif // TAGOTHERMONITOR_PATCH
#if TAGSWAPMON_PATCH
    IPCCOMMAND(tagswapmon, 1, {ARG_TYPE_SINT}),
#endif // TAGSWAPMON_PATCH
#if TOGGLEFULLSCREEN_PATCH
    IPCCOMMAND(togglefullscreen, 1, {ARG_TYPE_NONE}),
#endif // TOGGLEFULLSCREEN_PATCH
#if TRANSFER_PATCH
    IPCCOMMAND(transfer, 1, {ARG_TYPE_NONE}),
#endif // TRANSFER_PATCH
#if TRANSFER_ALL_PATCH
    IPCCOMMAND(transferall, 1, {ARG_TYPE_NONE}),
#endif // TRANSFER_ALL_PATCH
#if UNFLOATVISIBLE_PATCH
    IPCCOMMAND(unfloatvisible, 1, {ARG_TYPE_NONE}),
#endif // UNFLOATVISIBLE_PATCH
#if VANITYGAPS_PATCH
    IPCCOMMAND(incrgaps, 1, {ARG_TYPE_SINT}),
    IPCCOMMAND(incrigaps, 1, {ARG_TYPE_SINT}),
    IPCCOMMAND(incrogaps, 1, {ARG_TYPE_SINT}),
    IPCCOMMAND(incrihgaps, 1, {ARG_TYPE_SINT}),
    IPCCOMMAND(incrivgaps, 1, {ARG_TYPE_SINT}),
    IPCCOMMAND(incrohgaps, 1, {ARG_TYPE_SINT}),
    IPCCOMMAND(incrovgaps, 1, {ARG_TYPE_SINT}),
    IPCCOMMAND(togglegaps, 1, {ARG_TYPE_NONE}),
    IPCCOMMAND(defaultgaps, 1, {ARG_TYPE_NONE}),
    IPCCOMMAND(setgapsex, 1, {ARG_TYPE_SINT}),
#endif // VANITYGAPS_PATCH
#if WINVIEW_PATCH
    IPCCOMMAND(winview, 1, {ARG_TYPE_NONE}),
#endif // WINVIEW_PATCH
#if XRDB_PATCH || XRESOURCES_PATCH
    IPCCOMMAND(xrdb, 1, {ARG_TYPE_NONE}),
#endif // XRDB_PATCH | XRESOURCES_PATCH
};
#endif // IPC_PATCH
