From c65d88947f40e36003e4dc5a15b8a8252da12d63 Mon Sep 17 00:00:00 2001 From: tavo Date: Mon, 6 Jan 2025 21:50:42 -0600 Subject: [PATCH] patch .h files --- dwm-flexipatched.diff | 3531 ++++++++++++++++++++++++++++++++++++++--- st-flexipatched.diff | 1392 ++++++++++++++-- 2 files changed, 4567 insertions(+), 356 deletions(-) diff --git a/dwm-flexipatched.diff b/dwm-flexipatched.diff index 3cf7afa..e16e2c2 100644 --- a/dwm-flexipatched.diff +++ b/dwm-flexipatched.diff @@ -1,35 +1,181 @@ -diff '--color=auto' -Nu a/config.def.h b/config.def.h ---- a/config.def.h 2024-12-28 22:09:50.009762644 -0600 -+++ b/config.def.h 2024-12-28 23:28:39.313251353 -0600 -@@ -17,7 +17,7 @@ - * 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 */ +diff '--color=auto' -Nu a/config.h b/config.h +--- a/config.h 1969-12-31 18:00:00.000000000 -0600 ++++ b/config.h 2025-01-04 22:40:55.612529968 -0600 +@@ -0,0 +1,1835 @@ ++/* 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 = 1; /* 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 = 1; /* snap pixel */ - #if SWALLOW_PATCH - static const int swallowfloating = 0; /* 1 means swallow floating windows by default */ - #endif // SWALLOW_PATCH -@@ -166,21 +166,21 @@ - #if BAR_PANGO_PATCH - static const char font[] = "monospace 10"; - #else --static const char *fonts[] = { "monospace:size=10" }; ++#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 = 10; /* horiz outer gap between windows and screen edge */ ++static const unsigned int gappov = 30; /* 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 = 1; /* 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[] = ""; ++#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 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:bold:size=10" }; - #endif // BAR_PANGO_PATCH - static const char dmenufont[] = "monospace:size=10"; - - static char c000000[] = "#000000"; // placeholder value - --static char normfgcolor[] = "#bbbbbb"; --static char normbgcolor[] = "#222222"; --static char normbordercolor[] = "#444444"; --static char normfloatcolor[] = "#db8fd9"; -- --static char selfgcolor[] = "#eeeeee"; --static char selbgcolor[] = "#005577"; --static char selbordercolor[] = "#005577"; --static char selfloatcolor[] = "#005577"; ++#endif // BAR_PANGO_PATCH ++static const char dmenufont[] = "monospace:size=10"; ++ ++static char c000000[] = "#000000"; // placeholder value ++ +static char normfgcolor[] = "#374145"; +static char normbgcolor[] = "#1e2326"; +static char normbordercolor[] = "#1e2326"; @@ -39,89 +185,735 @@ diff '--color=auto' -Nu a/config.def.h b/config.def.h +static char selbgcolor[] = "#1e2326"; +static char selbordercolor[] = "#7fbbb3"; +static char selfloatcolor[] = "#7fbbb3"; - - static char titlenormfgcolor[] = "#bbbbbb"; - static char titlenormbgcolor[] = "#222222"; -@@ -192,13 +192,13 @@ - static char titleselbordercolor[] = "#005577"; - static char titleselfloatcolor[] = "#005577"; - --static char tagsnormfgcolor[] = "#bbbbbb"; --static char tagsnormbgcolor[] = "#222222"; ++ ++static char titlenormfgcolor[] = "#bbbbbb"; ++static char titlenormbgcolor[] = "#222222"; ++static char titlenormbordercolor[] = "#444444"; ++static char titlenormfloatcolor[] = "#db8fd9"; ++ ++static char titleselfgcolor[] = "#eeeeee"; ++static char titleselbgcolor[] = "#005577"; ++static char titleselbordercolor[] = "#005577"; ++static char titleselfloatcolor[] = "#005577"; ++ +static char tagsnormfgcolor[] = "#374145"; +static char tagsnormbgcolor[] = "#1e2326"; - static char tagsnormbordercolor[] = "#444444"; - static char tagsnormfloatcolor[] = "#db8fd9"; - --static char tagsselfgcolor[] = "#eeeeee"; --static char tagsselbgcolor[] = "#005577"; ++static char tagsnormbordercolor[] = "#444444"; ++static char tagsnormfloatcolor[] = "#db8fd9"; ++ +static char tagsselfgcolor[] = "#7fbbb3"; +static char tagsselbgcolor[] = "#1e2326"; - static char tagsselbordercolor[] = "#005577"; - static char tagsselfloatcolor[] = "#005577"; - -@@ -515,6 +515,10 @@ - #elif SCRATCHPADS_PATCH - RULE(.instance = "spterm", .tags = SPTAG(0), .isfloating = 1) - #endif // SCRATCHPADS_PATCH ++static char tagsselbordercolor[] = "#005577"; ++static char tagsselfloatcolor[] = "#005577"; ++ ++static char hidnormfgcolor[] = "#005577"; ++static char hidselfgcolor[] = "#227799"; ++static char hidnormbgcolor[] = "#222222"; ++static char hidselbgcolor[] = "#222222"; ++ ++static char urgfgcolor[] = "#bbbbbb"; ++static char urgbgcolor[] = "#222222"; ++static char urgbordercolor[] = "#ff0000"; ++static char urgfloatcolor[] = "#db8fd9"; ++ ++#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 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 }, ++}; ++#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 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 + RULE(.class = "st", .isfloating = 0, .isterminal = 1, .noswallow = 0) + RULE(.class = "Display-im6.q16", .isfloating = 1, .isterminal = 1, .noswallow = 0) + RULE(.class = "zbar", .isfloating = 1, .isterminal = 1, .noswallow = 0) + RULE(.class = "qemu-system-x86_64", .isfloating = 1, .isterminal = 1, .noswallow = 0) - }; - - #if MONITOR_RULES_PATCH -@@ -637,7 +641,7 @@ - }; - - /* layout(s) */ --static const float mfact = 0.55; /* factor of master area size [0.05..0.95] */ ++}; ++ ++#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.50; /* 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 */ -@@ -729,9 +733,9 @@ - static const Layout layouts[] = { - /* symbol arrange function */ - #if TILE_LAYOUT -- { "[]=", tile }, /* first entry is default */ ++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 */ ++#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 */ ++ #endif + /* { "><>", NULL }, /1* no layout function means floating behavior *1/ */ - #if MONOCLE_LAYOUT - { "[M]", monocle }, - #endif -@@ -783,7 +787,7 @@ - #endif // XKB_PATCH - - /* key definitions */ --#define MODKEY Mod1Mask ++ #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} }, \ -@@ -870,11 +874,11 @@ - #if !NODMENU_PATCH - "-m", dmenumon, - #endif // NODMENU_PATCH -- "-fn", dmenufont, -- "-nb", normbgcolor, -- "-nf", normfgcolor, -- "-sb", selbgcolor, -- "-sf", selfgcolor, ++#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 -@@ -906,19 +910,39 @@ - }; - #endif // ON_EMPTY_KEYS_PATCH - ++ #if BAR_DMENUMATCHTOP_PATCH ++ topbar ? NULL : "-b", ++ #endif // BAR_DMENUMATCHTOP_PATCH ++ NULL ++}; ++static const char *termcmd[] = { "st", 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 ++ +static const char *filemanager[] = { "st", "-e", "nav", NULL }; +static const char *dpass[] = { "dwmpass", NULL }; +static const char *dpassotp[] = { "dwmotp", NULL }; @@ -142,88 +934,411 @@ diff '--color=auto' -Nu a/config.def.h b/config.def.h +static const char *micmute[] = { "micmute", NULL }; + +#include - static const Key keys[] = { - /* modifier key function argument */ - #if KEYMODES_PATCH - { MODKEY, XK_Escape, setkeymode, {.ui = COMMANDMODE} }, - #endif // KEYMODES_PATCH -- { MODKEY, XK_p, spawn, {.v = dmenucmd } }, -- { MODKEY|ShiftMask, XK_Return, spawn, {.v = termcmd } }, ++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 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|ShiftMask, XK_b, togglebar, {0} }, - #if TOGGLETOPBAR_PATCH - { MODKEY|ShiftMask, XK_b, toggletopbar, {0} }, - #endif // TOGGLETOPBAR_PATCH -@@ -967,8 +991,8 @@ - { 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 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|ShiftMask, XK_i, incnmaster, {.i = +1 } }, + { MODKEY|ShiftMask, XK_d, incnmaster, {.i = -1 } }, - #if FLEXTILE_DELUXE_LAYOUT - { MODKEY|ControlMask, XK_i, incnstack, {.i = +1 } }, - { MODKEY|ControlMask, XK_u, incnstack, {.i = -1 } }, -@@ -1013,7 +1037,7 @@ - #if INSETS_PATCH - { MODKEY|ShiftMask|ControlMask, XK_a, updateinset, {.v = &default_inset } }, - #endif // INSETS_PATCH -- { MODKEY, XK_Return, zoom, {0} }, ++ #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 } }, -@@ -1064,7 +1088,7 @@ - #if BAR_WINTITLEACTIONS_PATCH - { MODKEY|ControlMask, XK_z, showhideclient, {0} }, - #endif // BAR_WINTITLEACTIONS_PATCH -- { MODKEY|ShiftMask, XK_c, killclient, {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} }, ++ #endif // BAR_WINTITLEACTIONS_PATCH + { MODKEY, XK_c, killclient, {0} }, - #if KILLUNSEL_PATCH - { MODKEY|ShiftMask, XK_x, killunsel, {0} }, - #endif // KILLUNSEL_PATCH -@@ -1087,9 +1111,8 @@ - #if XRDB_PATCH && !BAR_VTCOLORS_PATCH - { MODKEY|ShiftMask, XK_F5, xrdb, {.v = NULL } }, - #endif // XRDB_PATCH -- { MODKEY, XK_t, setlayout, {.v = &layouts[0]} }, -- { MODKEY, XK_f, setlayout, {.v = &layouts[1]} }, -- { MODKEY, XK_m, setlayout, {.v = &layouts[2]} }, ++ #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 && !BAR_VTCOLORS_PATCH ++ { MODKEY|ShiftMask, XK_F5, xrdb, {.v = NULL } }, ++ #endif // XRDB_PATCH + { MODKEY|ShiftMask, XK_t, setlayout, {.v = &layouts[0]} }, + { MODKEY|ShiftMask, XK_m, setlayout, {.v = &layouts[1]} }, - #if COLUMNS_LAYOUT - { MODKEY, XK_c, setlayout, {.v = &layouts[3]} }, - #endif // COLUMNS_LAYOUT -@@ -1105,7 +1128,7 @@ - { 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 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, XK_t, togglefloating, {0} }, - #if MAXIMIZE_PATCH - { MODKEY|ControlMask|ShiftMask, XK_h, togglehorizontalmax, {0} }, - { MODKEY|ControlMask|ShiftMask, XK_l, togglehorizontalmax, {0} }, -@@ -1139,7 +1162,7 @@ - { MODKEY|ShiftMask, XK_f, fullscreen, {0} }, - #endif // FULLSCREEN_PATCH - #if STICKY_PATCH -- { MODKEY|ShiftMask, XK_s, togglesticky, {0} }, ++ #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, XK_s, togglesticky, {0} }, - #endif // STICKY_PATCH - #if SCRATCHPAD_ALT_1_PATCH - { MODKEY, XK_minus, scratchpad_show, {0} }, -@@ -1312,6 +1335,25 @@ - TAGKEYS( XK_7, 6) - TAGKEYS( XK_8, 7) - TAGKEYS( XK_9, 8) ++ #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 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) + { MODKEY, XK_f, spawn, {.v = filemanager } }, + { MODKEY|ShiftMask, XK_o, spawn, {.v = dpassotp } }, + { MODKEY|ShiftMask, XK_c, spawn, {.v = clipmenu } }, @@ -243,12 +1358,488 @@ diff '--color=auto' -Nu a/config.def.h b/config.def.h + { ShiftMask, XF86XK_AudioMute, spawn, {.v = micmute } }, + { 0, XF86XK_AudioMicMute, spawn, {.v = micmute } }, + { 0, XK_Print, spawn, {.v = prtsc } }, - }; - - #if KEYMODES_PATCH ++}; ++ ++#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: [ ]"` */ ++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 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 && !BAR_VTCOLORS_PATCH ++ { "xrdb", xrdb }, ++ #endif // XRDB_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:"` */ ++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 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 && !BAR_VTCOLORS_PATCH ++ IPCCOMMAND( xrdb, 1, {ARG_TYPE_NONE} ), ++ #endif // XRDB_PATCH ++}; ++#endif // IPC_PATCH diff '--color=auto' -Nu a/config.mk b/config.mk ---- a/config.mk 2024-12-28 22:09:50.009762644 -0600 -+++ b/config.mk 2024-12-28 22:39:51.163155583 -0600 +--- a/config.mk 2025-01-06 21:39:06.818760501 -0600 ++++ b/config.mk 2025-01-04 22:40:35.585863427 -0600 @@ -46,7 +46,7 @@ #XEXTLIB = -lXext @@ -261,87 +1852,1533 @@ diff '--color=auto' -Nu a/config.mk b/config.mk Common subdirectories: a/.git and b/.git Common subdirectories: a/.github and b/.github Common subdirectories: a/patch and b/patch -diff '--color=auto' -Nu a/patches.def.h b/patches.def.h ---- a/patches.def.h 2024-12-28 22:09:50.019762642 -0600 -+++ b/patches.def.h 2024-12-28 22:39:38.159821799 -0600 -@@ -206,7 +206,7 @@ - #define BAR_WINICON_PATCH 0 - - /* Show window title in bar */ --#define BAR_WINTITLE_PATCH 1 +diff '--color=auto' -Nu a/patches.h b/patches.h +--- a/patches.h 1969-12-31 18:00:00.000000000 -0600 ++++ b/patches.h 2025-01-04 22:40:55.615863303 -0600 +@@ -0,0 +1,1526 @@ ++/* ++ * This file contains patch control flags. ++ * ++ * In principle you should be able to mix and match any patches ++ * you may want. In cases where patches are logically incompatible ++ * one patch may take precedence over the other as noted in the ++ * relevant descriptions. ++ * ++ * Although layouts typically come as patches they are differentiated ++ * here for grouping purposes. ++ */ ++ ++/** ++ * Bar modules ++ */ ++ ++/* Enhanced taskbar that shows the titles of all visible windows in the status bar ++ * and allows focus / hiding / unhiding of windows by clicking on the status bar. ++ * Awesomebar takes precedence over fancybar. ++ * https://dwm.suckless.org/patches/awesomebar/ ++ */ ++#define BAR_AWESOMEBAR_PATCH 0 ++ ++/* This patch depends on statuscmd patch and adds integration with a (patched) ++ * dwmblocks instance to give a clickable status bar. One must not necessarily ++ * have to use dwmblocks for this feature, any status updater that has support ++ * for real-time signals (SIGRTMIN) can be used. ++ * ++ * dwmblocks: https://github.com/torrinfail/dwmblocks ++ * https://dwm.suckless.org/patches/statuscmd/ ++ */ ++#define BAR_DWMBLOCKS_PATCH 0 ++ ++/* Originally the dwmblocks + statuscmd patch used a user defined signal (SIGUSR1) ++ * for communicating with dwmblocks to indicate update signal and what button was ++ * pressed. The signalling was later changed to SIGRTMIN instead. ++ * ++ * Ultimately this makes dwmblocks instances that were patched with the old patch ++ * are incompatible with the new dwm patch and vice versa. ++ * ++ * This is a compatibility patch that makes dwm use SIGUSR1 instead of SIGRTMIN so ++ * if button clicks are not working then you may want to try enabling this. ++ * ++ * If dwmblocks happen to die like this when clicking on a status ++ * ++ * [1] 54355 user-defined signal 1 dwmblocks ++ * ++ * then it suggests that dwmblocks does not support user defined signals and this ++ * patch should be left disabled. ++ * ++ * Patch: https://gist.github.com/danbyl/54f7c1d57fc6507242a95b71c3d8fdea ++ * https://dwm.suckless.org/patches/statuscmd/ ++ */ ++#define BAR_DWMBLOCKS_SIGUSR1_PATCH 0 ++ ++/* This patch shows the titles of all visible windows in the status bar ++ * (as opposed to showing only the selected one). ++ * Awesomebar takes precedence over fancybar. Fancybar takes precedence over ++ * the centeredwindowname patch. ++ * https://dwm.suckless.org/patches/fancybar/ ++ */ ++#define BAR_FANCYBAR_PATCH 0 ++ ++/* Being an evolution of the bartabgroups patch the flexwintitle patch specifically ++ * taps into the many layout options that flextile-deluxe offers to produce a window ++ * title section in the bar that is representative of what is shown on screen. ++ */ ++#define BAR_FLEXWINTITLE_PATCH 0 ++ ++/* Adds buttons to the bar that can be used to launch applications. ++ * https://dwm.suckless.org/patches/launcher/ ++ */ ++#define BAR_LAUNCHER_PATCH 0 ++ ++/* This patch adds a context menu for layout switching. ++ * - xmenu needs to be installed. ++ * - Edit layoutmenu.sh with the installed layouts and with correct indexes. ++ * - Place layoutmenu.sh in PATH. ++ * - The text of the menu items is for display only. Name them however you want. ++ * https://dwm.suckless.org/patches/layoutmenu/ ++ */ ++#define BAR_LAYOUTMENU_PATCH 0 ++ ++/* Show layout symbol in bar */ ++#define BAR_LTSYMBOL_PATCH 1 ++ ++/* Adds powerline arrows for the status. ++ * This uses statuscolors logic for choosing colors for the powerline. As these markers ++ * are also control characters there is no explicit statuscmd support for this patch. ++ * ++ * Powerline separators are defined as: ++ * |\xXX (creates a hard edge) ++ * <\xXX (creates a less than arrow) ++ * /\xXX (creates a diagonal line) ++ * ++ * Examples: ++ * xsetroot -name "$(echo -e '<\x01a<\x02b<\x03c')" ++ * xsetroot -name "$(echo -e '/\x01d/\x02e/\x03f')" ++ * ++ * https://gitlab.com/udiboy1209-suckless/dwm/-/commit/071f5063e8ac4280666828179f92788d893eea40#4b1a539194be7467cefbda22f675a3b7c19ceca7 ++ * https://dwm.suckless.org/patches/statuscolors/ ++ */ ++#define BAR_POWERLINE_STATUS_PATCH 0 ++ ++/* Adds powerline arrows for the tags. ++ * https://gitlab.com/udiboy1209-suckless/dwm/-/commit/071f5063e8ac4280666828179f92788d893eea40#4b1a539194be7467cefbda22f675a3b7c19ceca7 ++ */ ++#define BAR_POWERLINE_TAGS_PATCH 0 ++ ++/* Alters the tags powerline to use forward slash instead of arrows */ ++#define BAR_POWERLINE_TAGS_SLASH_PATCH 0 ++ ++/* This patch turns the titlebar area into a mfact-respecting tabbar showing each client's title. ++ * https://dwm.suckless.org/patches/bartabgroups/ ++ */ ++#define BAR_TABGROUPS_PATCH 0 ++ ++/* This patch adds an option to place tags in rows like in many other window managers. ++ * https://dwm.suckless.org/patches/taggrid/ ++ */ ++#define BAR_TAGGRID_PATCH 0 ++ ++/* Hover tag icons to see a preview of the windows on that tag. ++ * ++ * The patch depends on Imlib2 for icon scaling. ++ * You need to uncomment the corresponding line in config.mk to use the -lImlib2 library ++ * ++ * Arch Linux: ++ * sudo pacman -S imlib2 ++ * Debian: ++ * sudo apt install libimlib2-dev ++ * ++ * As with the winicon patch you may want to consider adding the compiler flags of -O3 and ++ * -march=native to enable auto loop vectorize for better performance. ++ * ++ * https://dwm.suckless.org/patches/tag-previews/ ++ */ ++#define BAR_TAGPREVIEW_PATCH 0 ++ ++/* Show status in bar */ ++#define BAR_STATUS_PATCH 1 ++ ++/* This patch adds a clickable button to the left hand side of the statusbar. ++ * https://dwm.suckless.org/patches/statusbutton/ ++ */ ++#define BAR_STATUSBUTTON_PATCH 0 ++ ++/* This patch adds the ability to execute shell commands based on the mouse button and position ++ * when clicking the status bar. Refer to the website for usage. ++ * https://dwm.suckless.org/patches/statuscmd/ ++ */ ++#define BAR_STATUSCMD_PATCH 0 ++ ++/* Status2d allows colors and rectangle drawing in your dwm status bar. ++ * This patch is incompatible with the statuscolors patch which takes precedence. ++ * This patch is incompatible with the extrabar patch. ++ * https://dwm.suckless.org/patches/status2d/ ++ */ ++#define BAR_STATUS2D_PATCH 0 ++ ++/* Supplementary patch should you want to disable alpha for the status2d section */ ++#define BAR_STATUS2D_NO_ALPHA_PATCH 0 ++ ++/* Addition to the status2d patch that allows the use of terminal colors (color0 through color15) ++ * from xrdb in the status, allowing programs like pywal to change statusbar colors. ++ * This adds the C and B codes to use terminal foreground and background colors respectively. ++ * E.g. ^B5^ would use color5 as the background color. ++ * https://dwm.suckless.org/patches/status2d/ ++ */ ++#define BAR_STATUS2D_XRDB_TERMCOLORS_PATCH 0 ++ ++/* The systray patch adds systray for the status bar. ++ * https://dwm.suckless.org/patches/systray/ ++ */ ++#define BAR_SYSTRAY_PATCH 0 ++ ++/* Show tag symbols in the bar. */ ++#define BAR_TAGS_PATCH 1 ++ ++/* Show tag symbols + class of master window in the bar. ++ * https://dwm.suckless.org/patches/taglabels/ ++ */ ++#define BAR_TAGLABELS_PATCH 0 ++ ++/* This patch underlines the selected tag, or optionally all tags. ++ * https://dwm.suckless.org/patches/underlinetags/ ++ */ ++#define BAR_UNDERLINETAGS_PATCH 0 ++ ++/* This patch adds the window icon next to the window title in the bar. ++ * ++ * The patch depends on Imlib2 for icon scaling. ++ * You need to uncomment the corresponding line in config.mk to use the -lImlib2 library ++ * ++ * Arch Linux: ++ * sudo pacman -S imlib2 ++ * Debian: ++ * sudo apt install libimlib2-dev ++ * ++ * The author recommends adding the compiler flags of -O3 and -march=native to enable auto loop ++ * vectorize for better performance. ++ * ++ * https://github.com/AdamYuan/dwm-winicon ++ * https://dwm.suckless.org/patches/winicon ++ */ ++#define BAR_WINICON_PATCH 0 ++ ++/* Show window title in bar */ +#define BAR_WINTITLE_PATCH 0 - - /* Shows window titles in the bar, but only for floating clients. - * This depends on code from the flexwintitle patch. -@@ -459,7 +459,7 @@ - * This patch interferes with the center transient windows patches. - * https://dwm.suckless.org/patches/alwayscenter/ - */ --#define ALWAYSCENTER_PATCH 0 ++ ++/* Shows window titles in the bar, but only for floating clients. ++ * This depends on code from the flexwintitle patch. ++ * Note that the configuration in config.def.h for this is merely an example. If combined ++ * with the corresponding hidden patch then these two will overlap unless the width of the ++ * modules are controlled. ++ */ ++#define BAR_WINTITLE_FLOATING_PATCH 0 ++ ++/* Shows window titles in the bar, but only for floating clients. ++ * This depends on code from the flexwintitle patch. ++ * Note that the configuration in config.def.h for this is merely an example. If combined ++ * with the corresponding floating patch then these two will overlap unless the width of the ++ * modules are controlled. ++ */ ++#define BAR_WINTITLE_HIDDEN_PATCH 0 ++ ++/* Title bar modules such as wintitle (default), fancybar and awesomebar ++ * do not by default add left and/or right padding as they take up the ++ * remaining space. These options allow you explicitly add padding should ++ * you need it. ++ */ ++#define BAR_TITLE_RIGHT_PAD_PATCH 0 ++#define BAR_TITLE_LEFT_PAD_PATCH 0 ++ ++/** ++ * Bar options ++ */ ++ ++/* This patch changes the rectangle indicating if a tag is used by a client into a bar ++ * above the tag name for better visibility. ++ * Set the tagindicatortype variable in config.h to INDICATOR_TOP_BAR to enable this. ++ * https://dwm.suckless.org/patches/activetagindicatorbar/ ++ */ ++#define BAR_ACTIVETAGINDICATORBAR_PATCH N/A ++ ++/* Alternative patch to the activetagindicatorbar patch, adds the bar below the tag ++ * icon rather than above. ++ * Set the tagindicatortype variable in config.h to INDICATOR_BOTTOM_BAR to enable this. ++ */ ++#define BAR_ACTIVETAGINDICATORBAR_ALT1_PATCH N/A ++ ++/* The alpha patch adds transparency for the status bar. ++ * You need to uncomment the corresponding line in config.mk to use the -lXrender library ++ * when including this patch. ++ * https://dwm.suckless.org/patches/alpha/ ++ */ ++#define BAR_ALPHA_PATCH 0 ++ ++/* This patch introduces alternative tags which can be switched on the fly for the ++ * sole purpose of providing visual aid. ++ * https://dwm.suckless.org/patches/alternativetags/ ++ */ ++#define BAR_ALTERNATIVE_TAGS_PATCH 0 ++ ++/* This patches provides the ability to use alternative text for tags which contain at ++ * least one window. ++ * https://dwm.suckless.org/patches/alttagsdecoration/ ++ */ ++#define BAR_ALTTAGSDECORATION_PATCH 0 ++ ++/* This patch enables dwm to manage external status bars such as lemonbar and polybar. ++ * dwm treats the external bar as it would its own, so all regular dwm commands such as ++ * togglebar affect the external bar in the same way. ++ * ++ * NB: Unless you want both anybar + dwm bar(s) then the recommendation is to disable all ++ * bar modules and have { -2 } in the barrules. ++ * ++ * https://dwm.suckless.org/patches/anybar/ ++ */ ++#define BAR_ANYBAR_PATCH 0 ++ ++/* Anybar option to place the next bar depending on previous bar's position (top or bottom) */ ++#define BAR_ANYBAR_TOP_AND_BOTTOM_BARS_PATCH 0 ++ ++/* Anybar option to let dwm manage the width of the bar */ ++#define BAR_ANYBAR_MANAGE_WIDTH_PATCH 0 ++ ++/* This patch adds a border around the status bar(s) just like the border of client windows. ++ * https://codemadness.org/paste/dwm-border-bar.patch ++ */ ++#define BAR_BORDER_PATCH 0 ++ ++/* This patch centers the WM_NAME of the currently selected window on the status bar. ++ * This is compatible with the wintitle, bartabgroups, flexwintitle and awesomebar bar ++ * modules. ++ * https://dwm.suckless.org/patches/centeredwindowname/ ++ */ ++#define BAR_CENTEREDWINDOWNAME_PATCH 0 ++ ++/* Draws a dot indicator overlayed on each tag icon for each client. The selected client ++ * is drawn as a larger horizontal line. ++ * Set the tagindicatortype variable in config.h to INDICATOR_CLIENT_DOTS to enable this. ++ * https://dwm.suckless.org/patches/clientindicators/ ++ */ ++#define BAR_CLIENTINDICATOR_PATCH N/A ++ ++/* Updates the position of dmenu to match that of the bar. I.e. if topbar is 0 then dmenu ++ * will appear at the bottom and if 1 then dmenu will appear at the top. ++ * https://dwm.suckless.org/patches/dmenumatchtop ++ */ ++#define BAR_DMENUMATCHTOP_PATCH 0 ++ ++/* Originally this was the extrabar patch, but as the handling of extra bars is now built-in ++ * only the splitting of the status by a designated separator remains. As such this has been ++ * renamed to more accurately reflect what it does - creating an extra status. ++ * https://dwm.suckless.org/patches/extrabar/ ++ */ ++#define BAR_EXTRASTATUS_PATCH 0 ++ ++/* Adds EWMH support for _NET_NUMBER_OF_DESKTOPS, _NET_CURRENT_DESKTOP, _NET_DESKTOP_NAMES ++ * and _NET_DESKTOP_VIEWPORT, which allows for compatibility with other bars and programs ++ * that request workspace information. For example polybar's xworkspaces module. ++ * ++ * This patch also includes support for adding the _IS_FLOATING property for floating windows ++ * allowing for compositors to treat floating windows differently to tiled windows. ++ * ++ * E.g. this setting makes picom only render shadows for floating windows: ++ * ++ * shadow-exclude = [ "! _IS_FLOATING@:32c = 1" ]; ++ * ++ * https://github.com/bakkeby/dwm-flexipatch/issues/50 (_IS_FLOATING patch) ++ * https://dwm.suckless.org/patches/ewmhtags/ ++ */ ++#define BAR_EWMHTAGS_PATCH 0 ++ ++/* Allows the bar height to be explicitly set rather than being derived from font. ++ * https://dwm.suckless.org/patches/bar_height/ ++ */ ++#define BAR_HEIGHT_PATCH 0 ++ ++/* This patch prevents dwm from drawing tags with no clients (i.e. vacant) on the bar. ++ * https://dwm.suckless.org/patches/hide_vacant_tags/ ++ */ ++#define BAR_HIDEVACANTTAGS_PATCH 0 ++ ++/* With this patch dwm's built-in status bar is only shown when HOLDKEY is pressed ++ * and the bar will now overlay the display. ++ * http://dwm.suckless.org/patches/holdbar/ ++ */ ++#define BAR_HOLDBAR_PATCH 0 ++ ++/* Sometimes dwm crashes when it cannot render some glyphs in window titles (usually emoji). ++ * This patch is essentially a hack to ignore any errors when drawing text on the status bar. ++ * https://groups.google.com/forum/m/#!topic/wmii/7bncCahYIww ++ * https://docs.google.com/viewer?a=v&pid=forums&srcid=MDAwODA2MTg0MDQyMjE0OTgzMzMBMDQ3ODQzODkyMTU3NTAyMTMxNTYBX2RUMVNtOUtDQUFKATAuMQEBdjI&authuser=0 ++ */ ++#define BAR_IGNORE_XFT_ERRORS_WHEN_DRAWING_TEXT_PATCH 0 ++ ++/* This patch adds back in the workaround for a BadLength error in the Xft library when color ++ * glyphs are used. This is for systems that do not have an updated version of the Xft library ++ * (or generally prefer monochrome fonts). ++ */ ++#define BAR_NO_COLOR_EMOJI_PATCH 0 ++ ++/* This patch adds vertical and horizontal space between the statusbar and the edge of the screen. ++ * https://dwm.suckless.org/patches/barpadding/ ++ */ ++#define BAR_PADDING_PATCH 0 ++ ++/* Same as barpadding patch but specifically tailored for the vanitygaps patch in that the outer ++ * bar padding is derived from the vanitygaps settings. In addition to this the bar padding is ++ * toggled in unison when vanitygaps are toggled. Increasing or decreasing gaps during runtime ++ * will not affect the bar padding. ++ */ ++#define BAR_PADDING_VANITYGAPS_PATCH 0 ++ ++/* Smart bar padding patch that automatically adjusts the padding when there is ++ * only one client on the monitor. Works well with vanitygaps and barpadding ++ * patches. ++ */ ++#define BAR_PADDING_SMART_PATCH 0 ++ ++/* This patch adds simple markup for status messages using pango markup. ++ * This depends on the pango library v1.44 or greater. ++ * You need to uncomment the corresponding lines in config.mk to use the pango libraries ++ * when including this patch. ++ * ++ * Note that the pango patch does not protect against the BadLength error from Xft ++ * when color glyphs are used, which means that dwm will crash if color emoji is used. ++ * ++ * If you need color emoji then you may want to install this patched library from the AUR: ++ * https://aur.archlinux.org/packages/libxft-bgra/ ++ * ++ * A long term fix for the libXft library is pending approval of this pull request: ++ * https://gitlab.freedesktop.org/xorg/lib/libxft/-/merge_requests/1 ++ * ++ * Also see: ++ * https://developer.gnome.org/pygtk/stable/pango-markup-language.html ++ * https://lists.suckless.org/hackers/2004/17285.html ++ * https://dwm.suckless.org/patches/pango/ ++ */ ++#define BAR_PANGO_PATCH 0 ++ ++/* This patch allows the status text to be fixed to the bar on a specific ++ * monitor rather than being drawn on the focused monitor. ++ * The statusallmons patch takes precedence over this patch. ++ * https://dwm.suckless.org/patches/staticstatus/ ++ */ ++#define BAR_STATICSTATUS_PATCH 0 ++ ++/* This patch draws and updates the statusbar on all monitors. ++ * https://dwm.suckless.org/patches/statusallmons/ ++ */ ++#define BAR_STATUSALLMONS_PATCH 0 ++ ++/* This patch enables colored text in the status bar. It changes the way colors are defined ++ * in config.h allowing multiple color combinations for use in the status script. ++ * This patch is incompatible with and takes precedence over the status2d patch. ++ * ++ * This patch is compatible with the statuscmd patch with the caveat that the first 16 markers ++ * are reserved for status colors restricting block signals to 17 through 31. ++ * ++ * https://dwm.suckless.org/patches/statuscolors/ ++ */ ++#define BAR_STATUSCOLORS_PATCH 0 ++ ++/* This patch adds configuration options for horizontal and vertical padding in the status bar. ++ * https://dwm.suckless.org/patches/statuspadding/ ++ */ ++#define BAR_STATUSPADDING_PATCH 0 ++ ++/* This patch adds the ability for dwm to read colors from the linux virtual console. ++ * /sys/module/vt/parameters/default_{red,grn,blu} ++ * Essentially this way the colors you use in your regular tty is "mirrored" to dwm. ++ * https://dwm.suckless.org/patches/vtcolors/ ++ */ ++#define BAR_VTCOLORS_PATCH 0 ++ ++/* This patch allows client windows to be hidden. This code was originally part of awesomebar, ++ * but has been separated out so that other bar modules can take advantage of it. ++ * Both awesomebar and bartabgroups patches depend on this patch and it will be auto-enabled ++ * during compile time if it is needed. Note that if using flexipatch-finalizer this must be ++ * explicitly enabled. ++ * https://github.com/bakkeby/patches/blob/master/dwm/dwm-barmodules-wintitleactions-6.2.diff ++ */ ++#define BAR_WINTITLEACTIONS_PATCH BAR_AWESOMEBAR_PATCH || BAR_TABGROUPS_PATCH || BAR_FLEXWINTITLE_PATCH ++ ++/*** ++ * Other patches ++ */ ++ ++/* Adds a window task switcher toggled using alt-tab. ++ * https://dwm.suckless.org/patches/alt-tab/ ++ */ ++#define ALT_TAB_PATCH 0 ++ ++/* All floating windows are centered, like the center patch, but without a rule. ++ * The center patch takes precedence over this patch. ++ * This patch interferes with the center transient windows patches. ++ * https://dwm.suckless.org/patches/alwayscenter/ ++ */ +#define ALWAYSCENTER_PATCH 1 - - /* This patch allows windows to be resized with its aspect ratio remaining constant. - * https://dwm.suckless.org/patches/aspectresize/ -@@ -488,7 +488,7 @@ - /* This patch adds new clients at the bottom of the stack. - * https://dwm.suckless.org/patches/attachbottom/ - */ --#define ATTACHBOTTOM_PATCH 0 ++ ++/* This patch allows windows to be resized with its aspect ratio remaining constant. ++ * https://dwm.suckless.org/patches/aspectresize/ ++ */ ++#define ASPECTRESIZE_PATCH 0 ++ ++/* This patch adds new clients above the selected client, instead of always ++ * becoming the new master. This behaviour is known from Xmonad. ++ * This patch takes precedence over ATTACHASIDE_PATCH. ++ * https://dwm.suckless.org/patches/attachabove/ ++ */ ++#define ATTACHABOVE_PATCH 0 ++ ++/* This patch adds new clients on top of the stack. ++ * This patch takes precedence over ATTACHBELOW_PATCH. ++ * https://dwm.suckless.org/patches/attachaside/ ++ */ ++#define ATTACHASIDE_PATCH 0 ++ ++/* This patch adds new clients below the selected client. ++ * This patch takes precedence over ATTACHBOTTOM_PATCH. ++ * https://dwm.suckless.org/patches/attachbelow/ ++ */ ++#define ATTACHBELOW_PATCH 0 ++ ++/* This patch adds new clients at the bottom of the stack. ++ * https://dwm.suckless.org/patches/attachbottom/ ++ */ +#define ATTACHBOTTOM_PATCH 1 - - /* This patch will make dwm run "~/.local/share/dwm/autostart_blocking.sh" and - * "~/.local/share/dwm/autostart.sh &" before entering the handler loop. One or -@@ -828,7 +828,7 @@ - /* This patch allows you to move clients around in the stack and swap them with the master. - * https://dwm.suckless.org/patches/movestack/ - */ --#define MOVESTACK_PATCH 0 ++ ++/* This patch will make dwm run "~/.local/share/dwm/autostart_blocking.sh" and ++ * "~/.local/share/dwm/autostart.sh &" before entering the handler loop. One or ++ * both of these files can be ommited. Note the path inside .local/share rather ++ * than the original ~/.dwm folder. ++ * https://dwm.suckless.org/patches/autostart/ ++ */ ++#define AUTOSTART_PATCH 0 ++ ++/* By default, windows that are not visible when requesting a resize/move will not ++ * get resized/moved. With this patch, they will. ++ * https://dwm.suckless.org/patches/autoresize/ ++ */ ++#define AUTORESIZE_PATCH 0 ++ ++/* This patch adds proper support for Right-To-Left languages. (such as Farsi, Arabic or Hebrew). ++ * ++ * You need to uncomment the corresponding lines in config.mk to use the -lfribidi library ++ * when including this patch. ++ * ++ * This patch depends on the following additional library: ++ * - fribidi ++ * ++ * https://dwm.suckless.org/patches/bidi/ ++ */ ++#define BIDI_PATCH 0 ++ ++/* This patch adds a client rule option to allow the border width to be specified on a per ++ * client basis. ++ * ++ * Example rule: ++ * RULE(.class = "Gimp", .bw = 0) ++ * ++ * https://dwm.suckless.org/patches/borderrule/ ++ */ ++#define BORDER_RULE_PATCH 0 ++ ++/* This patch adds an iscentered rule to automatically center clients on the current monitor. ++ * This patch takes precedence over centeredwindowname, alwayscenter and fancybar patches. ++ * https://dwm.suckless.org/patches/center/ ++ */ ++#define CENTER_PATCH 0 ++ ++/* A transient window is one that is meant to be short lived and is usually raised by a ++ * parent window. Such windows are typically dialog boxes and the like. ++ * It should be noted that in dwm transient windows are not subject to normal client rules ++ * and they are always floating by default. ++ * This patch centers transient windows on the screen like the center patch does. Note that ++ * the 6.2 center patch piggy-backed on the updatewindowtype function to ensure that all ++ * dialog boxes were centered, transient or not. This function was removed in relation to ++ * adding wintype as a client rule filter, hence this no longer works out of the box. This ++ * patch restores previous behaviour with the center patch. ++ */ ++#define CENTER_TRANSIENT_WINDOWS_PATCH 0 ++ ++/* As above, except that the transient window is centered within the position of the parent ++ * window, rather than at the center of the screen. This takes precedence over the above patch. ++ */ ++#define CENTER_TRANSIENT_WINDOWS_BY_PARENT_PATCH 0 ++ ++/* This patch provides the ability to assign different weights to clients in their ++ * respective stack in tiled layout. ++ * https://dwm.suckless.org/patches/cfacts/ ++ */ ++#define CFACTS_PATCH 0 ++ ++/* This patch allows color attributes to be set through the command line. ++ * https://dwm.suckless.org/patches/cmdcustomize/ ++ */ ++#define CMDCUSTOMIZE_PATCH 0 ++ ++/* This patch tweaks the tagging interface so that you can select multiple tags for tag ++ * or view by pressing all the right keys as a combo. For example to view tags 1 and 3, ++ * hold MOD and then press and hold 1 and 3 together. ++ * https://dwm.suckless.org/patches/combo/ ++ */ ++#define COMBO_PATCH 0 ++ ++/* Allow dwm to execute commands from autostart array in your config.h file. When dwm exits ++ * then all processes from autostart array will be killed. ++ * https://dwm.suckless.org/patches/cool_autostart/ ++ */ ++#define COOL_AUTOSTART_PATCH 0 ++ ++/* The cyclelayouts patch lets you cycle through all your layouts. ++ * https://dwm.suckless.org/patches/cyclelayouts/ ++ */ ++#define CYCLELAYOUTS_PATCH 0 ++ ++/* Make dwm respect _MOTIF_WM_HINTS property, and not draw borders around windows requesting ++ * for it. Some applications use this property to notify window managers to not draw window ++ * decorations. ++ * Not respecting this property leads to issues with applications that draw their own borders, ++ * like chromium (with "Use system title bar and borders" turned off) or vlc in fullscreen mode. ++ * https://dwm.suckless.org/patches/decoration_hints/ ++ */ ++#define DECORATION_HINTS_PATCH 0 ++ ++/* This feature distributes all clients on the current monitor evenly across all tags. ++ * It is a variant of the reorganizetags patch. ++ * https://dwm.suckless.org/patches/reorganizetags/ ++ */ ++#define DISTRIBUTETAGS_PATCH 0 ++ ++/* By default dwm will terminate on color allocation failure and the behaviour is intended to ++ * catch and inform the user of color configuration issues. ++ * ++ * Some patches like status2d and xresources / xrdb can change colours during runtime, which ++ * means that if a color can't be allocated at this time then the window manager will abruptly ++ * terminate. ++ * ++ * This patch will ignore color allocation failures and continue on as normal. The effect of ++ * this is that the existing color, that was supposed to be replaced, will remain as-is. ++ */ ++#define DO_NOT_DIE_ON_COLOR_ALLOCATION_FAILURE_PATCH 0 ++ ++/* Similarly to the dragmfact patch this allows you to click and drag clients to change the ++ * cfact to adjust the client's size in the stack. This patch depends on the cfacts patch. ++ */ ++#define DRAGCFACT_PATCH 0 ++ ++/* This patch lets you resize the split in the tile layout (i.e. modify mfact) by holding ++ * the modkey and dragging the mouse. ++ * This patch can be a bit wonky with other layouts, but generally works. ++ * https://dwm.suckless.org/patches/dragmfact/ ++ */ ++#define DRAGMFACT_PATCH 0 ++ ++/* Simple dwmc client using a fork of fsignal to communicate with dwm. ++ * To use this either copy the patch/dwmc shell script to somewhere in your path or ++ * uncomment the following line in Makefile: ++ * #cp -f patch/dwmc ${DESTDIR}${PREFIX}/bin ++ * http://dwm.suckless.org/patches/dwmc/ ++ */ ++#define DWMC_PATCH 0 ++ ++/* This patch allows no tag at all to be selected. The result is that dwm will start with ++ * no tag selected and when you start a client with no tag rule and no tag selected then ++ * it will be opened on the first tag. ++ * https://dwm.suckless.org/patches/emptyview/ ++ */ ++#define EMPTYVIEW_PATCH 0 ++ ++/* This patch allows the user to change size and placement of floating windows using only the ++ * keyboard. It also allows for temporary vertical and horizontal extension of windows similar ++ * to other WMs fill command. ++ * https://dwm.suckless.org/patches/exresize/ ++ */ ++#define EXRESIZE_PATCH 0 ++ ++/* Only allow clients to "fullscreen" into the space currently given to them. ++ * As an example, this will allow you to view a fullscreen video in your browser on ++ * one half of the screen, while having the other half available for other tasks. ++ * This patch takes precedence over the fakefullscreen client patch below. ++ * https://dwm.suckless.org/patches/fakefullscreen/ ++ */ ++#define FAKEFULLSCREEN_PATCH 0 ++ ++/* Similarly to the fakefullscreen patch this patch only allows clients to "fullscreen" into ++ * the space currently given to them. ++ * The "twist" with this patch is that fake fullscreen can be toggled on a per client basis ++ * rather than applying to all clients globally. ++ * Also see the selectivefakefullscreen option that adds a rule option to enabled this on client ++ * startup. ++ */ ++#define FAKEFULLSCREEN_CLIENT_PATCH 0 ++ ++/* This patch adds a float rule allowing the size and position of floating windows to be specified ++ * It also allows the size and position of floating windows to be controlled similar to the ++ * exresize, moveresize, and moveplace patches. ++ * The size and position can be specified using absolute, relative or fixed co-ordinates and ++ * https://github.com/bakkeby/patches/wiki/floatpos/ ++ */ ++#define FLOATPOS_PATCH 0 ++ ++/* Add-on functionality for the above: make the float positions respect outer (vanity)gaps. */ ++#define FLOATPOS_RESPECT_GAPS_PATCH 0 ++ ++/* This patch provides the ability to focus the tag on the immediate left or right of the ++ * currently focused tag. It also allows to send the focused window either on the left or ++ * the right tag. ++ * http://dwm.suckless.org/patches/focusadjacenttag/ ++ */ ++#define FOCUSADJACENTTAG_PATCH 0 ++ ++/* Allows focusing on clients based on direction (up, down, left, right) instead of client order. ++ * https://github.com/bakkeby/patches/wiki/focusdir/ ++ */ ++#define FOCUSDIR_PATCH 0 ++ ++/* When changing tags, closing windows or moving clients out of view then focus will revert to the ++ * client window that remains under the mouse cursor rather than the most recently focused window. ++ * https://github.com/bakkeby/patches/wiki/focusfollowmouse ++ */ ++#define FOCUSFOLLOWMOUSE_PATCH 0 ++ ++/* A simple patch that just puts focus back to the master client. ++ * https://dwm.suckless.org/patches/focusmaster/ ++ */ ++#define FOCUSMASTER_PATCH 0 ++ ++/* A variant of the focusmaster patch that additionally allows the focus to be returned to the ++ * previously focused client ++ * https://dwm.suckless.org/patches/focusmaster/ ++ */ ++#define FOCUSMASTER_RETURN_PATCH 0 ++ ++/* Switch focus only by mouse click and not sloppy (focus follows mouse pointer). ++ * https://dwm.suckless.org/patches/focusonclick/ ++ */ ++#define FOCUSONCLICK_PATCH 0 ++ ++/* Selects the next window having the urgent flag regardless of the tag it is on. ++ * The urgent flag can be artificially set with the following xdotool command on any window: ++ * xdotool selectwindow -- set_window --urgency 1 ++ * https://dwm.suckless.org/patches/focusurgent/ ++ */ ++#define FOCUSURGENT_PATCH 0 ++ ++/* By default, dwm responds to _NET_ACTIVE_WINDOW client messages by setting ++ * the urgency bit on the named window. This patch activates the window instead. ++ * https://dwm.suckless.org/patches/focusonnetactive/ ++ */ ++#define FOCUSONNETACTIVE_PATCH 0 ++ ++/* Send "fake signals" to dwm for handling, using xsetroot. This will not conflict with the ++ * status bar, which also is managed using xsetroot. ++ * Also see the dwmc patch, which takes precedence over this patch. ++ * https://dwm.suckless.org/patches/fsignal/ ++ */ ++#define FSIGNAL_PATCH 0 ++ ++/* Applies the monocle layout with the focused client on top and hides the bar. When pressed ++ * again it shows the bar and restores the layout that was active before going fullscreen. ++ * https://dwm.suckless.org/patches/fullscreen/ ++ */ ++#define FULLSCREEN_PATCH 0 ++ ++/* This patch provides a keybinding to rotate all clients in the currently selected ++ * area (master or stack) without affecting the other area. ++ * https://dwm.suckless.org/patches/inplacerotate/ ++ */ ++#define INPLACEROTATE_PATCH 0 ++ ++/* This patch lets you define custom insets from each edge of the screen. One use case would be ++ * to arrange space for an external bar. ++ * https://dwm.suckless.org/patches/insets/ ++ */ ++#define INSETS_PATCH 0 ++ ++/* This patch (v1.5.7) implements inter-process communication through a UNIX socket for dwm. This ++ * allows for the window manager to be queried for information, e.g. listen for events such as tag ++ * or layout changes, as well as send commands to control the window manager via other programs. ++ * ++ * You need to uncomment the corresponding lines in config.mk to use the -lyajl library ++ * when including this patch. ++ * This patch depends on the following additional library: ++ * - yajl ++ * ++ * https://github.com/mihirlad55/dwm-ipc ++ * https://dwm.suckless.org/patches/ipc/ ++ */ ++#define IPC_PATCH 0 ++ ++/* Adds rule option for clients to avoid accidental termination by killclient for sticky windows. ++ * https://dwm.suckless.org/patches/ispermanent/ ++ */ ++#define ISPERMANENT_PATCH 0 ++ ++/* This patch adds key modes (like in vim or emacs) where chains of keyboard shortcuts ++ * can be performed. ++ * https://dwm.suckless.org/patches/keymodes/ ++ */ ++#define KEYMODES_PATCH 0 ++ ++/* This patch adds a keybinding to kills all visible clients that are not selected. ++ * https://dwm.suckless.org/patches/killunsel/ ++ */ ++#define KILLUNSEL_PATCH 0 ++ ++/* This changes the window manager name to LG3d instead of dwm as a workaround for Java ++ * applications that assume that the window manager is using window reparenting. ++ * Refer to the ISSUES secton of the dwm man page for more details. ++ */ ++#define LG3D_PATCH 0 ++ ++/* By default in dwm it is possible to make an application fullscreen, then use ++ * the focusstack keybindings to focus on other windows beneath the current window. ++ * It is also possible to spawn new windows (e.g. a terminal) that end up getting ++ * focus while the previous window remains in fullscreen. This patch ensures that ++ * in such scenarios the previous window loses fullscreen. ++ * https://github.com/bakkeby/patches/blob/master/dwm/dwm-losefullscreen-6.2.diff ++ */ ++#define LOSEFULLSCREEN_PATCH 0 ++ ++/* This patch adds helper functions for maximizing, horizontally and vertically, floating ++ * windows using keybindings. ++ * https://dwm.suckless.org/patches/maximize/ ++ */ ++#define MAXIMIZE_PATCH 0 ++ ++/* Control Music Player Daemon via keybinds. ++ * You need to uncomment the corresponding line in config.mk to use the -lmpdclient library ++ * when including this patch. ++ * This patch depends on the following additional library: ++ * - libmpdclient ++ * https://dwm.suckless.org/patches/mpdcontrol/ ++ */ ++#define MPDCONTROL_PATCH 0 ++ ++/* Adds rules per monitor, e.g. have default layouts per monitor. ++ * The use case for this is if the second monitor is vertical (i.e. rotated) then ++ * you may want to use a different default layout for this monitor than what is ++ * used for the main monitor. E.g. normal vertical split for main monitor and ++ * horizontal split for the second. ++ */ ++#define MONITOR_RULES_PATCH 0 ++ ++/* Always display the the monocle-symbol as defined in config.h if the monocle-layout ++ * is activated. Do not display the number of open clients in the current tag. ++ * https://dwm.suckless.org/patches/monoclesymbol/ ++ */ ++#define MONOCLESYMBOL_PATCH 0 ++ ++/* Makes a window floating and 1/3rd the height and 1/3rd the width of the screen and is ++ * positioned in either the center or one of the 8 cardinal directions depending on which ++ * key is pressed. ++ * https://dwm.suckless.org/patches/moveplace/ ++ */ ++#define MOVEPLACE_PATCH 0 ++ ++/* This patch allows you to move and resize dwm's clients using keyboard bindings. ++ * https://dwm.suckless.org/patches/moveresize/ ++ */ ++#define MOVERESIZE_PATCH 0 ++ ++/* This patch allows you to move clients around in the stack and swap them with the master. ++ * https://dwm.suckless.org/patches/movestack/ ++ */ +#define MOVESTACK_PATCH 1 - - /* This patch allows you to change the names of tags during runtime. - * -@@ -865,7 +865,7 @@ - /* Removes the border when there is only one window visible. - * https://dwm.suckless.org/patches/noborder/ - */ --#define NOBORDER_PATCH 0 ++ ++/* This patch allows you to change the names of tags during runtime. ++ * ++ * This is a bespoke version implemented specifically in relation to tagicons, which is integrated ++ * into dwm-flexipatch. By default it uses dmenu to retrieve the new name, but this can be ++ * customised via config along with the maximum text length and the format string. ++ * ++ * Special behaviour: ++ * - if more than one tag is selected then the name change applies to all selected tags ++ * - if tagicons is configured to have unique tags per monitor then the change only applies ++ * for the current monitor ++ * - the name change applies to the tag set that is active for the current tag: ++ * * if used in combination with BAR_ALTTAGSDECORATION_PATCH and there are clients on the ++ * given tag then the name change only applies to the ALT_TAGS_DECORATION tag set ++ * * if used in combination with the BAR_ALTERNATIVE_TAGS_PATCH and alternative tags are ++ * shown then the name change only applies to the ALTERNATIVE_TAGS tag set ++ * * if used in combination with both then BAR_ALTTAGSDECORATION_PATCH takes precedence ++ * * otherwise the name change applies to the DEFAULT_TAGS tag set ++ * ++ * https://dwm.suckless.org/patches/nametag/ ++ */ ++#define NAMETAG_PATCH 0 ++ ++/* Variant of the above which prepends the tag number to the given string. ++ * The toggle does nothing on its own and need to be enabled in combination with the above. */ ++#define NAMETAG_PREPEND_PATCH 0 ++ ++/* Adds support for the _NET_CLIENT_LIST_STACKING atom, needed by certain applications like the ++ * Zoom video conferencing application. ++ * https://github.com/bakkeby/patches/wiki/netclientliststacking/ ++ */ ++#define NET_CLIENT_LIST_STACKING_PATCH 0 ++ ++/* Removes the border when there is only one window visible. ++ * https://dwm.suckless.org/patches/noborder/ ++ */ +#define NOBORDER_PATCH 1 - - /* Enable modifying or removing dmenu in config.def.h which resulted previously in a - * compilation error because two lines of code hardcode dmenu into dwm. -@@ -917,7 +917,7 @@ - * monitor (default). - * https://dwm.suckless.org/patches/pertag/ - */ --#define PERTAG_PATCH 0 ++ ++/* Enable modifying or removing dmenu in config.def.h which resulted previously in a ++ * compilation error because two lines of code hardcode dmenu into dwm. ++ * https://dwm.suckless.org/patches/nodmenu/ ++ */ ++#define NODMENU_PATCH 0 ++ ++/* This patch allows for toggleable client button bindings that have no modifiers. ++ * This can, for example, allow you to move or resize using the mouse alone without holding ++ * down a modifier key. This can be practical if you have extra buttons on your mouse. ++ * While you can use button bindings with no modifiers without this patch in a bare dwm, ++ * those buttons are then unavailable for use within the application itself so being able to ++ * toggle these on and off can be necessary in certain situations (e.g. being able to use ++ * back and forward buttons in a browser). ++ ++ * Example bindings: ++ * { ClkClientWin, 0, Button8, movemouse, {0} }, ++ * { ClkClientWin, 0, Button9, resizemouse, {0} }, ++ */ ++#define NO_MOD_BUTTONS_PATCH 0 ++ ++/* When terminals have transparency then their borders also become transparent. ++ * This patch ensures that borders have no transparency. Note that this patch is ++ * only relevant if you are not using the alpha patch. ++ * https://github.com/szatanjl/dwm/commit/1529909466206016f2101457bbf37c67195714c8 ++ * https://dwm.suckless.org/patches/alpha/dwm-fixborders-6.2.diff ++ */ ++#define NO_TRANSPARENT_BORDERS_PATCH 0 ++ ++/* Port of InstantWM's on_empty_keys functionality allowing keybindings that apply only when ++ * a tag is empty. An example use case is being able to launch applications with first hand ++ * keys like "f" to launch firefox. ++ * ++ * https://github.com/instantOS/instantWM/ ++ * https://github.com/bakkeby/dwm-flexipatch/issues/51 ++ */ ++#define ON_EMPTY_KEYS_PATCH 0 ++ ++/* Minor patch that prevents more than one rule being matched for a given client. */ ++#define ONLY_ONE_RULE_MATCH_PATCH 0 ++ ++/* This patch makes it so dwm will only exit via quit() if no windows are open. ++ * This is to prevent you accidentally losing all your work. ++ * https://dwm.suckless.org/patches/onlyquitonempty/ ++ */ ++#define ONLYQUITONEMPTY_PATCH 0 ++ ++/* The pertag patch adds nmaster, mfacts and layouts per tag rather than per ++ * monitor (default). ++ * https://dwm.suckless.org/patches/pertag/ ++ */ +#define PERTAG_PATCH 1 - - /* Option to enable gaps on a per tag basis rather than globally. - * Depends on both pertag and vanitygaps patches being enabled. -@@ -1188,7 +1188,7 @@ - /* Adds toggleable keyboard shortcut to make a client 'sticky', i.e. visible on all tags. - * https://dwm.suckless.org/patches/sticky/ - */ --#define STICKY_PATCH 0 ++ ++/* Option to enable gaps on a per tag basis rather than globally. ++ * Depends on both pertag and vanitygaps patches being enabled. ++ */ ++#define PERTAG_VANITYGAPS_PATCH 0 ++ ++/* This patch allows configuring vanity gaps on a per-monitor basis rather than ++ * all monitors (default). ++ */ ++#define PERMON_VANITYGAPS_PATCH 0 ++ ++/* This controls whether or not to also store bar position on a per ++ * tag basis, or leave it as one bar per monitor. ++ */ ++#define PERTAGBAR_PATCH 0 ++ ++/* Similar to the focusdir patch this patch allow users to move a window in any direction ++ * in the tiled stack (up, down, left, right). ++ * https://github.com/bakkeby/patches/wiki/placedir ++ */ ++#define PLACEDIR_PATCH 0 ++ ++/* This patch lets you change the position of a client in the stack using the mouse. ++ * https://github.com/bakkeby/patches/wiki/placemouse ++ */ ++#define PLACEMOUSE_PATCH 0 ++ ++/* This patch provides a way to move clients up and down inside the client list. ++ * https://dwm.suckless.org/patches/push/ ++ */ ++#define PUSH_PATCH 0 ++ ++/* This patch provides a way to move clients up and down inside the client list, ++ * but does not push up or down into the master area (except that it does not take ++ * nmaster into account). ++ * This takes precedence over the push patch above. ++ * https://dwm.suckless.org/patches/push/ ++ */ ++#define PUSH_NO_MASTER_PATCH 0 ++ ++/* Variant of the named scratchpads patch allowing scratch keys to be added or removed ++ * on demand, allowing multiple scratchpad windows to be toggled into and out of view ++ * in unison, as well as including multi-monitor support. ++ * ++ * https://github.com/bakkeby/patches/wiki/renamedscratchpads ++ */ ++#define RENAMED_SCRATCHPADS_PATCH 0 ++ ++/* Renamed scratchpads option to auto-hide scratchpads when moving to a different tag. ++ * This behaviour is similar to that of the (multiple) scratchpads patch. */ ++#define RENAMED_SCRATCHPADS_AUTO_HIDE_PATCH 0 ++ ++/* Shifts all clients per tag to leftmost unoccupied tags. ++ * ++ * For example, if clients A, B, C are tagged on tags 1, 5, 9 respectively, when ++ * this function is called, they will now be on 1, 2, and 3. The focused client ++ * will also remain focused. ++ * ++ * Clients on multiple tags will be treated as if they only were only on their ++ * leftmost tag, and will be reduced to one tag after the operation is complete. ++ * https://dwm.suckless.org/patches/reorganizetags/ ++ */ ++#define REORGANIZETAGS_PATCH 0 ++ ++/* By default, windows only resize from the bottom right corner. With this ++ * patch the mouse is warped to the nearest corner and you resize from there. ++ * https://dwm.suckless.org/patches/resizecorners/ ++ */ ++#define RESIZECORNERS_PATCH 0 ++ ++/* Practically the same as resizecorners, but the cursor does not warp to corners. ++ * This takes precedence over the resizecorners patch. ++ * https://github.com/bakkeby/patches/blob/master/dwm/dwm-resizepoint-6.2.diff ++ */ ++#define RESIZEPOINT_PATCH 0 ++ ++/* Adds a keyboard shortcut to restart dwm or alternatively by using kill -HUP dwmpid. ++ * Additionally dwm can quit cleanly by using kill -TERM dwmpid. ++ * https://dwm.suckless.org/patches/restartsig/ ++ */ ++#define RESTARTSIG_PATCH 0 ++ ++/* Adds rio-like drawing to resize the selected client. ++ * This depends on an external tool slop being installed. ++ * This patch was backported from instantWM. ++ * https://github.com/bakkeby/patches/blob/master/dwm/dwm-riodraw-6.2.diff ++ */ ++#define RIODRAW_PATCH 0 ++ ++/* This patch let's you rotate through the stack using keyboard shortcuts. ++ * https://dwm.suckless.org/patches/rotatestack/ ++ */ ++#define ROTATESTACK_PATCH 0 ++ ++/* This patch adds rounded corners to client windows in dwm. ++ * You need to uncomment the corresponding line in config.mk to use the -lXext library ++ * when including this patch. You will also want to set "borderpx = 0;" in your config.h. ++ * https://github.com/mitchweaver/suckless/blob/master/dwm/patches/mitch-06-rounded_corners-f04cac6d6e39cd9e3fc4fae526e3d1e8df5e34b2.patch ++ */ ++#define ROUNDED_CORNERS_PATCH 0 ++ ++/* This patch saves size and position of every floating window before it is forced ++ * into tiled mode. If the window is made floating again then the old dimensions ++ * will be restored. ++ * https://dwm.suckless.org/patches/save_floats/ ++ */ ++#define SAVEFLOATS_PATCH 0 ++ ++/* The scratchpad patch allows you to spawn or restore floating terminal windows. ++ * It is typically useful when one need to do some short typing. ++ * ++ * Note that this patch changes TAGMASK to make room for special scratchpad tags, ++ * so ~0 does more than select all tags with this patch. Code that relies on ~0 to ++ * represent all tags should use ~SPTAGMASK instead. ++ * ++ * Upgraded to Christian Tenllado's multiple scratchpad version. ++ * https://lists.suckless.org/hackers/2004/17205.html ++ * https://dwm.suckless.org/patches/scratchpads/ ++ */ ++#define SCRATCHPADS_PATCH 0 ++ ++/* Minor alteration of the above allowing clients to keep their size and position when shown */ ++#define SCRATCHPADS_KEEP_POSITION_AND_SIZE_PATCH 0 ++ ++/* This alternative patch enables a scratchpad feature in dwm similar to the scratchpad ++ * feature in i3wm. ++ * https://github.com/GasparVardanyan/dwm-scratchpad ++ */ ++#define SCRATCHPAD_ALT_1_PATCH 0 ++ ++/* This patch persists some settings across window manager restarts. These include but are not ++ * limited to: ++ * - client's assigned tag(s) on which monitor ++ * - the order of clients ++ * - nmaster ++ * - selected layout ++ * - plus various additions depending on what other patches are used ++ * ++ * The above is not persisted across reboots, however. ++ */ ++#define SEAMLESS_RESTART_PATCH 0 ++ ++/* As opposed to the original patch this only adds a rule option allowing fake fullscreen ++ * to be enabled for applications when they start. This is intended to be used in combination ++ * with the fakefullscreenclient patch and offers no practical functionality without it. ++ * https://dwm.suckless.org/patches/selectivefakefullscreen/ ++ */ ++#define SELECTIVEFAKEFULLSCREEN_PATCH 0 ++ ++/* Allows restarting dwm without the dependency of an external script. ++ * https://dwm.suckless.org/patches/selfrestart/ ++ */ ++#define SELFRESTART_PATCH 0 ++ ++/* Floating windows being sent to another monitor will be centered. ++ * https://dwm.suckless.org/patches/sendmoncenter/ ++ */ ++#define SENDMON_CENTER_PATCH 0 ++ ++/* This patch allow clients to keep focus when being sent to another monitor. ++ * https://github.com/bakkeby/patches/blob/master/dwm/dwm-sendmon_keepfocus-6.2.diff ++ */ ++#define SENDMON_KEEPFOCUS_PATCH 0 ++ ++/* This patch allows border pixels to be changed during runtime. ++ * https://dwm.suckless.org/patches/setborderpx/ ++ */ ++#define SETBORDERPX_PATCH 0 ++ ++/* Combines shifttag and shiftview. Basically moves the window to the next/prev tag and follows it. ++ * Also see the focusadjacenttag patch. ++ * https://dwm.suckless.org/patches/shift-tools/ ++ */ ++#define SHIFTBOTH_PATCH 0 ++ ++/* Swaps all the clients on the current tag with all the client on the next/prev tag. ++ * Depends on the swaptags patch. ++ * https://dwm.suckless.org/patches/shift-tools/ ++ */ ++#define SHIFTSWAPTAGS_PATCH 0 ++ ++/* Moves the current selected client to the adjacent tag. ++ * Also see the focusadjacenttag patch. ++ * https://dwm.suckless.org/patches/shift-tools/ ++ */ ++#define SHIFTTAG_PATCH 0 ++ ++/* Moves the current selected client to the adjacent tag that has at least one client, if none ++ * then it acts as shifttag. ++ * https://dwm.suckless.org/patches/shift-tools/ ++ */ ++#define SHIFTTAGCLIENTS_PATCH 0 ++ ++/* This patch adds keybindings for left and right circular shift through tags. ++ * https://github.com/chau-bao-long/dotfiles/blob/master/suckless/dwm/shiftview.diff ++ */ ++#define SHIFTVIEW_PATCH 0 ++ ++/* This variant of the shiftview patch adds left and right circular shift through tags, ++ * but skips tags where there are no clients. ++ */ ++#define SHIFTVIEW_CLIENTS_PATCH 0 ++ ++/* This patch makes dwm obey even "soft" sizehints for new clients. Any window ++ * that requests a specific initial size will be floated and set to that size. ++ * Unlike with "fixed size" windows, you are able to resize and/or unfloat these ++ * windows freely - only the initial state is affected. ++ * This version of the patch is honestly of limited utility since there are many ++ * clients that will abuse it. ++ * https://dwm.suckless.org/patches/sizehints/ ++ */ ++#define SIZEHINTS_PATCH 0 ++ ++/* This patch makes dwm obey even "soft" sizehints for new clients. This ruled ++ * version is essentially the same patch except it obeys the "isfloating" rule ++ * if it is available in config.h for the given client. ++ * https://dwm.suckless.org/patches/sizehints/ ++ */ ++#define SIZEHINTS_RULED_PATCH 0 ++ ++/* This patch makes dwm obey even "soft" sizehints for new clients. The isfreesize ++ * version is similar to the sizehints ruled patch except it allows you to specify ++ * via client rules which clients this should apply to. Soft sizehints applies by ++ * default to clients that are not ruled, and will be disabled by default for clients ++ * that are. ++ * ++ * Example client rule enabling soft sizehints: ++ * - RULE(.wintype = WTYPE "DIALOG", .isfloating = 1, .isfreesize = 1) ++ * ++ * https://dwm.suckless.org/patches/sizehints/ ++ */ ++#define SIZEHINTS_ISFREESIZE_PATCH 0 ++ ++/* In a multi-head setup monitor 0 is by default the primary screen, with the left and right ++ * screen being monitor 1 and 2 respectively. This patch sorts screens left to right (or ++ * top to bottom in a vertical layout) which aims to address some inconsistencies when it ++ * comes to focusmon, tagmon and similar functionality. ++ * https://www.mail-archive.com/hackers@suckless.org/msg09400.html ++ */ ++#define SORTSCREENS_PATCH 0 ++ ++/* Spawns programs from currently focused client's working directory. ++ * https://dwm.suckless.org/patches/spawn_cwd/ ++ */ ++#define SPAWNCMD_PATCH 0 ++ ++/* This patch provides comprehensive utilities for managing the client stack, providing ++ * keyboard shortcuts for focusing or placing a client at specific positions in the stack. ++ * Note that the default keybindings for this patch have been changed in dwm-flexipatch ++ * due to the many conflicts with other patches. As it provides similar functionality to the ++ * swapfocus patch it also uses the MOD+s shortcut to focus the previously selected client, ++ * thus note a conflict between these two patches. ++ * https://dwm.suckless.org/patches/stacker/ ++ */ ++#define STACKER_PATCH 0 ++ ++/* Steam, and steam windows (games), trigger a ConfigureNotify request every time the window ++ * gets focus. More so, the configure event passed along from Steam tends to have the wrong ++ * x and y co-ordinates which can make the window, if floating, jump around the screen. ++ * ++ * This patch works around this age-old issue by ignoring the x and y co-ordinates for ++ * ConfigureNotify requests relating to Steam windows. ++ * ++ * https://github.com/bakkeby/patches/wiki/steam ++ */ ++#define STEAM_PATCH 0 ++ ++/* Adds toggleable keyboard shortcut to make a client 'sticky', i.e. visible on all tags. ++ * https://dwm.suckless.org/patches/sticky/ ++ */ +#define STICKY_PATCH 1 - - /* This patch adds "window swallowing" to dwm as known from Plan 9's windowing system rio. - * Clients marked with isterminal in config.h swallow a window opened by any child process, -@@ -1205,7 +1205,7 @@ - * - * https://dwm.suckless.org/patches/swallow/ - */ --#define SWALLOW_PATCH 0 ++ ++/* This patch adds "window swallowing" to dwm as known from Plan 9's windowing system rio. ++ * Clients marked with isterminal in config.h swallow a window opened by any child process, ++ * e.g. running xclock in a terminal. Closing the xclock window restores the terminal window ++ * in the current position. ++ * ++ * This patch depends on the following additional libraries: ++ * - libxcb ++ * - Xlib-libxcb ++ * - xcb-res ++ * ++ * You need to uncomment the corresponding line in config.mk to use the above libraries when ++ * including this patch. ++ * ++ * https://dwm.suckless.org/patches/swallow/ ++ */ +#define SWALLOW_PATCH 1 - - /* This patch depends on the pertag patch and makes it possible to switch focus with a single - * shortcut (MOD+s) instead of having to think if you should use mod-j or mod-k for reaching -@@ -1403,7 +1403,7 @@ - * when the mouse cursor is (a) on a different screen or (b) on top of a different window. - * https://dwm.suckless.org/patches/warp/ - */ --#define WARP_PATCH 0 ++ ++/* This patch depends on the pertag patch and makes it possible to switch focus with a single ++ * shortcut (MOD+s) instead of having to think if you should use mod-j or mod-k for reaching ++ * the previously used window. ++ * https://dwm.suckless.org/patches/swapfocus/ ++ */ ++#define SWAPFOCUS_PATCH 0 ++ ++/* This patch allows swapping the contents of the currently selected tag with another tag using ++ * keyboard shortcuts. ++ * https://dwm.suckless.org/patches/swaptags/ ++ */ ++#define SWAPTAGS_PATCH 0 ++ ++/* Switch focus between the master and stack columns using a single keybinding. ++ * https://dwm.suckless.org/patches/switchcol/ ++ */ ++#define SWITCHCOL_PATCH 0 ++ ++/* By default dwm allow you to set application specific rules so that you can have your browser, ++ * for example, start up on tag 9 optionally on a given monitor when you open your browser it is ++ * then automatically moved to the configured tag, but you have to manually enable the tag to see ++ * the newly opened application. ++ * This patch adds an extra configuration option for individual rules where: ++ * 0 is default behaviour ++ * 1 automatically moves you to the tag of the newly opened application and ++ * 2 enables the tag of the newly opened application in addition to your existing enabled tags ++ * 3 as 1, but closing that window reverts the view back to what it was previously (*) ++ * 4 as 2, but closing that window reverts the view back to what it was previously (*) ++ * ++ * (*) except if the client has been moved between tags or to another monitor ++ * ++ * https://github.com/bakkeby/patches/blob/master/dwm/dwm-switchtag-6.2.diff ++ * Also see https://dwm.suckless.org/patches/switchtotag ++ */ ++#define SWITCHTAG_PATCH 0 ++ ++/* This patch transforms the monocle layout into a "tabbed" layout if more than one window is ++ * present on the monocle view. This patch has been added for demonstration purposes only and has ++ * limited compatibility with other patches. It will conflict space-wise with a second bar. ++ * Note that fancybar, awesomebar, bartabgroups and similar patches make the tab patch redundant. ++ * https://dwm.suckless.org/patches/tab/ ++ */ ++#define TAB_PATCH 0 ++ ++/* Adds keyboard shortcuts to move all (or only floating) windows from one tag to another. ++ * https://dwm.suckless.org/patches/tagall/ ++ */ ++#define TAGALL_PATCH 0 ++ ++/* This patch allows you to move all visible windows on a monitor to an adjacent monitor. ++ * https://github.com/bakkeby/patches/blob/master/dwm/dwm-tagallmon-6.2.diff ++ */ ++#define TAGALLMON_PATCH 0 ++ ++/* This patch makes new clients attach into the stack area when you toggle a new tag into ++ * view. This means your master area will remain unchanged when toggling views. ++ * The allmaster patch will cause all clients in the master area to be left alone. This patch ++ * takes precedence over the onemaster tagintostack patch. ++ * https://dwm.suckless.org/patches/tagintostack/ ++ */ ++#define TAGINTOSTACK_ALLMASTER_PATCH 0 ++ ++/* This patch makes new clients attach into the stack area when you toggle a new tag into ++ * view. This means your master area will remain unchanged when toggling views. ++ * The onemaster patch will cause the first client in the master area to be left alone. ++ * https://dwm.suckless.org/patches/tagintostack/ ++ */ ++#define TAGINTOSTACK_ONEMASTER_PATCH 0 ++ ++/* If you try to send a fullscreen window to an adjacent monitor using tagmon then ++ * the window is moved behind the scenes, but it remains in fullscreen on the original ++ * monitor until you exit fullscreen view (at which point it will appear on the adjacent ++ * monitor). This patch allows a fullscreen window to be moved to an adjacent monitor ++ * while remaining in fullscreen. ++ * https://github.com/bakkeby/patches/blob/master/dwm/dwm-tagmonfixfs-6.2.diff ++ */ ++#define TAGMONFIXFS_PATCH 0 ++ ++/* Add functions and keybindings to tag a window to a desired tag on the next (right) ++ * or previous (left) monitor from the currently selected monitor. ++ * https://dwm.suckless.org/patches/tagothermonitor/ ++ */ ++#define TAGOTHERMONITOR_PATCH 0 ++ ++/* This patch allows you to swap all visible windows on one monitor with those of an ++ * adjacent monitor. ++ * https://github.com/bakkeby/patches/blob/master/dwm/dwm-tagswapmon-6.2.diff ++ */ ++#define TAGSWAPMON_PATCH 0 ++ ++/* Sync tag actions across all monitors. ++ * This is comparable to a sort of pseudo-desktop environment. ++ * Also refer to the desktop patch: ++ * https://github.com/bakkeby/patches/blob/master/dwm/dwm-desktop-6.3.diff ++ */ ++#define TAGSYNC_PATCH 0 ++ ++/* This patch can be useful to the touchpad users because it allows to ++ * resize windows using Mod + two-finger scroll. It is useful when ++ * two-finger scrolling is configured in libinput. ++ * https://dwm.suckless.org/patches/tapresize/ ++ */ ++#define TAPRESIZE_PATCH 0 ++ ++/* This patch allows you to toggle fullscreen on and off using a single shortcut key. ++ * https://github.com/bakkeby/patches/blob/master/dwm/dwm-togglefullscreen-6.2.diff ++ */ ++#define TOGGLEFULLSCREEN_PATCH 0 ++ ++/* This patch allows for the bar position (top or bottom) to be toggled during runtime. ++ * https://dwm.suckless.org/patches/toggletopbar/ ++ */ ++#define TOGGLETOPBAR_PATCH 0 ++ ++/* Minor patch that lets you use the same keyboard shortcut to toggle to the previous layout if the ++ * designated layout is already active. ++ * ++ * This allows you to use e.g. MOD+m to change to the monocle layout and use the same keybinding to ++ * toggle back to what it was previously. The default behaviour in dwm forces you to use either ++ * MOD+space or MOD+t to change back to tiled layout. ++ * ++ * https://github.com/bakkeby/patches/wiki/togglelayout ++ */ ++ ++#define TOGGLELAYOUT_PATCH 0 ++ ++/* Minor patch that lets you use the same keyboard shortcut to toggle to the previous tag if the ++ * designated tag is already active. ++ * ++ * This allows you to use e.g. MOD+4 to quickly view the 4th tag and use the same keybinding to ++ * toggle back to what it was previously. The default behaviour in dwm forces you to use either ++ * MOD+tab or MOD+1 to change back to the previous tag. ++ * ++ * Idea ref. ++ * https://www.reddit.com/r/suckless/comments/ik27vd/key_toggle_between_next_and_previous_tag_dwm/ ++ * https://github.com/bakkeby/patches/wiki/toggletag ++ */ ++#define TOGGLETAG_PATCH 0 ++ ++/* Lets you transfer the currently focused client between the master and stack area ++ * while increasing or decreasing the master area (nmaster) accordingly. ++ * https://dwm.suckless.org/patches/transfer/ ++ */ ++#define TRANSFER_PATCH 0 ++ ++/* Lets you transfer all clients between the master and stack area ++ * while increasing or decreasing the master area (nmaster) accordingly. ++ * https://dwm.suckless.org/patches/transfer/ ++ */ ++#define TRANSFER_ALL_PATCH 0 ++ ++/* This patch resets isfloating on any visible windows that have it set. ++ * Optionally also applies a layout. ++ * https://dwm.suckless.org/patches/unfloatvisible/ ++ */ ++#define UNFLOATVISIBLE_PATCH 0 ++ ++/* This patch adds a client rule that allows for windows that do not specify the override-redirect ++ * to not be managed by the window manager. This can be useful for external bars, widgets, ++ * launchers, docks, desktop icons and more. ++ * https://github.com/bakkeby/patches/wiki/unmanaged ++ */ ++#define UNMANAGED_PATCH 0 ++ ++/* This patch adds configurable gaps between windows differentiating between outer, inner, ++ * horizontal and vertical gaps. ++ * https://github.com/bakkeby/patches/blob/master/dwm/dwm-vanitygaps-6.2.diff ++ * https://github.com/bakkeby/patches/blob/master/dwm/dwm-cfacts-vanitygaps-6.2.diff ++ */ ++#define VANITYGAPS_PATCH 0 ++ ++/* This patch adds outer gaps for the monocle layout. ++ * Most gaps patches tries to avoid gaps on the monocle layout, as it is often used as a ++ * fullscreen mode, hence this is enabled separately from the main vanitygaps patch. ++ */ ++#define VANITYGAPS_MONOCLE_PATCH 0 ++ ++/* By default MOD+Tab will take the user back to the previous tag only. If the user keeps ++ * using MOD+Tab then the view will switch back and forth between the current and previous tag. ++ * This patch allows dwm to keep a longer history of previous tag changes such that MOD+Tab can ++ * be pressed multiple times to go further back to earlier tag selections. ++ * ++ * The number of history elements is defined by the NUMVIEWHIST macro in dwm.c and defaults to ++ * the number of tags in the system. ++ */ ++#define VIEW_HISTORY_PATCH 0 ++ ++/* Follow a window to the tag it is being moved to. ++ * https://dwm.suckless.org/patches/viewontag/ ++ */ ++#define VIEWONTAG_PATCH 0 ++ ++/* This patch warps the mouse cursor to the center of the currently focused window or screen ++ * when the mouse cursor is (a) on a different screen or (b) on top of a different window. ++ * https://dwm.suckless.org/patches/warp/ ++ */ +#define WARP_PATCH 1 - - /* Sometimes a single application opens different windows depending on the task - * at hand and this is often reflected in the WM_WINDOW_ROLE(STRING) x property. ++ ++/* Sometimes a single application opens different windows depending on the task ++ * at hand and this is often reflected in the WM_WINDOW_ROLE(STRING) x property. ++ * This patch adds the role field to the rule configuration so that one can ++ * differentiate between, say, Firefox "browser" vs "Preferences" vs "Manager" ++ * or Google-chrome "browser" vs "pop-up". ++ * https://github.com/bakkeby/patches/blob/master/dwm/dwm-windowrolerule-6.2.diff ++ */ ++#define WINDOWROLERULE_PATCH 0 ++ ++/* The winview patch allows switching the view to that of a given client from the all-window ++ * view (Mod-0) using a keyboard shortcut. ++ * http://dwm.suckless.org/patches/winview/ ++ */ ++#define WINVIEW_PATCH 0 ++ ++/* Remember keyboard layout per client. ++ * It is recommended that you configure xkb before using this patch as described in ++ * https://www.x.org/archive/X11R7.5/doc/input/XKB-Config.html ++ * https://dwm.suckless.org/patches/xkb/ ++ */ ++#define XKB_PATCH 0 ++ ++/* Allows dwm to read colors from xrdb (.Xresources) during runtime. Compatible with ++ * the float border color, awesomebar, urgentborder and titlecolor patches. ++ * https://dwm.suckless.org/patches/xrdb/ ++ */ ++#define XRDB_PATCH 0 ++ ++/* Simple patch that allows floating windows to be zoomed into the master stack position. ++ * https://www.reddit.com/r/suckless/comments/ie5fe3/zoomfloating_my_own_simple_original_patch/ ++ */ ++#define ZOOMFLOATING_PATCH 0 ++ ++/* The zoomswap patch allows a master and a stack window to swap places ++ * rather than every window on the screen changing position. ++ * https://dwm.suckless.org/patches/zoomswap/ ++ */ ++#define ZOOMSWAP_PATCH 0 ++ ++/** ++ * Layouts ++ */ ++ ++/* Bottomstack layout. ++ * https://dwm.suckless.org/patches/bottomstack/ ++ */ ++#define BSTACK_LAYOUT 0 ++ ++/* Bottomstack horizontal layout. ++ * https://dwm.suckless.org/patches/bottomstack/ ++ */ ++#define BSTACKHORIZ_LAYOUT 0 ++ ++/* Centered master layout. ++ * https://dwm.suckless.org/patches/centeredmaster/ ++ */ ++#define CENTEREDMASTER_LAYOUT 0 ++ ++/* Centered floating master layout. ++ * https://dwm.suckless.org/patches/centeredmaster/ ++ */ ++#define CENTEREDFLOATINGMASTER_LAYOUT 0 ++ ++/* Same as the default tile layout except clients in the master area are arranged in ++ * columns (i.e. left to right). ++ * https://dwm.suckless.org/patches/columns/ ++ */ ++#define COLUMNS_LAYOUT 0 ++ ++/* Deck layout. ++ * https://dwm.suckless.org/patches/deck/ ++ */ ++#define DECK_LAYOUT 0 ++ ++/* Fibonacci dwindle layout. ++ * https://dwm.suckless.org/patches/fibonacci/ ++ */ ++#define FIBONACCI_DWINDLE_LAYOUT 0 ++ ++/* Fibonacci spiral layout. ++ * https://dwm.suckless.org/patches/fibonacci/ ++ */ ++#define FIBONACCI_SPIRAL_LAYOUT 0 ++ ++/* Flextile deluxe layout. ++ * A revamped, more flexible, and over-the-top version of the original flextile layout. ++ * https://dwm.suckless.org/patches/flextile/ (original) ++ */ ++#define FLEXTILE_DELUXE_LAYOUT 0 ++ ++/* Gappless grid layout. ++ * https://dwm.suckless.org/patches/gaplessgrid/ ++ */ ++#define GAPPLESSGRID_LAYOUT 0 ++ ++/* Gridmode (grid) layout. ++ * https://dwm.suckless.org/patches/gridmode/ ++ */ ++#define GRIDMODE_LAYOUT 0 ++ ++/* Horizontal grid (horizgrid) layout. ++ * https://dwm.suckless.org/patches/horizgrid/ ++ */ ++#define HORIZGRID_LAYOUT 0 ++ ++/* Grid layout where nmaster controls the number of rows. ++ * https://dwm.suckless.org/patches/nrowgrid/ ++ */ ++#define NROWGRID_LAYOUT 0 ++ ++/* The default tile layout. ++ * This can be optionally disabled in favour of other layouts. ++ */ ++#define TILE_LAYOUT 1 ++ ++/* Monocle layout (default). ++ * This can be optionally disabled in favour of other layouts. ++ */ ++#define MONOCLE_LAYOUT 1 diff --git a/st-flexipatched.diff b/st-flexipatched.diff index faa8057..f450c42 100644 --- a/st-flexipatched.diff +++ b/st-flexipatched.diff @@ -1,27 +1,187 @@ -diff '--color=auto' -Nu a/config.def.h b/config.def.h ---- a/config.def.h 2024-12-28 23:51:30.003295812 -0600 -+++ b/config.def.h 2024-12-28 23:53:26.293299467 -0600 -@@ -5,7 +5,7 @@ - * - * font: see http://freedesktop.org/software/fontconfig/fontconfig-user.html - */ --static char *font = "Liberation Mono:pixelsize=12:antialias=true:autohint=true"; +diff '--color=auto' -Nu a/config.h b/config.h +--- a/config.h 1969-12-31 18:00:00.000000000 -0600 ++++ b/config.h 2025-01-04 22:51:50.039021822 -0600 +@@ -0,0 +1,796 @@ ++/* See LICENSE file for copyright and license details. */ ++ ++/* ++ * appearance ++ * ++ * font: see http://freedesktop.org/software/fontconfig/fontconfig-user.html ++ */ +static char *font = "JetBrainsMono:size=10"; - #if FONT2_PATCH - /* Spare fonts */ - static char *font2[] = { -@@ -178,27 +178,31 @@ - /* Terminal colors (16 first used in escape sequence) */ - static const char *colorname[] = { - /* 8 normal colors */ -- "black", -- "red3", -- "green3", -- "yellow3", -- "blue2", -- "magenta3", -- "cyan3", -- "gray90", ++#if FONT2_PATCH ++/* Spare fonts */ ++static char *font2[] = { ++/* "Inconsolata for Powerline:pixelsize=12:antialias=true:autohint=true", */ ++/* "Hack Nerd Font Mono:pixelsize=11:antialias=true:autohint=true", */ ++}; ++#endif // FONT2_PATCH ++ ++#if BACKGROUND_IMAGE_PATCH ++/* ++ * background image ++ * expects farbfeld format ++ * pseudo transparency fixes coordinates to the screen origin ++ */ ++static const char *bgfile = "/path/to/image.ff"; ++static const int pseudotransparency = 0; ++#endif // BACKGROUND_IMAGE_PATCH ++ ++#if RELATIVEBORDER_PATCH ++/* borderperc: percentage of cell width to use as a border ++ * 0 = no border, 100 = border width is same as cell width */ ++int borderperc = 20; ++#else ++static int borderpx = 2; ++#endif // RELATIVEBORDER_PATCH ++ ++#if OPENURLONCLICK_PATCH ++/* modkey options: ControlMask, ShiftMask or XK_ANY_MOD */ ++static uint url_opener_modkey = XK_ANY_MOD; ++static char *url_opener = "xdg-open"; ++#endif // OPENURLONCLICK_PATCH ++ ++/* ++ * What program is execed by st depends of these precedence rules: ++ * 1: program passed with -e ++ * 2: scroll and/or utmp ++ * 3: SHELL environment variable ++ * 4: value of shell in /etc/passwd ++ * 5: value of shell in config.h ++ */ ++static char *shell = "/bin/sh"; ++char *utmp = NULL; ++/* scroll program: to enable use a string like "scroll" */ ++char *scroll = NULL; ++char *stty_args = "stty raw pass8 nl -echo -iexten -cstopb 38400"; ++ ++/* identification sequence returned in DA and DECID */ ++#if SIXEL_PATCH ++char *vtiden = "\033[?62;4c"; /* VT200 family (62) with sixel (4) */ ++ ++/* sixel rgb byte order: LSBFirst or MSBFirst */ ++int const sixelbyteorder = LSBFirst; ++#else ++char *vtiden = "\033[?6c"; ++#endif ++ ++/* Kerning / character bounding-box multipliers */ ++static float cwscale = 1.0; ++static float chscale = 1.0; ++ ++/* ++ * word delimiter string ++ * ++ * More advanced example: L" `'\"()[]{}" ++ */ ++wchar_t *worddelimiters = L" "; ++ ++#if KEYBOARDSELECT_PATCH && REFLOW_PATCH ++/* Word delimiters for short and long jumps in the keyboard select patch */ ++wchar_t *kbds_sdelim = L"!\"#$%&'()*+,-./:;<=>?@[\\]^`{|}~ "; ++wchar_t *kbds_ldelim = L" "; ++#endif // KEYBOARDSELECT_PATCH ++ ++/* selection timeouts (in milliseconds) */ ++static unsigned int doubleclicktimeout = 300; ++static unsigned int tripleclicktimeout = 600; ++ ++/* alt screens */ ++int allowaltscreen = 1; ++ ++/* allow certain non-interactive (insecure) window operations such as: ++ setting the clipboard text */ ++int allowwindowops = 0; ++ ++/* ++ * draw latency range in ms - from new content/keypress/etc until drawing. ++ * within this range, st draws when content stops arriving (idle). mostly it's ++ * near minlatency, but it waits longer for slow updates to avoid partial draw. ++ * low minlatency will tear/flicker more, as it can "detect" idle too early. ++ */ ++static double minlatency = 2; ++static double maxlatency = 33; ++ ++#if SYNC_PATCH ++/* ++ * Synchronized-Update timeout in ms ++ * https://gitlab.com/gnachman/iterm2/-/wikis/synchronized-updates-spec ++ */ ++static uint su_timeout = 200; ++#endif // SYNC_PATCH ++ ++/* ++ * blinking timeout (set to 0 to disable blinking) for the terminal blinking ++ * attribute. ++ */ ++static unsigned int blinktimeout = 800; ++ ++/* ++ * thickness of underline and bar cursors ++ */ ++static unsigned int cursorthickness = 2; ++ ++#if HIDECURSOR_PATCH ++/* Hide the X cursor whenever a key is pressed. 0: off, 1: on */ ++int hidecursor = 1; ++#endif // HIDECURSOR_PATCH ++ ++#if BOXDRAW_PATCH ++/* ++ * 1: render most of the lines/blocks characters without using the font for ++ * perfect alignment between cells (U2500 - U259F except dashes/diagonals). ++ * Bold affects lines thickness if boxdraw_bold is not 0. Italic is ignored. ++ * 0: disable (render all U25XX glyphs normally from the font). ++ */ ++const int boxdraw = 0; ++const int boxdraw_bold = 0; ++ ++/* braille (U28XX): 1: render as adjacent "pixels", 0: use font */ ++const int boxdraw_braille = 0; ++#endif // BOXDRAW_PATCH ++ ++/* ++ * bell volume. It must be a value between -100 and 100. Use 0 for disabling ++ * it ++ */ ++static int bellvolume = 0; ++ ++/* default TERM value */ ++char *termname = "st-256color"; ++ ++/* ++ * spaces per tab ++ * ++ * When you are changing this value, don't forget to adapt the »it« value in ++ * the st.info and appropriately install the st.info in the environment where ++ * you use this st version. ++ * ++ * it#$tabspaces, ++ * ++ * Secondly make sure your kernel is not expanding tabs. When running `stty ++ * -a` »tab0« should appear. You can tell the terminal to not expand tabs by ++ * running following command: ++ * ++ * stty tabs ++ */ ++unsigned int tabspaces = 8; ++ ++#if ALPHA_PATCH ++/* bg opacity */ ++float alpha = 0.8; ++#if ALPHA_GRADIENT_PATCH ++float grad_alpha = 0.54; //alpha value that'll change ++float stat_alpha = 0.46; //constant alpha value that'll get added to grad_alpha ++#endif // ALPHA_GRADIENT_PATCH ++#if ALPHA_FOCUS_HIGHLIGHT_PATCH ++float alphaUnfocused = 0.6; ++#endif // ALPHA_FOCUS_HIGHLIGHT_PATCH ++#endif // ALPHA_PATCH ++ ++/* Terminal colors (16 first used in escape sequence) */ ++static const char *colorname[] = { ++ /* 8 normal colors */ + [0] = "#414b50", /* black */ + [1] = "#e67e80", /* red */ + [2] = "#a7c080", /* green */ @@ -30,16 +190,8 @@ diff '--color=auto' -Nu a/config.def.h b/config.def.h + [5] = "#d699b6", /* magenta */ + [6] = "#83c092", /* cyan */ + [7] = "#d3c6aa", /* white */ - - /* 8 bright colors */ -- "gray50", -- "red", -- "green", -- "yellow", -- "#5c5cff", -- "magenta", -- "cyan", -- "white", ++ ++ /* 8 bright colors */ + [8] = "#475258", /* black */ + [9] = "#e67e80", /* red */ + [10] = "#a7c080", /* green */ @@ -48,53 +200,607 @@ diff '--color=auto' -Nu a/config.def.h b/config.def.h + [13] = "#d699b6", /* magenta */ + [14] = "#83c092", /* cyan */ + [15] = "#d3c6aa", /* white */ - - [255] = 0, - ++ ++ [255] = 0, ++ + /* special colors */ + [256] = "#272e33", /* background */ + [257] = "#d3c6aa", /* foreground */ + - /* more colors can be added after 255 to use with DefaultXX */ - "#add8e6", /* 256 -> cursor */ - "#555555", /* 257 -> rev cursor*/ -@@ -215,10 +219,10 @@ - unsigned int defaultbg = 0; - unsigned int bg = 17, bgUnfocused = 16; - #else --unsigned int defaultbg = 258; ++ /* more colors can be added after 255 to use with DefaultXX */ ++ "#add8e6", /* 256 -> cursor */ ++ "#555555", /* 257 -> rev cursor*/ ++ "#000000", /* 258 -> bg */ ++ "#e5e5e5", /* 259 -> fg */ ++}; ++ ++ ++/* ++ * Default colors (colorname index) ++ * foreground, background, cursor, reverse cursor ++ */ ++#if ALPHA_PATCH && ALPHA_FOCUS_HIGHLIGHT_PATCH ++unsigned int defaultbg = 0; ++unsigned int bg = 17, bgUnfocused = 16; ++#else +unsigned int defaultbg = 256; - #endif // ALPHA_FOCUS_HIGHLIGHT_PATCH --unsigned int defaultfg = 259; --unsigned int defaultcs = 256; ++#endif // ALPHA_FOCUS_HIGHLIGHT_PATCH +unsigned int defaultfg = 257; +unsigned int defaultcs = 257; - unsigned int defaultrcs = 257; - #if SELECTION_COLORS_PATCH - unsigned int selectionfg = 258; -@@ -413,6 +417,8 @@ - { TERMMOD, XK_Prior, zoom, {.f = +1} }, - { TERMMOD, XK_Next, zoom, {.f = -1} }, - { TERMMOD, XK_Home, zoomreset, {.f = 0} }, ++unsigned int defaultrcs = 257; ++#if SELECTION_COLORS_PATCH ++unsigned int selectionfg = 258; ++unsigned int selectionbg = 259; ++/* If 0 use selectionfg as foreground in order to have a uniform foreground-color */ ++/* Else if 1 keep original foreground-color of each cell => more colors :) */ ++static int ignoreselfg = 1; ++#endif // SELECTION_COLORS_PATCH ++#if KEYBOARDSELECT_PATCH && REFLOW_PATCH ++/* Foreground and background color of search results */ ++unsigned int highlightfg = 15; ++unsigned int highlightbg = 160; ++#endif // KEYBOARDSELECT_PATCH ++ ++#if BLINKING_CURSOR_PATCH ++/* ++ * https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h4-Functions-using-CSI-_-ordered-by-the-final-character-lparen-s-rparen:CSI-Ps-SP-q.1D81 ++ * Default style of cursor ++ * 0: Blinking block ++ * 1: Blinking block (default) ++ * 2: Steady block ("â–ˆ") ++ * 3: Blinking underline ++ * 4: Steady underline ("_") ++ * 5: Blinking bar ++ * 6: Steady bar ("|") ++ * 7: Blinking st cursor ++ * 8: Steady st cursor ++ */ ++static unsigned int cursorstyle = 1; ++static Rune stcursor = 0x2603; /* snowman (U+2603) */ ++#else ++/* ++ * Default shape of cursor ++ * 2: Block ("█") ++ * 4: Underline ("_") ++ * 6: Bar ("|") ++ * 7: Snowman ("☃") ++ */ ++static unsigned int cursorshape = 2; ++#endif // BLINKING_CURSOR_PATCH ++ ++/* ++ * Default columns and rows numbers ++ */ ++ ++static unsigned int cols = 80; ++static unsigned int rows = 24; ++ ++#if ANYGEOMETRY_PATCH ++/* ++ * Whether to use pixel geometry or cell geometry ++ */ ++ ++static Geometry geometry = CellGeometry; // or PixelGeometry to use the below size ++static unsigned int width = 564; ++static unsigned int height = 364; ++#endif // ANYGEOMETRY_PATCH ++ ++#if THEMED_CURSOR_PATCH ++/* ++ * Default shape of the mouse cursor ++ */ ++static char* mouseshape = "xterm"; ++#else ++/* ++ * Default colour and shape of the mouse cursor ++ */ ++static unsigned int mouseshape = XC_xterm; ++static unsigned int mousefg = 7; ++static unsigned int mousebg = 0; ++#endif // THEMED_CURSOR_PATCH ++ ++/* ++ * Color used to display font attributes when fontconfig selected a font which ++ * doesn't match the ones requested. ++ */ ++static unsigned int defaultattr = 11; ++ ++#if XRESOURCES_PATCH ++/* ++ * Xresources preferences to load at startup ++ */ ++ResourcePref resources[] = { ++ { "font", STRING, &font }, ++ { "color0", STRING, &colorname[0] }, ++ { "color1", STRING, &colorname[1] }, ++ { "color2", STRING, &colorname[2] }, ++ { "color3", STRING, &colorname[3] }, ++ { "color4", STRING, &colorname[4] }, ++ { "color5", STRING, &colorname[5] }, ++ { "color6", STRING, &colorname[6] }, ++ { "color7", STRING, &colorname[7] }, ++ { "color8", STRING, &colorname[8] }, ++ { "color9", STRING, &colorname[9] }, ++ { "color10", STRING, &colorname[10] }, ++ { "color11", STRING, &colorname[11] }, ++ { "color12", STRING, &colorname[12] }, ++ { "color13", STRING, &colorname[13] }, ++ { "color14", STRING, &colorname[14] }, ++ { "color15", STRING, &colorname[15] }, ++ { "background", STRING, &colorname[258] }, ++ { "foreground", STRING, &colorname[259] }, ++ { "cursorColor", STRING, &colorname[256] }, ++ { "termname", STRING, &termname }, ++ { "shell", STRING, &shell }, ++ { "minlatency", INTEGER, &minlatency }, ++ { "maxlatency", INTEGER, &maxlatency }, ++ { "blinktimeout", INTEGER, &blinktimeout }, ++ { "bellvolume", INTEGER, &bellvolume }, ++ { "tabspaces", INTEGER, &tabspaces }, ++ #if RELATIVEBORDER_PATCH ++ { "borderperc", INTEGER, &borderperc }, ++ #else ++ { "borderpx", INTEGER, &borderpx }, ++ #endif // RELATIVEBORDER_PATCH ++ { "cwscale", FLOAT, &cwscale }, ++ { "chscale", FLOAT, &chscale }, ++ #if ALPHA_PATCH ++ { "alpha", FLOAT, &alpha }, ++ #endif // ALPHA_PATCH ++ #if ALPHA_FOCUS_HIGHLIGHT_PATCH ++ { "alphaUnfocused",FLOAT, &alphaUnfocused }, ++ #endif // ALPHA_FOCUS_HIGHLIGHT_PATCH ++ #if KEYBOARDSELECT_PATCH && REFLOW_PATCH ++ { "highlightfg", INTEGER, &highlightfg }, ++ { "highlightbg", INTEGER, &highlightbg }, ++ #endif // KEYBOARDSELECT_PATCH ++}; ++#endif // XRESOURCES_PATCH ++ ++/* ++ * Force mouse select/shortcuts while mask is active (when MODE_MOUSE is set). ++ * Note that if you want to use ShiftMask with selmasks, set this to an other ++ * modifier, set to 0 to not use it. ++ */ ++static uint forcemousemod = ShiftMask; ++ ++/* ++ * Internal mouse shortcuts. ++ * Beware that overloading Button1 will disable the selection. ++ */ ++static MouseShortcut mshortcuts[] = { ++ /* mask button function argument release screen */ ++ #if CLIPBOARD_PATCH ++ { XK_ANY_MOD, Button2, clippaste, {.i = 0}, 1 }, ++ #else ++ { XK_ANY_MOD, Button2, selpaste, {.i = 0}, 1 }, ++ #endif // CLIPBOARD_PATCH ++ #if SCROLLBACK_MOUSE_PATCH ++ { ShiftMask, Button4, kscrollup, {.i = 1}, 0, S_PRI}, ++ { ShiftMask, Button5, kscrolldown, {.i = 1}, 0, S_PRI}, ++ #elif UNIVERSCROLL_PATCH ++ { XK_ANY_MOD, Button4, ttysend, {.s = "\033[5;2~"}, 0, S_PRI }, ++ { XK_ANY_MOD, Button5, ttysend, {.s = "\033[6;2~"}, 0, S_PRI }, ++ #else ++ { ShiftMask, Button4, ttysend, {.s = "\033[5;2~"} }, ++ { ShiftMask, Button5, ttysend, {.s = "\033[6;2~"} }, ++ #endif // SCROLLBACK_MOUSE_PATCH ++ #if SCROLLBACK_MOUSE_ALTSCREEN_PATCH || REFLOW_PATCH ++ { XK_ANY_MOD, Button4, kscrollup, {.i = 1}, 0, S_PRI }, ++ { XK_ANY_MOD, Button5, kscrolldown, {.i = 1}, 0, S_PRI }, ++ { XK_ANY_MOD, Button4, ttysend, {.s = "\031"}, 0, S_ALT }, ++ { XK_ANY_MOD, Button5, ttysend, {.s = "\005"}, 0, S_ALT }, ++ #else ++ { XK_ANY_MOD, Button4, ttysend, {.s = "\031"} }, ++ { XK_ANY_MOD, Button5, ttysend, {.s = "\005"} }, ++ #endif // SCROLLBACK_MOUSE_ALTSCREEN_PATCH ++}; ++ ++/* Internal keyboard shortcuts. */ ++#define MODKEY Mod1Mask ++#define TERMMOD (ControlMask|ShiftMask) ++ ++#if EXTERNALPIPE_PATCH // example command ++static char *openurlcmd[] = { "/bin/sh", "-c", ++ "xurls | dmenu -l 10 -w $WINDOWID | xargs -r open", ++ "externalpipe", NULL }; ++ ++#if EXTERNALPIPEIN_PATCH // example command ++static char *setbgcolorcmd[] = { "/bin/sh", "-c", ++ "printf '\033]11;#008000\007'", ++ "externalpipein", NULL }; ++#endif // EXTERNALPIPEIN_PATCH ++#endif // EXTERNALPIPE_PATCH ++ ++static Shortcut shortcuts[] = { ++ /* mask keysym function argument screen */ ++ { XK_ANY_MOD, XK_Break, sendbreak, {.i = 0} }, ++ { ControlMask, XK_Print, toggleprinter, {.i = 0} }, ++ { ShiftMask, XK_Print, printscreen, {.i = 0} }, ++ { XK_ANY_MOD, XK_Print, printsel, {.i = 0} }, ++ { TERMMOD, XK_Prior, zoom, {.f = +1} }, ++ { TERMMOD, XK_Next, zoom, {.f = -1} }, ++ { TERMMOD, XK_Home, zoomreset, {.f = 0} }, + { TERMMOD, XK_L, zoom, {.f = +1} }, + { TERMMOD, XK_H, zoom, {.f = -1} }, - { TERMMOD, XK_C, clipcopy, {.i = 0} }, - { TERMMOD, XK_V, clippaste, {.i = 0} }, - #if ALPHA_PATCH -@@ -428,8 +434,8 @@ - { MODKEY, XK_Return, fullscreen, {.i = 0} }, - #endif // FULLSCREEN_PATCH - #if SCROLLBACK_PATCH -- { ShiftMask, XK_Page_Up, kscrollup, {.i = -1}, S_PRI }, -- { ShiftMask, XK_Page_Down, kscrolldown, {.i = -1}, S_PRI }, ++ { TERMMOD, XK_C, clipcopy, {.i = 0} }, ++ { TERMMOD, XK_V, clippaste, {.i = 0} }, ++ #if ALPHA_PATCH ++ { TERMMOD, XK_O, changealpha, {.f = +0.05} }, ++ { TERMMOD, XK_P, changealpha, {.f = -0.05} }, ++ #if ALPHA_FOCUS_HIGHLIGHT_PATCH ++ //{ TERMMOD, XK_, changealphaunfocused, {.f = +0.05} }, ++ //{ TERMMOD, XK_, changealphaunfocused, {.f = -0.05} }, ++ #endif // ALPHA_FOCUS_HIGHLIGHT_PATCH ++ #endif // ALPHA_PATCH ++ #if FULLSCREEN_PATCH ++ { XK_NO_MOD, XK_F11, fullscreen, {.i = 0} }, ++ { MODKEY, XK_Return, fullscreen, {.i = 0} }, ++ #endif // FULLSCREEN_PATCH ++ #if SCROLLBACK_PATCH + { TERMMOD, XK_K, kscrollup, {.i = 1}, S_PRI }, + { TERMMOD, XK_J, kscrolldown, {.i = 1}, S_PRI }, - #endif // SCROLLBACK_PATCH - #if CLIPBOARD_PATCH - { TERMMOD, XK_Y, clippaste, {.i = 0} }, ++ #endif // SCROLLBACK_PATCH ++ #if CLIPBOARD_PATCH ++ { TERMMOD, XK_Y, clippaste, {.i = 0} }, ++ { ShiftMask, XK_Insert, clippaste, {.i = 0} }, ++ #else ++ { TERMMOD, XK_Y, selpaste, {.i = 0} }, ++ { ShiftMask, XK_Insert, selpaste, {.i = 0} }, ++ #endif // CLIPBOARD_PATCH ++ { TERMMOD, XK_Num_Lock, numlock, {.i = 0} }, ++ #if COPYURL_PATCH || COPYURL_HIGHLIGHT_SELECTED_URLS_PATCH ++ { MODKEY, XK_l, copyurl, {.i = 0} }, ++ #endif // COPYURL_PATCH ++ #if OPENCOPIED_PATCH ++ { MODKEY, XK_o, opencopied, {.v = "xdg-open"} }, ++ #endif // OPENCOPIED_PATCH ++ #if NEWTERM_PATCH ++ { TERMMOD, XK_Return, newterm, {.i = 0} }, ++ #endif // NEWTERM_PATCH ++ #if EXTERNALPIPE_PATCH ++ { TERMMOD, XK_U, externalpipe, { .v = openurlcmd } }, ++ #if EXTERNALPIPEIN_PATCH ++ { TERMMOD, XK_M, externalpipein, { .v = setbgcolorcmd } }, ++ #endif // EXTERNALPIPEIN_PATCH ++ #endif // EXTERNALPIPE_PATCH ++ #if KEYBOARDSELECT_PATCH ++ { TERMMOD, XK_Escape, keyboard_select, { 0 } }, ++ #endif // KEYBOARDSELECT_PATCH ++ #if KEYBOARDSELECT_PATCH && REFLOW_PATCH ++ { TERMMOD, XK_F, searchforward, { 0 } }, ++ { TERMMOD, XK_B, searchbackward, { 0 } }, ++ #endif // KEYBOARDSELECT_PATCH ++ #if ISO14755_PATCH ++ { TERMMOD, XK_I, iso14755, {.i = 0} }, ++ #endif // ISO14755_PATCH ++ #if INVERT_PATCH ++ { TERMMOD, XK_X, invert, { 0 } }, ++ #endif // INVERT_PATCH ++ #if OSC133_PATCH ++ { ControlMask, XK_Page_Up, scrolltoprompt, {.i = -1}, S_PRI }, ++ { ControlMask, XK_Page_Down, scrolltoprompt, {.i = 1}, S_PRI }, ++ #endif // OSC133_PATCH ++}; ++ ++/* ++ * Special keys (change & recompile st.info accordingly) ++ * ++ * Mask value: ++ * * Use XK_ANY_MOD to match the key no matter modifiers state ++ * * Use XK_NO_MOD to match the key alone (no modifiers) ++ * appkey value: ++ * * 0: no value ++ * * > 0: keypad application mode enabled ++ * * = 2: term.numlock = 1 ++ * * < 0: keypad application mode disabled ++ * appcursor value: ++ * * 0: no value ++ * * > 0: cursor application mode enabled ++ * * < 0: cursor application mode disabled ++ * ++ * Be careful with the order of the definitions because st searches in ++ * this table sequentially, so any XK_ANY_MOD must be in the last ++ * position for a key. ++ */ ++ ++#if !FIXKEYBOARDINPUT_PATCH ++/* ++ * If you want keys other than the X11 function keys (0xFD00 - 0xFFFF) ++ * to be mapped below, add them to this array. ++ */ ++static KeySym mappedkeys[] = { -1 }; ++#endif // FIXKEYBOARDINPUT_PATCH ++ ++/* ++ * State bits to ignore when matching key or button events. By default, ++ * numlock (Mod2Mask) and keyboard layout (XK_SWITCH_MOD) are ignored. ++ */ ++static uint ignoremod = Mod2Mask|XK_SWITCH_MOD; ++ ++#if !FIXKEYBOARDINPUT_PATCH ++/* ++ * This is the huge key array which defines all compatibility to the Linux ++ * world. Please decide about changes wisely. ++ */ ++static Key key[] = { ++ /* keysym mask string appkey appcursor */ ++ { XK_KP_Home, ShiftMask, "\033[2J", 0, -1}, ++ { XK_KP_Home, ShiftMask, "\033[1;2H", 0, +1}, ++ { XK_KP_Home, XK_ANY_MOD, "\033[H", 0, -1}, ++ { XK_KP_Home, XK_ANY_MOD, "\033[1~", 0, +1}, ++ { XK_KP_Up, XK_ANY_MOD, "\033Ox", +1, 0}, ++ { XK_KP_Up, XK_ANY_MOD, "\033[A", 0, -1}, ++ { XK_KP_Up, XK_ANY_MOD, "\033OA", 0, +1}, ++ { XK_KP_Down, XK_ANY_MOD, "\033Or", +1, 0}, ++ { XK_KP_Down, XK_ANY_MOD, "\033[B", 0, -1}, ++ { XK_KP_Down, XK_ANY_MOD, "\033OB", 0, +1}, ++ { XK_KP_Left, XK_ANY_MOD, "\033Ot", +1, 0}, ++ { XK_KP_Left, XK_ANY_MOD, "\033[D", 0, -1}, ++ { XK_KP_Left, XK_ANY_MOD, "\033OD", 0, +1}, ++ { XK_KP_Right, XK_ANY_MOD, "\033Ov", +1, 0}, ++ { XK_KP_Right, XK_ANY_MOD, "\033[C", 0, -1}, ++ { XK_KP_Right, XK_ANY_MOD, "\033OC", 0, +1}, ++ { XK_KP_Prior, ShiftMask, "\033[5;2~", 0, 0}, ++ { XK_KP_Prior, XK_ANY_MOD, "\033[5~", 0, 0}, ++ { XK_KP_Begin, XK_ANY_MOD, "\033[E", 0, 0}, ++ { XK_KP_End, ControlMask, "\033[J", -1, 0}, ++ { XK_KP_End, ControlMask, "\033[1;5F", +1, 0}, ++ { XK_KP_End, ShiftMask, "\033[K", -1, 0}, ++ { XK_KP_End, ShiftMask, "\033[1;2F", +1, 0}, ++ { XK_KP_End, XK_ANY_MOD, "\033[4~", 0, 0}, ++ { XK_KP_Next, ShiftMask, "\033[6;2~", 0, 0}, ++ { XK_KP_Next, XK_ANY_MOD, "\033[6~", 0, 0}, ++ { XK_KP_Insert, ShiftMask, "\033[2;2~", +1, 0}, ++ { XK_KP_Insert, ShiftMask, "\033[4l", -1, 0}, ++ { XK_KP_Insert, ControlMask, "\033[L", -1, 0}, ++ { XK_KP_Insert, ControlMask, "\033[2;5~", +1, 0}, ++ { XK_KP_Insert, XK_ANY_MOD, "\033[4h", -1, 0}, ++ { XK_KP_Insert, XK_ANY_MOD, "\033[2~", +1, 0}, ++ { XK_KP_Delete, ControlMask, "\033[M", -1, 0}, ++ { XK_KP_Delete, ControlMask, "\033[3;5~", +1, 0}, ++ { XK_KP_Delete, ShiftMask, "\033[2K", -1, 0}, ++ { XK_KP_Delete, ShiftMask, "\033[3;2~", +1, 0}, ++ #if DELKEY_PATCH ++ { XK_KP_Delete, XK_ANY_MOD, "\033[3~", -1, 0}, ++ #else ++ { XK_KP_Delete, XK_ANY_MOD, "\033[P", -1, 0}, ++ #endif // DELKEY_PATCH ++ { XK_KP_Delete, XK_ANY_MOD, "\033[3~", +1, 0}, ++ { XK_KP_Multiply, XK_ANY_MOD, "\033Oj", +2, 0}, ++ { XK_KP_Add, XK_ANY_MOD, "\033Ok", +2, 0}, ++ { XK_KP_Enter, XK_ANY_MOD, "\033OM", +2, 0}, ++ { XK_KP_Enter, XK_ANY_MOD, "\r", -1, 0}, ++ { XK_KP_Subtract, XK_ANY_MOD, "\033Om", +2, 0}, ++ { XK_KP_Decimal, XK_ANY_MOD, "\033On", +2, 0}, ++ { XK_KP_Divide, XK_ANY_MOD, "\033Oo", +2, 0}, ++ { XK_KP_0, XK_ANY_MOD, "\033Op", +2, 0}, ++ { XK_KP_1, XK_ANY_MOD, "\033Oq", +2, 0}, ++ { XK_KP_2, XK_ANY_MOD, "\033Or", +2, 0}, ++ { XK_KP_3, XK_ANY_MOD, "\033Os", +2, 0}, ++ { XK_KP_4, XK_ANY_MOD, "\033Ot", +2, 0}, ++ { XK_KP_5, XK_ANY_MOD, "\033Ou", +2, 0}, ++ { XK_KP_6, XK_ANY_MOD, "\033Ov", +2, 0}, ++ { XK_KP_7, XK_ANY_MOD, "\033Ow", +2, 0}, ++ { XK_KP_8, XK_ANY_MOD, "\033Ox", +2, 0}, ++ { XK_KP_9, XK_ANY_MOD, "\033Oy", +2, 0}, ++ { XK_Up, ShiftMask, "\033[1;2A", 0, 0}, ++ { XK_Up, Mod1Mask, "\033[1;3A", 0, 0}, ++ { XK_Up, ShiftMask|Mod1Mask,"\033[1;4A", 0, 0}, ++ { XK_Up, ControlMask, "\033[1;5A", 0, 0}, ++ { XK_Up, ShiftMask|ControlMask,"\033[1;6A", 0, 0}, ++ { XK_Up, ControlMask|Mod1Mask,"\033[1;7A", 0, 0}, ++ { XK_Up,ShiftMask|ControlMask|Mod1Mask,"\033[1;8A", 0, 0}, ++ { XK_Up, XK_ANY_MOD, "\033[A", 0, -1}, ++ { XK_Up, XK_ANY_MOD, "\033OA", 0, +1}, ++ { XK_Down, ShiftMask, "\033[1;2B", 0, 0}, ++ { XK_Down, Mod1Mask, "\033[1;3B", 0, 0}, ++ { XK_Down, ShiftMask|Mod1Mask,"\033[1;4B", 0, 0}, ++ { XK_Down, ControlMask, "\033[1;5B", 0, 0}, ++ { XK_Down, ShiftMask|ControlMask,"\033[1;6B", 0, 0}, ++ { XK_Down, ControlMask|Mod1Mask,"\033[1;7B", 0, 0}, ++ { XK_Down,ShiftMask|ControlMask|Mod1Mask,"\033[1;8B",0, 0}, ++ { XK_Down, XK_ANY_MOD, "\033[B", 0, -1}, ++ { XK_Down, XK_ANY_MOD, "\033OB", 0, +1}, ++ { XK_Left, ShiftMask, "\033[1;2D", 0, 0}, ++ { XK_Left, Mod1Mask, "\033[1;3D", 0, 0}, ++ { XK_Left, ShiftMask|Mod1Mask,"\033[1;4D", 0, 0}, ++ { XK_Left, ControlMask, "\033[1;5D", 0, 0}, ++ { XK_Left, ShiftMask|ControlMask,"\033[1;6D", 0, 0}, ++ { XK_Left, ControlMask|Mod1Mask,"\033[1;7D", 0, 0}, ++ { XK_Left,ShiftMask|ControlMask|Mod1Mask,"\033[1;8D",0, 0}, ++ { XK_Left, XK_ANY_MOD, "\033[D", 0, -1}, ++ { XK_Left, XK_ANY_MOD, "\033OD", 0, +1}, ++ { XK_Right, ShiftMask, "\033[1;2C", 0, 0}, ++ { XK_Right, Mod1Mask, "\033[1;3C", 0, 0}, ++ { XK_Right, ShiftMask|Mod1Mask,"\033[1;4C", 0, 0}, ++ { XK_Right, ControlMask, "\033[1;5C", 0, 0}, ++ { XK_Right, ShiftMask|ControlMask,"\033[1;6C", 0, 0}, ++ { XK_Right, ControlMask|Mod1Mask,"\033[1;7C", 0, 0}, ++ { XK_Right,ShiftMask|ControlMask|Mod1Mask,"\033[1;8C",0, 0}, ++ { XK_Right, XK_ANY_MOD, "\033[C", 0, -1}, ++ { XK_Right, XK_ANY_MOD, "\033OC", 0, +1}, ++ { XK_ISO_Left_Tab, ShiftMask, "\033[Z", 0, 0}, ++ { XK_Return, Mod1Mask, "\033\r", 0, 0}, ++ { XK_Return, XK_ANY_MOD, "\r", 0, 0}, ++ { XK_Insert, ShiftMask, "\033[4l", -1, 0}, ++ { XK_Insert, ShiftMask, "\033[2;2~", +1, 0}, ++ { XK_Insert, ControlMask, "\033[L", -1, 0}, ++ { XK_Insert, ControlMask, "\033[2;5~", +1, 0}, ++ { XK_Insert, XK_ANY_MOD, "\033[4h", -1, 0}, ++ { XK_Insert, XK_ANY_MOD, "\033[2~", +1, 0}, ++ { XK_Delete, ControlMask, "\033[M", -1, 0}, ++ { XK_Delete, ControlMask, "\033[3;5~", +1, 0}, ++ { XK_Delete, ShiftMask, "\033[2K", -1, 0}, ++ { XK_Delete, ShiftMask, "\033[3;2~", +1, 0}, ++ #if DELKEY_PATCH ++ { XK_Delete, XK_ANY_MOD, "\033[3~", -1, 0}, ++ #else ++ { XK_Delete, XK_ANY_MOD, "\033[P", -1, 0}, ++ #endif // DELKEY_PATCH ++ { XK_Delete, XK_ANY_MOD, "\033[3~", +1, 0}, ++ { XK_BackSpace, XK_NO_MOD, "\177", 0, 0}, ++ { XK_BackSpace, Mod1Mask, "\033\177", 0, 0}, ++ { XK_Home, ShiftMask, "\033[2J", 0, -1}, ++ { XK_Home, ShiftMask, "\033[1;2H", 0, +1}, ++ { XK_Home, XK_ANY_MOD, "\033[H", 0, -1}, ++ { XK_Home, XK_ANY_MOD, "\033[1~", 0, +1}, ++ { XK_End, ControlMask, "\033[J", -1, 0}, ++ { XK_End, ControlMask, "\033[1;5F", +1, 0}, ++ { XK_End, ShiftMask, "\033[K", -1, 0}, ++ { XK_End, ShiftMask, "\033[1;2F", +1, 0}, ++ { XK_End, XK_ANY_MOD, "\033[4~", 0, 0}, ++ { XK_Prior, ControlMask, "\033[5;5~", 0, 0}, ++ { XK_Prior, ShiftMask, "\033[5;2~", 0, 0}, ++ { XK_Prior, XK_ANY_MOD, "\033[5~", 0, 0}, ++ { XK_Next, ControlMask, "\033[6;5~", 0, 0}, ++ { XK_Next, ShiftMask, "\033[6;2~", 0, 0}, ++ { XK_Next, XK_ANY_MOD, "\033[6~", 0, 0}, ++ { XK_F1, XK_NO_MOD, "\033OP" , 0, 0}, ++ { XK_F1, /* F13 */ ShiftMask, "\033[1;2P", 0, 0}, ++ { XK_F1, /* F25 */ ControlMask, "\033[1;5P", 0, 0}, ++ { XK_F1, /* F37 */ Mod4Mask, "\033[1;6P", 0, 0}, ++ { XK_F1, /* F49 */ Mod1Mask, "\033[1;3P", 0, 0}, ++ { XK_F1, /* F61 */ Mod3Mask, "\033[1;4P", 0, 0}, ++ { XK_F2, XK_NO_MOD, "\033OQ" , 0, 0}, ++ { XK_F2, /* F14 */ ShiftMask, "\033[1;2Q", 0, 0}, ++ { XK_F2, /* F26 */ ControlMask, "\033[1;5Q", 0, 0}, ++ { XK_F2, /* F38 */ Mod4Mask, "\033[1;6Q", 0, 0}, ++ { XK_F2, /* F50 */ Mod1Mask, "\033[1;3Q", 0, 0}, ++ { XK_F2, /* F62 */ Mod3Mask, "\033[1;4Q", 0, 0}, ++ { XK_F3, XK_NO_MOD, "\033OR" , 0, 0}, ++ { XK_F3, /* F15 */ ShiftMask, "\033[1;2R", 0, 0}, ++ { XK_F3, /* F27 */ ControlMask, "\033[1;5R", 0, 0}, ++ { XK_F3, /* F39 */ Mod4Mask, "\033[1;6R", 0, 0}, ++ { XK_F3, /* F51 */ Mod1Mask, "\033[1;3R", 0, 0}, ++ { XK_F3, /* F63 */ Mod3Mask, "\033[1;4R", 0, 0}, ++ { XK_F4, XK_NO_MOD, "\033OS" , 0, 0}, ++ { XK_F4, /* F16 */ ShiftMask, "\033[1;2S", 0, 0}, ++ { XK_F4, /* F28 */ ControlMask, "\033[1;5S", 0, 0}, ++ { XK_F4, /* F40 */ Mod4Mask, "\033[1;6S", 0, 0}, ++ { XK_F4, /* F52 */ Mod1Mask, "\033[1;3S", 0, 0}, ++ { XK_F5, XK_NO_MOD, "\033[15~", 0, 0}, ++ { XK_F5, /* F17 */ ShiftMask, "\033[15;2~", 0, 0}, ++ { XK_F5, /* F29 */ ControlMask, "\033[15;5~", 0, 0}, ++ { XK_F5, /* F41 */ Mod4Mask, "\033[15;6~", 0, 0}, ++ { XK_F5, /* F53 */ Mod1Mask, "\033[15;3~", 0, 0}, ++ { XK_F6, XK_NO_MOD, "\033[17~", 0, 0}, ++ { XK_F6, /* F18 */ ShiftMask, "\033[17;2~", 0, 0}, ++ { XK_F6, /* F30 */ ControlMask, "\033[17;5~", 0, 0}, ++ { XK_F6, /* F42 */ Mod4Mask, "\033[17;6~", 0, 0}, ++ { XK_F6, /* F54 */ Mod1Mask, "\033[17;3~", 0, 0}, ++ { XK_F7, XK_NO_MOD, "\033[18~", 0, 0}, ++ { XK_F7, /* F19 */ ShiftMask, "\033[18;2~", 0, 0}, ++ { XK_F7, /* F31 */ ControlMask, "\033[18;5~", 0, 0}, ++ { XK_F7, /* F43 */ Mod4Mask, "\033[18;6~", 0, 0}, ++ { XK_F7, /* F55 */ Mod1Mask, "\033[18;3~", 0, 0}, ++ { XK_F8, XK_NO_MOD, "\033[19~", 0, 0}, ++ { XK_F8, /* F20 */ ShiftMask, "\033[19;2~", 0, 0}, ++ { XK_F8, /* F32 */ ControlMask, "\033[19;5~", 0, 0}, ++ { XK_F8, /* F44 */ Mod4Mask, "\033[19;6~", 0, 0}, ++ { XK_F8, /* F56 */ Mod1Mask, "\033[19;3~", 0, 0}, ++ { XK_F9, XK_NO_MOD, "\033[20~", 0, 0}, ++ { XK_F9, /* F21 */ ShiftMask, "\033[20;2~", 0, 0}, ++ { XK_F9, /* F33 */ ControlMask, "\033[20;5~", 0, 0}, ++ { XK_F9, /* F45 */ Mod4Mask, "\033[20;6~", 0, 0}, ++ { XK_F9, /* F57 */ Mod1Mask, "\033[20;3~", 0, 0}, ++ { XK_F10, XK_NO_MOD, "\033[21~", 0, 0}, ++ { XK_F10, /* F22 */ ShiftMask, "\033[21;2~", 0, 0}, ++ { XK_F10, /* F34 */ ControlMask, "\033[21;5~", 0, 0}, ++ { XK_F10, /* F46 */ Mod4Mask, "\033[21;6~", 0, 0}, ++ { XK_F10, /* F58 */ Mod1Mask, "\033[21;3~", 0, 0}, ++ { XK_F11, XK_NO_MOD, "\033[23~", 0, 0}, ++ { XK_F11, /* F23 */ ShiftMask, "\033[23;2~", 0, 0}, ++ { XK_F11, /* F35 */ ControlMask, "\033[23;5~", 0, 0}, ++ { XK_F11, /* F47 */ Mod4Mask, "\033[23;6~", 0, 0}, ++ { XK_F11, /* F59 */ Mod1Mask, "\033[23;3~", 0, 0}, ++ { XK_F12, XK_NO_MOD, "\033[24~", 0, 0}, ++ { XK_F12, /* F24 */ ShiftMask, "\033[24;2~", 0, 0}, ++ { XK_F12, /* F36 */ ControlMask, "\033[24;5~", 0, 0}, ++ { XK_F12, /* F48 */ Mod4Mask, "\033[24;6~", 0, 0}, ++ { XK_F12, /* F60 */ Mod1Mask, "\033[24;3~", 0, 0}, ++ { XK_F13, XK_NO_MOD, "\033[1;2P", 0, 0}, ++ { XK_F14, XK_NO_MOD, "\033[1;2Q", 0, 0}, ++ { XK_F15, XK_NO_MOD, "\033[1;2R", 0, 0}, ++ { XK_F16, XK_NO_MOD, "\033[1;2S", 0, 0}, ++ { XK_F17, XK_NO_MOD, "\033[15;2~", 0, 0}, ++ { XK_F18, XK_NO_MOD, "\033[17;2~", 0, 0}, ++ { XK_F19, XK_NO_MOD, "\033[18;2~", 0, 0}, ++ { XK_F20, XK_NO_MOD, "\033[19;2~", 0, 0}, ++ { XK_F21, XK_NO_MOD, "\033[20;2~", 0, 0}, ++ { XK_F22, XK_NO_MOD, "\033[21;2~", 0, 0}, ++ { XK_F23, XK_NO_MOD, "\033[23;2~", 0, 0}, ++ { XK_F24, XK_NO_MOD, "\033[24;2~", 0, 0}, ++ { XK_F25, XK_NO_MOD, "\033[1;5P", 0, 0}, ++ { XK_F26, XK_NO_MOD, "\033[1;5Q", 0, 0}, ++ { XK_F27, XK_NO_MOD, "\033[1;5R", 0, 0}, ++ { XK_F28, XK_NO_MOD, "\033[1;5S", 0, 0}, ++ { XK_F29, XK_NO_MOD, "\033[15;5~", 0, 0}, ++ { XK_F30, XK_NO_MOD, "\033[17;5~", 0, 0}, ++ { XK_F31, XK_NO_MOD, "\033[18;5~", 0, 0}, ++ { XK_F32, XK_NO_MOD, "\033[19;5~", 0, 0}, ++ { XK_F33, XK_NO_MOD, "\033[20;5~", 0, 0}, ++ { XK_F34, XK_NO_MOD, "\033[21;5~", 0, 0}, ++ { XK_F35, XK_NO_MOD, "\033[23;5~", 0, 0}, ++}; ++#endif // FIXKEYBOARDINPUT_PATCH ++ ++/* ++ * Selection types' masks. ++ * Use the same masks as usual. ++ * Button1Mask is always unset, to make masks match between ButtonPress. ++ * ButtonRelease and MotionNotify. ++ * If no match is found, regular selection is used. ++ */ ++static uint selmasks[] = { ++ [SEL_RECTANGULAR] = Mod1Mask, ++}; ++ ++/* ++ * Printable characters in ASCII, used to estimate the advance width ++ * of single wide characters. ++ */ ++static char ascii_printable[] = ++ " !\"#$%&'()*+,-./0123456789:;<=>?" ++ "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_" ++ "`abcdefghijklmnopqrstuvwxyz{|}~"; ++ ++#if RIGHTCLICKTOPLUMB_PATCH ++/* ++ * plumb_cmd is run on mouse button 3 click, with argument set to ++ * current selection and with cwd set to the cwd of the active shell ++ */ ++static char *plumb_cmd = "plumb"; ++#endif // RIGHTCLICKTOPLUMB_PATCH ++ ++#if UNDERCURL_PATCH ++/** ++ * Undercurl style. Set UNDERCURL_STYLE to one of the available styles. ++ * ++ * Curly: Dunno how to draw it *shrug* ++ * _ _ _ _ ++ * ( ) ( ) ( ) ( ) ++ * (_) (_) (_) (_) ++ * ++ * Spiky: ++ * /\ /\ /\ /\ ++ * \/ \/ \/ ++ * ++ * Capped: ++ * _ _ _ ++ * / \ / \ / \ ++ * \_/ \_/ ++ */ ++// Available styles ++#define UNDERCURL_CURLY 0 ++#define UNDERCURL_SPIKY 1 ++#define UNDERCURL_CAPPED 2 ++// Active style ++#define UNDERCURL_STYLE UNDERCURL_SPIKY ++#endif // UNDERCURL_PATCH diff '--color=auto' -Nu a/config.mk b/config.mk ---- a/config.mk 2024-12-28 23:51:30.003295812 -0600 -+++ b/config.mk 2024-12-28 23:51:42.343296202 -0600 +--- a/config.mk 2025-01-06 21:45:32.882091979 -0600 ++++ b/config.mk 2025-01-04 22:51:49.319021801 -0600 @@ -27,8 +27,8 @@ #LIGATURES_LIBS = `$(PKG_CONFIG) --libs harfbuzz` @@ -108,49 +814,517 @@ diff '--color=auto' -Nu a/config.mk b/config.mk #NETWMICON_LIBS = `$(PKG_CONFIG) --libs gdlib` Common subdirectories: a/.git and b/.git Common subdirectories: a/patch and b/patch -diff '--color=auto' -Nu a/patches.def.h b/patches.def.h ---- a/patches.def.h 2024-12-28 23:51:30.006629148 -0600 -+++ b/patches.def.h 2024-12-28 23:51:42.343296202 -0600 -@@ -44,7 +44,7 @@ - /* A simple variant of the anysize patch that only changes the resize hints to allow the window to - * be resized to any size. - */ --#define ANYSIZE_SIMPLE_PATCH 0 +diff '--color=auto' -Nu a/patches.h b/patches.h +--- a/patches.h 1969-12-31 18:00:00.000000000 -0600 ++++ b/patches.h 2025-01-04 22:51:50.042355158 -0600 +@@ -0,0 +1,510 @@ ++/* ++ * This file contains patch control flags. ++ * ++ * In principle you should be able to mix and match any patches ++ * you may want. In cases where patches are logically incompatible ++ * one patch may take precedence over the other as noted in the ++ * relevant descriptions. ++ */ ++ ++/* Patches */ ++ ++/* The alpha patch adds transparency for the terminal. ++ * You need to uncomment the corresponding line in config.mk to use the -lXrender library ++ * when including this patch. ++ * https://st.suckless.org/patches/alpha/ ++ */ ++#define ALPHA_PATCH 0 ++ ++/* The alpha focus highlight patch allows the user to specify two distinct opacity values or ++ * background colors in order to easily differentiate between focused and unfocused terminal ++ * windows. This depends on the alpha patch. ++ * https://github.com/juliusHuelsmann/st-focus/ ++ * https://st.suckless.org/patches/alpha_focus_highlight/ ++ */ ++#define ALPHA_FOCUS_HIGHLIGHT_PATCH 0 ++ ++/* Adds gradient transparency to st, depends on the alpha patch. ++ * https://st.suckless.org/patches/gradient/ ++ */ ++#define ALPHA_GRADIENT_PATCH 0 ++ ++/* Allows for the initial size of the terminal to be specified as pixel width and height ++ * using the -G command line option. Can be combined with the anysize patch to also allow ++ * the window to be resized to any pixel size. ++ * https://st.suckless.org/patches/anygeometry/ ++ */ ++#define ANYGEOMETRY_PATCH 0 ++ ++/* This patch allows st to resize to any pixel size rather than snapping to character width/height. ++ * https://st.suckless.org/patches/anysize/ ++ */ ++#define ANYSIZE_PATCH 0 ++ ++/* A simple variant of the anysize patch that only changes the resize hints to allow the window to ++ * be resized to any size. ++ */ +#define ANYSIZE_SIMPLE_PATCH 1 - - /* Draws a background image in farbfeld format in place of the defaultbg color allowing for pseudo - * transparency. -@@ -321,7 +321,7 @@ - * Text wraps when the terminal window is made smaller. - * Comes with scrollback. - */ --#define REFLOW_PATCH 0 ++ ++/* Draws a background image in farbfeld format in place of the defaultbg color allowing for pseudo ++ * transparency. ++ * https://st.suckless.org/patches/background_image/ ++ */ ++#define BACKGROUND_IMAGE_PATCH 0 ++ ++/* This patch adds the ability to reload the background image config when a SIGUSR1 signal is ++ * received, e.g.: killall -USR1 st ++ * Depends on the BACKGROUND_IMAGE_PATCH. ++ */ ++#define BACKGROUND_IMAGE_RELOAD_PATCH 0 ++ ++/* This patch allows the use of a blinking cursor. ++ * Only cursor styles 0, 1, 3, 5, and 7 blink. Set cursorstyle accordingly. ++ * Cursor styles are defined here: ++ * https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h4-Functions-using-CSI-_-ordered-by-the-final-character-lparen-s-rparen:CSI-Ps-SP-q.1D81 ++ * https://st.suckless.org/patches/blinking_cursor/ ++ */ ++#define BLINKING_CURSOR_PATCH 0 ++ ++/* By default bold text is rendered with a bold font in the bright variant of the current color. ++ * This patch makes bold text rendered simply as bold, leaving the color unaffected. ++ * https://st.suckless.org/patches/bold-is-not-bright/ ++ */ ++#define BOLD_IS_NOT_BRIGHT_PATCH 0 ++ ++/* This patch adds custom rendering of lines/blocks/braille characters for gapless alignment. ++ * https://st.suckless.org/patches/boxdraw/ ++ */ ++#define BOXDRAW_PATCH 0 ++ ++/* By default st only sets PRIMARY on selection. ++ * This patch makes st set CLIPBOARD on selection. ++ * https://st.suckless.org/patches/clipboard/ ++ */ ++#define CLIPBOARD_PATCH 0 ++ ++/* This patch allows st to be resized without cutting off text when the terminal window is ++ * made larger again. Text does not wrap when the terminal window is made smaller, you may ++ * also want to have a look at the reflow patch. ++ * ++ * https://github.com/bakkeby/st-flexipatch/issues/34 ++ */ ++#define COLUMNS_PATCH 0 ++ ++/* Select and copy the last URL displayed with Mod+l. Multiple invocations cycle through the ++ * available URLs. ++ * https://st.suckless.org/patches/copyurl/ ++ */ ++#define COPYURL_PATCH 0 ++ ++/* Select and copy the last URL displayed with Mod+l. Multiple invocations cycle through the ++ * available URLs. This variant also highlights the selected URLs. ++ * https://st.suckless.org/patches/copyurl/ ++ */ ++#define COPYURL_HIGHLIGHT_SELECTED_URLS_PATCH 0 ++ ++/* This patch adds support for CSI escape sequences 22 and 23, which save and ++ * restores the window title (for instance nvim does this when opening and closing). ++ * https://st.suckless.org/patches/csi_22_23/ ++ */ ++#define CSI_22_23_PATCH 0 ++ ++/* According to the specification (see link in BLINKING_CURSOR_PATCH) the "Set cursor style ++ * (DECSCUSR), VT520." escape sequences define both values of 0 and 1 as a blinking block, ++ * with 1 being the default. ++ * ++ * This patch allows the default cursor to be set when value 0 is used, as opposed to ++ * setting the cursor to a blinking block. ++ * ++ * This allows a command like this to restore the cursor to what st is configured with: ++ * $ echo -ne "\e[ q" ++ * ++ * While many terminal emulators do this it is not adhering to specification. xterm is an ++ * example terminal that sets a blinking block instead of the configured one, same as st. ++ */ ++#define DEFAULT_CURSOR_PATCH 0 ++ ++/* Return BS on pressing backspace and DEL on pressing the delete key. ++ * https://st.suckless.org/patches/delkey/ ++ */ ++#define DELKEY_PATCH 0 ++ ++/* This patch adds the option of disabling bold fonts globally. ++ * https://st.suckless.org/patches/disable_bold_italic_fonts/ ++ */ ++#define DISABLE_BOLD_FONTS_PATCH 0 ++ ++/* This patch adds the option of disabling italic fonts globally. ++ * https://st.suckless.org/patches/disable_bold_italic_fonts/ ++ */ ++#define DISABLE_ITALIC_FONTS_PATCH 0 ++ ++/* This patch adds the option of disabling roman fonts globally. ++ * https://st.suckless.org/patches/disable_bold_italic_fonts/ ++ */ ++#define DISABLE_ROMAN_FONTS_PATCH 0 ++ ++/* This patch makes the cursor color the inverse of the current cell color. ++ * https://st.suckless.org/patches/dynamic-cursor-color/ ++ */ ++#define DYNAMIC_CURSOR_COLOR_PATCH 0 ++ ++/* Reading and writing st's screen through a pipe, e.g. pass info to dmenu. ++ * https://st.suckless.org/patches/externalpipe/ ++ */ ++#define EXTERNALPIPE_PATCH 0 ++ ++/* This patch improves and extends the externalpipe patch in two ways: ++ * - it prevents the reset of the signal handler set on SIGCHILD, when ++ * the forked process that executes the external process exits and ++ * - it adds the externalpipein function to redirect the standard output ++ * of the external command to the slave size of the pty, that is, as if ++ * the external program had been manually executed on the terminal ++ * ++ * It can be used to send desired escape sequences to the terminal with a ++ * keyboard shortcut. The patch was created to make use of the dynamic-colors ++ * tool that uses the OSC escape sequences to change the colors of the terminal. ++ * ++ * This patch depends on EXTERNALPIPE_PATCH being enabled. ++ * ++ * https://github.com/sos4nt/dynamic-colors ++ * https://lists.suckless.org/hackers/2004/17218.html ++ */ ++#define EXTERNALPIPEIN_PATCH 0 ++ ++/* This patch allows command line applications to use all the fancy key combinations ++ * that are available to GUI applications. ++ * https://st.suckless.org/patches/fix_keyboard_input/ ++ */ ++#define FIXKEYBOARDINPUT_PATCH 0 ++ ++/* This patch allows you to add spare font besides the default. Some glyphs can be not present in ++ * the default font. For this glyphs st uses font-config and try to find them in font cache first. ++ * This patch append fonts defined in font2 variable to the beginning of the font cache. ++ * So they will be used first for glyphs that are absent in the default font. ++ * https://st.suckless.org/patches/font2/ ++ */ ++#define FONT2_PATCH 0 ++ ++/* This patch adds the ability to toggle st into fullscreen mode. ++ * Two key bindings are defined: F11 which is typical with other applications and Alt+Enter ++ * which matches the default xterm behavior. ++ * https://st.suckless.org/patches/fullscreen/ ++ */ ++#define FULLSCREEN_PATCH 0 ++ ++/* Hide the X cursor whenever a key is pressed and show it back when the mouse is moved in ++ * the terminal window. ++ * https://st.suckless.org/patches/hidecursor/ ++ */ ++#define HIDECURSOR_PATCH 0 ++ ++/* This patch hides the terminal cursor when the window loses focus (as opposed to showing a hollow ++ * cursor). ++ * https://www.reddit.com/r/suckless/comments/nvee8h/how_to_hide_cursor_in_st_is_there_a_patch_for_it/ ++ */ ++#define HIDE_TERMINAL_CURSOR_PATCH 0 ++ ++/* This patch adds a keybinding that lets you invert the current colorscheme of st. ++ * This provides a simple way to temporarily switch to a light colorscheme if you use a dark ++ * colorscheme or visa-versa. ++ * https://st.suckless.org/patches/invert/ ++ */ ++#define INVERT_PATCH 0 ++ ++/* Pressing the default binding Ctrl+Shift-i will popup dmenu, asking you to enter a unicode ++ * codepoint that will be converted to a glyph and then pushed to st. ++ * https://st.suckless.org/patches/iso14755/ ++ */ ++#define ISO14755_PATCH 0 ++ ++/* This patch allows you to select text on the terminal using keyboard shortcuts. ++ * NB: An improved variant of this patch is enabled if combined with the reflow patch. ++ * ++ * https://st.suckless.org/patches/keyboard_select/ ++ */ ++#define KEYBOARDSELECT_PATCH 0 ++ ++/* This patch adds support for drawing ligatures using the Harfbuzz library to transform ++ * original text of a single line to a list of glyphs with ligatures included. ++ * This patch depends on the Harfbuzz library and headers to compile. ++ * You need to uncomment the corresponding lines in config.mk to use the harfbuzz library ++ * when including this patch. ++ * https://github.com/cog1to/st-ligatures ++ * https://st.suckless.org/patches/ligatures/ ++ */ ++#define LIGATURES_PATCH 0 ++ ++/* This patch makes st ignore terminal color attributes by forcing display of the default ++ * foreground and background colors only - making for a monochrome look. Idea ref. ++ * https://www.reddit.com/r/suckless/comments/ixbx6z/how_to_use_black_and_white_only_for_st/ ++ */ ++#define MONOCHROME_PATCH 0 ++ ++/* This patch sets the _NET_WM_ICON X property with an icon that is read from a .png file. ++ * This patch depends on the GD Graphics Library and headers to compile. ++ * You need to uncomment the corresponding lines in config.mk to use the gd library. ++ * ++ * The default location for the .png file is: ++ * - /usr/local/share/pixmaps/st.png ++ * ++ * https://st.suckless.org/patches/netwmicon/ ++ */ ++#define NETWMICON_PATCH 0 ++ ++/* This patch sets the _NET_WM_ICON X property with an icon that is read from a farbfeld image. ++ * The benefit of this patch is that you do not need an additional dependency on an external ++ * library to read and convert the farbfeld image. ++ * ++ * The default location for the farbfeld image is: ++ * - /usr/local/share/pixmaps/st.ff ++ * ++ * Remember to change the ICONNAME in config.mk from st.png to st.ff when using this patch. ++ * ++ * Example command to convert a .png to farbfeld: ++ * $ png2ff < st.png > st.ff ++ * ++ * https://tools.suckless.org/farbfeld/ ++ * https://github.com/bakkeby/patches/wiki/netwmicon/ ++ */ ++#define NETWMICON_FF_PATCH 0 ++ ++/* This patch sets the _NET_WM_ICON X property with a hardcoded icon for st. This is the ++ * original version that predates the version that reads the image from a .png file. ++ * https://st.suckless.org/patches/netwmicon/ ++ */ ++#define NETWMICON_LEGACY_PATCH 0 ++ ++/* This patch allows you to spawn a new st terminal using Ctrl-Shift-Return. It will have the ++ * same CWD (current working directory) as the original st instance. ++ * https://st.suckless.org/patches/newterm/ ++ */ ++#define NEWTERM_PATCH 0 ++ ++/* This patch will set the _MOTIF_WM_HINTS property for the st window which, if the window manager ++ * respects it, will show the st window without window decorations. ++ * ++ * In dwm, if the decoration hints patch is applied, then the st window will start out without a ++ * border. In GNOME and KDE the window should start without a window title. ++ */ ++#define NO_WINDOW_DECORATIONS_PATCH 0 ++ ++/* Open contents of the clipboard in a user-defined browser. ++ * https://st.suckless.org/patches/open_copied_url/ ++ */ ++#define OPENCOPIED_PATCH 0 ++ ++/* This patch allows for URLs to be opened directly when you click on them. This may not work with ++ * all terminal applications. ++ * ++ * https://www.reddit.com/r/suckless/comments/cc83om/st_open_url/ ++ */ ++#define OPENURLONCLICK_PATCH 0 ++ ++/* This patch allows st to fetch the current working directory through the OSC 7 escape ++ * sequence emitted by shells. Must be used with newterm patch. ++ * ++ * https://codeberg.org/dnkl/foot/wiki#spawning-new-terminal-instances-in-the-current-working-directory ++ * https://github.com/veltza/st-sx/commit/817865c2c6ed905af8849580e58bdcf399216fbd ++ */ ++#define OSC7_PATCH 0 ++ ++/* This patch allows jumping between prompts by utilizing the OSC 133 escape sequence ++ * emitted by shells. Must be used with either reflow or scrollback patch. ++ * ++ * https://codeberg.org/dnkl/foot#jumping-between-prompts ++ */ ++#define OSC133_PATCH 0 ++ ++/* Reflow. ++ * Allows st to be resized without cutting off text when the terminal window is made larger again. ++ * Text wraps when the terminal window is made smaller. ++ * Comes with scrollback. ++ */ +#define REFLOW_PATCH 1 - - /* This patch allows you to specify a border that is relative in size to the width of a cell - * in the terminal. -@@ -338,13 +338,13 @@ - /* Scroll back through terminal output using Shift+{PageUp, PageDown}. - * https://st.suckless.org/patches/scrollback/ - */ --#define SCROLLBACK_PATCH 0 ++ ++/* This patch allows you to specify a border that is relative in size to the width of a cell ++ * in the terminal. ++ * https://st.suckless.org/patches/relativeborder/ ++ */ ++#define RELATIVEBORDER_PATCH 0 ++ ++/* This patch allows you to right-click on some selected text to send it to the plumbing ++ * program of choice, e.g. open a file, view an image, open a URL. ++ * https://st.suckless.org/patches/right_click_to_plumb/ ++ */ ++#define RIGHTCLICKTOPLUMB_PATCH 0 ++ ++/* Scroll back through terminal output using Shift+{PageUp, PageDown}. ++ * https://st.suckless.org/patches/scrollback/ ++ */ +#define SCROLLBACK_PATCH 1 - - /* Scroll back through terminal output using Shift+MouseWheel. - * This variant depends on SCROLLBACK_PATCH being enabled. - * https://st.suckless.org/patches/scrollback/ - */ --#define SCROLLBACK_MOUSE_PATCH 0 ++ ++/* Scroll back through terminal output using Shift+MouseWheel. ++ * This variant depends on SCROLLBACK_PATCH being enabled. ++ * https://st.suckless.org/patches/scrollback/ ++ */ +#define SCROLLBACK_MOUSE_PATCH 1 - - /* Scroll back through terminal output using mouse wheel (when not in MODE_ALTSCREEN). - * This variant depends on SCROLLBACK_PATCH being enabled. -@@ -378,7 +378,7 @@ - * - * https://gist.github.com/saitoha/70e0fdf22e3e8f63ce937c7f7da71809 - */ --#define SIXEL_PATCH 0 ++ ++/* Scroll back through terminal output using mouse wheel (when not in MODE_ALTSCREEN). ++ * This variant depends on SCROLLBACK_PATCH being enabled. ++ * https://st.suckless.org/patches/scrollback/ ++ */ ++#define SCROLLBACK_MOUSE_ALTSCREEN_PATCH 0 ++ ++/* This patch adds the two color-settings selectionfg and selectionbg to config.def.h. ++ * Those define the fore- and background colors which are used when text on the screen is selected ++ * with the mouse. This removes the default behaviour which would simply reverse the colors. ++ * https://st.suckless.org/patches/selectioncolors/ ++ */ ++#define SELECTION_COLORS_PATCH 0 ++ ++/* This is the single drawable buffer patch as outlined in the FAQ to get images ++ * in w3m to display. While this patch does not break the alpha patch it images ++ * are not shown in w3m if the alpha patch is applied. ++ */ ++#define SINGLE_DRAWABLE_BUFFER_PATCH 0 ++ ++/* This patch adds SIXEL graphics support for st. ++ * Note that patch/sixel.c/sixel_hls.c come from mintty, licensed under GPL. ++ * Known issues: ++ * - Rendering sixel graphics may cause unusual cursor placement, this is ++ * not specific to this variant of st - the same issue is present in ++ * the xterm implementation. This is likely an issue of sixel height ++ * not being detected correctly. ++ * ++ * Note that you need to uncomment the corresponding lines in config.mk when including this patch. ++ * This patch is incompatible with the W3M patch. ++ * ++ * https://gist.github.com/saitoha/70e0fdf22e3e8f63ce937c7f7da71809 ++ */ +#define SIXEL_PATCH 1 - - /* This patch allows clients to embed into the st window and is useful if you tend to - * start X applications from the terminal. For example: ++ ++/* This patch allows clients to embed into the st window and is useful if you tend to ++ * start X applications from the terminal. For example: ++ * ++ * $ surf -e $WINDOWID ++ * ++ * The behavior is similar to Plan 9 where applications can take over windows. ++ * URL TBC ++ */ ++#define ST_EMBEDDER_PATCH 0 ++ ++/* Use inverted defaultbg/fg for selection when bg/fg are the same. ++ * https://st.suckless.org/patches/spoiler/ ++ */ ++#define SPOILER_PATCH 0 ++ ++/* This patch changes the mouse shape to the global default when the running program subscribes ++ * for mouse events, for instance, in programs like ranger and fzf. It emulates the behaviour ++ * shown by vte terminals like termite. ++ * https://st.suckless.org/patches/swapmouse/ ++ */ ++#define SWAPMOUSE_PATCH 0 ++ ++/* This patch adds synchronized-updates/application-sync support in st. ++ * This will have no effect except when an application uses the synchronized-update escape ++ * sequences. With this patch nearly all cursor flicker is eliminated in tmux, and tmux detects ++ * it automatically via terminfo. ++ * ++ * Note: this patch alters st.info to promote support for extra escape sequences, which can ++ * potentially cause application misbehaviour if you do not use this patch. Try removing or ++ * commenting out the corresponding line in st.info if this is causing issues. ++ * ++ * https://st.suckless.org/patches/sync/ ++ */ ++#define SYNC_PATCH 0 ++ ++/* Instead of a default X cursor, use the xterm cursor from your cursor theme. ++ * You need to uncomment the corresponding line in config.mk to use the -lXcursor library ++ * when including this patch. ++ * https://st.suckless.org/patches/themed_cursor/ ++ */ ++#define THEMED_CURSOR_PATCH 0 ++ ++/* Adds support for special underlines. ++ * ++ * Example test command: ++ * $ echo -e "\e[4:3m\e[58:5:10munderline\e[0m" ++ * ^ ^ ^ ^ ^- sets terminal color 10 ++ * | | | \- indicates that terminal colors should be used ++ * | | \- indicates that underline color is being set ++ * | \- sets underline style to curvy ++ * \- set underline ++ * ++ * Note: this patch alters st.info to promote support for extra escape sequences, which can ++ * potentially cause application misbehaviour if you do not use this patch. Try removing or ++ * commenting out the corresponding line in st.info if this is causing issues. ++ * ++ * https://st.suckless.org/patches/undercurl/ ++ */ ++#define UNDERCURL_PATCH 0 ++ ++/* Allows mouse scroll without modifier keys for regardless of alt screen using the external ++ * scroll program. ++ * https://st.suckless.org/patches/universcroll/ ++ */ ++#define UNIVERSCROLL_PATCH 0 ++ ++/* Use XftFontMatch in place of FcFontMatch. ++ * ++ * XftFontMatch calls XftDefaultSubstitute which configures various match properties according ++ * to the user's configured Xft defaults (xrdb) as well as according to the current display and ++ * screen. Most importantly, the screen DPI is computed [1]. Without this, st uses a "default" ++ * DPI of 75 [2]. ++ * ++ * [1]: https://cgit.freedesktop.org/xorg/lib/libXft/tree/src/xftdpy.c?id=libXft-2.3.2#n535 ++ * [2]: https://cgit.freedesktop.org/fontconfig/tree/src/fcdefault.c?id=2.11.1#n255 ++ * ++ * https://git.suckless.org/st/commit/528241aa3835e2f1f052abeeaf891737712955a0.html ++ */ ++#define USE_XFTFONTMATCH_PATCH 0 ++ ++/* Vertically center lines in the space available if you have set a larger chscale in config.h ++ * https://st.suckless.org/patches/vertcenter/ ++ */ ++#define VERTCENTER_PATCH 0 ++ ++/* Briefly inverts window content on terminal bell event. ++ * https://st.suckless.org/patches/visualbell/ ++ */ ++#define VISUALBELL_1_PATCH 0 ++ ++/* Adds support for w3m images. ++ * https://st.suckless.org/patches/w3m/ ++ */ ++#define W3M_PATCH 0 ++ ++/* Adds proper glyphs rendering in st allowing wide glyphs to be drawn as-is as opposed to ++ * smaller or cut glyphs being rendered. ++ * https://github.com/Dreomite/st/commit/e3b821dcb3511d60341dec35ee05a4a0abfef7f2 ++ * https://www.reddit.com/r/suckless/comments/jt90ai/update_support_for_proper_glyph_rendering_in_st/ ++ */ ++#define WIDE_GLYPHS_PATCH 0 ++ ++/* There is a known issue that Google's Variable Fonts (VF) can end up with letter spacing ++ * that is too wide in programs that use Xft, for example Inconsolata v3.000. ++ * ++ * This is intended as a temporary patch / hack until (if) this is fixed in the Xft library ++ * itself. ++ * ++ * https://github.com/googlefonts/Inconsolata/issues/42#issuecomment-737508890 ++ */ ++#define WIDE_GLYPH_SPACING_PATCH 0 ++ ++/* This patch allows user to specify the initial path st should use as the working directory. ++ * https://st.suckless.org/patches/workingdir/ ++ */ ++#define WORKINGDIR_PATCH 0 ++ ++/* This patch adds the ability to configure st via Xresources. At startup, st will read and ++ * apply the resources named in the resources[] array in config.h. ++ * https://st.suckless.org/patches/xresources/ ++ */ ++#define XRESOURCES_PATCH 0 ++ ++/* This patch adds the ability to reload the Xresources config when a SIGUSR1 signal is received ++ * e.g.: killall -USR1 st ++ * Depends on the XRESOURCES_PATCH. ++ */ ++#define XRESOURCES_RELOAD_PATCH 0