Split monolithic dwm.h into modular headers and group them by it's functionalities

The new plan of refactoring this project is to split entire monolithic codebase into separate, (kind of) independent modules. This will help with understanding the code by turning off modules and deciding which ones require some work.

Signed-off-by: Filip Wandzio <contact@philw.dev>

18 files changed, 325 insertions, 138 deletions

diff --git a/src/config/config.mk b/src/config/config.mk
deleted file mode 100644
index f8dab1b..0000000
--- a/src/config/config.mk
+++ /dev/null
@@ -1,40 +0,0 @@
-# dwm version
-VERSION = 6.4
-
-# Customize below to fit your system
-
-# paths
-PREFIX = /usr/local
-MANPREFIX = ${PREFIX}/share/man
-
-X11INC = /usr/X11R6/include
-X11LIB = /usr/X11R6/lib
-
-# Xinerama, comment if you don't want it
-XINERAMALIBS  = -lXinerama
-XINERAMAFLAGS = -DXINERAMA
-
-# freetype
-FREETYPELIBS = -lfontconfig -lXft
-FREETYPEINC = /usr/include/freetype2
-# OpenBSD (uncomment)
-#FREETYPEINC = ${X11INC}/freetype2
-#MANPREFIX = ${PREFIX}/man
-#KVMLIB = -lkvm
-
-# includes and libs
-INCS = -I${X11INC} -I${FREETYPEINC}
-LIBS = -L${X11LIB} -lX11 ${XINERAMALIBS} ${FREETYPELIBS} -lX11-xcb -lxcb -lxcb-res ${KVMLIB}
-
-# flags
-CPPFLAGS = -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_XOPEN_SOURCE=700L -DVERSION=\"${VERSION}\" ${XINERAMAFLAGS}
-#CFLAGS   = -g -std=c99 -pedantic -Wall -O0 ${INCS} ${CPPFLAGS}
-CFLAGS   = -std=c99 -pedantic -Wall -Wno-deprecated-declarations -Os ${INCS} ${CPPFLAGS}
-LDFLAGS  = ${LIBS}
-
-# Solaris
-#CFLAGS = -fast ${INCS} -DVERSION=\"${VERSION}\"
-#LDFLAGS = ${LIBS}
-
-# compiler and linker
-CC = tcc
diff --git a/src/core/dwm.c b/src/core/dwm.c
index cd7fdb0..6d4cdcd 100644
--- a/src/core/dwm.c
+++ b/src/core/dwm.c
@@ -851,7 +851,7 @@ Atom getatomprop(Client *c, Atom prop)
         return atom;
 }
 
-unsigned int getsystraywidth()
+unsigned int getsystraywidth(void)
 {
         unsigned int w = 0;
         Client *i;
@@ -1970,7 +1970,7 @@ void updatebarpos(Monitor *m)
                 m->by = -bh;
 }
 
-void updateclientlist()
+void updateclientlist(void)
 {
         Client *c;
         Monitor *m;
diff --git a/src/core/dwm.h b/src/core/dwm.h
index 273645a..d3bdf5a 100644
--- a/src/core/dwm.h
+++ b/src/core/dwm.h
@@ -153,7 +153,7 @@ static void focusin(XEvent *e);
 static Atom getatomprop(Client *c, Atom prop);
 static int getrootptr(int *x, int *y);
 static long getstate(Window w);
-static unsigned int getsystraywidth();
+static unsigned int getsystraywidth(void);
 static int gettextprop(Window w, Atom atom, char *text, unsigned int size);
 static void grabbuttons(Client *c, int focused);
 static void grabkeys(void);
diff --git a/src/core/globals.h b/src/core/globals.h
new file mode 100644
index 0000000..4b800fe
--- /dev/null
+++ b/src/core/globals.h
@@ -0,0 +1,21 @@
+
+#pragma once
+
+#include "types.h"
+
+extern Display *dpy;
+extern Window root, wmcheckwin;
+
+extern Monitor *mons, *selmon;
+
+extern int screen;
+extern int sw, sh;
+extern int bh;
+extern int running;
+extern unsigned int numlockmask;
+
+extern Atom wmatom[WMLast];
+extern Atom netatom[NetLast];
+extern Atom xatom[XLast];
+
+extern Systray *systray;
diff --git a/src/core/types.h b/src/core/types.h
new file mode 100644
index 0000000..dc10fc0
--- /dev/null
+++ b/src/core/types.h
@@ -0,0 +1,158 @@
+
+#pragma once
+
+#include <X11/Xatom.h>
+#include <X11/Xlib.h>
+#include <sys/types.h>
+
+/* cursors */
+enum { CurNormal, CurResize, CurMove, CurLast };
+
+/* color schemes */
+enum { SchemeNorm, SchemeSel };
+
+/* EWMH atoms */
+enum {
+        NetSupported,
+        NetWMName,
+        NetWMState,
+        NetWMCheck,
+        NetSystemTray,
+        NetSystemTrayOP,
+        NetSystemTrayOrientation,
+        NetSystemTrayOrientationHorz,
+        NetWMFullscreen,
+        NetActiveWindow,
+        NetWMWindowType,
+        NetWMWindowTypeDialog,
+        NetClientList,
+        NetLast
+};
+
+/* XEmbed */
+enum { Manager, Xembed, XembedInfo, XLast };
+
+/* ICCCM */
+enum { WMProtocols, WMDelete, WMState, WMTakeFocus, WMLast };
+
+/* clicks */
+enum {
+        ClkTagBar,
+        ClkLtSymbol,
+        ClkStatusText,
+        ClkWinTitle,
+        ClkClientWin,
+        ClkRootWin,
+        ClkLast
+};
+
+/* generic argument */
+typedef union {
+        int i;
+        unsigned int ui;
+        float f;
+        const void *v;
+} Arg;
+
+/* input */
+typedef struct {
+        unsigned int click;
+        unsigned int mask;
+        unsigned int button;
+        void (*func)(const Arg *arg);
+        const Arg arg;
+} Button;
+
+typedef struct {
+        unsigned int mod;
+        KeySym keysym;
+        void (*func)(const Arg *);
+        const Arg arg;
+} Key;
+
+/* forward decls */
+typedef struct Client Client;
+typedef struct Monitor Monitor;
+
+/* layout */
+typedef struct {
+        const char *symbol;
+        void (*arrange)(Monitor *);
+} Layout;
+
+/* client */
+struct Client {
+        char name[256];
+
+        float mina, maxa;
+        int basew, baseh, incw, inch, maxw, maxh, minw, minh;
+        int hintsvalid;
+
+        int x, y, w, h;
+        int oldx, oldy, oldw, oldh;
+        int bw, oldbw;
+
+        unsigned int tags;
+        int isfixed, isfloating, isurgent, neverfocus;
+        int oldstate, isfullscreen;
+        int isterminal, noswallow;
+
+        pid_t pid;
+
+        Client *next;
+        Client *snext;
+        Client *swallowing;
+
+        Monitor *mon;
+        Window win;
+};
+
+/* monitor */
+struct Monitor {
+        char ltsymbol[16];
+
+        float mfact;
+        int nmaster;
+        int num;
+
+        int mx, my, mw, mh;
+        int wx, wy, ww, wh;
+        int by;
+
+        int gappih, gappiv;
+        int gappoh, gappov;
+
+        unsigned int seltags;
+        unsigned int sellt;
+        unsigned int tagset[2];
+
+        int showbar;
+        int topbar;
+
+        Client *clients;
+        Client *sel;
+        Client *stack;
+
+        Monitor *next;
+        Window barwin;
+
+        const Layout *lt[2];
+};
+
+/* rules */
+typedef struct {
+        const char *class;
+        const char *instance;
+        const char *title;
+        unsigned int tags;
+        int isfloating;
+        int isterminal;
+        int noswallow;
+        int monitor;
+} Rule;
+
+/* systray */
+typedef struct Systray {
+        Window win;
+        Client *icons;
+} Systray;
diff --git a/src/drw/drw.c b/src/drw/drw.c
index 05420c0..5e90c2c 100644
--- a/src/drw/drw.c
+++ b/src/drw/drw.c
@@ -111,7 +111,7 @@ static Fnt *xfont_create(Drw *drw, const char *fontname, FcPattern *fontpattern)
                 /* Using the pattern found at font->xfont->pattern does not
                  * yield the same substitution results as using the pattern
                  * returned by FcNameParse; using the latter results in the
-                 * desired fallback behaviour whereas the former just results in
+                 * desired fallback behavior whereas the former just results in
                  * missing-character rectangles being drawn, at least with some
                  * fonts. */
                 if (!(xfont =
diff --git a/src/drw/drw.h b/src/drw/drw.h
index 88308ab..e1c91ae 100644
--- a/src/drw/drw.h
+++ b/src/drw/drw.h
@@ -1,5 +1,6 @@
 /* See LICENSE file for copyright and license details. */
 
+#include <X11/Xft/Xft.h>
 typedef struct {
         Cursor cursor;
 } Cur;
diff --git a/src/transient/transient.c b/src/transient/transient.c
deleted file mode 100644
index fed0f77..0000000
--- a/src/transient/transient.c
+++ /dev/null
@@ -1,90 +0,0 @@
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-#define FLOATING_WINDOW_WIDTH 400
-#define FLOATING_WINDOW_HEIGHT 400
-#define FLOATING_WINDOW_X_POS 100
-#define FLOATING_WINDOW_Y_POS 100
-
-#define TRANSIENT_WINDOW_WIDTH 100
-#define TRANSIENT_WINDOW_HEIGHT 100
-#define TRANSIENT_WINDOW_X_POS 50
-#define TRANSIENT_WINDOW_Y_POS 50
-
-#define SLEEP_TIME 5
-
-#define WINDOW_BORDER_WIDTH 0
-#define WINDOW_BORDER_COLOR 0
-#define WINDOW_BACKGROUND_COLOR 0
-
-/**
- * @brief Function that creates and manages floating and transient window.
- *
- * This program opens an X display, creates a floating window with specific
- * size and position, and then creates a transient (child) window after a
- * specified delay. The transient window is always associated with the
- * floating window, meaning it will behave as a child of the floating window.
- * The program uses Xlib to interact with the X server, handle events, and
- * manage window properties such as size, title, and position.
- *
- * The key steps are:
- * 1. Create the floating window and set its size constraints.
- * 2. After a delay (5 seconds), create the transient window and associate
- *    it with the floating window.
- * 3. Display both windows on the screen.
- * 4. Wait for and process X events in an infinite loop. This allows the
- *    windows to remain open and interact with the X server.
- *
- * @return int Exit status (always 0).
- */
-int main(void)
-{
-        Display *display;
-        Window rootWindow, floatingWindow, transientWindow = None;
-        XSizeHints sizeHints;
-        XEvent event;
-
-        display = XOpenDisplay(NULL);
-        if (!display)
-                exit(1);
-
-        rootWindow = DefaultRootWindow(display);
-
-        floatingWindow = XCreateSimpleWindow(
-            display, rootWindow, FLOATING_WINDOW_X_POS, FLOATING_WINDOW_Y_POS,
-            FLOATING_WINDOW_WIDTH, FLOATING_WINDOW_HEIGHT, WINDOW_BORDER_WIDTH,
-            WINDOW_BORDER_COLOR, WINDOW_BACKGROUND_COLOR);
-
-        sizeHints.min_width = sizeHints.max_width = sizeHints.min_height =
-            sizeHints.max_height = FLOATING_WINDOW_WIDTH;
-        sizeHints.flags = PMinSize | PMaxSize;
-        XSetWMNormalHints(display, floatingWindow, &sizeHints);
-        XStoreName(display, floatingWindow, "floating");
-        XMapWindow(display, floatingWindow);
-        XSelectInput(display, floatingWindow, ExposureMask);
-
-        while (1) {
-                XNextEvent(display, &event);
-
-                if (transientWindow == None) {
-                        sleep(SLEEP_TIME);
-
-                        transientWindow = XCreateSimpleWindow(
-                            display, rootWindow, TRANSIENT_WINDOW_X_POS,
-                            TRANSIENT_WINDOW_Y_POS, TRANSIENT_WINDOW_WIDTH,
-                            TRANSIENT_WINDOW_HEIGHT, WINDOW_BORDER_WIDTH,
-                            WINDOW_BORDER_COLOR, WINDOW_BACKGROUND_COLOR);
-
-                        XSetTransientForHint(display, transientWindow,
-                                             floatingWindow);
-                        XStoreName(display, transientWindow, "transient");
-                        XMapWindow(display, transientWindow);
-                        XSelectInput(display, transientWindow, ExposureMask);
-                }
-        }
-
-        XCloseDisplay(display);
-        exit(0);
-}
diff --git a/src/ui/bar.h b/src/ui/bar.h
new file mode 100644
index 0000000..79e4912
--- /dev/null
+++ b/src/ui/bar.h
@@ -0,0 +1,13 @@
+
+#pragma once
+
+#include "../core/types.h"
+
+void drawbar(Monitor *m);
+void drawbars(void);
+void updatebars(void);
+void updatestatus(void);
+unsigned int getsystraywidth(void);
+
+extern char stext[256];
+extern int lrpad;
diff --git a/src/ui/input.h b/src/ui/input.h
new file mode 100644
index 0000000..54e3c58
--- /dev/null
+++ b/src/ui/input.h
@@ -0,0 +1,13 @@
+
+#pragma once
+
+#include "../core/types.h"
+
+void grabkeys(void);
+void grabbuttons(Client *c, int focused);
+
+void keypress(XEvent *e);
+void buttonpress(XEvent *e);
+
+void movemouse(const Arg *arg);
+void resizemouse(const Arg *arg);
diff --git a/src/ui/systray.h b/src/ui/systray.h
new file mode 100644
index 0000000..ad78f58
--- /dev/null
+++ b/src/ui/systray.h
@@ -0,0 +1,12 @@
+
+#pragma once
+
+#include "../core/types.h"
+
+void updatesystray(void);
+void removesystrayicon(Client *i);
+void updatesystrayicongeom(Client *i, int w, int h);
+void updatesystrayiconstate(Client *i, XPropertyEvent *ev);
+
+Client *wintosystrayicon(Window w);
+Monitor *systraytomon(Monitor *m);
diff --git a/src/util/util.c b/src/util/util.c
index 61c864c..7938f0f 100644
--- a/src/util/util.c
+++ b/src/util/util.c
@@ -54,11 +54,11 @@ void die(const char *format_string, ...)
  *   int *array = ecalloc(10, sizeof(int));  // Allocate memory for an array of
  * 10 integers.
  */
-void *ecalloc(size_t num_elements, size_t element_size)
+void *ecalloc(const size_t num_elements, const size_t element_size)
 {
         void *allocated_memory;
 
-        if (!(allocated_memory = calloc(num_elements, element_size)))
+        if (!((allocated_memory = calloc(num_elements, element_size))))
                 die("calloc:");
 
         return allocated_memory;
diff --git a/src/util/util.h b/src/util/util.h
index 6ef3c86..2c2f773 100644
--- a/src/util/util.h
+++ b/src/util/util.h
@@ -35,7 +35,7 @@
  * Usage:
  *   die("Error occurred in function %s", __func__);
  */
-void die(const char *fmt, ...);
+void die(const char *format_string, ...);
 
 /*
  * ecalloc()
@@ -56,4 +56,4 @@ void die(const char *fmt, ...);
  *   int *arr = ecalloc(10, sizeof(int));  // Allocate memory for an array of 10
  * integers.
  */
-void *ecalloc(size_t nmemb, size_t size);
+void *ecalloc(size_t num_elements, size_t element_size);
diff --git a/src/wm/client.h b/src/wm/client.h
new file mode 100644
index 0000000..8a2a05e
--- /dev/null
+++ b/src/wm/client.h
@@ -0,0 +1,26 @@
+
+#pragma once
+
+#include "../core/types.h"
+
+void manage(Window w, XWindowAttributes *wa);
+void unmanage(Client *c, int destroyed);
+
+void attach(Client *c);
+void detach(Client *c);
+void attachstack(Client *c);
+void detachstack(Client *c);
+
+void focus(Client *c);
+void unfocus(Client *c, int setfocus);
+
+void resize(Client *c, int x, int y, int w, int h, int interact);
+void resizeclient(Client *c, int x, int y, int w, int h);
+
+Client *nexttiled(Client *c);
+Client *wintoclient(Window w);
+
+/* swallow (optional) */
+Client *swallowingclient(Window w);
+Client *termforwin(const Client *c);
+pid_t winpid(Window w);
diff --git a/src/wm/layout.h b/src/wm/layout.h
new file mode 100644
index 0000000..5deab64
--- /dev/null
+++ b/src/wm/layout.h
@@ -0,0 +1,12 @@
+
+#pragma once
+
+#include "../core/types.h"
+
+void arrange(Monitor *m);
+void arrangemon(Monitor *m);
+void tile(Monitor *m);
+void restack(Monitor *m);
+void showhide(Client *c);
+void zoom(const Arg *arg);
+void setlayout(const Arg *arg);
diff --git a/src/wm/monitor.h b/src/wm/monitor.h
new file mode 100644
index 0000000..e09935e
--- /dev/null
+++ b/src/wm/monitor.h
@@ -0,0 +1,15 @@
+
+#pragma once
+
+#include "../core/types.h"
+
+Monitor *createmon(void);
+void cleanupmon(Monitor *mon);
+
+Monitor *recttomon(int x, int y, int w, int h);
+Monitor *wintomon(Window w);
+void sendmon(Client *c, Monitor *m);
+
+int updategeom(void);
+void updatebarpos(Monitor *m);
+void resizebarwin(Monitor *m);
diff --git a/src/x11/xevents.h b/src/x11/xevents.h
new file mode 100644
index 0000000..98129bb
--- /dev/null
+++ b/src/x11/xevents.h
@@ -0,0 +1,25 @@
+
+#pragma once
+
+#include <X11/Xlib.h>
+
+void run(void);
+void scan(void);
+
+void buttonpress(XEvent *e);
+void keypress(XEvent *e);
+void maprequest(XEvent *e);
+void configurerequest(XEvent *e);
+void configurenotify(XEvent *e);
+void destroynotify(XEvent *e);
+void unmapnotify(XEvent *e);
+void clientmessage(XEvent *e);
+void propertynotify(XEvent *e);
+void resizerequest(XEvent *e);
+void mappingnotify(XEvent *e);
+void motionnotify(XEvent *e);
+void enternotify(XEvent *e);
+void focusin(XEvent *e);
+void expose(XEvent *e);
+
+extern void (*handler[LASTEvent])(XEvent *);
diff --git a/src/x11/xutil.h b/src/x11/xutil.h
new file mode 100644
index 0000000..2e044e3
--- /dev/null
+++ b/src/x11/xutil.h
@@ -0,0 +1,21 @@
+
+#pragma once
+
+#include "../core/types.h"
+
+void checkotherwm(void);
+
+Atom getatomprop(Client *c, Atom prop);
+int getrootptr(int *x, int *y);
+long getstate(Window w);
+int gettextprop(Window w, Atom atom, char *text, unsigned int size);
+
+int sendevent(Window w, Atom proto, int m, long d0, long d1, long d2, long d3,
+              long d4);
+
+void setfocus(Client *c);
+void updatenumlockmask(void);
+
+int xerror(Display *dpy, XErrorEvent *ee);
+int xerrordummy(Display *dpy, XErrorEvent *ee);
+int xerrorstart(Display *dpy, XErrorEvent *ee);