forgot to add patch file

LICENSE

@@ -1,6 +1,5 @@
 MIT/X Consortium License
 
-© 2010-2026 Hiltjo Posthuma <hiltjo@codemadness.org>
 © 2006-2019 Anselm R Garbe <anselm@garbe.ca>
 © 2006-2009 Jukka Salmi <jukka at salmi dot ch>
 © 2006-2007 Sander van Dijk <a dot h dot vandijk at gmail dot com>
@@ -12,6 +11,7 @@ MIT/X Consortium License
 © 2008 Martin Hurton <martin dot hurton at gmail dot com>
 © 2008 Neale Pickett <neale dot woozle dot org>
 © 2009 Mate Nagy <mnagy at port70 dot net>
+© 2010-2016 Hiltjo Posthuma <hiltjo@codemadness.org>
 © 2010-2012 Connor Lane Smith <cls@lubutu.com>
 © 2011 Christoph Lohmann <20h@r-36.net>
 © 2015-2016 Quentin Rameau <quinq@fifth.space>

config.def.h

@@ -36,7 +36,6 @@ 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 int refreshrate = 120;  /* refresh rate (per second) for client move/resize */
 
 static const Layout layouts[] = {
 	/* symbol     arrange function */

config.mk

@@ -1,5 +1,5 @@
 # dwm version
-VERSION = 6.8
+VERSION = 6.5
 
 # Customize below to fit your system
 

drw.c

@@ -178,7 +178,8 @@ drw_clr_create(Drw *drw, Clr *dest, const char *clrname)
 		die("error, cannot allocate color '%s'", clrname);
 }
 
-/* Create color schemes. */
+/* Wrapper to create color schemes. The caller has to call free(3) on the
+ * returned color scheme when done using it. */
 Clr *
 drw_scm_create(Drw *drw, const char *clrnames[], size_t clrcount)
 {
@@ -186,7 +187,7 @@ drw_scm_create(Drw *drw, const char *clrnames[], size_t clrcount)
 	Clr *ret;
 
 	/* need at least two colors for a scheme */
-	if (!drw || !clrnames || clrcount < 2 || !(ret = ecalloc(clrcount, sizeof(Clr))))
+	if (!drw || !clrnames || clrcount < 2 || !(ret = ecalloc(clrcount, sizeof(XftColor))))
 		return NULL;
 
 	for (i = 0; i < clrcount; i++)
@@ -194,30 +195,6 @@ drw_scm_create(Drw *drw, const char *clrnames[], size_t clrcount)
 	return ret;
 }
 
-void
-drw_clr_free(Drw *drw, Clr *c)
-{
-	if (!drw || !c)
-		return;
-
-	/* c is typedef XftColor Clr */
-	XftColorFree(drw->dpy, DefaultVisual(drw->dpy, drw->screen),
-	             DefaultColormap(drw->dpy, drw->screen), c);
-}
-
-void
-drw_scm_free(Drw *drw, Clr *scm, size_t clrcount)
-{
-	size_t i;
-
-	if (!drw || !scm)
-		return;
-
-	for (i = 0; i < clrcount; i++)
-		drw_clr_free(drw, &scm[i]);
-	free(scm);
-}
-
 void
 drw_setfontset(Drw *drw, Fnt *set)
 {

drw.h

@@ -40,9 +40,7 @@ void drw_font_getexts(Fnt *font, const char *text, unsigned int len, unsigned in
 
 /* Colorscheme abstraction */
 void drw_clr_create(Drw *drw, Clr *dest, const char *clrname);
-void drw_clr_free(Drw *drw, Clr *c);
 Clr *drw_scm_create(Drw *drw, const char *clrnames[], size_t clrcount);
-void drw_scm_free(Drw *drw, Clr *scm, size_t clrcount);
 
 /* Cursor abstraction */
 Cur *drw_cur_create(Drw *drw, int shape);

dwm-keychord-6.4.diff

@@ -0,0 +1,234 @@
+From cb7ea178ac8e60cf123b333af64df8228762f669 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Aaron=20Z=C3=BCger?= <contact@azureorange.xyz>
+Date: Wed, 19 Jul 2023 14:17:39 +0200
+Subject: [PATCH] Update dwm-keychord patch to comply with the changes in dwm
+ from version 6.2 to version 6.4. Namely changes in the grabkey function to
+ match the newer implementation of said function.
+
+---
+ config.def.h | 81 ++++++++++++++++++++++++++--------------------------
+ dwm.c        | 72 +++++++++++++++++++++++++++++++++++++---------
+ 2 files changed, 99 insertions(+), 54 deletions(-)
+
+diff --git a/config.def.h b/config.def.h
+index 9efa774..49f0558 100644
+--- a/config.def.h
++++ b/config.def.h
+@@ -46,11 +46,11 @@ static const Layout layouts[] = {
+
+ /* key definitions */
+ #define MODKEY Mod1Mask
+-#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} },
++#define TAGKEYS(KEY,TAG)                                                                                               \
++       &((Keychord){1, {{MODKEY, KEY}},                                        view,           {.ui = 1 << TAG} }), \
++       &((Keychord){1, {{MODKEY|ControlMask, KEY}},                            toggleview,     {.ui = 1 << TAG} }), \
++       &((Keychord){1, {{MODKEY|ShiftMask, KEY}},                              tag,            {.ui = 1 << TAG} }), \
++       &((Keychord){1, {{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 } }
+@@ -60,41 +60,42 @@ static char dmenumon[2] = "0"; /* component of dmenucmd, manipulated in spawn()
+ static const char *dmenucmd[] = { "dmenu_run", "-m", dmenumon, "-fn", dmenufont, "-nb", col_gray1, "-nf", col_gray3, "-sb", col_cyan, "-sf", col_gray4, NULL };
+ static const char *termcmd[]  = { "st", NULL };
+
+-static const Key keys[] = {
+-	/* modifier                     key        function        argument */
+-	{ MODKEY,                       XK_p,      spawn,          {.v = dmenucmd } },
+-	{ MODKEY|ShiftMask,             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,                       XK_Return, zoom,           {0} },
+-	{ MODKEY,                       XK_Tab,    view,           {0} },
+-	{ MODKEY|ShiftMask,             XK_c,      killclient,     {0} },
+-	{ MODKEY,                       XK_t,      setlayout,      {.v = &layouts[0]} },
+-	{ MODKEY,                       XK_f,      setlayout,      {.v = &layouts[1]} },
+-	{ MODKEY,                       XK_m,      setlayout,      {.v = &layouts[2]} },
+-	{ MODKEY,                       XK_space,  setlayout,      {0} },
+-	{ MODKEY|ShiftMask,             XK_space,  togglefloating, {0} },
+-	{ MODKEY,                       XK_0,      view,           {.ui = ~0 } },
+-	{ MODKEY|ShiftMask,             XK_0,      tag,            {.ui = ~0 } },
+-	{ MODKEY,                       XK_comma,  focusmon,       {.i = -1 } },
+-	{ MODKEY,                       XK_period, focusmon,       {.i = +1 } },
+-	{ MODKEY|ShiftMask,             XK_comma,  tagmon,         {.i = -1 } },
+-	{ MODKEY|ShiftMask,             XK_period, tagmon,         {.i = +1 } },
+-	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|ShiftMask,             XK_q,      quit,           {0} },
++static Keychord *keychords[] = {
++       /* Keys        function        argument */
++       &((Keychord){1, {{MODKEY, XK_p}},                                       spawn,          {.v = dmenucmd } }),
++       &((Keychord){1, {{MODKEY|ShiftMask, XK_Return}},                        spawn,          {.v = termcmd } }),
++       &((Keychord){2, {{MODKEY, XK_e}, {MODKEY, XK_e}},                       spawn,          {.v = termcmd } }),
++       &((Keychord){1, {{MODKEY, XK_b}},                                       togglebar,      {0} }),
++       &((Keychord){1, {{MODKEY, XK_j}},                                       focusstack,     {.i = +1 } }),
++       &((Keychord){1, {{MODKEY, XK_k}},                                       focusstack,     {.i = -1 } }),
++       &((Keychord){1, {{MODKEY, XK_i}},                                       incnmaster,     {.i = +1 } }),
++       &((Keychord){1, {{MODKEY, XK_d}},                                       incnmaster,     {.i = -1 } }),
++       &((Keychord){1, {{MODKEY, XK_h}},                                       setmfact,       {.f = -0.05} }),
++       &((Keychord){1, {{MODKEY, XK_l}},                                       setmfact,       {.f = +0.05} }),
++       &((Keychord){1, {{MODKEY, XK_Return}},                                  zoom,           {0} }),
++       &((Keychord){1, {{MODKEY, XK_Tab}},                                     view,           {0} }),
++       &((Keychord){1, {{MODKEY|ShiftMask, XK_c}},                             killclient,     {0} }),
++       &((Keychord){1, {{MODKEY, XK_t}},                                       setlayout,      {.v = &layouts[0]} }),
++       &((Keychord){1, {{MODKEY, XK_f}},                                       setlayout,      {.v = &layouts[1]} }),
++       &((Keychord){1, {{MODKEY, XK_m}},                                       setlayout,      {.v = &layouts[2]} }),
++       &((Keychord){1, {{MODKEY, XK_space}},                                   setlayout,      {0} }),
++       &((Keychord){1, {{MODKEY|ShiftMask, XK_space}},                         togglefloating, {0} }),
++       &((Keychord){1, {{MODKEY, XK_0}},                                       view,           {.ui = ~0 } }),
++       &((Keychord){1, {{MODKEY|ShiftMask, XK_0}},                             tag,            {.ui = ~0 } }),
++       &((Keychord){1, {{MODKEY, XK_comma}},                                   focusmon,       {.i = -1 } }),
++       &((Keychord){1, {{MODKEY, XK_period}},                                  focusmon,       {.i = +1 } }),
++       &((Keychord){1, {{MODKEY|ShiftMask, XK_comma}},                         tagmon,         {.i = -1 } }),
++       &((Keychord){1, {{MODKEY|ShiftMask, XK_period}},                        tagmon,         {.i = +1 } }),
++       &((Keychord){1, {{MODKEY|ShiftMask, XK_q}},                             quit,           {0} }),
++	   TAGKEYS(                        XK_1,                      0)
++	   TAGKEYS(                        XK_2,                      1)
++	   TAGKEYS(                        XK_3,                      2)
++	   TAGKEYS(                        XK_4,                      3)
++	   TAGKEYS(                        XK_5,                      4)
++	   TAGKEYS(                        XK_6,                      5)
++	   TAGKEYS(                        XK_7,                      6)
++	   TAGKEYS(                        XK_8,                      7)
++	   TAGKEYS(                        XK_9,                      8)
+ };
+
+ /* button definitions */
+diff --git a/dwm.c b/dwm.c
+index f1d86b2..e4885a4 100644
+--- a/dwm.c
++++ b/dwm.c
+@@ -102,9 +102,14 @@ struct Client {
+ typedef struct {
+ 	unsigned int mod;
+ 	KeySym keysym;
++} Key;
++
++typedef struct {
++    unsigned int n;
++    const Key keys[5];
+ 	void (*func)(const Arg *);
+ 	const Arg arg;
+-} Key;
++} Keychord;
+
+ typedef struct {
+ 	const char *symbol;
+@@ -267,6 +272,7 @@ static Display *dpy;
+ static Drw *drw;
+ static Monitor *mons, *selmon;
+ static Window root, wmcheckwin;
++unsigned int currentkey = 0;
+
+ /* configuration, allows nested code to access above variables */
+ #include "config.h"
+@@ -954,7 +960,8 @@ grabkeys(void)
+ {
+ 	updatenumlockmask();
+ 	{
+-		unsigned int i, j, k;
++		/* unsigned int i, j, k; */
++		unsigned int i, c, k;
+ 		unsigned int modifiers[] = { 0, LockMask, numlockmask, numlockmask|LockMask };
+ 		int start, end, skip;
+ 		KeySym *syms;
+@@ -964,15 +971,18 @@ grabkeys(void)
+ 		syms = XGetKeyboardMapping(dpy, start, end - start + 1, &skip);
+ 		if (!syms)
+ 			return;
++
+ 		for (k = start; k <= end; k++)
+-			for (i = 0; i < LENGTH(keys); i++)
++			for (i = 0; i < LENGTH(keychords); i++)
+ 				/* skip modifier codes, we do that ourselves */
+-				if (keys[i].keysym == syms[(k - start) * skip])
+-					for (j = 0; j < LENGTH(modifiers); j++)
++				if (keychords[i]->keys[currentkey].keysym == syms[(k - start) * skip])
++					for (c = 0; c < LENGTH(modifiers); c++)
+ 						XGrabKey(dpy, k,
+-							 keys[i].mod | modifiers[j],
++							 keychords[i]->keys[currentkey].mod | modifiers[c],
+ 							 root, True,
+ 							 GrabModeAsync, GrabModeAsync);
++                if(currentkey > 0)
++                        XGrabKey(dpy, XKeysymToKeycode(dpy, XK_Escape), AnyModifier, root, True, GrabModeAsync, GrabModeAsync);
+ 		XFree(syms);
+ 	}
+ }
+@@ -999,17 +1009,51 @@ isuniquegeom(XineramaScreenInfo *unique, size_t n, XineramaScreenInfo *info)
+ void
+ keypress(XEvent *e)
+ {
+-	unsigned int i;
++	/* unsigned int i; */
++    XEvent event = *e;
++    unsigned int ran = 0;
+ 	KeySym keysym;
+ 	XKeyEvent *ev;
+
+-	ev = &e->xkey;
+-	keysym = XKeycodeToKeysym(dpy, (KeyCode)ev->keycode, 0);
+-	for (i = 0; i < LENGTH(keys); i++)
+-		if (keysym == keys[i].keysym
+-		&& CLEANMASK(keys[i].mod) == CLEANMASK(ev->state)
+-		&& keys[i].func)
+-			keys[i].func(&(keys[i].arg));
++    Keychord *arr1[sizeof(keychords) / sizeof(Keychord*)];
++    Keychord *arr2[sizeof(keychords) / sizeof(Keychord*)];
++    memcpy(arr1, keychords, sizeof(keychords));
++    Keychord **rpointer = arr1;
++    Keychord **wpointer = arr2;
++
++    size_t r = sizeof(keychords)/ sizeof(Keychord*);
++
++    while(1){
++            ev = &event.xkey;
++            keysym = XKeycodeToKeysym(dpy, (KeyCode)ev->keycode, 0);
++            size_t w = 0;
++            for (int i = 0; i < r; i++){
++                    if(keysym == (*(rpointer + i))->keys[currentkey].keysym
++                       && CLEANMASK((*(rpointer + i))->keys[currentkey].mod) == CLEANMASK(ev->state)
++                       && (*(rpointer + i))->func){
++                            if((*(rpointer + i))->n == currentkey +1){
++                                    (*(rpointer + i))->func(&((*(rpointer + i))->arg));
++                                    ran = 1;
++                            }else{
++                                    *(wpointer + w) = *(rpointer + i);
++                                    w++;
++                            }
++                    }
++            }
++            currentkey++;
++            if(w == 0 || ran == 1)
++                    break;
++            grabkeys();
++            while (running && !XNextEvent(dpy, &event) && !ran)
++                    if(event.type == KeyPress)
++                            break;
++            r = w;
++            Keychord **holder = rpointer;
++            rpointer = wpointer;
++            wpointer = holder;
++    }
++    currentkey = 0;
++    grabkeys();
+ }
+
+ void
+--
+2.41.0

dwm.c

@@ -101,9 +101,14 @@ struct Client {
 typedef struct {
 	unsigned int mod;
 	KeySym keysym;
+} Key;
+
+typedef struct {
+    unsigned int n;
+    const Key keys[5];
 	void (*func)(const Arg *);
 	const Arg arg;
-} Key;
+} Keychord;
 
 typedef struct {
 	const char *symbol;
@@ -266,6 +271,7 @@ static Display *dpy;
 static Drw *drw;
 static Monitor *mons, *selmon;
 static Window root, wmcheckwin;
+unsigned int currentkey = 0;
 
 /* configuration, allows nested code to access above variables */
 #include "config.h"
@@ -440,7 +446,7 @@ buttonpress(XEvent *e)
 			arg.ui = 1 << i;
 		} else if (ev->x < x + TEXTW(selmon->ltsymbol))
 			click = ClkLtSymbol;
-		else if (ev->x > selmon->ww - (int)TEXTW(stext) + lrpad - 2)
+		else if (ev->x > selmon->ww - (int)TEXTW(stext))
 			click = ClkStatusText;
 		else
 			click = ClkWinTitle;
@@ -486,7 +492,7 @@ cleanup(void)
 	for (i = 0; i < CurLast; i++)
 		drw_cur_free(drw, cursor[i]);
 	for (i = 0; i < LENGTH(colors); i++)
-		drw_scm_free(drw, scheme[i], 3);
+		free(scheme[i]);
 	free(scheme);
 	XDestroyWindow(dpy, wmcheckwin);
 	drw_free(drw);
@@ -863,15 +869,14 @@ focusstack(const Arg *arg)
 Atom
 getatomprop(Client *c, Atom prop)
 {
-	int format;
-	unsigned long nitems, dl;
+	int di;
+	unsigned long dl;
 	unsigned char *p = NULL;
 	Atom da, atom = None;
 
 	if (XGetWindowProperty(dpy, c->win, prop, 0L, sizeof atom, False, XA_ATOM,
-		&da, &format, &nitems, &dl, &p) == Success && p) {
-		if (nitems > 0 && format == 32)
-			atom = *(long *)p;
+		&da, &di, &dl, &dl, &p) == Success && p) {
+		atom = *(Atom *)p;
 		XFree(p);
 	}
 	return atom;
@@ -897,10 +902,10 @@ getstate(Window w)
 	Atom real;
 
 	if (XGetWindowProperty(dpy, w, wmatom[WMState], 0L, 2L, False, wmatom[WMState],
-		&real, &format, &n, &extra, &p) != Success)
+		&real, &format, &n, &extra, (unsigned char **)&p) != Success)
 		return -1;
-	if (n != 0 && format == 32)
-		result = *(long *)p;
+	if (n != 0)
+		result = *p;
 	XFree(p);
 	return result;
 }
@@ -954,7 +959,8 @@ grabkeys(void)
 {
 	updatenumlockmask();
 	{
-		unsigned int i, j, k;
+		/* unsigned int i, j, k; */
+		unsigned int i, c, k;
 		unsigned int modifiers[] = { 0, LockMask, numlockmask, numlockmask|LockMask };
 		int start, end, skip;
 		KeySym *syms;
@@ -964,15 +970,18 @@ grabkeys(void)
 		syms = XGetKeyboardMapping(dpy, start, end - start + 1, &skip);
 		if (!syms)
 			return;
+
 		for (k = start; k <= end; k++)
-			for (i = 0; i < LENGTH(keys); i++)
+			for (i = 0; i < LENGTH(keychords); i++)
 				/* skip modifier codes, we do that ourselves */
-				if (keys[i].keysym == syms[(k - start) * skip])
-					for (j = 0; j < LENGTH(modifiers); j++)
+				if (keychords[i]->keys[currentkey].keysym == syms[(k - start) * skip])
+					for (c = 0; c < LENGTH(modifiers); c++)
 						XGrabKey(dpy, k,
-							 keys[i].mod | modifiers[j],
+							 keychords[i]->keys[currentkey].mod | modifiers[c],
 							 root, True,
 							 GrabModeAsync, GrabModeAsync);
+                if(currentkey > 0)
+                        XGrabKey(dpy, XKeysymToKeycode(dpy, XK_Escape), AnyModifier, root, True, GrabModeAsync, GrabModeAsync);
 		XFree(syms);
 	}
 }
@@ -999,17 +1008,51 @@ isuniquegeom(XineramaScreenInfo *unique, size_t n, XineramaScreenInfo *info)
 void
 keypress(XEvent *e)
 {
-	unsigned int i;
+	/* unsigned int i; */
+    XEvent event = *e;
+    unsigned int ran = 0;
 	KeySym keysym;
 	XKeyEvent *ev;
 
-	ev = &e->xkey;
+    Keychord *arr1[sizeof(keychords) / sizeof(Keychord*)];
+    Keychord *arr2[sizeof(keychords) / sizeof(Keychord*)];
+    memcpy(arr1, keychords, sizeof(keychords));
+    Keychord **rpointer = arr1;
+    Keychord **wpointer = arr2;
+
+    size_t r = sizeof(keychords)/ sizeof(Keychord*);
+
+    while(1){
+            ev = &event.xkey;
             keysym = XKeycodeToKeysym(dpy, (KeyCode)ev->keycode, 0);
-	for (i = 0; i < LENGTH(keys); i++)
-		if (keysym == keys[i].keysym
-		&& CLEANMASK(keys[i].mod) == CLEANMASK(ev->state)
-		&& keys[i].func)
-			keys[i].func(&(keys[i].arg));
+            size_t w = 0;
+            for (int i = 0; i < r; i++){
+                    if(keysym == (*(rpointer + i))->keys[currentkey].keysym
+                       && CLEANMASK((*(rpointer + i))->keys[currentkey].mod) == CLEANMASK(ev->state)
+                       && (*(rpointer + i))->func){
+                            if((*(rpointer + i))->n == currentkey +1){
+                                    (*(rpointer + i))->func(&((*(rpointer + i))->arg));
+                                    ran = 1;
+                            }else{
+                                    *(wpointer + w) = *(rpointer + i);
+                                    w++;
+                            }
+                    }
+            }
+            currentkey++;
+            if(w == 0 || ran == 1)
+                    break;
+            grabkeys();
+            while (running && !XNextEvent(dpy, &event) && !ran)
+                    if(event.type == KeyPress)
+                            break;
+            r = w;
+            Keychord **holder = rpointer;
+            rpointer = wpointer;
+            wpointer = holder;
+    }
+    currentkey = 0;
+    grabkeys();
 }
 
 void
@@ -1172,7 +1215,7 @@ movemouse(const Arg *arg)
 			handler[ev.type](&ev);
 			break;
 		case MotionNotify:
-			if ((ev.xmotion.time - lasttime) <= (1000 / refreshrate))
+			if ((ev.xmotion.time - lasttime) <= (1000 / 60))
 				continue;
 			lasttime = ev.xmotion.time;
 
@@ -1326,7 +1369,7 @@ resizemouse(const Arg *arg)
 			handler[ev.type](&ev);
 			break;
 		case MotionNotify:
-			if ((ev.xmotion.time - lasttime) <= (1000 / refreshrate))
+			if ((ev.xmotion.time - lasttime) <= (1000 / 60))
 				continue;
 			lasttime = ev.xmotion.time;
 
@@ -1429,8 +1472,6 @@ sendmon(Client *c, Monitor *m)
 	c->tags = m->tagset[m->seltags]; /* assign tags of target monitor */
 	attach(c);
 	attachstack(c);
-	if (c->isfullscreen)
-		resizeclient(c, m->mx, m->my, m->mw, m->mh);
 	focus(NULL);
 	arrange(NULL);
 }
@@ -1472,10 +1513,12 @@ sendevent(Client *c, Atom proto)
 void
 setfocus(Client *c)
 {
-	if (!c->neverfocus)
+	if (!c->neverfocus) {
 		XSetInputFocus(dpy, c->win, RevertToPointerRoot, CurrentTime);
-	XChangeProperty(dpy, root, netatom[NetActiveWindow], XA_WINDOW, 32,
-		PropModeReplace, (unsigned char *)&c->win, 1);
+		XChangeProperty(dpy, root, netatom[NetActiveWindow],
+			XA_WINDOW, 32, PropModeReplace,
+			(unsigned char *) &(c->win), 1);
+	}
 	sendevent(c, wmatom[WMTakeFocus]);
 }