feat: use solid fills with rle compressed images

Author: Ddystopia

src/lib.rs

@@ -266,7 +266,6 @@ where
         D: DrawTarget<Color = C>,
     {
         let area = self.bounding_box();
-        let slice_size = Size::new(area.size.width, 1);
 
         match self.raw_bmp.color_type {
             ColorType::Index1 => {
@@ -300,13 +299,25 @@ where
                                 .map(Into::into)
                                 .unwrap_or(fallback_color)
                         };
+
                         // RLE produces pixels in bottom-up order, so we draw them line by line rather than the entire bitmap at once.
                         for y in (0..area.size.height).rev() {
                             colors.start_row();
 
-                            let row = Rectangle::new(Point::new(0, y as i32), slice_size);
-                            let colors = colors.by_ref().map(map_color);
-                            target.fill_contiguous(&row, colors.take(area.size.width as usize))?;
+                            let mut point = Point::new(0, y as i32);
+                            loop {
+                                if point.x >= area.size.width as i32 {
+                                    break;
+                                }
+                                let Some((raw_color, count)) = colors.next_solid_chunk() else {
+                                    break;
+                                };
+
+                                let size = Size::new(count as u32, 1);
+                                let color = map_color(raw_color);
+                                target.fill_solid(&Rectangle::new(point, size), color)?;
+                                point.x += count as i32;
+                            }
                         }
                         Ok(())
                     } else {
@@ -335,13 +346,25 @@ where
                                 .map(Into::into)
                                 .unwrap_or(fallback_color)
                         };
+
                         // RLE produces pixels in bottom-up order, so we draw them line by line rather than the entire bitmap at once.
                         for y in (0..area.size.height).rev() {
                             colors.start_row();
 
-                            let row = Rectangle::new(Point::new(0, y as i32), slice_size);
-                            let colors = colors.by_ref().map(map_color);
-                            target.fill_contiguous(&row, colors.take(area.size.width as usize))?;
+                            let mut point = Point::new(0, y as i32);
+                            loop {
+                                if point.x >= area.size.width as i32 {
+                                    break;
+                                }
+                                let Some((raw_color, count)) = colors.next_solid_chunk() else {
+                                    break;
+                                };
+
+                                let size = Size::new(count as u32, 1);
+                                let color = map_color(raw_color);
+                                target.fill_solid(&Rectangle::new(point, size), color)?;
+                                point.x += count as i32;
+                            }
                         }
                         Ok(())
                     } else {