& fallback_scaling
)
```
This function takes care of all the nitty-gritty of shaping a single line of
text. It takes the same font information input as `string_width()`, that is,
a `FontSettings` struct and size and res. It further accepts a number of vectors
where the shaping information will be written. `loc` will end up
containing the location of each glyph in pts starting from a (0, 0) origin.
Since the graphic engine only pass single lines to the graphic device at a time
then line breaking is not handled and for now all returned y positions are set
to 0.0 (this may change in the future depending on the development of the
graphic engine). The glyph id in the font file will be written to the `id`
vector You will need to use this to look up the glyph to render instead of
relying on the characters in the input string due to the potential substitution
and merging of glyphs happening during shaping. The `cluster` array is currently
unused (and will thus not be touched) but may in the future contain
identifications of which character in the input string relates to the provided
glyphs. The `font`, `fallback`, and `fallback_scaling` vectors will be filled
with information about the selected fonts for the shaping. The `font` vector
will map each glyph to a font in the `fallback` vector. The first element in the
`fallback` vector will be the requested font, and if any additional elements
exist it will be due to font fallback occurring. The `fallback_scaling` vector
is holding information about how the shaping of non-scalable fonts has been
scaled. It contains one element for each elements in `fallback`. If the value is
negative the font is scalable and no scaling of the metrics have occurred. If it
is positive it is the value that has been multiplied to the glyph metrics.
textshaping/R/ 0000755 0001762 0000144 00000000000 14510740320 013005 5 ustar ligges users textshaping/R/shape_text.R 0000644 0001762 0000144 00000022120 14006512173 015274 0 ustar ligges users #' Calculate glyph positions for strings
#'
#' @description
#' `r lifecycle::badge('experimental')`
#'
#' Do basic text shaping of strings. This function will use freetype to
#' calculate advances, doing kerning if possible. It will not perform any font
#' substitution or ligature resolving and will thus be much in line with how
#' the standard graphic devices does text shaping. Inputs are recycled to the
#' length of `strings`.
#'
#' @param strings A character vector of strings to shape
#' @param id A vector grouping the strings together. If strings share an id the
#' shaping will continue between strings
#' @inheritParams systemfonts::font_info
#' @param lineheight A multiplier for the lineheight
#' @param align Within text box alignment, either `'left'`, `'center'`, or
#' `'right'`
#' @param hjust,vjust The justification of the textbox surrounding the text
#' @param width The requested with of the string in inches. Setting this to
#' something other than `NA` will turn on word wrapping.
#' @param tracking Tracking of the glyphs (space adjustment) measured in 1/1000
#' em.
#' @param indent The indent of the first line in a paragraph measured in inches.
#' @param hanging The indent of the remaining lines in a paragraph measured in
#' inches.
#' @param space_before,space_after The spacing above and below a paragraph,
#' measured in points
#' @param path,index path an index of a font file to circumvent lookup based on
#' family and style
#'
#' @return
#' A list with two element: `shape` contains the position of each glyph,
#' relative to the origin in the enclosing textbox. `metrics` contain metrics
#' about the full strings.
#'
#' `shape` is a data.frame with the following columns:
#' \describe{
#' \item{glyph}{The glyph as a character}
#' \item{index}{The index of the glyph in the font file}
#' \item{metric_id}{The index of the string the glyph is part of (referencing a row in the `metrics` data.frame)}
#' \item{string_id}{The index of the string the glyph came from (referencing an element in the `strings` input)}
#' \item{x_offset}{The x offset in pixels from the origin of the textbox}
#' \item{y_offset}{The y offset in pixels from the origin of the textbox}
#' \item{x_mid}{The x offset in pixels to the middle of the glyph, measured from the origin of the glyph}
#' }
#'
#' `metrics` is a data.frame with the following columns:
#' \describe{
#' \item{string}{The text the string consist of}
#' \item{width}{The width of the string}
#' \item{height}{The height of the string}
#' \item{left_bearing}{The distance from the left edge of the textbox and the leftmost glyph}
#' \item{right_bearing}{The distance from the right edge of the textbox and the rightmost glyph}
#' \item{top_bearing}{The distance from the top edge of the textbox and the topmost glyph}
#' \item{bottom_bearing}{The distance from the bottom edge of the textbox and the bottommost glyph}
#' \item{left_border}{The position of the leftmost edge of the textbox related to the origin}
#' \item{top_border}{The position of the topmost edge of the textbox related to the origin}
#' \item{pen_x}{The horizontal position of the next glyph after the string}
#' \item{pen_y}{The vertical position of the next glyph after the string}
#' }
#'
#' @export
#'
#' @examples
#' string <- "This is a long string\nLook; It spans multiple lines\nand all"
#'
#' # Shape with default settings
#' shape_text(string)
#'
#' # Mix styles within the same string
#' string <- c(
#' "This string will have\na ",
#' "very large",
#' " text style\nin the middle"
#' )
#'
#' shape_text(string, id = c(1, 1, 1), size = c(12, 24, 12))
#'
shape_text <- function(strings, id = NULL, family = '', italic = FALSE,
bold = FALSE, size = 12, res = 72, lineheight = 1,
align = 'left', hjust = 0, vjust = 0, width = NA,
tracking = 0, indent = 0, hanging = 0, space_before = 0,
space_after = 0, path = NULL, index = 0) {
n_strings = length(strings)
if (is.null(id)) id <- seq_len(n_strings)
id <- rep_len(id, n_strings)
id <- match(id, unique(id))
if (anyNA(id)) {
stop('id must be a vector of valid integers', call. = FALSE)
}
ido <- order(id)
id <- id[ido]
strings <- as.character(strings)[ido]
if (is.null(path)) {
if (all(c(length(family), length(italic), length(bold)) == 1)) {
loc <- systemfonts::match_font(family, italic, bold)
path <- loc$path
index <- loc$index
} else {
family <- rep_len(family, n_strings)
italic <- rep_len(italic, n_strings)
bold <- rep_len(bold, n_strings)
loc <- Map(systemfonts::match_font, family = family, italic = italic, bold = bold)
path <- vapply(loc, `[[`, character(1L), 1, USE.NAMES = FALSE)[ido]
index <- vapply(loc, `[[`, integer(1L), 2, USE.NAMES = FALSE)[ido]
}
} else {
if (!all(c(length(path), length(index)) == 1)) {
path <- rep_len(path, n_strings)[ido]
index <- rep_len(index, n_strings)[ido]
}
}
if (length(size) != 1) size <- rep_len(size, n_strings)[ido]
if (length(res) != 1) res <- rep_len(res, n_strings)[ido]
if (length(lineheight) != 1) lineheight <- rep_len(lineheight, n_strings)[ido]
align <- match.arg(align, c('left', 'center', 'right'), TRUE)
align <- match(align, c('left', 'center', 'right'))
if (length(align) != 1) align <- rep_len(align, n_strings)[ido]
if (length(hjust) != 1) hjust <- rep_len(hjust, n_strings)[ido]
if (length(vjust) != 1) vjust <- rep_len(vjust, n_strings)[ido]
if (length(width) != 1) width <- rep_len(width, n_strings)[ido]
width[is.na(width)] <- -1
if (length(tracking) != 1) tracking <- rep_len(tracking, n_strings)[ido]
if (length(indent) != 1) indent <- rep_len(indent, n_strings)[ido]
if (length(hanging) != 1) hanging <- rep_len(hanging, n_strings)[ido]
if (length(space_before) != 1) space_before <- rep_len(space_before, n_strings)[ido]
if (length(space_after) != 1) space_after <- rep_len(space_after, n_strings)[ido]
width <- width * res
indent <- indent * res
hanging <- hanging * res
if (!all(file.exists(path))) stop("path must point to a valid file", call. = FALSE)
shape <- get_string_shape_c(
strings, id, path, as.integer(index), as.numeric(size), as.numeric(res),
as.numeric(lineheight), as.integer(align) - 1L, as.numeric(hjust),
as.numeric(vjust), as.numeric(width), as.numeric(tracking),
as.numeric(indent), as.numeric(hanging), as.numeric(space_before),
as.numeric(space_after)
)
if (nrow(shape$shape) == 0) return(shape)
shape$metrics$string <- vapply(split(strings, id), paste, character(1), collapse = '')
shape$shape$string_id <- ido[shape$shape$string_id]
shape$shape <- shape$shape[order(shape$shape$string_id), , drop = FALSE]
#shape$shape$glyph <- intToUtf8(shape$shape$glyph, multiple = TRUE)
shape$shape$x_offset <- shape$shape$x_offset * (72 / res)
shape$shape$y_offset <- shape$shape$y_offset * (72 / res)
shape$shape$x_midpoint <- shape$shape$x_midpoint * (72 / res)
shape
}
#' Calculate the width of a string, ignoring new-lines
#'
#' This is a very simple alternative to [shape_string()] that simply calculates
#' the width of strings without taking any newline into account. As such it is
#' suitable to calculate the width of words or lines that has already been
#' splitted by `\n`. Input is recycled to the length of `strings`.
#'
#' @inheritParams systemfonts::font_info
#' @param strings A character vector of strings
#' @param include_bearing Logical, should left and right bearing be included in
#' the string width?
#'
#' @return A numeric vector giving the width of the strings in pixels. Use the
#' provided `res` value to convert it into absolute values.
#'
#' @export
#'
#' @examples
#' strings <- c('A short string', 'A very very looong string')
#' text_width(strings)
#'
text_width <- function(strings, family = '', italic = FALSE, bold = FALSE,
size = 12, res = 72, include_bearing = TRUE, path = NULL,
index = 0) {
n_strings <- length(strings)
if (is.null(path)) {
if (all(c(length(family), length(italic), length(bold)) == 1)) {
loc <- systemfonts::match_font(family, italic, bold)
path <- loc$path
index <- loc$index
} else {
family <- rep_len(family, n_strings)
italic <- rep_len(italic, n_strings)
bold <- rep_len(bold, n_strings)
loc <- Map(systemfonts::match_font, family = family, italic = italic, bold = bold)
path <- vapply(loc, `[[`, character(1L), 1, USE.NAMES = FALSE)
index <- vapply(loc, `[[`, integer(1L), 2, USE.NAMES = FALSE)
}
} else {
if (!all(c(length(path), length(index)) == 1)) {
path <- rep_len(path, n_strings)
index <- rep_len(index, n_strings)
}
}
if (length(size) != 1) size <- rep_len(size, n_strings)
if (length(res) != 1) res <- rep_len(res, n_strings)
if (length(include_bearing) != 1) include_bearing <- rep_len(include_bearing, n_strings)
if (!all(file.exists(path))) stop("path must point to a valid file", call. = FALSE)
get_line_width_c(
as.character(strings), path, as.integer(index), as.numeric(size),
as.numeric(res), as.logical(include_bearing)
)
}
textshaping/R/textshaping-package.R 0000644 0001762 0000144 00000000442 13734677572 017110 0 ustar ligges users #' @keywords internal
"_PACKAGE"
# The following block is used by usethis to automatically manage
# roxygen namespace tags. Modify with care!
## usethis namespace: start
#' @useDynLib textshaping, .registration = TRUE
#' @importFrom systemfonts system_fonts
## usethis namespace: end
NULL
textshaping/R/aaa.R 0000644 0001762 0000144 00000000350 13753507707 013672 0 ustar ligges users release_bullets <- function() {
c(
'`rhub::check_on_solaris(env_vars = c("_R_CHECK_FORCE_SUGGESTS_" = "false"))`',
'`rhub::check_with_valgrind(env_vars = c(VALGRIND_OPTS = "--leak-check=full --track-origins=yes"))`'
)
}
textshaping/R/cpp11.R 0000644 0001762 0000144 00000001225 14510740320 014054 0 ustar ligges users # Generated by cpp11: do not edit by hand
get_face_features_c <- function(path, index) {
.Call(`_textshaping_get_face_features_c`, path, index)
}
get_string_shape_c <- function(string, id, path, index, size, res, lineheight, align, hjust, vjust, width, tracking, indent, hanging, space_before, space_after) {
.Call(`_textshaping_get_string_shape_c`, string, id, path, index, size, res, lineheight, align, hjust, vjust, width, tracking, indent, hanging, space_before, space_after)
}
get_line_width_c <- function(string, path, index, size, res, include_bearing) {
.Call(`_textshaping_get_line_width_c`, string, path, index, size, res, include_bearing)
}
textshaping/R/font_features.R 0000644 0001762 0000144 00000003162 13720020600 015770 0 ustar ligges users #' Get available OpenType features in a font
#'
#' This is a simply functions that returns the available OpenType feature tags
#' for one or more fonts. See [`font_feature()`][systemfonts::font_feature] for
#' more information on how to use the different feature with a font.
#'
#' @inheritParams systemfonts::font_info
#'
#' @return A list with an element for each of the input fonts containing the
#' supported feature tags for that font.
#'
#' @importFrom systemfonts match_font
#' @export
#'
#' @examples
#' # Select a random font on the system
#' sys_fonts <- systemfonts::system_fonts()
#' random_font <- sys_fonts$family[sample(nrow(sys_fonts), 1)]
#'
#' # Get the features
#' get_font_features(random_font)
#'
get_font_features <- function(family = '', italic = FALSE, bold = FALSE,
path = NULL, index = 0) {
if (is.null(path)) {
full_length <- max(length(family), length(italic), length(bold))
if (full_length == 1) {
loc <- match_font(family, italic, bold)
path <- loc$path
index <- loc$index
} else {
family <- rep_len(family, full_length)
italic <- rep_len(italic, full_length)
bold <- rep_len(bold, full_length)
loc <- Map(match_font, family = family, italic = italic, bold = bold)
path <- vapply(loc, `[[`, character(1L), 1, USE.NAMES = FALSE)
index <- vapply(loc, `[[`, integer(1L), 2, USE.NAMES = FALSE)
}
} else {
full_length <- max(length(path), length(index))
path <- rep_len(path, full_length)
index <- rep_len(index, full_length)
}
lapply(get_face_features_c(as.character(path), as.integer(index)), unique)
}
textshaping/NEWS.md 0000644 0001762 0000144 00000002517 14510740772 013722 0 ustar ligges users # textshaping 0.3.7
* Prepare for Arm Windows
# textshaping 0.3.6
* Fix a bug in fallback font loading which would crash the process if the font
failed to load (#23)
* Fixed bug that would reset fallback to the original font for short strings
(#25)
# textshaping 0.3.5
* Address an UBCSAN issue in packages linking to textshaping
* Remove a few compiler warnings
# textshaping 0.3.4
* Prepare textshaping for UCRT support
* Address upstream changes in cpp11
# textshaping 0.3.3
* Support static linking on macOS (#17, @jeroen)
# textshaping 0.3.2
* Avoid overindexing fallbacks when no fallback is found
# textshaping 0.3.1
* Try to avoid ASAN issue reported by CRAN
# textshaping 0.3.0
* Add support for performing font fallback as part of the single-line shaping
* Provide support for non-scalable fonts
# textshaping 0.2.1
* Fix issues with the Solaris mock solution
# textshaping 0.2.0
* Update C API to prepare for font fallback
* Make sure it compiles on Solaris without system dependencies
# textshaping 0.1.2
* Fix a bug in the interaction with the systemfonts font cache that could cause
random crashes on some mac installations.
# textshaping 0.1.1
* Small changes to comply with next cpp11 version
# textshaping 0.1.0
* First release. Provide access to HarfBuzz shaping and FriBidi bidirectional
script support.
textshaping/MD5 0000644 0001762 0000144 00000005001 14511003546 013113 0 ustar ligges users 5fda8bf1f24499b2eacce69ad49fe917 *DESCRIPTION
38658af2499f1780bb9f1586ab95a939 *LICENSE
fc0493ada33f1e1178890b4f0469e120 *NAMESPACE
f272bd9a9d92a6e33de244d0634bf6dd *NEWS.md
3cdfcedc32dc8d2928eff42ab0a3b6bf *R/aaa.R
4cce499f2c314a68991f0cddfd5c7d18 *R/cpp11.R
69bc51cc86c2aaf6b57c6cf9afa01c42 *R/font_features.R
76bed6d3d027641c019531490e0a1c07 *R/shape_text.R
377383f1194400cd367aa2179278e110 *R/textshaping-package.R
a871008abd64e26780eb0ef6110f8a3e *README.md
6a6339732cbd1c52f590d6259021af8c *build/vignette.rds
8fedab5931036be90e6ff98113518359 *cleanup
b8ae4f780f000469c9767692fc9566d0 *configure
3c9e2d06e8560272e30c98b0c827478b *inst/doc/c_interface.R
53f397f83d34bac25a463944ebed33cd *inst/doc/c_interface.Rmd
61ed44df4d30306f4143e2faa2e33224 *inst/doc/c_interface.html
01b664ff9df4ae7d423f1bd0c14100fb *inst/include/textshaping.h
cb1e46f469cfbbbde29c8b5113e1d789 *man/figures/lifecycle-archived.svg
c0d2e5a54f1fa4ff02bf9533079dd1f7 *man/figures/lifecycle-defunct.svg
a1b8c987c676c16af790f563f96cbb1f *man/figures/lifecycle-deprecated.svg
c3978703d8f40f2679795335715e98f4 *man/figures/lifecycle-experimental.svg
952b59dc07b171b97d5d982924244f61 *man/figures/lifecycle-maturing.svg
27b879bf3677ea76e3991d56ab324081 *man/figures/lifecycle-questioning.svg
53b3f893324260b737b3c46ed2a0e643 *man/figures/lifecycle-stable.svg
1c1fe7a759b86dc6dbcbe7797ab8246c *man/figures/lifecycle-superseded.svg
c133a270dc1b71b167024fd39dab737f *man/get_font_features.Rd
036740619525db3fe3e3b5dea958da41 *man/shape_text.Rd
215b7e33ec51984e374dc9285e379aeb *man/text_width.Rd
7b5f7475e9625d04808b9ca2d6923660 *man/textshaping-package.Rd
cc18986c4e1452a0271a288286379ef4 *src/Makevars.in
e454b8d8e9abd7b89a0204782134a1f4 *src/Makevars.win
48efff0cee3d1c6f89a3b5ff3354f715 *src/cache_lru.h
68b8239ba1f0ba79cfaf02581c7eda66 *src/cpp11.cpp
a9c63ad033e0923f693b947a8b6db973 *src/face_feature.cpp
b828ba4493df04539e8c025afe9a399b *src/face_feature.h
85c1c789268626413a7f6c83fc2d97fc *src/hb_shaper.cpp
7dcce7900ea26f0b6ddf77500c123eca *src/hb_shaper.h
39054766e1da4fbe98f064a018a81958 *src/init.cpp
13e1783c7b9198be0d421f2a6fd30f39 *src/string_bidi.cpp
96cab9d24d19732554287f96e75fd14a *src/string_bidi.h
86bee2b79a2128f76c894202fbec51f5 *src/string_metrics.cpp
e41bab9452b13b4d65f780a891d27880 *src/string_metrics.h
51a6f4e26c152cce3adb142fea924497 *src/string_shape.cpp
dd7664858e6e86f07af92ad11ea425fc *src/string_shape.h
a97ba99eaca7f130d80de3dc3743cd7d *src/utils.h
4c4ae954ec118afe315b00b91f278391 *tools/winlibs.R
53f397f83d34bac25a463944ebed33cd *vignettes/c_interface.Rmd
textshaping/inst/ 0000755 0001762 0000144 00000000000 14510741207 013566 5 ustar ligges users textshaping/inst/doc/ 0000755 0001762 0000144 00000000000 14510741207 014333 5 ustar ligges users textshaping/inst/doc/c_interface.R 0000644 0001762 0000144 00000000217 14510741207 016720 0 ustar ligges users ## ---- include = FALSE---------------------------------------------------------
knitr::opts_chunk$set(
collapse = TRUE,
comment = "#>"
)
textshaping/inst/doc/c_interface.html 0000644 0001762 0000144 00000036055 14510741207 017474 0 ustar ligges users
textshaping C interface
textshaping C interface
textshaping is predominantly intended to be used by other packages
implementing graphic devicees and calling it from the C level. As such
it exports a set of functions that match the needs of graphic devices.
The C API builds upon that of systemfonts and you’ll thus need to link
to both packages to access it succesfully. This is done with the
LinkingTo field in the DESCRIPTION file:
LinkingTo:
systemfonts,
textshaping
You will further need to make sure that both packages are loaded when
you need to use the C API. This is most easily done by importing a
function from each package into your namespace.
In your C/C++ code you’ll then have
#include <textshaping.h> to get access to the
functions described below. The functions are available in the
textshaping namespace.
The C API expects fonts to be given as FontSettings
structs which can be obtained from the systemfonts C API with
locate_font_with_features(). This makes it possible to both
get access to the font file location along with potential OpenType
features registered to the font.
String width
int string_width(
const char* string,
FontSettings font_info,
double size,
double res,
int include_bearing,
double* width
)
This function calculates the width of a string, ignoring any newlines
(these are automatically being handled by the graphic engine). It takes
a UTF-8 encoded string, along with a FontSettings struct to use for
shaping the string before calculating the width. It also take a size in
pt and a res in ppi for setting the size. In addition it takes an
include_bearing flag to control whether the bearings of the first and
last character should be taken into account (this is recommended by the
graphic engine). It will write the width in pts to the passed in pointer
and return 0 if successful.
String shape
int string_shape(
const char* string,
FontSettings font_info,
double size,
double res,
std::vector<Point>& loc,
std::vector<uint32_t>& id,
std::vector<int>& cluster,
std::vector<unsigned int>& font,
std::vector<FontSettings>& fallbacks,
std::vector<double>& fallback_scaling
)
This function takes care of all the nitty-gritty of shaping a single
line of text. It takes the same font information input as
string_width(), that is, a FontSettings struct
and size and res. It further accepts a number of vectors where the
shaping information will be written. loc will end up
containing the location of each glyph in pts starting from a (0, 0)
origin. Since the graphic engine only pass single lines to the graphic
device at a time then line breaking is not handled and for now all
returned y positions are set to 0.0 (this may change in the future
depending on the development of the graphic engine). The glyph id in the
font file will be written to the id vector You will need to
use this to look up the glyph to render instead of relying on the
characters in the input string due to the potential substitution and
merging of glyphs happening during shaping. The cluster
array is currently unused (and will thus not be touched) but may in the
future contain identifications of which character in the input string
relates to the provided glyphs. The font,
fallback, and fallback_scaling vectors will be
filled with information about the selected fonts for the shaping. The
font vector will map each glyph to a font in the
fallback vector. The first element in the
fallback vector will be the requested font, and if any
additional elements exist it will be due to font fallback occurring. The
fallback_scaling vector is holding information about how
the shaping of non-scalable fonts has been scaled. It contains one
element for each elements in fallback. If the value is
negative the font is scalable and no scaling of the metrics have
occurred. If it is positive it is the value that has been multiplied to
the glyph metrics.
textshaping/inst/doc/c_interface.Rmd 0000644 0001762 0000144 00000010243 14006506145 017241 0 ustar ligges users ---
title: "textshaping C interface"
output: rmarkdown::html_vignette
vignette: >
%\VignetteIndexEntry{textshaping C interface}
%\VignetteEngine{knitr::rmarkdown}
%\VignetteEncoding{UTF-8}
---
```{r, include = FALSE}
knitr::opts_chunk$set(
collapse = TRUE,
comment = "#>"
)
```
textshaping is predominantly intended to be used by other packages implementing
graphic devicees and calling it from the C level. As such it exports a set of
functions that match the needs of graphic devices. The C API builds upon that of
systemfonts and you'll thus need to link to both packages to access it
succesfully. This is done with the `LinkingTo` field in the `DESCRIPTION` file:
```
LinkingTo:
systemfonts,
textshaping
```
You will further need to make sure that both packages are loaded when you need
to use the C API. This is most easily done by importing a function from each
package into your namespace.
In your C/C++ code you'll then have `#include ` to get access to
the functions described below. The functions are available in the `textshaping`
namespace.
The C API expects fonts to be given as `FontSettings` structs which can be
obtained from the systemfonts C API with `locate_font_with_features()`. This
makes it possible to both get access to the font file location along with
potential OpenType features registered to the font.
## String width
```C
int string_width(
const char* string,
FontSettings font_info,
double size,
double res,
int include_bearing,
double* width
)
```
This function calculates the width of a string, ignoring any newlines (these are
automatically being handled by the graphic engine). It takes a UTF-8 encoded
string, along with a FontSettings struct to use for shaping the string before
calculating the width. It also take a size in pt and a res in ppi for setting
the size. In addition it takes an include_bearing flag to control whether the
bearings of the first and last character should be taken into account (this is
recommended by the graphic engine). It will write the width in pts to the passed
in pointer and return 0 if successful.
## String shape
```C
int string_shape(
const char* string,
FontSettings font_info,
double size,
double res,
std::vector& loc,
std::vector& id,
std::vector& cluster,
std::vector& font,
std::vector& fallbacks,
std::vector& fallback_scaling
)
```
This function takes care of all the nitty-gritty of shaping a single line of
text. It takes the same font information input as `string_width()`, that is,
a `FontSettings` struct and size and res. It further accepts a number of vectors
where the shaping information will be written. `loc` will end up
containing the location of each glyph in pts starting from a (0, 0) origin.
Since the graphic engine only pass single lines to the graphic device at a time
then line breaking is not handled and for now all returned y positions are set
to 0.0 (this may change in the future depending on the development of the
graphic engine). The glyph id in the font file will be written to the `id`
vector You will need to use this to look up the glyph to render instead of
relying on the characters in the input string due to the potential substitution
and merging of glyphs happening during shaping. The `cluster` array is currently
unused (and will thus not be touched) but may in the future contain
identifications of which character in the input string relates to the provided
glyphs. The `font`, `fallback`, and `fallback_scaling` vectors will be filled
with information about the selected fonts for the shaping. The `font` vector
will map each glyph to a font in the `fallback` vector. The first element in the
`fallback` vector will be the requested font, and if any additional elements
exist it will be due to font fallback occurring. The `fallback_scaling` vector
is holding information about how the shaping of non-scalable fonts has been
scaled. It contains one element for each elements in `fallback`. If the value is
negative the font is scalable and no scaling of the metrics have occurred. If it
is positive it is the value that has been multiplied to the glyph metrics.
textshaping/inst/include/ 0000755 0001762 0000144 00000000000 14147726340 015220 5 ustar ligges users textshaping/inst/include/textshaping.h 0000644 0001762 0000144 00000006404 14060125341 017717 0 ustar ligges users #pragma once
#define R_NO_REMAP
#include
#include
#include
#include
#include
#include
#include
#include
namespace textshaping {
struct Point {
double x;
double y;
};
// Calculate the width of a string based on a fontfile, index, size, and
// resolution. Writes it to width, and returns 0 if successful
static inline int string_width(const char* string, FontSettings font_info,
double size, double res, int include_bearing,
double* width) {
static int (*p_ts_string_width)(const char*, FontSettings, double, double, int, double*) = NULL;
if (p_ts_string_width == NULL) {
p_ts_string_width = (int (*)(const char*, FontSettings, double, double, int, double*)) R_GetCCallable("textshaping", "ts_string_width");
}
return p_ts_string_width(string, font_info, size, res, include_bearing, width);
}
// Calculate glyph positions and id in the font file for a string based on a
// fontfile, index, size, and resolution, and writes it to the x and y arrays.
// Returns 0 if successful.
static inline int string_shape(const char* string, FontSettings font_info,
double size, double res, std::vector& loc,
std::vector& id, std::vector& cluster,
std::vector& font, std::vector& fallbacks,
std::vector& fallback_scaling) {
static int (*p_ts_string_shape)(const char*, FontSettings, double, double, std::vector&, std::vector&, std::vector&, std::vector&, std::vector&, std::vector&) = NULL;
if (p_ts_string_shape == NULL) {
p_ts_string_shape = (int (*)(const char*, FontSettings, double, double, std::vector&, std::vector&, std::vector&, std::vector&, std::vector&, std::vector&)) R_GetCCallable("textshaping", "ts_string_shape_new");
}
return p_ts_string_shape(string, font_info, size, res, loc, id, cluster, font, fallbacks, fallback_scaling);
}
}
// Old API ---------------------------------------------------------------------
static inline int ts_string_width(const char* string, FontSettings font_info,
double size, double res, int include_bearing,
double* width) {
return textshaping::string_width(string, font_info, size, res, include_bearing, width);
}
static inline int ts_string_shape(const char* string, FontSettings font_info,
double size, double res, double* x, double* y,
int* id, int* cluster, int* n_glyphs,
unsigned int max_length) {
static int (*p_ts_string_shape)(const char*, FontSettings, double, double, double*, double*, int*, int*, unsigned int) = NULL;
if (p_ts_string_shape == NULL) {
p_ts_string_shape = (int (*)(const char*, FontSettings, double, double, double*, double*, int*, int*, unsigned int)) R_GetCCallable("textshaping", "ts_string_shape");
}
return p_ts_string_shape(string, font_info, size, res, x, y, id, n_glyphs, max_length);
}
textshaping/cleanup 0000755 0001762 0000144 00000000047 14510741210 014161 0 ustar ligges users #!/bin/sh
rm -f autobrew configure.log
textshaping/configure 0000755 0001762 0000144 00000006327 14510741210 014522 0 ustar ligges users #! /bin/sh
# Anticonf (tm) script by Jeroen Ooms and Thomas Lin Pedersen(2020)
# This script will query 'pkg-config' for the required cflags and ldflags.
# If pkg-config is unavailable or does not find the library, try setting
# INCLUDE_DIR and LIB_DIR manually via e.g:
# R CMD INSTALL --configure-vars='INCLUDE_DIR=/.../include LIB_DIR=/.../lib'
# Library settings
PKG_CONFIG_NAME="harfbuzz freetype2 fribidi"
PKG_DEB_NAME="libharfbuzz-dev libfribidi-dev"
PKG_RPM_NAME="harfbuzz-devel fribidi-devel"
PKG_CSW_NAME="libharfbuzz_dev libfribidi_dev"
PKG_BREW_NAME="harfbuzz fribidi"
PKG_TEST_HEADER="#include "
PKG_LIBS="-lfreetype -lharfbuzz -lfribidi -lpng"
# Support static linking for binary packages on MacOS
if [ `uname` = "Darwin" ]; then
PKG_CONFIG_NAME="--static $PKG_CONFIG_NAME"
fi
# Use pkg-config if available
if [ "`command -v pkg-config`" ]; then
PKGCONFIG_CFLAGS="`pkg-config --cflags --silence-errors ${PKG_CONFIG_NAME}`"
PKGCONFIG_LIBS="`pkg-config --libs ${PKG_CONFIG_NAME}`"
fi
# Note that cflags may be empty in case of success
if [ "$INCLUDE_DIR" ] || [ "$LIB_DIR" ]; then
echo "Found INCLUDE_DIR and/or LIB_DIR!"
PKG_CFLAGS="-I$INCLUDE_DIR $PKG_CFLAGS"
PKG_LIBS="-L$LIB_DIR $PKG_LIBS"
elif [ "$PKGCONFIG_CFLAGS" ] || [ "$PKGCONFIG_LIBS" ]; then
echo "Found pkg-config cflags and libs!"
PKG_CFLAGS="${PKGCONFIG_CFLAGS}"
PKG_LIBS="${PKGCONFIG_LIBS}"
elif [ "`uname`" = "Darwin" ]; then
test ! "$CI" && brew --version 2>/dev/null
if [ $? -eq 0 ]; then
BREWDIR="`brew --prefix`"
PKG_CFLAGS="-I$BREWDIR/include/freetype2 -I$BREWDIR/include/harfbuzz -I$BREWDIR/include/glib-2.0 -I$BREWDIR/include/fribidi"
else
curl -sfL "https://autobrew.github.io/scripts/harfbuzz" > autobrew
. autobrew
fi
fi
# For debugging
echo "Using PKG_CFLAGS=$PKG_CFLAGS"
echo "Using PKG_LIBS=$PKG_LIBS"
# Find compiler
CC="`${R_HOME}/bin/R CMD config CC`"
CFLAGS="`${R_HOME}/bin/R CMD config CFLAGS`"
CPPFLAGS="`${R_HOME}/bin/R CMD config CPPFLAGS`"
# Test configuration
echo "$PKG_TEST_HEADER" | ${CC} ${CPPFLAGS} ${PKG_CFLAGS} ${CFLAGS} -E -xc - >/dev/null 2>configure.log
# Customize the error
if [ $? -ne 0 ]; then
if [ "`uname`" = "SunOS" ]; then
PKG_CFLAGS="$PKG_CFLAGS -DNO_HARFBUZZ_FRIBIDI"
PKG_LIBS=""
else
echo "--------------------------- [ANTICONF] --------------------------------"
echo "Configuration failed to find the $PKG_CONFIG_NAME library. Try installing:"
echo " * deb: $PKG_DEB_NAME (Debian, Ubuntu, etc)"
echo " * rpm: $PKG_RPM_NAME (Fedora, EPEL)"
echo " * csw: $PKG_CSW_NAME (Solaris)"
echo " * brew: $PKG_BREW_NAME (OSX)"
echo "If $PKG_CONFIG_NAME is already installed, check that 'pkg-config' is in your"
echo "PATH and PKG_CONFIG_PATH contains a $PKG_CONFIG_NAME.pc file. If pkg-config"
echo "is unavailable you can set INCLUDE_DIR and LIB_DIR manually via:"
echo "R CMD INSTALL --configure-vars='INCLUDE_DIR=... LIB_DIR=...'"
echo "-------------------------- [ERROR MESSAGE] ---------------------------"
cat configure.log
echo "--------------------------------------------------------------------"
exit 1
fi
fi
# Write to Makevars
sed -e "s|@cflags@|$PKG_CFLAGS|" -e "s|@libs@|$PKG_LIBS|" src/Makevars.in > src/Makevars
# Success
exit 0