diff options
Diffstat (limited to 'shared-module/displayio')
27 files changed, 441 insertions, 441 deletions
diff --git a/shared-module/displayio/Bitmap.c b/shared-module/displayio/Bitmap.c index 1831ac697..f03ade84b 100644 --- a/shared-module/displayio/Bitmap.c +++ b/shared-module/displayio/Bitmap.c @@ -57,7 +57,7 @@ void common_hal_displayio_bitmap_construct(displayio_bitmap_t *self, uint32_t wi self->x_shift = 0; // Used to divide the index by the number of pixels per word. Its used in a // shift which effectively divides by 2 ** x_shift. uint32_t power_of_two = 1; - while (power_of_two < align_bits / bits_per_value ) { + while (power_of_two < align_bits / bits_per_value) { self->x_shift++; power_of_two <<= 1; } @@ -93,13 +93,13 @@ uint32_t common_hal_displayio_bitmap_get_pixel(displayio_bitmap_t *self, int16_t return (word >> (sizeof(size_t) * 8 - ((x & self->x_mask) + 1) * self->bits_per_value)) & self->bitmask; } else { - size_t* row = self->data + row_start; + size_t *row = self->data + row_start; if (bytes_per_value == 1) { - return ((uint8_t*) row)[x]; + return ((uint8_t *)row)[x]; } else if (bytes_per_value == 2) { - return ((uint16_t*) row)[x]; + return ((uint16_t *)row)[x]; } else if (bytes_per_value == 4) { - return ((uint32_t*) row)[x]; + return ((uint32_t *)row)[x]; } } return 0; @@ -157,19 +157,19 @@ void displayio_bitmap_write_pixel(displayio_bitmap_t *self, int16_t x, int16_t y word |= (value & self->bitmask) << bit_position; self->data[index] = word; } else { - size_t* row = self->data + row_start; + size_t *row = self->data + row_start; if (bytes_per_value == 1) { - ((uint8_t*) row)[x] = value; + ((uint8_t *)row)[x] = value; } else if (bytes_per_value == 2) { - ((uint16_t*) row)[x] = value; + ((uint16_t *)row)[x] = value; } else if (bytes_per_value == 4) { - ((uint32_t*) row)[x] = value; + ((uint32_t *)row)[x] = value; } } } void common_hal_displayio_bitmap_blit(displayio_bitmap_t *self, int16_t x, int16_t y, displayio_bitmap_t *source, - int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint32_t skip_index, bool skip_index_none) { + int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint32_t skip_index, bool skip_index_none) { // Copy region of "source" bitmap into "self" bitmap at location x,y in the "self" // If skip_value is encountered in the source bitmap, it will not be copied. // If skip_value is `None`, then all pixels are copied. @@ -180,11 +180,11 @@ void common_hal_displayio_bitmap_blit(displayio_bitmap_t *self, int16_t x, int16 } // Update the dirty area - int16_t dirty_x_max = (x + (x2-x1)); + int16_t dirty_x_max = (x + (x2 - x1)); if (dirty_x_max > self->width) { dirty_x_max = self->width; } - int16_t dirty_y_max = y + (y2-y1); + int16_t dirty_y_max = y + (y2 - y1); if (dirty_y_max > self->height) { dirty_y_max = self->height; } @@ -203,21 +203,21 @@ void common_hal_displayio_bitmap_blit(displayio_bitmap_t *self, int16_t x, int16 } // simplest version - use internal functions for get/set pixels - for (int16_t i=0; i < (x2-x1); i++) { + for (int16_t i = 0; i < (x2 - x1); i++) { - const int xs_index = x_reverse ? ( (x2) - i - 1) : x1+i; // x-index into the source bitmap - const int xd_index = x_reverse ? ((x + (x2-x1)) - i - 1) : x+i; // x-index into the destination bitmap + const int xs_index = x_reverse ? ((x2) - i - 1) : x1 + i; // x-index into the source bitmap + const int xd_index = x_reverse ? ((x + (x2 - x1)) - i - 1) : x + i; // x-index into the destination bitmap - if ( (xd_index >= 0) && (xd_index < self->width) ) { - for (int16_t j=0; j < (y2-y1) ; j++){ + if ((xd_index >= 0) && (xd_index < self->width)) { + for (int16_t j = 0; j < (y2 - y1); j++) { - const int ys_index = y_reverse ? ( (y2 ) - j - 1) : y1+j ; // y-index into the source bitmap - const int yd_index = y_reverse ? ((y + (y2-y1)) - j - 1) : y+j ; // y-index into the destination bitmap + const int ys_index = y_reverse ? ((y2) - j - 1) : y1 + j; // y-index into the source bitmap + const int yd_index = y_reverse ? ((y + (y2 - y1)) - j - 1) : y + j; // y-index into the destination bitmap - if ((yd_index >= 0) && (yd_index < self->height) ) { + if ((yd_index >= 0) && (yd_index < self->height)) { uint32_t value = common_hal_displayio_bitmap_get_pixel(source, xs_index, ys_index); - if ( (skip_index_none) || (value != skip_index) ) { // write if skip_value_none is True - displayio_bitmap_write_pixel(self, xd_index, yd_index, value); + if ((skip_index_none) || (value != skip_index)) { // write if skip_value_none is True + displayio_bitmap_write_pixel(self, xd_index, yd_index, value); } } } @@ -231,14 +231,14 @@ void common_hal_displayio_bitmap_set_pixel(displayio_bitmap_t *self, int16_t x, } // update the dirty region - displayio_bitmap_set_dirty_area(self, x, y, x+1, y+1); + displayio_bitmap_set_dirty_area(self, x, y, x + 1, y + 1); // write the pixel displayio_bitmap_write_pixel(self, x, y, value); } -displayio_area_t* displayio_bitmap_get_refresh_areas(displayio_bitmap_t *self, displayio_area_t* tail) { +displayio_area_t *displayio_bitmap_get_refresh_areas(displayio_bitmap_t *self, displayio_area_t *tail) { if (self->dirty_area.x1 == self->dirty_area.x2) { return tail; } @@ -263,11 +263,11 @@ void common_hal_displayio_bitmap_fill(displayio_bitmap_t *self, uint32_t value) // build the packed word uint32_t word = 0; - for (uint8_t i=0; i<32 / self->bits_per_value; i++) { - word |= (value & self->bitmask) << (32 - ((i+1)*self->bits_per_value)); + for (uint8_t i = 0; i < 32 / self->bits_per_value; i++) { + word |= (value & self->bitmask) << (32 - ((i + 1) * self->bits_per_value)); } // copy it in - for (uint32_t i=0; i<self->stride * self->height; i++) { + for (uint32_t i = 0; i < self->stride * self->height; i++) { self->data[i] = word; } } diff --git a/shared-module/displayio/Bitmap.h b/shared-module/displayio/Bitmap.h index d6aaaa8ba..c1ce9612b 100644 --- a/shared-module/displayio/Bitmap.h +++ b/shared-module/displayio/Bitmap.h @@ -37,7 +37,7 @@ typedef struct { mp_obj_base_t base; uint16_t width; uint16_t height; - size_t* data; + size_t *data; uint16_t stride; // size_t's uint8_t bits_per_value; uint8_t x_shift; @@ -48,7 +48,7 @@ typedef struct { } displayio_bitmap_t; void displayio_bitmap_finish_refresh(displayio_bitmap_t *self); -displayio_area_t* displayio_bitmap_get_refresh_areas(displayio_bitmap_t *self, displayio_area_t* tail); +displayio_area_t *displayio_bitmap_get_refresh_areas(displayio_bitmap_t *self, displayio_area_t *tail); void displayio_bitmap_set_dirty_area(displayio_bitmap_t *self, int16_t x1, int16_t y1, int16_t x2, int16_t y2); void displayio_bitmap_write_pixel(displayio_bitmap_t *self, int16_t x, int16_t y, uint32_t value); diff --git a/shared-module/displayio/ColorConverter.c b/shared-module/displayio/ColorConverter.c index 40dcd9d16..be9e9dc1a 100644 --- a/shared-module/displayio/ColorConverter.c +++ b/shared-module/displayio/ColorConverter.c @@ -31,18 +31,17 @@ #define NO_TRANSPARENT_COLOR (0x1000000) -uint32_t displayio_colorconverter_dither_noise_1 (uint32_t n) -{ - n = (n >> 13) ^ n; - int nn = (n * (n * n * 60493 + 19990303) + 1376312589) & 0x7fffffff; - return (uint32_t) (((float)nn / (1073741824.0f*2)) * 255); +uint32_t displayio_colorconverter_dither_noise_1(uint32_t n) { + n = (n >> 13) ^ n; + int nn = (n * (n * n * 60493 + 19990303) + 1376312589) & 0x7fffffff; + return (uint32_t)(((float)nn / (1073741824.0f * 2)) * 255); } uint32_t displayio_colorconverter_dither_noise_2(uint32_t x, uint32_t y) { return displayio_colorconverter_dither_noise_1(x + y * 0xFFFF); } -void common_hal_displayio_colorconverter_construct(displayio_colorconverter_t* self, bool dither) { +void common_hal_displayio_colorconverter_construct(displayio_colorconverter_t *self, bool dither) { self->dither = dither; self->transparent_color = NO_TRANSPARENT_COLOR; } @@ -83,11 +82,11 @@ uint8_t displayio_colorconverter_compute_hue(uint32_t color_rgb888) { int32_t hue = 0; if (max == r8) { - hue = (((int32_t) (g8 - b8) * 40) / c) % 240; + hue = (((int32_t)(g8 - b8) * 40) / c) % 240; } else if (max == g8) { - hue = (((int32_t) (b8 - r8) + (2 * c)) * 40) / c; + hue = (((int32_t)(b8 - r8) + (2 * c)) * 40) / c; } else if (max == b8) { - hue = (((int32_t) (r8 - g8) + (4 * c)) * 40) / c; + hue = (((int32_t)(r8 - g8) + (4 * c)) * 40) / c; } if (hue < 0) { hue += 240; @@ -96,7 +95,7 @@ uint8_t displayio_colorconverter_compute_hue(uint32_t color_rgb888) { return hue; } -void displayio_colorconverter_compute_tricolor(const _displayio_colorspace_t* colorspace, uint8_t pixel_hue, uint8_t pixel_luma, uint32_t* color) { +void displayio_colorconverter_compute_tricolor(const _displayio_colorspace_t *colorspace, uint8_t pixel_hue, uint8_t pixel_luma, uint32_t *color) { int16_t hue_diff = colorspace->tricolor_hue - pixel_hue; if ((-10 <= hue_diff && hue_diff <= 10) || hue_diff <= -220 || hue_diff >= 220) { @@ -110,7 +109,7 @@ void displayio_colorconverter_compute_tricolor(const _displayio_colorspace_t* co } } -void common_hal_displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t* colorspace, uint32_t input_color, uint32_t* output_color) { +void common_hal_displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t *colorspace, uint32_t input_color, uint32_t *output_color) { displayio_input_pixel_t input_pixel; input_pixel.pixel = input_color; input_pixel.x = input_pixel.y = input_pixel.tile = input_pixel.tile_x = input_pixel.tile_y = 0; @@ -124,28 +123,28 @@ void common_hal_displayio_colorconverter_convert(displayio_colorconverter_t *sel (*output_color) = output_pixel.pixel; } -void common_hal_displayio_colorconverter_set_dither(displayio_colorconverter_t* self, bool dither) { +void common_hal_displayio_colorconverter_set_dither(displayio_colorconverter_t *self, bool dither) { self->dither = dither; } -bool common_hal_displayio_colorconverter_get_dither(displayio_colorconverter_t* self) { +bool common_hal_displayio_colorconverter_get_dither(displayio_colorconverter_t *self) { return self->dither; } -void common_hal_displayio_colorconverter_make_transparent(displayio_colorconverter_t* self, uint32_t transparent_color) { +void common_hal_displayio_colorconverter_make_transparent(displayio_colorconverter_t *self, uint32_t transparent_color) { if (self->transparent_color != NO_TRANSPARENT_COLOR) { mp_raise_RuntimeError(translate("Only one color can be transparent at a time")); } self->transparent_color = transparent_color; } -void common_hal_displayio_colorconverter_make_opaque(displayio_colorconverter_t* self, uint32_t transparent_color) { - (void) transparent_color; +void common_hal_displayio_colorconverter_make_opaque(displayio_colorconverter_t *self, uint32_t transparent_color) { + (void)transparent_color; // NO_TRANSPARENT_COLOR will never equal a valid color self->transparent_color = NO_TRANSPARENT_COLOR; } -void displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t* colorspace, const displayio_input_pixel_t *input_pixel, displayio_output_pixel_t *output_color) { +void displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t *colorspace, const displayio_input_pixel_t *input_pixel, displayio_output_pixel_t *output_color) { uint32_t pixel = input_pixel->pixel; if (self->transparent_color == pixel) { @@ -153,19 +152,19 @@ void displayio_colorconverter_convert(displayio_colorconverter_t *self, const _d return; } - if (self->dither){ + if (self->dither) { uint8_t randr = (displayio_colorconverter_dither_noise_2(input_pixel->tile_x,input_pixel->tile_y)); - uint8_t randg = (displayio_colorconverter_dither_noise_2(input_pixel->tile_x+33,input_pixel->tile_y)); - uint8_t randb = (displayio_colorconverter_dither_noise_2(input_pixel->tile_x,input_pixel->tile_y+33)); + uint8_t randg = (displayio_colorconverter_dither_noise_2(input_pixel->tile_x + 33,input_pixel->tile_y)); + uint8_t randb = (displayio_colorconverter_dither_noise_2(input_pixel->tile_x,input_pixel->tile_y + 33)); uint32_t r8 = (pixel >> 16); uint32_t g8 = (pixel >> 8) & 0xff; uint32_t b8 = pixel & 0xff; if (colorspace->depth == 16) { - b8 = MIN(255,b8 + (randb&0x07)); - r8 = MIN(255,r8 + (randr&0x07)); - g8 = MIN(255,g8 + (randg&0x03)); + b8 = MIN(255,b8 + (randb & 0x07)); + r8 = MIN(255,r8 + (randr & 0x07)); + g8 = MIN(255,g8 + (randg & 0x03)); } else { int bitmask = 0xFF >> colorspace->depth; b8 = MIN(255,b8 + (randb & bitmask)); @@ -197,7 +196,7 @@ void displayio_colorconverter_convert(displayio_colorconverter_t *self, const _d uint8_t pixel_hue = displayio_colorconverter_compute_hue(pixel); displayio_colorconverter_compute_tricolor(colorspace, pixel_hue, luma, &output_color->pixel); return; - } else if (colorspace->grayscale && colorspace->depth <= 8) { + } else if (colorspace->grayscale && colorspace->depth <= 8) { uint8_t luma = displayio_colorconverter_compute_luma(pixel); size_t bitmask = (1 << colorspace->depth) - 1; output_color->pixel = (luma >> colorspace->grayscale_bit) & bitmask; diff --git a/shared-module/displayio/ColorConverter.h b/shared-module/displayio/ColorConverter.h index b402625ef..ebe4b2719 100644 --- a/shared-module/displayio/ColorConverter.h +++ b/shared-module/displayio/ColorConverter.h @@ -41,15 +41,15 @@ typedef struct { bool displayio_colorconverter_needs_refresh(displayio_colorconverter_t *self); void displayio_colorconverter_finish_refresh(displayio_colorconverter_t *self); -void displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t* colorspace, const displayio_input_pixel_t *input_pixel, displayio_output_pixel_t *output_color); +void displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t *colorspace, const displayio_input_pixel_t *input_pixel, displayio_output_pixel_t *output_color); -uint32_t displayio_colorconverter_dither_noise_1 (uint32_t n); +uint32_t displayio_colorconverter_dither_noise_1(uint32_t n); uint32_t displayio_colorconverter_dither_noise_2(uint32_t x, uint32_t y); uint16_t displayio_colorconverter_compute_rgb565(uint32_t color_rgb888); uint8_t displayio_colorconverter_compute_luma(uint32_t color_rgb888); uint8_t displayio_colorconverter_compute_chroma(uint32_t color_rgb888); uint8_t displayio_colorconverter_compute_hue(uint32_t color_rgb888); -void displayio_colorconverter_compute_tricolor(const _displayio_colorspace_t* colorspace, uint8_t pixel_hue, uint8_t pixel_luma, uint32_t* color); +void displayio_colorconverter_compute_tricolor(const _displayio_colorspace_t *colorspace, uint8_t pixel_hue, uint8_t pixel_luma, uint32_t *color); #endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_COLORCONVERTER_H diff --git a/shared-module/displayio/Display.c b/shared-module/displayio/Display.c index 7c8c9280b..63e098e08 100644 --- a/shared-module/displayio/Display.c +++ b/shared-module/displayio/Display.c @@ -41,15 +41,15 @@ #include <stdint.h> #include <string.h> -void common_hal_displayio_display_construct(displayio_display_obj_t* self, - mp_obj_t bus, uint16_t width, uint16_t height, int16_t colstart, int16_t rowstart, - uint16_t rotation, uint16_t color_depth, bool grayscale, bool pixels_in_byte_share_row, - uint8_t bytes_per_cell, bool reverse_pixels_in_byte, bool reverse_bytes_in_word, uint8_t set_column_command, - uint8_t set_row_command, uint8_t write_ram_command, uint8_t set_vertical_scroll, - uint8_t* init_sequence, uint16_t init_sequence_len, const mcu_pin_obj_t* backlight_pin, - uint16_t brightness_command, mp_float_t brightness, bool auto_brightness, - bool single_byte_bounds, bool data_as_commands, bool auto_refresh, uint16_t native_frames_per_second, - bool backlight_on_high, bool SH1107_addressing) { +void common_hal_displayio_display_construct(displayio_display_obj_t *self, + mp_obj_t bus, uint16_t width, uint16_t height, int16_t colstart, int16_t rowstart, + uint16_t rotation, uint16_t color_depth, bool grayscale, bool pixels_in_byte_share_row, + uint8_t bytes_per_cell, bool reverse_pixels_in_byte, bool reverse_bytes_in_word, uint8_t set_column_command, + uint8_t set_row_command, uint8_t write_ram_command, uint8_t set_vertical_scroll, + uint8_t *init_sequence, uint16_t init_sequence_len, const mcu_pin_obj_t *backlight_pin, + uint16_t brightness_command, mp_float_t brightness, bool auto_brightness, + bool single_byte_bounds, bool data_as_commands, bool auto_refresh, uint16_t native_frames_per_second, + bool backlight_on_high, bool SH1107_addressing) { // Turn off auto-refresh as we init. self->auto_refresh = false; @@ -141,34 +141,34 @@ void common_hal_displayio_display_construct(displayio_display_obj_t* self, common_hal_displayio_display_set_auto_refresh(self, auto_refresh); } -bool common_hal_displayio_display_show(displayio_display_obj_t* self, displayio_group_t* root_group) { +bool common_hal_displayio_display_show(displayio_display_obj_t *self, displayio_group_t *root_group) { return displayio_display_core_show(&self->core, root_group); } -uint16_t common_hal_displayio_display_get_width(displayio_display_obj_t* self){ +uint16_t common_hal_displayio_display_get_width(displayio_display_obj_t *self) { return displayio_display_core_get_width(&self->core); } -uint16_t common_hal_displayio_display_get_height(displayio_display_obj_t* self){ +uint16_t common_hal_displayio_display_get_height(displayio_display_obj_t *self) { return displayio_display_core_get_height(&self->core); } -bool common_hal_displayio_display_get_auto_brightness(displayio_display_obj_t* self) { +bool common_hal_displayio_display_get_auto_brightness(displayio_display_obj_t *self) { return self->auto_brightness; } -void common_hal_displayio_display_set_auto_brightness(displayio_display_obj_t* self, bool auto_brightness) { +void common_hal_displayio_display_set_auto_brightness(displayio_display_obj_t *self, bool auto_brightness) { self->auto_brightness = auto_brightness; } -mp_float_t common_hal_displayio_display_get_brightness(displayio_display_obj_t* self) { +mp_float_t common_hal_displayio_display_get_brightness(displayio_display_obj_t *self) { return self->current_brightness; } -bool common_hal_displayio_display_set_brightness(displayio_display_obj_t* self, mp_float_t brightness) { +bool common_hal_displayio_display_set_brightness(displayio_display_obj_t *self, mp_float_t brightness) { self->updating_backlight = true; - if (!self->backlight_on_high){ - brightness = 1.0-brightness; + if (!self->backlight_on_high) { + brightness = 1.0 - brightness; } bool ok = false; @@ -181,7 +181,7 @@ bool common_hal_displayio_display_set_brightness(displayio_display_obj_t* self, if (ispwm) { #if (CIRCUITPY_PULSEIO) - common_hal_pwmio_pwmout_set_duty_cycle(&self->backlight_pwm, (uint16_t) (0xffff * brightness)); + common_hal_pwmio_pwmout_set_duty_cycle(&self->backlight_pwm, (uint16_t)(0xffff * brightness)); ok = true; #else ok = false; @@ -193,7 +193,7 @@ bool common_hal_displayio_display_set_brightness(displayio_display_obj_t* self, ok = displayio_display_core_begin_transaction(&self->core); if (ok) { if (self->data_as_commands) { - uint8_t set_brightness[2] = {self->brightness_command, (uint8_t) (0xff * brightness)}; + uint8_t set_brightness[2] = {self->brightness_command, (uint8_t)(0xff * brightness)}; self->core.send(self->core.bus, DISPLAY_COMMAND, CHIP_SELECT_TOGGLE_EVERY_BYTE, set_brightness, 2); } else { uint8_t command = self->brightness_command; @@ -212,11 +212,11 @@ bool common_hal_displayio_display_set_brightness(displayio_display_obj_t* self, return ok; } -mp_obj_t common_hal_displayio_display_get_bus(displayio_display_obj_t* self) { +mp_obj_t common_hal_displayio_display_get_bus(displayio_display_obj_t *self) { return self->core.bus; } -STATIC const displayio_area_t* _get_refresh_areas(displayio_display_obj_t *self) { +STATIC const displayio_area_t *_get_refresh_areas(displayio_display_obj_t *self) { if (self->core.full_refresh) { self->core.area.next = NULL; return &self->core.area; @@ -226,14 +226,14 @@ STATIC const displayio_area_t* _get_refresh_areas(displayio_display_obj_t *self) return NULL; } -STATIC void _send_pixels(displayio_display_obj_t* self, uint8_t* pixels, uint32_t length) { +STATIC void _send_pixels(displayio_display_obj_t *self, uint8_t *pixels, uint32_t length) { if (!self->data_as_commands) { self->core.send(self->core.bus, DISPLAY_COMMAND, CHIP_SELECT_TOGGLE_EVERY_BYTE, &self->write_ram_command, 1); } self->core.send(self->core.bus, DISPLAY_DATA, CHIP_SELECT_UNTOUCHED, pixels, length); } -STATIC bool _refresh_area(displayio_display_obj_t* self, const displayio_area_t* area) { +STATIC bool _refresh_area(displayio_display_obj_t *self, const displayio_area_t *area) { uint16_t buffer_size = 128; // In uint32_ts displayio_area_t clipped; @@ -294,8 +294,8 @@ STATIC bool _refresh_area(displayio_display_obj_t* self, const displayio_area_t* remaining_rows -= rows_per_buffer; displayio_display_core_set_region_to_update(&self->core, self->set_column_command, - self->set_row_command, NO_COMMAND, NO_COMMAND, self->data_as_commands, false, - &subrectangle, self->SH1107_addressing); + self->set_row_command, NO_COMMAND, NO_COMMAND, self->data_as_commands, false, + &subrectangle, self->SH1107_addressing); uint16_t subrectangle_size_bytes; if (self->core.colorspace.depth >= 8) { @@ -315,7 +315,7 @@ STATIC bool _refresh_area(displayio_display_obj_t* self, const displayio_area_t* } displayio_display_core_begin_transaction(&self->core); - _send_pixels(self, (uint8_t*) buffer, subrectangle_size_bytes); + _send_pixels(self, (uint8_t *)buffer, subrectangle_size_bytes); displayio_display_core_end_transaction(&self->core); // TODO(tannewt): Make refresh displays faster so we don't starve other @@ -325,12 +325,12 @@ STATIC bool _refresh_area(displayio_display_obj_t* self, const displayio_area_t* return true; } -STATIC void _refresh_display(displayio_display_obj_t* self) { +STATIC void _refresh_display(displayio_display_obj_t *self) { if (!displayio_display_core_start_refresh(&self->core)) { // A refresh on this bus is already in progress. Try next display. return; } - const displayio_area_t* current_area = _get_refresh_areas(self); + const displayio_area_t *current_area = _get_refresh_areas(self); while (current_area != NULL) { _refresh_area(self, current_area); current_area = current_area->next; @@ -338,10 +338,10 @@ STATIC void _refresh_display(displayio_display_obj_t* self) { displayio_display_core_finish_refresh(&self->core); } -void common_hal_displayio_display_set_rotation(displayio_display_obj_t* self, int rotation){ +void common_hal_displayio_display_set_rotation(displayio_display_obj_t *self, int rotation) { bool transposed = (self->core.rotation == 90 || self->core.rotation == 270); bool will_transposed = (rotation == 90 || rotation == 270); - if(transposed != will_transposed) { + if (transposed != will_transposed) { int tmp = self->core.width; self->core.width = self->core.height; self->core.height = tmp; @@ -356,13 +356,13 @@ void common_hal_displayio_display_set_rotation(displayio_display_obj_t* self, in } } -uint16_t common_hal_displayio_display_get_rotation(displayio_display_obj_t* self){ +uint16_t common_hal_displayio_display_get_rotation(displayio_display_obj_t *self) { return self->core.rotation; } -bool common_hal_displayio_display_refresh(displayio_display_obj_t* self, uint32_t target_ms_per_frame, uint32_t maximum_ms_per_real_frame) { - if (!self->auto_refresh && !self->first_manual_refresh && (target_ms_per_frame != 0xffffffff) ) { +bool common_hal_displayio_display_refresh(displayio_display_obj_t *self, uint32_t target_ms_per_frame, uint32_t maximum_ms_per_real_frame) { + if (!self->auto_refresh && !self->first_manual_refresh && (target_ms_per_frame != 0xffffffff)) { uint64_t current_time = supervisor_ticks_ms64(); uint32_t current_ms_since_real_refresh = current_time - self->core.last_refresh; // Test to see if the real frame time is below our minimum. @@ -386,12 +386,12 @@ bool common_hal_displayio_display_refresh(displayio_display_obj_t* self, uint32_ return true; } -bool common_hal_displayio_display_get_auto_refresh(displayio_display_obj_t* self) { +bool common_hal_displayio_display_get_auto_refresh(displayio_display_obj_t *self) { return self->auto_refresh; } -void common_hal_displayio_display_set_auto_refresh(displayio_display_obj_t* self, - bool auto_refresh) { +void common_hal_displayio_display_set_auto_refresh(displayio_display_obj_t *self, + bool auto_refresh) { self->first_manual_refresh = !auto_refresh; if (auto_refresh != self->auto_refresh) { if (auto_refresh) { @@ -403,7 +403,7 @@ void common_hal_displayio_display_set_auto_refresh(displayio_display_obj_t* self self->auto_refresh = auto_refresh; } -STATIC void _update_backlight(displayio_display_obj_t* self) { +STATIC void _update_backlight(displayio_display_obj_t *self) { if (!self->auto_brightness || self->updating_backlight) { return; } @@ -417,7 +417,7 @@ STATIC void _update_backlight(displayio_display_obj_t* self) { self->last_backlight_refresh = supervisor_ticks_ms64(); } -void displayio_display_background(displayio_display_obj_t* self) { +void displayio_display_background(displayio_display_obj_t *self) { _update_backlight(self); if (self->auto_refresh && (supervisor_ticks_ms64() - self->core.last_refresh) > self->native_ms_per_frame) { @@ -425,7 +425,7 @@ void displayio_display_background(displayio_display_obj_t* self) { } } -void release_display(displayio_display_obj_t* self) { +void release_display(displayio_display_obj_t *self) { common_hal_displayio_display_set_auto_refresh(self, false); release_display_core(&self->core); #if (CIRCUITPY_PULSEIO) @@ -440,12 +440,12 @@ void release_display(displayio_display_obj_t* self) { #endif } -void reset_display(displayio_display_obj_t* self) { +void reset_display(displayio_display_obj_t *self) { common_hal_displayio_display_set_auto_refresh(self, true); self->auto_brightness = true; common_hal_displayio_display_show(self, NULL); } -void displayio_display_collect_ptrs(displayio_display_obj_t* self) { +void displayio_display_collect_ptrs(displayio_display_obj_t *self) { displayio_display_core_collect_ptrs(&self->core); } diff --git a/shared-module/displayio/Display.h b/shared-module/displayio/Display.h index cc9cd54c4..a0049f00c 100644 --- a/shared-module/displayio/Display.h +++ b/shared-module/displayio/Display.h @@ -64,10 +64,10 @@ typedef struct { bool SH1107_addressing; } displayio_display_obj_t; -void displayio_display_background(displayio_display_obj_t* self); -void release_display(displayio_display_obj_t* self); -void reset_display(displayio_display_obj_t* self); +void displayio_display_background(displayio_display_obj_t *self); +void release_display(displayio_display_obj_t *self); +void reset_display(displayio_display_obj_t *self); -void displayio_display_collect_ptrs(displayio_display_obj_t* self); +void displayio_display_collect_ptrs(displayio_display_obj_t *self); #endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_DISPLAY_H diff --git a/shared-module/displayio/EPaperDisplay.c b/shared-module/displayio/EPaperDisplay.c index 3fb37ff21..7eff58775 100644 --- a/shared-module/displayio/EPaperDisplay.c +++ b/shared-module/displayio/EPaperDisplay.c @@ -42,15 +42,15 @@ #include <stdint.h> #include <string.h> -void common_hal_displayio_epaperdisplay_construct(displayio_epaperdisplay_obj_t* self, - mp_obj_t bus, const uint8_t* start_sequence, uint16_t start_sequence_len, - const uint8_t* stop_sequence, uint16_t stop_sequence_len, - uint16_t width, uint16_t height, uint16_t ram_width, uint16_t ram_height, - int16_t colstart, int16_t rowstart, uint16_t rotation, - uint16_t set_column_window_command, uint16_t set_row_window_command, - uint16_t set_current_column_command, uint16_t set_current_row_command, - uint16_t write_black_ram_command, bool black_bits_inverted, uint16_t write_color_ram_command, bool color_bits_inverted, uint32_t highlight_color, uint16_t refresh_display_command, mp_float_t refresh_time, - const mcu_pin_obj_t* busy_pin, bool busy_state, mp_float_t seconds_per_frame, bool chip_select, bool grayscale) { +void common_hal_displayio_epaperdisplay_construct(displayio_epaperdisplay_obj_t *self, + mp_obj_t bus, const uint8_t *start_sequence, uint16_t start_sequence_len, + const uint8_t *stop_sequence, uint16_t stop_sequence_len, + uint16_t width, uint16_t height, uint16_t ram_width, uint16_t ram_height, + int16_t colstart, int16_t rowstart, uint16_t rotation, + uint16_t set_column_window_command, uint16_t set_row_window_command, + uint16_t set_current_column_command, uint16_t set_current_row_command, + uint16_t write_black_ram_command, bool black_bits_inverted, uint16_t write_color_ram_command, bool color_bits_inverted, uint32_t highlight_color, uint16_t refresh_display_command, mp_float_t refresh_time, + const mcu_pin_obj_t *busy_pin, bool busy_state, mp_float_t seconds_per_frame, bool chip_select, bool grayscale) { if (highlight_color != 0x000000) { self->core.colorspace.tricolor = true; self->core.colorspace.tricolor_hue = displayio_colorconverter_compute_hue(highlight_color); @@ -97,16 +97,16 @@ void common_hal_displayio_epaperdisplay_construct(displayio_epaperdisplay_obj_t* common_hal_displayio_epaperdisplay_show(self, &circuitpython_splash); } -bool common_hal_displayio_epaperdisplay_show(displayio_epaperdisplay_obj_t* self, displayio_group_t* root_group) { +bool common_hal_displayio_epaperdisplay_show(displayio_epaperdisplay_obj_t *self, displayio_group_t *root_group) { return displayio_display_core_show(&self->core, root_group); } -const displayio_area_t* displayio_epaperdisplay_get_refresh_areas(displayio_epaperdisplay_obj_t *self) { +const displayio_area_t *displayio_epaperdisplay_get_refresh_areas(displayio_epaperdisplay_obj_t *self) { if (self->core.full_refresh) { self->core.area.next = NULL; return &self->core.area; } - const displayio_area_t* first_area = NULL; + const displayio_area_t *first_area = NULL; if (self->core.current_group != NULL) { first_area = displayio_group_get_refresh_areas(self->core.current_group, NULL); } @@ -117,15 +117,15 @@ const displayio_area_t* displayio_epaperdisplay_get_refresh_areas(displayio_epap return first_area; } -uint16_t common_hal_displayio_epaperdisplay_get_width(displayio_epaperdisplay_obj_t* self){ +uint16_t common_hal_displayio_epaperdisplay_get_width(displayio_epaperdisplay_obj_t *self) { return displayio_display_core_get_width(&self->core); } -uint16_t common_hal_displayio_epaperdisplay_get_height(displayio_epaperdisplay_obj_t* self){ +uint16_t common_hal_displayio_epaperdisplay_get_height(displayio_epaperdisplay_obj_t *self) { return displayio_display_core_get_height(&self->core); } -STATIC void wait_for_busy(displayio_epaperdisplay_obj_t* self) { +STATIC void wait_for_busy(displayio_epaperdisplay_obj_t *self) { if (self->busy.base.type == &mp_type_NoneType) { return; } @@ -134,8 +134,8 @@ STATIC void wait_for_busy(displayio_epaperdisplay_obj_t* self) { } } -STATIC void send_command_sequence(displayio_epaperdisplay_obj_t* self, - bool should_wait_for_busy, const uint8_t* sequence, uint32_t sequence_len) { +STATIC void send_command_sequence(displayio_epaperdisplay_obj_t *self, + bool should_wait_for_busy, const uint8_t *sequence, uint32_t sequence_len) { uint32_t i = 0; while (i < sequence_len) { const uint8_t *cmd = sequence + i; @@ -163,7 +163,7 @@ STATIC void send_command_sequence(displayio_epaperdisplay_obj_t* self, } } -void displayio_epaperdisplay_start_refresh(displayio_epaperdisplay_obj_t* self) { +void displayio_epaperdisplay_start_refresh(displayio_epaperdisplay_obj_t *self) { // run start sequence self->core.bus_reset(self->core.bus); @@ -171,7 +171,7 @@ void displayio_epaperdisplay_start_refresh(displayio_epaperdisplay_obj_t* self) displayio_display_core_start_refresh(&self->core); } -uint32_t common_hal_displayio_epaperdisplay_get_time_to_refresh(displayio_epaperdisplay_obj_t* self) { +uint32_t common_hal_displayio_epaperdisplay_get_time_to_refresh(displayio_epaperdisplay_obj_t *self) { if (self->core.last_refresh == 0) { return 0; } @@ -183,7 +183,7 @@ uint32_t common_hal_displayio_epaperdisplay_get_time_to_refresh(displayio_epaper return self->milliseconds_per_frame - elapsed_time; } -void displayio_epaperdisplay_finish_refresh(displayio_epaperdisplay_obj_t* self) { +void displayio_epaperdisplay_finish_refresh(displayio_epaperdisplay_obj_t *self) { // Actually refresh the display now that all pixel RAM has been updated. displayio_display_core_begin_transaction(&self->core); self->core.send(self->core.bus, DISPLAY_COMMAND, self->chip_select, &self->refresh_display_command, 1); @@ -194,14 +194,14 @@ void displayio_epaperdisplay_finish_refresh(displayio_epaperdisplay_obj_t* self) displayio_display_core_finish_refresh(&self->core); } -mp_obj_t common_hal_displayio_epaperdisplay_get_bus(displayio_epaperdisplay_obj_t* self) { +mp_obj_t common_hal_displayio_epaperdisplay_get_bus(displayio_epaperdisplay_obj_t *self) { return self->core.bus; } -void common_hal_displayio_epaperdisplay_set_rotation(displayio_epaperdisplay_obj_t* self, int rotation){ +void common_hal_displayio_epaperdisplay_set_rotation(displayio_epaperdisplay_obj_t *self, int rotation) { bool transposed = (self->core.rotation == 90 || self->core.rotation == 270); bool will_transposed = (rotation == 90 || rotation == 270); - if(transposed != will_transposed) { + if (transposed != will_transposed) { int tmp = self->core.width; self->core.width = self->core.height; self->core.height = tmp; @@ -216,12 +216,12 @@ void common_hal_displayio_epaperdisplay_set_rotation(displayio_epaperdisplay_obj } } -uint16_t common_hal_displayio_epaperdisplay_get_rotation(displayio_epaperdisplay_obj_t* self){ +uint16_t common_hal_displayio_epaperdisplay_get_rotation(displayio_epaperdisplay_obj_t *self) { return self->core.rotation; } -bool displayio_epaperdisplay_refresh_area(displayio_epaperdisplay_obj_t* self, const displayio_area_t* area) { +bool displayio_epaperdisplay_refresh_area(displayio_epaperdisplay_obj_t *self, const displayio_area_t *area) { uint16_t buffer_size = 128; // In uint32_ts displayio_area_t clipped; @@ -264,8 +264,8 @@ bool displayio_epaperdisplay_refresh_area(displayio_epaperdisplay_obj_t* self, c if (self->set_row_window_command != NO_COMMAND) { displayio_display_core_set_region_to_update(&self->core, self->set_column_window_command, - self->set_row_window_command, self->set_current_column_command, self->set_current_row_command, - false, self->chip_select, &clipped, false /* SH1107_addressing */); + self->set_row_window_command, self->set_current_column_command, self->set_current_row_command, + false, self->chip_select, &clipped, false /* SH1107_addressing */); } uint8_t write_command = self->write_black_ram_command; @@ -317,7 +317,7 @@ bool displayio_epaperdisplay_refresh_area(displayio_epaperdisplay_obj_t* self, c // Can't acquire display bus; skip the rest of the data. Try next display. return false; } - self->core.send(self->core.bus, DISPLAY_DATA, self->chip_select, (uint8_t*) buffer, subrectangle_size_bytes); + self->core.send(self->core.bus, DISPLAY_DATA, self->chip_select, (uint8_t *)buffer, subrectangle_size_bytes); displayio_display_core_end_transaction(&self->core); // TODO(tannewt): Make refresh displays faster so we don't starve other @@ -329,7 +329,7 @@ bool displayio_epaperdisplay_refresh_area(displayio_epaperdisplay_obj_t* self, c return true; } -bool common_hal_displayio_epaperdisplay_refresh(displayio_epaperdisplay_obj_t* self) { +bool common_hal_displayio_epaperdisplay_refresh(displayio_epaperdisplay_obj_t *self) { if (self->refreshing && self->busy.base.type == &digitalio_digitalinout_type) { if (common_hal_digitalio_digitalinout_get_value(&self->busy) != self->busy_state) { @@ -352,7 +352,7 @@ bool common_hal_displayio_epaperdisplay_refresh(displayio_epaperdisplay_obj_t* s // Can't acquire display bus; skip updating this display. Try next display. return false; } - const displayio_area_t* current_area = displayio_epaperdisplay_get_refresh_areas(self); + const displayio_area_t *current_area = displayio_epaperdisplay_get_refresh_areas(self); if (current_area == NULL) { return true; } @@ -365,7 +365,7 @@ bool common_hal_displayio_epaperdisplay_refresh(displayio_epaperdisplay_obj_t* s return true; } -void displayio_epaperdisplay_background(displayio_epaperdisplay_obj_t* self) { +void displayio_epaperdisplay_background(displayio_epaperdisplay_obj_t *self) { if (self->refreshing) { bool refresh_done = false; if (self->busy.base.type == &digitalio_digitalinout_type) { @@ -383,12 +383,12 @@ void displayio_epaperdisplay_background(displayio_epaperdisplay_obj_t* self) { } } -bool common_hal_displayio_epaperdisplay_get_busy(displayio_epaperdisplay_obj_t* self) { +bool common_hal_displayio_epaperdisplay_get_busy(displayio_epaperdisplay_obj_t *self) { displayio_epaperdisplay_background(self); return self->refreshing; } -void release_epaperdisplay(displayio_epaperdisplay_obj_t* self) { +void release_epaperdisplay(displayio_epaperdisplay_obj_t *self) { if (self->refreshing) { wait_for_busy(self); supervisor_disable_tick(); @@ -403,10 +403,10 @@ void release_epaperdisplay(displayio_epaperdisplay_obj_t* self) { } } -void displayio_epaperdisplay_collect_ptrs(displayio_epaperdisplay_obj_t* self) { +void displayio_epaperdisplay_collect_ptrs(displayio_epaperdisplay_obj_t *self) { displayio_display_core_collect_ptrs(&self->core); - gc_collect_ptr((void *) self->start_sequence); - gc_collect_ptr((void *) self->stop_sequence); + gc_collect_ptr((void *)self->start_sequence); + gc_collect_ptr((void *)self->stop_sequence); } bool maybe_refresh_epaperdisplay(void) { @@ -416,7 +416,7 @@ bool maybe_refresh_epaperdisplay(void) { // Skip regular displays and those not showing the splash. continue; } - displayio_epaperdisplay_obj_t* display = &displays[i].epaper_display; + displayio_epaperdisplay_obj_t *display = &displays[i].epaper_display; if (common_hal_displayio_epaperdisplay_get_time_to_refresh(display) != 0) { return false; } diff --git a/shared-module/displayio/EPaperDisplay.h b/shared-module/displayio/EPaperDisplay.h index d0668ff44..988cc57fa 100644 --- a/shared-module/displayio/EPaperDisplay.h +++ b/shared-module/displayio/EPaperDisplay.h @@ -38,9 +38,9 @@ typedef struct { displayio_display_core_t core; digitalio_digitalinout_obj_t busy; uint32_t milliseconds_per_frame; - const uint8_t* start_sequence; + const uint8_t *start_sequence; uint32_t start_sequence_len; - const uint8_t* stop_sequence; + const uint8_t *stop_sequence; uint32_t stop_sequence_len; uint16_t refresh_time; uint16_t set_column_window_command; @@ -59,10 +59,10 @@ typedef struct { display_chip_select_behavior_t chip_select; } displayio_epaperdisplay_obj_t; -void displayio_epaperdisplay_background(displayio_epaperdisplay_obj_t* self); -void release_epaperdisplay(displayio_epaperdisplay_obj_t* self); +void displayio_epaperdisplay_background(displayio_epaperdisplay_obj_t *self); +void release_epaperdisplay(displayio_epaperdisplay_obj_t *self); bool maybe_refresh_epaperdisplay(void); -void displayio_epaperdisplay_collect_ptrs(displayio_epaperdisplay_obj_t* self); +void displayio_epaperdisplay_collect_ptrs(displayio_epaperdisplay_obj_t *self); #endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_EPAPERDISPLAY_H diff --git a/shared-module/displayio/FourWire.c b/shared-module/displayio/FourWire.c index e993f2480..59e2021bd 100644 --- a/shared-module/displayio/FourWire.c +++ b/shared-module/displayio/FourWire.c @@ -36,9 +36,9 @@ #include "shared-bindings/time/__init__.h" #include "shared-module/displayio/display_core.h" -void common_hal_displayio_fourwire_construct(displayio_fourwire_obj_t* self, - busio_spi_obj_t* spi, const mcu_pin_obj_t* command, - const mcu_pin_obj_t* chip_select, const mcu_pin_obj_t* reset, uint32_t baudrate, +void common_hal_displayio_fourwire_construct(displayio_fourwire_obj_t *self, + busio_spi_obj_t *spi, const mcu_pin_obj_t *command, + const mcu_pin_obj_t *chip_select, const mcu_pin_obj_t *reset, uint32_t baudrate, uint8_t polarity, uint8_t phase) { self->bus = spi; @@ -69,7 +69,7 @@ void common_hal_displayio_fourwire_construct(displayio_fourwire_obj_t* self, common_hal_never_reset_pin(chip_select); } -void common_hal_displayio_fourwire_deinit(displayio_fourwire_obj_t* self) { +void common_hal_displayio_fourwire_deinit(displayio_fourwire_obj_t *self) { if (self->bus == &self->inline_bus) { common_hal_busio_spi_deinit(self->bus); } @@ -80,7 +80,7 @@ void common_hal_displayio_fourwire_deinit(displayio_fourwire_obj_t* self) { } bool common_hal_displayio_fourwire_reset(mp_obj_t obj) { - displayio_fourwire_obj_t* self = MP_OBJ_TO_PTR(obj); + displayio_fourwire_obj_t *self = MP_OBJ_TO_PTR(obj); if (self->reset.base.type == &mp_type_NoneType) { return false; } @@ -92,7 +92,7 @@ bool common_hal_displayio_fourwire_reset(mp_obj_t obj) { } bool common_hal_displayio_fourwire_bus_free(mp_obj_t obj) { - displayio_fourwire_obj_t* self = MP_OBJ_TO_PTR(obj); + displayio_fourwire_obj_t *self = MP_OBJ_TO_PTR(obj); if (!common_hal_busio_spi_try_lock(self->bus)) { return false; } @@ -101,19 +101,19 @@ bool common_hal_displayio_fourwire_bus_free(mp_obj_t obj) { } bool common_hal_displayio_fourwire_begin_transaction(mp_obj_t obj) { - displayio_fourwire_obj_t* self = MP_OBJ_TO_PTR(obj); + displayio_fourwire_obj_t *self = MP_OBJ_TO_PTR(obj); if (!common_hal_busio_spi_try_lock(self->bus)) { return false; } common_hal_busio_spi_configure(self->bus, self->frequency, self->polarity, - self->phase, 8); + self->phase, 8); common_hal_digitalio_digitalinout_set_value(&self->chip_select, false); return true; } void common_hal_displayio_fourwire_send(mp_obj_t obj, display_byte_type_t data_type, - display_chip_select_behavior_t chip_select, const uint8_t *data, uint32_t data_length) { - displayio_fourwire_obj_t* self = MP_OBJ_TO_PTR(obj); + display_chip_select_behavior_t chip_select, const uint8_t *data, uint32_t data_length) { + displayio_fourwire_obj_t *self = MP_OBJ_TO_PTR(obj); common_hal_digitalio_digitalinout_set_value(&self->command, data_type == DISPLAY_DATA); if (chip_select == CHIP_SELECT_TOGGLE_EVERY_BYTE) { // Toggle chip select after each command byte in case the display driver @@ -130,7 +130,7 @@ void common_hal_displayio_fourwire_send(mp_obj_t obj, display_byte_type_t data_t } void common_hal_displayio_fourwire_end_transaction(mp_obj_t obj) { - displayio_fourwire_obj_t* self = MP_OBJ_TO_PTR(obj); + displayio_fourwire_obj_t *self = MP_OBJ_TO_PTR(obj); common_hal_digitalio_digitalinout_set_value(&self->chip_select, true); common_hal_busio_spi_unlock(self->bus); } diff --git a/shared-module/displayio/FourWire.h b/shared-module/displayio/FourWire.h index a4260a3ac..b28c1ef84 100644 --- a/shared-module/displayio/FourWire.h +++ b/shared-module/displayio/FourWire.h @@ -33,7 +33,7 @@ typedef struct { mp_obj_base_t base; - busio_spi_obj_t* bus; + busio_spi_obj_t *bus; busio_spi_obj_t inline_bus; digitalio_digitalinout_obj_t command; digitalio_digitalinout_obj_t chip_select; diff --git a/shared-module/displayio/Group.c b/shared-module/displayio/Group.c index a36acc1c3..c50f034bf 100644 --- a/shared-module/displayio/Group.c +++ b/shared-module/displayio/Group.c @@ -35,16 +35,16 @@ #endif -void common_hal_displayio_group_construct(displayio_group_t* self, uint32_t scale, mp_int_t x, mp_int_t y) { +void common_hal_displayio_group_construct(displayio_group_t *self, uint32_t scale, mp_int_t x, mp_int_t y) { mp_obj_list_t *members = mp_obj_new_list(0, NULL); displayio_group_construct(self, members, scale, x, y); } -bool common_hal_displayio_group_get_hidden(displayio_group_t* self) { +bool common_hal_displayio_group_get_hidden(displayio_group_t *self) { return self->hidden; } -void common_hal_displayio_group_set_hidden(displayio_group_t* self, bool hidden) { +void common_hal_displayio_group_set_hidden(displayio_group_t *self, bool hidden) { if (self->hidden == hidden) { return; } @@ -95,11 +95,11 @@ void displayio_group_set_hidden_by_parent(displayio_group_t *self, bool hidden) } } -uint32_t common_hal_displayio_group_get_scale(displayio_group_t* self) { +uint32_t common_hal_displayio_group_get_scale(displayio_group_t *self) { return self->scale; } -bool displayio_group_get_previous_area(displayio_group_t *self, displayio_area_t* area) { +bool displayio_group_get_previous_area(displayio_group_t *self, displayio_area_t *area) { bool first = true; for (size_t i = 0; i < self->members->len; i++) { mp_obj_t layer; @@ -137,20 +137,20 @@ bool displayio_group_get_previous_area(displayio_group_t *self, displayio_area_t return !first; } -static void _update_child_transforms(displayio_group_t* self) { +static void _update_child_transforms(displayio_group_t *self) { if (!self->in_group) { return; } for (size_t i = 0; i < self->members->len; i++) { mp_obj_t layer; -#if CIRCUITPY_VECTORIO + #if CIRCUITPY_VECTORIO layer = mp_instance_cast_to_native_base( self->members->items[i], &vectorio_vector_shape_type); if (layer != MP_OBJ_NULL) { vectorio_vector_shape_update_transform(layer, &self->absolute_transform); continue; } -#endif + #endif layer = mp_instance_cast_to_native_base( self->members->items[i], &displayio_tilegrid_type); if (layer != MP_OBJ_NULL) { @@ -167,7 +167,7 @@ static void _update_child_transforms(displayio_group_t* self) { } void displayio_group_update_transform(displayio_group_t *self, - const displayio_buffer_transform_t* parent_transform) { + const displayio_buffer_transform_t *parent_transform) { self->in_group = parent_transform != NULL; if (self->in_group) { int16_t x = self->x; @@ -189,7 +189,7 @@ void displayio_group_update_transform(displayio_group_t *self, _update_child_transforms(self); } -void common_hal_displayio_group_set_scale(displayio_group_t* self, uint32_t scale) { +void common_hal_displayio_group_set_scale(displayio_group_t *self, uint32_t scale) { if (self->scale == scale) { return; } @@ -201,18 +201,18 @@ void common_hal_displayio_group_set_scale(displayio_group_t* self, uint32_t scal _update_child_transforms(self); } -mp_int_t common_hal_displayio_group_get_x(displayio_group_t* self) { +mp_int_t common_hal_displayio_group_get_x(displayio_group_t *self) { return self->x; } -void common_hal_displayio_group_set_x(displayio_group_t* self, mp_int_t x) { +void common_hal_displayio_group_set_x(displayio_group_t *self, mp_int_t x) { if (self->x == x) { return; } if (self->absolute_transform.transpose_xy) { int16_t dy = self->absolute_transform.dy / self->scale; self->absolute_transform.y += dy * (x - self->x); - } else { + } else { int16_t dx = self->absolute_transform.dx / self->scale; self->absolute_transform.x += dx * (x - self->x); } @@ -221,18 +221,18 @@ void common_hal_displayio_group_set_x(displayio_group_t* self, mp_int_t x) { _update_child_transforms(self); } -mp_int_t common_hal_displayio_group_get_y(displayio_group_t* self) { +mp_int_t common_hal_displayio_group_get_y(displayio_group_t *self) { return self->y; } -void common_hal_displayio_group_set_y(displayio_group_t* self, mp_int_t y) { +void common_hal_displayio_group_set_y(displayio_group_t *self, mp_int_t y) { if (self->y == y) { return; } if (self->absolute_transform.transpose_xy) { int8_t dx = self->absolute_transform.dx / self->scale; self->absolute_transform.x += dx * (y - self->y); - } else { + } else { int8_t dy = self->absolute_transform.dy / self->scale; self->absolute_transform.y += dy * (y - self->y); } @@ -240,18 +240,18 @@ void common_hal_displayio_group_set_y(displayio_group_t* self, mp_int_t y) { _update_child_transforms(self); } -static void _add_layer(displayio_group_t* self, mp_obj_t layer) { +static void _add_layer(displayio_group_t *self, mp_obj_t layer) { mp_obj_t native_layer; -#if CIRCUITPY_VECTORIO + #if CIRCUITPY_VECTORIO native_layer = mp_instance_cast_to_native_base(layer, &vectorio_vector_shape_type); if (native_layer != MP_OBJ_NULL) { vectorio_vector_shape_update_transform(native_layer, &self->absolute_transform); return; } -#endif + #endif native_layer = mp_instance_cast_to_native_base(layer, &displayio_tilegrid_type); if (native_layer != MP_OBJ_NULL) { - displayio_tilegrid_t* tilegrid = native_layer; + displayio_tilegrid_t *tilegrid = native_layer; if (tilegrid->in_group) { mp_raise_ValueError(translate("Layer already in a group.")); } else { @@ -262,7 +262,7 @@ static void _add_layer(displayio_group_t* self, mp_obj_t layer) { } native_layer = mp_instance_cast_to_native_base(layer, &displayio_group_type); if (native_layer != MP_OBJ_NULL) { - displayio_group_t* group = native_layer; + displayio_group_t *group = native_layer; if (group->in_group) { mp_raise_ValueError(translate("Layer already in a group.")); } else { @@ -274,11 +274,11 @@ static void _add_layer(displayio_group_t* self, mp_obj_t layer) { mp_raise_ValueError(translate("Layer must be a Group or TileGrid subclass.")); } -static void _remove_layer(displayio_group_t* self, size_t index) { +static void _remove_layer(displayio_group_t *self, size_t index) { mp_obj_t layer; displayio_area_t layer_area; bool rendered_last_frame = false; -#if CIRCUITPY_VECTORIO + #if CIRCUITPY_VECTORIO layer = mp_instance_cast_to_native_base( self->members->items[index], &vectorio_vector_shape_type); if (layer != MP_OBJ_NULL) { @@ -286,18 +286,18 @@ static void _remove_layer(displayio_group_t* self, size_t index) { rendered_last_frame = has_dirty_area; vectorio_vector_shape_update_transform(layer, NULL); } -#endif + #endif layer = mp_instance_cast_to_native_base( self->members->items[index], &displayio_tilegrid_type); if (layer != MP_OBJ_NULL) { - displayio_tilegrid_t* tilegrid = layer; + displayio_tilegrid_t *tilegrid = layer; rendered_last_frame = displayio_tilegrid_get_previous_area(tilegrid, &layer_area); displayio_tilegrid_update_transform(tilegrid, NULL); } layer = mp_instance_cast_to_native_base( self->members->items[index], &displayio_group_type); if (layer != MP_OBJ_NULL) { - displayio_group_t* group = layer; + displayio_group_t *group = layer; rendered_last_frame = displayio_group_get_previous_area(group, &layer_area); displayio_group_update_transform(group, NULL); } @@ -312,38 +312,38 @@ static void _remove_layer(displayio_group_t* self, size_t index) { self->item_removed = true; } -void common_hal_displayio_group_insert(displayio_group_t* self, size_t index, mp_obj_t layer) { +void common_hal_displayio_group_insert(displayio_group_t *self, size_t index, mp_obj_t layer) { _add_layer(self, layer); mp_obj_list_insert(self->members, index, layer); } -mp_obj_t common_hal_displayio_group_pop(displayio_group_t* self, size_t index) { +mp_obj_t common_hal_displayio_group_pop(displayio_group_t *self, size_t index) { _remove_layer(self, index); return mp_obj_list_pop(self->members, index); } -mp_int_t common_hal_displayio_group_index(displayio_group_t* self, mp_obj_t layer) { +mp_int_t common_hal_displayio_group_index(displayio_group_t *self, mp_obj_t layer) { mp_obj_t args[] = {self->members, layer}; mp_obj_t *index = mp_seq_index_obj( self->members->items, self->members->len, 2, args); return MP_OBJ_SMALL_INT_VALUE(index); } -size_t common_hal_displayio_group_get_len(displayio_group_t* self) { +size_t common_hal_displayio_group_get_len(displayio_group_t *self) { return self->members->len; } -mp_obj_t common_hal_displayio_group_get(displayio_group_t* self, size_t index) { +mp_obj_t common_hal_displayio_group_get(displayio_group_t *self, size_t index) { return self->members->items[index]; } -void common_hal_displayio_group_set(displayio_group_t* self, size_t index, mp_obj_t layer) { +void common_hal_displayio_group_set(displayio_group_t *self, size_t index, mp_obj_t layer) { _add_layer(self, layer); _remove_layer(self, index); mp_obj_list_store(self->members, MP_OBJ_NEW_SMALL_INT(index), layer); } -void displayio_group_construct(displayio_group_t* self, mp_obj_list_t* members, uint32_t scale, mp_int_t x, mp_int_t y) { +void displayio_group_construct(displayio_group_t *self, mp_obj_list_t *members, uint32_t scale, mp_int_t x, mp_int_t y) { self->x = x; self->y = y; self->members = members; @@ -352,12 +352,12 @@ void displayio_group_construct(displayio_group_t* self, mp_obj_list_t* members, self->in_group = false; } -bool displayio_group_fill_area(displayio_group_t *self, const _displayio_colorspace_t* colorspace, const displayio_area_t* area, uint32_t* mask, uint32_t* buffer) { +bool displayio_group_fill_area(displayio_group_t *self, const _displayio_colorspace_t *colorspace, const displayio_area_t *area, uint32_t *mask, uint32_t *buffer) { // Track if any of the layers finishes filling in the given area. We can ignore any remaining // layers at that point. - for (int32_t i = self->members->len - 1; i >= 0 ; i--) { + for (int32_t i = self->members->len - 1; i >= 0; i--) { mp_obj_t layer; -#if CIRCUITPY_VECTORIO + #if CIRCUITPY_VECTORIO layer = mp_instance_cast_to_native_base( self->members->items[i], &vectorio_vector_shape_type); if (layer != MP_OBJ_NULL) { @@ -366,7 +366,7 @@ bool displayio_group_fill_area(displayio_group_t *self, const _displayio_colorsp } continue; } -#endif + #endif layer = mp_instance_cast_to_native_base( self->members->items[i], &displayio_tilegrid_type); if (layer != MP_OBJ_NULL) { @@ -389,16 +389,16 @@ bool displayio_group_fill_area(displayio_group_t *self, const _displayio_colorsp void displayio_group_finish_refresh(displayio_group_t *self) { self->item_removed = false; - for (int32_t i = self->members->len - 1; i >= 0 ; i--) { + for (int32_t i = self->members->len - 1; i >= 0; i--) { mp_obj_t layer; -#if CIRCUITPY_VECTORIO + #if CIRCUITPY_VECTORIO layer = mp_instance_cast_to_native_base( self->members->items[i], &vectorio_vector_shape_type); if (layer != MP_OBJ_NULL) { vectorio_vector_shape_finish_refresh(layer); continue; } -#endif + #endif layer = mp_instance_cast_to_native_base( self->members->items[i], &displayio_tilegrid_type); if (layer != MP_OBJ_NULL) { @@ -414,22 +414,22 @@ void displayio_group_finish_refresh(displayio_group_t *self) { } } -displayio_area_t* displayio_group_get_refresh_areas(displayio_group_t *self, displayio_area_t* tail) { +displayio_area_t *displayio_group_get_refresh_areas(displayio_group_t *self, displayio_area_t *tail) { if (self->item_removed) { self->dirty_area.next = tail; tail = &self->dirty_area; } - for (int32_t i = self->members->len - 1; i >= 0 ; i--) { + for (int32_t i = self->members->len - 1; i >= 0; i--) { mp_obj_t layer; -#if CIRCUITPY_VECTORIO + #if CIRCUITPY_VECTORIO layer = mp_instance_cast_to_native_base( self->members->items[i], &vectorio_vector_shape_type); if (layer != MP_OBJ_NULL) { tail = vectorio_vector_shape_get_refresh_areas(layer, tail); continue; } -#endif + #endif layer = mp_instance_cast_to_native_base( self->members->items[i], &displayio_tilegrid_type); if (layer != MP_OBJ_NULL) { diff --git a/shared-module/displayio/Group.h b/shared-module/displayio/Group.h index 0964e0a0b..f68422315 100644 --- a/shared-module/displayio/Group.h +++ b/shared-module/displayio/Group.h @@ -43,19 +43,19 @@ typedef struct { int16_t x; int16_t y; uint16_t scale; - bool item_removed :1; - bool in_group :1; - bool hidden :1; - bool hidden_by_parent :1; - uint8_t padding :4; + bool item_removed : 1; + bool in_group : 1; + bool hidden : 1; + bool hidden_by_parent : 1; + uint8_t padding : 4; } displayio_group_t; -void displayio_group_construct(displayio_group_t* self, mp_obj_list_t* members, uint32_t scale, mp_int_t x, mp_int_t y); +void displayio_group_construct(displayio_group_t *self, mp_obj_list_t *members, uint32_t scale, mp_int_t x, mp_int_t y); void displayio_group_set_hidden_by_parent(displayio_group_t *self, bool hidden); -bool displayio_group_get_previous_area(displayio_group_t *group, displayio_area_t* area); -bool displayio_group_fill_area(displayio_group_t *group, const _displayio_colorspace_t* colorspace, const displayio_area_t* area, uint32_t* mask, uint32_t *buffer); -void displayio_group_update_transform(displayio_group_t *group, const displayio_buffer_transform_t* parent_transform); +bool displayio_group_get_previous_area(displayio_group_t *group, displayio_area_t *area); +bool displayio_group_fill_area(displayio_group_t *group, const _displayio_colorspace_t *colorspace, const displayio_area_t *area, uint32_t *mask, uint32_t *buffer); +void displayio_group_update_transform(displayio_group_t *group, const displayio_buffer_transform_t *parent_transform); void displayio_group_finish_refresh(displayio_group_t *self); -displayio_area_t* displayio_group_get_refresh_areas(displayio_group_t *self, displayio_area_t* tail); +displayio_area_t *displayio_group_get_refresh_areas(displayio_group_t *self, displayio_area_t *tail); #endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_GROUP_H diff --git a/shared-module/displayio/I2CDisplay.c b/shared-module/displayio/I2CDisplay.c index cc811e83d..6446e3198 100644 --- a/shared-module/displayio/I2CDisplay.c +++ b/shared-module/displayio/I2CDisplay.c @@ -38,8 +38,8 @@ #include "shared-bindings/time/__init__.h" #include "shared-module/displayio/display_core.h" -void common_hal_displayio_i2cdisplay_construct(displayio_i2cdisplay_obj_t* self, - busio_i2c_obj_t* i2c, uint16_t device_address, const mcu_pin_obj_t* reset) { +void common_hal_displayio_i2cdisplay_construct(displayio_i2cdisplay_obj_t *self, + busio_i2c_obj_t *i2c, uint16_t device_address, const mcu_pin_obj_t *reset) { // Reset the display before probing self->reset.base.type = &mp_type_NoneType; @@ -67,7 +67,7 @@ void common_hal_displayio_i2cdisplay_construct(displayio_i2cdisplay_obj_t* self, self->address = device_address; } -void common_hal_displayio_i2cdisplay_deinit(displayio_i2cdisplay_obj_t* self) { +void common_hal_displayio_i2cdisplay_deinit(displayio_i2cdisplay_obj_t *self) { if (self->bus == &self->inline_bus) { common_hal_busio_i2c_deinit(self->bus); } @@ -78,7 +78,7 @@ void common_hal_displayio_i2cdisplay_deinit(displayio_i2cdisplay_obj_t* self) { } bool common_hal_displayio_i2cdisplay_reset(mp_obj_t obj) { - displayio_i2cdisplay_obj_t* self = MP_OBJ_TO_PTR(obj); + displayio_i2cdisplay_obj_t *self = MP_OBJ_TO_PTR(obj); if (self->reset.base.type == &mp_type_NoneType) { return false; } @@ -90,7 +90,7 @@ bool common_hal_displayio_i2cdisplay_reset(mp_obj_t obj) { } bool common_hal_displayio_i2cdisplay_bus_free(mp_obj_t obj) { - displayio_i2cdisplay_obj_t* self = MP_OBJ_TO_PTR(obj); + displayio_i2cdisplay_obj_t *self = MP_OBJ_TO_PTR(obj); if (!common_hal_busio_i2c_try_lock(self->bus)) { return false; } @@ -99,13 +99,13 @@ bool common_hal_displayio_i2cdisplay_bus_free(mp_obj_t obj) { } bool common_hal_displayio_i2cdisplay_begin_transaction(mp_obj_t obj) { - displayio_i2cdisplay_obj_t* self = MP_OBJ_TO_PTR(obj); + displayio_i2cdisplay_obj_t *self = MP_OBJ_TO_PTR(obj); return common_hal_busio_i2c_try_lock(self->bus); } void common_hal_displayio_i2cdisplay_send(mp_obj_t obj, display_byte_type_t data_type, - display_chip_select_behavior_t chip_select, const uint8_t *data, uint32_t data_length) { - displayio_i2cdisplay_obj_t* self = MP_OBJ_TO_PTR(obj); + display_chip_select_behavior_t chip_select, const uint8_t *data, uint32_t data_length) { + displayio_i2cdisplay_obj_t *self = MP_OBJ_TO_PTR(obj); if (data_type == DISPLAY_COMMAND) { uint8_t command_bytes[2 * data_length]; for (uint32_t i = 0; i < data_length; i++) { @@ -122,6 +122,6 @@ void common_hal_displayio_i2cdisplay_send(mp_obj_t obj, display_byte_type_t data } void common_hal_displayio_i2cdisplay_end_transaction(mp_obj_t obj) { - displayio_i2cdisplay_obj_t* self = MP_OBJ_TO_PTR(obj); + displayio_i2cdisplay_obj_t *self = MP_OBJ_TO_PTR(obj); common_hal_busio_i2c_unlock(self->bus); } diff --git a/shared-module/displayio/I2CDisplay.h b/shared-module/displayio/I2CDisplay.h index 4636c3f73..cc5bcf1eb 100644 --- a/shared-module/displayio/I2CDisplay.h +++ b/shared-module/displayio/I2CDisplay.h @@ -32,7 +32,7 @@ typedef struct { mp_obj_base_t base; - busio_i2c_obj_t* bus; + busio_i2c_obj_t *bus; busio_i2c_obj_t inline_bus; digitalio_digitalinout_obj_t reset; uint16_t address; diff --git a/shared-module/displayio/OnDiskBitmap.c b/shared-module/displayio/OnDiskBitmap.c index c1a0ddeb7..5c7e00a58 100644 --- a/shared-module/displayio/OnDiskBitmap.c +++ b/shared-module/displayio/OnDiskBitmap.c @@ -31,11 +31,11 @@ #include "py/mperrno.h" #include "py/runtime.h" -static uint32_t read_word(uint16_t* bmp_header, uint16_t index) { +static uint32_t read_word(uint16_t *bmp_header, uint16_t index) { return bmp_header[index] | bmp_header[index + 1] << 16; } -void common_hal_displayio_ondiskbitmap_construct(displayio_ondiskbitmap_t *self, pyb_file_obj_t* file) { +void common_hal_displayio_ondiskbitmap_construct(displayio_ondiskbitmap_t *self, pyb_file_obj_t *file) { // Load the wave self->file = file; uint16_t bmp_header[69]; @@ -58,12 +58,12 @@ void common_hal_displayio_ondiskbitmap_construct(displayio_ondiskbitmap_t *self, uint32_t number_of_colors = read_word(bmp_header, 23); bool indexed = bits_per_pixel <= 8; - self->bitfield_compressed = (compression == 3); + self->bitfield_compressed = (compression == 3); self->bits_per_pixel = bits_per_pixel; self->width = read_word(bmp_header, 9); self->height = read_word(bmp_header, 11); - if (bits_per_pixel == 16){ + if (bits_per_pixel == 16) { if (((header_size >= 56)) || (self->bitfield_compressed)) { self->r_bitmask = read_word(bmp_header, 27); self->g_bitmask = read_word(bmp_header, 29); @@ -101,9 +101,9 @@ void common_hal_displayio_ondiskbitmap_construct(displayio_ondiskbitmap_t *self, mp_raise_ValueError_varg(translate("Only monochrome, indexed 4bpp or 8bpp, and 16bpp or greater BMPs supported: %d bpp given"), bits_per_pixel); } - uint8_t bytes_per_pixel = (self->bits_per_pixel / 8) ? (self->bits_per_pixel /8) : 1; + uint8_t bytes_per_pixel = (self->bits_per_pixel / 8) ? (self->bits_per_pixel / 8) : 1; uint8_t pixels_per_byte = 8 / self->bits_per_pixel; - if (pixels_per_byte == 0){ + if (pixels_per_byte == 0) { self->stride = (self->width * bytes_per_pixel); // Rows are word aligned. if (self->stride % 4 != 0) { @@ -121,15 +121,15 @@ void common_hal_displayio_ondiskbitmap_construct(displayio_ondiskbitmap_t *self, uint32_t common_hal_displayio_ondiskbitmap_get_pixel(displayio_ondiskbitmap_t *self, - int16_t x, int16_t y) { + int16_t x, int16_t y) { if (x < 0 || x >= self->width || y < 0 || y >= self->height) { return 0; } uint32_t location; - uint8_t bytes_per_pixel = (self->bits_per_pixel / 8) ? (self->bits_per_pixel /8) : 1; + uint8_t bytes_per_pixel = (self->bits_per_pixel / 8) ? (self->bits_per_pixel / 8) : 1; uint8_t pixels_per_byte = 8 / self->bits_per_pixel; - if (pixels_per_byte == 0){ + if (pixels_per_byte == 0) { location = self->data_offset + (self->height - y - 1) * self->stride + x * bytes_per_pixel; } else { location = self->data_offset + (self->height - y - 1) * self->stride + x / pixels_per_byte; @@ -159,12 +159,12 @@ uint32_t common_hal_displayio_ondiskbitmap_get_pixel(displayio_ondiskbitmap_t *s return self->palette_data[index]; } else if (bytes_per_pixel == 2) { if (self->g_bitmask == 0x07e0) { // 565 - red =((pixel_data & self->r_bitmask) >>11); - green = ((pixel_data & self->g_bitmask) >>5); + red = ((pixel_data & self->r_bitmask) >> 11); + green = ((pixel_data & self->g_bitmask) >> 5); blue = ((pixel_data & self->b_bitmask) >> 0); } else { // 555 - red =((pixel_data & self->r_bitmask) >>10); - green = ((pixel_data & self->g_bitmask) >>4); + red = ((pixel_data & self->r_bitmask) >> 10); + green = ((pixel_data & self->g_bitmask) >> 4); blue = ((pixel_data & self->b_bitmask) >> 0); } tmp = (red << 19 | green << 10 | blue << 3); diff --git a/shared-module/displayio/OnDiskBitmap.h b/shared-module/displayio/OnDiskBitmap.h index 28426f11b..610b11491 100644 --- a/shared-module/displayio/OnDiskBitmap.h +++ b/shared-module/displayio/OnDiskBitmap.h @@ -44,9 +44,9 @@ typedef struct { uint32_t g_bitmask; uint32_t b_bitmask; bool bitfield_compressed; - pyb_file_obj_t* file; + pyb_file_obj_t *file; uint8_t bits_per_pixel; - uint32_t* palette_data; + uint32_t *palette_data; } displayio_ondiskbitmap_t; #endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_ONDISKBITMAP_H diff --git a/shared-module/displayio/Palette.c b/shared-module/displayio/Palette.c index ba5ff665c..6dde3a80f 100644 --- a/shared-module/displayio/Palette.c +++ b/shared-module/displayio/Palette.c @@ -28,26 +28,26 @@ #include "shared-module/displayio/ColorConverter.h" -void common_hal_displayio_palette_construct(displayio_palette_t* self, uint16_t color_count) { +void common_hal_displayio_palette_construct(displayio_palette_t *self, uint16_t color_count) { self->color_count = color_count; - self->colors = (_displayio_color_t *) m_malloc(color_count * sizeof(_displayio_color_t), false); + self->colors = (_displayio_color_t *)m_malloc(color_count * sizeof(_displayio_color_t), false); } -void common_hal_displayio_palette_make_opaque(displayio_palette_t* self, uint32_t palette_index) { +void common_hal_displayio_palette_make_opaque(displayio_palette_t *self, uint32_t palette_index) { self->colors[palette_index].transparent = false; self->needs_refresh = true; } -void common_hal_displayio_palette_make_transparent(displayio_palette_t* self, uint32_t palette_index) { +void common_hal_displayio_palette_make_transparent(displayio_palette_t *self, uint32_t palette_index) { self->colors[palette_index].transparent = true; self->needs_refresh = true; } -uint32_t common_hal_displayio_palette_get_len(displayio_palette_t* self) { +uint32_t common_hal_displayio_palette_get_len(displayio_palette_t *self) { return self->color_count; } -void common_hal_displayio_palette_set_color(displayio_palette_t* self, uint32_t palette_index, uint32_t color) { +void common_hal_displayio_palette_set_color(displayio_palette_t *self, uint32_t palette_index, uint32_t color) { if (self->colors[palette_index].rgb888 == color) { return; } @@ -61,11 +61,11 @@ void common_hal_displayio_palette_set_color(displayio_palette_t* self, uint32_t self->needs_refresh = true; } -uint32_t common_hal_displayio_palette_get_color(displayio_palette_t* self, uint32_t palette_index) { +uint32_t common_hal_displayio_palette_get_color(displayio_palette_t *self, uint32_t palette_index) { return self->colors[palette_index].rgb888; } -bool displayio_palette_get_color(displayio_palette_t *self, const _displayio_colorspace_t* colorspace, uint32_t palette_index, uint32_t* color) { +bool displayio_palette_get_color(displayio_palette_t *self, const _displayio_colorspace_t *colorspace, uint32_t palette_index, uint32_t *color) { if (palette_index > self->color_count || self->colors[palette_index].transparent) { return false; // returns opaque } @@ -74,7 +74,7 @@ bool displayio_palette_get_color(displayio_palette_t *self, const _displayio_col uint8_t luma = self->colors[palette_index].luma; *color = luma >> (8 - colorspace->depth); // Chroma 0 means the color is a gray and has no hue so never color based on it. - if (self->colors[palette_index].chroma <= 16) { + if (self->colors[palette_index].chroma <= 16) { if (!colorspace->grayscale) { *color = 0; } diff --git a/shared-module/displayio/Palette.h b/shared-module/displayio/Palette.h index 993912cc5..82504b7ed 100644 --- a/shared-module/displayio/Palette.h +++ b/shared-module/displayio/Palette.h @@ -71,14 +71,14 @@ typedef struct { typedef struct { mp_obj_base_t base; - _displayio_color_t* colors; + _displayio_color_t *colors; uint32_t color_count; bool needs_refresh; } displayio_palette_t; // Returns false if color fetch did not succeed (out of range or transparent). // Returns true if color is opaque, and sets color. -bool displayio_palette_get_color(displayio_palette_t *palette, const _displayio_colorspace_t* colorspace, uint32_t palette_index, uint32_t* color); +bool displayio_palette_get_color(displayio_palette_t *palette, const _displayio_colorspace_t *colorspace, uint32_t palette_index, uint32_t *color); bool displayio_palette_needs_refresh(displayio_palette_t *self); void displayio_palette_finish_refresh(displayio_palette_t *self); diff --git a/shared-module/displayio/Shape.c b/shared-module/displayio/Shape.c index b94a392bc..4a32c7a60 100644 --- a/shared-module/displayio/Shape.c +++ b/shared-module/displayio/Shape.c @@ -56,10 +56,10 @@ void common_hal_displayio_shape_construct(displayio_shape_t *self, uint32_t widt self->data[2 * i + 1] = width; } - self->dirty_area.x1=0; - self->dirty_area.x2=width; - self->dirty_area.y1=0; - self->dirty_area.y2=height; + self->dirty_area.x1 = 0; + self->dirty_area.x2 = width; + self->dirty_area.y1 = 0; + self->dirty_area.y2 = height; } void common_hal_displayio_shape_set_boundary(displayio_shape_t *self, uint16_t y, uint16_t start_x, uint16_t end_x) { @@ -130,7 +130,7 @@ uint32_t common_hal_displayio_shape_get_pixel(void *obj, int16_t x, int16_t y) { return 1; } -displayio_area_t* displayio_shape_get_refresh_areas(displayio_shape_t *self, displayio_area_t* tail) { +displayio_area_t *displayio_shape_get_refresh_areas(displayio_shape_t *self, displayio_area_t *tail) { if (self->dirty_area.x1 == self->dirty_area.x2) { return tail; } diff --git a/shared-module/displayio/Shape.h b/shared-module/displayio/Shape.h index e59ad586e..2cac5d73b 100644 --- a/shared-module/displayio/Shape.h +++ b/shared-module/displayio/Shape.h @@ -39,13 +39,13 @@ typedef struct { uint16_t height; uint16_t half_width; uint16_t half_height; - uint16_t* data; + uint16_t *data; bool mirror_x; bool mirror_y; displayio_area_t dirty_area; } displayio_shape_t; void displayio_shape_finish_refresh(displayio_shape_t *self); -displayio_area_t* displayio_shape_get_refresh_areas(displayio_shape_t *self, displayio_area_t* tail); +displayio_area_t *displayio_shape_get_refresh_areas(displayio_shape_t *self, displayio_area_t *tail); #endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_SHAPE_H diff --git a/shared-module/displayio/TileGrid.c b/shared-module/displayio/TileGrid.c index 96473d4a8..347eba577 100644 --- a/shared-module/displayio/TileGrid.c +++ b/shared-module/displayio/TileGrid.c @@ -34,21 +34,21 @@ #include "shared-bindings/displayio/Shape.h" void common_hal_displayio_tilegrid_construct(displayio_tilegrid_t *self, mp_obj_t bitmap, - uint16_t bitmap_width_in_tiles, uint16_t bitmap_height_in_tiles, - mp_obj_t pixel_shader, uint16_t width, uint16_t height, - uint16_t tile_width, uint16_t tile_height, uint16_t x, uint16_t y, uint8_t default_tile) { + uint16_t bitmap_width_in_tiles, uint16_t bitmap_height_in_tiles, + mp_obj_t pixel_shader, uint16_t width, uint16_t height, + uint16_t tile_width, uint16_t tile_height, uint16_t x, uint16_t y, uint8_t default_tile) { uint32_t total_tiles = width * height; // Sprites will only have one tile so save a little memory by inlining values in the pointer. - uint8_t inline_tiles = sizeof(uint8_t*); + uint8_t inline_tiles = sizeof(uint8_t *); if (total_tiles <= inline_tiles) { self->tiles = 0; // Pack values into the pointer since there are only a few. for (uint32_t i = 0; i < inline_tiles; i++) { - ((uint8_t*) &self->tiles)[i] = default_tile; + ((uint8_t *)&self->tiles)[i] = default_tile; } self->inline_tiles = true; } else { - self->tiles = (uint8_t*) m_malloc(total_tiles, false); + self->tiles = (uint8_t *)m_malloc(total_tiles, false); for (uint32_t i = 0; i < total_tiles; i++) { self->tiles[i] = default_tile; } @@ -78,25 +78,25 @@ void common_hal_displayio_tilegrid_construct(displayio_tilegrid_t *self, mp_obj_ } -bool common_hal_displayio_tilegrid_get_hidden(displayio_tilegrid_t* self) { +bool common_hal_displayio_tilegrid_get_hidden(displayio_tilegrid_t *self) { return self->hidden; } -void common_hal_displayio_tilegrid_set_hidden(displayio_tilegrid_t* self, bool hidden) { +void common_hal_displayio_tilegrid_set_hidden(displayio_tilegrid_t *self, bool hidden) { self->hidden = hidden; - if(!hidden){ + if (!hidden) { self->full_change = true; } } void displayio_tilegrid_set_hidden_by_parent(displayio_tilegrid_t *self, bool hidden) { self->hidden_by_parent = hidden; - if(!hidden){ + if (!hidden) { self->full_change = true; } } -bool displayio_tilegrid_get_previous_area(displayio_tilegrid_t *self, displayio_area_t* area) { +bool displayio_tilegrid_get_previous_area(displayio_tilegrid_t *self, displayio_area_t *area) { if (self->previous_area.x1 == self->previous_area.x2) { return false; } @@ -113,8 +113,8 @@ void _update_current_x(displayio_tilegrid_t *self) { } // If there's no transform, substitute an identity transform so the calculations will work. - const displayio_buffer_transform_t* absolute_transform = - self->absolute_transform == NULL + const displayio_buffer_transform_t *absolute_transform = + self->absolute_transform == NULL ? &null_transform : self->absolute_transform; @@ -146,8 +146,8 @@ void _update_current_y(displayio_tilegrid_t *self) { } // If there's no transform, substitute an identity transform so the calculations will work. - const displayio_buffer_transform_t* absolute_transform = - self->absolute_transform == NULL + const displayio_buffer_transform_t *absolute_transform = + self->absolute_transform == NULL ? &null_transform : self->absolute_transform; @@ -171,7 +171,7 @@ void _update_current_y(displayio_tilegrid_t *self) { } void displayio_tilegrid_update_transform(displayio_tilegrid_t *self, - const displayio_buffer_transform_t* absolute_transform) { + const displayio_buffer_transform_t *absolute_transform) { self->in_group = absolute_transform != NULL; self->absolute_transform = absolute_transform; if (absolute_transform != NULL) { @@ -230,9 +230,9 @@ uint16_t common_hal_displayio_tilegrid_get_height(displayio_tilegrid_t *self) { } uint8_t common_hal_displayio_tilegrid_get_tile(displayio_tilegrid_t *self, uint16_t x, uint16_t y) { - uint8_t* tiles = self->tiles; + uint8_t *tiles = self->tiles; if (self->inline_tiles) { - tiles = (uint8_t*) &self->tiles; + tiles = (uint8_t *)&self->tiles; } if (tiles == NULL) { return 0; @@ -244,16 +244,16 @@ void common_hal_displayio_tilegrid_set_tile(displayio_tilegrid_t *self, uint16_t if (tile_index >= self->tiles_in_bitmap) { mp_raise_ValueError(translate("Tile index out of bounds")); } - uint8_t* tiles = self->tiles; + uint8_t *tiles = self->tiles; if (self->inline_tiles) { - tiles = (uint8_t*) &self->tiles; + tiles = (uint8_t *)&self->tiles; } if (tiles == NULL) { return; } tiles[y * self->width_in_tiles + x] = tile_index; displayio_area_t temp_area; - displayio_area_t* tile_area; + displayio_area_t *tile_area; if (!self->partial_change) { tile_area = &self->dirty_area; } else { @@ -331,11 +331,11 @@ void common_hal_displayio_tilegrid_set_top_left(displayio_tilegrid_t *self, uint self->full_change = true; } -bool displayio_tilegrid_fill_area(displayio_tilegrid_t *self, const _displayio_colorspace_t* colorspace, const displayio_area_t* area, uint32_t* mask, uint32_t *buffer) { +bool displayio_tilegrid_fill_area(displayio_tilegrid_t *self, const _displayio_colorspace_t *colorspace, const displayio_area_t *area, uint32_t *mask, uint32_t *buffer) { // If no tiles are present we have no impact. - uint8_t* tiles = self->tiles; + uint8_t *tiles = self->tiles; if (self->inline_tiles) { - tiles = (uint8_t*) &self->tiles; + tiles = (uint8_t *)&self->tiles; } if (tiles == NULL) { return false; @@ -384,9 +384,9 @@ bool displayio_tilegrid_fill_area(displayio_tilegrid_t *self, const _displayio_c // can either return full coverage or bulk update the mask. displayio_area_t transformed; displayio_area_transform_within(flip_x != (self->absolute_transform->dx < 0), flip_y != (self->absolute_transform->dy < 0), self->transpose_xy != self->absolute_transform->transpose_xy, - &overlap, - &self->current_area, - &transformed); + &overlap, + &self->current_area, + &transformed); int16_t start_x = (transformed.x1 - self->current_area.x1); int16_t end_x = (transformed.x2 - self->current_area.x1); @@ -443,7 +443,7 @@ bool displayio_tilegrid_fill_area(displayio_tilegrid_t *self, const _displayio_c input_pixel.tile_x = (input_pixel.tile % self->bitmap_width_in_tiles) * self->tile_width + local_x % self->tile_width; input_pixel.tile_y = (input_pixel.tile / self->bitmap_width_in_tiles) * self->tile_height + local_y % self->tile_height; - //uint32_t value = 0; + // uint32_t value = 0; output_pixel.pixel = 0; input_pixel.pixel = 0; @@ -471,9 +471,9 @@ bool displayio_tilegrid_fill_area(displayio_tilegrid_t *self, const _displayio_c } else { mask[offset / 32] |= 1 << (offset % 32); if (colorspace->depth == 16) { - *(((uint16_t*) buffer) + offset) = output_pixel.pixel; + *(((uint16_t *)buffer) + offset) = output_pixel.pixel; } else if (colorspace->depth == 8) { - *(((uint8_t*) buffer) + offset) = output_pixel.pixel; + *(((uint8_t *)buffer) + offset) = output_pixel.pixel; } else if (colorspace->depth < 8) { // Reorder the offsets to pack multiple rows into a byte (meaning they share a column). if (!colorspace->pixels_in_byte_share_row) { @@ -492,7 +492,7 @@ bool displayio_tilegrid_fill_area(displayio_tilegrid_t *self, const _displayio_c // Reverse the shift by subtracting it from the leftmost shift. shift = (pixels_per_byte - 1) * colorspace->depth - shift; } - ((uint8_t*)buffer)[offset / pixels_per_byte] |= output_pixel.pixel << shift; + ((uint8_t *)buffer)[offset / pixels_per_byte] |= output_pixel.pixel << shift; } } } @@ -529,7 +529,7 @@ void displayio_tilegrid_finish_refresh(displayio_tilegrid_t *self) { // That way they won't change during a refresh and tear. } -displayio_area_t* displayio_tilegrid_get_refresh_areas(displayio_tilegrid_t *self, displayio_area_t* tail) { +displayio_area_t *displayio_tilegrid_get_refresh_areas(displayio_tilegrid_t *self, displayio_area_t *tail) { bool first_draw = self->previous_area.x1 == self->previous_area.x2; bool hidden = self->hidden || self->hidden_by_parent; // Check hidden first because it trumps all other changes. @@ -553,7 +553,7 @@ displayio_area_t* displayio_tilegrid_get_refresh_areas(displayio_tilegrid_t *sel // If we have an in-memory bitmap, then check it for modifications. if (MP_OBJ_IS_TYPE(self->bitmap, &displayio_bitmap_type)) { - displayio_area_t* refresh_area = displayio_bitmap_get_refresh_areas(self->bitmap, tail); + displayio_area_t *refresh_area = displayio_bitmap_get_refresh_areas(self->bitmap, tail); if (refresh_area != tail) { // Special case a TileGrid that shows a full bitmap and use its // dirty area. Copy it to ours so we can transform it. @@ -565,7 +565,7 @@ displayio_area_t* displayio_tilegrid_get_refresh_areas(displayio_tilegrid_t *sel } } } else if (MP_OBJ_IS_TYPE(self->bitmap, &displayio_shape_type)) { - displayio_area_t* refresh_area = displayio_shape_get_refresh_areas(self->bitmap, tail); + displayio_area_t *refresh_area = displayio_shape_get_refresh_areas(self->bitmap, tail); if (refresh_area != tail) { displayio_area_copy(refresh_area, &self->dirty_area); self->partial_change = true; @@ -574,9 +574,9 @@ displayio_area_t* displayio_tilegrid_get_refresh_areas(displayio_tilegrid_t *sel self->full_change = self->full_change || (MP_OBJ_IS_TYPE(self->pixel_shader, &displayio_palette_type) && - displayio_palette_needs_refresh(self->pixel_shader)) || + displayio_palette_needs_refresh(self->pixel_shader)) || (MP_OBJ_IS_TYPE(self->pixel_shader, &displayio_colorconverter_type) && - displayio_colorconverter_needs_refresh(self->pixel_shader)); + displayio_colorconverter_needs_refresh(self->pixel_shader)); if (self->full_change || first_draw) { self->current_area.next = tail; return &self->current_area; diff --git a/shared-module/displayio/TileGrid.h b/shared-module/displayio/TileGrid.h index e97d3dfd4..b5aab5134 100644 --- a/shared-module/displayio/TileGrid.h +++ b/shared-module/displayio/TileGrid.h @@ -42,7 +42,8 @@ typedef struct { int16_t y; uint16_t pixel_width; uint16_t pixel_height; - uint16_t bitmap_width_in_tiles;; + uint16_t bitmap_width_in_tiles; + ; uint16_t tiles_in_bitmap; uint16_t width_in_tiles; uint16_t height_in_tiles; @@ -50,22 +51,22 @@ typedef struct { uint16_t tile_height; uint16_t top_left_x; uint16_t top_left_y; - uint8_t* tiles; - const displayio_buffer_transform_t* absolute_transform; + uint8_t *tiles; + const displayio_buffer_transform_t *absolute_transform; displayio_area_t dirty_area; // Stored as a relative area until the refresh area is fetched. displayio_area_t previous_area; // Stored as an absolute area. displayio_area_t current_area; // Stored as an absolute area so it applies across frames. - bool partial_change :1; - bool full_change :1; - bool moved :1; - bool inline_tiles :1; - bool in_group :1; - bool flip_x :1; - bool flip_y :1; - bool transpose_xy :1; - bool hidden :1; - bool hidden_by_parent :1; - uint8_t padding :6; + bool partial_change : 1; + bool full_change : 1; + bool moved : 1; + bool inline_tiles : 1; + bool in_group : 1; + bool flip_x : 1; + bool flip_y : 1; + bool transpose_xy : 1; + bool hidden : 1; + bool hidden_by_parent : 1; + uint8_t padding : 6; } displayio_tilegrid_t; void displayio_tilegrid_set_hidden_by_parent(displayio_tilegrid_t *self, bool hidden); @@ -73,16 +74,16 @@ void displayio_tilegrid_set_hidden_by_parent(displayio_tilegrid_t *self, bool hi // Updating the screen is a three stage process. // The first stage is used to determine i -displayio_area_t* displayio_tilegrid_get_refresh_areas(displayio_tilegrid_t *self, displayio_area_t* tail); +displayio_area_t *displayio_tilegrid_get_refresh_areas(displayio_tilegrid_t *self, displayio_area_t *tail); // Area is always in absolute screen coordinates. Update transform is used to inform TileGrids how // they relate to it. -bool displayio_tilegrid_fill_area(displayio_tilegrid_t *self, const _displayio_colorspace_t* colorspace, const displayio_area_t* area, uint32_t* mask, uint32_t *buffer); -void displayio_tilegrid_update_transform(displayio_tilegrid_t *group, const displayio_buffer_transform_t* parent_transform); +bool displayio_tilegrid_fill_area(displayio_tilegrid_t *self, const _displayio_colorspace_t *colorspace, const displayio_area_t *area, uint32_t *mask, uint32_t *buffer); +void displayio_tilegrid_update_transform(displayio_tilegrid_t *group, const displayio_buffer_transform_t *parent_transform); // Fills in area with the maximum bounds of all related pixels in the last rendered frame. Returns // false if the tilegrid wasn't rendered in the last frame. -bool displayio_tilegrid_get_previous_area(displayio_tilegrid_t *self, displayio_area_t* area); +bool displayio_tilegrid_get_previous_area(displayio_tilegrid_t *self, displayio_area_t *area); void displayio_tilegrid_finish_refresh(displayio_tilegrid_t *self); #endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_TILEGRID_H diff --git a/shared-module/displayio/__init__.c b/shared-module/displayio/__init__.c index 740af0570..3c9c2cc3a 100644 --- a/shared-module/displayio/__init__.c +++ b/shared-module/displayio/__init__.c @@ -44,7 +44,7 @@ displayio_buffer_transform_t null_transform = { STATIC bool any_display_uses_this_framebuffer(mp_obj_base_t *obj) { for (uint8_t i = 0; i < CIRCUITPY_DISPLAY_LIMIT; i++) { if (displays[i].display_base.type == &framebufferio_framebufferdisplay_type) { - framebufferio_framebufferdisplay_obj_t* display = &displays[i].framebuffer_display; + framebufferio_framebufferdisplay_obj_t *display = &displays[i].framebuffer_display; if (display->framebuffer == obj) { return true; } @@ -72,10 +72,10 @@ void displayio_background(void) { } if (displays[i].display.base.type == &displayio_display_type) { displayio_display_background(&displays[i].display); -#if CIRCUITPY_FRAMEBUFFERIO + #if CIRCUITPY_FRAMEBUFFERIO } else if (displays[i].framebuffer_display.base.type == &framebufferio_framebufferdisplay_type) { framebufferio_framebufferdisplay_background(&displays[i].framebuffer_display); -#endif + #endif } else if (displays[i].epaper_display.base.type == &displayio_epaperdisplay_type) { displayio_epaperdisplay_background(&displays[i].epaper_display); } @@ -94,10 +94,10 @@ void common_hal_displayio_release_displays(void) { release_display(&displays[i].display); } else if (display_type == &displayio_epaperdisplay_type) { release_epaperdisplay(&displays[i].epaper_display); -#if CIRCUITPY_FRAMEBUFFERIO + #if CIRCUITPY_FRAMEBUFFERIO } else if (display_type == &framebufferio_framebufferdisplay_type) { release_framebufferdisplay(&displays[i].framebuffer_display); -#endif + #endif } displays[i].display.base.type = &mp_type_NoneType; } @@ -111,14 +111,14 @@ void common_hal_displayio_release_displays(void) { common_hal_displayio_i2cdisplay_deinit(&displays[i].i2cdisplay_bus); } else if (bus_type == &displayio_parallelbus_type) { common_hal_displayio_parallelbus_deinit(&displays[i].parallel_bus); -#if CIRCUITPY_RGBMATRIX + #if CIRCUITPY_RGBMATRIX } else if (bus_type == &rgbmatrix_RGBMatrix_type) { common_hal_rgbmatrix_rgbmatrix_deinit(&displays[i].rgbmatrix); -#endif -#if CIRCUITPY_SHARPDISPLAY + #endif + #if CIRCUITPY_SHARPDISPLAY } else if (displays[i].bus_base.type == &sharpdisplay_framebuffer_type) { common_hal_sharpdisplay_framebuffer_deinit(&displays[i].sharpdisplay); -#endif + #endif } displays[i].fourwire_bus.base.type = &mp_type_NoneType; } @@ -130,68 +130,68 @@ void reset_displays(void) { // The SPI buses used by FourWires may be allocated on the heap so we need to move them inline. for (uint8_t i = 0; i < CIRCUITPY_DISPLAY_LIMIT; i++) { if (displays[i].fourwire_bus.base.type == &displayio_fourwire_type) { - displayio_fourwire_obj_t* fourwire = &displays[i].fourwire_bus; - if (((uint32_t) fourwire->bus) < ((uint32_t) &displays) || - ((uint32_t) fourwire->bus) > ((uint32_t) &displays + CIRCUITPY_DISPLAY_LIMIT)) { - busio_spi_obj_t* original_spi = fourwire->bus; + displayio_fourwire_obj_t *fourwire = &displays[i].fourwire_bus; + if (((uint32_t)fourwire->bus) < ((uint32_t)&displays) || + ((uint32_t)fourwire->bus) > ((uint32_t)&displays + CIRCUITPY_DISPLAY_LIMIT)) { + busio_spi_obj_t *original_spi = fourwire->bus; #if BOARD_SPI - // We don't need to move original_spi if it is the board.SPI object because it is - // statically allocated already. (Doing so would also make it impossible to reference in - // a subsequent VM run.) - if (original_spi == common_hal_board_get_spi()) { - continue; - } + // We don't need to move original_spi if it is the board.SPI object because it is + // statically allocated already. (Doing so would also make it impossible to reference in + // a subsequent VM run.) + if (original_spi == common_hal_board_get_spi()) { + continue; + } #endif #ifdef BOARD_USE_INTERNAL_SPI - if (original_spi == (mp_obj_t)(&supervisor_flash_spi_bus)) { - continue; - } + if (original_spi == (mp_obj_t)(&supervisor_flash_spi_bus)) { + continue; + } #endif memcpy(&fourwire->inline_bus, original_spi, sizeof(busio_spi_obj_t)); fourwire->bus = &fourwire->inline_bus; // Check for other displays that use the same spi bus and swap them too. for (uint8_t j = i + 1; j < CIRCUITPY_DISPLAY_LIMIT; j++) { if (displays[i].fourwire_bus.base.type == &displayio_fourwire_type && - displays[i].fourwire_bus.bus == original_spi) { + displays[i].fourwire_bus.bus == original_spi) { displays[i].fourwire_bus.bus = &fourwire->inline_bus; } } } } else if (displays[i].i2cdisplay_bus.base.type == &displayio_i2cdisplay_type) { - displayio_i2cdisplay_obj_t* i2c = &displays[i].i2cdisplay_bus; - if (((uint32_t) i2c->bus) < ((uint32_t) &displays) || - ((uint32_t) i2c->bus) > ((uint32_t) &displays + CIRCUITPY_DISPLAY_LIMIT)) { - busio_i2c_obj_t* original_i2c = i2c->bus; + displayio_i2cdisplay_obj_t *i2c = &displays[i].i2cdisplay_bus; + if (((uint32_t)i2c->bus) < ((uint32_t)&displays) || + ((uint32_t)i2c->bus) > ((uint32_t)&displays + CIRCUITPY_DISPLAY_LIMIT)) { + busio_i2c_obj_t *original_i2c = i2c->bus; #if BOARD_I2C - // We don't need to move original_i2c if it is the board.I2C object because it is - // statically allocated already. (Doing so would also make it impossible to reference in - // a subsequent VM run.) - if (original_i2c == common_hal_board_get_i2c()) { - continue; - } + // We don't need to move original_i2c if it is the board.I2C object because it is + // statically allocated already. (Doing so would also make it impossible to reference in + // a subsequent VM run.) + if (original_i2c == common_hal_board_get_i2c()) { + continue; + } #endif memcpy(&i2c->inline_bus, original_i2c, sizeof(busio_i2c_obj_t)); i2c->bus = &i2c->inline_bus; // Check for other displays that use the same i2c bus and swap them too. for (uint8_t j = i + 1; j < CIRCUITPY_DISPLAY_LIMIT; j++) { if (displays[i].i2cdisplay_bus.base.type == &displayio_i2cdisplay_type && - displays[i].i2cdisplay_bus.bus == original_i2c) { + displays[i].i2cdisplay_bus.bus == original_i2c) { displays[i].i2cdisplay_bus.bus = &i2c->inline_bus; } } } -#if CIRCUITPY_RGBMATRIX + #if CIRCUITPY_RGBMATRIX } else if (displays[i].rgbmatrix.base.type == &rgbmatrix_RGBMatrix_type) { - rgbmatrix_rgbmatrix_obj_t * pm = &displays[i].rgbmatrix; - if(!any_display_uses_this_framebuffer(&pm->base)) { + rgbmatrix_rgbmatrix_obj_t *pm = &displays[i].rgbmatrix; + if (!any_display_uses_this_framebuffer(&pm->base)) { common_hal_rgbmatrix_rgbmatrix_deinit(pm); } -#endif -#if CIRCUITPY_SHARPDISPLAY + #endif + #if CIRCUITPY_SHARPDISPLAY } else if (displays[i].bus_base.type == &sharpdisplay_framebuffer_type) { - sharpdisplay_framebuffer_obj_t * sharp = &displays[i].sharpdisplay; + sharpdisplay_framebuffer_obj_t *sharp = &displays[i].sharpdisplay; common_hal_sharpdisplay_framebuffer_reset(sharp); -#endif + #endif } else { // Not an active display bus. continue; @@ -204,28 +204,28 @@ void reset_displays(void) { if (displays[i].display.base.type == &displayio_display_type) { reset_display(&displays[i].display); } else if (displays[i].epaper_display.base.type == &displayio_epaperdisplay_type) { - displayio_epaperdisplay_obj_t* display = &displays[i].epaper_display; + displayio_epaperdisplay_obj_t *display = &displays[i].epaper_display; common_hal_displayio_epaperdisplay_show(display, NULL); -#if CIRCUITPY_FRAMEBUFFERIO + #if CIRCUITPY_FRAMEBUFFERIO } else if (displays[i].framebuffer_display.base.type == &framebufferio_framebufferdisplay_type) { framebufferio_framebufferdisplay_reset(&displays[i].framebuffer_display); -#endif + #endif } } } void displayio_gc_collect(void) { for (uint8_t i = 0; i < CIRCUITPY_DISPLAY_LIMIT; i++) { -#if CIRCUITPY_RGBMATRIX + #if CIRCUITPY_RGBMATRIX if (displays[i].rgbmatrix.base.type == &rgbmatrix_RGBMatrix_type) { rgbmatrix_rgbmatrix_collect_ptrs(&displays[i].rgbmatrix); } -#endif -#if CIRCUITPY_SHARPDISPLAY + #endif + #if CIRCUITPY_SHARPDISPLAY if (displays[i].bus_base.type == &sharpdisplay_framebuffer_type) { common_hal_sharpdisplay_framebuffer_collect_ptrs(&displays[i].sharpdisplay); } -#endif + #endif if (displays[i].display.base.type == NULL) { continue; @@ -235,17 +235,17 @@ void displayio_gc_collect(void) { // but this is more precise, and is the only field that needs marking. if (displays[i].display.base.type == &displayio_display_type) { displayio_display_collect_ptrs(&displays[i].display); -#if CIRCUITPY_FRAMEBUFFERIO + #if CIRCUITPY_FRAMEBUFFERIO } else if (displays[i].framebuffer_display.base.type == &framebufferio_framebufferdisplay_type) { framebufferio_framebufferdisplay_collect_ptrs(&displays[i].framebuffer_display); -#endif + #endif } else if (displays[i].epaper_display.base.type == &displayio_epaperdisplay_type) { displayio_epaperdisplay_collect_ptrs(&displays[i].epaper_display); } } } -void displayio_area_expand(displayio_area_t* original, const displayio_area_t* addition) { +void displayio_area_expand(displayio_area_t *original, const displayio_area_t *addition) { if (addition->x1 < original->x1) { original->x1 = addition->x1; } @@ -260,30 +260,30 @@ void displayio_area_expand(displayio_area_t* original, const displayio_area_t* a } } -void displayio_area_copy(const displayio_area_t* src, displayio_area_t* dst) { +void displayio_area_copy(const displayio_area_t *src, displayio_area_t *dst) { dst->x1 = src->x1; dst->y1 = src->y1; dst->x2 = src->x2; dst->y2 = src->y2; } -void displayio_area_scale(displayio_area_t* area, uint16_t scale) { +void displayio_area_scale(displayio_area_t *area, uint16_t scale) { area->x1 *= scale; area->y1 *= scale; area->x2 *= scale; area->y2 *= scale; } -void displayio_area_shift(displayio_area_t* area, int16_t dx, int16_t dy) { +void displayio_area_shift(displayio_area_t *area, int16_t dx, int16_t dy) { area->x1 += dx; area->y1 += dy; area->x2 += dx; area->y2 += dy; } -bool displayio_area_compute_overlap(const displayio_area_t* a, - const displayio_area_t* b, - displayio_area_t* overlap) { +bool displayio_area_compute_overlap(const displayio_area_t *a, + const displayio_area_t *b, + displayio_area_t *overlap) { overlap->x1 = a->x1; if (b->x1 > overlap->x1) { overlap->x1 = b->x1; @@ -309,9 +309,9 @@ bool displayio_area_compute_overlap(const displayio_area_t* a, return true; } -void displayio_area_union(const displayio_area_t* a, - const displayio_area_t* b, - displayio_area_t* u) { +void displayio_area_union(const displayio_area_t *a, + const displayio_area_t *b, + displayio_area_t *u) { u->x1 = a->x1; if (b->x1 < u->x1) { u->x1 = b->x1; @@ -331,19 +331,19 @@ void displayio_area_union(const displayio_area_t* a, } } -uint16_t displayio_area_width(const displayio_area_t* area) { +uint16_t displayio_area_width(const displayio_area_t *area) { return area->x2 - area->x1; } -uint16_t displayio_area_height(const displayio_area_t* area) { +uint16_t displayio_area_height(const displayio_area_t *area) { return area->y2 - area->y1; } -uint32_t displayio_area_size(const displayio_area_t* area) { +uint32_t displayio_area_size(const displayio_area_t *area) { return displayio_area_width(area) * displayio_area_height(area); } -bool displayio_area_equal(const displayio_area_t* a, const displayio_area_t* b) { +bool displayio_area_equal(const displayio_area_t *a, const displayio_area_t *b) { return a->x1 == b->x1 && a->y1 == b->y1 && a->x2 == b->x2 && @@ -352,9 +352,9 @@ bool displayio_area_equal(const displayio_area_t* a, const displayio_area_t* b) // Original and whole must be in the same coordinate space. void displayio_area_transform_within(bool mirror_x, bool mirror_y, bool transpose_xy, - const displayio_area_t* original, - const displayio_area_t* whole, - displayio_area_t* transformed) { + const displayio_area_t *original, + const displayio_area_t *whole, + displayio_area_t *transformed) { if (mirror_x) { transformed->x1 = whole->x1 + (whole->x2 - original->x2); transformed->x2 = whole->x2 - (original->x1 - whole->x1); diff --git a/shared-module/displayio/__init__.h b/shared-module/displayio/__init__.h index 44ad5a9a9..4a74b0e0e 100644 --- a/shared-module/displayio/__init__.h +++ b/shared-module/displayio/__init__.h @@ -49,20 +49,20 @@ typedef struct { displayio_fourwire_obj_t fourwire_bus; displayio_i2cdisplay_obj_t i2cdisplay_bus; displayio_parallelbus_obj_t parallel_bus; -#if CIRCUITPY_RGBMATRIX + #if CIRCUITPY_RGBMATRIX rgbmatrix_rgbmatrix_obj_t rgbmatrix; -#endif -#if CIRCUITPY_SHARPDISPLAY + #endif + #if CIRCUITPY_SHARPDISPLAY sharpdisplay_framebuffer_obj_t sharpdisplay; -#endif + #endif }; union { mp_obj_base_t display_base; displayio_display_obj_t display; displayio_epaperdisplay_obj_t epaper_display; -#if CIRCUITPY_FRAMEBUFFERIO + #if CIRCUITPY_FRAMEBUFFERIO framebufferio_framebufferdisplay_obj_t framebuffer_display; -#endif + #endif }; } primary_display_t; diff --git a/shared-module/displayio/area.h b/shared-module/displayio/area.h index 7ad36883c..21bf2f8b2 100644 --- a/shared-module/displayio/area.h +++ b/shared-module/displayio/area.h @@ -35,7 +35,7 @@ struct _displayio_area_t { int16_t y1; int16_t x2; // Second point is exclusive. int16_t y2; - const displayio_area_t* next; // Next area in the linked list. + const displayio_area_t *next; // Next area in the linked list. }; typedef struct { @@ -53,23 +53,23 @@ typedef struct { extern displayio_buffer_transform_t null_transform; -void displayio_area_union(const displayio_area_t* a, - const displayio_area_t* b, - displayio_area_t* u); -void displayio_area_expand(displayio_area_t* original, const displayio_area_t* addition); -void displayio_area_copy(const displayio_area_t* src, displayio_area_t* dst); -void displayio_area_scale(displayio_area_t* area, uint16_t scale); -void displayio_area_shift(displayio_area_t* area, int16_t dx, int16_t dy); -bool displayio_area_compute_overlap(const displayio_area_t* a, - const displayio_area_t* b, - displayio_area_t* overlap); -uint16_t displayio_area_width(const displayio_area_t* area); -uint16_t displayio_area_height(const displayio_area_t* area); -uint32_t displayio_area_size(const displayio_area_t* area); -bool displayio_area_equal(const displayio_area_t* a, const displayio_area_t* b); +void displayio_area_union(const displayio_area_t *a, + const displayio_area_t *b, + displayio_area_t *u); +void displayio_area_expand(displayio_area_t *original, const displayio_area_t *addition); +void displayio_area_copy(const displayio_area_t *src, displayio_area_t *dst); +void displayio_area_scale(displayio_area_t *area, uint16_t scale); +void displayio_area_shift(displayio_area_t *area, int16_t dx, int16_t dy); +bool displayio_area_compute_overlap(const displayio_area_t *a, + const displayio_area_t *b, + displayio_area_t *overlap); +uint16_t displayio_area_width(const displayio_area_t *area); +uint16_t displayio_area_height(const displayio_area_t *area); +uint32_t displayio_area_size(const displayio_area_t *area); +bool displayio_area_equal(const displayio_area_t *a, const displayio_area_t *b); void displayio_area_transform_within(bool mirror_x, bool mirror_y, bool transpose_xy, - const displayio_area_t* original, - const displayio_area_t* whole, - displayio_area_t* transformed); + const displayio_area_t *original, + const displayio_area_t *whole, + displayio_area_t *transformed); #endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_AREA_H diff --git a/shared-module/displayio/display_core.c b/shared-module/displayio/display_core.c index 57d33b565..a0b3afa0e 100644 --- a/shared-module/displayio/display_core.c +++ b/shared-module/displayio/display_core.c @@ -43,9 +43,9 @@ #define DISPLAYIO_CORE_DEBUG(...) (void)0 // #define DISPLAYIO_CORE_DEBUG(...) mp_printf(&mp_plat_print __VA_OPT__(,) __VA_ARGS__) -void displayio_display_core_construct(displayio_display_core_t* self, - mp_obj_t bus, uint16_t width, uint16_t height, uint16_t ram_width, uint16_t ram_height, int16_t colstart, int16_t rowstart, uint16_t rotation, - uint16_t color_depth, bool grayscale, bool pixels_in_byte_share_row, uint8_t bytes_per_cell, bool reverse_pixels_in_byte, bool reverse_bytes_in_word) { +void displayio_display_core_construct(displayio_display_core_t *self, + mp_obj_t bus, uint16_t width, uint16_t height, uint16_t ram_width, uint16_t ram_height, int16_t colstart, int16_t rowstart, uint16_t rotation, + uint16_t color_depth, bool grayscale, bool pixels_in_byte_share_row, uint8_t bytes_per_cell, bool reverse_pixels_in_byte, bool reverse_bytes_in_word) { self->colorspace.depth = color_depth; self->colorspace.grayscale = grayscale; self->colorspace.grayscale_bit = 8 - color_depth; @@ -99,8 +99,8 @@ void displayio_display_core_construct(displayio_display_core_t* self, displayio_display_core_set_rotation(self, rotation); } -void displayio_display_core_set_rotation( displayio_display_core_t* self, - int rotation) { +void displayio_display_core_set_rotation(displayio_display_core_t *self, + int rotation) { int height = self->height; int width = self->width; @@ -157,7 +157,7 @@ void displayio_display_core_set_rotation( displayio_display_core_t* self, } } -bool displayio_display_core_show(displayio_display_core_t* self, displayio_group_t* root_group) { +bool displayio_display_core_show(displayio_display_core_t *self, displayio_group_t *root_group) { if (root_group == NULL) { if (!circuitpython_splash.in_group) { root_group = &circuitpython_splash; @@ -184,19 +184,19 @@ bool displayio_display_core_show(displayio_display_core_t* self, displayio_group return true; } -uint16_t displayio_display_core_get_width(displayio_display_core_t* self){ +uint16_t displayio_display_core_get_width(displayio_display_core_t *self) { return self->width; } -uint16_t displayio_display_core_get_height(displayio_display_core_t* self){ +uint16_t displayio_display_core_get_height(displayio_display_core_t *self) { return self->height; } -void displayio_display_core_set_dither(displayio_display_core_t* self, bool dither){ +void displayio_display_core_set_dither(displayio_display_core_t *self, bool dither) { self->colorspace.dither = dither; } -bool displayio_display_core_get_dither(displayio_display_core_t* self){ +bool displayio_display_core_get_dither(displayio_display_core_t *self) { return self->colorspace.dither; } @@ -204,18 +204,18 @@ bool displayio_display_core_bus_free(displayio_display_core_t *self) { return !self->bus || self->bus_free(self->bus); } -bool displayio_display_core_begin_transaction(displayio_display_core_t* self) { +bool displayio_display_core_begin_transaction(displayio_display_core_t *self) { return self->begin_transaction(self->bus); } -void displayio_display_core_end_transaction(displayio_display_core_t* self) { +void displayio_display_core_end_transaction(displayio_display_core_t *self) { self->end_transaction(self->bus); } -void displayio_display_core_set_region_to_update(displayio_display_core_t* self, uint8_t column_command, - uint8_t row_command, uint16_t set_current_column_command, uint16_t set_current_row_command, - bool data_as_commands, bool always_toggle_chip_select, - displayio_area_t* area, bool SH1107_addressing) { +void displayio_display_core_set_region_to_update(displayio_display_core_t *self, uint8_t column_command, + uint8_t row_command, uint16_t set_current_column_command, uint16_t set_current_row_command, + bool data_as_commands, bool always_toggle_chip_select, + displayio_area_t *area, bool SH1107_addressing) { uint16_t x1 = area->x1; uint16_t x2 = area->x2; uint16_t y1 = area->y1; @@ -320,7 +320,7 @@ void displayio_display_core_set_region_to_update(displayio_display_core_t* self, } } -bool displayio_display_core_start_refresh(displayio_display_core_t* self) { +bool displayio_display_core_start_refresh(displayio_display_core_t *self) { if (!displayio_display_core_bus_free(self)) { // Can't acquire display bus; skip updating this display. Try next display. return false; @@ -333,7 +333,7 @@ bool displayio_display_core_start_refresh(displayio_display_core_t* self) { return true; } -void displayio_display_core_finish_refresh(displayio_display_core_t* self) { +void displayio_display_core_finish_refresh(displayio_display_core_t *self) { if (self->current_group != NULL) { DISPLAYIO_CORE_DEBUG("displayiocore group_finish_refresh\n"); displayio_group_finish_refresh(self->current_group); @@ -343,21 +343,21 @@ void displayio_display_core_finish_refresh(displayio_display_core_t* self) { self->last_refresh = supervisor_ticks_ms64(); } -void release_display_core(displayio_display_core_t* self) { +void release_display_core(displayio_display_core_t *self) { if (self->current_group != NULL) { self->current_group->in_group = false; } } -void displayio_display_core_collect_ptrs(displayio_display_core_t* self) { +void displayio_display_core_collect_ptrs(displayio_display_core_t *self) { gc_collect_ptr(self->current_group); } -bool displayio_display_core_fill_area(displayio_display_core_t *self, displayio_area_t* area, uint32_t* mask, uint32_t *buffer) { +bool displayio_display_core_fill_area(displayio_display_core_t *self, displayio_area_t *area, uint32_t *mask, uint32_t *buffer) { return displayio_group_fill_area(self->current_group, &self->colorspace, area, mask, buffer); } -bool displayio_display_core_clip_area(displayio_display_core_t *self, const displayio_area_t* area, displayio_area_t* clipped) { +bool displayio_display_core_clip_area(displayio_display_core_t *self, const displayio_area_t *area, displayio_area_t *clipped) { bool overlaps = displayio_area_compute_overlap(&self->area, area, clipped); if (!overlaps) { return false; diff --git a/shared-module/displayio/display_core.h b/shared-module/displayio/display_core.h index fe6cb6f3f..8c2ba21b5 100644 --- a/shared-module/displayio/display_core.h +++ b/shared-module/displayio/display_core.h @@ -57,38 +57,38 @@ typedef struct { bool refresh_in_progress; } displayio_display_core_t; -void displayio_display_core_construct(displayio_display_core_t* self, - mp_obj_t bus, uint16_t width, uint16_t height, uint16_t ram_width, uint16_t ram_height, int16_t colstart, int16_t rowstart, uint16_t rotation, - uint16_t color_depth, bool grayscale, bool pixels_in_byte_share_row, uint8_t bytes_per_cell, bool reverse_pixels_in_byte, bool reverse_bytes_in_word); +void displayio_display_core_construct(displayio_display_core_t *self, + mp_obj_t bus, uint16_t width, uint16_t height, uint16_t ram_width, uint16_t ram_height, int16_t colstart, int16_t rowstart, uint16_t rotation, + uint16_t color_depth, bool grayscale, bool pixels_in_byte_share_row, uint8_t bytes_per_cell, bool reverse_pixels_in_byte, bool reverse_bytes_in_word); -bool displayio_display_core_show(displayio_display_core_t* self, displayio_group_t* root_group); +bool displayio_display_core_show(displayio_display_core_t *self, displayio_group_t *root_group); -uint16_t displayio_display_core_get_width(displayio_display_core_t* self); -uint16_t displayio_display_core_get_height(displayio_display_core_t* self); +uint16_t displayio_display_core_get_width(displayio_display_core_t *self); +uint16_t displayio_display_core_get_height(displayio_display_core_t *self); -void displayio_display_core_set_dither(displayio_display_core_t* self, bool dither); -bool displayio_display_core_get_dither(displayio_display_core_t* self); +void displayio_display_core_set_dither(displayio_display_core_t *self, bool dither); +bool displayio_display_core_get_dither(displayio_display_core_t *self); -void displayio_display_core_set_rotation(displayio_display_core_t* self, int rotation); +void displayio_display_core_set_rotation(displayio_display_core_t *self, int rotation); bool displayio_display_core_bus_free(displayio_display_core_t *self); -bool displayio_display_core_begin_transaction(displayio_display_core_t* self); -void displayio_display_core_end_transaction(displayio_display_core_t* self); +bool displayio_display_core_begin_transaction(displayio_display_core_t *self); +void displayio_display_core_end_transaction(displayio_display_core_t *self); -void displayio_display_core_set_region_to_update(displayio_display_core_t* self, uint8_t column_command, - uint8_t row_command, uint16_t set_current_column_command, uint16_t set_current_row_command, - bool data_as_commands, bool always_toggle_chip_select, - displayio_area_t* area, bool SH1107_addressing); +void displayio_display_core_set_region_to_update(displayio_display_core_t *self, uint8_t column_command, + uint8_t row_command, uint16_t set_current_column_command, uint16_t set_current_row_command, + bool data_as_commands, bool always_toggle_chip_select, + displayio_area_t *area, bool SH1107_addressing); -void release_display_core(displayio_display_core_t* self); +void release_display_core(displayio_display_core_t *self); -bool displayio_display_core_start_refresh(displayio_display_core_t* self); -void displayio_display_core_finish_refresh(displayio_display_core_t* self); +bool displayio_display_core_start_refresh(displayio_display_core_t *self); +void displayio_display_core_finish_refresh(displayio_display_core_t *self); -void displayio_display_core_collect_ptrs(displayio_display_core_t* self); +void displayio_display_core_collect_ptrs(displayio_display_core_t *self); -bool displayio_display_core_fill_area(displayio_display_core_t *self, displayio_area_t* area, uint32_t* mask, uint32_t *buffer); +bool displayio_display_core_fill_area(displayio_display_core_t *self, displayio_area_t *area, uint32_t *mask, uint32_t *buffer); -bool displayio_display_core_clip_area(displayio_display_core_t *self, const displayio_area_t* area, displayio_area_t* clipped); +bool displayio_display_core_clip_area(displayio_display_core_t *self, const displayio_area_t *area, displayio_area_t *clipped); #endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_DISPLAY_CORE_H |