fw: black notification banner with inverted icon on bw

Signed-off-by: Joshua Jun <[email protected]>

Author: jplexer

src/fw/applib/applib_malloc.json

@@ -229,7 +229,7 @@
         "_comment": "Generously padded because it's not feature complete yet (only 3.x)"
     }, {
         "name": "KinoLayer",
-        "size_3x_padding": 40,
+        "size_3x_padding": 36,
         "size_3x": 164,
         "dependencies": ["Layer", "KinoPlayer"],
         "_comment": "Generously padded because it's not feature complete yet (only 3.x)"
@@ -241,7 +241,7 @@
         "_comment": "Generously padded because it's not feature complete yet (only 3.x)"
     }, {
         "name": "ExpandableDialog",
-        "size_3x_padding": 48,
+        "size_3x_padding": 44,
         "size_3x": 1280,
         "dependencies": ["Dialog", "TextLayer", "ScrollLayer", "ActionBarLayer", "Layer"],
         "_comment": "Generously padded because it's not feature complete yet (only 3.x)"
@@ -253,7 +253,7 @@
         "_comment": "Generously padded because it's not feature complete yet (only 3.x)"
     }, {
         "name": "VoiceWindow",
-        "size_3x_padding": 40,
+        "size_3x_padding": 36,
         "size_3x": 2368,
         "dependencies": ["TranscriptionDialog", "Layer", "Layer", "StatusBarLayer", "TextLayer", 
                          "KinoLayer", "Window", "EventServiceInfo"],

src/fw/applib/ui/kino/kino_layer.c

@@ -16,9 +16,37 @@
 
 #include "kino_layer.h"
 
+#include <stdint.h>  // For uintptr_t
+
 #include "applib/applib_malloc.auto.h"
 #include "applib/graphics/graphics.h"
 
+static GColor prv_invert_bw_color(GColor color) {
+  if (gcolor_equal(color, GColorBlack)) {
+    return GColorWhite;
+  } else if (gcolor_equal(color, GColorWhite)) {
+    return GColorBlack;
+  }
+  return color;
+}
+
+static void prv_invert_pdc_colors(GDrawCommandProcessor *processor, GDrawCommand *processed_command,
+                                  size_t processed_command_max_size, const GDrawCommandList *list,
+                                  const GDrawCommand *command) {
+  gdraw_command_set_stroke_color(
+      processed_command,
+      prv_invert_bw_color(gdraw_command_get_stroke_color((GDrawCommand *)command)));
+  gdraw_command_set_fill_color(
+      processed_command,
+      prv_invert_bw_color(gdraw_command_get_fill_color((GDrawCommand *)command)));
+}
+
+GDrawCommandProcessor prv_gdraw_inv_processor = {
+  .command = prv_invert_pdc_colors,
+};
+
+KinoReelProcessor PRV_INVERT_COLORS_PROCESSOR = {.draw_command_processor = &prv_gdraw_inv_processor};
+
 static void prv_update_proc(Layer *layer, GContext *ctx) {
   KinoLayer *kino_layer = (KinoLayer *)layer;
 
@@ -35,7 +63,9 @@ static void prv_update_proc(Layer *layer, GContext *ctx) {
   }
 
   const GRect reel_bounds = kino_layer_get_reel_bounds(kino_layer);
-  kino_player_draw(&kino_layer->player, ctx, reel_bounds.origin);
+
+  KinoReelProcessor processor = kino_layer->invert_colors ? PRV_INVERT_COLORS_PROCESSOR : (KinoReelProcessor){};
+  kino_player_draw_processed(&kino_layer->player, ctx, reel_bounds.origin, &processor);
 }
 
 //////////////////////
@@ -66,10 +96,12 @@ void kino_layer_init(KinoLayer *kino_layer, const GRect *frame) {
   // init kino layer
   kino_layer->background_color = GColorClear;
   // init kino player
-  kino_player_set_callbacks(&kino_layer->player, (KinoPlayerCallbacks){
-    .frame_did_change = prv_player_frame_did_change,
-    .did_stop = prv_player_did_stop,
-  }, kino_layer);
+  kino_player_set_callbacks(&kino_layer->player,
+                            (KinoPlayerCallbacks){
+                                .frame_did_change = prv_player_frame_did_change,
+                                .did_stop = prv_player_did_stop,
+                            },
+                            kino_layer);
 }
 
 void kino_layer_deinit(KinoLayer *kino_layer) {
@@ -107,22 +139,26 @@ void kino_layer_set_reel(KinoLayer *kino_layer, KinoReel *reel, bool take_owners
   kino_player_set_reel(&kino_layer->player, reel, take_ownership);
 }
 
+void kino_layer_set_invert_colors(KinoLayer *kino_layer, bool invert) {
+  // Store the invert flag in the LSB of the context pointer
+  kino_layer->invert_colors = invert;
+}
+
 void kino_layer_set_reel_with_resource(KinoLayer *kino_layer, uint32_t resource_id) {
   kino_player_set_reel_with_resource(&kino_layer->player, resource_id);
 }
 
 void kino_layer_set_reel_with_resource_system(KinoLayer *kino_layer, ResAppNum app_num,
-                                              uint32_t resource_id) {
+                                              uint32_t resource_id, bool invert) {
+  kino_layer_set_invert_colors(kino_layer, invert);
   kino_player_set_reel_with_resource_system(&kino_layer->player, app_num, resource_id);
 }
 
 KinoReel *kino_layer_get_reel(KinoLayer *kino_layer) {
   return kino_player_get_reel(&kino_layer->player);
 }
 
-KinoPlayer *kino_layer_get_player(KinoLayer *kino_layer) {
-  return &kino_layer->player;
-}
+KinoPlayer *kino_layer_get_player(KinoLayer *kino_layer) { return &kino_layer->player; }
 
 void kino_layer_set_alignment(KinoLayer *kino_layer, GAlign alignment) {
   kino_layer->alignment = alignment;
@@ -134,9 +170,7 @@ void kino_layer_set_background_color(KinoLayer *kino_layer, GColor color) {
   layer_mark_dirty(&kino_layer->layer);
 }
 
-void kino_layer_play(KinoLayer *kino_layer) {
-  kino_player_play(&kino_layer->player);
-}
+void kino_layer_play(KinoLayer *kino_layer) { kino_player_play(&kino_layer->player); }
 
 void kino_layer_play_section(KinoLayer *kino_layer, uint32_t from_position, uint32_t to_position) {
   kino_player_play_section(&kino_layer->player, from_position, to_position);
@@ -146,27 +180,21 @@ ImmutableAnimation *kino_layer_create_play_animation(KinoLayer *kino_layer) {
   return kino_player_create_play_animation(&kino_layer->player);
 }
 
-ImmutableAnimation *kino_layer_create_play_section_animation(
-    KinoLayer *kino_layer, uint32_t from_position, uint32_t to_position) {
-  return kino_player_create_play_section_animation(&kino_layer->player, from_position,
-                                                   to_position);
+ImmutableAnimation *kino_layer_create_play_section_animation(KinoLayer *kino_layer,
+                                                             uint32_t from_position,
+                                                             uint32_t to_position) {
+  return kino_player_create_play_section_animation(&kino_layer->player, from_position, to_position);
 }
 
-void kino_layer_pause(KinoLayer *kino_layer) {
-  kino_player_pause(&kino_layer->player);
-}
+void kino_layer_pause(KinoLayer *kino_layer) { kino_player_pause(&kino_layer->player); }
 
-void kino_layer_rewind(KinoLayer *kino_layer) {
-  kino_player_rewind(&kino_layer->player);
-}
+void kino_layer_rewind(KinoLayer *kino_layer) { kino_player_rewind(&kino_layer->player); }
 
 GColor kino_layer_get_background_color(KinoLayer *kino_layer) {
   return kino_layer->background_color;
 }
 
-GAlign kino_layer_get_alignment(KinoLayer *kino_layer) {
-  return kino_layer->alignment;
-}
+GAlign kino_layer_get_alignment(KinoLayer *kino_layer) { return kino_layer->alignment; }
 
 GRect kino_layer_get_reel_bounds(KinoLayer *kino_layer) {
   KinoPlayer *player = kino_layer_get_player(kino_layer);

src/fw/applib/ui/kino/kino_layer.h

@@ -16,10 +16,9 @@
 
 #pragma once
 
-#include "kino_reel.h"
-#include "kino_player.h"
-
 #include "applib/ui/layer.h"
+#include "kino_player.h"
+#include "kino_reel.h"
 
 struct KinoLayer;
 typedef struct KinoLayer KinoLayer;
@@ -37,6 +36,7 @@ struct KinoLayer {
   GAlign alignment;
   KinoLayerCallbacks callbacks;
   void *context;
+  bool invert_colors;
 };
 
 void kino_layer_init(KinoLayer *kino_layer, const GRect *frame);
@@ -50,11 +50,12 @@ void kino_layer_destroy(KinoLayer *kino_layer);
 Layer *kino_layer_get_layer(KinoLayer *kino_layer);
 
 void kino_layer_set_reel(KinoLayer *kino_layer, KinoReel *reel, bool take_ownership);
+void kino_layer_set_invert_colors(KinoLayer *kino_layer, bool invert);
 
 //! @internal
 void kino_layer_set_reel_with_resource(KinoLayer *kino_layer, uint32_t resource_id);
 void kino_layer_set_reel_with_resource_system(KinoLayer *kino_layer, ResAppNum app_num,
-                                              uint32_t resource_id);
+                                              uint32_t resource_id, bool invert);
 
 KinoReel *kino_layer_get_reel(KinoLayer *kino_layer);
 
@@ -74,8 +75,9 @@ void kino_layer_play_section(KinoLayer *kino_layer, uint32_t from_position, uint
 
 ImmutableAnimation *kino_layer_create_play_animation(KinoLayer *kino_layer);
 
-ImmutableAnimation *kino_layer_create_play_section_animation(
-    KinoLayer *kino_layer, uint32_t from_position, uint32_t to_position);
+ImmutableAnimation *kino_layer_create_play_section_animation(KinoLayer *kino_layer,
+                                                             uint32_t from_position,
+                                                             uint32_t to_position);
 
 void kino_layer_pause(KinoLayer *kino_layer);
 

src/fw/applib/ui/kino/kino_player.c

@@ -50,7 +50,7 @@ T_STATIC void prv_play_animation_update(Animation *animation, const AnimationPro
   bool is_reel_infinite = (kino_reel_duration == PLAY_DURATION_INFINITE);
   bool is_animation_reversed = animation_get_reverse(animation);
   bool is_animation_infinite =
-    (animation_get_duration(animation, false, false) == PLAY_DURATION_INFINITE);
+      (animation_get_duration(animation, false, false) == PLAY_DURATION_INFINITE);
 
   if (!is_animation_infinite && !is_reel_infinite) {
     // If neither animation nor reel is infinite
@@ -81,11 +81,11 @@ static void prv_play_anim_stopped(Animation *anim, bool finished, void *context)
 }
 
 static const AnimationImplementation s_play_animation_impl = {
-  .update = prv_play_animation_update,
+    .update = prv_play_animation_update,
 };
 
 static const AnimationHandlers s_play_anim_handlers = {
-  .stopped = prv_play_anim_stopped,
+    .stopped = prv_play_anim_stopped,
 };
 
 //////////////////////////////////
@@ -129,9 +129,7 @@ void kino_player_set_reel_with_resource_system(KinoPlayer *player, ResAppNum app
   kino_player_set_reel(player, new_reel, true);
 }
 
-KinoReel *kino_player_get_reel(KinoPlayer *player) {
-  return player->reel;
-}
+KinoReel *kino_player_get_reel(KinoPlayer *player) { return player->reel; }
 
 static void prv_create_play_animation(KinoPlayer *player, uint32_t from_value, uint32_t to_value) {
   // stop any ongoing animation
@@ -180,8 +178,9 @@ ImmutableAnimation *kino_player_create_play_animation(KinoPlayer *player) {
   return NULL;
 }
 
-ImmutableAnimation *kino_player_create_play_section_animation(
-    KinoPlayer *player, uint32_t from_elapsed_ms, uint32_t to_elapsed_ms) {
+ImmutableAnimation *kino_player_create_play_section_animation(KinoPlayer *player,
+                                                              uint32_t from_elapsed_ms,
+                                                              uint32_t to_elapsed_ms) {
   if (player && player->reel) {
     prv_create_play_animation(player, from_elapsed_ms, to_elapsed_ms);
     return (ImmutableAnimation *)player->animation;
@@ -207,12 +206,17 @@ void kino_player_rewind(KinoPlayer *player) {
 }
 
 void kino_player_draw(KinoPlayer *player, GContext *ctx, GPoint offset) {
+  kino_player_draw_processed(player, ctx, offset, NULL);
+}
+
+void kino_player_draw_processed(KinoPlayer *player, GContext *ctx, GPoint offset,
+                                KinoReelProcessor *processor) {
   if (player && player->reel) {
-    kino_reel_draw(player->reel, ctx, offset);
+    kino_reel_draw_processed(player->reel, ctx, offset, processor);
   }
 }
 
 void kino_player_deinit(KinoPlayer *player) {
-  player->callbacks = (KinoPlayerCallbacks) { 0 };
+  player->callbacks = (KinoPlayerCallbacks){0};
   kino_player_set_reel(player, NULL, false);
 }

src/fw/applib/ui/kino/kino_player.h

@@ -16,9 +16,8 @@
 
 #pragma once
 
-#include "kino_reel.h"
-
 #include "applib/ui/animation.h"
+#include "kino_reel.h"
 
 struct KinoPlayer;
 typedef struct KinoPlayer KinoPlayer;
@@ -67,8 +66,9 @@ void kino_player_play_section(KinoPlayer *player, uint32_t from_elapsed_ms, uint
 //! @return a pointer to a ImmutableAnimation object that plays the KinoPlayer when scheduled
 ImmutableAnimation *kino_player_create_play_animation(KinoPlayer *player);
 
-ImmutableAnimation *kino_player_create_play_section_animation(
-    KinoPlayer *player, uint32_t from_elapsed_ms, uint32_t to_elapsed_ms);
+ImmutableAnimation *kino_player_create_play_section_animation(KinoPlayer *player,
+                                                              uint32_t from_elapsed_ms,
+                                                              uint32_t to_elapsed_ms);
 
 void kino_player_pause(KinoPlayer *player);
 
@@ -77,3 +77,6 @@ void kino_player_rewind(KinoPlayer *player);
 void kino_player_deinit(KinoPlayer *player);
 
 void kino_player_draw(KinoPlayer *player, GContext *ctx, GPoint offset);
+
+void kino_player_draw_processed(KinoPlayer *player, GContext *ctx, GPoint offset,
+                                KinoReelProcessor *processor);