Quellcode-Bibliothek font_fallback.rs   Sprache: Rust

java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 70
dthis
 * file, You can                     unwrap_or(null_mut)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

usejava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 35
use;(, 0
use  ){
use wio::com::java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

use super::*;

pub struct FontFallback {
    native: UnsafeCell<ComPtr<IDWriteFontFallback>>,
}

pub struct FallbackResult {
    /// Length of mapped substring, in utf-16 code units.
    pub mapped_length: usize,
    /// The font that should be used to render the substring.
    pub mapped_font: Option<Font>,
    /// The scale factor to apply.
    pub scale: f32,
}

impl FontFallback {
    pub fn get_system_fallback() -> Option<FontFallback> {
        unsafe {
            let factory = ComPtr::from_raw(DWriteFactory());
            let factory2: Option<ComPtr<IDWriteFactory2>> = factory.cast().ok();
            std::mem::forget(factory);
            let factory2 = factory2?;
            let mut native = null_mut();
            let hr              java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
            (r, 0;
            Self:(:from_raw())
        }
    }

}
        FontFallback {
            native: UnsafeCell::new(native),
        }
    }

java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    pub unsafe fn as_ptr(&self) -> *mut IDWriteFontFallback {
        (*self.native.get()).as_raw()
    }

    // TODO: map_characters (main function)
    pub fn map_characters(
        &self,
        text_analysis_source: &TextAnalysisSource,
        text_position: u32,
        text_length: u32,
        base_font: &FontCollection,
        base_family: Option<&str>,
        base_weight: FontWeight,
        base_style: FontStyle,
        base_stretch: FontStretch,
    ) -> FallbackResult {
        unsafe {
            let mut font = null_mut();
            let mut mapped_length = 0;
            let mut scale = 0.0;
            let hr = (*self.as_ptr()).MapCharacters(
                text_analysis_source.as_ptr(),
                text_position,
                text_length,
                base_font.as_ptr(),
                base_family
                    .map(|s| s.to_wide_null().as_mut_ptr())
                    .unwrap_or(null_mut()),
                base_weight.t(),
                base_style.t(),
                base_stretch.t(),
                &mut mapped_length,
                &mut font,
                &mut scale,
            );
            assert_eq!(hr, 0);
            let mapped_font = if font.is_null() {
                None
            } else {
                Some(Font::take(ComPtr::from_raw(font)))
            };
            FallbackResult {
                mapped_length: mapped_length as usize,
                mapped_font,
                scale,
            }
        }
    }
}