re-format with uncrustify

2 files changed, 58 insertions, 58 deletions

diff --git a/shared-bindings/bitmaptools/__init__.c b/shared-bindings/bitmaptools/__init__.c
index 5de85156a..0edbe135d 100644
--- a/shared-bindings/bitmaptools/__init__.c
+++ b/shared-bindings/bitmaptools/__init__.c
@@ -38,7 +38,7 @@
 
 STATIC int16_t validate_point(mp_obj_t point, int16_t default_value) {
     // Checks if point is None and returns default_value, otherwise decodes integer value
-    if ( point == mp_const_none ) {
+    if (point == mp_const_none) {
         return default_value;
     }
     return mp_obj_get_int(point);
@@ -47,13 +47,13 @@ STATIC int16_t validate_point(mp_obj_t point, int16_t default_value) {
 STATIC void extract_tuple(mp_obj_t xy_tuple, int16_t *x, int16_t *y, int16_t x_default, int16_t y_default) {
     // Helper function for rotozoom
     // Extract x,y values from a tuple or default if None
-    if ( xy_tuple == mp_const_none ) {
+    if (xy_tuple == mp_const_none) {
         *x = x_default;
         *y = y_default;
-    } else if ( !MP_OBJ_IS_OBJ(xy_tuple) ) {
+    } else if (!MP_OBJ_IS_OBJ(xy_tuple)) {
         mp_raise_ValueError(translate("clip point must be (x,y) tuple"));
     } else {
-        mp_obj_t* items;
+        mp_obj_t *items;
         mp_obj_get_array_fixed_n(xy_tuple, 2, &items);
         *x = mp_obj_get_int(items[0]);
         *y = mp_obj_get_int(items[1]);
@@ -61,7 +61,7 @@ STATIC void extract_tuple(mp_obj_t xy_tuple, int16_t *x, int16_t *y, int16_t x_d
 }
 
 STATIC void validate_clip_region(displayio_bitmap_t *bitmap, mp_obj_t clip0_tuple, int16_t *clip0_x, int16_t *clip0_y,
-                                                   mp_obj_t clip1_tuple, int16_t *clip1_x, int16_t *clip1_y) {
+    mp_obj_t clip1_tuple, int16_t *clip1_x, int16_t *clip1_y) {
     // Helper function for rotozoom
     // 1. Extract the clip x,y points from the two clip tuples
     // 2. Rearrange values such that clip0_ < clip1_
@@ -71,12 +71,12 @@ STATIC void validate_clip_region(displayio_bitmap_t *bitmap, mp_obj_t clip0_tupl
     extract_tuple(clip1_tuple, clip1_x, clip1_y, bitmap->width, bitmap->height);
 
     // Ensure the value for clip0 is less than clip1 (for both x and y)
-    if ( *clip0_x > *clip1_x ) {
+    if (*clip0_x > *clip1_x) {
         int16_t temp_value = *clip0_x; // swap values
         *clip0_x = *clip1_x;
         *clip1_x = temp_value;
     }
-    if ( *clip0_y > *clip1_y ) {
+    if (*clip0_y > *clip1_y) {
         int16_t temp_value = *clip0_y; // swap values
         *clip0_y = *clip1_y;
         *clip1_y = temp_value;
@@ -144,11 +144,11 @@ STATIC void validate_clip_region(displayio_bitmap_t *bitmap, mp_obj_t clip0_tupl
 //|             set to None to copy all pixels"""
 //|      ...
 //|
-STATIC mp_obj_t bitmaptools_obj_rotozoom(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args){
+STATIC mp_obj_t bitmaptools_obj_rotozoom(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     enum {ARG_dest_bitmap, ARG_source_bitmap,
-        ARG_ox, ARG_oy, ARG_dest_clip0, ARG_dest_clip1,
-        ARG_px, ARG_py, ARG_source_clip0, ARG_source_clip1,
-        ARG_angle, ARG_scale, ARG_skip_index};
+          ARG_ox, ARG_oy, ARG_dest_clip0, ARG_dest_clip1,
+          ARG_px, ARG_py, ARG_source_clip0, ARG_source_clip1,
+          ARG_angle, ARG_scale, ARG_skip_index};
 
     static const mp_arg_t allowed_args[] = {
         {MP_QSTR_dest_bitmap, MP_ARG_REQUIRED | MP_ARG_OBJ},
@@ -166,7 +166,7 @@ STATIC mp_obj_t bitmaptools_obj_rotozoom(size_t n_args, const mp_obj_t *pos_args
 
         {MP_QSTR_angle, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} }, // None convert to 0.0
         {MP_QSTR_scale, MP_ARG_KW_ONLY | MP_ARG_OBJ, {.u_obj = mp_const_none} }, // None convert to 1.0
-        {MP_QSTR_skip_index, MP_ARG_OBJ | MP_ARG_KW_ONLY, {.u_obj=mp_const_none} },
+        {MP_QSTR_skip_index, MP_ARG_OBJ | MP_ARG_KW_ONLY, {.u_obj = mp_const_none} },
     };
 
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
@@ -183,35 +183,35 @@ STATIC mp_obj_t bitmaptools_obj_rotozoom(size_t n_args, const mp_obj_t *pos_args
 
     // Confirm the destination location target (ox,oy); if None, default to bitmap midpoint
     int16_t ox, oy;
-    ox = validate_point(args[ARG_ox].u_obj, destination->width  / 2);
+    ox = validate_point(args[ARG_ox].u_obj, destination->width / 2);
     oy = validate_point(args[ARG_oy].u_obj, destination->height / 2);
 
     // Confirm the source location target (px,py); if None, default to bitmap midpoint
     int16_t px, py;
-    px = validate_point(args[ARG_px].u_obj, source->width  / 2);
+    px = validate_point(args[ARG_px].u_obj, source->width / 2);
     py = validate_point(args[ARG_py].u_obj, source->height / 2);
 
     // Validate the clipping regions for the destination bitmap
     int16_t dest_clip0_x, dest_clip0_y, dest_clip1_x, dest_clip1_y;
 
     validate_clip_region(destination, args[ARG_dest_clip0].u_obj, &dest_clip0_x, &dest_clip0_y,
-                               args[ARG_dest_clip1].u_obj, &dest_clip1_x, &dest_clip1_y);
+        args[ARG_dest_clip1].u_obj, &dest_clip1_x, &dest_clip1_y);
 
     // Validate the clipping regions for the source bitmap
     int16_t source_clip0_x, source_clip0_y, source_clip1_x, source_clip1_y;
 
     validate_clip_region(source, args[ARG_source_clip0].u_obj, &source_clip0_x, &source_clip0_y,
-                                 args[ARG_source_clip1].u_obj, &source_clip1_x, &source_clip1_y);
+        args[ARG_source_clip1].u_obj, &source_clip1_x, &source_clip1_y);
 
     // Confirm the angle value
-    float angle=0.0;
-    if ( args[ARG_angle].u_obj != mp_const_none ) {
+    float angle = 0.0;
+    if (args[ARG_angle].u_obj != mp_const_none) {
         angle = mp_obj_get_float(args[ARG_angle].u_obj);
     }
 
     // Confirm the scale value
-    float scale=1.0;
-    if ( args[ARG_scale].u_obj != mp_const_none ) {
+    float scale = 1.0;
+    if (args[ARG_scale].u_obj != mp_const_none) {
         scale = mp_obj_get_float(args[ARG_scale].u_obj);
     }
     if (scale < 0) { // ensure scale >= 0
@@ -220,7 +220,7 @@ STATIC mp_obj_t bitmaptools_obj_rotozoom(size_t n_args, const mp_obj_t *pos_args
 
     uint32_t skip_index;
     bool skip_index_none; // Flag whether input skip_value was None
-    if (args[ARG_skip_index].u_obj == mp_const_none ) {
+    if (args[ARG_skip_index].u_obj == mp_const_none) {
         skip_index = 0;
         skip_index_none = true;
     } else {
@@ -229,14 +229,14 @@ STATIC mp_obj_t bitmaptools_obj_rotozoom(size_t n_args, const mp_obj_t *pos_args
     }
 
     common_hal_bitmaptools_rotozoom(destination, ox, oy,
-                                            dest_clip0_x, dest_clip0_y,
-                                            dest_clip1_x, dest_clip1_y,
-                                            source, px, py,
-                                            source_clip0_x, source_clip0_y,
-                                            source_clip1_x, source_clip1_y,
-                                            angle,
-                                            scale,
-                                            skip_index, skip_index_none);
+        dest_clip0_x, dest_clip0_y,
+        dest_clip1_x, dest_clip1_y,
+        source, px, py,
+        source_clip0_x, source_clip0_y,
+        source_clip1_x, source_clip1_y,
+        angle,
+        scale,
+        skip_index, skip_index_none);
 
     return mp_const_none;
 }
@@ -262,7 +262,7 @@ MP_DEFINE_CONST_FUN_OBJ_KW(bitmaptools_rotozoom_obj, 0, bitmaptools_obj_rotozoom
 //|             fill region in the destination bitmap"""
 //|      ...
 //|
-STATIC mp_obj_t bitmaptools_obj_fill_region(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args){
+STATIC mp_obj_t bitmaptools_obj_fill_region(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     enum {ARG_dest_bitmap, ARG_x1, ARG_y1, ARG_x2, ARG_y2, ARG_value};
 
     static const mp_arg_t allowed_args[] = {
@@ -282,8 +282,8 @@ STATIC mp_obj_t bitmaptools_obj_fill_region(size_t n_args, const mp_obj_t *pos_a
     value = args[ARG_value].u_int;
     color_depth = (1 << destination->bits_per_value);
     if (color_depth <= value) {
-            mp_raise_ValueError(translate("out of range of target"));
-        }
+        mp_raise_ValueError(translate("out of range of target"));
+    }
 
     int16_t x1 = args[ARG_x1].u_int;
     int16_t y1 = args[ARG_y1].u_int;
@@ -315,7 +315,7 @@ MP_DEFINE_CONST_FUN_OBJ_KW(bitmaptools_fill_region_obj, 0, bitmaptools_obj_fill_
 //|             line in the destination bitmap"""
 //|      ...
 //|
-STATIC mp_obj_t bitmaptools_obj_draw_line(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args){
+STATIC mp_obj_t bitmaptools_obj_draw_line(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     enum {ARG_dest_bitmap, ARG_x1, ARG_y1, ARG_x2, ARG_y2, ARG_value};
 
     static const mp_arg_t allowed_args[] = {
@@ -335,8 +335,8 @@ STATIC mp_obj_t bitmaptools_obj_draw_line(size_t n_args, const mp_obj_t *pos_arg
     value = args[ARG_value].u_int;
     color_depth = (1 << destination->bits_per_value);
     if (color_depth <= value) {
-            mp_raise_ValueError(translate("out of range of target"));
-        }
+        mp_raise_ValueError(translate("out of range of target"));
+    }
 
     int16_t x1 = args[ARG_x1].u_int;
     int16_t y1 = args[ARG_y1].u_int;
@@ -344,9 +344,9 @@ STATIC mp_obj_t bitmaptools_obj_draw_line(size_t n_args, const mp_obj_t *pos_arg
     int16_t y2 = args[ARG_y2].u_int;
 
     // verify points are within the bitmap boundary (inclusive)
-    if ( (x1 < 0) || (x2 < 0) || (y1 < 0) || (y2 < 0) ||
-         (x1 >= destination->width)  || (x2 >= destination->width) ||
-         (y1 >= destination->height) || (y2 >= destination->height) ) {
+    if ((x1 < 0) || (x2 < 0) || (y1 < 0) || (y2 < 0) ||
+        (x1 >= destination->width) || (x2 >= destination->width) ||
+        (y1 >= destination->height) || (y2 >= destination->height)) {
         mp_raise_ValueError(translate("out of range of target"));
     }
 
@@ -399,7 +399,7 @@ STATIC mp_obj_t bitmaptools_arrayblit(size_t n_args, const mp_obj_t *pos_args, m
         { MP_QSTR_y2, MP_ARG_INT, {.u_int = -1} },
         { MP_QSTR_skip_index, MP_ARG_OBJ, {.u_obj = mp_const_none } },
     }
-;
+    ;
     mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
     mp_arg_parse_all(n_args, pos_args, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
 
@@ -420,7 +420,7 @@ STATIC mp_obj_t bitmaptools_arrayblit(size_t n_args, const mp_obj_t *pos_args, m
         mp_raise_IndexError(translate("pixel coordinates out of bounds"));
     }
 
-    size_t output_element_count = (x2-x1) * (y2-y1);
+    size_t output_element_count = (x2 - x1) * (y2 - y1);
     size_t element_size = mp_binary_get_size('@', bufinfo.typecode, NULL);
     size_t input_element_count = bufinfo.len / element_size;
 
@@ -477,11 +477,11 @@ STATIC mp_obj_t bitmaptools_readinto(size_t n_args, const mp_obj_t *pos_args, mp
     if (!MP_OBJ_IS_TYPE(args[ARG_file].u_obj, &mp_type_fileio)) {
         mp_raise_TypeError(NULL);
     }
-    pyb_file_obj_t* file = MP_OBJ_TO_PTR(args[ARG_file].u_obj);
+    pyb_file_obj_t *file = MP_OBJ_TO_PTR(args[ARG_file].u_obj);
 
     int element_size = args[ARG_element_size].u_int;
     if (element_size != 1 && element_size != 2 && element_size != 4) {
-            mp_raise_ValueError_varg(translate("invalid element_size %d, must be, 1, 2, or 4"), element_size);
+        mp_raise_ValueError_varg(translate("invalid element_size %d, must be, 1, 2, or 4"), element_size);
     }
 
     int bits_per_pixel = args[ARG_bits_per_pixel].u_int;
@@ -523,5 +523,5 @@ STATIC MP_DEFINE_CONST_DICT(bitmaptools_module_globals, bitmaptools_module_globa
 
 const mp_obj_module_t bitmaptools_module = {
     .base = {&mp_type_module },
-    .globals = (mp_obj_dict_t*)&bitmaptools_module_globals,
+    .globals = (mp_obj_dict_t *)&bitmaptools_module_globals,
 };
diff --git a/shared-bindings/bitmaptools/__init__.h b/shared-bindings/bitmaptools/__init__.h
index bb89cd732..6b80f98f5 100644
--- a/shared-bindings/bitmaptools/__init__.h
+++ b/shared-bindings/bitmaptools/__init__.h
@@ -32,26 +32,26 @@
 #include "extmod/vfs_fat.h"
 
 void common_hal_bitmaptools_rotozoom(displayio_bitmap_t *self, int16_t ox, int16_t oy,
-                                            int16_t dest_clip0_x, int16_t dest_clip0_y,
-                                            int16_t dest_clip1_x, int16_t dest_clip1_y,
-                                            displayio_bitmap_t *source, int16_t px, int16_t py,
-                                            int16_t source_clip0_x, int16_t source_clip0_y,
-                                            int16_t source_clip1_x, int16_t source_clip1_y,
-                                            float angle,
-                                            float scale,
-                                            uint32_t skip_index, bool skip_index_none);
+    int16_t dest_clip0_x, int16_t dest_clip0_y,
+    int16_t dest_clip1_x, int16_t dest_clip1_y,
+    displayio_bitmap_t *source, int16_t px, int16_t py,
+    int16_t source_clip0_x, int16_t source_clip0_y,
+    int16_t source_clip1_x, int16_t source_clip1_y,
+    float angle,
+    float scale,
+    uint32_t skip_index, bool skip_index_none);
 
 void common_hal_bitmaptools_fill_region(displayio_bitmap_t *destination,
-                                        int16_t x1, int16_t y1,
-                                        int16_t x2, int16_t y2,
-                                        uint32_t value);
+    int16_t x1, int16_t y1,
+    int16_t x2, int16_t y2,
+    uint32_t value);
 
 void common_hal_bitmaptools_draw_line(displayio_bitmap_t *destination,
-                                 int16_t x0, int16_t y0,
-                                 int16_t x1, int16_t y1,
-                                 uint32_t value);
+    int16_t x0, int16_t y0,
+    int16_t x1, int16_t y1,
+    uint32_t value);
 
-void common_hal_bitmaptools_readinto(displayio_bitmap_t *self, pyb_file_obj_t* file, int element_size, int bits_per_pixel, bool reverse_pixels_in_word, bool swap_bytes);
+void common_hal_bitmaptools_readinto(displayio_bitmap_t *self, pyb_file_obj_t *file, int element_size, int bits_per_pixel, bool reverse_pixels_in_word, bool swap_bytes);
 void common_hal_bitmaptools_arrayblit(displayio_bitmap_t *self, void *data, int element_size, int x1, int y1, int x2, int y2, bool skip_specified, uint32_t skip_index);
 
 #endif // MICROPY_INCLUDED_SHARED_BINDINGS_BITMAPTOOLS__INIT__H