appcore-filemaker 0.1.0-beta.1

Deterministic declarative document, canvas, and dataset compiler for AppCore
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

// =============================================================================
//        #######
//     ###       ###     F: pdf_paint.rs
//    ##   ## ##   ##    P: AppCore-Runtime
//         ## ##
//                       C: 2026/09/02 20:00:00 by dnettoRaw
//    ##   ## ##   ##    U: 2026/09/02 20:00:00 by dnettoRaw
//      ###########      S: 1.0.2-rc
// =============================================================================

//! Applies resolved colors and opacity resources without changing geometry.

use std::collections::{BTreeMap, BTreeSet};

use pdf_writer::{Content, Name};

use super::pdf::opacity_name;
use crate::{Color, ResolvedElement, ResolvedPage};

pub(super) fn collect_opacities(pages: &[&ResolvedPage]) -> BTreeSet<u32> {
    pages
        .iter()
        .flat_map(|page| &page.elements)
        .flat_map(element_opacities)
        .filter(|opacity| *opacity < 1_000_000)
        .collect()
}

fn element_opacities(element: &ResolvedElement) -> Vec<u32> {
    let mut values: Vec<_> = [
        element.style.fill,
        element.style.stroke,
        Some(element.style.color),
    ]
    .into_iter()
    .flatten()
    .map(|color| effective_opacity(element.style.opacity, color))
    .collect();
    if let Some(table) = &element.table {
        for cell in table
            .header
            .iter()
            .chain(table.rows.iter().flat_map(|row| &row.cells))
            .chain(&table.totals)
        {
            values.extend(
                [cell.style.fill, cell.style.stroke, Some(cell.style.color)]
                    .into_iter()
                    .flatten()
                    .map(|color| effective_opacity(cell.style.opacity, color)),
            );
        }
    }
    values
}

pub(super) fn effective_opacity(opacity: u32, color: Color) -> u32 {
    let alpha = match color {
        Color::Rgba { a, .. } => u32::from(a) * 1_000_000 / 255,
        _ => 1_000_000,
    };
    (u64::from(opacity) * u64::from(alpha) / 1_000_000).min(1_000_000) as u32
}

pub(super) fn apply_opacity(
    content: &mut Content,
    opacity: u32,
    available: &BTreeMap<u32, pdf_writer::Ref>,
) {
    if available.contains_key(&opacity) {
        content.set_parameters(Name(opacity_name(opacity).as_bytes()));
    }
}

pub(super) fn set_fill(content: &mut Content, color: Color) {
    match color {
        Color::Rgb { r, g, b } | Color::Rgba { r, g, b, .. } => {
            content.set_fill_rgb(channel(r), channel(g), channel(b))
        }
        Color::Gray { value } => content.set_fill_gray(channel(value)),
        Color::Cmyk { c, m, y, k } => content.set_fill_cmyk(
            c as f32 / 1_000_000.0,
            m as f32 / 1_000_000.0,
            y as f32 / 1_000_000.0,
            k as f32 / 1_000_000.0,
        ),
    };
}

pub(super) fn set_stroke(content: &mut Content, color: Color) {
    match color {
        Color::Rgb { r, g, b } | Color::Rgba { r, g, b, .. } => {
            content.set_stroke_rgb(channel(r), channel(g), channel(b))
        }
        Color::Gray { value } => content.set_stroke_gray(channel(value)),
        Color::Cmyk { c, m, y, k } => content.set_stroke_cmyk(
            c as f32 / 1_000_000.0,
            m as f32 / 1_000_000.0,
            y as f32 / 1_000_000.0,
            k as f32 / 1_000_000.0,
        ),
    };
}

fn channel(value: u8) -> f32 {
    f32::from(value) / 255.0
}