This would be awesome, and a great time to do this. I have thought about this in the past but it got a bit more complex than I'd like. My attempts usually started something like this:

typedef enum eScreenDir {
  SCREEN_DIR_NONE = 0, /* Unset, unknown, or invalid. */
  SCREEN_DIR_W = (1 << 0), /* To West/Left. */
  SCREEN_DIR_N = (1 << 1), /* To North/Up. */
  SCREEN_DIR_E = (1 << 2), /* To East/Right. */
  SCREEN_DIR_S = (1 << 3), /* To South/Down. */
  SCREEN_AXIS_H = SCREEN_DIR_W | SCREEN_DIR_E,
  SCREEN_AXIS_V = SCREEN_DIR_N | SCREEN_DIR_S
} eScreenDir;

Using zero for no direction seemed to fit well, and using bits allowed simplification of all the ELEM(dir, SCREEN_DIR_N, SCREEN_DIR_S) all over the place, and also gets rid of the 'h' and 'v' char values.

But I'd usually give up on the attempts because I found it difficult to find all the usages of these directions all over. I normally want one patch to fix everything and not have to go back and incrementally fix what I missed.

Since the current uses of the enum don't mix directions, I'd rather this be a separate enum/flag, e.g. SCREEN_DIR_MASK_W = (1 << SCREEN_DIR_W).

Then it's clear when multiple directions need to be checked.

@Campbell Barton (campbellbarton) - Then it's clear when multiple directions need to be checked.

Or maybe like this. I just like the idea of getting rid of the "v/h" char values.

typedef enum eScreenDir {
  SCREEN_DIR_NONE = 0, /* Unset, unknown, or invalid. */
  SCREEN_DIR_W = (1 << 0), /* To West/Left. */
  SCREEN_DIR_N = (1 << 1), /* To North/Up. */
  SCREEN_DIR_E = (1 << 2), /* To East/Right. */
  SCREEN_DIR_S = (1 << 3), /* To South/Down. */
} eScreenDir;

typedef enum eScreenAxis {
  SCREEN_AXIS_NONE = 0,
  SCREEN_AXIS_H = SCREEN_DIR_W | SCREEN_DIR_E, /* Horizontal */
  SCREEN_AXIS_V = SCREEN_DIR_N | SCREEN_DIR_S, /* Vertical. */
} eScreenAxis;

#define SCREEN_DIR_IS_V(dir) (SCREEN_AXIS_V & dir)
#define SCREEN_DIR_IS_H(dir) (SCREEN_AXIS_H & dir)

The problem with making these flags is any code that uses them might check if (dir & SCREEN_DIR_W) {...} instead of if (dir == SCREEN_DIR_W) {...}.
Then anyone changing the code might reasonably mix direction flags together and pass them to functions.

Since the existing logic doesn't gain much/anything from mixing these as flags, making them into flags adds ambiguity where the current usage is strict.

We could do this:

typedef enum eScreenAxis {
  SCREEN_AXIS_H = (1 << SCREEN_DIR_W) | (1 << SCREEN_DIR_E), /* Horizontal */
  SCREEN_AXIS_V = (1 << SCREEN_DIR_N) | (1 << SCREEN_DIR_S), /* Vertical. */
} eScreenAxis;

#define SCREEN_DIR_IS_V(dir) (SCREEN_AXIS_V & (1 << (dir)))
#define SCREEN_DIR_IS_H(dir) (SCREEN_AXIS_H & (1 << (dir)))

Although comparing directly with the enum is less error prone as it will give useful warning messages if an incompatible enum is used.

Thanks, committed rB079f415debd85b44f9ceaca17edfb82517240448