blitz-pdf 0.1.6 → 0.1.7

package/vendor/fontique/src/impl_fontconfig.rs

@@ -0,0 +1,159 @@
+// Copyright 2025 the Parley Authors
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+//! Fontconfig numeric value conversions.
+//!
+//! The numeric values used here are based on the `fonts.conf` documentation:
+//! <https://www.freedesktop.org/software/fontconfig/fontconfig-user.html>.
+
+use crate::{FontStyle, FontWeight, FontWidth};
+
+/// Conversion from Fontconfig numeric values.
+///
+/// This is intentionally kept in `fontique` (rather than `parlance`) because it is a
+/// Fontconfig-specific mapping.
+///
+/// The numeric values used by these conversions are based on the `fonts.conf` documentation:
+/// <https://www.freedesktop.org/software/fontconfig/fontconfig-user.html>.
+pub trait FromFontconfig: Sized {
+    /// Creates a value from the corresponding Fontconfig numeric representation.
+    ///
+    /// The numeric values are determined based on the `fonts.conf` documentation:
+    /// <https://www.freedesktop.org/software/fontconfig/fontconfig-user.html>.
+    fn from_fontconfig(value: i32) -> Self;
+}
+
+impl FromFontconfig for FontWeight {
+    /// Creates a new weight attribute with the given value from Fontconfig.
+    ///
+    /// The values are determined based on the `fonts.conf` documentation:
+    /// <https://www.freedesktop.org/software/fontconfig/fontconfig-user.html>.
+    fn from_fontconfig(weight: i32) -> Self {
+        // A selection of OpenType weights (first) and their corresponding fontconfig value (second)
+        // Invariant: The fontconfig values are sorted.
+        const MAP: &[(i32, i32)] = &[
+            (0, 0),
+            (100, 0),
+            (200, 40),
+            (300, 50),
+            (350, 55),
+            (380, 75),
+            (400, 80),
+            (500, 100),
+            (600, 180),
+            (700, 200),
+            (800, 205),
+            (900, 210),
+            (950, 215),
+        ];
+
+        for i in 1..MAP.len() {
+            let (ot_b, fc_b) = MAP[i];
+            if weight == fc_b {
+                return Self::new(ot_b as f32);
+            }
+
+            // Linear interpolation if not an exact match.
+            if weight < fc_b {
+                let weight = weight as f32;
+                let fc_b = fc_b as f32;
+                let ot_b = ot_b as f32;
+
+                let (ot_a, fc_a) = MAP[i - 1];
+                let fc_a = fc_a as f32;
+                let ot_a = ot_a as f32;
+
+                let t = (weight - fc_a) / (fc_b - fc_a);
+                return Self::new(ot_a + (ot_b - ot_a) * t);
+            }
+        }
+
+        Self::EXTRA_BLACK
+    }
+}
+
+impl FromFontconfig for FontWidth {
+    /// Creates a new width attribute with the given value from Fontconfig.
+    ///
+    /// The values are determined based on the `fonts.conf` documentation:
+    /// <https://www.freedesktop.org/software/fontconfig/fontconfig-user.html>.
+    fn from_fontconfig(width: i32) -> Self {
+        match width {
+            50 => Self::ULTRA_CONDENSED,
+            63 => Self::EXTRA_CONDENSED,
+            75 => Self::CONDENSED,
+            87 => Self::SEMI_CONDENSED,
+            100 => Self::NORMAL,
+            113 => Self::SEMI_EXPANDED,
+            125 => Self::EXPANDED,
+            150 => Self::EXTRA_EXPANDED,
+            200 => Self::ULTRA_EXPANDED,
+            _ => Self::from_ratio(width as f32 / 100.0),
+        }
+    }
+}
+
+impl FromFontconfig for FontStyle {
+    /// Creates a new style attribute with the given value from Fontconfig.
+    ///
+    /// The values are determined based on the `fonts.conf` documentation:
+    /// <https://www.freedesktop.org/software/fontconfig/fontconfig-user.html>.
+    fn from_fontconfig(slant: i32) -> Self {
+        match slant {
+            100 => Self::Italic,
+            110 => Self::Oblique(None),
+            _ => Self::Normal,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::FromFontconfig;
+    use crate::{FontStyle, FontWeight, FontWidth};
+    use alloc::string::ToString;
+
+    #[test]
+    fn fontwidth_from_fontconfig() {
+        fn check_fc(fc: i32, s: &str) {
+            let fs = FontWidth::from_fontconfig(fc);
+            assert_eq!(s, fs.to_string());
+        }
+
+        check_fc(50, "ultra-condensed");
+        check_fc(63, "extra-condensed");
+        check_fc(75, "condensed");
+        check_fc(87, "semi-condensed");
+        check_fc(100, "normal");
+        check_fc(113, "semi-expanded");
+        check_fc(125, "expanded");
+        check_fc(150, "extra-expanded");
+        check_fc(200, "ultra-expanded");
+    }
+
+    #[test]
+    fn fontstyle_from_fontconfig() {
+        fn check_fc(fc: i32, s: &str) {
+            let fs = FontStyle::from_fontconfig(fc);
+            assert_eq!(s, fs.to_string());
+        }
+
+        check_fc(0, "normal");
+        check_fc(100, "italic");
+        check_fc(110, "oblique");
+    }
+
+    #[test]
+    fn fontweight_from_fontconfig_interpolates_monotonically() {
+        let demilight = FontWeight::from_fontconfig(55);
+        assert!(demilight > FontWeight::LIGHT);
+        assert!(demilight < FontWeight::NORMAL);
+
+        let book = FontWeight::from_fontconfig(75);
+        assert!(book > demilight);
+        assert!(book < FontWeight::NORMAL);
+
+        let extrablack = FontWeight::from_fontconfig(215);
+        assert!(extrablack > FontWeight::BLACK);
+    }
+}

package/vendor/fontique/src/lib.rs

@@ -0,0 +1,87 @@
+// Copyright 2024 the Parley Authors
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+//! Font enumeration and fallback.
+
+// LINEBENDER LINT SET - lib.rs - v4
+// See https://linebender.org/wiki/canonical-lints/
+// These lints shouldn't apply to examples or tests.
+#![cfg_attr(not(test), warn(unused_crate_dependencies))]
+// These lints shouldn't apply to examples.
+#![warn(clippy::print_stdout, clippy::print_stderr)]
+// Targeting e.g. 32-bit means structs containing usize can give false positives for 64-bit.
+#![cfg_attr(target_pointer_width = "64", warn(clippy::trivially_copy_pass_by_ref))]
+// END LINEBENDER LINT SET
+#![cfg_attr(docsrs, feature(doc_cfg))]
+#![no_std]
+#![allow(unsafe_code, reason = "We access platform libraries using ffi.")]
+#![allow(missing_docs, reason = "We have many as-yet undocumented items.")]
+#![expect(
+    missing_debug_implementations,
+    unnameable_types,
+    unreachable_pub,
+    clippy::allow_attributes_without_reason,
+    clippy::cast_possible_truncation,
+    reason = "Deferred"
+)]
+#![allow(
+    single_use_lifetimes,
+    reason = "False positive: https://github.com/rust-lang/rust/issues/129255"
+)]
+
+#[cfg(not(any(feature = "std", feature = "libm")))]
+compile_error!("fontique requires either the `std` or `libm` feature to be enabled");
+
+extern crate alloc;
+
+#[cfg(feature = "std")]
+extern crate std;
+
+mod attributes;
+mod backend;
+mod charmap;
+mod collection;
+mod fallback;
+mod family;
+mod family_name;
+mod font;
+mod generic;
+mod impl_fontconfig;
+mod matching;
+mod scan;
+mod script;
+mod source;
+
+mod source_cache;
+
+pub use linebender_resource_handle::Blob;
+pub use script::ScriptExt;
+
+pub use attributes::Attributes;
+pub use charmap::{Charmap, CharmapIndex};
+pub use collection::{Collection, CollectionOptions, Query, QueryFamily, QueryFont, QueryStatus};
+pub use fallback::FallbackKey;
+pub use family::{FamilyId, FamilyInfo};
+pub use font::{AxisInfo, FontInfo, FontInfoOverride, Synthesis};
+pub use impl_fontconfig::FromFontconfig;
+pub use parlance::{FontStyle, FontWeight, FontWidth, GenericFamily, Language, Script};
+pub use source::{SourceId, SourceInfo, SourceKind};
+
+#[cfg(all(feature = "system", target_vendor = "apple"))]
+use objc2 as _;
+pub use source_cache::{SourceCache, SourceCacheOptions};
+
+#[cfg(not(target_has_atomic = "64"))]
+use core::sync::atomic::AtomicU32 as AtomicCounter;
+#[cfg(target_has_atomic = "64")]
+use core::sync::atomic::AtomicU64 as AtomicCounter;
+
+/// The integer type underlying [`AtomicCounter`].
+///
+/// This is `u32` on platforms without 64-bit atomics (e.g. many 32-bit
+/// targets) and `u64` elsewhere.
+#[cfg(not(target_has_atomic = "64"))]
+type CounterInt = u32;
+/// The integer type underlying [`AtomicCounter`].
+#[cfg(target_has_atomic = "64")]
+type CounterInt = u64;