use std::cell::UnsafeCell;
use std::mem::{self, zeroed};
use std::slice;
use std::{error, fmt, ptr};
use winapi::ctypes::c_void;
use winapi::shared::minwindef::{BOOL, FALSE, TRUE};
use winapi::shared::winerror::S_OK;
use winapi::um::dcommon::DWRITE_MEASURING_MODE;
use winapi::um::dwrite::IDWriteRenderingParams;
use winapi::um::dwrite::DWRITE_FONT_FACE_TYPE_TRUETYPE;
use winapi::um::dwrite::{IDWriteFontFace, IDWriteFontFile};
use winapi::um::dwrite::{DWRITE_FONT_FACE_TYPE_BITMAP, DWRITE_FONT_FACE_TYPE_CFF};
use winapi::um::dwrite::{DWRITE_FONT_FACE_TYPE_RAW_CFF, DWRITE_FONT_FACE_TYPE_TYPE1};
use winapi::um::dwrite::{DWRITE_FONT_FACE_TYPE_TRUETYPE_COLLECTION, DWRITE_FONT_FACE_TYPE_VECTOR};
use winapi::um::dwrite::{DWRITE_FONT_SIMULATIONS, DWRITE_GLYPH_METRICS};
use winapi::um::dwrite::{DWRITE_GLYPH_OFFSET, DWRITE_MATRIX, DWRITE_RENDERING_MODE};
use winapi::um::dwrite::{DWRITE_RENDERING_MODE_DEFAULT, DWRITE_RENDERING_MODE_NATURAL_SYMMETRIC};
use winapi::um::dwrite_1::IDWriteFontFace1;
use winapi::um::dwrite_3::{
IDWriteFontFace5, IDWriteFontResource, DWRITE_FONT_AXIS_ATTRIBUTES_VARIABLE,
DWRITE_FONT_AXIS_VALUE,
};
use winapi::um::winnt::HRESULT;
use winapi::Interface;
use wio::com::ComPtr;
use super::{DWriteFactory, DefaultDWriteRenderParams, FontFile, FontMetrics};
use crate::com_helpers::Com;
use crate::geometry_sink_impl::GeometrySinkImpl;
use crate::outline_builder::OutlineBuilder;
use crate::FontSimulations;
pub struct FontFace {
native: UnsafeCell<ComPtr<IDWriteFontFace>>,
face1: UnsafeCell<Option<ComPtr<IDWriteFontFace1>>>,
face5: UnsafeCell<Option<ComPtr<IDWriteFontFace5>>>,
}
impl FontFace {
pub fn take(native: ComPtr<IDWriteFontFace>) -> FontFace {
let cell = UnsafeCell::new(native);
FontFace {
native: cell,
face1: UnsafeCell::new(None),
face5: UnsafeCell::new(None),
}
}
pub unsafe fn as_ptr(&self) -> *mut IDWriteFontFace {
(*self.native.get()).as_raw()
}
unsafe fn raw_files(&self) -> Result<Vec<*mut IDWriteFontFile>, HRESULT> {
let mut number_of_files: u32 = 0;
let hr = (*self.native.get()).GetFiles(&mut number_of_files, ptr::null_mut());
if hr != S_OK {
return Err(hr);
}
let mut file_ptrs: Vec<*mut IDWriteFontFile> =
vec![ptr::null_mut(); number_of_files as usize];
let hr = (*self.native.get()).GetFiles(&mut number_of_files, file_ptrs.as_mut_ptr());
if hr != S_OK {
return Err(hr);
}
Ok(file_ptrs)
}
#[deprecated(note = "Use `files` instead.")]
pub fn get_files(&self) -> Vec<FontFile> {
self.files().unwrap()
}
pub fn files(&self) -> Result<Vec<FontFile>, HRESULT> {
unsafe {
self.raw_files().map(|file_ptrs| {
file_ptrs
.iter()
.map(|p| FontFile::take(ComPtr::from_raw(*p)))
.collect()
})
}
}
pub fn create_font_face_with_simulations(
&self,
simulations: DWRITE_FONT_SIMULATIONS,
) -> FontFace {
unsafe {
let file_ptrs = self.raw_files().unwrap();
let face_type = (*self.native.get()).GetType();
let face_index = (*self.native.get()).GetIndex();
let mut face: *mut IDWriteFontFace = ptr::null_mut();
let hr = (*DWriteFactory()).CreateFontFace(
face_type,
file_ptrs.len() as u32,
file_ptrs.as_ptr(),
face_index,
simulations,
&mut face,
);
for p in file_ptrs {
let _ = ComPtr::<IDWriteFontFile>::from_raw(p);
}
assert!(hr == 0);
FontFace::take(ComPtr::from_raw(face))
}
}
pub fn get_glyph_count(&self) -> u16 {
unsafe { (*self.native.get()).GetGlyphCount() }
}
pub fn metrics(&self) -> FontMetrics {
unsafe {
let font_1 = self.get_face1();
match font_1 {
None => {
let mut metrics = mem::zeroed();
(*self.native.get()).GetMetrics(&mut metrics);
FontMetrics::Metrics0(metrics)
}
Some(font_1) => {
let mut metrics_1 = mem::zeroed();
font_1.GetMetrics(&mut metrics_1);
FontMetrics::Metrics1(metrics_1)
}
}
}
}
#[deprecated(note = "Use `glyph_indices` instead.")]
pub fn get_glyph_indices(&self, code_points: &[u32]) -> Vec<u16> {
self.glyph_indices(code_points).unwrap()
}
pub fn glyph_indices(&self, code_points: &[u32]) -> Result<Vec<u16>, HRESULT> {
let mut glyph_indices: Vec<u16> = vec![0; code_points.len()];
unsafe {
let hr = (*self.native.get()).GetGlyphIndices(
code_points.as_ptr(),
code_points.len() as u32,
glyph_indices.as_mut_ptr(),
);
if hr != S_OK {
return Err(hr);
}
Ok(glyph_indices)
}
}
#[deprecated(note = "Use `design_glyph_metrics` instead.")]
pub fn get_design_glyph_metrics(
&self,
glyph_indices: &[u16],
is_sideways: bool,
) -> Vec<DWRITE_GLYPH_METRICS> {
self.design_glyph_metrics(glyph_indices, is_sideways)
.unwrap()
}
pub fn design_glyph_metrics(
&self,
glyph_indices: &[u16],
is_sideways: bool,
) -> Result<Vec<DWRITE_GLYPH_METRICS>, HRESULT> {
unsafe {
let mut metrics: Vec<DWRITE_GLYPH_METRICS> = vec![zeroed(); glyph_indices.len()];
let hr = (*self.native.get()).GetDesignGlyphMetrics(
glyph_indices.as_ptr(),
glyph_indices.len() as u32,
metrics.as_mut_ptr(),
is_sideways as BOOL,
);
if hr != S_OK {
return Err(hr);
}
Ok(metrics)
}
}
#[deprecated(note = "Use `gdi_compatible_glyph_metrics` instead.")]
pub fn get_gdi_compatible_glyph_metrics(
&self,
em_size: f32,
pixels_per_dip: f32,
transform: *const DWRITE_MATRIX,
use_gdi_natural: bool,
glyph_indices: &[u16],
is_sideways: bool,
) -> Vec<DWRITE_GLYPH_METRICS> {
self.gdi_compatible_glyph_metrics(
em_size,
pixels_per_dip,
transform,
use_gdi_natural,
glyph_indices,
is_sideways,
)
.unwrap()
}
pub fn gdi_compatible_glyph_metrics(
&self,
em_size: f32,
pixels_per_dip: f32,
transform: *const DWRITE_MATRIX,
use_gdi_natural: bool,
glyph_indices: &[u16],
is_sideways: bool,
) -> Result<Vec<DWRITE_GLYPH_METRICS>, HRESULT> {
unsafe {
let mut metrics: Vec<DWRITE_GLYPH_METRICS> = vec![zeroed(); glyph_indices.len()];
let hr = (*self.native.get()).GetGdiCompatibleGlyphMetrics(
em_size,
pixels_per_dip,
transform,
use_gdi_natural as BOOL,
glyph_indices.as_ptr(),
glyph_indices.len() as u32,
metrics.as_mut_ptr(),
is_sideways as BOOL,
);
if hr != S_OK {
return Err(hr);
}
Ok(metrics)
}
}
#[deprecated(note = "Use `font_table` instead.")]
pub fn get_font_table(&self, opentype_table_tag: u32) -> Option<Vec<u8>> {
self.font_table(opentype_table_tag).unwrap()
}
pub fn font_table(&self, opentype_table_tag: u32) -> Result<Option<Vec<u8>>, HRESULT> {
let mut table_data_ptr: *const u8 = ptr::null_mut();
let mut table_size: u32 = 0;
let mut table_context: *mut c_void = ptr::null_mut();
let mut exists: BOOL = FALSE;
unsafe {
let hr = (*self.native.get()).TryGetFontTable(
opentype_table_tag,
&mut table_data_ptr as *mut *const _ as *mut *const c_void,
&mut table_size,
&mut table_context,
&mut exists,
);
if hr != S_OK {
return Err(hr);
}
if exists == FALSE {
return Ok(None);
}
let table_bytes = slice::from_raw_parts(table_data_ptr, table_size as usize).to_vec();
(*self.native.get()).ReleaseFontTable(table_context);
Ok(Some(table_bytes))
}
}
pub fn get_recommended_rendering_mode(
&self,
em_size: f32,
pixels_per_dip: f32,
measure_mode: DWRITE_MEASURING_MODE,
rendering_params: *mut IDWriteRenderingParams,
) -> DWRITE_RENDERING_MODE {
unsafe {
let mut render_mode: DWRITE_RENDERING_MODE = DWRITE_RENDERING_MODE_DEFAULT;
let hr = (*self.native.get()).GetRecommendedRenderingMode(
em_size,
pixels_per_dip,
measure_mode,
rendering_params,
&mut render_mode,
);
if hr != S_OK {
return DWRITE_RENDERING_MODE_NATURAL_SYMMETRIC;
}
render_mode
}
}
pub fn get_recommended_rendering_mode_default_params(
&self,
em_size: f32,
pixels_per_dip: f32,
measure_mode: DWRITE_MEASURING_MODE,
) -> DWRITE_RENDERING_MODE {
self.get_recommended_rendering_mode(
em_size,
pixels_per_dip,
measure_mode,
DefaultDWriteRenderParams(),
)
}
#[deprecated(note = "Use `glyph_run_outline` instead.")]
pub fn get_glyph_run_outline(
&self,
em_size: f32,
glyph_indices: &[u16],
glyph_advances: Option<&[f32]>,
glyph_offsets: Option<&[DWRITE_GLYPH_OFFSET]>,
is_sideways: bool,
is_right_to_left: bool,
outline_builder: Box<dyn OutlineBuilder>,
) {
self.glyph_run_outline(
em_size,
glyph_indices,
glyph_advances,
glyph_offsets,
is_sideways,
is_right_to_left,
outline_builder,
)
.unwrap()
}
pub fn glyph_run_outline(
&self,
em_size: f32,
glyph_indices: &[u16],
glyph_advances: Option<&[f32]>,
glyph_offsets: Option<&[DWRITE_GLYPH_OFFSET]>,
is_sideways: bool,
is_right_to_left: bool,
outline_builder: Box<dyn OutlineBuilder>,
) -> Result<(), GlyphRunOutlineError> {
let glyph_advances = match glyph_advances {
None => ptr::null(),
Some(glyph_advances) => {
if glyph_advances.len() != glyph_indices.len() {
return Err(GlyphRunOutlineError::InvalidInput);
}
glyph_advances.as_ptr()
}
};
let glyph_offsets = match glyph_offsets {
None => ptr::null(),
Some(glyph_offsets) => {
if glyph_offsets.len() != glyph_indices.len() {
return Err(GlyphRunOutlineError::InvalidInput);
}
glyph_offsets.as_ptr()
}
};
let is_sideways = if is_sideways { TRUE } else { FALSE };
let is_right_to_left = if is_right_to_left { TRUE } else { FALSE };
let geometry_sink = GeometrySinkImpl::new(outline_builder);
let geometry_sink = geometry_sink.into_interface();
unsafe {
let hr = (*self.native.get()).GetGlyphRunOutline(
em_size,
glyph_indices.as_ptr(),
glyph_advances,
glyph_offsets,
glyph_indices.len() as u32,
is_sideways,
is_right_to_left,
geometry_sink,
);
if hr != S_OK {
return Err(GlyphRunOutlineError::Win32Error(hr));
}
}
Ok(())
}
pub fn has_kerning_pairs(&self) -> bool {
unsafe {
match self.get_face1() {
Some(face1) => face1.HasKerningPairs() == TRUE,
None => false,
}
}
}
#[deprecated(note = "Use `glyph_pair_kerning_adjustment` instead.")]
pub fn get_glyph_pair_kerning_adjustment(&self, first_glyph: u16, second_glyph: u16) -> i32 {
self.glyph_pair_kerning_adjustment(first_glyph, second_glyph)
.unwrap()
}
pub fn glyph_pair_kerning_adjustment(
&self,
first_glyph: u16,
second_glyph: u16,
) -> Result<i32, HRESULT> {
unsafe {
match self.get_face1() {
Some(face1) => {
let mut adjustments = [0; 2];
let hr = face1.GetKerningPairAdjustments(
2,
[first_glyph, second_glyph].as_ptr(),
adjustments.as_mut_ptr(),
);
if hr != S_OK {
return Err(hr);
}
Ok(adjustments[0])
}
None => Ok(0),
}
}
}
#[inline]
pub fn get_type(&self) -> FontFaceType {
unsafe {
match (*self.native.get()).GetType() {
DWRITE_FONT_FACE_TYPE_CFF => FontFaceType::Cff,
DWRITE_FONT_FACE_TYPE_RAW_CFF => FontFaceType::RawCff,
DWRITE_FONT_FACE_TYPE_TRUETYPE => FontFaceType::TrueType,
DWRITE_FONT_FACE_TYPE_TRUETYPE_COLLECTION => FontFaceType::TrueTypeCollection,
DWRITE_FONT_FACE_TYPE_TYPE1 => FontFaceType::Type1,
DWRITE_FONT_FACE_TYPE_VECTOR => FontFaceType::Vector,
DWRITE_FONT_FACE_TYPE_BITMAP => FontFaceType::Bitmap,
_ => FontFaceType::Unknown,
}
}
}
#[inline]
pub fn get_index(&self) -> u32 {
unsafe { (*self.native.get()).GetIndex() }
}
#[inline]
unsafe fn get_face1(&self) -> Option<ComPtr<IDWriteFontFace1>> {
self.get_interface(&self.face1)
}
#[inline]
unsafe fn get_face5(&self) -> Option<ComPtr<IDWriteFontFace5>> {
self.get_interface(&self.face5)
}
#[inline]
unsafe fn get_interface<I: Interface>(
&self,
interface: &UnsafeCell<Option<ComPtr<I>>>,
) -> Option<ComPtr<I>> {
if (*interface.get()).is_none() {
*interface.get() = (*self.native.get()).cast().ok()
}
(*interface.get()).clone()
}
pub fn has_variations(&self) -> bool {
unsafe {
match self.get_face5() {
Some(face5) => face5.HasVariations() == TRUE,
None => false,
}
}
}
pub fn variations(&self) -> Result<Vec<DWRITE_FONT_AXIS_VALUE>, HRESULT> {
let face5 = unsafe { self.get_face5() };
let Some(face5) = face5 else {
return Ok(vec![]);
};
if unsafe { face5.HasVariations() != TRUE } {
return Ok(vec![]);
}
let axis_count = unsafe { face5.GetFontAxisValueCount() as usize };
if axis_count == 0 {
return Ok(vec![]);
}
let mut resource: *mut IDWriteFontResource = ptr::null_mut();
let hr = unsafe { face5.GetFontResource(&mut resource) };
if hr != S_OK || resource.is_null() {
return Err(hr);
}
let mut axis_values = Vec::with_capacity(axis_count);
axis_values.resize(
axis_count,
DWRITE_FONT_AXIS_VALUE {
axisTag: 0,
value: 0.,
},
);
let hr = unsafe { face5.GetFontAxisValues(axis_values.as_mut_ptr(), axis_count as u32) };
if hr != S_OK {
return Err(hr);
}
let resource = unsafe { &*resource };
Ok(axis_values
.iter()
.enumerate()
.filter_map(|(index, axis_value)| {
let attributes = unsafe { resource.GetFontAxisAttributes(index as u32) };
if attributes & DWRITE_FONT_AXIS_ATTRIBUTES_VARIABLE == 0 {
None
} else {
Some(*axis_value)
}
})
.collect())
}
pub fn create_font_face_with_variations(
&self,
simulations: DWRITE_FONT_SIMULATIONS,
axis_values: &[DWRITE_FONT_AXIS_VALUE],
) -> Option<FontFace> {
unsafe {
if let Some(face5) = self.get_face5() {
let mut resource: *mut IDWriteFontResource = ptr::null_mut();
let hr = face5.GetFontResource(&mut resource);
if hr == S_OK && !resource.is_null() {
let resource = ComPtr::from_raw(resource);
let mut var_face: *mut IDWriteFontFace5 = ptr::null_mut();
let hr = resource.CreateFontFace(
simulations,
axis_values.as_ptr(),
axis_values.len() as u32,
&mut var_face,
);
if hr == S_OK && !var_face.is_null() {
let var_face = ComPtr::from_raw(var_face).cast().unwrap();
return Some(FontFace::take(var_face));
}
}
}
None
}
}
pub fn simulations(&self) -> FontSimulations {
unsafe {
std::mem::transmute::<DWRITE_FONT_SIMULATIONS, FontSimulations>(
(*self.native.get()).GetSimulations(),
)
}
}
}
impl Clone for FontFace {
fn clone(&self) -> FontFace {
unsafe {
FontFace {
native: UnsafeCell::new((*self.native.get()).clone()),
face1: UnsafeCell::new(None),
face5: UnsafeCell::new(None),
}
}
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum FontFaceType {
Unknown,
Cff,
RawCff,
TrueType,
TrueTypeCollection,
Type1,
Vector,
Bitmap,
}
#[derive(Debug)]
pub enum GlyphRunOutlineError {
InvalidInput,
Win32Error(HRESULT),
}
impl fmt::Display for GlyphRunOutlineError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::InvalidInput => write!(f, "Invalid input"),
Self::Win32Error(code) => write!(f, "{:#x}", code),
}
}
}
impl error::Error for GlyphRunOutlineError {}