pub fn new(width: u32, height: u32) -> Self {

        let root_id = LayerId(0);

        let root_layer = Layer::new(

            root_id,

            LogicalRect {

                origin: LogicalPosition::zero(),

                size: LogicalSize { width: width as f32, height: height as f32 },

            },

            width,

            height,

        let mut layers = HashMap::new();

        layers.insert(root_id, root_layer);

        CompositorState {

            layers,

            root_layer: root_id,

            next_layer_id: 1,

            previous_positions: Vec::new(),

        }

    }

    pub fn alloc_layer_id(&mut self) -> LayerId {

        let id = LayerId(self.next_layer_id);

        self.next_layer_id += 1;

        id

    }

    pub fn next_layer_id_peek(&self) -> u64 {

        self.next_layer_id

    }

    pub fn allocate_layers_from_display_list(

        &mut self,

        display_list: &DisplayList,

        dpi_factor: f32,

    ) {

        let root_id = self.root_layer;

        self.layers.retain(|id, _| *id == root_id);

        if let Some(root) = self.layers.get_mut(&root_id) {

            root.children.clear();

            root.damage.clear();

            root.display_list_range = (0, display_list.items.len());

            root.composite_dirty = true;

        }

        let mut layer_stack: Vec<LayerId> = vec![root_id];

        let mut i = 0;

        while i < display_list.items.len() {

            match &display_list.items[i] {

                DisplayListItem::PushScrollFrame { clip_bounds, content_size, scroll_id, .. } => {

                    let bounds = *clip_bounds.inner();

                    let pw = (bounds.size.width * dpi_factor).ceil() as u32;

                    let ph = (bounds.size.height * dpi_factor).ceil() as u32;

                    if pw > 0 && ph > 0 {

                        let new_id = self.alloc_layer_id();

                        let mut layer = Layer::new(new_id, bounds, pw, ph);

                        layer.scroll_id = Some(*scroll_id);

                        let end = find_matching_pop(&display_list.items, i, MatchKind::ScrollFrame);

                        layer.display_list_range = (i + 1, end);

                        self.layers.insert(new_id, layer);

                        let parent_id = *layer_stack.last().unwrap();

                        if let Some(parent) = self.layers.get_mut(&parent_id) {

                            parent.children.push(new_id);

                        }

                        layer_stack.push(new_id);

                    }

                    if layer_stack.len() > 1 {

                        layer_stack.pop();

                    }

                DisplayListItem::PushOpacity { bounds, opacity } => {

                    if *opacity < 1.0 {

                        let b = *bounds.inner();

                        let pw = (b.size.width * dpi_factor).ceil() as u32;

                        let ph = (b.size.height * dpi_factor).ceil() as u32;

                        if pw > 0 && ph > 0 {

                            let new_id = self.alloc_layer_id();

                            let mut layer = Layer::new(new_id, b, pw, ph);

                            layer.opacity = *opacity;

                            let end = find_matching_pop(&display_list.items, i, MatchKind::Opacity);

                            layer.display_list_range = (i + 1, end);

                            self.layers.insert(new_id, layer);

                            let parent_id = *layer_stack.last().unwrap();

                            if let Some(parent) = self.layers.get_mut(&parent_id) {

                                parent.children.push(new_id);

                            }

                            layer_stack.push(new_id);

                        }

                    }

                    if layer_stack.len() > 1 {

                        let top_id = *layer_stack.last().unwrap();

                        if let Some(layer) = self.layers.get(&top_id) {

                            if layer.opacity < 1.0 && layer.scroll_id.is_none() {

                                layer_stack.pop();

                            }

                        }

                    }

                DisplayListItem::PushFilter { bounds, filters } => {

                    let has_blur = filters.iter().any(|f| matches!(f, StyleFilter::Blur(_)));

                    if has_blur {

                        let b = *bounds.inner();

                        let pw = (b.size.width * dpi_factor).ceil() as u32;

                        let ph = (b.size.height * dpi_factor).ceil() as u32;

                        if pw > 0 && ph > 0 {

                            let new_id = self.alloc_layer_id();

                            let mut layer = Layer::new(new_id, b, pw, ph);

                            layer.filters = filters.clone();

                            let end = find_matching_pop(&display_list.items, i, MatchKind::Filter);

                            layer.display_list_range = (i + 1, end);

                            self.layers.insert(new_id, layer);

                            let parent_id = *layer_stack.last().unwrap();

                            if let Some(parent) = self.layers.get_mut(&parent_id) {

                                parent.children.push(new_id);

                            }

                            layer_stack.push(new_id);

                        }

                    }

                    if layer_stack.len() > 1 {

                        let top_id = *layer_stack.last().unwrap();

                        if let Some(layer) = self.layers.get(&top_id) {

                            if !layer.filters.is_empty() {

                                layer_stack.pop();

                            }

                        }

                    }

                DisplayListItem::PushReferenceFrame { initial_transform, bounds, .. } => {

                    let m = &initial_transform.m;

                    let is_identity =

                        (m[0][0] - 1.0).abs() < IDENTITY_EPSILON &&

                        m[0][1].abs() < IDENTITY_EPSILON &&

                        m[1][0].abs() < IDENTITY_EPSILON &&

                        (m[1][1] - 1.0).abs() < IDENTITY_EPSILON &&

                        m[3][0].abs() < IDENTITY_EPSILON &&

                        m[3][1].abs() < IDENTITY_EPSILON;

                    if !is_identity {

                        let b = *bounds.inner();

                        let pw = (b.size.width * dpi_factor).ceil().max(1.0) as u32;

                        let ph = (b.size.height * dpi_factor).ceil().max(1.0) as u32;

                        let new_id = self.alloc_layer_id();

                        let mut layer = Layer::new(new_id, b, pw, ph);

                        layer.transform = TransAffine::new_custom(

                            m[0][0] as f64, m[0][1] as f64,

                            m[1][0] as f64, m[1][1] as f64,

                            m[3][0] as f64, m[3][1] as f64,

                        );

                        let end = find_matching_pop(&display_list.items, i, MatchKind::ReferenceFrame);

                        layer.display_list_range = (i + 1, end);

                        self.layers.insert(new_id, layer);

                        let parent_id = *layer_stack.last().unwrap();

                        if let Some(parent) = self.layers.get_mut(&parent_id) {

                            parent.children.push(new_id);

                        }

                        layer_stack.push(new_id);

                    }

                    if layer_stack.len() > 1 {

                        let top_id = *layer_stack.last().unwrap();

                        if let Some(layer) = self.layers.get(&top_id) {

                            if !layer.transform.is_identity(IDENTITY_EPSILON_F64) {

                                layer_stack.pop();

                            }

                        }

                    }

                _ => {}

            i += 1;

    }

    pub fn compute_damage(

        &mut self,

        dirty_nodes: &std::collections::BTreeSet<usize>,

        old_positions: &[LogicalPosition],

        new_positions: &[LogicalPosition],

        calculated_rects: &[LogicalRect],

    ) {

        if dirty_nodes.is_empty() {

            return;

        }

        let mut damage_rects = Vec::new();

        for &node_idx in dirty_nodes {

            if node_idx < old_positions.len() && node_idx < calculated_rects.len() {

                let old_rect = LogicalRect {

                    origin: old_positions[node_idx],

                    size: calculated_rects[node_idx].size,

                };

                damage_rects.push(old_rect);

            }

            if node_idx < new_positions.len() && node_idx < calculated_rects.len() {

                let new_rect = LogicalRect {

                    origin: new_positions[node_idx],

                    size: calculated_rects[node_idx].size,

                };

                damage_rects.push(new_rect);

            }

        for (_, layer) in self.layers.iter_mut() {

            for damage in &damage_rects {

                if let Some(intersection) = rect_intersection(&layer.bounds, damage) {

                    layer.damage.push(intersection);

                    layer.composite_dirty = true;

                }

    }

    pub fn render_layers(

        &mut self,

        display_list: &DisplayList,

        dpi_factor: f32,

        renderer_resources: &RendererResources,

        font_manager: Option<&FontManager<FontRef>>,

        glyph_cache: &mut GlyphCache,

    ) -> Result<(), String> {

        let layer_ranges: Vec<(LayerId, (usize, usize), LogicalRect)> = self.layers

            .iter()

            .map(|(id, layer)| (*id, layer.display_list_range, layer.bounds))

            .collect();

        for (layer_id, range, layer_bounds) in &layer_ranges {

            let (start, end) = *range;

            if start >= end || start >= display_list.items.len() {

                continue;

            }

            let layer = self.layers.get_mut(layer_id).unwrap();

            if *layer_id == self.root_layer {

                layer.pixbuf.fill(255, 255, 255, 255);

            } else {

                layer.pixbuf.fill(0, 0, 0, 0);

            }

            let offset_x = layer_bounds.origin.x;

            let offset_y = layer_bounds.origin.y;

            render_display_list_range(

                display_list,

                &mut layer.pixbuf,

                start,

                end.min(display_list.items.len()),

                offset_x,

                offset_y,

                dpi_factor,

                renderer_resources,

                font_manager,

                glyph_cache,

            )?;

        Ok(())

    }

    pub fn composite_frame(&self, output: &mut AzulPixmap, dpi_factor: f32) {

        self.composite_layer_recursive(self.root_layer, output, 0.0, 0.0, dpi_factor);

    }

    fn composite_layer_recursive(

        &self,

        layer_id: LayerId,

        output: &mut AzulPixmap,

        parent_offset_x: f32,

        parent_offset_y: f32,

        dpi_factor: f32,

    ) {

        let layer = match self.layers.get(&layer_id) {

            Some(l) => l,

            None => return,

        let abs_x = parent_offset_x + layer.bounds.origin.x;

        let abs_y = parent_offset_y + layer.bounds.origin.y;

        if layer_id == self.root_layer {

            blit_pixmap(&layer.pixbuf, output, 0, 0, 1.0);

        } else {

            let src = if !layer.filters.is_empty() {

                let mut filtered = layer.pixbuf.clone_pixmap();

                apply_layer_filters(&mut filtered, &layer.filters, dpi_factor);

                Some(filtered)

                None

            let src_pixbuf = src.as_ref().unwrap_or(&layer.pixbuf);

            let px_x = (abs_x * dpi_factor) as i32;

            let px_y = (abs_y * dpi_factor) as i32;

            blit_pixmap(src_pixbuf, output, px_x, px_y, layer.opacity);

        let children: Vec<LayerId> = layer.children.clone();

        for child_id in &children {

            self.composite_layer_recursive(

                *child_id,

                output,

                if layer_id == self.root_layer { 0.0 } else { abs_x },

                if layer_id == self.root_layer { 0.0 } else { abs_y },

                dpi_factor,

    }

    pub fn scroll_layer(

        &mut self,

        scroll_id: LocalScrollId,

        new_offset: (f32, f32),

        display_list: &DisplayList,

        dpi_factor: f32,

        renderer_resources: &RendererResources,

        font_manager: Option<&FontManager<FontRef>>,

        glyph_cache: &mut GlyphCache,

    ) -> Result<(), String> {

        let layer_id = self.layers.iter()

            .find(|(_, l)| l.scroll_id == Some(scroll_id))

            .map(|(id, _)| *id);

        let layer_id = match layer_id {

            Some(id) => id,

            None => return Ok(()), // No layer for this scroll ID

        let layer = self.layers.get_mut(&layer_id).unwrap();

        let old_offset = layer.scroll_offset;

        let dx = new_offset.0 - old_offset.0;

        let dy = new_offset.1 - old_offset.1;

        if dx.abs() < 0.5 && dy.abs() < 0.5 {

            return Ok(());

        }

        let px_dx = (dx * dpi_factor).round() as i32;

        let px_dy = (dy * dpi_factor).round() as i32;

        shift_pixbuf(&mut layer.pixbuf, px_dx, px_dy);

        let exposed = compute_exposed_rects(&layer.bounds, dx, dy);

        for exposed_rect in exposed {

            layer.damage.push(exposed_rect);

        }

        layer.scroll_offset = new_offset;

        layer.composite_dirty = true;

        let range = layer.display_list_range;

        let bounds = layer.bounds;

        let offset_x = bounds.origin.x;

        let offset_y = bounds.origin.y;

        render_display_list_range(

            display_list,

            &mut self.layers.get_mut(&layer_id).unwrap().pixbuf,

            range.0,

            range.1.min(display_list.items.len()),

            offset_x,

            offset_y,

            dpi_factor,

            renderer_resources,

            font_manager,

            glyph_cache,

        )?;

        Ok(())

    }

    fn new(id: LayerId, bounds: LogicalRect, pixel_width: u32, pixel_height: u32) -> Self {

            id,

            pixbuf: AzulPixmap::new(pixel_width.max(1), pixel_height.max(1))

                .unwrap_or_else(|| AzulPixmap { data: vec![0; 4], width: 1, height: 1 }),

            bounds,

            damage: Vec::new(),

            children: Vec::new(),

            scroll_offset: (0.0, 0.0),

            filters: Vec::new(),

            transform: TransAffine::new(),

            display_list_range: (0, 0),

            scroll_id: None,

    }

fn find_matching_pop(items: &[DisplayListItem], start: usize, kind: MatchKind) -> usize {

    let mut depth = 1u32;

    for i in (start + 1)..items.len() {

        match (&items[i], kind) {

            (DisplayListItem::PushScrollFrame { .. }, MatchKind::ScrollFrame) => depth += 1,

                depth -= 1;

                if depth == 0 { return i; }

            (DisplayListItem::PushOpacity { .. }, MatchKind::Opacity) => depth += 1,

                depth -= 1;

                if depth == 0 { return i; }

            (DisplayListItem::PushFilter { .. }, MatchKind::Filter) => depth += 1,

                depth -= 1;

                if depth == 0 { return i; }

            (DisplayListItem::PushReferenceFrame { .. }, MatchKind::ReferenceFrame) => depth += 1,

                depth -= 1;

                if depth == 0 { return i; }

            _ => {}

    items.len()

}

fn rect_intersection(a: &LogicalRect, b: &LogicalRect) -> Option<LogicalRect> {

    let x1 = a.origin.x.max(b.origin.x);

    let y1 = a.origin.y.max(b.origin.y);

    let x2 = (a.origin.x + a.size.width).min(b.origin.x + b.size.width);

    let y2 = (a.origin.y + a.size.height).min(b.origin.y + b.size.height);

    if x2 > x1 && y2 > y1 {

        Some(LogicalRect {

            origin: LogicalPosition { x: x1, y: y1 },

            size: LogicalSize { width: x2 - x1, height: y2 - y1 },

        })

        None

}

fn blit_pixmap(src: &AzulPixmap, dst: &mut AzulPixmap, px_x: i32, px_y: i32, opacity: f32) {

    let sw = src.width as i32;

    let sh = src.height as i32;

    let dw = dst.width as i32;

    let dh = dst.height as i32;

    let op = (opacity * 255.0).clamp(0.0, 255.0) as u32;

    for sy in 0..sh {

        let dy = px_y + sy;

        if dy < 0 || dy >= dh { continue; }

        for sx in 0..sw {

            let dx = px_x + sx;

            if dx < 0 || dx >= dw { continue; }

            let si = ((sy * sw + sx) * 4) as usize;

            let di = ((dy * dw + dx) * 4) as usize;

            if si + 3 >= src.data.len() || di + 3 >= dst.data.len() { continue; }

            let sr = src.data[si] as u32;

            let sg = src.data[si + 1] as u32;

            let sb = src.data[si + 2] as u32;

            let sa = (src.data[si + 3] as u32 * op) / 255;

            if sa == 0 { continue; }

            if sa == 255 {

                dst.data[di] = sr as u8;

                dst.data[di + 1] = sg as u8;

                dst.data[di + 2] = sb as u8;

                dst.data[di + 3] = 255;

            } else {

                let inv_sa = 255 - sa;

                dst.data[di]     = ((sr * sa + dst.data[di] as u32 * inv_sa) / 255) as u8;

                dst.data[di + 1] = ((sg * sa + dst.data[di + 1] as u32 * inv_sa) / 255) as u8;

                dst.data[di + 2] = ((sb * sa + dst.data[di + 2] as u32 * inv_sa) / 255) as u8;

                dst.data[di + 3] = ((sa + dst.data[di + 3] as u32 * inv_sa / 255).min(255)) as u8;

            }

}

fn shift_pixbuf(pixmap: &mut AzulPixmap, dx: i32, dy: i32) {

    let w = pixmap.width as i32;

    let h = pixmap.height as i32;

    if dx.abs() >= w || dy.abs() >= h {

        pixmap.fill(0, 0, 0, 0);

        return;

    }

    let stride = (w * 4) as usize;

    let data = &mut pixmap.data;

    if dy > 0 {

        for row in (0..h - dy).rev() {

            let src_start = (row * w * 4) as usize;

            let dst_start = ((row + dy) * w * 4) as usize;

            data.copy_within(src_start..src_start + stride, dst_start);

        }

        for row in 0..dy {

            let start = (row * w * 4) as usize;

            data[start..start + stride].fill(0);

        }

    } else if dy < 0 {

        let ady = (-dy) as i32;

        for row in ady..h {

            let src_start = (row * w * 4) as usize;

            let dst_start = ((row - ady) * w * 4) as usize;

            data.copy_within(src_start..src_start + stride, dst_start);

        }

        for row in (h - ady)..h {

            let start = (row * w * 4) as usize;

            data[start..start + stride].fill(0);

        }

    }

    if dx > 0 {

        for row in 0..h {

            let row_start = (row * w * 4) as usize;

            let shift = (dx * 4) as usize;

            // Shift right within the row

            data.copy_within(row_start..row_start + stride - shift, row_start + shift);

            // Clear left columns

            data[row_start..row_start + shift].fill(0);

        }

    } else if dx < 0 {

        let adx = (-dx * 4) as usize;

        for row in 0..h {

            let row_start = (row * w * 4) as usize;

            data.copy_within(row_start + adx..row_start + stride, row_start);

            // Clear right columns

            data[row_start + stride - adx..row_start + stride].fill(0);

        }

    }

}

fn compute_exposed_rects(bounds: &LogicalRect, dx: f32, dy: f32) -> Vec<LogicalRect> {

    let w = bounds.size.width;

    let h = bounds.size.height;

    let mut rects = Vec::new();

    if dy.abs() > 0.5 {

        let strip = if dy > 0.0 {

            LogicalRect {

                origin: LogicalPosition { x: bounds.origin.x, y: bounds.origin.y },

                size: LogicalSize { width: w, height: dy.min(h) },

            }

            LogicalRect {

                origin: LogicalPosition { x: bounds.origin.x, y: bounds.origin.y + h + dy },

                size: LogicalSize { width: w, height: (-dy).min(h) },

            }

        rects.push(strip);

    }

    if dx.abs() > 0.5 {

        let strip = if dx > 0.0 {

            LogicalRect {

                origin: LogicalPosition { x: bounds.origin.x, y: bounds.origin.y },

                size: LogicalSize { width: dx.min(w), height: h },

            }

            LogicalRect {

                origin: LogicalPosition { x: bounds.origin.x + w + dx, y: bounds.origin.y },

                size: LogicalSize { width: (-dx).min(w), height: h },

            }

        rects.push(strip);

    }

    rects

}

fn apply_layer_filters(pixmap: &mut AzulPixmap, filters: &[StyleFilter], dpi_factor: f32) {

    for filter in filters {

        match filter {

            StyleFilter::Blur(blur) => {

                let rx = blur.width.to_pixels_internal(0.0, DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE) * dpi_factor;

                let ry = blur.height.to_pixels_internal(0.0, DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE) * dpi_factor;

                let radius = ((rx + ry) / 2.0).ceil() as u32;

                if radius > 0 {

                    let w = pixmap.width;

                    let h = pixmap.height;

                    let stride = (w * 4) as i32;

                    let mut ra = unsafe {

                        RowAccessor::new_with_buf(pixmap.data.as_mut_ptr(), w, h, stride)

                    };

                    stack_blur_rgba32(&mut ra, radius, radius);

                }

            StyleFilter::Opacity(pct) => {

                let op = (pct.normalized() * 255.0).clamp(0.0, 255.0) as u32;

                for chunk in pixmap.data.chunks_exact_mut(4) {

                    chunk[3] = ((chunk[3] as u32 * op) / 255) as u8;

                }

            StyleFilter::Grayscale(pct) => {

                let amount = pct.normalized().clamp(0.0, 1.0);

                for chunk in pixmap.data.chunks_exact_mut(4) {

                    let r = chunk[0] as f32;

                    let g = chunk[1] as f32;

                    let b = chunk[2] as f32;

                    let gray = 0.2126 * r + 0.7152 * g + 0.0722 * b;

                    chunk[0] = (r + (gray - r) * amount).clamp(0.0, 255.0) as u8;

                    chunk[1] = (g + (gray - g) * amount).clamp(0.0, 255.0) as u8;

                    chunk[2] = (b + (gray - b) * amount).clamp(0.0, 255.0) as u8;

                }

            StyleFilter::Brightness(pct) => {

                let factor = pct.normalized().max(0.0);

                for chunk in pixmap.data.chunks_exact_mut(4) {

                    chunk[0] = (chunk[0] as f32 * factor).clamp(0.0, 255.0) as u8;

                    chunk[1] = (chunk[1] as f32 * factor).clamp(0.0, 255.0) as u8;

                    chunk[2] = (chunk[2] as f32 * factor).clamp(0.0, 255.0) as u8;

                }

            StyleFilter::Contrast(pct) => {

                let factor = pct.normalized().max(0.0);

                for chunk in pixmap.data.chunks_exact_mut(4) {

                    chunk[0] = ((((chunk[0] as f32 / 255.0) - 0.5) * factor + 0.5) * 255.0).clamp(0.0, 255.0) as u8;

                    chunk[1] = ((((chunk[1] as f32 / 255.0) - 0.5) * factor + 0.5) * 255.0).clamp(0.0, 255.0) as u8;

                    chunk[2] = ((((chunk[2] as f32 / 255.0) - 0.5) * factor + 0.5) * 255.0).clamp(0.0, 255.0) as u8;

                }

            StyleFilter::Invert(pct) => {

                let amount = pct.normalized().clamp(0.0, 1.0);

                for chunk in pixmap.data.chunks_exact_mut(4) {

                    chunk[0] = (chunk[0] as f32 + (255.0 - 2.0 * chunk[0] as f32) * amount).clamp(0.0, 255.0) as u8;

                    chunk[1] = (chunk[1] as f32 + (255.0 - 2.0 * chunk[1] as f32) * amount).clamp(0.0, 255.0) as u8;

                    chunk[2] = (chunk[2] as f32 + (255.0 - 2.0 * chunk[2] as f32) * amount).clamp(0.0, 255.0) as u8;

                }

            StyleFilter::Sepia(pct) => {

                let amount = pct.normalized().clamp(0.0, 1.0);

                for chunk in pixmap.data.chunks_exact_mut(4) {

                    let r = chunk[0] as f32;

                    let g = chunk[1] as f32;

                    let b = chunk[2] as f32;

                    let sr = (0.393 * r + 0.769 * g + 0.189 * b).min(255.0);

                    let sg = (0.349 * r + 0.686 * g + 0.168 * b).min(255.0);

                    let sb = (0.272 * r + 0.534 * g + 0.131 * b).min(255.0);

                    chunk[0] = (r + (sr - r) * amount).clamp(0.0, 255.0) as u8;

                    chunk[1] = (g + (sg - g) * amount).clamp(0.0, 255.0) as u8;

                    chunk[2] = (b + (sb - b) * amount).clamp(0.0, 255.0) as u8;

                }

            StyleFilter::Saturate(pct) => {

                let s = pct.normalized().max(0.0);

                for chunk in pixmap.data.chunks_exact_mut(4) {

                    let r = chunk[0] as f32;

                    let g = chunk[1] as f32;

                    let b = chunk[2] as f32;

                    let gray = 0.2126 * r + 0.7152 * g + 0.0722 * b;

                    chunk[0] = (gray + (r - gray) * s).clamp(0.0, 255.0) as u8;

                    chunk[1] = (gray + (g - gray) * s).clamp(0.0, 255.0) as u8;

                    chunk[2] = (gray + (b - gray) * s).clamp(0.0, 255.0) as u8;

                }

            StyleFilter::HueRotate(angle) => {

                let rad = angle.to_degrees().to_radians();

                let cos_a = rad.cos();

                let sin_a = rad.sin();

                for chunk in pixmap.data.chunks_exact_mut(4) {

                    let r = chunk[0] as f32;

                    let g = chunk[1] as f32;

                    let b = chunk[2] as f32;

                    let nr = (0.213 + 0.787 * cos_a - 0.213 * sin_a) * r

                           + (0.715 - 0.715 * cos_a - 0.715 * sin_a) * g

                           + (0.072 - 0.072 * cos_a + 0.928 * sin_a) * b;

                    let ng = (0.213 - 0.213 * cos_a + 0.143 * sin_a) * r

                           + (0.715 + 0.285 * cos_a + 0.140 * sin_a) * g

                           + (0.072 - 0.072 * cos_a - 0.283 * sin_a) * b;

                    let nb = (0.213 - 0.213 * cos_a - 0.787 * sin_a) * r

                           + (0.715 - 0.715 * cos_a + 0.715 * sin_a) * g

                           + (0.072 + 0.928 * cos_a + 0.072 * sin_a) * b;

                    chunk[0] = nr.clamp(0.0, 255.0) as u8;

                    chunk[1] = ng.clamp(0.0, 255.0) as u8;

                    chunk[2] = nb.clamp(0.0, 255.0) as u8;

                }

            _ => {} // Blend, Flood, ColorMatrix, DropShadow, ComponentTransfer, Offset, Composite not yet implemented

}

fn render_display_list_range(

    display_list: &DisplayList,

    pixmap: &mut AzulPixmap,

    start: usize,

    end: usize,

    offset_x: f32,

    offset_y: f32,

    dpi_factor: f32,

    renderer_resources: &RendererResources,

    font_manager: Option<&FontManager<FontRef>>,

    glyph_cache: &mut GlyphCache,

) -> Result<(), String> {

    let empty_state = CpuRenderState::new(ScrollOffsetMap::new());

    let render_state = &empty_state;

    let mut transform_stack = vec![TransAffine::new()];

    let mut clip_stack: Vec<Option<AzRect>> = vec![None];

    let mut mask_stack: Vec<MaskEntry> = Vec::new();

    let mut scroll_offset_stack: Vec<(f32, f32)> = vec![(0.0, 0.0)];

    for i in start..end {

        let item = &display_list.items[i];

        render_single_item(

            item,

            pixmap,

            dpi_factor,

            renderer_resources,

            font_manager,

            glyph_cache,

            &mut transform_stack,

            &mut clip_stack,

            &mut mask_stack,

            &mut scroll_offset_stack,

            render_state,

        )?;

    Ok(())

}

            return None;

    pub fn fill_rect(&mut self, x: i32, y: i32, w: i32, h: i32, r: u8, g: u8, b: u8, a: u8) {

        let pw = self.width as i32;

        let ph = self.height as i32;

        let x0 = x.max(0).min(pw);

        let y0 = y.max(0).min(ph);

        let x1 = (x + w).max(0).min(pw);

        let y1 = (y + h).max(0).min(ph);

        for row in y0..y1 {

            let start = (row * pw + x0) as usize * 4;

            let end = (row * pw + x1) as usize * 4;

            if end <= self.data.len() {

                for chunk in self.data[start..end].chunks_exact_mut(4) {

                    chunk[0] = r;

                    chunk[1] = g;

                    chunk[2] = b;

                    chunk[3] = a;

                }

            }

    }

    pub fn data_mut(&mut self) -> &mut [u8] {

        &mut self.data

    }

    pub fn resize_grow_only(

        &mut self,

        new_width: u32,

        new_height: u32,

        fill_r: u8, fill_g: u8, fill_b: u8, fill_a: u8,

    ) -> Option<()> {

        if new_width < self.width || new_height < self.height {

            return None;

        }

        if new_width == self.width && new_height == self.height {

            return Some(());

        }

        let old_w = self.width as usize;

        let old_h = self.height as usize;

        let new_w = new_width as usize;

        let new_h = new_height as usize;

        let mut new_data = vec![fill_a; new_w * new_h * 4];

        for chunk in new_data.chunks_exact_mut(4) {

            chunk[0] = fill_r;

            chunk[1] = fill_g;

            chunk[2] = fill_b;

            chunk[3] = fill_a;

        }

        let old_stride = old_w * 4;

        let new_stride = new_w * 4;

        for row in 0..old_h {

            let src = row * old_stride;

            let dst = row * new_stride;

            new_data[dst..dst + old_stride]

                .copy_from_slice(&self.data[src..src + old_stride]);

        }

        self.data = new_data;

        self.width = new_width;

        self.height = new_height;

        Some(())

    }

    pub fn resize_reuse(

        &mut self,

        new_width: u32,

        new_height: u32,

        fill_r: u8, fill_g: u8, fill_b: u8, fill_a: u8,

    ) {

        if new_width == self.width && new_height == self.height {

            return;

        }

        let old_w = self.width as usize;

        let old_h = self.height as usize;

        let new_w = new_width as usize;

        let new_h = new_height as usize;

        let new_stride = new_w * 4;

        let old_stride = old_w * 4;

        let mut new_data = vec![0u8; new_w * new_h * 4];

        for chunk in new_data.chunks_exact_mut(4) {

            chunk[0] = fill_r;

            chunk[1] = fill_g;

            chunk[2] = fill_b;

            chunk[3] = fill_a;

        }

        let copy_rows = old_h.min(new_h);

        let copy_cols_bytes = old_stride.min(new_stride);

        for row in 0..copy_rows {

            let src = row * old_stride;

            let dst = row * new_stride;

            new_data[dst..dst + copy_cols_bytes]

                .copy_from_slice(&self.data[src..src + copy_cols_bytes]);

        }

        self.data = new_data;

        self.width = new_width;

        self.height = new_height;

    }

                let mut rgba = Vec::with_capacity((width * height * 4) as usize);

                for chunk in buf[..info.buffer_size()].chunks_exact(3) {

                    rgba.push(chunk[0]);

                    rgba.push(chunk[1]);

                    rgba.push(chunk[2]);

                    rgba.push(255);

                }

                rgba

                let mut rgba = Vec::with_capacity((width * height * 4) as usize);

                for &v in &buf[..info.buffer_size()] {

                    rgba.push(v);

                    rgba.push(v);

                    rgba.push(v);

                    rgba.push(255);

                }

                rgba

            other => return Err(format!("Unsupported PNG color type: {:?}", other)),

    pub fn is_match(&self) -> bool {

        self.dimensions_match && self.diff_count == 0

    }

    pub fn diff_ratio(&self) -> f64 {

        if self.total_pixels == 0 { 0.0 }

        else { self.diff_count as f64 / self.total_pixels as f64 }

    }

        return PixelDiffResult {

            diff_count: 0,

            total_pixels: 0,

            max_delta: 0,

            dimensions_match: false,

            ref_width: reference.width,

            ref_height: reference.height,

            test_width: test.width,

            test_height: test.height,

        };

                pixel_differs = true;

                max_delta = delta;

            diff_count += 1;

pub fn compare_against_reference(

    rendered: &AzulPixmap,

    reference_png_path: &str,

    threshold: u8,

) -> Result<PixelDiffResult, String> {

    let ref_bytes = std::fs::read(reference_png_path)

        .map_err(|e| format!("Cannot read reference image {}: {}", reference_png_path, e))?;

    let reference = AzulPixmap::decode_png(&ref_bytes)?;

    Ok(pixel_diff(&reference, rendered, threshold))

}

            return None;

    fn clip(&self, clip: &AzRect) -> Option<AzRect> {

        let x1 = self.x.max(clip.x);

        let y1 = self.y.max(clip.y);

        let x2 = (self.x + self.width).min(clip.x + clip.width);

        let y2 = (self.y + self.height).min(clip.y + clip.height);

        if x2 > x1 && y2 > y1 {

            Some(AzRect { x: x1, y: y1, width: x2 - x1, height: y2 - y1 })

            None

    }

        rb.clip_box_i(

            c.x as i32,

            c.y as i32,

            (c.x + c.width) as i32 - 1,

            (c.y + c.height) as i32 - 1,

        );

fn agg_fill_transformed_path(

    pixmap: &mut AzulPixmap,

    path: &mut PathStorage,

    color: &Rgba8,

    rule: FillingRule,

    transform: &TransAffine,

) {

    agg_fill_transformed_path_clipped(pixmap, path, color, rule, transform, None);

}

fn agg_fill_transformed_path_clipped(

    pixmap: &mut AzulPixmap,