text: #include <X11/XF86keysym.h>
  #include <stdlib.h>
  /* See LICENSE file for copyright and license details. */
  
  /* appearance */
  static const unsigned int borderpx  = 2;        /* border pixel of windows */
  static const unsigned int snap      = 32;       /* snap pixel */
  static const int showbar            = 1;        /* 0 means no bar */
  static const int topbar             = 1;        /* 0 means bottom bar */
  static const unsigned int gappih         = 5;  /* horiz inner gap between windows */
  static const unsigned int gappiv         = 5;  /* vert inner gap between windows */
  static const unsigned int gappoh         = 5;  /* horiz outer gap between windows and screen edge */
  static const unsigned int gappov         = 5;  /* vert outer gap between windows and screen edge */
  static const int smartgaps               = 0;   /* 1 means no outer gap when there is only one window */
  /* Indicators: see patch/bar_indicators.h for options */
  static int tagindicatortype              = INDICATOR_TOP_LEFT_SQUARE;
  static int tiledindicatortype            = INDICATOR_NONE;
  static int floatindicatortype            = INDICATOR_TOP_LEFT_SQUARE;
  static const char *fonts[]          = { "FontAwesome:size=10", "Liberation Mono:size=9", "monospace:size=9" };
  static const char dmenufont[]       = "Liberation Mono:size=10";
  
  static char normfgcolor[]                = "#bbbbbb";
  static char normbgcolor[]                = "#222222";
  static char normbordercolor[]            = "#444444";
  static char normfloatcolor[]             = "#db8fd9";
  
  static char selfgcolor[]                 = "#eeeeee";
  static char selbgcolor[]                 = "#005577";
  static char selbordercolor[]             = "#005577";
  static char selfloatcolor[]              = "#005577";
  
  static char titlenormfgcolor[]           = "#bbbbbb";
  static char titlenormbgcolor[]           = "#222222";
  static char titlenormbordercolor[]       = "#444444";
  static char titlenormfloatcolor[]        = "#db8fd9";
  
  static char titleselfgcolor[]            = "#eeeeee";
  static char titleselbgcolor[]            = "#005577";
  static char titleselbordercolor[]        = "#005577";
  static char titleselfloatcolor[]         = "#005577";
  
  static char tagsnormfgcolor[]            = "#bbbbbb";
  static char tagsnormbgcolor[]            = "#222222";
  static char tagsnormbordercolor[]        = "#444444";
  static char tagsnormfloatcolor[]         = "#db8fd9";
  
  static char tagsselfgcolor[]             = "#eeeeee";
  static char tagsselbgcolor[]             = "#005577";
  static char tagsselbordercolor[]         = "#005577";
  static char tagsselfloatcolor[]          = "#005577";
  
  static char hidfgcolor[]                 = "#005577";
  static char hidbgcolor[]                 = "#222222";
  static char hidbordercolor[]             = "#005577";
  static char hidfloatcolor[]              = "#f76e0c";
  
  static char urgfgcolor[]                 = "#bbbbbb";
  static char urgbgcolor[]                 = "#222222";
  static char urgbordercolor[]             = "#ff0000";
  static char urgfloatcolor[]              = "#db8fd9";
  
  //static char solarizedBase02[] = "#073642";
  //static char solarizedBase01[] = "#586e75";
  //static char solarizedBase00[] = "#657b83";
  static char solarizedBase03[] = "#002b36";
  static char solarizedBase0 [] = "#839496";
  static char solarizedBase1 [] = "#93a1a1";
  static char solarizedBase2 [] = "#eee8d5";
  static char solarizedBase3 [] = "#fdf6e3";
  static char solarizedYellow[] = "#b58900";
  static char solarizedOrange[] = "#cb4b16";
  static char solarizedRed   [] = "#dc322f";
  static char solarizedMagent[] = "#d33682";
  static char solarizedViolet[] = "#6c71c4";
  static char solarizedBlue  [] = "#268bd2";
  static char solarizedCyan  [] = "#2aa198";
  static char solarizedGreen [] = "#859900";
  
  const static char *colors[][ColCount] = {
  	/*                       fg                bg                border                float */
  	[SchemeNorm]         = { solarizedBase2,   solarizedBase03,  solarizedBase03,      solarizedBlue },
  	[SchemeSel]          = { solarizedBase3,   solarizedBase0,   solarizedBase1,       solarizedBlue },
  	[SchemeTitleNorm]    = { solarizedBase2,   solarizedBase03,  titlenormbordercolor, titlenormfloatcolor },
  	[SchemeTitleSel]     = { solarizedBase2,   solarizedBase03,  titleselbordercolor,  titleselfloatcolor },
  	[SchemeTagsNorm]     = { tagsnormfgcolor,  tagsnormbgcolor,  tagsnormbordercolor,  tagsnormfloatcolor },
  	[SchemeTagsSel]      = { tagsselfgcolor,   tagsselbgcolor,   tagsselbordercolor,   tagsselfloatcolor },
  	[SchemeHid]          = { hidfgcolor,       hidbgcolor,       hidbordercolor,       hidfloatcolor },
  	[SchemeUrg]          = { urgfgcolor,       urgbgcolor,       urgbordercolor,       urgfloatcolor },
  };
  
  const 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 },
  	[SchemeHid]          = { hidfgcolor,       hidbgcolor,       hidbordercolor,       hidfloatcolor },
  	[SchemeUrg]          = { urgfgcolor,       urgbgcolor,       urgbordercolor,       urgfloatcolor },
  	[SchemeViolet]       = { solarizedBase2,   solarizedViolet,  urgbordercolor,       urgfloatcolor },
  	[SchemeBlue]         = { solarizedBase2,   solarizedBlue,    urgbordercolor,       urgfloatcolor },
  	[SchemeYellow]       = { solarizedBase2,   solarizedYellow,  urgbordercolor,       urgfloatcolor },
  	[SchemeOrange]       = { solarizedBase2,   solarizedOrange,  urgbordercolor,       urgfloatcolor },
  	[SchemeRed]          = { solarizedBase2,   solarizedRed,     urgbordercolor,       urgfloatcolor },
  	[SchemeMagent]       = { solarizedBase2,   solarizedMagent,  urgbordercolor,       urgfloatcolor },
  	[SchemeCyan]         = { solarizedBase2,   solarizedCyan,    urgbordercolor,       urgfloatcolor },
  	[SchemeGreen]        = { solarizedBase2,   solarizedGreen,   urgbordercolor,       urgfloatcolor },
  	[SchemeDark]         = { solarizedBase2,   solarizedBase03,  urgbordercolor,       urgfloatcolor },
  };
  
  
  /* Tags
   * In a traditional dwm the number of tags in use can be changed simply by changing the number
   * of strings in the tags array. This build does things a bit different which has some added
   * benefits. If you need to change the number of tags here then change the NUMTAGS macro in dwm.c.
   *
   * Examples:
   *
   *  1) static char *tagicons[][NUMTAGS*2] = {
   *         [DEFAULT_TAGS] = { "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "I" },
   *     }
   *
   *  2) static char *tagicons[][1] = {
   *         [DEFAULT_TAGS] = { "•" },
   *     }
   *
   * The first example would result in the tags on the first monitor to be 1 through 9, while the
   * tags for the second monitor would be named A through I. A third monitor would start again at
   * 1 through 9 while the tags on a fourth monitor would also be named A through I. Note the tags
   * count of NUMTAGS*2 in the array initialiser which defines how many tag text / icon exists in
   * the array. This can be changed to *3 to add separate icons for a third monitor.
   *
   * For the second example each tag would be represented as a bullet point. Both cases work the
   * same from a technical standpoint - the icon index is derived from the tag index and the monitor
   * index. If the icon index is is greater than the number of tag icons then it will wrap around
   * until it an icon matches. Similarly if there are two tag icons then it would alternate between
   * them. This works seamlessly with alternative tags and alttagsdecoration patches.
   */
  static char *tagicons[][NUMTAGS] = {
  	[DEFAULT_TAGS]        = { "", "", "", "", "", "", "", "", "", "" },
  	[ALTERNATIVE_TAGS]    = { "A", "B", "C", "D", "E", "F", "G", "H", "I", "K" },
  	[ALT_TAGS_DECORATION] = { "<1>", "<2>", "<3>", "<4>", "<5>", "<6>", "<7>", "<8>", "<9>", "<10>" },
  };
  
  
  /* 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 << 6, .isfloating = 1)
  	RULE(.class = "Microsoft Teams", .tags = 1 << 3, .isfloating = 1)
  	RULE(.class = "firefox", .tags = 1 << 8)
  	RULE(.class = "Thunderbird", .tags = 1 << 9)
  	RULE(.class = "nvim-qt", .tags = 1 << 2)
  	RULE(.class = "Zathura", .tags = 1 << 5)
  	RULE(.class = "libreoffice", .tags = 1 << 7)
      RULE(.class = "passpopup", .isfloating = 1)
  };
  
  /* Bar rules allow you to configure what is shown where on the bar, as well as
   * introducing your own bar modules.
   *
   *    monitor:
   *      -1  show on all monitors
   *       0  show on monitor 0
   *      'A' show on active monitor (i.e. focused / selected) (or just -1 for active?)
   *    bar - bar index, 0 is default, 1 is extrabar
   *    alignment - how the module is aligned compared to other modules
   *    widthfunc, drawfunc, clickfunc - providing bar module width, draw and click functions
   *    name - does nothing, intended for visual clue and for logging / debugging
   */
  static const BarRule barrules[] = {
  	/* monitor  bar    alignment         widthfunc                drawfunc                clickfunc                name */
  	{  -1,       0,     BAR_ALIGN_LEFT,   width_pwrl_tags,         draw_pwrl_tags,         click_pwrl_tags,         "powerline_tags" },
  	{  -1,       0,     BAR_ALIGN_RIGHT,  width_pwrl_status,       draw_pwrl_status,       click_pwrl_status,       "powerline_status" },
  	{ -1,       0,     BAR_ALIGN_NONE,   width_wintitle,          draw_wintitle,          click_wintitle,          "wintitle" },
  };
  /* layout(s) */
  static const float mfact     = 0.55; /* factor of master area size [0.05..0.95] */
  static const int nmaster     = 1;    /* number of clients in master area */
  static const int resizehints = 1;    /* 1 means respect size hints in tiled resizals */
  static const int lockfullscreen = 1; /* 1 will force focus on the fullscreen window */
  
  static const Layout layouts[] = {
  	/* symbol     arrange function */
  	{ "(@)",      spiral },
  	{ "[]=",      tile },    /* first entry is default */
  	{ "><>",      NULL },    /* no layout function means floating behavior */
  	{ "[M]",      monocle },
  	{ "[\\]",      dwindle },
  };
  
  /* key definitions */
  #define MODKEY Mod4Mask
  #define TAGKEYS(KEY,TAG) \
  	{ MODKEY,                       KEY,      view,           {.ui = 1 << TAG} }, \
  	{ MODKEY|ControlMask,           KEY,      toggleview,     {.ui = 1 << TAG} }, \
  	{ MODKEY|ShiftMask,             KEY,      tag,            {.ui = 1 << TAG} }, \
  	{ MODKEY|ControlMask|ShiftMask, KEY,      toggletag,      {.ui = 1 << TAG} },
  
  /* helper for spawning shell commands in the pre dwm-5.0 fashion */
  #define SHCMD(cmd) { .v = (const char*[]){ "/bin/sh", "-c", cmd, NULL } }
  
  /* commands */
  static char dmenumon[2] = "0"; /* component of dmenucmd, manipulated in spawn() */
  static const char *dmenucmd[] = {
  	"dmenu_run",
  	"-m", dmenumon,
  	"-fn", dmenufont,
  	"-nb", normbgcolor,
  	"-nf", normfgcolor,
  	"-sb", selbgcolor,
  	"-sf", selfgcolor,
  	topbar ? NULL : "-b",
  	NULL
  };
  static const char *termcmd[]  = { "st", NULL };
  static const char *roottermcmd[] = { "st", "-e", "/usr/bin/bash", "-c", "su -", NULL };
  static const char *bigtermcmd[] = { "st", "-f", "'Dejavu Sans Mono:pixelsize=20:antialias=true:autohint=true'", NULL };
  static const char *web_browser[]  = { "firefox", NULL };
  static const char *qt_nvim[] = { "nvim-qt", NULL };
  
  // Audio management
  static const char *up_volume[] = { "change_vol", "up", NULL };
  static const char *down_volume[] = { "change_vol", "down", NULL };
  
  // Screen locker
  static const char *screen_locker[]  = { "slock", NULL };
  
  // PDF reader
  static const char *pdf_viewer[] = { "zathura", NULL };
  
  
  static Key keys[] = {
  	/* modifier                     key                         function        argument */
  	{ MODKEY,                       XK_p,                       spawn,          {.v = dmenucmd } },
  	{ MODKEY,                       XK_Return,                  spawn,          {.v = termcmd } },
  	{ MODKEY,                       XK_b,                       togglebar,      {0} },
  	{ MODKEY,                       XK_j,                       focusstack,     {.i = +1 } },
  	{ MODKEY,                       XK_k,                       focusstack,     {.i = -1 } },
  	{ MODKEY,                       XK_i,                       incnmaster,     {.i = +1 } },
  	{ MODKEY,                       XK_d,                       incnmaster,     {.i = -1 } },
  	{ MODKEY,                       XK_h,                       setmfact,       {.f = -0.05} },
  	{ MODKEY,                       XK_l,                       setmfact,       {.f = +0.05} },
  	{ MODKEY|ShiftMask,             XK_Return,                  zoom,           {0} },
  	{ MODKEY,                       XK_Tab,                     view,           {0} },
  	{ MODKEY|ShiftMask,             XK_c,                       killclient,     {0} },
  	{ MODKEY|ShiftMask,             XK_q,                       quit,           {0} },
  	{ MODKEY,                       XK_t,                       setlayout,      {.v = &layouts[1]} },
  	{ MODKEY,                       XK_f,                       setlayout,      {.v = &layouts[2]} },
  	{ MODKEY,                       XK_m,                       setlayout,      {.v = &layouts[3]} },
  	{ MODKEY,                       XK_r,                       setlayout,      {.v = &layouts[4]} },
  	{ MODKEY,                       XK_u,                       setlayout,      {.v = &layouts[0]} },
  	{ MODKEY,                       XK_space,                   setlayout,      {0} },
  	{ MODKEY|ShiftMask,             XK_space,                   togglefloating, {0} },
  	{ MODKEY,                       XK_comma,                   focusmon,       {.i = -1 } },
  	{ MODKEY,                       XK_period,                  focusmon,       {.i = +1 } },
  	{ MODKEY|ShiftMask,             XK_j,                       focusmon,       {.i = -1 } },
  	{ MODKEY|ShiftMask,             XK_k,                       focusmon,       {.i = +1 } },
  	{ MODKEY|ShiftMask,             XK_comma,                   tagmon,         {.i = -1 } },
  	{ MODKEY|ShiftMask,             XK_period,                  tagmon,         {.i = +1 } },
  	TAGKEYS(                        XK_1,                                       0)
  	TAGKEYS(                        XK_2,                                       1)
  	TAGKEYS(                        XK_3,                                       2)
  	TAGKEYS(                        XK_4,                                       3)
  	TAGKEYS(                        XK_5,                                       4)
  	TAGKEYS(                        XK_6,                                       5)
  	TAGKEYS(                        XK_7,                                       6)
  	TAGKEYS(                        XK_8,                                       7)
  	TAGKEYS(                        XK_9,                                       8)
  	TAGKEYS(                        XK_0,                                       9)
  	{ MODKEY|ShiftMask,             XK_f,                       spawn,          {.v = web_browser} },
      { 0,                            XF86XK_AudioLowerVolume,    spawn,          {.v = down_volume } },
      { 0,                            XF86XK_AudioRaiseVolume,    spawn,          {.v = up_volume } },
      { 0,                            XF86XK_ScreenSaver,         spawn,          {.v = screen_locker } },
      { 0,                            XF86XK_Battery,             spawn,          SHCMD("notify-send \"Battery Information\" \"$(acpi)\"") },
      { MODKEY,                       XK_z,                       spawn,          { .v = pdf_viewer } },
  	{ MODKEY|ShiftMask,             XK_v,                       spawn,          { .v = qt_nvim } },
  	{ MODKEY|ShiftMask,             XK_r,                       spawn,          { .v = roottermcmd } },
  	{ MODKEY|ShiftMask,             XK_b,                       spawn,          { .v = bigtermcmd } },
  	{ MODKEY|Mod1Mask,              XK_u,          incrgaps,               {.i = +1 } },
  	{ MODKEY|Mod1Mask|ShiftMask,    XK_u,          incrgaps,               {.i = -1 } },
  	{ MODKEY|Mod1Mask,              XK_i,          incrigaps,              {.i = +1 } },
  	{ MODKEY|Mod1Mask|ShiftMask,    XK_i,          incrigaps,              {.i = -1 } },
  	{ MODKEY|Mod1Mask,              XK_o,          incrogaps,              {.i = +1 } },
  	{ MODKEY|Mod1Mask|ShiftMask,    XK_o,          incrogaps,              {.i = -1 } },
  	{ MODKEY|Mod1Mask,              XK_6,          incrihgaps,             {.i = +1 } },
  	{ MODKEY|Mod1Mask|ShiftMask,    XK_6,          incrihgaps,             {.i = -1 } },
  	{ MODKEY|Mod1Mask,              XK_7,          incrivgaps,             {.i = +1 } },
  	{ MODKEY|Mod1Mask|ShiftMask,    XK_7,          incrivgaps,             {.i = -1 } },
  	{ MODKEY|Mod1Mask,              XK_8,          incrohgaps,             {.i = +1 } },
  	{ MODKEY|Mod1Mask|ShiftMask,    XK_8,          incrohgaps,             {.i = -1 } },
  	{ MODKEY|Mod1Mask,              XK_9,          incrovgaps,             {.i = +1 } },
  	{ MODKEY|Mod1Mask|ShiftMask,    XK_9,          incrovgaps,             {.i = -1 } },
  	{ MODKEY|ShiftMask,             XK_t,          togglegaps,             {0} },
  	{ MODKEY|Mod1Mask|ShiftMask,    XK_0,          defaultgaps,            {0} },
  };
  
  
  /* button definitions */
  /* click can be ClkTagBar, ClkLtSymbol, ClkStatusText, ClkWinTitle, ClkClientWin, or ClkRootWin */
  static Button buttons[] = {
  	/* click                event mask      button          function        argument */
  	{ ClkLtSymbol,          0,              Button1,        setlayout,      {0} },
  	{ ClkLtSymbol,          0,              Button3,        setlayout,      {.v = &layouts[2]} },
  	{ ClkWinTitle,          0,              Button2,        zoom,           {0} },
  	{ ClkStatusText,        0,              Button2,        spawn,          {.v = termcmd } },
  	{ ClkClientWin,         MODKEY,         Button1,        movemouse,      {0} },
  	{ ClkClientWin,         MODKEY,         Button2,        togglefloating, {0} },
  	{ ClkClientWin,         MODKEY,         Button3,        resizemouse,    {0} },
  	{ ClkTagBar,            0,              Button1,        view,           {0} },
  	{ ClkTagBar,            0,              Button3,        toggleview,     {0} },
  	{ ClkTagBar,            MODKEY,         Button1,        tag,            {0} },
  	{ ClkTagBar,            MODKEY,         Button3,        toggletag,      {0} },
  };
  
  