|⧘kGSf63IgN'wټY=FⒻ#1@F6Zf1mR!r
p ^f D\H9#XF8t@I N7y_SO3zHt? /az<$Ix|;jه@sG$Q%%)s㺜'^g{>wxU""&vff
*ǻ 8uFX4҉CFt*ۢI/!#[TB{nIa(A2 P jXP@rvI51jNX҅s^Lc'(LD iG b qIDPJNAA( _@ ҼTKI3f vn 7}7q6uwn#Pa2U^!J -oR^
6Yϳd 6|cݞɕc
@ $ަ^
B|&L#rцfc 3tt9U|}4te˿%5.c 5rlO4~ ;x T;ia7]8G8p&"I8]b By0| .91IA$Y}U5Mf͛5W{r52d>8&Z `9;f%d -b¢t< iv?PM2HM+etB˗.\WfI& e`az| Z@|Mz}'}W d](HfA. do not edit by hand
# Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393
str_extents_ <- function(x, fontname = "sans", fontsize = 12, bold = FALSE, italic = FALSE, fontfile = "") {
.Call('_gdtools_str_extents_', PACKAGE = 'gdtools', x, fontname, fontsize, bold, italic, fontfile)
}
str_metrics_ <- function(x, fontname = "sans", fontsize = 12, bold = FALSE, italic = FALSE, fontfile = "") {
.Call('_gdtools_str_metrics_', PACKAGE = 'gdtools', x, fontname, fontsize, bold, italic, fontfile)
}
m_str_extents_ <- function(x, fontname, fontsize, bold, italic, fontfile) {
.Call('_gdtools_m_str_extents_', PACKAGE = 'gdtools', x, fontname, fontsize, bold, italic, fontfile)
}
glyphs_match_ <- function(x, fontname = "sans", bold = FALSE, italic = FALSE, fontfile = "") {
.Call('_gdtools_glyphs_match_', PACKAGE = 'gdtools', x, fontname, bold, italic, fontfile)
}
context_create <- function() {
.Call('_gdtools_context_create', PACKAGE = 'gdtools')
}
context_set_font <- function(cc, fontname, fontsize, bold, italic, fontfile = "") {
.Call('_gdtools_context_set_font', PACKAGE = 'gdtools', cc, fontname, fontsize, bold, italic, fontfile)
}
context_extents <- function(cc, x) {
.Call('_gdtools_context_extents', PACKAGE = 'gdtools', cc, x)
}
raster_to_str <- function(raster, w, h, width, height, interpolate) {
.Call('_gdtools_raster_to_str', PACKAGE = 'gdtools', raster, w, h, width, height, interpolate)
}
raster_to_file <- function(raster, w, h, width, height, interpolate, filename) {
.Call('_gdtools_raster_to_file', PACKAGE = 'gdtools', raster, w, h, width, height, interpolate, filename)
}
raster_png_ <- function(raster_, w, h, width, height, interpolate, filename) {
.Call('_gdtools_raster_png_', PACKAGE = 'gdtools', raster_, w, h, width, height, interpolate, filename)
}
base64_raster_encode <- function(raster_, w, h, width, height, interpolate) {
.Call('_gdtools_base64_raster_encode', PACKAGE = 'gdtools', raster_, w, h, width, height, interpolate)
}
base64_file_encode <- function(filename) {
.Call('_gdtools_base64_file_encode', PACKAGE = 'gdtools', filename)
}
base64_string_encode <- function(string) {
.Call('_gdtools_base64_string_encode', PACKAGE = 'gdtools', string)
}
#' @rdname version_cairo
#' @export
version_freetype <- function() {
.Call('_gdtools_version_freetype', PACKAGE = 'gdtools')
}
version_cairo_ <- function() {
.Call('_gdtools_version_cairo_', PACKAGE = 'gdtools')
}
# Register entry points for exported C++ functions
methods::setLoadAction(function(ns) {
.Call('_gdtools_RcppExport_registerCCallable', PACKAGE = 'gdtools')
})
gdtools/R/font_family_exists.R 0000644 0001762 0000144 00000001757 14373655132 016202 0 ustar ligges users #' @title Check if font family exists.
#'
#' @description Check if a font family exists in system fonts.
#'
#' @return A logical value
#' @param font_family font family name (case sensitive)
#' @examples
#' font_family_exists("sans")
#' font_family_exists("Arial")
#' font_family_exists("Courier")
#' @export
#' @importFrom systemfonts match_font system_fonts
font_family_exists <- function( font_family = "sans" ){
datafonts <- sys_fonts()
tolower(font_family) %in% tolower(datafonts$family)
}
#' @title List fonts for 'systemfonts'.
#'
#' @description List system and registryfonts details into a data.frame
#' containing columns foundry, family, file, slant and weight.
#' @examples
#' sys_fonts()
#' @export
#' @importFrom systemfonts system_fonts registry_fonts
sys_fonts <- function() {
db_sys <- system_fonts()
db_reg <- registry_fonts()
nam <- intersect(colnames(db_sys), colnames(db_reg))
db_sys <- db_sys[,nam]
db_reg <- db_reg[,nam]
font_db <- rbind(db_sys, db_reg)
font_db
}
gdtools/R/fontconfig.R 0000644 0001762 0000144 00000002413 14373654614 014422 0 ustar ligges users #' Find best family match with systemfonts
#'
#' \code{match_family()} returns the best font family match.
#'
#' @param font family or face to match.
#' @param bold Wheter to match a font featuring a \code{bold} face.
#' @param italic Wheter to match a font featuring an \code{italic} face.
#' @param debug deprecated
#' @export
#' @examples
#' match_family("sans")
#' match_family("serif")
#' @importFrom systemfonts match_font system_fonts
match_family <- function(font = "sans", bold = TRUE, italic = TRUE, debug = NULL) {
font <- match_font(font, bold = bold, italic = italic)
sysfonts <- system_fonts()
match <- which( sysfonts$path %in% font$path )
sysfonts$family[match[1]]
}
#' Set and unset a minimalistic Fontconfig configuration
#'
#' @note
#' Fontconfig is not used anymore and these functions will be deprecated
#' in the next release.
#' @export
set_dummy_conf <- function() {
}
#' @rdname set_dummy_conf
#' @export
unset_dummy_conf <- function() {
}
#' @export
#' @title reload Fontconfig configuration
#' @description This function can be used to make fontconfig
#' reload font configuration files.
#' @note
#' Fontconfig is not used anymore and that function will be deprecated
#' in the next release.
#' @author Paul Murrell
fontconfig_reinit <- function() {
}
gdtools/R/fonts.R 0000644 0001762 0000144 00000020462 14535104271 013410 0 ustar ligges users #' @importFrom htmltools htmlDependency
#' @importFrom utils packageVersion
#' @export
#' @title 'Google Font' HTML dependency
#' @description Create an HTML dependency ready
#' to be used in 'Shiny' or 'R Markdown'.
#' @details
#' It allows users to use fonts from 'Google Fonts' in an HTML page generated by 'shiny' or 'R Markdown'.
#' At the first request, the font files will be downloaded and stored in a cache on the
#' user's machine, thus avoiding many useless downloads or allowing to work with
#' these fonts afterwards without an Internet connection, in a docker image for example.
#' See [fonts_cache_dir()].
#'
#' The server delivering the font files should not be too busy. That's
#' why a one second pause is added after each download to respect the server's
#' limits. This time can be set with the option `GFONTS_DOWNLOAD_SLEEPTIME` which
#' must be a number of seconds.
#' @param family family name of a 'Google Fonts', for example, "Open Sans", "Roboto",
#' "Fira Code" or "Fira Sans Condensed". Complete list is available with the
#' following command:
#'
#' ```
#' gfonts::get_all_fonts()$family |>
#' unlist() |>
#' unique() |>
#' sort()
#' ```
#' @param subset font subset, a character vector, it defaults to only "latin" and
#' "latin-ext" and can contains values such as "greek", "emoji", "chinese-traditional",
#'
#' Run the following code to get a complete list:
#' ```
#' gfonts::get_all_fonts()$subsets |> unlist() |> unique() |> sort()
#' ```
#'
#' @family functions for font management
#' @return an object defined with [htmlDependency()].
#' @examples
#' \dontrun{
#' if (curl::has_internet()) {
#' dummy_setup()
#' gfontHtmlDependency(family = "Open Sans")
#' }
#' }
gfontHtmlDependency <- function(family = "Open Sans", subset = c("latin", "latin-ext")) {
pkg_version <- packageVersion("gdtools")
pkg_version_str <- format(pkg_version)
register_gfont(family = family, subset = subset)
x <- gfonts_summary()
font_id <- x[x$family %in% family, ]$id
htmlDependency(
all_files = TRUE,
name = font_id,
version = pkg_version_str,
src = file.path(fonts_cache_dir(), font_id),
stylesheet = paste0("css/", font_id, ".css")
)
}
#' @export
#' @title 'Liberation Sans' Font HTML dependency
#' @description Create an HTML dependency ready
#' to be used in 'Shiny' or 'R Markdown' with
#' 'Liberation Sans' Font.
#' @seealso [gfontHtmlDependency()]
#' @family functions for font management
liberationsansHtmlDependency <- function() {
pkg_version <- packageVersion("gdtools")
pkg_version_str <- format(pkg_version)
font_id <- "liberation-sans"
htmlDependency(
all_files = TRUE,
name = font_id,
version = pkg_version_str,
src = file.path(fonts_cache_dir(), font_id),
stylesheet = paste0("css/", font_id, ".css")
)
}
#' @export
#' @importFrom htmltools tags attachDependencies
#' @title Use a font in Shiny or Markdown
#' @description Add an empty HTML element attached
#' to an 'HTML Dependency' containing
#' the css and the font files so that the font is available
#' in the HTML page. Multiple families are supported.
#'
#' The htmlDependency is defined with function [gfontHtmlDependency()].
#' @inherit gfontHtmlDependency params details
#' @return an HTML object
#' @family functions for font management
#' @examples
#' \dontrun{
#' if (curl::has_internet()) {
#' dummy_setup()
#' addGFontHtmlDependency(family = "Open Sans")
#' }
#' }
addGFontHtmlDependency <- function(family = "Open Sans", subset = c("latin", "latin-ext")) {
attachDependencies(
x = tags$style(""),
lapply(family, gfontHtmlDependency, subset = subset)
)
}
#' @importFrom systemfonts register_font
#' @export
#' @title Register a 'Google Fonts'
#' @description Register a font from 'Google Fonts' so that it can be used
#' with devices using the 'systemfonts' package, i.e. the 'flextable'
#' package and graphic outputs generated with the 'ragg', 'svglite'
#' and 'ggiraph' packages.
#' @inherit gfontHtmlDependency params details
#' @return TRUE if the operation went ok.
#' @family functions for font management
#' @examples
#' \dontrun{
#' if (curl::has_internet()) {
#' dummy_setup()
#' register_gfont(family = "Roboto")
#' }
#' }
register_gfont <- function(family = "Open Sans", subset = c("latin", "latin-ext")) {
x <- gfonts_summary()
font_id <- x[x$family %in% family, ]$id
faces <- reduce_faces(x[x$id %in% font_id, ]$variants[[1]])
font_to_cache(family = family, faces = faces, subset = subset)
files <- lapply(faces, function(face) {
list.files(
path = font_dir(font_id),
pattern = paste0(font_id, "(.*)-", face, "\\.ttf"),
full.names = TRUE
)
})
if (!font_family_exists(family)) {
files[["name"]] <- family
do.call(register_font, files)
}
font_family_exists(family)
}
#' @export
#' @title Shell command to install a font from 'Google Fonts'
#' @description Create a string containing a system command to execute
#' so that the font from 'Google Fonts' is installed on the system.
#' Its execution may require root permissions, in dockerfile for example.
#' @inherit gfontHtmlDependency params details
#' @param platform "debian" and "windows" and "macos" are supported.
#' @param file script file to generate, optional. If the parameter is
#' specified, a file will be generated ready for execution. If the
#' platform is Windows, administration rights are required to run
#' the script.
#' @return the 'shell' or 'PowerShell' command as a string
#' @family functions for font management
#' @examples
#' \dontrun{
#' if (curl::has_internet()) {
#' dummy_setup()
#' install_gfont_script(family = "Roboto", platform = "macos")
#' }
#' }
install_gfont_script <- function(family = "Open Sans",
subset = c("latin", "latin-ext"),
platform = c("debian", "windows", "macos"),
file = NULL) {
platform <- match.arg(platform)
x <- gfonts_summary()
font_id <- x[x$family %in% family, ]$id
faces <- reduce_faces(x[x$id %in% font_id, ]$variants[[1]])
font_to_cache(family = family, faces = faces, subset = subset)
if ("debian" %in% platform) {
str <- debian_sysinstall_command(font_id, dir = "custom-fonts")
} else if ("windows" %in% platform) {
str <- windows_sysinstall_command(font_id)
} else {
str <- macos_sysinstall_command(font_id, dir = if (user_cache_exists()) "~/Library/Fonts" else "/Library/Fonts")
}
if (!is.null(file)) {
writeLines(str, file, useBytes = TRUE)
Sys.chmod(file, mode = "755")
}
invisible(str)
}
#' @export
#' @title List installed 'Google Fonts'
#' @description List installed 'Google Fonts' that can be
#' found in the user cache directory.
#' @return families names as a character vector
#' @family functions for font management
#' @examples
#' \dontrun{
#' if (curl::has_internet()) {
#' dummy_setup()
#' register_gfont(family = "Roboto")
#' installed_gfonts()
#' }
#' }
installed_gfonts <- function() {
x <- gfonts_summary()
fonts_ids <- basename(list.dirs(fonts_cache_dir(), recursive = FALSE))
x$family[x$id %in% fonts_ids]
}
# utils ----
windows_sysinstall_command <- function(font_id) {
#https://www.jordanmalcolm.com/deploying-windows-10-fonts-at-scale/
id_dir <- font_dir(font_id)
install_cmd <- c(
sprintf("$FontFolder = \"%s\"", id_dir),
"$FontItem = Get-Item -Path $FontFolder",
"$FontList = Get-ChildItem -Path \"$FontItem\\*\" -Include ('*.otf','*.ttc','*.ttf')",
"",
"foreach ($Font in $FontList) {",
" Copy-Item $Font \"C:\\Windows\\Fonts\"",
" New-ItemProperty -Name $Font.BaseName -Path \"HKLM:\\Software\\Microsoft\\Windows NT\\CurrentVersion\\Fonts\" -PropertyType string -Value $Font.name",
"}", "")
install_cmd <- paste0(install_cmd, collapse = "\n")
install_cmd
}
debian_sysinstall_command <- function(font_id, dir = "custom-fonts") {
id_dir <- font_dir(font_id)
create_dir <- sprintf("mkdir -p /usr/share/fonts/truetype/%s", dir)
id_dir <- font_dir(font_id)
install_cmd <- sprintf(
"find %s -name \"*.ttf\" -exec install -m644 {} /usr/share/fonts/truetype/%s/ \\; || return 1",
gsub(" ", "\\ ", id_dir, fixed = TRUE), dir
)
paste(create_dir, install_cmd, "fc-cache -f", sep = ";")
}
macos_sysinstall_command <- function(font_id, dir = "~/Library/Fonts") {
id_dir <- font_dir(font_id)
sprintf("cp %s/* %s", gsub(" ", "\\ ", id_dir, fixed = TRUE), dir)
}
gdtools/R/str-metrics.R 0000644 0001762 0000144 00000006502 14373640554 014543 0 ustar ligges users #' @title Compute string extents.
#'
#' @description Determines the width and height of a bounding box that's big enough
#' to (just) enclose the provided text.
#'
#' @param x Character vector of strings to measure
#' @param bold,italic Is text bold/italic?
#' @param fontname Font name
#' @param fontsize Font size
#' @param fontfile Font file
#' @examples
#' str_extents(letters)
#' str_extents("Hello World!", bold = TRUE, italic = FALSE,
#' fontname = "sans", fontsize = 12)
#' @export
str_extents <- function(x, fontname = "sans", fontsize = 12, bold = FALSE, italic = FALSE, fontfile = "") {
str_extents_(x = x, fontname = fontname, fontsize = fontsize, bold = bold, italic = italic, fontfile = fontfile)
}
#' Get font metrics for a string.
#'
#' @return A named numeric vector
#' @inheritParams str_extents
#' @examples
#' str_metrics("Hello World!")
#' @export
str_metrics <- function(x, fontname = "sans", fontsize = 12, bold = FALSE, italic = FALSE, fontfile = "") {
str_metrics_(x = x, fontname = fontname, fontsize = fontsize, bold = bold, italic = italic, fontfile = fontfile)
}
#' Validate glyph entries
#'
#' Determines if strings contain glyphs not part of a font.
#'
#' @param x Character vector of strings
#' @param bold,italic Is text bold/italic?
#' @param fontname Font name
#' @param fontfile Font file
#' @return a logical vector, if a character element is containing at least
#' a glyph that can not be matched in the font table, FALSE is returned.
#'
#' @examples
#' glyphs_match(letters)
#' glyphs_match("\u265E", bold = TRUE)
#' @export
glyphs_match <- function(x, fontname = "sans", bold = FALSE, italic = FALSE, fontfile = "") {
glyphs_match_(x = x, fontname = fontname, bold = bold, italic = italic, fontfile = fontfile)
}
#' Compute string extents for a vector of string.
#'
#' For each \code{x} element, determines the width and height of a bounding box that's big enough
#' to (just) enclose the provided text. Unit is pixel.
#' @param x Character vector of strings to measure
#' @param bold,italic Is text bold/italic?. A vector of logical to match with x.
#' @param fontname Font name. A vector of character to match with x.
#' @param fontsize Font size. A vector of numeric to match with x.
#' @param fontfile Font file. A vector of character to match with x.
#' @examples
#' \donttest{
#' # The first run can be slow when font caches are missing
#' # as font files are then being scanned to build those font caches.
#' m_str_extents(letters, fontsize = 1:26)
#' m_str_extents(letters[1:3],
#' bold = c(TRUE, FALSE, TRUE),
#' italic = c(FALSE, TRUE, TRUE),
#' fontname = c("sans", "sans", "sans") )
#' }
#' @export
m_str_extents <- function(x, fontname = "sans", fontsize=10, bold = FALSE, italic = FALSE, fontfile = NULL) {
stopifnot(is.character(x), is.character(fontname),
is.numeric(fontsize), is.logical(bold),
is.logical(italic), is.character(fontfile) || is.null(fontfile))
max_length <- length(x)
fontname <- rep(fontname, length.out = max_length)
fontsize <- rep(fontsize, length.out = max_length)
bold <- rep(bold, length.out = max_length)
italic <- rep(italic, length.out = max_length)
if( is.null(fontfile) )
fontfile <- rep("", length.out = max_length)
else
fontfile <- rep(fontfile, length.out = max_length)
m_str_extents_(x, fontname, fontsize, bold, italic, fontfile)
}
gdtools/R/gdtools.R 0000644 0001762 0000144 00000001040 14373642545 013734 0 ustar ligges users #' @useDynLib gdtools
#' @importFrom Rcpp sourceCpp
#' @importFrom grDevices is.raster
NULL
#' Version numbers of C libraries
#'
#' \code{version_cairo()} and \code{version_freetype()} return the
#' runtime version. These helpers return version objects as with
#' \code{\link[utils]{packageVersion}()}.
#' @export
version_cairo <- function() {
ver <- version_cairo_()
ver <- strsplit(ver, "\\.")[[1]]
ver <- as.integer(ver)
structure(list(ver), class = c("package_version", "numeric_version"))
}
#' @importFrom systemfonts match_font
gdtools/R/raster.R 0000644 0001762 0000144 00000003544 14360611071 013556 0 ustar ligges users #' Draw/preview a raster into a string
#'
#' \code{raster_view} is a helper function for testing. It uses \code{htmltools}
#' to render a png as an image with base64 encoded data image.
#'
#' @param x A raster object
#' @param width,height Width and height in pixels.
#' @param interpolate A logical value indicating whether to linearly
#' interpolate the image.
#' @param code base64 code of a raster
#' @export
#' @examples
#' r <- as.raster(matrix(hcl(0, 80, seq(50, 80, 10)),
#' nrow = 4, ncol = 5))
#' code <- raster_str(r, width = 50, height = 50)
#' if (interactive() && require("htmltools")) {
#' raster_view(code = code)
#' }
raster_str <- function(x, width = 480, height = 480, interpolate = FALSE) {
stopifnot(is.raster(x))
value <- base64_raster_encode(x,
w = ncol(x), h = nrow(x), width = width, height = height,
interpolate = interpolate)
value
}
#' @export
#' @rdname raster_str
raster_view <- function(code) {
img <- paste0("![](\"data:image/png;base64,",)
")
htmltools::browsable(htmltools::HTML(img))
}
#' Draw/preview a raster to a png file
#'
#' @param x A raster object
#' @param path name of the file to create
#' @param width,height Width and height in pixels.
#' @param interpolate A logical value indicating whether to linearly
#' interpolate the image.
#' @export
#' @examples
#' r <- as.raster(matrix(hcl(0, 80, seq(50, 80, 10)),
#' nrow = 4, ncol = 5))
#' filepng <- tempfile(fileext = ".png")
#' raster_write(x = r, path = filepng, width = 50, height = 50)
raster_write <- function(x, path, width = 480, height = 480,
interpolate = FALSE) {
stopifnot(is.raster(x))
raster_png_(raster_ = x,
w = ncol(x), h = nrow(x),
width = as.double(width), height = as.double(height),
interpolate = interpolate,
filename = path)
invisible(path)
}
gdtools/MD5 0000644 0001762 0000144 00000006124 14535116431 012243 0 ustar ligges users 48f9678759e45564f2bea309d314eb48 *DESCRIPTION
d32239bcb673463ab874e80d47fae504 *LICENSE
c38db40a78337646730b7101893f9f0d *NAMESPACE
7a47fb03ede4fc8c2e8ffcf8308d9d6f *NEWS
f0b63e0e1999064c425ca8e457c0db15 *R/RcppExports.R
40d4d4cb575fb48161348d633a879fc6 *R/font-caching.R
a137011a584b13f634d535089060e9fc *R/font_family_exists.R
5aed04ca16b25f7db8c45812d6919c96 *R/fontconfig.R
9f225cb11617571d0c65b900bc0c9dc1 *R/fonts.R
44b848e6ac68b95511b7c6f6821b3680 *R/gdtools.R
94780024b9e98d4c01a56e06e239f668 *R/raster.R
4f1bcc24bacae82428ddb12020a7a722 *R/str-metrics.R
d7f3c57db50902de8735c487baaa18d9 *R/sysdata.rda
e9153cb1d2ca36fb59e0d492d0736c47 *README.md
bc7baead3b6080f04dc81efd2fe1ff39 *cleanup
fa71cebc4b7a5f9c9daed0a8ad2033c3 *configure
d41d8cd98f00b204e9800998ecf8427e *configure.win
f0484399ab52a5dafecafdbd5b8417c1 *inst/css/liberation-sans.css
1dd40cfbddcb72173c6d8c2f6b3c8df9 *inst/include/gdtools.h
02ccd021b0ef8f143602d8585ca29ee2 *inst/include/gdtools_RcppExports.h
d41d8cd98f00b204e9800998ecf8427e *inst/include/gdtools_types.cpp
2dca6b353cb2cd15593657282218b299 *inst/include/gdtools_types.h
05c74f661c0125119624ba4d4b9e3805 *man/addGFontHtmlDependency.Rd
0ac2418bcc65250ddd001c45d3ea39fd *man/dummy_setup.Rd
0eb091ca1aaad54395a3bd0201079e36 *man/font_family_exists.Rd
7a1d9ec664e2782a674ab250d3de635f *man/fontconfig_reinit.Rd
e14d19d2adf1bd11e09ddd71d53302aa *man/fonts_cache_dir.Rd
241888baa4c3a2c1cc74730cedc6d87e *man/gfontHtmlDependency.Rd
a342fb166d40577af315ad731882f42d *man/glyphs_match.Rd
5b075b15a750ff688c83c470e8ee7314 *man/install_gfont_script.Rd
254a547d23b08ad47ef520ba8dc92f2b *man/installed_gfonts.Rd
3c308c65057472948f5a8d0bdda2a7f3 *man/liberationsansHtmlDependency.Rd
5ecbead9d286dbbfd6a2c91e2eb37a23 *man/m_str_extents.Rd
4dab2884581711ea97cfce4ec03c2716 *man/match_family.Rd
79c3fe71d0572cdddd1f5faf661559e2 *man/raster_str.Rd
9ec0dc2f294656184a81f2dd91529fa8 *man/raster_write.Rd
7bacbaa6513a1a0e18b4cf469fcd48d5 *man/register_gfont.Rd
a54c3df15efdcb6d2db8e8499fce8485 *man/register_liberationsans.Rd
9bc98cdde728bd01bd614abb107953bb *man/set_dummy_conf.Rd
c68e9c707af2d9c8b2c526e181ca5075 *man/str_extents.Rd
7543c3d22324af177742dfb1622720d2 *man/str_metrics.Rd
75c1a6c8471d9a8ad578c071775f2d02 *man/sys_fonts.Rd
06afbcca1d0a00c5635944cceb0f3a8e *man/version_cairo.Rd
1406cbb642867f1cec46d30ce148c67d *src/CairoContext.cpp
131e8f2086512f6bd15d7a46fd2998f4 *src/Makevars.in
51ff70aba2efc97d6d291061f2d8d8cc *src/Makevars.win
ad490335dc913639f2b1f1edf882a20e *src/RcppExports.cpp
2053aadb4276b4066e13af220812b9b8 *src/font_metrics.cpp
bc6a9479fe9002fc251f3bbca282c303 *src/gdtools.cpp
d15f803daf529add0e3c695271bbede3 *src/raster_to_base64.cpp
e88be22bd4f02671ef54bf42f42065b8 *src/tests/sysdeps.c
8dabb51a7c1a30785bf722556222a85f *src/versions.cpp
d8252437453801ecb341846f83005a7f *tests/testthat.R
3f1839b260441de56baeb401d2b22b7b *tests/testthat/helper-fontconfig.R
2f541f9d74d8ef19bcda19a7ab42729d *tests/testthat/test-raster.R
df90cd2644166b7e6efde5b4c377f5fc *tests/testthat/test-str_extents.R
363712ab46912f592279feed64afc32e *tests/testthat/test-str_metrics.R
08e104261e69b705be125dd4390ae8dd *tools/winlibs.R
gdtools/inst/ 0000755 0001762 0000144 00000000000 14373537043 012713 5 ustar ligges users gdtools/inst/include/ 0000755 0001762 0000144 00000000000 14360611071 014324 5 ustar ligges users gdtools/inst/include/gdtools_RcppExports.h 0000644 0001762 0000144 00000027074 14360611071 020533 0 ustar ligges users // Generated by using Rcpp::compileAttributes() -> do not edit by hand
// Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393
#ifndef RCPP_gdtools_RCPPEXPORTS_H_GEN_
#define RCPP_gdtools_RCPPEXPORTS_H_GEN_
#include "gdtools_types.h"
#include
namespace gdtools {
using namespace Rcpp;
namespace {
void validateSignature(const char* sig) {
Rcpp::Function require = Rcpp::Environment::base_env()["require"];
require("gdtools", Rcpp::Named("quietly") = true);
typedef int(*Ptr_validate)(const char*);
static Ptr_validate p_validate = (Ptr_validate)
R_GetCCallable("gdtools", "_gdtools_RcppExport_validate");
if (!p_validate(sig)) {
throw Rcpp::function_not_exported(
"C++ function with signature '" + std::string(sig) + "' not found in gdtools");
}
}
}
inline XPtrCairoContext context_create() {
typedef SEXP(*Ptr_context_create)();
static Ptr_context_create p_context_create = NULL;
if (p_context_create == NULL) {
validateSignature("XPtrCairoContext(*context_create)()");
p_context_create = (Ptr_context_create)R_GetCCallable("gdtools", "_gdtools_context_create");
}
RObject rcpp_result_gen;
{
RNGScope RCPP_rngScope_gen;
rcpp_result_gen = p_context_create();
}
if (rcpp_result_gen.inherits("interrupted-error"))
throw Rcpp::internal::InterruptedException();
if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
throw Rcpp::LongjumpException(rcpp_result_gen);
if (rcpp_result_gen.inherits("try-error"))
throw Rcpp::exception(Rcpp::as(rcpp_result_gen).c_str());
return Rcpp::as(rcpp_result_gen);
}
inline bool context_set_font(XPtrCairoContext cc, std::string fontname, double fontsize, bool bold, bool italic, std::string fontfile = "") {
typedef SEXP(*Ptr_context_set_font)(SEXP,SEXP,SEXP,SEXP,SEXP,SEXP);
static Ptr_context_set_font p_context_set_font = NULL;
if (p_context_set_font == NULL) {
validateSignature("bool(*context_set_font)(XPtrCairoContext,std::string,double,bool,bool,std::string)");
p_context_set_font = (Ptr_context_set_font)R_GetCCallable("gdtools", "_gdtools_context_set_font");
}
RObject rcpp_result_gen;
{
RNGScope RCPP_rngScope_gen;
rcpp_result_gen = p_context_set_font(Shield(Rcpp::wrap(cc)), Shield(Rcpp::wrap(fontname)), Shield(Rcpp::wrap(fontsize)), Shield(Rcpp::wrap(bold)), Shield(Rcpp::wrap(italic)), Shield(Rcpp::wrap(fontfile)));
}
if (rcpp_result_gen.inherits("interrupted-error"))
throw Rcpp::internal::InterruptedException();
if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
throw Rcpp::LongjumpException(rcpp_result_gen);
if (rcpp_result_gen.inherits("try-error"))
throw Rcpp::exception(Rcpp::as(rcpp_result_gen).c_str());
return Rcpp::as(rcpp_result_gen);
}
inline FontMetric context_extents(XPtrCairoContext cc, std::string x) {
typedef SEXP(*Ptr_context_extents)(SEXP,SEXP);
static Ptr_context_extents p_context_extents = NULL;
if (p_context_extents == NULL) {
validateSignature("FontMetric(*context_extents)(XPtrCairoContext,std::string)");
p_context_extents = (Ptr_context_extents)R_GetCCallable("gdtools", "_gdtools_context_extents");
}
RObject rcpp_result_gen;
{
RNGScope RCPP_rngScope_gen;
rcpp_result_gen = p_context_extents(Shield(Rcpp::wrap(cc)), Shield(Rcpp::wrap(x)));
}
if (rcpp_result_gen.inherits("interrupted-error"))
throw Rcpp::internal::InterruptedException();
if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
throw Rcpp::LongjumpException(rcpp_result_gen);
if (rcpp_result_gen.inherits("try-error"))
throw Rcpp::exception(Rcpp::as(rcpp_result_gen).c_str());
return Rcpp::as(rcpp_result_gen);
}
inline std::string raster_to_str(std::vector raster, int w, int h, double width, double height, int interpolate) {
typedef SEXP(*Ptr_raster_to_str)(SEXP,SEXP,SEXP,SEXP,SEXP,SEXP);
static Ptr_raster_to_str p_raster_to_str = NULL;
if (p_raster_to_str == NULL) {
validateSignature("std::string(*raster_to_str)(std::vector,int,int,double,double,int)");
p_raster_to_str = (Ptr_raster_to_str)R_GetCCallable("gdtools", "_gdtools_raster_to_str");
}
RObject rcpp_result_gen;
{
RNGScope RCPP_rngScope_gen;
rcpp_result_gen = p_raster_to_str(Shield(Rcpp::wrap(raster)), Shield(Rcpp::wrap(w)), Shield(Rcpp::wrap(h)), Shield(Rcpp::wrap(width)), Shield(Rcpp::wrap(height)), Shield(Rcpp::wrap(interpolate)));
}
if (rcpp_result_gen.inherits("interrupted-error"))
throw Rcpp::internal::InterruptedException();
if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
throw Rcpp::LongjumpException(rcpp_result_gen);
if (rcpp_result_gen.inherits("try-error"))
throw Rcpp::exception(Rcpp::as(rcpp_result_gen).c_str());
return Rcpp::as(rcpp_result_gen);
}
inline int raster_to_file(std::vector raster, int w, int h, double width, double height, int interpolate, std::string filename) {
typedef SEXP(*Ptr_raster_to_file)(SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP);
static Ptr_raster_to_file p_raster_to_file = NULL;
if (p_raster_to_file == NULL) {
validateSignature("int(*raster_to_file)(std::vector,int,int,double,double,int,std::string)");
p_raster_to_file = (Ptr_raster_to_file)R_GetCCallable("gdtools", "_gdtools_raster_to_file");
}
RObject rcpp_result_gen;
{
RNGScope RCPP_rngScope_gen;
rcpp_result_gen = p_raster_to_file(Shield(Rcpp::wrap(raster)), Shield(Rcpp::wrap(w)), Shield(Rcpp::wrap(h)), Shield(Rcpp::wrap(width)), Shield(Rcpp::wrap(height)), Shield(Rcpp::wrap(interpolate)), Shield(Rcpp::wrap(filename)));
}
if (rcpp_result_gen.inherits("interrupted-error"))
throw Rcpp::internal::InterruptedException();
if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
throw Rcpp::LongjumpException(rcpp_result_gen);
if (rcpp_result_gen.inherits("try-error"))
throw Rcpp::exception(Rcpp::as(rcpp_result_gen).c_str());
return Rcpp::as(rcpp_result_gen);
}
inline bool raster_png_(CharacterVector raster_, int w, int h, double width, double height, int interpolate, std::string filename) {
typedef SEXP(*Ptr_raster_png_)(SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP);
static Ptr_raster_png_ p_raster_png_ = NULL;
if (p_raster_png_ == NULL) {
validateSignature("bool(*raster_png_)(CharacterVector,int,int,double,double,int,std::string)");
p_raster_png_ = (Ptr_raster_png_)R_GetCCallable("gdtools", "_gdtools_raster_png_");
}
RObject rcpp_result_gen;
{
RNGScope RCPP_rngScope_gen;
rcpp_result_gen = p_raster_png_(Shield(Rcpp::wrap(raster_)), Shield(Rcpp::wrap(w)), Shield(Rcpp::wrap(h)), Shield(Rcpp::wrap(width)), Shield(Rcpp::wrap(height)), Shield(Rcpp::wrap(interpolate)), Shield(Rcpp::wrap(filename)));
}
if (rcpp_result_gen.inherits("interrupted-error"))
throw Rcpp::internal::InterruptedException();
if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
throw Rcpp::LongjumpException(rcpp_result_gen);
if (rcpp_result_gen.inherits("try-error"))
throw Rcpp::exception(Rcpp::as(rcpp_result_gen).c_str());
return Rcpp::as(rcpp_result_gen);
}
inline std::string base64_raster_encode(CharacterVector raster_, int w, int h, double width, double height, int interpolate) {
typedef SEXP(*Ptr_base64_raster_encode)(SEXP,SEXP,SEXP,SEXP,SEXP,SEXP);
static Ptr_base64_raster_encode p_base64_raster_encode = NULL;
if (p_base64_raster_encode == NULL) {
validateSignature("std::string(*base64_raster_encode)(CharacterVector,int,int,double,double,int)");
p_base64_raster_encode = (Ptr_base64_raster_encode)R_GetCCallable("gdtools", "_gdtools_base64_raster_encode");
}
RObject rcpp_result_gen;
{
RNGScope RCPP_rngScope_gen;
rcpp_result_gen = p_base64_raster_encode(Shield(Rcpp::wrap(raster_)), Shield(Rcpp::wrap(w)), Shield(Rcpp::wrap(h)), Shield(Rcpp::wrap(width)), Shield(Rcpp::wrap(height)), Shield(Rcpp::wrap(interpolate)));
}
if (rcpp_result_gen.inherits("interrupted-error"))
throw Rcpp::internal::InterruptedException();
if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
throw Rcpp::LongjumpException(rcpp_result_gen);
if (rcpp_result_gen.inherits("try-error"))
throw Rcpp::exception(Rcpp::as(rcpp_result_gen).c_str());
return Rcpp::as(rcpp_result_gen);
}
inline std::string base64_file_encode(std::string filename) {
typedef SEXP(*Ptr_base64_file_encode)(SEXP);
static Ptr_base64_file_encode p_base64_file_encode = NULL;
if (p_base64_file_encode == NULL) {
validateSignature("std::string(*base64_file_encode)(std::string)");
p_base64_file_encode = (Ptr_base64_file_encode)R_GetCCallable("gdtools", "_gdtools_base64_file_encode");
}
RObject rcpp_result_gen;
{
RNGScope RCPP_rngScope_gen;
rcpp_result_gen = p_base64_file_encode(Shield(Rcpp::wrap(filename)));
}
if (rcpp_result_gen.inherits("interrupted-error"))
throw Rcpp::internal::InterruptedException();
if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
throw Rcpp::LongjumpException(rcpp_result_gen);
if (rcpp_result_gen.inherits("try-error"))
throw Rcpp::exception(Rcpp::as(rcpp_result_gen).c_str());
return Rcpp::as(rcpp_result_gen);
}
inline std::string base64_string_encode(std::string string) {
typedef SEXP(*Ptr_base64_string_encode)(SEXP);
static Ptr_base64_string_encode p_base64_string_encode = NULL;
if (p_base64_string_encode == NULL) {
validateSignature("std::string(*base64_string_encode)(std::string)");
p_base64_string_encode = (Ptr_base64_string_encode)R_GetCCallable("gdtools", "_gdtools_base64_string_encode");
}
RObject rcpp_result_gen;
{
RNGScope RCPP_rngScope_gen;
rcpp_result_gen = p_base64_string_encode(Shield(Rcpp::wrap(string)));
}
if (rcpp_result_gen.inherits("interrupted-error"))
throw Rcpp::internal::InterruptedException();
if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
throw Rcpp::LongjumpException(rcpp_result_gen);
if (rcpp_result_gen.inherits("try-error"))
throw Rcpp::exception(Rcpp::as(rcpp_result_gen).c_str());
return Rcpp::as(rcpp_result_gen);
}
}
#endif // RCPP_gdtools_RCPPEXPORTS_H_GEN_
gdtools/inst/include/gdtools.h 0000644 0001762 0000144 00000000372 14360611071 016152 0 ustar ligges users // Generated by using Rcpp::compileAttributes() -> do not edit by hand
// Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393
#ifndef RCPP_gdtools_H_GEN_
#define RCPP_gdtools_H_GEN_
#include "gdtools_RcppExports.h"
#endif // RCPP_gdtools_H_GEN_
gdtools/inst/include/gdtools_types.cpp 0000644 0001762 0000144 00000000000 14360611071 017715 0 ustar ligges users gdtools/inst/include/gdtools_types.h 0000644 0001762 0000144 00000003024 14360611071 017373 0 ustar ligges users #ifndef __GDTOOLS_TYPES__
#define __GDTOOLS_TYPES__
#include
class FontMetric {
public:
double height, width, ascent, descent;
FontMetric();
FontMetric(SEXP);
operator SEXP() const ;
};
#include
using namespace Rcpp;
inline FontMetric::FontMetric() {}
inline FontMetric::FontMetric(SEXP x_) {
Rcpp::NumericVector x(x_);
if (x.size() != 4)
Rcpp::stop("Invalid size");
width = x[0];
height = x[1];
ascent = x[2];
descent = x[3];
}
inline FontMetric::operator SEXP() const {
return Rcpp::NumericVector::create(width, height, ascent, descent);
}
typedef struct _cairo_font_face cairo_font_face_t;
class CairoContext {
struct CairoContext_;
CairoContext_* cairo_;
typedef std::map fontCache;
public:
CairoContext();
~CairoContext();
void cacheFont(fontCache& cache, std::string& key, std::string fontfile, int fontindex);
void cacheSystemFont(std::string& key, std::string& fontname, bool bold, bool italic);
void setFont(std::string fontname = "sans", double fontsize = 12,
bool bold = false, bool italic = false,
std::string fontfile = "");
void setUserFont(std::string& fontname, double fontsize,
bool bold, bool italic, std::string& fontfile);
void setSystemFont(std::string& fontname, double fontsize,
bool bold, bool italic);
FontMetric getExtents(std::string x);
bool validateGlyphs(std::string x);
};
typedef Rcpp::XPtr XPtrCairoContext;
#endif
gdtools/inst/css/ 0000755 0001762 0000144 00000000000 14373537072 013505 5 ustar ligges users gdtools/inst/css/liberation-sans.css 0000644 0001762 0000144 00000002001 14373537446 017307 0 ustar ligges users @font-face {
font-family: 'Liberation Sans';
font-style: normal;
font-weight: 400;
src:
url('../fonts/LiberationSans-Regular.ttf') format('truetype'), /* Safari, Android, iOS */
url('../fonts/LiberationSans-Regular.woff') format('woff');
}
@font-face {
font-family: 'Liberation Sans';
font-style: italic;
font-weight: 400;
src:
url('../fonts/LiberationSans-Italic.ttf') format('truetype'), /* Safari, Android, iOS */
url('../fonts/LiberationSans-Italic.woff') format('woff');
}
@font-face {
font-family: 'Liberation Sans';
font-style: normal;
font-weight: 700;
src:
url('../fonts/LiberationSans-Bold.ttf') format('truetype'), /* Safari, Android, iOS */
url('../fonts/LiberationSans-Bold.woff') format('woff');
}
@font-face {
font-family: 'Liberation Sans';
font-style: italic;
font-weight: 700;
src:
url('../fonts/LiberationSans-BoldItalic.ttf') format('truetype'), /* Safari, Android, iOS */
url('../fonts/LiberationSans-BoldItalic.woff') format('woff');
}
gdtools/cleanup 0000755 0001762 0000144 00000000053 14535110661 013302 0 ustar ligges users #!/bin/sh
rm -f src/Makevars configure.log
gdtools/configure 0000755 0001762 0000144 00000006217 14535110661 013644 0 ustar ligges users # Anticonf script by Jeroen Ooms (2020)
# The script will try 'pkg-config' to find required cflags and ldflags.
# Make sure this executable is in PATH when installing the package.
# Alternatively, you can set INCLUDE_DIR and LIB_DIR manually:
# R CMD INSTALL --configure-vars='INCLUDE_DIR=/.../include LIB_DIR=/.../lib'
# Library settings
PKG_CONFIG_NAME="cairo freetype2"
PKG_DEB_NAME="libcairo2-dev"
PKG_RPM_NAME="cairo-devel"
PKG_CSW_NAME="libcairo_dev"
PKG_BREW_NAME="cairo"
PKG_LIBS="-lcairo -lfreetype"
PKG_TEST_FILE="src/tests/sysdeps.c"
# Prefer static linking on MacOS
if [ `uname` = "Darwin" ]; then
PKG_CONFIG_NAME="--static $PKG_CONFIG_NAME"
if [ `arch` = "i386" ]; then
export PKG_CONFIG_PATH="$PKG_CONFIG_PATH:/usr/local/opt/libffi/lib/pkgconfig"
fi
fi
# Use pkg-config if available
if [ `command -v pkg-config` ]; then
PKGCONFIG_CFLAGS=`pkg-config --cflags ${PKG_CONFIG_NAME}`
PKGCONFIG_LIBS=`pkg-config --libs ${PKG_CONFIG_NAME}`
fi
# On CRAN do not use pkgconfig cairo (which depends on XQuartz)
if [ -d "/Builds/CRAN-QA-Simon" ] || [ -d "/Volumes/Builds" ]; then
unset PKGCONFIG_CFLAGS
unset PKGCONFIG_LIBS
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
brew --version 2>/dev/null
if [ $? -eq 0 ]; then
BREWDIR=`brew --prefix`
PKG_CFLAGS="-I$BREWDIR/include/cairo -I$BREWDIR/include/fontconfig -I$BREWDIR/include/freetype2"
PKG_LIBS="-L$BREWDIR/lib $PKG_LIBS"
else
curl -sfL "https://autobrew.github.io/scripts/cairo" > autobrew
. ./autobrew
fi
fi
# 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`
# For debugging
echo "Using PKG_CFLAGS=$PKG_CFLAGS"
echo "Using PKG_LIBS=$PKG_LIBS"
# Test configuration
${CC} ${CPPFLAGS} ${PKG_CFLAGS} ${CFLAGS} -E ${PKG_TEST_FILE} >/dev/null 2>configure.log
if [ $? -ne 0 ]; then
echo "-----------------------------[ ANTICONF ]-------------------------------"
echo "Configuration failed to find libraries. Try installing:"
echo " * deb: $PKG_DEB_NAME (Debian, Ubuntu)"
echo " * rpm: $PKG_RPM_NAME (Fedora, CentOS, RHEL)"
echo " * csw: $PKG_CSW_NAME (Solaris)"
echo " * brew: $PKG_BREW_NAME (OSX)"
echo "If $PKG_CONFIG_NAME are 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
# Write to Makevars
sed -e "s|@cflags@|$PKG_CFLAGS|" -e "s|@libs@|$PKG_LIBS|" src/Makevars.in > src/Makevars
# Success
exit 0