Import of the watch repository from Pebble

src/fw/applib/graphics/gdraw_command_image.c

@@ -0,0 +1,142 @@
+/*
+ * 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 "gdraw_command_image.h"
+#include "gdraw_command_private.h"
+
+#include "applib/applib_malloc.auto.h"
+#include "applib/applib_resource_private.h"
+#include "syscall/syscall.h"
+
+GDrawCommandImage *gdraw_command_image_create_with_resource(uint32_t resource_id) {
+  ResAppNum app_num = sys_get_current_resource_num();
+
+  return gdraw_command_image_create_with_resource_system(app_num, resource_id);
+}
+
+GDrawCommandImage *gdraw_command_image_create_with_resource_system(ResAppNum app_num,
+                                                                   uint32_t resource_id) {
+  uint32_t data_size;
+  if (!gdraw_command_resource_is_valid(app_num, resource_id, PDCI_SIGNATURE, &data_size)) {
+    return NULL;
+  }
+
+  GDrawCommandImage *draw_command_image = applib_resource_mmap_or_load(app_num, resource_id,
+                                                                       PDCI_DATA_OFFSET, data_size,
+                                                                       false);
+
+  // Validate the loaded command image
+  if (!gdraw_command_image_validate(draw_command_image, data_size)) {
+    gdraw_command_image_destroy(draw_command_image);
+    return NULL;
+  }
+
+  return draw_command_image;
+}
+
+bool gdraw_command_image_copy(void *buffer, size_t buffer_length, GDrawCommandImage *src) {
+  size_t src_size = gdraw_command_image_get_data_size(src);
+  if (buffer_length < src_size) {
+    return false;
+  }
+
+  memcpy(buffer, src, src_size);
+  return true;
+}
+
+GDrawCommandImage *gdraw_command_image_clone(GDrawCommandImage *image) {
+  if (!image) {
+    return NULL;
+  }
+
+  // potentially extracting into a generic task_ptrdup(void *, size_t)
+  size_t size = gdraw_command_image_get_data_size(image);
+  GDrawCommandImage *result = applib_malloc(size);
+  if (result) {
+    memcpy(result, image, size);
+  }
+
+  return result;
+}
+
+void gdraw_command_image_destroy(GDrawCommandImage *image) {
+  applib_resource_munmap_or_free(image);
+}
+
+bool gdraw_command_image_validate(GDrawCommandImage *image, size_t size) {
+  if (!image ||
+      (size < sizeof(GDrawCommandImage)) ||
+      (image->version > GDRAW_COMMAND_VERSION) ||
+      !gdraw_command_list_validate(&image->command_list, size - (sizeof(GDrawCommandImage) -
+          sizeof(GDrawCommandList)))) {
+    return false;
+  }
+  uint8_t *end = (uint8_t *)image + size;
+
+  return (end == gdraw_command_list_iterate_private(&image->command_list, NULL, NULL));
+}
+
+void gdraw_command_image_draw(GContext *ctx, GDrawCommandImage *image, GPoint offset) {
+  gdraw_command_image_draw_processed(ctx, image, offset, NULL);
+}
+
+void gdraw_command_image_draw_processed(GContext *ctx, GDrawCommandImage *image, GPoint offset,
+                                        GDrawCommandProcessor *processor) {
+  if (!ctx || !image) {
+    return;
+  }
+
+  // Offset graphics context drawing box origin by specified amount
+  graphics_context_move_draw_box(ctx, offset);
+
+  gdraw_command_list_draw_processed(ctx, &image->command_list, processor);
+
+  // Offset graphics context drawing box back to previous origin
+  graphics_context_move_draw_box(ctx, GPoint(-offset.x, -offset.y));
+}
+
+size_t gdraw_command_image_get_data_size(GDrawCommandImage *image) {
+  if (!image) {
+    return 0;
+  }
+
+  return sizeof(GDrawCommandImage) - sizeof(GDrawCommandList)
+      + gdraw_command_list_get_data_size(&image->command_list);
+}
+
+GSize gdraw_command_image_get_bounds_size(GDrawCommandImage *image) {
+  if (!image) {
+    return GSizeZero;
+  }
+
+  return image->size;
+}
+
+void gdraw_command_image_set_bounds_size(GDrawCommandImage *image, GSize size) {
+  if (!image) {
+    return;
+  }
+
+  image->size = size;
+}
+
+GDrawCommandList *gdraw_command_image_get_command_list(GDrawCommandImage *image) {
+  if (!image) {
+    return NULL;
+  }
+
+  return &image->command_list;
+}