From fa029808744e41240656da38977d03dff8c6b930 Mon Sep 17 00:00:00 2001
From: Reza Jelveh <git@jelveh.me>
Date: Thu, 3 Dec 2020 17:35:34 +0800
Subject: [PATCH] ducky: clang-format matrix and one2mini.c

---
 keyboards/ducky/one2mini/matrix.c   | 153 +++++++++++-----------------
 keyboards/ducky/one2mini/one2mini.c |  43 ++++----
 2 files changed, 78 insertions(+), 118 deletions(-)

diff --git a/keyboards/ducky/one2mini/matrix.c b/keyboards/ducky/one2mini/matrix.c
index 5fb936cfac2..b4baaeac2f2 100644
--- a/keyboards/ducky/one2mini/matrix.c
+++ b/keyboards/ducky/one2mini/matrix.c
@@ -26,24 +26,24 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "quantum.h"
 
 #if (MATRIX_COLS <= 8)
-#    define print_matrix_header()  print("\nr/c 01234567\n")
-#    define print_matrix_row(row)  print_bin_reverse8(matrix_get_row(row))
-#    define matrix_bitpop(i)       bitpop(matrix[i])
+#    define print_matrix_header() print("\nr/c 01234567\n")
+#    define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row))
+#    define matrix_bitpop(i) bitpop(matrix[i])
 #    define ROW_SHIFTER ((uint8_t)1)
 #elif (MATRIX_COLS <= 16)
-#    define print_matrix_header()  print("\nr/c 0123456789ABCDEF\n")
-#    define print_matrix_row(row)  print_bin_reverse16(matrix_get_row(row))
-#    define matrix_bitpop(i)       bitpop16(matrix[i])
+#    define print_matrix_header() print("\nr/c 0123456789ABCDEF\n")
+#    define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row))
+#    define matrix_bitpop(i) bitpop16(matrix[i])
 #    define ROW_SHIFTER ((uint16_t)1)
 #elif (MATRIX_COLS <= 32)
-#    define print_matrix_header()  print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n")
-#    define print_matrix_row(row)  print_bin_reverse32(matrix_get_row(row))
-#    define matrix_bitpop(i)       bitpop32(matrix[i])
-#    define ROW_SHIFTER  ((uint32_t)1)
+#    define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n")
+#    define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row))
+#    define matrix_bitpop(i) bitpop32(matrix[i])
+#    define ROW_SHIFTER ((uint32_t)1)
 #endif
 
 #ifdef MATRIX_MASKED
-    extern const matrix_row_t matrix_mask[];
+extern const matrix_row_t matrix_mask[];
 #endif
 
 #if (DIODE_DIRECTION == ROW2COL) || (DIODE_DIRECTION == COL2ROW)
@@ -52,100 +52,70 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
 #endif
 
 /* matrix state(1:on, 0:off) */
-static matrix_row_t raw_matrix[MATRIX_ROWS]; //raw values
-static matrix_row_t matrix[MATRIX_ROWS]; //debounced values
+static matrix_row_t raw_matrix[MATRIX_ROWS];  // raw values
+static matrix_row_t matrix[MATRIX_ROWS];      // debounced values
 
 #if (DIODE_DIRECTION == COL2ROW)
-    static void init_cols(void);
-    static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row);
-    static void unselect_rows(void);
-    static void select_row(uint8_t row);
-    static void unselect_row(uint8_t row);
+static void init_cols(void);
+static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row);
+static void unselect_rows(void);
+static void select_row(uint8_t row);
+static void unselect_row(uint8_t row);
 #elif (DIODE_DIRECTION == ROW2COL)
-    static void init_rows(void);
-    static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col);
-    static void unselect_cols(void);
-    static void unselect_col(uint8_t col);
-    static void select_col(uint8_t col);
+static void init_rows(void);
+static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col);
+static void unselect_cols(void);
+static void unselect_col(uint8_t col);
+static void select_col(uint8_t col);
 #endif
 
-__attribute__ ((weak))
-void matrix_init_quantum(void) {
-    matrix_init_kb();
-}
+__attribute__((weak)) void matrix_init_quantum(void) { matrix_init_kb(); }
 
-__attribute__ ((weak))
-void matrix_scan_quantum(void) {
-    matrix_scan_kb();
-}
+__attribute__((weak)) void matrix_scan_quantum(void) { matrix_scan_kb(); }
 
-__attribute__ ((weak))
-void matrix_init_kb(void) {
-    matrix_init_user();
-}
+__attribute__((weak)) void matrix_init_kb(void) { matrix_init_user(); }
 
-__attribute__ ((weak))
-void matrix_scan_kb(void) {
-    matrix_scan_user();
-}
+__attribute__((weak)) void matrix_scan_kb(void) { matrix_scan_user(); }
 
-__attribute__ ((weak))
-void matrix_init_user(void) {
-}
+__attribute__((weak)) void matrix_init_user(void) {}
 
-__attribute__ ((weak))
-void matrix_scan_user(void) {
-}
+__attribute__((weak)) void matrix_scan_user(void) {}
 
-inline
-uint8_t matrix_rows(void) {
-    return MATRIX_ROWS;
-}
+inline uint8_t matrix_rows(void) { return MATRIX_ROWS; }
 
-inline
-uint8_t matrix_cols(void) {
-    return MATRIX_COLS;
-}
+inline uint8_t matrix_cols(void) { return MATRIX_COLS; }
 
 void matrix_init(void) {
-
     unselect_rows();
     init_cols();
 
     // initialize matrix state: all keys off
-    for (uint8_t i=0; i < MATRIX_ROWS; i++) {
+    for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
         raw_matrix[i] = 0;
-        matrix[i] = 0;
+        matrix[i]     = 0;
     }
     debounce_init(MATRIX_ROWS);
 
     matrix_init_quantum();
 }
 
-uint8_t matrix_scan(void)
-{
-  bool changed = false;
+uint8_t matrix_scan(void) {
+    bool changed = false;
 
-  // Set row, read cols
-  for (uint8_t current_row = 0; current_row < MATRIX_ROWS; current_row++) {
-    changed |= read_cols_on_row(raw_matrix, current_row);
-  }
+    // Set row, read cols
+    for (uint8_t current_row = 0; current_row < MATRIX_ROWS; current_row++) {
+        changed |= read_cols_on_row(raw_matrix, current_row);
+    }
 
-  debounce(raw_matrix, matrix, MATRIX_ROWS, changed);
+    debounce(raw_matrix, matrix, MATRIX_ROWS, changed);
 
-  matrix_scan_quantum();
-  return (uint8_t)changed;
+    matrix_scan_quantum();
+    return (uint8_t)changed;
 }
 
-inline
-bool matrix_is_on(uint8_t row, uint8_t col)
-{
-    return (matrix[row] & ((matrix_row_t)1<<col));
-}
+inline bool matrix_is_on(uint8_t row, uint8_t col) { return (matrix[row] & ((matrix_row_t)1 << col)); }
 
-inline
-matrix_row_t matrix_get_row(uint8_t row)
-{
+inline matrix_row_t matrix_get_row(uint8_t row) {
     // Matrix mask lets you disable switches in the returned matrix data. For example, if you have a
     // switch blocker installed and the switch is always pressed.
 #ifdef MATRIX_MASKED
@@ -155,19 +125,18 @@ matrix_row_t matrix_get_row(uint8_t row)
 #endif
 }
 
-void matrix_print(void)
-{
+void matrix_print(void) {
     print_matrix_header();
 
     for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
-        phex(row); print(": ");
+        phex(row);
+        print(": ");
         print_matrix_row(row);
         print("\n");
     }
 }
 
-uint8_t matrix_key_count(void)
-{
+uint8_t matrix_key_count(void) {
     uint8_t count = 0;
     for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
         count += matrix_bitpop(i);
@@ -175,15 +144,13 @@ uint8_t matrix_key_count(void)
     return count;
 }
 
-static void init_cols(void)
-{
-    for(uint8_t x = 0; x < MATRIX_COLS; x++) {
+static void init_cols(void) {
+    for (uint8_t x = 0; x < MATRIX_COLS; x++) {
         setPinInputHigh(col_pins[x]);
     }
 }
 
-static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
-{
+static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) {
     // Store last value of row prior to reading
     matrix_row_t last_row_value = current_matrix[current_row];
 
@@ -195,13 +162,12 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
     wait_us(30);
 
     // For each col...
-    for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
-
+    for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
         // Select the col pin to read (active low)
         uint8_t pin_state = readPin(col_pins[col_index]);
 
         // Populate the matrix row with the state of the col pin
-        current_matrix[current_row] |=  pin_state ? 0 : (ROW_SHIFTER << col_index);
+        current_matrix[current_row] |= pin_state ? 0 : (ROW_SHIFTER << col_index);
     }
 
     // Unselect row
@@ -210,20 +176,15 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
     return (last_row_value != current_matrix[current_row]);
 }
 
-static void select_row(uint8_t row)
-{
+static void select_row(uint8_t row) {
     setPinOutput(row_pins[row]);
     writePinLow(row_pins[row]);
 }
 
-static void unselect_row(uint8_t row)
-{
-    writePinHigh(row_pins[row]);
-}
+static void unselect_row(uint8_t row) { writePinHigh(row_pins[row]); }
 
-static void unselect_rows(void)
-{
-    for(uint8_t x = 0; x < MATRIX_ROWS; x++) {
+static void unselect_rows(void) {
+    for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
         writePinHigh(row_pins[x]);
     }
 }
diff --git a/keyboards/ducky/one2mini/one2mini.c b/keyboards/ducky/one2mini/one2mini.c
index 355948452ce..4661ec62d55 100644
--- a/keyboards/ducky/one2mini/one2mini.c
+++ b/keyboards/ducky/one2mini/one2mini.c
@@ -1,4 +1,5 @@
 /* Copyright 2019 /u/KeepItUnder
+ * Copyright 2020 Reza Jelveh
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -24,25 +25,23 @@
  */
 void bootmagic_lite(void) {
     matrix_scan();
-    wait_ms(DEBOUNCE*2);
+    wait_ms(DEBOUNCE * 2);
     matrix_scan();
 
     uint8_t valMatrixRow = 0U;
 
     valMatrixRow = matrix_get_row(2);
 
-    if ( ( valMatrixRow & (1<<3) ) &&
-      ( valMatrixRow & (1<<9) ) ) {
-      // Jump to bootloader.
-      bootloader_jump();
+    if ((valMatrixRow & (1 << 3)) && (valMatrixRow & (1 << 9))) {
+        // Jump to bootloader.
+        bootloader_jump();
     }
 
     valMatrixRow = matrix_get_row(3);
 
-    if ( ( valMatrixRow & (1<<2) ) &&
-      ( valMatrixRow & (1<<3) ) ) {
-      // Jump to bootloader.
-      bootloader_jump();
+    if ((valMatrixRow & (1 << 2)) && (valMatrixRow & (1 << 3))) {
+        // Jump to bootloader.
+        bootloader_jump();
     }
 }
 
@@ -50,31 +49,31 @@ void bootmagic_lite(void) {
  * @brief   RGB Matrix LED layout
  * @details We need a layout for ISO and ANSI
  */
-#define USB_LED_CAPSLOCK_INDEX 28  /* Location of CAPS LOCK led in matrix */
+#define USB_LED_CAPSLOCK_INDEX 28 /* Location of CAPS LOCK led in matrix */
 
 void matrix_init_kb(void) {
-	// put your keyboard start-up code here
-	// runs once when the firmware starts up
-	//bootmagic_lite();
-	matrix_init_user();
+    // put your keyboard start-up code here
+    // runs once when the firmware starts up
+    // bootmagic_lite();
+    matrix_init_user();
 }
 
 void matrix_scan_kb(void) {
-	// put your looping keyboard code here
-	// runs every cycle (a lot)
+    // put your looping keyboard code here
+    // runs every cycle (a lot)
 
-	matrix_scan_user();
+    matrix_scan_user();
 }
 
 bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
-	// put your per-action keyboard code here
-	// runs for every action, just before processing by the firmware
+    // put your per-action keyboard code here
+    // runs for every action, just before processing by the firmware
 
-	return process_record_user(keycode, record);
+    return process_record_user(keycode, record);
 }
 
 void led_set_kb(uint8_t usb_led) {
-	// put your keyboard LED indicator (ex: Caps Lock LED) toggling code here
+    // put your keyboard LED indicator (ex: Caps Lock LED) toggling code here
 
-	led_set_user(usb_led);
+    led_set_user(usb_led);
 }