The great formattening!

1 files changed, 254 insertions, 247 deletions

diff --git a/src/input.c b/src/input.c
index 633145a..f026260 100644
--- a/src/input.c
+++ b/src/input.c
@@ -1,332 +1,339 @@
-#include <string.h>
-#include <engine/input.h>
 #include <engine/dltools.h>
+#include <engine/input.h>
 #include <engine/logging.h>
+#include <string.h>
 
 /* Lazy binds, used internally. They are similar to BindAction and friends.
  * The only difference is that we set callbacks and such to NULL, but populate
  * the function name strings such that can be reloaded. */
-#define BindActionLazy(key, altkey, action_str) \
-  (binding_t){\
-  .action = (action_t){.action = {\
-		.type = InputType_action,\
-		.callback     = NULL,\
-		.callback_str = strdup( action_str ),\
-	}},\
-	.scancode = key,\
-	.scancode_alt = altkey,\
-  .since_last_activation = 0\
-}
+#define BindActionLazy(key, altkey, action_str)                                \
+  (binding_t) {                                                                \
+    .action = (action_t){.action =                                             \
+                             {                                                 \
+                                 .type = InputType_action,                     \
+                                 .callback = NULL,                             \
+                                 .callback_str = strdup(action_str),           \
+                             }},                                               \
+    .scancode = key, .scancode_alt = altkey, .since_last_activation = 0        \
+  }
 
-#define BindStateLazy(key, altkey, _activate_str , _deactivate_str) \
-  (binding_t){\
-  .action = (action_t){.state = {\
-		.type = InputType_state,\
-    .activate   = NULL,\
-    .deactivate = NULL,\
-    .activate_str   = strdup( _activate_str ),\
-    .deactivate_str = strdup( _deactivate_str ),\
-	}},\
-	.scancode = key,\
-	.scancode_alt = altkey,\
-  .since_last_activation = 0\
-}
+#define BindStateLazy(key, altkey, _activate_str, _deactivate_str)             \
+  (binding_t) {                                                                \
+    .action = (action_t){.state =                                              \
+                             {                                                 \
+                                 .type = InputType_state,                      \
+                                 .activate = NULL,                             \
+                                 .deactivate = NULL,                           \
+                                 .activate_str = strdup(_activate_str),        \
+                                 .deactivate_str = strdup(_deactivate_str),    \
+                             }},                                               \
+    .scancode = key, .scancode_alt = altkey, .since_last_activation = 0        \
+  }
 
 void binding_t_free(binding_t* b) {
-	switch (b->action.type) {
-		case InputType_error:
-			ERROR("Cannot free binding of type InputType_error");
-			break;
-		case InputType_action:
-			free(b->action.action.callback_str);
-			return;
+  switch (b->action.type) {
+  case InputType_error:
+    ERROR("Cannot free binding of type InputType_error");
+    break;
+  case InputType_action:
+    free(b->action.action.callback_str);
+    return;
 
-		case InputType_state:
-			free(b->action.state.activate_str);
-			free(b->action.state.deactivate_str);
-			break;
+  case InputType_state:
+    free(b->action.state.activate_str);
+    free(b->action.state.deactivate_str);
+    break;
 
-		case InputType_range:
-			ERROR("Cannot free binding of type InputType_rage");
-			break;
+  case InputType_range:
+    ERROR("Cannot free binding of type InputType_rage");
+    break;
 
-		default:
-			ERROR("Unknown bindings type");
-			break;
-	}
-	exit(EXIT_FAILURE);
+  default:
+    ERROR("Unknown bindings type");
+    break;
+  }
+  exit(EXIT_FAILURE);
 }
 
 void i_ctx_t_free(i_ctx* c) {
-	for (isize i = 0; i < c->len; i++) {
-		binding_t_free(&c->bindings[i]);
-	}
+  for (isize i = 0; i < c->len; i++) {
+    binding_t_free(&c->bindings[i]);
+  }
 }
 
-bool binding_action_cmp(binding_t *restrict a, binding_t *restrict b) {
-	InputType t = a->action.type;
-	if (t != b->action.type) return false;
-	switch (t) {
-		case InputType_action:
-			return !strcmp(a->action.action.callback_str, b->action.action.callback_str);
+bool binding_action_cmp(binding_t* restrict a, binding_t* restrict b) {
+  InputType t = a->action.type;
+  if (t != b->action.type) return false;
+  switch (t) {
+  case InputType_action:
+    return !strcmp(a->action.action.callback_str,
+                   b->action.action.callback_str);
 
-		case InputType_state:
-			return (!strcmp(a->action.state.activate_str,   b->action.state.activate_str))
-			    && (!strcmp(a->action.state.deactivate_str, b->action.state.deactivate_str));
+  case InputType_state:
+    return (!strcmp(a->action.state.activate_str,
+                    b->action.state.activate_str)) &&
+           (!strcmp(a->action.state.deactivate_str,
+                    b->action.state.deactivate_str));
 
-		case InputType_range: // fallthrough
-		default:
-			return false; // not implemented
-	}
-	return false;
+  case InputType_range:  // fallthrough
+  default:
+    return false;  // not implemented
+  }
+  return false;
 }
 
-bool binding_scancode_cmp(binding_t *restrict a, binding_t *restrict b) {
-	return a->scancode == b->scancode
-	    || a->scancode_alt == b->scancode_alt;
+bool binding_scancode_cmp(binding_t* restrict a, binding_t* restrict b) {
+  return a->scancode == b->scancode || a->scancode_alt == b->scancode_alt;
 }
 
-bool binding_scancode_cmp_i(binding_t *restrict a, scancode_t scancode) {
-	return a->scancode == scancode
-	    || a->scancode_alt == scancode;
+bool binding_scancode_cmp_i(binding_t* restrict a, scancode_t scancode) {
+  return a->scancode == scancode || a->scancode_alt == scancode;
 }
 
 // If any binding in ctx contains action, replace that entry.
-bool i_update_binding(i_ctx *ctx, binding_t* binding) {
-	isize idx = 0;
-	if (ctx == NULL || binding == NULL) {
-		ERROR("i_update_binding received nullptr!");
-		return false;
-	}
+bool i_update_binding(i_ctx* ctx, binding_t* binding) {
+  isize idx = 0;
+  if (ctx == NULL || binding == NULL) {
+    ERROR("i_update_binding received nullptr!");
+    return false;
+  }
 
-	while (idx < ctx->len && !binding_action_cmp(&ctx->bindings[idx], binding)) idx++;
+  while (idx < ctx->len && !binding_action_cmp(&ctx->bindings[idx], binding))
+    idx++;
 
-	if (idx < ctx->len && binding_action_cmp(&ctx->bindings[idx], binding)) {
-		ctx->bindings[idx].scancode = binding->scancode;
-		ctx->bindings[idx].scancode_alt = binding->scancode_alt;
-		return true;
-	}
+  if (idx < ctx->len && binding_action_cmp(&ctx->bindings[idx], binding)) {
+    ctx->bindings[idx].scancode = binding->scancode;
+    ctx->bindings[idx].scancode_alt = binding->scancode_alt;
+    return true;
+  }
 
-	return false;
+  return false;
 }
 
 // If any binding in ctx contains scancode, replace that action.
-bool i_update_unique_binding(i_ctx *ctx, binding_t* binding) {
-	isize idx = 0;
-	if (ctx == NULL || binding == NULL) {
-		ERROR("i_update_unique_binding received nullptr!");
-		return false;
-	}
+bool i_update_unique_binding(i_ctx* ctx, binding_t* binding) {
+  isize idx = 0;
+  if (ctx == NULL || binding == NULL) {
+    ERROR("i_update_unique_binding received nullptr!");
+    return false;
+  }
 
-	while (idx < ctx->len && !binding_scancode_cmp(&ctx->bindings[idx], binding)) idx++;
+  while (idx < ctx->len && !binding_scancode_cmp(&ctx->bindings[idx], binding))
+    idx++;
 
-	if (idx < ctx->len && binding_scancode_cmp(&ctx->bindings[idx], binding)) {
-		ctx->bindings[idx].action = binding->action;
-		return true;
-	}
+  if (idx < ctx->len && binding_scancode_cmp(&ctx->bindings[idx], binding)) {
+    ctx->bindings[idx].action = binding->action;
+    return true;
+  }
 
-	return false;
+  return false;
 }
 
 void i_flush_bindings(usize numcalls, void* state_mem, input_callback_t* c[]) {
-	for (usize i = 0; i < numcalls; i++) {
-		(c[i])(state_mem);
-	}
+  for (usize i = 0; i < numcalls; i++) {
+    (c[i])(state_mem);
+  }
 }
 
-action_t i_get_action(const i_ctx *restrict ctx, u32 time, scancode_t scancode) {
-	isize idx = 0;
+action_t i_get_action(const i_ctx* restrict ctx, u32 time,
+                      scancode_t scancode) {
+  isize idx = 0;
 
-	if (ctx == NULL) {
-		ERROR("%s received nullptr!", __func__);
-		return (action_t){.type = InputType_error};
-	}
+  if (ctx == NULL) {
+    ERROR("%s received nullptr!", __func__);
+    return (action_t){.type = InputType_error};
+  }
 
-	while (idx < ctx->len && !binding_scancode_cmp_i(&ctx->bindings[idx], scancode)) idx++;
+  while (idx < ctx->len &&
+         !binding_scancode_cmp_i(&ctx->bindings[idx], scancode))
+    idx++;
 
-	if (idx < ctx->len
-		  && binding_scancode_cmp_i(&ctx->bindings[idx], scancode)) {
-		ctx->bindings[idx].since_last_activation = time;
-		return ctx->bindings[idx].action;
-	}
+  if (idx < ctx->len && binding_scancode_cmp_i(&ctx->bindings[idx], scancode)) {
+    ctx->bindings[idx].since_last_activation = time;
+    return ctx->bindings[idx].action;
+  }
 
-	return (action_t){.type = InputType_error};
+  return (action_t){.type = InputType_error};
 }
 
-bool state_refresh_input_ctx(void *lib, i_ctx **ctx, usize ctx_len) {
-	if (ctx == NULL) return true;
-	if (ctx_len > 0 && ctx[0] == NULL) return false;
-	if (lib == NULL) return false;
+bool state_refresh_input_ctx(void* lib, i_ctx** ctx, usize ctx_len) {
+  if (ctx == NULL) return true;
+  if (ctx_len > 0 && ctx[0] == NULL) return false;
+  if (lib == NULL) return false;
 
-	for (usize c = 0; c < ctx_len; c++) {
-		LOG("ctx[%d]->len = %d", c, ctx[c]->len);
-		for (isize b = 0; b < ctx[c]->len; b++) {
-			switch (ctx[c]->bindings[b].action.type) {
-				case InputType_error:
-					break;
-				case InputType_action:
-					if (strcmp("NULL", ctx[c]->bindings[b].action.action.callback_str) != 0) {
+  for (usize c = 0; c < ctx_len; c++) {
+    LOG("ctx[%d]->len = %d", c, ctx[c]->len);
+    for (isize b = 0; b < ctx[c]->len; b++) {
+      switch (ctx[c]->bindings[b].action.type) {
+      case InputType_error:
+        break;
+      case InputType_action:
+        if (strcmp("NULL", ctx[c]->bindings[b].action.action.callback_str) !=
+            0) {
 
-						ctx[c]->bindings[b].action.action.callback =
-							(input_callback_t*)dynamic_library_get_symbol(lib, ctx[c]->bindings[b].action.action.callback_str);
+          ctx[c]->bindings[b].action.action.callback =
+              (input_callback_t*)dynamic_library_get_symbol(
+                  lib, ctx[c]->bindings[b].action.action.callback_str);
 
-							if (ctx[c]->bindings[b].action.action.callback == NULL) {
-								ERROR("Failed to get binding for %s: %s",
-										ctx[c]->bindings[b].action.action.callback_str,
-										dynamic_library_get_error());
-								return false;
-							}
-					}
-					break;
-				case InputType_state:
-					if (strcmp("NULL", ctx[c]->bindings[b].action.state.activate_str) != 0) {
+          if (ctx[c]->bindings[b].action.action.callback == NULL) {
+            ERROR("Failed to get binding for %s: %s",
+                  ctx[c]->bindings[b].action.action.callback_str,
+                  dynamic_library_get_error());
+            return false;
+          }
+        }
+        break;
+      case InputType_state:
+        if (strcmp("NULL", ctx[c]->bindings[b].action.state.activate_str) !=
+            0) {
 
-						ctx[c]->bindings[b].action.state.activate =
-							(input_callback_t*)dynamic_library_get_symbol(lib, ctx[c]->bindings[b].action.state.activate_str);
+          ctx[c]->bindings[b].action.state.activate =
+              (input_callback_t*)dynamic_library_get_symbol(
+                  lib, ctx[c]->bindings[b].action.state.activate_str);
 
-							if (ctx[c]->bindings[b].action.state.activate == NULL) {
-								ERROR("Failed to get binding for %s: %s",
-										ctx[c]->bindings[b].action.state.activate_str,
-										dynamic_library_get_error());
-								return false;
-							}
-					}
+          if (ctx[c]->bindings[b].action.state.activate == NULL) {
+            ERROR("Failed to get binding for %s: %s",
+                  ctx[c]->bindings[b].action.state.activate_str,
+                  dynamic_library_get_error());
+            return false;
+          }
+        }
 
-					if (strcmp("NULL", ctx[c]->bindings[b].action.state.deactivate_str) != 0) {
+        if (strcmp("NULL", ctx[c]->bindings[b].action.state.deactivate_str) !=
+            0) {
 
-						ctx[c]->bindings[b].action.state.deactivate =
-							(input_callback_t*)dynamic_library_get_symbol(lib, ctx[c]->bindings[b].action.state.deactivate_str);
+          ctx[c]->bindings[b].action.state.deactivate =
+              (input_callback_t*)dynamic_library_get_symbol(
+                  lib, ctx[c]->bindings[b].action.state.deactivate_str);
 
-							if (ctx[c]->bindings[b].action.state.deactivate == NULL) {
-								ERROR("Failed to get binding for %s: %s",
-										ctx[c]->bindings[b].action.state.deactivate_str,
-										dynamic_library_get_error());
-								return false;
-							}
-					}
-					break;
-				case InputType_range:
-				default:
-					break;
-			}
-		}
-	}
+          if (ctx[c]->bindings[b].action.state.deactivate == NULL) {
+            ERROR("Failed to get binding for %s: %s",
+                  ctx[c]->bindings[b].action.state.deactivate_str,
+                  dynamic_library_get_error());
+            return false;
+          }
+        }
+        break;
+      case InputType_range:
+      default:
+        break;
+      }
+    }
+  }
 
-	return true;
+  return true;
 }
 
-
 /* Make a lazy duplication of a binding. See comments on BindActionLazy and
  * friends above. */
-i_ctx* i_ctx_dup(i_ctx **ctx, usize ctx_len) {
-	usize num_binds = 0;
-	for (usize c = 0; c < ctx_len; c++) {
-		num_binds += ctx[c]->len;
-	}
+i_ctx* i_ctx_dup(i_ctx** ctx, usize ctx_len) {
+  usize num_binds = 0;
+  for (usize c = 0; c < ctx_len; c++) {
+    num_binds += ctx[c]->len;
+  }
 
-	binding_t *bb = calloc(num_binds, sizeof(binding_t));
-	i_ctx *ret = calloc(ctx_len, sizeof(i_ctx));
+  binding_t* bb = calloc(num_binds, sizeof(binding_t));
+  i_ctx* ret = calloc(ctx_len, sizeof(i_ctx));
 
-	usize cumsum = 0;
-	for (usize c = 0; c < ctx_len; c++) {
-			binding_t *b = ctx[c]->bindings;
-			ret[c].len = ctx[c]->len;
-			ret[c].bindings = &bb[cumsum];
+  usize cumsum = 0;
+  for (usize c = 0; c < ctx_len; c++) {
+    binding_t* b = ctx[c]->bindings;
+    ret[c].len = ctx[c]->len;
+    ret[c].bindings = &bb[cumsum];
 
-			for (isize i = 0; i < ctx[c]->len; i++) {
-				switch (b[i].action.type) {
-				case InputType_error:
-					break;
-				case InputType_action:
-					bb[cumsum] = BindActionLazy(
-							b[i].scancode,
-							b[i].scancode_alt,
-							strdup(b[i].action.action.callback_str));
-					break;
-				case InputType_state:
-					bb[cumsum] = BindStateLazy(
-							b[i].scancode,
-							b[i].scancode_alt,
-							strdup(b[i].action.state.activate_str),
-							strdup(b[i].action.state.deactivate_str));
-					break;
-				case InputType_range:
-				default:
-					break;
-				}
-				cumsum++;
-			}
-	}
-	return ret;
+    for (isize i = 0; i < ctx[c]->len; i++) {
+      switch (b[i].action.type) {
+      case InputType_error:
+        break;
+      case InputType_action:
+        bb[cumsum] = BindActionLazy(b[i].scancode, b[i].scancode_alt,
+                                    strdup(b[i].action.action.callback_str));
+        break;
+      case InputType_state:
+        bb[cumsum] = BindStateLazy(b[i].scancode, b[i].scancode_alt,
+                                   strdup(b[i].action.state.activate_str),
+                                   strdup(b[i].action.state.deactivate_str));
+        break;
+      case InputType_range:
+      default:
+        break;
+      }
+      cumsum++;
+    }
+  }
+  return ret;
 }
 
 /* Returns a pointer to a binding in c with .action == a.
  * Returns NULL if not found. */
-binding_t *get_action(i_ctx *c, action_t *a) {
-	for (isize i = 0; i < c->len; i++) {
-		if (c->bindings[i].action.type != a->type) continue;
+binding_t* get_action(i_ctx* c, action_t* a) {
+  for (isize i = 0; i < c->len; i++) {
+    if (c->bindings[i].action.type != a->type) continue;
 
-		switch (c->bindings[i].action) {
-			case InputType_error:
-				return NULL;
+    switch (c->bindings[i].action) {
+    case InputType_error:
+      return NULL;
 
-			case InputType_action:
-				if (!strcmp(c->bindings[i].action.action.callback_str, a->action.callback_str)) {
-					return &c->bindings[i];
-				}
-				break;
+    case InputType_action:
+      if (!strcmp(c->bindings[i].action.action.callback_str,
+                  a->action.callback_str)) {
+        return &c->bindings[i];
+      }
+      break;
 
-			case InputType_state:
-				if (!strcmp(c->bindings[i].action.state.activate_str, a->state.activate_str)
-				 && !strcmp(c->bindings[i].action.state.deactivate_str, a->state.deactivate_str)) {
-					return &c->bindings[i];
-				}
-				break;
+    case InputType_state:
+      if (!strcmp(c->bindings[i].action.state.activate_str,
+                  a->state.activate_str) &&
+          !strcmp(c->bindings[i].action.state.deactivate_str,
+                  a->state.deactivate_str)) {
+        return &c->bindings[i];
+      }
+      break;
 
-			case InputType_range:
-			default:
-				return NULL;
-		}
-	}
-	return NULL;
+    case InputType_range:
+    default:
+      return NULL;
+    }
+  }
+  return NULL;
 }
 
-void i_bind_ctx(i_ctx *c, scancode_t s, action_t *a) {
-	binding_t* b = get_action(c, a);
+void i_bind_ctx(i_ctx* c, scancode_t s, action_t* a) {
+  binding_t* b = get_action(c, a);
 
-	if (b == NULL) {
-		WARN("Failed to update keybinding");
-		return;
-	}
+  if (b == NULL) {
+    WARN("Failed to update keybinding");
+    return;
+  }
 
-	b->scancode = s;
+  b->scancode = s;
 }
 
-void i_bind_ctx_alt(i_ctx *c, scancode_t s, action_t *a) {
-	binding_t* b = get_action(c, a);
+void i_bind_ctx_alt(i_ctx* c, scancode_t s, action_t* a) {
+  binding_t* b = get_action(c, a);
 
-	if (b == NULL) {
-		WARN("Failed to update keybinding");
-		return;
-	}
+  if (b == NULL) {
+    WARN("Failed to update keybinding");
+    return;
+  }
 
-	b->scancode_alt = s;
+  b->scancode_alt = s;
 }
 
-void i_bind(binding_t *b, scancode_t s) {
-	if (b == NULL) {
-		WARN("Failed to update keybinding");
-		return;
-	}
+void i_bind(binding_t* b, scancode_t s) {
+  if (b == NULL) {
+    WARN("Failed to update keybinding");
+    return;
+  }
 
-	b->scancode = s;
+  b->scancode = s;
 }
 
-void i_bind_alt(binding_t *b, scancode_t s) {
-	if (b == NULL) {
-		WARN("Failed to update keybinding");
-		return;
-	}
+void i_bind_alt(binding_t* b, scancode_t s) {
+  if (b == NULL) {
+    WARN("Failed to update keybinding");
+    return;
+  }
 
-	b->scancode_alt = s;
+  b->scancode_alt = s;
 }