mirror of
https://github.com/google/pebble.git
synced 2025-05-02 00:01:41 -04:00
113 lines
3.9 KiB
C
113 lines
3.9 KiB
C
/*
|
|
* Copyright 2024 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include "inverter_layer.h"
|
|
|
|
#include "applib/graphics/graphics.h"
|
|
#include "applib/applib_malloc.auto.h"
|
|
#include "system/passert.h"
|
|
|
|
#include <string.h>
|
|
|
|
inline static void prv_inverter_layer_update_proc_color(GContext *ctx) {
|
|
// ctx->draw_state.drawing_box is the correct rect when this function gets
|
|
// called through layer_render_tree(),
|
|
GRect rect = ctx->draw_state.drawing_box;
|
|
// invert bytes in rect
|
|
grect_clip(&rect, &ctx->dest_bitmap.bounds); // clip to display bounds
|
|
for (int16_t y = rect.origin.y; y < rect.origin.y + rect.size.h; y++) {
|
|
int16_t row_offset = y * ctx->dest_bitmap.row_size_bytes;
|
|
for (int16_t x = rect.origin.x; x < rect.origin.x + rect.size.w; x++) {
|
|
uint8_t *pixel_addr = &(((uint8_t*)ctx->dest_bitmap.addr)[row_offset + x]);
|
|
// Only invert the RGB and not the alpha
|
|
*pixel_addr = (~(*pixel_addr) & 0b00111111) | (*pixel_addr & 0b11000000);
|
|
}
|
|
}
|
|
|
|
graphics_context_mark_dirty_rect(ctx, ctx->draw_state.drawing_box);
|
|
}
|
|
|
|
inline static void prv_inverter_layer_update_proc_bw(GContext *ctx) {
|
|
// For 1Bit, just revert to the 2.x code.
|
|
GBitmap sub_bitmap;
|
|
GBitmap* context_bitmap = graphics_context_get_bitmap(ctx);
|
|
// ctx->draw_state.drawing_box is the correct rect when this function gets called through
|
|
// layer_render_tree(), although it might be nicer to have a function to map a rect to another
|
|
// coordinate system...
|
|
gbitmap_init_as_sub_bitmap(&sub_bitmap, context_bitmap, ctx->draw_state.drawing_box);
|
|
|
|
// The sub-bitmap might have different bounds than this layer:
|
|
// when the requested bounds lie outside of the original bitmap it will be clipped.
|
|
// The following work-around will make sure the sub-bitmap gets painted at
|
|
// exactly the same spot as it came from:
|
|
GRect rect = sub_bitmap.bounds;
|
|
rect.origin.x -= ctx->draw_state.drawing_box.origin.x;
|
|
rect.origin.y -= ctx->draw_state.drawing_box.origin.y;
|
|
graphics_context_set_compositing_mode(ctx, GCompOpAssignInverted);
|
|
graphics_draw_bitmap_in_rect(ctx, &sub_bitmap, &rect);
|
|
}
|
|
|
|
void inverter_layer_update_proc(InverterLayer *inverter, GContext* ctx) {
|
|
#if SCREEN_COLOR_DEPTH_BITS == 1
|
|
prv_inverter_layer_update_proc_bw(ctx);
|
|
#else
|
|
prv_inverter_layer_update_proc_color(ctx);
|
|
#endif
|
|
(void)inverter;
|
|
}
|
|
|
|
void inverter_layer_init(InverterLayer *inverter, const GRect *frame) {
|
|
if (inverter == NULL) {
|
|
return;
|
|
}
|
|
*inverter = (InverterLayer){};
|
|
inverter->layer.frame = *frame;
|
|
inverter->layer.bounds = (GRect){{0, 0}, frame->size};
|
|
inverter->layer.update_proc = (LayerUpdateProc)inverter_layer_update_proc;
|
|
layer_set_clips(&inverter->layer, true);
|
|
layer_mark_dirty(&(inverter->layer));
|
|
}
|
|
|
|
InverterLayer* inverter_layer_create(GRect frame) {
|
|
InverterLayer* layer = applib_type_malloc(InverterLayer);
|
|
if (layer) {
|
|
inverter_layer_init(layer, &frame);
|
|
}
|
|
return layer;
|
|
}
|
|
|
|
void inverter_layer_deinit(InverterLayer *inverter_layer) {
|
|
if (inverter_layer == NULL) {
|
|
return;
|
|
}
|
|
layer_deinit(&inverter_layer->layer);
|
|
}
|
|
|
|
void inverter_layer_destroy(InverterLayer *inverter_layer) {
|
|
if (inverter_layer == NULL) {
|
|
return;
|
|
}
|
|
inverter_layer_deinit(inverter_layer);
|
|
applib_free(inverter_layer);
|
|
}
|
|
|
|
Layer* inverter_layer_get_layer(InverterLayer *inverter_layer) {
|
|
if (inverter_layer == NULL) {
|
|
return NULL;
|
|
}
|
|
return &inverter_layer->layer;
|
|
}
|
|
|