feat(draw): add convenience methods for safely getting correct draw descriptor (#5505)

23 files changed, 176 insertions, 71 deletions

diff --git a/demos/benchmark/lv_demo_benchmark.c b/demos/benchmark/lv_demo_benchmark.c
index 5d0fc4b10..1a9ed2bd7 100644
--- a/demos/benchmark/lv_demo_benchmark.c
+++ b/demos/benchmark/lv_demo_benchmark.c
@@ -517,24 +517,24 @@ static void table_draw_task_event_cb(lv_event_t * e)
 
     int32_t row = draw_dsc_base->id1;
     if(row == 0) {
-        if(t->type == LV_DRAW_TASK_TYPE_FILL) {
-            lv_draw_fill_dsc_t * draw_dsc_fill = t->draw_dsc;
+        lv_draw_fill_dsc_t * draw_dsc_fill = lv_draw_task_get_fill_dsc(t);
+        if(draw_dsc_fill) {
             draw_dsc_fill->color = lv_palette_darken(LV_PALETTE_BLUE_GREY, 4);
         }
-        else if(t->type == LV_DRAW_TASK_TYPE_LABEL) {
-            lv_draw_label_dsc_t * draw_dsc_label = t->draw_dsc;
+        lv_draw_label_dsc_t * draw_dsc_label = lv_draw_task_get_label_dsc(t);
+        if(draw_dsc_label) {
             draw_dsc_label->color = lv_color_white();
         }
     }
     else if(row == 1) {
-        if(t->type == LV_DRAW_TASK_TYPE_BORDER) {
-            lv_draw_border_dsc_t * draw_dsc_border = t->draw_dsc;
+        lv_draw_border_dsc_t * draw_dsc_border = lv_draw_task_get_border_dsc(t);
+        if(draw_dsc_border) {
             draw_dsc_border->color = lv_palette_darken(LV_PALETTE_BLUE_GREY, 4);
             draw_dsc_border->width = 2;
             draw_dsc_border->side = LV_BORDER_SIDE_BOTTOM;
         }
-        else if(t->type == LV_DRAW_TASK_TYPE_LABEL) {
-            lv_draw_label_dsc_t * draw_dsc_label = t->draw_dsc;
+        lv_draw_label_dsc_t * draw_dsc_label = lv_draw_task_get_label_dsc(t);
+        if(draw_dsc_label) {
             draw_dsc_label->color = lv_palette_darken(LV_PALETTE_BLUE_GREY, 4);
         }
     }
diff --git a/demos/widgets/lv_demo_widgets.c b/demos/widgets/lv_demo_widgets.c
index 01803eac6..c8633a845 100644
--- a/demos/widgets/lv_demo_widgets.c
+++ b/demos/widgets/lv_demo_widgets.c
@@ -1412,13 +1412,12 @@ static void chart_event_cb(lv_event_t * e)
         lv_draw_task_t * draw_task = lv_event_get_param(e);
         lv_draw_dsc_base_t * base_dsc = draw_task->draw_dsc;
 
-        if(base_dsc->part == LV_PART_ITEMS && draw_task->type == LV_DRAW_TASK_TYPE_LINE) {
+        lv_draw_line_dsc_t * draw_line_dsc = lv_draw_task_get_line_dsc(draw_task);
+        if(base_dsc->part == LV_PART_ITEMS && draw_line_dsc) {
             const lv_chart_series_t * ser = lv_chart_get_series_next(obj, NULL);
             if(base_dsc->id1 == 1) ser = lv_chart_get_series_next(obj, ser);
 
-            lv_draw_line_dsc_t * draw_line_dsc = draw_task->draw_dsc;
             lv_draw_triangle_dsc_t tri_dsc;
-
             lv_draw_triangle_dsc_init(&tri_dsc);
             tri_dsc.p[0].x = (int32_t)draw_line_dsc->p1.x;
             tri_dsc.p[0].y = (int32_t)draw_line_dsc->p1.y;
diff --git a/examples/widgets/buttonmatrix/lv_example_buttonmatrix_2.c b/examples/widgets/buttonmatrix/lv_example_buttonmatrix_2.c
index 97a340e38..f355e37d5 100644
--- a/examples/widgets/buttonmatrix/lv_example_buttonmatrix_2.c
+++ b/examples/widgets/buttonmatrix/lv_example_buttonmatrix_2.c
@@ -15,33 +15,36 @@ static void event_cb(lv_event_t * e)
 
         /*Change the draw descriptor of the 2nd button*/
         if(base_dsc->id1 == 1) {
-            if(draw_task->type == LV_DRAW_TASK_TYPE_FILL) {
-                lv_draw_rect_dsc_t * rect_draw_dsc = draw_task->draw_dsc;
-                rect_draw_dsc->radius = 0;
-                if(pressed) rect_draw_dsc->bg_color = lv_palette_darken(LV_PALETTE_BLUE, 3);
-                else rect_draw_dsc->bg_color = lv_palette_main(LV_PALETTE_BLUE);
-                rect_draw_dsc->shadow_width = 6;
-                rect_draw_dsc->shadow_offset_x = 3;
-                rect_draw_dsc->shadow_offset_y = 3;
+            lv_draw_fill_dsc_t * fill_draw_dsc = lv_draw_task_get_fill_dsc(draw_task);
+            if(fill_draw_dsc) {
+                fill_draw_dsc->radius = 0;
+                if(pressed) fill_draw_dsc->color = lv_palette_darken(LV_PALETTE_BLUE, 3);
+                else fill_draw_dsc->color = lv_palette_main(LV_PALETTE_BLUE);
+            }
+            lv_draw_box_shadow_dsc_t * box_shadow_draw_dsc = lv_draw_task_get_box_shadow_dsc(draw_task);
+            if(box_shadow_draw_dsc) {
+                box_shadow_draw_dsc->width = 6;
+                box_shadow_draw_dsc->ofs_x = 3;
+                box_shadow_draw_dsc->ofs_y = 3;
             }
-            if(draw_task->type == LV_DRAW_TASK_TYPE_LABEL) {
-                lv_draw_label_dsc_t * label_draw_dsc = draw_task->draw_dsc;
+            lv_draw_label_dsc_t * label_draw_dsc = lv_draw_task_get_label_dsc(draw_task);
+            if(label_draw_dsc) {
                 label_draw_dsc->color = lv_color_white();
             }
 
         }
         /*Change the draw descriptor of the 3rd button*/
         else if(base_dsc->id1 == 2) {
-            if(draw_task->type == LV_DRAW_TASK_TYPE_FILL) {
-                lv_draw_rect_dsc_t * rect_draw_dsc = draw_task->draw_dsc;
-                rect_draw_dsc->radius = LV_RADIUS_CIRCLE;
-                if(pressed) rect_draw_dsc->bg_color = lv_palette_darken(LV_PALETTE_RED, 3);
-                else rect_draw_dsc->bg_color = lv_palette_main(LV_PALETTE_RED);
+            lv_draw_fill_dsc_t * fill_draw_dsc = lv_draw_task_get_fill_dsc(draw_task);
+            if(fill_draw_dsc) {
+                fill_draw_dsc->radius = LV_RADIUS_CIRCLE;
+                if(pressed) fill_draw_dsc->color = lv_palette_darken(LV_PALETTE_RED, 3);
+                else fill_draw_dsc->color = lv_palette_main(LV_PALETTE_RED);
             }
         }
         else if(base_dsc->id1 == 3) {
-            if(draw_task->type == LV_DRAW_TASK_TYPE_LABEL) {
-                lv_draw_label_dsc_t * label_draw_dsc = draw_task->draw_dsc;
+            lv_draw_label_dsc_t * label_draw_dsc = lv_draw_task_get_label_dsc(draw_task);
+            if(label_draw_dsc) {
                 label_draw_dsc->opa = 0;
             }
             if(draw_task->type == LV_DRAW_TASK_TYPE_FILL) {
diff --git a/examples/widgets/chart/lv_example_chart_4.c b/examples/widgets/chart/lv_example_chart_4.c
index e8aebd613..c1004f1d1 100644
--- a/examples/widgets/chart/lv_example_chart_4.c
+++ b/examples/widgets/chart/lv_example_chart_4.c
@@ -7,9 +7,12 @@ static void draw_event_cb(lv_event_t * e)
     lv_draw_task_t * draw_task = lv_event_get_draw_task(e);
     lv_draw_dsc_base_t * base_dsc = draw_task->draw_dsc;
 
-    if(base_dsc->part == LV_PART_ITEMS && draw_task->type == LV_DRAW_TASK_TYPE_FILL) {
-        lv_draw_fill_dsc_t * fill_dsc = draw_task->draw_dsc;
+    if(base_dsc->part != LV_PART_ITEMS) {
+        return;
+    }
 
+    lv_draw_fill_dsc_t * fill_dsc = lv_draw_task_get_fill_dsc(draw_task);
+    if(fill_dsc) {
         lv_obj_t * chart = lv_event_get_target(e);
         int32_t * y_array = lv_chart_get_y_array(chart, lv_chart_get_series_next(chart, NULL));
         int32_t v = y_array[base_dsc->id2];
diff --git a/examples/widgets/table/lv_example_table_1.c b/examples/widgets/table/lv_example_table_1.c
index 4f26c3ac8..e9d663a5f 100644
--- a/examples/widgets/table/lv_example_table_1.c
+++ b/examples/widgets/table/lv_example_table_1.c
@@ -12,30 +12,30 @@ static void draw_event_cb(lv_event_t * e)
 
         /*Make the texts in the first cell center aligned*/
         if(row == 0) {
-            if(draw_task->type == LV_DRAW_TASK_TYPE_LABEL) {
-                lv_draw_label_dsc_t * label_draw_dsc = draw_task->draw_dsc;
+            lv_draw_label_dsc_t * label_draw_dsc = lv_draw_task_get_label_dsc(draw_task);
+            if(label_draw_dsc) {
                 label_draw_dsc->align = LV_TEXT_ALIGN_CENTER;
             }
-            if(draw_task->type == LV_DRAW_TASK_TYPE_FILL) {
-                lv_draw_rect_dsc_t * rect_draw_dsc = draw_task->draw_dsc;
-                rect_draw_dsc->bg_color = lv_color_mix(lv_palette_main(LV_PALETTE_BLUE), rect_draw_dsc->bg_color, LV_OPA_20);
-                rect_draw_dsc->bg_opa = LV_OPA_COVER;
+            lv_draw_fill_dsc_t * fill_draw_dsc = lv_draw_task_get_fill_dsc(draw_task);
+            if(fill_draw_dsc) {
+                fill_draw_dsc->color = lv_color_mix(lv_palette_main(LV_PALETTE_BLUE), fill_draw_dsc->color, LV_OPA_20);
+                fill_draw_dsc->opa = LV_OPA_COVER;
             }
         }
         /*In the first column align the texts to the right*/
         else if(col == 0) {
-            if(draw_task->type == LV_DRAW_TASK_TYPE_LABEL) {
-                lv_draw_label_dsc_t * label_draw_dsc = draw_task->draw_dsc;
+            lv_draw_label_dsc_t * label_draw_dsc = lv_draw_task_get_label_dsc(draw_task);
+            if(label_draw_dsc) {
                 label_draw_dsc->align = LV_TEXT_ALIGN_RIGHT;
             }
         }
 
         /*Make every 2nd row grayish*/
         if((row != 0 && row % 2) == 0) {
-            if(draw_task->type == LV_DRAW_TASK_TYPE_FILL) {
-                lv_draw_rect_dsc_t * rect_draw_dsc = draw_task->draw_dsc;
-                rect_draw_dsc->bg_color = lv_color_mix(lv_palette_main(LV_PALETTE_GREY), rect_draw_dsc->bg_color, LV_OPA_10);
-                rect_draw_dsc->bg_opa = LV_OPA_COVER;
+            lv_draw_fill_dsc_t * fill_draw_dsc = lv_draw_task_get_fill_dsc(draw_task);
+            if(fill_draw_dsc) {
+                fill_draw_dsc->color = lv_color_mix(lv_palette_main(LV_PALETTE_GREY), fill_draw_dsc->color, LV_OPA_10);
+                fill_draw_dsc->opa = LV_OPA_COVER;
             }
         }
     }
diff --git a/src/draw/lv_draw.c b/src/draw/lv_draw.c
index 548c5ec01..c73585e11 100644
--- a/src/draw/lv_draw.c
+++ b/src/draw/lv_draw.c
@@ -213,12 +213,10 @@ bool lv_draw_dispatch_layer(lv_display_t * disp, lv_layer_t * layer)
                     lv_free(layer_drawn);
                 }
             }
-            if(t->type == LV_DRAW_TASK_TYPE_LABEL) {
-                lv_draw_label_dsc_t * draw_label_dsc = t->draw_dsc;
-                if(draw_label_dsc->text_local) {
-                    lv_free((void *)draw_label_dsc->text);
-                    draw_label_dsc->text = NULL;
-                }
+            lv_draw_label_dsc_t * draw_label_dsc = lv_draw_task_get_label_dsc(t);
+            if(draw_label_dsc && draw_label_dsc->text_local) {
+                lv_free((void *)draw_label_dsc->text);
+                draw_label_dsc->text = NULL;
             }
 
             lv_free(t->draw_dsc);
diff --git a/src/draw/lv_draw_arc.c b/src/draw/lv_draw_arc.c
index 9f8a8b0f9..634c0429e 100644
--- a/src/draw/lv_draw_arc.c
+++ b/src/draw/lv_draw_arc.c
@@ -43,6 +43,11 @@ void lv_draw_arc_dsc_init(lv_draw_arc_dsc_t * dsc)
     dsc->color = lv_color_black();
 }
 
+lv_draw_arc_dsc_t * lv_draw_task_get_arc_dsc(lv_draw_task_t * task)
+{
+    return task->type == LV_DRAW_TASK_TYPE_ARC ? (lv_draw_arc_dsc_t *)task->draw_dsc : NULL;
+}
+
 void lv_draw_arc(lv_layer_t * layer, const lv_draw_arc_dsc_t * dsc)
 {
     if(dsc->opa <= LV_OPA_MIN) return;
diff --git a/src/draw/lv_draw_arc.h b/src/draw/lv_draw_arc.h
index e4e09987f..726bd68c8 100644
--- a/src/draw/lv_draw_arc.h
+++ b/src/draw/lv_draw_arc.h
@@ -51,6 +51,13 @@ typedef struct {
 void lv_draw_arc_dsc_init(lv_draw_arc_dsc_t * dsc);
 
 /**
+ * Try to get an arc draw descriptor from a draw task.
+ * @param task      draw task
+ * @return          the task's draw descriptor or NULL if the task is not of type LV_DRAW_TASK_TYPE_ARC
+ */
+lv_draw_arc_dsc_t * lv_draw_task_get_arc_dsc(lv_draw_task_t * task);
+
+/**
  * Create an arc draw task.
  * @param layer         pointer to a layer
  * @param dsc           pointer to an initialized draw descriptor variable
diff --git a/src/draw/lv_draw_image.c b/src/draw/lv_draw_image.c
index cb89fbda2..aafde5603 100644
--- a/src/draw/lv_draw_image.c
+++ b/src/draw/lv_draw_image.c
@@ -54,6 +54,11 @@ void lv_draw_image_dsc_init(lv_draw_image_dsc_t * dsc)
     dsc->base.dsc_size = sizeof(lv_draw_image_dsc_t);
 }
 
+lv_draw_image_dsc_t * lv_draw_task_get_image_dsc(lv_draw_task_t * task)
+{
+    return task->type == LV_DRAW_TASK_TYPE_IMAGE ? (lv_draw_image_dsc_t *)task->draw_dsc : NULL;
+}
+
 void lv_draw_layer(lv_layer_t * layer, const lv_draw_image_dsc_t * dsc, const lv_area_t * coords)
 {
     lv_draw_task_t * t = lv_draw_add_task(layer, coords);
diff --git a/src/draw/lv_draw_image.h b/src/draw/lv_draw_image.h
index 4965c773e..8a53ae2be 100644
--- a/src/draw/lv_draw_image.h
+++ b/src/draw/lv_draw_image.h
@@ -84,6 +84,13 @@ typedef void (*lv_draw_image_core_cb)(lv_draw_unit_t * draw_unit, const lv_draw_
 void lv_draw_image_dsc_init(lv_draw_image_dsc_t * dsc);
 
 /**
+ * Try to get an image draw descriptor from a draw task.
+ * @param task      draw task
+ * @return          the task's draw descriptor or NULL if the task is not of type LV_DRAW_TASK_TYPE_IMAGE
+ */
+lv_draw_image_dsc_t * lv_draw_task_get_image_dsc(lv_draw_task_t * task);
+
+/**
  * Create an image draw task
  * @param layer         pointer to a layer
  * @param dsc           pointer to an initialized draw descriptor
diff --git a/src/draw/lv_draw_label.c b/src/draw/lv_draw_label.c
index be26735ed..dfb0640f5 100644
--- a/src/draw/lv_draw_label.c
+++ b/src/draw/lv_draw_label.c
@@ -61,6 +61,11 @@ void lv_draw_label_dsc_init(lv_draw_label_dsc_t * dsc)
     dsc->base.dsc_size = sizeof(lv_draw_label_dsc_t);
 }
 
+lv_draw_label_dsc_t * lv_draw_task_get_label_dsc(lv_draw_task_t * task)
+{
+    return task->type == LV_DRAW_TASK_TYPE_LABEL ? (lv_draw_label_dsc_t *)task->draw_dsc : NULL;
+}
+
 void lv_draw_glyph_dsc_init(lv_draw_glyph_dsc_t * dsc)
 {
     lv_memzero(dsc, sizeof(lv_draw_glyph_dsc_t));
diff --git a/src/draw/lv_draw_label.h b/src/draw/lv_draw_label.h
index ef80addbb..3dcb6a0f9 100644
--- a/src/draw/lv_draw_label.h
+++ b/src/draw/lv_draw_label.h
@@ -116,6 +116,13 @@ typedef void(*lv_draw_glyph_cb_t)(lv_draw_unit_t * draw_unit, lv_draw_glyph_dsc_
 void /* LV_ATTRIBUTE_FAST_MEM */ lv_draw_label_dsc_init(lv_draw_label_dsc_t * dsc);
 
 /**
+ * Try to get a label draw descriptor from a draw task.
+ * @param task      draw task
+ * @return          the task's draw descriptor or NULL if the task is not of type LV_DRAW_TASK_TYPE_LABEL
+ */
+lv_draw_label_dsc_t * lv_draw_task_get_label_dsc(lv_draw_task_t * task);
+
+/**
  * Initialize a glyph draw descriptor.
  * Used internally.
  * @param dsc       pointer to a draw descriptor
diff --git a/src/draw/lv_draw_line.c b/src/draw/lv_draw_line.c
index 325fb8cc8..f906699c1 100644
--- a/src/draw/lv_draw_line.c
+++ b/src/draw/lv_draw_line.c
@@ -43,6 +43,11 @@ void LV_ATTRIBUTE_FAST_MEM lv_draw_line_dsc_init(lv_draw_line_dsc_t * dsc)
     dsc->color = lv_color_black();
 }
 
+lv_draw_line_dsc_t * lv_draw_task_get_line_dsc(lv_draw_task_t * task)
+{
+    return task->type == LV_DRAW_TASK_TYPE_LINE ? (lv_draw_line_dsc_t *)task->draw_dsc : NULL;
+}
+
 void LV_ATTRIBUTE_FAST_MEM lv_draw_line(lv_layer_t * layer, const lv_draw_line_dsc_t * dsc)
 {
     LV_PROFILER_BEGIN;
diff --git a/src/draw/lv_draw_line.h b/src/draw/lv_draw_line.h
index f7a95ea14..f070d0fe4 100644
--- a/src/draw/lv_draw_line.h
+++ b/src/draw/lv_draw_line.h
@@ -52,6 +52,13 @@ typedef struct {
 void lv_draw_line_dsc_init(lv_draw_line_dsc_t * dsc);
 
 /**
+ * Try to get a line draw descriptor from a draw task.
+ * @param task      draw task
+ * @return          the task's draw descriptor or NULL if the task is not of type LV_DRAW_TASK_TYPE_LINE
+ */
+lv_draw_line_dsc_t * lv_draw_task_get_line_dsc(lv_draw_task_t * task);
+
+/**
  * Create a line draw task
  * @param layer     pointer to a layer
  * @param dsc       pointer to an initialized `lv_draw_line_dsc_t` variable
diff --git a/src/draw/lv_draw_mask.c b/src/draw/lv_draw_mask.c
index dab578232..ed1ff2b44 100644
--- a/src/draw/lv_draw_mask.c
+++ b/src/draw/lv_draw_mask.c
@@ -41,6 +41,11 @@ void LV_ATTRIBUTE_FAST_MEM lv_draw_mask_rect_dsc_init(lv_draw_mask_rect_dsc_t *
     lv_memzero(dsc, sizeof(lv_draw_mask_rect_dsc_t));
 }
 
+lv_draw_mask_rect_dsc_t * lv_draw_task_get_mask_rect_dsc(lv_draw_task_t * task)
+{
+    return task->type == LV_DRAW_TASK_TYPE_MASK_RECTANGLE ? (lv_draw_mask_rect_dsc_t *)task->draw_dsc : NULL;
+}
+
 void LV_ATTRIBUTE_FAST_MEM lv_draw_mask_rect(lv_layer_t * layer, const lv_draw_mask_rect_dsc_t * dsc)
 {
     if(!lv_color_format_has_alpha(layer->color_format)) {
diff --git a/src/draw/lv_draw_mask.h b/src/draw/lv_draw_mask.h
index 103b8c9b7..6357647e9 100644
--- a/src/draw/lv_draw_mask.h
+++ b/src/draw/lv_draw_mask.h
@@ -43,6 +43,13 @@ typedef struct {
 void /* LV_ATTRIBUTE_FAST_MEM */ lv_draw_mask_rect_dsc_init(lv_draw_mask_rect_dsc_t * dsc);
 
 /**
+ * Try to get a rectangle mask draw descriptor from a draw task.
+ * @param task      draw task
+ * @return          the task's draw descriptor or NULL if the task is not of type LV_DRAW_TASK_TYPE_MASK_RECTANGLE
+ */
+lv_draw_mask_rect_dsc_t * lv_draw_task_get_mask_rect_dsc(lv_draw_task_t * task);
+
+/**
  * Create a draw task to mask a rectangle from the buffer
  * @param layer     pointer to a layer
  * @param dsc       pointer to a draw descriptor
diff --git a/src/draw/lv_draw_rect.c b/src/draw/lv_draw_rect.c
index 85f72f01a..574d78a73 100644
--- a/src/draw/lv_draw_rect.c
+++ b/src/draw/lv_draw_rect.c
@@ -62,6 +62,11 @@ void lv_draw_fill_dsc_init(lv_draw_fill_dsc_t * dsc)
     dsc->base.dsc_size = sizeof(lv_draw_fill_dsc_t);
 }
 
+lv_draw_fill_dsc_t * lv_draw_task_get_fill_dsc(lv_draw_task_t * task)
+{
+    return task->type == LV_DRAW_TASK_TYPE_FILL ? (lv_draw_fill_dsc_t *)task->draw_dsc : NULL;
+}
+
 void lv_draw_border_dsc_init(lv_draw_border_dsc_t * dsc)
 {
     lv_memzero(dsc, sizeof(*dsc));
@@ -70,6 +75,11 @@ void lv_draw_border_dsc_init(lv_draw_border_dsc_t * dsc)
     dsc->base.dsc_size = sizeof(lv_draw_border_dsc_t);
 }
 
+lv_draw_border_dsc_t * lv_draw_task_get_border_dsc(lv_draw_task_t * task)
+{
+    return task->type == LV_DRAW_TASK_TYPE_BORDER ? (lv_draw_border_dsc_t *)task->draw_dsc : NULL;
+}
+
 void lv_draw_box_shadow_dsc_init(lv_draw_box_shadow_dsc_t * dsc)
 {
     lv_memzero(dsc, sizeof(*dsc));
@@ -77,6 +87,11 @@ void lv_draw_box_shadow_dsc_init(lv_draw_box_shadow_dsc_t * dsc)
     dsc->base.dsc_size = sizeof(lv_draw_box_shadow_dsc_t);
 }
 
+lv_draw_box_shadow_dsc_t * lv_draw_task_get_box_shadow_dsc(lv_draw_task_t * task)
+{
+    return task->type == LV_DRAW_TASK_TYPE_BOX_SHADOW ? (lv_draw_box_shadow_dsc_t *)task->draw_dsc : NULL;
+}
+
 void lv_draw_rect(lv_layer_t * layer, const lv_draw_rect_dsc_t * dsc, const lv_area_t * coords)
 {
 
diff --git a/src/draw/lv_draw_rect.h b/src/draw/lv_draw_rect.h
index d3be1d774..6fe3a82e7 100644
--- a/src/draw/lv_draw_rect.h
+++ b/src/draw/lv_draw_rect.h
@@ -122,18 +122,39 @@ void /* LV_ATTRIBUTE_FAST_MEM */ lv_draw_rect_dsc_init(lv_draw_rect_dsc_t * dsc)
 void lv_draw_fill_dsc_init(lv_draw_fill_dsc_t * dsc);
 
 /**
+ * Try to get a fill draw descriptor from a draw task.
+ * @param task      draw task
+ * @return          the task's draw descriptor or NULL if the task is not of type LV_DRAW_TASK_TYPE_FILL
+ */
+lv_draw_fill_dsc_t * lv_draw_task_get_fill_dsc(lv_draw_task_t * task);
+
+/**
  * Initialize a border draw descriptor.
  * @param dsc       pointer to a draw descriptor
  */
 void lv_draw_border_dsc_init(lv_draw_border_dsc_t * dsc);
 
 /**
+ * Try to get a border draw descriptor from a draw task.
+ * @param task      draw task
+ * @return          the task's draw descriptor or NULL if the task is not of type LV_DRAW_TASK_TYPE_BORDER
+ */
+lv_draw_border_dsc_t * lv_draw_task_get_border_dsc(lv_draw_task_t * task);
+
+/**
  * Initialize a box shadow draw descriptor.
  * @param dsc       pointer to a draw descriptor
  */
 void lv_draw_box_shadow_dsc_init(lv_draw_box_shadow_dsc_t * dsc);
 
 /**
+ * Try to get a box shadow draw descriptor from a draw task.
+ * @param task      draw task
+ * @return          the task's draw descriptor or NULL if the task is not of type LV_DRAW_TASK_TYPE_BOX_SHADOW
+ */
+lv_draw_box_shadow_dsc_t * lv_draw_task_get_box_shadow_dsc(lv_draw_task_t * task);
+
+/**
  * The rectangle is a wrapper for fill, border, bg. image and box shadow.
  * Internally fill, border, image and box shadow draw tasks will be created.
  * @param layer         pointer to a layer
diff --git a/src/draw/lv_draw_triangle.c b/src/draw/lv_draw_triangle.c
index 86d236321..ae18968b5 100644
--- a/src/draw/lv_draw_triangle.c
+++ b/src/draw/lv_draw_triangle.c
@@ -49,6 +49,11 @@ void lv_draw_triangle_dsc_init(lv_draw_triangle_dsc_t * dsc)
     LV_PROFILER_END;
 }
 
+lv_draw_triangle_dsc_t * lv_draw_task_get_triangle_dsc(lv_draw_task_t * task)
+{
+    return task->type == LV_DRAW_TASK_TYPE_TRIANGLE ? (lv_draw_triangle_dsc_t *)task->draw_dsc : NULL;
+}
+
 void lv_draw_triangle(lv_layer_t * layer, const lv_draw_triangle_dsc_t * dsc)
 {
     LV_PROFILER_BEGIN;
diff --git a/src/draw/lv_draw_triangle.h b/src/draw/lv_draw_triangle.h
index 618908d4a..b825e5311 100644
--- a/src/draw/lv_draw_triangle.h
+++ b/src/draw/lv_draw_triangle.h
@@ -43,6 +43,13 @@ typedef struct {
 void lv_draw_triangle_dsc_init(lv_draw_triangle_dsc_t * draw_dsc);
 
 /**
+ * Try to get a triangle draw descriptor from a draw task.
+ * @param task      draw task
+ * @return          the task's draw descriptor or NULL if the task is not of type LV_DRAW_TASK_TYPE_TRIANGLE
+ */
+lv_draw_triangle_dsc_t * lv_draw_task_get_triangle_dsc(lv_draw_task_t * task);
+
+/**
  * Create a triangle draw task
  * @param layer     pointer to a layer
  * @param dsc       pointer to an initialized `lv_draw_triangle_dsc_t` variable
diff --git a/src/draw/sdl/lv_draw_sdl.c b/src/draw/sdl/lv_draw_sdl.c
index 7ce1935df..b7e41cdce 100644
--- a/src/draw/sdl/lv_draw_sdl.c
+++ b/src/draw/sdl/lv_draw_sdl.c
@@ -344,8 +344,8 @@ static void draw_from_cached_texture(lv_draw_sdl_unit_t * u)
 
     SDL_SetRenderTarget(renderer, layer_get_texture(dest_layer));
 
-    if(t->type == LV_DRAW_TASK_TYPE_IMAGE) {
-        lv_draw_image_dsc_t * draw_dsc = t->draw_dsc;
+    lv_draw_image_dsc_t * draw_dsc = lv_draw_task_get_image_dsc(t);
+    if(draw_dsc) {
         lv_area_t image_area;
         image_area.x1 = 0;
         image_area.y1 = 0;
diff --git a/src/widgets/calendar/lv_calendar.c b/src/widgets/calendar/lv_calendar.c
index d053b7dd0..fb5682bf9 100644
--- a/src/widgets/calendar/lv_calendar.c
+++ b/src/widgets/calendar/lv_calendar.c
@@ -300,16 +300,10 @@ static void draw_task_added_event_cb(lv_event_t * e)
     lv_draw_task_t * draw_task = lv_event_get_param(e);
     if(((lv_draw_dsc_base_t *)draw_task->draw_dsc)->part != LV_PART_ITEMS) return;
 
-    lv_draw_fill_dsc_t * fill_draw_dsc = NULL;
-    lv_draw_border_dsc_t * border_draw_dsc = NULL;
+    lv_draw_fill_dsc_t * fill_draw_dsc = lv_draw_task_get_fill_dsc(draw_task);
+    lv_draw_border_dsc_t * border_draw_dsc = lv_draw_task_get_border_dsc(draw_task);
 
-    if(draw_task->type == LV_DRAW_TASK_TYPE_FILL) {
-        fill_draw_dsc = draw_task->draw_dsc;
-    }
-    else if(draw_task->type == LV_DRAW_TASK_TYPE_BORDER) {
-        border_draw_dsc = draw_task->draw_dsc;
-    }
-    else {
+    if(!fill_draw_dsc && !border_draw_dsc) {
         return;
     }
 
diff --git a/tests/src/test_cases/widgets/test_table.c b/tests/src/test_cases/widgets/test_table.c
index 6b7d98135..825200aaf 100644
--- a/tests/src/test_cases/widgets/test_table.c
+++ b/tests/src/test_cases/widgets/test_table.c
@@ -139,30 +139,30 @@ static void draw_part_event_cb(lv_event_t * e)
 
         /*Make the texts in the first cell center aligned*/
         if(row == 0) {
-            if(draw_task->type == LV_DRAW_TASK_TYPE_LABEL) {
-                lv_draw_label_dsc_t * label_draw_dsc = draw_task->draw_dsc;
+            lv_draw_label_dsc_t * label_draw_dsc = lv_draw_task_get_label_dsc(draw_task);
+            if(label_draw_dsc) {
                 label_draw_dsc->align = LV_TEXT_ALIGN_CENTER;
             }
-            if(draw_task->type == LV_DRAW_TASK_TYPE_FILL) {
-                lv_draw_rect_dsc_t * rect_draw_dsc = draw_task->draw_dsc;
-                rect_draw_dsc->bg_color = lv_color_mix(lv_palette_main(LV_PALETTE_BLUE), rect_draw_dsc->bg_color, LV_OPA_20);
-                rect_draw_dsc->bg_opa = LV_OPA_COVER;
+            lv_draw_fill_dsc_t * fill_draw_dsc = lv_draw_task_get_fill_dsc(draw_task);
+            if(fill_draw_dsc) {
+                fill_draw_dsc->color = lv_color_mix(lv_palette_main(LV_PALETTE_BLUE), fill_draw_dsc->color, LV_OPA_20);
+                fill_draw_dsc->opa = LV_OPA_COVER;
             }
         }
         /*In the first column align the texts to the right*/
         else if(col == 0) {
-            if(draw_task->type == LV_DRAW_TASK_TYPE_LABEL) {
-                lv_draw_label_dsc_t * label_draw_dsc = draw_task->draw_dsc;
+            lv_draw_label_dsc_t * label_draw_dsc = lv_draw_task_get_label_dsc(draw_task);
+            if(label_draw_dsc) {
                 label_draw_dsc->align = LV_TEXT_ALIGN_RIGHT;
             }
         }
 
         /*Make every 2nd row grayish*/
         if((row != 0 && row % 2) == 0) {
-            if(draw_task->type == LV_DRAW_TASK_TYPE_FILL) {
-                lv_draw_rect_dsc_t * rect_draw_dsc = draw_task->draw_dsc;
-                rect_draw_dsc->bg_color = lv_color_mix(lv_palette_main(LV_PALETTE_GREY), rect_draw_dsc->bg_color, LV_OPA_10);
-                rect_draw_dsc->bg_opa = LV_OPA_COVER;
+            lv_draw_fill_dsc_t * fill_draw_dsc = lv_draw_task_get_fill_dsc(draw_task);
+            if(fill_draw_dsc) {
+                fill_draw_dsc->color = lv_color_mix(lv_palette_main(LV_PALETTE_GREY), fill_draw_dsc->color, LV_OPA_10);
+                fill_draw_dsc->opa = LV_OPA_COVER;
             }
         }
     }