enable swallow for every client

[apprehensions]

i'm not sure how to allow every window to be able to swallow windows, this can be useful for file managers and various terminals i use, plus i am not sure how to enable swallowing as there is no template'd rule for such a thing

[bakkeby]

Maybe read through https://dwm.suckless.org/patches/swallow/?

If you create client rules that marks a client as a "terminal" then that client will be able to swallow windows.

As you say this would be great for file managers like nautilus as an example, but the swallow functionality depends on two things:

• the _NET_WM_PID property is set for the window referring to the process that owns the window and
• that PID is a descendant of the given client

If you open an image or a document from nautilus then this will open as an orphan, as in the opened window has nothing to do with nautilus. As such swallowing will not work in this case because the opened window is not a descendant of the file manager.

Most programs launching other program will work this way and terminal emulators is more like an exception in this context. That would the reason why the client rule indicates a "terminal" rather than something more generic like "can swallow".

The Rule struct controls the options when it comes to client rules:

dwm-flexipatch/dwm.c

Lines 535 to 574 in fcbe686

	typedef struct {
	const char *class;
	#if WINDOWROLERULE_PATCH
	const char *role;
	#endif // WINDOWROLERULE_PATCH
	const char *instance;
	const char *title;
	const char *wintype;
	unsigned int tags;
	#if SWITCHTAG_PATCH
	int switchtag;
	#endif // SWITCHTAG_PATCH
	#if CENTER_PATCH
	int iscentered;
	#endif // CENTER_PATCH
	int isfloating;
	#if SELECTIVEFAKEFULLSCREEN_PATCH && FAKEFULLSCREEN_CLIENT_PATCH && !FAKEFULLSCREEN_PATCH
	int isfakefullscreen;
	#endif // SELECTIVEFAKEFULLSCREEN_PATCH
	#if SIZEHINTS_ISFREESIZE_PATCH
	int isfreesize;
	#endif // SIZEHINTS_ISFREESIZE_PATCH
	#if ISPERMANENT_PATCH
	int ispermanent;
	#endif // ISPERMANENT_PATCH
	#if SWALLOW_PATCH
	int isterminal;
	int noswallow;
	#endif // SWALLOW_PATCH
	#if FLOATPOS_PATCH
	const char *floatpos;
	#endif // FLOATPOS_PATCH
	int monitor;
	#if RENAMED_SCRATCHPADS_PATCH
	const char scratchkey;
	#endif // RENAMED_SCRATCHPADS_PATCH
	#if XKB_PATCH
	int xkb_layout;
	#endif // XKB_PATCH
	} Rule;

An example rule could be:

RULE(.class = "st-256color", .terminal = 1)

[apprehensions]

alright, since thats how the rule is done; what i was trying to ask is how to enable the terminal or noswallow for all windows by default, allowing various windows to swallow?

[bakkeby]

The way I would describe it is that there are two parts to client rules:

• rule filters and
• rule options

Rule filters are used when matching rules to windows when they first map. For example a rule can match on a window class, instance, title, role or type.

When a rule matches then the rule options are applied to the given window. An example rule option would be to place the window on tag 8 or to make it floating.

Enabling terminal for all windows by default would simply be a matter of creating a rule that has no rule filters, i.e. the rule will apply to all windows unless.

For example the following rule would make all windows floating by default.

RULE(.isfloating = 1)

or using a traditional struct table you would have:

   // class      instance  title  wintype  tags mask  isfloating  monitor
   { NULL,       NULL,     NULL,  NULL,    0,         1,          -1 },

The way rule matching work in dwm is that once a match has been found it will continue to search through the rules looking for other matches. As in the last rule takes precedence. This is due to a lack of a break statement after a matching rule has been found.

This means that you would want to put the rule that you want to apply to all window to be the very first rule. Generic rules first, specific matching last.

If you do not like this behaviour then in dwm-flexipatch you have the option to add a break point such that the first rule to match is the one that applies. I.e. specific rules first and generic rules last. This is enabled via the ONLY_ONE_RULE_MATCH_PATCH toggle.

If you were to use this solution then you would want to add your all matching rule to be the very last rule in the list.