", "is", "
", "it", "
", "this", "
", "thatsit", "
" ) ) }) test_that("word superscript and subscript", { ft <- flextable(data.frame(a = ""), col_keys = c("dummy")) ft <- delete_part(ft, part = "header") ft <- compose(ft, i = 1, j = "dummy", part = "body", value = as_paragraph( as_sub("Sepal.Length") ) ) runs <- information_data_chunk(ft) expect_equal(runs$vertical.align[1], "subscript") openxml <- flextable:::runs_as_wml(ft, txt_data = runs)$run_openxml expect_match(openxml, "
", is_tab = dat$txt %in% "
#' }}
#' @param x gam model
#' @param ... unused argument
#' @family as_flextable methods
#' @examples
#' if (require("mgcv")) {
#' set.seed(2)
#'
#' # Simulated data
#' dat <- gamSim(1, n = 400, dist = "normal", scale = 2)
#'
#' # basic GAM model
#' b <- gam(y ~ s(x0) + s(x1) + s(x2) + s(x3), data = dat)
#'
#' ft <- as_flextable(b)
#' ft
#' }
as_flextable.gam <- function(x, ...) {
data_t <- tidy_gam(x)
data_g <- glance_gam(x)
std_border <- fp_border(color = flextable_global$defaults$border.color, style = "solid", ...)
param.head <- c("Component", "Term", "Estimate", "Std Error", "t-value", "p-value")
smooth.head <- c("Component", "Term", "edf", "Ref. df", "F-value", "p-value")
names(param.head) <- names(data_t$parametric)
names(smooth.head) <- names(data_t$parametric)
has_pvalue <- if ("p.value" %in% colnames(data_t)) TRUE else FALSE
show_signif <- !is.null(getOption("show.signif.stars")) && getOption("show.signif.stars")
ft <- flextable(data_t$parametric, col_keys = c(
names(data_t$parametric),
if (show_signif) "signif"
))
ft <- border_remove(ft)
ft <- set_header_labels(ft, values = param.head)
if (nrow(data_t$smooth) > 0) {
ft <- add_body(ft, Component = NA_character_, top = FALSE)
new_dat <- data_t$smooth
names(new_dat) <- names(data_t$parametric)
if (show_signif) {
new_dat[["signif"]] <- ""
}
ft <- add_body(ft, values = new_dat, top = FALSE)
}
ft <- colformat_double(ft, j = 3:5, digits = 3)
ft <- colformat_double(ft, j = 6, digits = 4)
if (show_signif) {
ft <- mk_par(ft, j = "signif", value = as_paragraph(pvalue_format(p.value)))
}
if (nrow(data_t$smooth) > 0) {
ft <- mk_par(ft, i = nrow(data_t$parametric) + 1, value = as_paragraph(c(smooth.head, if (show_signif) "")))
ft <- hline(ft, i = nrow(data_t$parametric) + c(0, 1), border = std_border)
ft <- bold(ft, i = nrow(data_t$parametric) + 1)
}
ft <- hline_bottom(ft, border = std_border)
ft <- bold(ft, part = "header")
ft <- hline_top(ft, border = std_border, part = "header")
ft <- hline(ft, border = std_border, part = "header")
ft <- merge_v(ft, j = 1)
ft <- valign(ft, j = 1, valign = "top")
ft <- align_nottext_col(ft)
ft <- align_text_col(ft)
ft <- fix_border_issues(ft)
if (show_signif) {
ft <- add_footer_lines(ft, values = c(
"Signif. codes: 0 <= '***' < 0.001 < '**' < 0.01 < '*' < 0.05",
""
))
}
ft <- add_footer_lines(ft, values = c(
sprintf("Adjusted R-squared: %s, Deviance explained %s", format(data_g$adj.r.squared, digits = 3, format = "f", nsmall = 3), format(data_g$deviance, digits = 3, format = "f", nsmall = 3)),
sprintf("%s : %s, Scale est: %s, N: %d", data_g$method, format(data_g$sp.crit, format = "f", digits = 3, nsmall = 3), format(data_g$scale.est, digits = 3, nsmall = 3), data_g$nobs)
))
ft <- align(ft, i = 1, align = "right", part = "footer")
ft <- autofit(ft, part = c("header", "body"))
if (show_signif) {
ft <- width(ft, j = "signif", width = .4)
}
ft
}
#' Summarize a(n) gam object
#' @description summarizes information about the components of a model
#' @noRd
tidy_gam <- function(model) {
ptab <- data.frame(summary(model)$p.table)
ptab$term <- rownames(ptab)
rownames(ptab) <- NULL
ptab$Component <- "A. parametric coefficients"
ptab <- ptab[, c(6, 5, 1:4)]
colnames(ptab) <- c("Component", "Term", "Estimate", "Std.Error", "t.value", "p.value")
stab <- data.frame(summary(model)$s.table)
if (nrow(stab) > 0) {
stab$term <- rownames(stab)
stab$Component <- "B. smooth terms"
stab <- stab[, c(6, 5, 1:4)]
colnames(stab) <- c("Component", "Term", "edf", "Ref. df", "F.value", "p.value")
rownames(stab) <- NULL
}
list(parametric = ptab, smooth = stab)
}
#' Summarize a(n) gam object
#' @description provides model summaries in one line
#' @noRd
#' @importFrom stats AIC BIC logLik df.residual nobs
glance_gam <- function(model) {
df <- sum(model$edf)
if (length(df) < 1) df <- NA_real_
df.res <- df.residual(model)
if (length(df.res) < 1) df.res <- NA_real_
logLik <- as.numeric(logLik(model))
if (length(logLik) < 1) logLik <- NA_real_
aic <- AIC(model)
if (length(aic) < 1) aic <- NA_real_
bic <- BIC(model)
if (length(bic) < 1) bic <- NA_real_
dev <- summary(model)$dev.expl
if (length(dev) < 1) dev <- NA_real_
adj.r.squared <- summary(model)$r.sq
if (length(adj.r.squared) < 1) adj.r.squared <- NA_real_
scale.est <- summary(model)$scale
if (length(scale.est) < 1) scale.est <- NA_real_
sp.criterion <- as.numeric(summary(model)$sp.criterion)
if (length(sp.criterion) < 1) sp.criterion <- NA_real_
data.frame(
df = df,
df.residual = df.res,
logLik = logLik,
AIC = aic,
BIC = bic,
adj.r.squared = adj.r.squared,
deviance = dev,
nobs = length(model$y),
method = as.character(summary(model)$method),
sp.crit = sp.criterion,
scale.est = scale.est,
stringsAsFactors = FALSE
)
}
flextable/R/printers.R 0000644 0001762 0000144 00000110775 15143100244 014417 0 ustar ligges users # main ----
#' @export
#' @title Convert a flextable to an HTML object
#'
#' @description get a [htmltools::div()] from a flextable object.
#' This can be used in a shiny application. For an output within
#' "R Markdown" document, use [knit_print.flextable].
#' @return an object marked as [htmltools::HTML] ready to be used within
#' a call to `shiny::renderUI` for example.
#' @inheritParams args_x_only
#' @param ft.align flextable alignment, supported values are 'left', 'center' and 'right'.
#' @param ft.shadow deprecated.
#' @param extra_dependencies a list of HTML dependencies to
#' add in the HTML output.
#' @family flextable print function
#' @examples
#' htmltools_value(flextable(iris[1:5, ]))
#' @importFrom htmltools tagList attachDependencies tags
htmltools_value <- function(x, ft.align = NULL, ft.shadow = NULL,
extra_dependencies = NULL) {
x <- flextable_global$defaults$post_process_all(x)
x <- flextable_global$defaults$post_process_html(x)
x <- fix_border_issues(x)
if (!is.null(ft.align)) {
x$properties$align <- ft.align
}
caption <- caption_default_html(x)
manual_css <- attr(caption, "css")
list_deps <- html_dependencies_list(x)
html_o <- tagList(
if (length(extra_dependencies) > 0) {
attachDependencies(
x = tags$style(""),
extra_dependencies
)
},
attachDependencies(
x = tags$style(""),
list_deps
),
HTML(gen_raw_html(x,
class = "tabwid",
caption = caption,
manual_css = manual_css
))
)
html_o
}
#' @importFrom knitr knit_child
#' @export
#' @title Print a flextable inside knitr loops and conditionals
#'
#' @description Print flextable in R Markdown or Quarto documents
#' within `for` loop or `if` statement.
#'
#' The function is particularly useful when you want
#' to generate flextable in a loop from a R Markdown document.
#'
#' Inside R Markdown document, chunk option `results` must be
#' set to 'asis'.
#'
#' See [knit_print.flextable] for more details.
#' @inheritParams args_x_only
#' @param ... unused argument
#' @family flextable print function
#' @examples
#' \dontrun{
#' library(rmarkdown)
#' if (pandoc_available() &&
#' pandoc_version() > numeric_version("2")) {
#' demo_loop <- system.file(
#' package = "flextable",
#' "examples/rmd",
#' "loop_with_flextable.Rmd"
#' )
#' rmd_file <- tempfile(fileext = ".Rmd")
#' file.copy(demo_loop, to = rmd_file, overwrite = TRUE)
#' render(
#' input = rmd_file, output_format = "html_document",
#' output_file = "loop_with_flextable.html"
#' )
#' }
#' }
flextable_to_rmd <- function(x, ...) {
is_bookdown <- is_in_bookdown()
is_quarto <- is_in_quarto()
x <- knitr_update_properties(x, bookdown = is_bookdown, quarto = is_quarto)
if (is_quarto) {
tmp_file <- tempfile(fileext = ".qmd")
} else {
tmp_file <- tempfile(fileext = ".Rmd")
}
writeLines(
c("```{r echo=FALSE}",
"x", "```", ""),
tmp_file,
useBytes = TRUE)
z <- knit_child(
input = tmp_file,
options = list(
fig.path=tempfile(),
eval = isTRUE(knitr::opts_current$get("eval"))
),
envir = environment(), quiet = TRUE)
cat(z, sep = '\n')
invisible("")
}
#' @export
#' @title Get HTML code as a string
#' @description Generate HTML code of corresponding
#' flextable as an HTML table or an HTML image.
#' @inheritParams args_x_only
#' @param type output type. one of "table" or "img".
#' @param ... unused
#' @return If `type='img'`, the result will be a string
#' containing HTML code of an image tag, otherwise, the
#' result will be a string containing HTML code of
#' a table tag.
#' @family flextable print function
#' @examples
#' library(officer)
#' library(flextable)
#' x <- to_html(as_flextable(cars))
to_html.flextable <- function(x, type = c("table", "img"), ...) {
type_output <- match.arg(type)
x <- knitr_update_properties(x)
is_bookdown <- is_in_bookdown()
is_quarto <- is_in_quarto()
if ("table" %in% type_output) {
x <- flextable_global$defaults$post_process_all(x)
x <- flextable_global$defaults$post_process_html(x)
x <- fix_border_issues(x)
manual_css <- readLines(system.file(package = "flextable", "web_1.1.3", "tabwid.css"), encoding = "UTF-8")
gen_raw_html(x, class = "tabwid", caption = "", manual_css = paste0(manual_css, collapse = "\n"))
} else {
tmp <- tempfile(fileext = ".png")
gr <- gen_grob(x, fit = "fixed", just = "center")
dims <- dim(gr)
expand <- 10
width <- dims$width + expand / 72
height <- dims$height + expand / 72
agg_png(
filename = tmp,
width = dims$width + expand / 72,
height = dims$height + expand / 72,
res = 200, units = "in",
background = "transparent"
)
tryCatch(
{
plot(gr)
},
finally = {
dev.off()
}
)
base64_string <- image_to_base64(tmp)
sprintf("", 1L, default = 0L) )] txt_data[, c("fake_row_id") := list( cumsum(.SD$fake_row_id) ), by = c(".row_id", ".col_id")] txt_data[, c("fake_row_id") := list( rleid(.SD$fake_row_id) ), by = c(".row_id", ".col_id")] # set new lines to blank txt_data$txt[txt_data$txt %in% "
"] <- "" # set tabs to 4 'm' txt_data$txt[txt_data$txt %in% "
#' }}
#' @note
#' This is very first version of the function; be aware it
#' can evolve or change.
#' @param x an aggregated data.frame
#' @param rows column names to use in rows dimensions
#' @param columns column names to use in columns dimensions
#' @param datasup_first additional data that will be merged with
#' table and placed after the columns presenting
#' the row dimensions.
#' @param datasup_last additional data that will be merged with
#' table and placed at the end of the table.
#' @param hidden_data additional data that will be merged with
#' table, the columns are not presented but can be used
#' with [compose()] or [mk_par()] function.
#' @param row_compose a list of call to [as_paragraph()] - these
#' calls will be applied to the row dimensions (the name is
#' used to target the displayed column).
#' @param ... named arguments calling function [as_paragraph()].
#' The names are used as labels and the values are evaluated
#' when the flextable is created.
#' @return an object of class `tabulator`.
#' @examples
#' \dontrun{
#' set_flextable_defaults(digits = 2, border.color = "gray")
#'
#' library(data.table)
#' # example 1 ----
#' if (require("stats")) {
#' dat <- aggregate(breaks ~ wool + tension,
#' data = warpbreaks, mean
#' )
#'
#' cft_1 <- tabulator(
#' x = dat, rows = "wool",
#' columns = "tension",
#' `mean` = as_paragraph(as_chunk(breaks)),
#' `(N)` = as_paragraph(as_chunk(length(breaks), formatter = fmt_int))
#' )
#'
#' ft_1 <- as_flextable(cft_1)
#' ft_1
#' }
#'
#' # example 2 ----
#' if (require("ggplot2")) {
#' multi_fun <- function(x) {
#' list(mean = mean(x), sd = sd(x))
#' }
#'
#' dat <- as.data.table(ggplot2::diamonds)
#' dat <- dat[cut %in% c("Fair", "Good", "Very Good")]
#'
#' dat <- dat[, unlist(lapply(.SD, multi_fun),
#' recursive = FALSE
#' ),
#' .SDcols = c("z", "y"),
#' by = c("cut", "color")
#' ]
#'
#' tab_2 <- tabulator(
#' x = dat, rows = "color",
#' columns = "cut",
#' `z stats` = as_paragraph(as_chunk(fmt_avg_dev(z.mean, z.sd, digit2 = 2))),
#' `y stats` = as_paragraph(as_chunk(fmt_avg_dev(y.mean, y.sd, digit2 = 2)))
#' )
#' ft_2 <- as_flextable(tab_2)
#' ft_2 <- autofit(x = ft_2, add_w = .05)
#' ft_2
#' }
#'
#' # example 3 ----
#' # data.table version
#' dat <- melt(as.data.table(iris),
#' id.vars = "Species",
#' variable.name = "name", value.name = "value"
#' )
#' dat <- dat[,
#' list(
#' avg = mean(value, na.rm = TRUE),
#' sd = sd(value, na.rm = TRUE)
#' ),
#' by = c("Species", "name")
#' ]
#' # dplyr version
#' # library(dplyr)
#' # dat <- iris %>%
#' # pivot_longer(cols = -c(Species)) %>%
#' # group_by(Species, name) %>%
#' # summarise(avg = mean(value, na.rm = TRUE),
#' # sd = sd(value, na.rm = TRUE),
#' # .groups = "drop")
#'
#' tab_3 <- tabulator(
#' x = dat, rows = c("Species"),
#' columns = "name",
#' `mean (sd)` = as_paragraph(
#' as_chunk(avg),
#' " (", as_chunk(sd), ")"
#' )
#' )
#' ft_3 <- as_flextable(tab_3)
#' ft_3
#'
#' init_flextable_defaults()
#' }
#' @importFrom rlang enquos enquo call_args
#' @importFrom data.table rleidv as.data.table
#' @seealso [as_flextable.tabulator()], [summarizor()],
#' [as_grouped_data()], [tabulator_colnames()]
tabulator <- function(x, rows, columns,
datasup_first = NULL,
datasup_last = NULL,
hidden_data = NULL,
row_compose = list(),
...) {
stopifnot(
`rows can not be empty` = length(rows) > 0,
`columns can not be empty` = length(columns) > 0
)
use_labels <- attr(x, "use_labels")
n_by <- attr(x, "n_by")
x <- as.data.frame(x)
row_compose <- enquo(row_compose)
row_compose <- call_args(row_compose)
col_exprs <- enquos(...)
data_colnames <- setdiff(colnames(x), c(rows, columns))
col_expr_names <- names(col_exprs)
hidden_columns <- map_hidden_columns(
dat = x, columns = columns,
rows = rows
)
x <- add_fake_columns(x, col_expr_names)
supp_colnames <- setdiff(colnames(datasup_first), rows)
supp_colnames_last <- setdiff(colnames(datasup_last), rows)
visible_columns <- map_visible_columns(
dat = x, columns = columns, rows = rows,
supp_colnames = supp_colnames,
supp_colnames_last = supp_colnames_last,
value_names = col_expr_names
)
# check dimensions
cts <- as.data.table(x)[, c("cts") := .N, by = c(columns, rows)]
setDF(cts)
cts <- cts[cts$cts > 1, ]
if (nrow(cts) > 0) {
all_dims <- paste0("`", c(columns, rows), "`", collapse = ", ")
stop(sprintf(
"number of rows is not unique for some combinations of rows and columns: %s.",
all_dims
))
}
.formula <- paste(
paste0("`", rows, "`", collapse = "+"),
"~", paste0("`", columns, "`", collapse = "+")
)
value_vars <- c(data_colnames, col_expr_names)
dat <- dcast(
data = as.data.table(x),
formula = .formula,
value.var = value_vars, sep = "@"
)
setDF(dat)
dat <- merge_additional_dataset(dat, datasup_first, rows = rows)
dat <- merge_additional_dataset(dat, hidden_data, rows = rows)
dat <- merge_additional_dataset(dat, datasup_last, rows = rows)
setDF(dat)
z <- list(
data = dat,
rows = rows,
columns = columns,
visible_columns = visible_columns,
hidden_columns = hidden_columns,
col_exprs = col_exprs,
row_exprs = row_compose,
use_labels = use_labels,
n_by = n_by
)
class(z) <- "tabulator"
z
}
#' @export
#' @title Transform a 'tabulator' object into a flextable
#' @description [tabulator()] object can be transformed as a flextable
#' with method [as_flextable()].
#' @param x result from [tabulator()]
#' @param separate_with columns used to sepatate the groups
#' with an horizontal line.
#' @param big_border,small_border big and small border properties defined
#' by a call to [fp_border_default()] or [officer::fp_border()].
#' @param rows_alignment,columns_alignment alignments to apply to
#' columns corresponding to `rows` and `columns`; see arguments
#' `rows` and `columns` in [tabulator()].
#' @param label_rows labels to use for the first column names, i.e.
#' the *row* column names. It must be a named vector, the values will
#' be matched based on the names.
#' @param spread_first_col if TRUE, first row is spread as a new line separator
#' instead of being a column. This helps to reduce the width and allows for
#' clear divisions.
#' @param expand_single if FALSE (the default), groups with only one
#' row will not be expanded with a title row. If TRUE,
#' single row groups and multi-row groups are all
#' restructured.
#' @param sep_w blank column separators'width to be used. If 0,
#' blank column separators will not be used.
#' @param unit unit of argument `sep_w`, one of "in", "cm", "mm".
#' @param ... unused argument
#' @family as_flextable methods
#' @seealso [summarizor()], [as_grouped_data()]
#' @examples
#' \dontrun{
#' library(flextable)
#'
#' set_flextable_defaults(digits = 2, border.color = "gray")
#'
#' if (require("stats")) {
#' dat <- aggregate(breaks ~ wool + tension,
#' data = warpbreaks, mean
#' )
#'
#' cft_1 <- tabulator(
#' x = dat,
#' rows = "wool",
#' columns = "tension",
#' `mean` = as_paragraph(as_chunk(breaks)),
#' `(N)` = as_paragraph(
#' as_chunk(length(breaks))
#' )
#' )
#'
#' ft_1 <- as_flextable(cft_1, sep_w = .1)
#' ft_1
#' }
#'
#' if (require("stats")) {
#' set_flextable_defaults(
#' padding = 1, font.size = 9,
#' border.color = "orange"
#' )
#'
#' ft_2 <- as_flextable(cft_1, sep_w = 0)
#' ft_2
#' }
#'
#' if (require("stats")) {
#' set_flextable_defaults(
#' padding = 6, font.size = 11,
#' border.color = "white",
#' font.color = "white",
#' background.color = "#333333"
#' )
#'
#' ft_3 <- as_flextable(
#' x = cft_1, sep_w = 0,
#' rows_alignment = "center",
#' columns_alignment = "right"
#' )
#' ft_3
#' }
#'
#' init_flextable_defaults()
#' }
as_flextable.tabulator <- function(
x, separate_with = character(0),
big_border = fp_border_default(width = 1.5),
small_border = fp_border_default(width = .75),
rows_alignment = "left", columns_alignment = "center",
label_rows = x$rows, spread_first_col = FALSE,
expand_single = FALSE,
sep_w = .05, unit = "in", ...) {
# get necessary element
dat <- x$data
rows <- x$rows
columns <- x$columns
if (spread_first_col) {
dat <- as_grouped_data(dat, groups = rows[1], expand_single = expand_single)
}
visible_columns <- x$visible_columns
hidden_columns <- x$hidden_columns
col_exprs <- x$col_exprs
if (sep_w < 0.001) {
visible_columns <- visible_columns[!visible_columns[[".tab_columns"]] %in% "dummy", ]
}
visible_columns_keys <- visible_columns[
visible_columns$.type. %in% "columns" &
!visible_columns[[".tab_columns"]] %in% "dummy",
"col_keys"
]
blank_columns <- visible_columns[
visible_columns[[".tab_columns"]] %in% "dummy", "col_keys"
]
# create border_h_major from separate_with
stopifnot(
`separate_with is not part of rows` =
length(separate_with) < 1 || all(separate_with %in% rows)
)
border_h_major <- integer()
if (length(separate_with) > 0) {
rle <- rleidv(dat[separate_with])
border_h_major <- which(rle != c(-1, rle[-length(rle)])) - 1
border_h_major <- setdiff(border_h_major, 0)
}
if (length(separate_with) > 0 && spread_first_col) {
border_h_major <- setdiff(border_h_major, which(!is.na(dat[[rows[1]]])))
}
if (spread_first_col) {
visible_columns <- visible_columns[-1, ]
}
# for later iteration, a list of visible columns
# to use when filling the table
visible_columns_mapping <- visible_columns[visible_columns$.type. %in% "columns" & !visible_columns[[".tab_columns"]] %in% "dummy", ]
visible_columns_mapping$.type. <- NULL
visible_columns_mapping <- split(visible_columns_mapping, visible_columns_mapping[columns], drop = TRUE)
# for later iteration, a list of hidden columns that can
# be used by expressions defined by the user
hidden_columns_mapping <- split(hidden_columns, hidden_columns[columns], drop = TRUE)
ft <- flextable(dat, col_keys = visible_columns$col_keys)
ft <- border_remove(ft)
labels_tab <- visible_columns
labels_tab <- labels_tab[!labels_tab$.tab_columns %in% "dummy", ]
if (length(col_exprs) > 1) {
labels <- labels_tab$.tab_columns
names(labels) <- labels_tab$col_keys
ft <- set_header_labels(x = ft, values = labels)
} else {
labels <- labels_tab[[columns[length(columns)]]]
names(labels) <- labels_tab$col_keys
ft <- set_header_labels(x = ft, values = labels)
columns <- columns[-length(columns)]
}
for (j in names(visible_columns_mapping)) {
visible_columns_mapping_j <- visible_columns_mapping[[j]]
replication_info <- hidden_columns_mapping[[j]]
ft$body$dataset[as.character(replication_info$.user_columns)] <- ft$body$dataset[replication_info$col_keys]
for (i in seq_len(nrow(visible_columns_mapping_j))) {
colname <- visible_columns_mapping_j[i, "col_keys"]
exp_name <- visible_columns_mapping_j[i, ".tab_columns"]
ft <- mk_par(ft, j = colname, value = !!col_exprs[[exp_name]])
}
ft$body$dataset[as.character(replication_info$.user_columns)] <- rep(list(NULL), nrow(replication_info))
}
row_spanner <- character(length = 0L)
if (spread_first_col) {
row_spanner <- rows[1]
rows <- rows[-1]
# treatment of groups
rleid_ <- do.call(rleid, dat[row_spanner])
table_rleid <- table(rleid_[is.na(dat[[row_spanner]])])
table_uid <- as.integer(names(table_rleid[table_rleid > 1])) - 1 # considered as title row for non single group
# write title rows for non single groups
sel <- rleid_ %in% table_uid
row_spanner_labels <- dat[[row_spanner]][sel]
ft <- mk_par(ft, i = sel, value = as_paragraph(row_spanner_labels))
ft <- merge_h(ft, i = sel)
# write title rows for single groups
sna <- !is.na(dat[[row_spanner]])
sna <- c(sna[-length(sna)] == sna[-1], FALSE) & sna
row_spanner_labels <- dat[[row_spanner]][sna]
ft <- mk_par(ft, i = sna, j = 1, value = as_paragraph(row_spanner_labels))
}
ft <- merge_v(ft, j = rows, part = "body")
ft <- valign(ft, valign = "top", j = rows)
for (j in names(x$row_exprs)) {
if (!j %in% row_spanner) {
ft <- mk_par(ft, i = !is.na(dat[[j]]), j = j, value = !!x$row_exprs[[j]])
} else {
ft <- mk_par(ft, i = !is.na(dat[[j]]), j = 1, value = !!x$row_exprs[[j]])
}
}
for (column in rev(columns)) {
rel_ <- rle(visible_columns[[column]])
rel_$values[rel_$values %in% "dummy"] <- ""
ft <- add_header_row(
x = ft,
values = rel_$values,
colwidths = rel_$lengths, top = TRUE
)
ft <- hline(ft,
i = 1, j = which(!visible_columns[[column]] %in% c("dummy", rows)),
border = small_border,
part = "header"
)
ft <- align(x = ft, i = 1, align = "center", part = "header")
}
rows_supp <- visible_columns$col_keys[
visible_columns$.type. %in% c("rows_supp", "rows_supp_last") &
!visible_columns$.tab_columns %in% "dummy"
]
ft <- merge_v(
x = ft,
j = c(rows, rows_supp), part = "header"
)
ft <- valign(ft, valign = "bottom", j = c(rows, rows_supp), part = "header")
ft <- valign(ft, valign = "top", part = "body")
ft <- align(x = ft, j = visible_columns_keys, align = columns_alignment, part = "all")
ft <- align(x = ft, j = c(rows, rows_supp), align = rows_alignment, part = "all")
if (sep_w > 0) {
ft <- padding(ft, j = blank_columns, padding = 0, part = "all")
}
# dummy as blank columns
ft <- hline(ft, i = border_h_major, border = small_border)
ft <- hline(ft,
i = nrow_part(ft, part = "header"),
j = setdiff(visible_columns$col_keys, blank_columns),
border = big_border, part = "header"
)
ft <- hline_top(x = ft, border = big_border, part = "header")
ft <- hline_bottom(x = ft, border = big_border, part = "body")
if (sep_w > 0) {
ft <- border(ft,
j = blank_columns,
border.top = fp_border_default(width = 0),
border.bottom = fp_border_default(width = 0),
part = "all"
)
ft <- bg(ft, j = blank_columns, bg = "transparent", part = "all")
ft <- void(ft, j = blank_columns, part = "all")
ft <- width(ft, j = blank_columns, width = sep_w, unit = unit)
}
if (!is.null(names(label_rows))) {
j_labs <- names(label_rows)
if (spread_first_col) {
j_labs <- j_labs[!names(label_rows) %in% row_spanner]
label_rows <- label_rows[!names(label_rows) %in% row_spanner]
}
ft <- mk_par(ft,
i = 1, j = j_labs,
value = as_paragraph(as.character(label_rows)),
part = "header"
)
}
if (spread_first_col) {
ft <- align(x = ft, i = !is.na(dat[[row_spanner]]), align = columns_alignment)
}
if (!is.null(x$use_labels)) {
for (labj in names(x$use_labels)) {
if (labj %in% ft$col_keys) {
ft <- labelizor(
x = ft, j = labj,
labels = x$use_labels[[labj]],
part = "all"
)
}
}
}
if (!is.null(x$n_by)) {
sum_x <- visible_columns[
visible_columns$.tab_columns %in% names(x$col_exprs)[1] &
visible_columns$.type. %in% "columns", , drop = FALSE
]
header_row <- length(x$columns)
for (k in seq_len(nrow(x$n_by))) {
mask <- rep(TRUE, nrow(sum_x))
for (col in x$columns) {
mask <- mask & as.character(sum_x[[col]]) == as.character(x$n_by[[col]][k])
}
if (any(mask)) {
ft <- append_chunks(
x = ft,
j = sum_x[mask, "col_keys"][1],
i = header_row, part = "header",
as_chunk(x$n_by$n[k], formatter = fmt_header_n)
)
}
}
}
ft <- autofit(ft, part = "all", add_w = .2, add_h = .0, unit = "cm")
ft <- fix_border_issues(ft, part = "all")
ft
}
# util methods -----
#' @export
#' @describeIn tabulator call `summary()` to get
#' a data.frame describing mappings between variables
#' and their names in the flextable. This data.frame contains
#' a column named `col_keys` where are stored the names that
#' can be used for further selections.
#' @param object an object returned by function
#' `tabulator()`.
summary.tabulator <- function(object, ...) {
hidden_columns <- object$hidden_columns
names(hidden_columns)[names(hidden_columns) %in% ".user_columns"] <- "column"
hidden_columns$.type. <- "hidden"
visible_columns <- object$visible_columns
names(visible_columns)[names(visible_columns) %in% ".tab_columns"] <- "column"
dat <- rbind(visible_columns, hidden_columns)
dat
}
#' @export
#' @importFrom rlang quo_text
#' @title Column keys of tabulator objects
#' @description The function provides a way to get column keys
#' associated with the flextable corresponding to a [tabulator()]
#' object. It helps in customizing or programing with `tabulator`.
#'
#' The function is using column names from the original
#' dataset, eventually filters and returns the names
#' corresponding to the selection.
#' @param x a [tabulator()] object
#' @param columns column names to look for
#' @param type the type of column to look for, it can be:
#'
#' * 'columns': visible columns, corresponding to names provided
#' in the '...' arguments of your call to 'tabulator()'.
#' * 'hidden': unvisible columns, corresponding to names of
#' the original dataset columns.
#' * 'rows': visible columns used as 'row' content
#' * 'rows_supp': visible columns used as 'rows_supp' content
#' * NULL: any type of column
#' @param ... any filter conditions that use variables
#' names, the same than the argument `columns` of function [tabulator()]
#' (`tabulator(columns = c("col1", "col2"))`).
#' @seealso [tabulator()], [as_flextable.tabulator()]
#' @examples
#' library(flextable)
#'
#' cancer_dat <- data.frame(
#' count = c(
#' 9L, 5L, 1L, 2L, 2L, 1L, 9L, 3L, 1L, 10L, 2L, 1L, 1L, 2L, 0L, 3L,
#' 2L, 1L, 1L, 2L, 0L, 12L, 4L, 1L, 7L, 3L, 1L, 5L, 5L, 3L, 10L,
#' 4L, 1L, 4L, 2L, 0L, 3L, 1L, 0L, 4L, 4L, 2L, 42L, 28L, 19L, 26L,
#' 19L, 11L, 12L, 10L, 7L, 10L, 5L, 6L, 5L, 0L, 3L, 4L, 3L, 3L,
#' 1L, 2L, 3L
#' ),
#' risktime = c(
#' 157L, 77L, 21L, 139L, 68L, 17L, 126L, 63L, 14L, 102L, 55L,
#' 12L, 88L, 50L, 10L, 82L, 45L, 8L, 76L, 42L, 6L, 134L, 71L,
#' 22L, 110L, 63L, 18L, 96L, 58L, 14L, 86L, 42L, 10L, 66L,
#' 35L, 8L, 59L, 32L, 8L, 51L, 28L, 6L, 212L, 130L, 101L,
#' 136L, 72L, 63L, 90L, 42L, 43L, 64L, 21L, 32L, 47L, 14L,
#' 21L, 39L, 13L, 14L, 29L, 7L, 10L
#' ),
#' time = rep(as.character(1:7), 3),
#' histology = rep(as.character(1:3), 21),
#' stage = rep(as.character(1:3), each = 21)
#' )
#'
#' datasup_first <- data.frame(
#' time = factor(1:7, levels = 1:7),
#' zzz = runif(7)
#' )
#'
#' z <- tabulator(cancer_dat,
#' rows = "time",
#' columns = c("histology", "stage"),
#' datasup_first = datasup_first,
#' n = as_paragraph(as_chunk(count))
#' )
#'
#' j <- tabulator_colnames(
#' x = z, type = "columns",
#' columns = c("n"),
#' stage %in% 1
#' )
#'
#' src <- tabulator_colnames(
#' x = z, type = "hidden",
#' columns = c("count"),
#' stage %in% 1
#' )
#'
#' if (require("scales")) {
#' colourer <- col_numeric(
#' palette = c("wheat", "red"),
#' domain = c(0, 45)
#' )
#' ft_1 <- as_flextable(z)
#' ft_1 <- bg(
#' ft_1,
#' bg = colourer, part = "body",
#' j = j, source = src
#' )
#' ft_1
#' }
tabulator_colnames <- function(x, columns, ..., type = NULL) {
dat <- summary(x)
if (!is.null(type)) {
dat <- dat[dat$.type. %in% type, ]
}
exprs <- enquos(...)
exprs_evals <- lapply(exprs, function(expr_filter, dat) {
check_filter_expr(expr_filter, dat)
eval_tidy({{ expr_filter }}, data = dat)
}, dat = dat)
exprs_evals <- append(exprs_evals, list(dat$column %in% columns))
keep <- Reduce(`&`, exprs_evals)
dat["col_keys"][keep, ]
}
#' @export
print.tabulator <- function(x, ...) {
cat("layout:\n")
cat(
"* row(s): ",
paste0("`", x$rows, "`", collapse = ", "),
"\n"
)
cat(
"* column(s): ",
paste0("`", x$columns, "`", collapse = ", "),
"\n"
)
cat(
"* content(s): ",
paste0("`", names(x$col_exprs), "`", collapse = ", "),
"\n"
)
visible_columns <- x$visible_columns
columns_keys <- visible_columns[visible_columns$.type. %in% "columns" & !visible_columns[[".tab_columns"]] %in% "dummy", "col_keys"]
cat("\ncol_keys: c(",
paste0(shQuote(columns_keys, type = "cmd"), collapse = ", "),
")\n",
sep = ""
)
print(as.data.table(x$data))
invisible()
}
# utils -----
#' @importFrom rlang quo_text
check_filter_expr <- function(filter_expr, x) {
filter_varnames <- all.vars(filter_expr)
missing_varnames <- setdiff(filter_varnames, colnames(x))
if (length(missing_varnames) > 0) {
stop(
sprintf(
"`%s` is using unknown variable(s): %s",
quo_text(filter_expr),
paste0("`", missing_varnames, "`", collapse = ",")
),
call. = FALSE
)
}
}
add_fake_columns <- function(x, fake_columns) {
x[fake_columns] <- rep(list(character(nrow(x))), length(fake_columns))
x
}
merge_additional_dataset <- function(a, b, rows) {
if (!is.null(b)) {
by <- intersect(rows, colnames(b))
a$.keep_order_a <- seq_len(nrow(a))
b$.keep_order_b <- seq_len(nrow(b))
z <- merge(a, b, by = by, all.x = TRUE, all.y = FALSE)
z <- z[order(z$.keep_order_a, z$.keep_order_b), ]
z[c(".keep_order_a", ".keep_order_b")] <- list(NULL, NULL)
a <- z
}
a
}
#' @importFrom data.table setorderv
map_visible_columns <- function(dat, columns, rows, value_names = character(0),
supp_colnames = character(0),
supp_colnames_last = character(0)) {
dat <- dat[c(columns, rows)]
dat[value_names] <- lapply(value_names, function(x, n) character(n), n = nrow(dat))
dat <- as.data.table(dat)
dat <- melt(as.data.table(dat),
id.vars = c(rows, columns),
measure.vars = value_names, variable.name = ".tab_columns"
)
setorderv(dat, cols = c(rows, columns))
columns <- c(columns, ".tab_columns")
ldims <- dat[, .SD, .SDcols = columns]
ldims <- unique(ldims)
setorderv(ldims, cols = columns[-length(columns)]) # important - order matters
uid_cols <- columns
last_m1_column <- length(columns) - 1
ldims <- split(ldims, rleid(ldims[[last_m1_column]]))
ldims <- lapply(ldims, function(x, j) {
x1 <- x[1, ]
x1[, j] <- "dummy"
rbind(x, x1)
}, j = seq(last_m1_column, length(columns), by = 1L))
ldims <- do.call(rbind, ldims)
sel_columns <- columns[seq_len(length(columns) - 2)]
for (j in rev(seq_along(sel_columns))) {
# Check if any group has more than 1 row (only then do we need separators)
group_sizes <- table(rleid(ldims[[j]]))
if (all(group_sizes <= 1)) next
ldims <- split(ldims, rleid(ldims[[j]]))
ldims <- lapply(ldims, function(x, j) {
x[nrow(x), j] <- "dummy"
x
}, j = j)
ldims <- do.call(rbind, ldims)
}
ldims <- ldims[-nrow(ldims), ]
rdims <- lapply(rows, function(x, n) rep(x, n), n = ncol(ldims))
rdims <- do.call(rbind, rdims)
x1 <- rdims[1, ]
x1[] <- "dummy"
rdims <- rbind(rdims, x1)
colnames(rdims) <- names(ldims)
rdims <- as.data.frame(rdims, row.names = FALSE)
rdims_supp <- NULL
if (length(supp_colnames) > 0) {
rdims_supp <- lapply(supp_colnames, function(x, n) rep(x, n), n = ncol(ldims))
rdims_supp <- do.call(rbind, rdims_supp)
x1 <- rdims_supp[1, ]
x1[] <- "dummy"
rdims_supp <- rbind(rdims_supp, x1)
colnames(rdims_supp) <- names(ldims)
rdims_supp <- as.data.frame(rdims_supp, row.names = FALSE)
rdims_supp$.type. <- "rows_supp"
}
rdims_supp_last <- NULL
if (length(supp_colnames_last) > 0) {
rdims_supp_last <- lapply(supp_colnames_last, function(x, n) rep(x, n), n = ncol(ldims))
rdims_supp_last <- do.call(rbind, rdims_supp_last)
x1 <- rdims_supp_last[1, ]
x1[] <- "dummy"
rdims_supp_last <- rbind(x1, rdims_supp_last)
colnames(rdims_supp_last) <- names(ldims)
rdims_supp_last <- as.data.frame(rdims_supp_last, row.names = FALSE)
rdims_supp_last$.type. <- "rows_supp_last"
}
ldims$.type. <- "columns"
rdims$.type. <- "rows"
last_column <- columns[length(columns)]
dims <- rbind(rdims, rdims_supp, ldims, rdims_supp_last)
is_dummy <- dims[[last_column]] %in% "dummy"
dims$col_keys <- do.call(paste, append(as.list(dims[uid_cols]), list(sep = "@")))
if (length(value_names) > 1) {
dims$col_keys <- paste0(dims$.stat_name, "@", dims$col_keys)
}
dims$col_keys[is_dummy] <- paste0("dummy", seq_len(sum(is_dummy)))
dims$col_keys[dims$.type. %in% "rows" & !is_dummy] <- dims[[last_column]][dims$.type. %in% "rows" & !is_dummy]
dims$col_keys[dims$.type. %in% "rows_supp" & !is_dummy] <- dims[[last_column]][dims$.type. %in% "rows_supp" & !is_dummy]
dims$col_keys[dims$.type. %in% "rows_supp_last" & !is_dummy] <- dims[[last_column]][dims$.type. %in% "rows_supp_last" & !is_dummy]
setDF(dims)
dims
}
map_hidden_columns <- function(dat, columns, rows) {
user_columns <- setdiff(colnames(dat), c(columns, rows))
dat <- as.data.table(dat)
dat[, c(user_columns) :=
lapply(.SD, function(x) character(length(x))), .SDcols = user_columns]
dat <- melt(as.data.table(dat),
id.vars = c(columns, rows),
measure.vars = user_columns, variable.name = ".user_columns"
)
columns <- c(columns, ".user_columns")
dims <- dat[, .SD, .SDcols = columns]
setDF(dat)
dims <- unique(dims)
dims$col_keys <- do.call(paste, append(as.list(dims[, .SD, .SDcols = columns[-length(columns)]]), list(sep = "@")))
dims$col_keys <- paste0(dims$.user_columns, "@", dims$col_keys)
setDF(dims)
dims
}
flextable/R/table-properties.R 0000644 0001762 0000144 00000022273 15143103203 016023 0 ustar ligges users #' @importFrom officer table_layout table_width table_colwidths prop_table
#' @export
#' @title Set table layout and width properties
#' @description Set table layout and table width. Default to fixed
#' algorithm.
#'
#' If layout is fixed, column widths will be used to display the table;
#' `width` is ignored.
#'
#' If layout is autofit, column widths will not be used;
#' table width is used (as a percentage).
#' @note
#' PowerPoint output ignore 'autofit layout'.
#' @inheritParams args_x_only
#' @param layout 'autofit' or 'fixed' algorithm. Default to 'fixed'.
#' @param width The parameter has a different effect depending on the
#' output format. Users should consider it as a minimum width.
#' In HTML, it is the minimum width of the space that the
#' table should occupy. In Word, it is a preferred size and Word
#' may decide not to strictly stick to it. It has no effect on
#' PowerPoint and PDF output. Its default value is 0, as an effect, it
#' only use necessary width to display all content. It is not used by the
#' PDF output.
#' @param align alignment in document (only Word, HTML and PDF),
#' supported values are 'left', 'center' and 'right'.
#' @param opts_html html options as a list. Supported elements are:
#' - 'extra_css': extra css instructions to be integrated with the HTML
#' code of the table.
#' - 'scroll': NULL or a list if you want to add a scroll-box.
#' - Use an empty list to add an horizontal scroll. The with
#' is fixed, corresponding to the container's width.
#' - If the list has a value named `height` it will be used as
#' height and the scroll will happen also vertically. The height
#' will be in pixel if numeric, if a string it should be a valid css
#' measure.
#' - If the list has a value named `freeze_first_column` set to `TRUE`,
#' the first column is set as a *sticky* column.
#' - If the list has a value named `add_css` it will be used as extra
#' css to add, .i.e: `border:1px solid red;`.
#' - 'extra_class': extra classes to add in the table tag
#' @param opts_word Word options as a list. Supported elements are:
#' - 'split': Word option 'Allow row to break across pages' can be
#' activated when TRUE.
#' - 'keep_with_next': Word option 'keep rows together' is
#' activated when TRUE. It avoids page break within tables. This
#' is handy for small tables, i.e. less than a page height.
#' - 'repeat_headers': Word option 'Repeat as header row' is
#' activated and associated to header rows when TRUE.
#' @param opts_pdf PDF options as a list. Supported elements are:
#' - 'tabcolsep': space between the text and the left/right border of its containing
#' cell.
#' - 'arraystretch': height of each row relative to its default
#' height, the default value is 1.5.
#' - 'float': type of floating placement in the PDF document, one of:
#' * 'none' (the default value), table is placed after the preceding
#' paragraph.
#' * 'float', table can float to a place in the text where it fits best
#' * 'wrap-r', wrap text around the table positioned to the right side of the text
#' * 'wrap-l', wrap text around the table positioned to the left side of the text
#' * 'wrap-i', wrap text around the table positioned inside edge-near the binding
#' * 'wrap-o', wrap text around the table positioned outside edge-far from the binding
#' - 'fonts_ignore': if TRUE, pdf-engine 'pdflatex' can be used instead of
#' 'xelatex' or 'lualatex.' If pdflatex is used, fonts will be ignored because they are
#' not supported by pdflatex, whereas with the xelatex and lualatex engines they are.
#' - 'caption_repeat': a boolean that indicates if the caption should be
#' repeated along pages. Its default value is `TRUE`.
#' - 'footer_repeat': a boolean that indicates if the footer should be
#' repeated along pages. Its default value is `TRUE`.
#' - 'default_line_color': default line color, restored globally after
#' the flextable is produced.
#' @param word_title alternative text for Word table (used as title of the table)
#' @param word_description alternative text for Word table (used as description of the table)
#' @examples
#' library(flextable)
#' ft_1 <- flextable(head(cars))
#' ft_1 <- autofit(ft_1)
#' ft_2 <- set_table_properties(ft_1, width = .5, layout = "autofit")
#' ft_2
#' ft_3 <- set_table_properties(ft_1, width = 1, layout = "autofit")
#'
#' # add scroll for HTML ----
#' set.seed(2)
#' dat <- lapply(1:14, function(x) rnorm(n = 20))
#' dat <- setNames(dat, paste0("colname", 1:14))
#' dat <- as.data.frame(dat)
#'
#' ft_4 <- flextable(dat)
#' ft_4 <- colformat_double(ft_4)
#' ft_4 <- bg(ft_4, j = 1, bg = "#DDDDDD", part = "all")
#' ft_4 <- bg(ft_4, i = 1, bg = "#DDDDDD", part = "header")
#' ft_4 <- autofit(ft_4)
#' ft_4 <- set_table_properties(
#' x = ft_4,
#' opts_html = list(
#' scroll = list(
#' height = "500px",
#' freeze_first_column = TRUE
#' )
#' )
#' )
#' ft_4
#' @seealso [flextable()], [as_flextable()], [autofit()],
#' [knit_print.flextable()]
set_table_properties <- function(
x,
layout = "fixed",
width = 0,
align = NULL,
opts_html = list(),
opts_word = list(),
opts_pdf = list(),
word_title = NULL,
word_description = NULL
) {
stopifnot(
`wrong layout value` = layout %in% c("fixed", "autofit"),
`width is not numeric` = is.numeric(width),
`width is > 1` = width <= 1
)
if (!is.null(word_title)) {
stopifnot(
is.character(word_title),
length(word_title) == 1
)
stopifnot(
is.character(word_description),
length(word_description) == 1
)
}
x$properties <- list(
layout = layout,
width = width,
align = if (is.null(align)) get_flextable_defaults()$table_align else align,
opts_html = do.call(opts_ft_html, opts_html),
opts_word = do.call(opts_ft_word, opts_word),
opts_pdf = do.call(opts_ft_pdf, opts_pdf),
word_title = word_title,
word_description = word_description
)
x
}
opts_ft_html <- function(
extra_css = get_flextable_defaults()$extra_css,
scroll = get_flextable_defaults()$scroll,
extra_class = NULL,
...
) {
if (
!is.character(extra_css) || length(extra_css) != 1 || any(is.na(extra_css))
) {
stop(
sprintf("'%s' is expected to be a single %s.", "extra_css", "character"),
call. = FALSE
)
}
if (!is.null(scroll) && !is.list(scroll)) {
stop(
sprintf("'%s' is expected to be %s.", "scroll", "NULL or a list"),
call. = FALSE
)
}
z <- list(extra_css = extra_css, scroll = scroll, extra_class = extra_class)
class(z) <- "opts_ft_html"
z
}
opts_ft_word <- function(
split = get_flextable_defaults()$split,
keep_with_next = get_flextable_defaults()$keep_with_next,
repeat_headers = TRUE
) {
if (!is.logical(split) || length(split) != 1) {
stop(
sprintf("'%s' is expected to be a single %s.", "split", "logical"),
call. = FALSE
)
}
if (!is.logical(keep_with_next) || length(keep_with_next) != 1) {
stop(
sprintf(
"'%s' is expected to be a single %s.",
"keep_with_next",
"logical"
),
call. = FALSE
)
}
if (!is.logical(repeat_headers) || length(repeat_headers) != 1) {
stop(
sprintf(
"'%s' is expected to be a single %s.",
"repeat_headers",
"logical"
),
call. = FALSE
)
}
z <- list(
split = split,
keep_with_next = keep_with_next,
repeat_headers = repeat_headers
)
class(z) <- "opts_ft_word"
z
}
opts_ft_pdf <- function(
tabcolsep = get_flextable_defaults()$tabcolsep,
arraystretch = get_flextable_defaults()$arraystretch,
float = get_flextable_defaults()$float,
fonts_ignore = get_flextable_defaults()$fonts_ignore,
caption_repeat = TRUE,
footer_repeat = FALSE,
default_line_color = "black"
) {
if (!is.logical(fonts_ignore) || length(fonts_ignore) != 1) {
stop(
sprintf("'%s' is expected to be a single %s.", "fonts_ignore", "logical"),
call. = FALSE
)
}
if (
!is.numeric(tabcolsep) || length(tabcolsep) != 1 || any(sign(tabcolsep) < 0)
) {
stop(
sprintf(
"'%s' is expected to be a single %s.",
"tabcolsep",
"positive number"
),
call. = FALSE
)
}
if (
!is.numeric(arraystretch) ||
length(arraystretch) != 1 ||
any(sign(arraystretch) < 0)
) {
stop(
sprintf(
"'%s' is expected to be a single %s.",
"arraystretch",
"positive number"
),
call. = FALSE
)
}
if (
!is.character(float) ||
length(float) != 1 ||
!all(
float %in% c("none", "float", "wrap-r", "wrap-l", "wrap-i", "wrap-o")
)
) {
stop(
sprintf(
"'%s' is expected to be a single %s.",
"float",
"character (one of 'none', 'float', 'wrap-r', 'wrap-l', 'wrap-i', 'wrap-o')"
),
call. = FALSE
)
}
if (!is.logical(caption_repeat) || length(caption_repeat) != 1) {
stop(
sprintf("'%s' is expected to be a single %s.", "caption_repeat", "logical"),
call. = FALSE
)
}
z <- list(
tabcolsep = tabcolsep,
arraystretch = arraystretch,
float = float,
default_line_color = default_line_color,
caption_repeat = caption_repeat,
footer_repeat = footer_repeat,
fonts_ignore = fonts_ignore
)
class(z) <- "opts_ft_pdf"
z
}
flextable/R/00_utils.R 0000644 0001762 0000144 00000010071 15131745533 014211 0 ustar ligges users colcode <- function(x) {
rgb(t(col2rgb(x, alpha = TRUE)), maxColorValue = 255)
}
colcodecss <- function(x) {
args <- as.list(as.data.frame(t(col2rgb(x, alpha = TRUE))))
args$alpha <- args$alpha / 255
args$fmt <- "rgba(%.0f, %.0f, %.0f, %.2f)"
do.call(sprintf, args)
}
colalpha <- function(x) {
x[x %in% "transparent"] <- "#FFFFFF00"
rgbvals <- col2rgb(x, alpha = TRUE)
as.integer(rgbvals[4, ] / 255 * 100000)
}
colcode0 <- function(x) {
x[x %in% "transparent"] <- "#FFFFFF00"
substr(rgb(t(col2rgb(x, alpha = TRUE)), maxColorValue = 255), 2, 7)
}
check_choice <- function(value, choices) {
varname <- as.character(substitute(value))
if (is.character(value) && length(value) == 1) {
if (!value %in% choices) {
stop(
sprintf(
"%s is expected to be one of: %s",
varname, paste(shQuote(choices))
),
call. = FALSE
)
}
} else {
stop(sprintf("`%s` must be a character scalar.", varname), call. = FALSE)
}
TRUE
}
cast_borders <- function(value) {
borders_id <- c("border.bottom", "border.top", "border.left", "border.right")
borders_side <- c("bottom", "top", "left", "right")
z <- mapply(function(name, fp_b) {
x <- unclass(fp_b)
if (is.null(x)) {
x <- list(width = NA_integer_, color = NA_character_, style = NA_character_)
}
names(x) <- paste("border", c("width", "color", "style"), name, sep = ".")
x
}, borders_side, value[borders_id], SIMPLIFY = FALSE, USE.NAMES = FALSE)
z <- Reduce(f = append, z)
value <- append(value, z)
value[borders_id] <- NULL
value
}
as_struct <- function(nrow, keys, pr, fun) {
args <- pr
args$nrow <- nrow
args$keys <- keys
borders_id <- c("border.bottom", "border.top", "border.left", "border.right")
borders_side <- c("bottom", "top", "left", "right")
avail_bdr_id <- borders_id %in% names(pr)
bdr_id <- borders_id[avail_bdr_id]
bdr_side <- borders_side[avail_bdr_id]
z <- mapply(function(name, fp_b) {
x <- unclass(fp_b)
names(x) <- paste("border", names(x), name, sep = ".")
x
}, bdr_side, pr[bdr_id], SIMPLIFY = FALSE, USE.NAMES = FALSE)
z <- Reduce(f = append, z)
args <- append(args, z)
args[bdr_id] <- NULL
obj_str <- do.call(fun, args)
obj_str
}
base_ns <- "xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\""
wml_image <- function(src, width, height) {
str <- paste0(
sprintf("
#'
#' See https://www.ardata.fr/en/flextable-gallery/2022-06-23-separate-headers/ for the example
#' shown
#' }}
#' @inheritParams args_selectors_without_all
#' @param value a call to function [as_paragraph()].
#' @param ref_symbols character value, symbols to append that will be used
#' as references to notes.
#' @param inline whether to add footnote on same line as previous footnote or not
#' @param sep used only when inline = TRUE, character string to use as
#' a separator between footnotes.
#' @param symbol_sep separator to insert between multiple
#' footnote symbols in the same cell (e.g. `","` to
#' produce `1,2` instead of `12`). Default is `""`
#' (no separator, backward compatible).
#' @examples
#' ft_1 <- flextable(head(iris))
#' ft_1 <- footnote(ft_1,
#' i = 1, j = 1:3,
#' value = as_paragraph(
#' c(
#' "This is footnote one",
#' "This is footnote two",
#' "This is footnote three"
#' )
#' ),
#' ref_symbols = c("a", "b", "c"),
#' part = "header"
#' )
#' ft_1 <- valign(ft_1, valign = "bottom", part = "header")
#' ft_1 <- autofit(ft_1)
#'
#' ft_2 <- flextable(head(iris))
#' ft_2 <- autofit(ft_2)
#' ft_2 <- footnote(ft_2,
#' i = 1, j = 1:2,
#' value = as_paragraph(
#' c(
#' "This is footnote one",
#' "This is footnote two"
#' )
#' ),
#' ref_symbols = c("a", "b"),
#' part = "header", inline = TRUE
#' )
#' ft_2 <- footnote(ft_2,
#' i = 1, j = 3:4,
#' value = as_paragraph(
#' c(
#' "This is footnote three",
#' "This is footnote four"
#' )
#' ),
#' ref_symbols = c("c", "d"),
#' part = "header", inline = TRUE
#' )
#' ft_2
#'
#' ft_3 <- flextable(head(iris))
#' ft_3 <- autofit(ft_3)
#' ft_3 <- footnote(
#' x = ft_3, i = 1:3, j = 1:3,
#' ref_symbols = "a",
#' value = as_paragraph("This is footnote one")
#' )
#' ft_3
#' @export
#' @importFrom stats update
footnote <- function(x, i = NULL, j = NULL, value,
ref_symbols = NULL, part = "body",
inline = FALSE, sep = "; ",
symbol_sep = "") {
if (!inherits(x, "flextable")) {
stop(sprintf("Function `%s` supports only flextable objects.", "footnote()"))
}
if (!inherits(value, "paragraph")) {
stop("`value` must be a paragraph.")
}
part <- match.arg(part, c("body", "header", "footer"),
several.ok = FALSE
)
if (nrow_part(x, part) < 1) {
return(x)
}
check_formula_i_and_part(i, part)
i <- get_rows_id(x[[part]], i)
j <- get_columns_id(x[[part]], j)
if (length(i) < 1) {
return(x)
}
if (is.null(ref_symbols)) {
symbols_str <- as.character(seq_along(value))
} else {
symbols_str <- ref_symbols
}
if (any(symbols_str %in% "")) {
long_msg <- c(
"Usage of empty symbol '' with footnote should not happen, ",
"use `add_footer_lines()` instead, it does not require any symbol. "
)
long_msg <- paste0(long_msg, collapse = "\n")
stop(long_msg)
}
sep_str <- rep(sep, length(value))
cell_index <- data.frame(i = i, j = j)
if (length(symbols_str) == 1) {
symbols_str <- rep(symbols_str, nrow(cell_index))
}
# Assert that either one footnote, or that footnote symbol length matches number
# of cells to tag
stopifnot(length(symbols_str) == nrow(cell_index))
for (index_num in seq_len(nrow(cell_index))) {
i_cell <- cell_index[["i"]][index_num]
j_cell <- cell_index[["j"]][index_num]
if (nzchar(symbol_sep)) {
cell_para <- get_fpstruct_elements(
x = x[[part]]$content,
i = i_cell,
j = x$col_keys[j_cell]
)[[1, 1]]
last_valign <- cell_para$vertical.align[
nrow(cell_para)
]
if (isTRUE(last_valign == "superscript")) {
x <- append_chunks(x,
i = i_cell, j = j_cell,
part = part,
as_sup(symbol_sep)
)
}
}
x <- append_chunks(x,
i = i_cell, j = j_cell,
part = part,
as_sup(symbols_str[index_num])
)
}
if (inline) {
# init a new line
if (nrow_part(x, "footer") < 1) {
x <- add_footer_lines(x, values = "")
n_row <- 1
} else {
n_row <- nrow_part(x, "footer")
target_par <- get_fpstruct_elements(
x = x[["footer"]]$content,
i = n_row,
j = 1)[[1,1]]
}
paras <- mapply(rbind,
as_paragraph(as_sup(ref_symbols)),
value,
as_paragraph(sep_str),
SIMPLIFY = FALSE
)
paras <- rbind_match_columns(paras)
paras$.chunk_index <- NULL
for(i in seq_len(nrow(paras))) {
x[["footer"]]$content <-
append_chunkset_struct_element(
x = x[["footer"]]$content,
i = n_row,
j = 1,
chunk_data = paras[i,]
)
}
} else {
# init new lines
n_row <- nrow_part(x, "footer")
x <- add_footer_lines(x, values = rep("", length(value)))
newcontent <- as_chunkset_struct(
l_paragraph = value, keys = x$col_keys[1])
x[["footer"]]$content <- set_chunkset_struct_element(
x = x[["footer"]]$content,
i = n_row + seq_along(value), j = 1,
value = newcontent
)
for (v in seq_along(value)) {
x <- prepend_chunks(
x = x, i = n_row + v, j = 1,
part = "footer",
as_sup(symbols_str[v])
)
}
}
x
}
flextable/R/as_flextable.tabular.R 0000644 0001762 0000144 00000027064 15131745533 016646 0 ustar ligges users #' @export
#' @title Transform a 'tables::tabular' object into a flextable
#' @description Produce a flextable from a 'tabular' object
#' produced with function [tables::tabular()].
#'
#' When `as_flextable.tabular=TRUE`, the first column is
#' used as row separator acting as a row title. It can
#' be formated with arguments `fp_p` (the formatting
#' properties of the paragraph) and `row_title` that
#' specifies the content and eventually formattings
#' of the content.
#'
#' Two hidden columns can be used for conditional formatting
#' after the creation of the flextable (use only when
#' `spread_first_col=TRUE`):
#'
#' - The column `.row_title` that contains the title label
#' - The column `.type` that can contain the following values:
#' - "one_row": Indicates that there is only one row for this group. In this case, the row is not expanded with a title above.
#' - "list_title": Indicates a row that serves as a title for the data that are displayed after it.
#' - "list_data": Indicates rows that follow a title and contain data to be displayed.
#'
#' The result is paginated (see [paginate()]).
#' @param x object produced by [tables::tabular()].
#' @param spread_first_col if TRUE, first row is spread as a new line separator
#' instead of being a column. This helps to reduce the width and allows for
#' clear divisions.
#' @param fp_p paragraph formatting properties associated with row titles,
#' see [officer::fp_par()].
#' @param row_title a call to [as_paragraph()] - it
#' will be applied to the row titles if any
#' when `spread_first_col=TRUE`.
#' @param add_tab adds a tab in front of "list_data"
#' label lines (located in column `.type`).
#' @param ... unused argument
#' @family as_flextable methods
#' @examples
#' if (require("tables")) {
#' set.seed(42)
#' genders <- c("Male", "Female")
#' status <- c("low", "medium", "high")
#' Sex <- factor(sample(genders, 100, rep = TRUE))
#' Status <- factor(sample(status, 100, rep = TRUE))
#' z <- rnorm(100) + 5
#' fmt <- function(x) {
#' s <- format(x, digits = 2)
#' even <- ((1:length(s)) %% 2) == 0
#' s[even] <- sprintf("(%s)", s[even])
#' s
#' }
#' tab <- tabular(
#' Justify(c) * Heading() * z *
#' Sex * Heading(Statistic) *
#' Format(fmt()) *
#' (mean + sd) ~ Status
#' )
#' as_flextable(tab)
#' }
#'
#' if (require("tables")) {
#' tab <- tabular(
#' (Species + 1) ~ (n = 1) + Format(digits = 2) *
#' (Sepal.Length + Sepal.Width) * (mean + sd),
#' data = iris
#' )
#' as_flextable(tab)
#' }
#'
#' if (require("tables")) {
#' x <- tabular((Factor(gear, "Gears") + 1)
#' * ((n = 1) + Percent()
#' + (RowPct = Percent("row"))
#' + (ColPct = Percent("col")))
#' ~ (Factor(carb, "Carburetors") + 1)
#' * Format(digits = 1), data = mtcars)
#'
#' ft <- as_flextable(
#' x,
#' spread_first_col = TRUE,
#' row_title = as_paragraph(
#' colorize("Gears: ", color = "#666666"),
#' colorize(as_b(.row_title), color = "red")
#' )
#' )
#' ft
#' }
#'
#' if (require("tables")) {
#' tab <- tabular(
#' (mean + mean) * (Sepal.Length + Sepal.Width) ~ 1,
#' data = iris
#' )
#' as_flextable(tab)
#' }
as_flextable.tabular <- function(x,
spread_first_col = FALSE,
fp_p = fp_par(text.align = "center", padding.top = 4),
row_title = as_paragraph(as_chunk(.row_title)),
add_tab = FALSE,
...) {
stopifnot(requireNamespace("tables", quietly = TRUE))
body_data <- fortify_tabular_body(x)
header_data <- fortify_tabular_header(x)
text_align <- fortify_tabular_justify(x)
vmerge_ins <- vmerge_instructions(x)
hmerge_ins <- hmerge_instructions(x)
.ncol <- ncol(tables::rowLabels(x))
row_columns <- colnames(vmerge_ins)
data_columns <- setdiff(colnames(body_data), row_columns)
group_colname <- character()
if (spread_first_col) {
group_colname <- row_columns[1]
row_columns <- setdiff(row_columns, group_colname)
.ncol <- .ncol - length(group_colname)
.is_list_title <- is_list_title(body_data[[group_colname]])
.is_one_row <- is_one_row(body_data[[group_colname]])
body_data <- expand_dataset(
body_data = body_data,
is_title = .is_list_title, is_single = .is_one_row,
group_colname = group_colname
)
text_align$body <- expand_dataset(
body_data = as.data.frame(text_align$body),
is_title = .is_list_title, is_single = .is_one_row,
group_colname = group_colname
)
} else {
body_data$.type <- "list_data"
body_data$.row_title <- FALSE
}
columns_keys <- setdiff(c(row_columns, data_columns), group_colname)
vmerge_ins <- vmerge_ins[, setdiff(colnames(vmerge_ins), group_colname), drop = FALSE]
text_align$header <- text_align$header[, setdiff(colnames(text_align$header), group_colname), drop = FALSE]
text_align$body <- text_align$body[, setdiff(colnames(text_align$body), group_colname), drop = FALSE]
if (length(group_colname)) {
body_data$.row_title <- body_data[[group_colname]]
body_data$.row_title[body_data$.type %in% "one_row"] <-
body_data[[row_columns]][body_data$.type %in% "one_row"]
}
ft <- flextable(body_data, col_keys = columns_keys)
ft <- set_header_df(ft, mapping = header_data)
ft <- merge_v(ft, part = "header", j = row_columns)
for (i in seq_along(hmerge_ins)) {
hgroups <- split(seq_len(nrow(hmerge_ins)), hmerge_ins[[i]])
for (hgroup in hgroups) {
ft <- merge_at(ft, part = "header", j = hgroup + .ncol, i = i)
}
}
if (spread_first_col) {
for (j in setdiff(names(vmerge_ins), ".type")) {
vgroups <- split(seq_len(nrow(vmerge_ins)), vmerge_ins[[j]])
for (vgroup in vgroups) {
ft <- merge_at(ft, part = "body", j = j, i = vgroup)
}
}
}
ft <- do.call(get_flextable_defaults()$theme_fun, list(ft))
for (j in columns_keys) {
ft <- align(ft, j = j, align = text_align$header[, j], part = "header")
aligns <- text_align$body[, j]
if (".type" %in% colnames(text_align$body)) {
aligns <- aligns[text_align$body$.type %in% c("one_row", "list_data")]
}
ft <- align(ft,
j = j, i = ~ .type %in% c("one_row", "list_data"),
align = aligns, part = "body"
)
}
ft <- valign(ft, valign = "top", part = "body")
ft <- valign(ft, valign = "bottom", part = "header")
# format functions can not be simply called
# then, it looks easier to call format.tabular
# and inject its trimmed values. That way we
# preserve data types and can do conditionnal
# formatting
strmat <- format(x)
colnames(strmat) <- data_columns
rindex <- body_data$.type %in% c("one_row", "list_data")
newcontent <- get_chunkset_struct_element(
x = ft[["body"]]$content,
i = rindex, j = data_columns)
newtext <- trimws(strmat[, data_columns, drop = FALSE])
for(j in data_columns) {
for(irow in seq_len(nrow(newtext))) {
newcontent[[irow, j]]$txt <- newtext[[irow, j]]
}
}
ft[["body"]]$content <- set_chunkset_struct_element(
x = ft[["body"]]$content,
i = rindex, j = data_columns,
value = newcontent)
if (any(body_data$.type %in% "list_title")) {
ft <- merge_h_range(ft,
i = ~ .type %in% c("list_title"),
j1 = 1L, j2 = length(columns_keys)
)
ft <- mk_par(ft, i = body_data$.type %in% c("list_title", "one_row"), j = 1, value = {{ row_title }})
ft <- style(ft, i = body_data$.type %in% c("list_title", "one_row"), j = 1, pr_p = fp_p, part = "body")
if (add_tab) {
ft <- prepend_chunks(ft, i = ~ .type %in% "list_data", j = 1, as_chunk("\t"))
}
}
ft <- fix_border_issues(ft)
best_widths_ <- dim_pretty(ft)$widths
best_widths_[setdiff(seq_along(columns_keys), seq_len(.ncol))] <- max(best_widths_[setdiff(seq_along(columns_keys), seq_len(.ncol))]) * 1.1
ft <- width(ft, width = best_widths_)
if (spread_first_col) {
ft <- paginate(ft, group = group_colname, group_def = "nonempty")
} else {
ft <- paginate(ft, group = row_columns[1], group_def = "nonempty")
}
ft$tabular_info <- list(
row_columns = row_columns,
data_columns = data_columns
)
ft
}
# utils -----
expand_dataset <- function(
body_data,
is_title, is_single,
group_colname = "COL1") {
body_data$.fakeid <- seq_len(nrow(body_data))
title_dat <- body_data[is_title, ]
title_dat$.fakeid <- title_dat$.fakeid - .1
title_dat <- title_dat[, c(".fakeid", group_colname)]
title_dat$.type <- rep("list_title", nrow(title_dat))
singlerow_dat <- body_data[is_single, ]
singlerow_dat$.fakeid <- singlerow_dat$.fakeid - .1
.col_dest <- head(setdiff(colnames(singlerow_dat), group_colname), 1)
singlerow_dat[[.col_dest]] <- singlerow_dat[[group_colname]]
singlerow_dat[[group_colname]] <- rep(NA_character_, nrow(singlerow_dat))
singlerow_dat$.type <- rep("one_row", nrow(singlerow_dat))
body_data <- body_data[!is_single, ]
body_data[[group_colname]] <- rep(NA_character_, nrow(body_data))
body_data$.type <- rep("list_data", nrow(body_data))
dat <- rbindlist(list(title_dat, singlerow_dat, body_data), use.names = TRUE, fill = TRUE)
dat <- dat[order(dat$.fakeid), ]
dat$.fakeid <- NULL
setDF(dat)
dat
}
vmerge_instructions <- function(x) {
label_data <- tables::rowLabels(x)
label_data <- apply(label_data[], 2, function(z) {
notna <- !is.na(z)
rleid(cumsum(notna))
})
label_data <- as.data.frame(label_data)
colnames(label_data) <- sprintf("COL%.0f", seq_len(ncol(label_data)))
label_data
}
hmerge_instructions <- function(x) {
label_data <- tables::colLabels(x)
label_data <- apply(label_data[], 1, function(z) {
notna <- !is.na(z)
rleid(cumsum(notna))
})
label_data <- as.data.frame(label_data)
label_data
}
fortify_tabular_body <- function(x, ...) {
row_labels <- as.data.frame(unclass(tables::rowLabels(x)))
names(row_labels) <- sprintf("COL%.0f", seq_len(ncol(row_labels)))
dims <- attr(x, "dim")
celldata <- matrix(x[], nrow = dims[1], ncol = dims[2])
celldata <- apply(celldata, 2, function(dat) {
unlist(dat)
})
celldata <- as.data.frame(celldata)
names(celldata) <- sprintf("COL%.0f", seq_len(ncol(celldata)) + ncol(row_labels))
cbind(row_labels, celldata)
}
fortify_tabular_header <- function(x, ...) {
col_labels <- as.data.frame(unclass(tables::colLabels(x)))
row_labels <- matrix(
rep(colnames(tables::rowLabels(x)), nrow(col_labels)),
nrow = nrow(col_labels), byrow = TRUE
)
dat <- cbind(row_labels, col_labels)
dat <- t(dat)
dat <- as.data.frame(dat)
dat$col_keys <- sprintf("COL%.0f", seq_len(nrow(dat)))
dat
}
fortify_tabular_justify <- function(x, justification = "c", ...) {
justify <- attr(x, "justification")
rlabels <- tables::rowLabels(x)
rjustify <- attr(rlabels, "justification")
clabels <- tables::colLabels(x)
cjustify <- attr(clabels, "justification")
corjustify <- matrix(NA, nrow(clabels), ncol(rlabels))
for (i in seq_len(ncol(rlabels))) {
corjustify[nrow(clabels), i] <- rjustify[1, i]
}
justify <- rbind(
cbind(corjustify, cjustify),
cbind(rjustify, justify)
)
justify[is.na(justify)] <- justification
justify[] <- c(l = "left", c = "center", r = "right", n = "left")[justify]
colnames(justify) <- sprintf("COL%.0f", seq_len(ncol(justify)))
list(
header = justify[seq_len(nrow(clabels)), , drop = FALSE],
body = justify[setdiff(seq_len(nrow(justify)), seq_len(nrow(clabels))), , drop = FALSE]
)
}
is_list_title <- function(x) {
lag_str <- c(tail(x, -1), "")
!is.na(x) & is.na(lag_str)
}
is_one_row <- function(x) {
lag_str <- c(tail(x, -1), "")
!is.na(x) & !is.na(lag_str)
}
flextable/R/05_content.R 0000644 0001762 0000144 00000070761 15143353350 014537 0 ustar ligges users #' @export
#' @title Create a chunk representation suitable for flextable
#' @description This function is to be used by external packages
#' that want to provide an object that can be inserted as a chunk
#' object in paragraphs of a flextable object.
#' @param ... values to set.
#' @section text pattern with default values:
#'
#' ```
#' chunk_dataframe(txt = c("any text", "other text"))
#' ```
#' @section text pattern with bold set to TRUE:
#'
#' ```
#' chunk_dataframe(
#' txt = c("any text", "other text"),
#' bold = c(TRUE, TRUE))
#' ```
#' @section text pattern with control over all formatting properties:
#'
#' ```
#' chunk_dataframe(
#' txt = c("any text", "other text"),
#' font.size = c(12, 10),
#' italic = c(FALSE, TRUE),
#' bold = c(FALSE, TRUE),
#' underlined = c(FALSE, TRUE),
#' strike = c(FALSE, TRUE),
#' color = c("black", "red"),
#' shading.color = c("transparent", "yellow"),
#' font.family = c("Arial", "Arial"),
#' hansi.family = c("Arial", "Arial"),
#' eastasia.family = c("Arial", "Arial"),
#' cs.family = c("Arial", "Arial"),
#' vertical.align = c("top", "bottom") )
#' ```
#' @section text with url pattern:
#' ```
#' chunk_dataframe(
#' txt = c("any text", "other text"),
#' url = rep("https://www.google.fr", 2),
#' font.size = c(12, 10),
#' italic = c(FALSE, TRUE),
#' bold = c(FALSE, TRUE),
#' underlined = c(FALSE, TRUE),
#' strike = c(FALSE, TRUE),
#' color = c("black", "red"),
#' shading.color = c("transparent", "yellow"),
#' font.family = c("Arial", "Arial"),
#' hansi.family = c("Arial", "Arial"),
#' eastasia.family = c("Arial", "Arial"),
#' cs.family = c("Arial", "Arial"),
#' vertical.align = c("top", "bottom") )
#' ```
#' @section images pattern:
#' ```
#' chunk_dataframe(width = width, height = height, img_data = files )
#' ```
#' @keywords internal
#' @return a data.frame with an additional class "chunk" that makes it
#' suitable for beeing used in [as_paragraph()]
chunk_dataframe <- function(...) {
x <- list(...)
img_data <- x$img_data
x$img_data <- NULL
x <- as.data.frame(x, stringsAsFactors = FALSE)
def_chr <- rep(NA_character_, nrow(x))
def_dbl <- rep(NA_real_, nrow(x))
def_lgl <- as.logical(rep(NA_integer_, nrow(x)))
def_lst <- rep(list(NULL), nrow(x))
data0 <- data.frame(
txt = def_chr,
font.size = def_dbl,
italic = def_lgl,
bold = def_lgl,
underlined = def_lgl,
strike = def_lgl,
color = def_chr,
shading.color = def_chr,
font.family = def_chr,
hansi.family = def_chr,
eastasia.family = def_chr,
cs.family = def_chr,
vertical.align = def_chr,
width = def_dbl,
height = def_dbl,
url = def_chr,
eq_data = def_chr,
word_field_data = def_chr,
qmd_data = def_chr,
stringsAsFactors = FALSE
)
data0$img_data <- def_lst
data0[names(x)] <- x
if (!is.null(img_data)) {
data0$img_data <- img_data
}
class(data0) <- c("chunk", "data.frame")
data0
}
default_fptext_prop <- structure(
list(
font.size = NA_real_,
bold = as.logical(NA_integer_),
italic = as.logical(NA_integer_),
underlined = as.logical(NA_integer_),
strike = as.logical(NA_integer_),
color = NA_character_,
shading.color = NA_character_,
font.family = NA_character_,
hansi.family = NA_character_,
eastasia.family = NA_character_,
cs.family = NA_character_,
vertical.align = NA_character_
),
class = "fp_text"
)
#' @export
#' @title Text chunk
#' @description The function lets add formated text in flextable
#' cells.
#'
#' It is used to add it to the content of a cell of the
#' flextable with the functions [compose()], [append_chunks()]
#' or [prepend_chunks()].
#'
#' It should be used inside a call to [as_paragraph()].
#' @param x text or any element that can be formatted as text
#' with function provided in argument `formatter`.
#' @param props an [fp_text_default()] or [officer::fp_text()] object to be used to format the text.
#' If not specified, it will be the default value corresponding to the cell.
#' @param formatter a function that will format x as a character vector.
#' @param ... additional arguments for `formatter` function.
#' @family chunk elements for paragraph
#' @examples
#' library(officer)
#'
#' ft <- flextable(head(iris))
#'
#' ft <- compose(ft,
#' j = "Sepal.Length",
#' value = as_paragraph(
#' "Sepal.Length value is ",
#' as_chunk(Sepal.Length, props = fp_text(color = "red"))
#' ),
#' part = "body"
#' )
#' ft <- color(ft, color = "gray40", part = "all")
#' ft <- autofit(ft)
#' ft
as_chunk <- function(x, props = NULL, formatter = format_fun, ...) {
if (is.function(x)) {
stop("argument `x` in function `as_chunk` cannot be a function")
}
if (!is.function(formatter)) {
stop("argument `formatter` in function `as_chunk` should be a function")
}
text <- formatter(x, ...)
if (is.null(props)) {
props <- default_fptext_prop
} else if (!inherits(props, "fp_text")) {
stop("argument `props` should be an object of class 'fp_text'.")
}
if (inherits(props, "fp_text")) {
props <- rep(list(props), length(text))
}
if (length(props) > 0 && is.list(props)) {
if (!all(sapply(props, inherits, "fp_text"))) {
stop("`props` should be a list of `fp_text` object(s).")
}
if (length(props) != length(text)) {
stop(sprintf("`props` should be a list of same length than `x`: %.0f.", length(text)))
}
}
data <- chunk_dataframe(
txt = text,
font.size = sapply(props, function(x) x$font.size),
italic = sapply(props, function(x) x$italic),
bold = sapply(props, function(x) x$bold),
underlined = sapply(props, function(x) x$underlined),
strike = sapply(props, function(x) x$strike),
color = sapply(props, function(x) x$color),
shading.color = sapply(props, function(x) x$shading.color),
font.family = sapply(props, function(x) x$font.family),
hansi.family = sapply(props, function(x) x$hansi.family),
eastasia.family = sapply(props, function(x) x$eastasia.family),
cs.family = sapply(props, function(x) x$cs.family),
vertical.align = sapply(props, function(x) x$vertical.align)
)
data
}
#' @export
#' @title Subscript chunk
#' @description The function is producing a chunk with
#' subscript vertical alignment.
#'
#' It is used to add it to the content of a cell of the
#' flextable with the functions [compose()], [append_chunks()]
#' or [prepend_chunks()].
#' @param x value, if a chunk, the chunk will be updated
#' @family chunk elements for paragraph
#' @examples
#' ft <- flextable(head(iris), col_keys = c("dummy"))
#'
#' ft <- compose(ft,
#' i = 1, j = "dummy", part = "header",
#' value = as_paragraph(
#' as_sub("Sepal.Length"),
#' " anything "
#' )
#' )
#'
#' ft <- autofit(ft)
#' ft
as_sub <- function(x) {
if (!inherits(x, "chunk")) {
x <- as_chunk(x, formatter = format_fun)
}
x$vertical.align <- "subscript"
x
}
#' @export
#' @title Superscript chunk
#' @description The function is producing a chunk with
#' superscript vertical alignment.
#'
#' It is used to add it to the content of a cell of the
#' flextable with the functions [compose()], [append_chunks()]
#' or [prepend_chunks()].
#'
#' @inheritParams as_sub
#' @note
#' This is a sugar function that ease the composition of complex
#' labels made of different formattings. It should be used inside a
#' call to [as_paragraph()].
#' @family chunk elements for paragraph
#' @examples
#' ft <- flextable(head(iris), col_keys = c("dummy"))
#'
#' ft <- compose(ft,
#' i = 1, j = "dummy", part = "header",
#' value = as_paragraph(
#' " anything ",
#' as_sup("Sepal.Width")
#' )
#' )
#'
#' ft <- autofit(ft)
#' ft
as_sup <- function(x) {
if (!inherits(x, "chunk")) {
x <- as_chunk(x, formatter = format_fun)
}
x$vertical.align <- "superscript"
x
}
#' @export
#' @title Bold chunk
#' @description The function is producing a chunk with
#' bold font.
#'
#' It is used to add it to the content of a cell of the
#' flextable with the functions [compose()], [append_chunks()]
#' or [prepend_chunks()].
#'
#' @inheritParams as_sub
#' @family chunk elements for paragraph
#' @examples
#' ft <- flextable(head(iris),
#' col_keys = c("Sepal.Length", "dummy")
#' )
#'
#' ft <- compose(ft,
#' j = "dummy",
#' value = as_paragraph(
#' as_b(Sepal.Length)
#' )
#' )
#'
#' ft
as_b <- function(x) {
if (!inherits(x, "chunk")) {
x <- as_chunk(x, formatter = format_fun)
}
x$bold <- TRUE
x
}
#' @export
#' @title Strikethrough chunk
#' @description The function is producing a chunk with
#' strikethrough font.
#'
#' It is used to add it to the content of a cell of the
#' flextable with the functions [compose()], [append_chunks()]
#' or [prepend_chunks()].
#'
#' @inheritParams as_sub
#' @family chunk elements for paragraph
#' @examples
#' ft <- flextable(head(iris),
#' col_keys = c("Sepal.Length", "dummy")
#' )
#'
#' ft <- compose(ft,
#' j = "dummy",
#' value = as_paragraph(
#' as_strike(Sepal.Length)
#' )
#' )
#'
#' ft
as_strike <- function(x) {
if (!inherits(x, "chunk")) {
x <- as_chunk(x, formatter = format_fun)
}
x$strike <- TRUE
x
}
#' @export
#' @title Italic chunk
#' @description The function is producing a chunk with
#' italic font.
#'
#' It is used to add it to the content of a cell of the
#' flextable with the functions [compose()], [append_chunks()]
#' or [prepend_chunks()].
#'
#' @inheritParams as_sub
#' @family chunk elements for paragraph
#' @examples
#' ft <- flextable(head(iris),
#' col_keys = c("Sepal.Length", "dummy")
#' )
#'
#' ft <- compose(ft,
#' j = "dummy",
#' value = as_paragraph(as_i(Sepal.Length))
#' )
#'
#' ft
as_i <- function(x) {
if (!inherits(x, "chunk")) {
x <- as_chunk(x, formatter = format_fun)
}
x$italic <- TRUE
x
}
#' @export
#' @title Colorize chunk
#' @description The function is producing a chunk with
#' a font in color.
#'
#' It is used to add it to the content of a cell of the
#' flextable with the functions [compose()], [append_chunks()]
#' or [prepend_chunks()].
#'
#' @param color color to use as text highlighting color as character vector.
#' @inheritParams as_sub
#' @family chunk elements for paragraph
#' @examples
#' ft <- flextable(head(iris),
#' col_keys = c("Sepal.Length", "dummy")
#' )
#'
#' ft <- compose(ft,
#' j = "dummy",
#' value = as_paragraph(colorize(Sepal.Length, color = "red"))
#' )
#'
#' ft
colorize <- function(x, color) {
if (!inherits(x, "chunk")) {
x <- as_chunk(x, formatter = format_fun)
}
x$color <- color
x
}
#' @export
#' @title Highlight chunk
#' @description The function is producing a chunk with
#' an highlight chunk.
#'
#' It is used to add it to the content of a cell of the
#' flextable with the functions [compose()], [append_chunks()]
#' or [prepend_chunks()].
#'
#' @param color color to use as text highlighting color as character vector.
#' @inheritParams as_sub
#' @family chunk elements for paragraph
#' @examples
#' ft <- flextable(head(iris),
#' col_keys = c("Sepal.Length", "dummy")
#' )
#'
#' ft <- compose(ft,
#' j = "dummy",
#' value = as_paragraph(as_highlight(Sepal.Length, color = "yellow"))
#' )
#'
#' ft
as_highlight <- function(x, color) {
if (!inherits(x, "chunk")) {
x <- as_chunk(x, formatter = format_fun)
}
x$shading.color <- color
x
}
#' @export
#' @title Bracket chunk
#' @description The function is producing a chunk by
#' pasting values and add the result in brackets.
#'
#' It is used to add it to the content of a cell of the
#' flextable with the functions [compose()], [append_chunks()]
#' or [prepend_chunks()].
#'
#' @param ... text and column names
#' @param sep separator
#' @param p prefix, default to '('
#' @param s suffix, default to ')'
#' @family chunk elements for paragraph
#' @examples
#' ft <- flextable(head(iris),
#' col_keys = c("Species", "Sepal", "Petal")
#' )
#' ft <- set_header_labels(ft, Sepal = "Sepal", Petal = "Petal")
#' ft <- compose(ft,
#' j = "Sepal",
#' value = as_paragraph(as_bracket(Sepal.Length, Sepal.Width))
#' )
#' ft <- compose(ft,
#' j = "Petal",
#' value = as_paragraph(as_bracket(Petal.Length, Petal.Width))
#' )
#' ft
as_bracket <- function(..., sep = ", ", p = "(", s = ")") {
x <- list(...)
x <- lapply(x, formatC)
x$sep <- sep
x <- do.call(paste, x)
x <- paste0(p, x, s)
as_chunk(x)
}
#' @export
#' @title Hyperlink chunk
#' @description The function lets add hyperlinks within flextable
#' objects.
#'
#' It is used to add it to the content of a cell of the
#' flextable with the functions [compose()], [append_chunks()]
#' or [prepend_chunks()].
#'
#' URL are not encoded, they are preserved 'as is'.
#'
#' @note
#' This chunk option requires package officedown in a R Markdown
#' context with Word output format.
#' @inheritParams as_chunk
#' @param url url to be used
#' @seealso [compose()]
#' @examples
#' dat <- data.frame(
#' col = "Google it",
#' href = "https://www.google.fr/search?source=hp&q=flextable+R+package",
#' stringsAsFactors = FALSE
#' )
#'
#' ftab <- flextable(dat)
#' ftab <- compose(
#' x = ftab, j = "col",
#' value = as_paragraph(
#' "This is a link: ",
#' hyperlink_text(x = col, url = href)
#' )
#' )
#' ftab
#' @family chunk elements for paragraph
hyperlink_text <- function(x, props = NULL, formatter = format_fun, url, ...) {
zz <- data.frame(x = x, url = url, stringsAsFactors = FALSE)
x <- as_chunk(x = zz$x, props = props, formatter = formatter, ...)
x$url <- zz$url
x
}
#' @export
#' @title Equation chunk
#' @description This function is used to insert equations into
#' flextable.
#'
#' It is used to add it to the content of a cell of the
#' flextable with the functions [compose()], [append_chunks()]
#' or [prepend_chunks()].
#'
#' To use this function, package 'equatags' is required;
#' also `equatags::mathjax_install()` must be executed only once
#' to install necessary dependencies.
#'
#' @param x values containing the 'MathJax' equations
#' @param props an [fp_text_default()] or [officer::fp_text()] object to be used to format the text.
#' If not specified, it will be the default value corresponding to the cell.
#' @param width,height size of the resulting equation
#' @param unit unit for width and height, one of "in", "cm", "mm".
#' @family chunk elements for paragraph
#' @examples
#' library(flextable)
#' if (require("equatags")) {
#' eqs <- c(
#' "(ax^2 + bx + c = 0)",
#' "a \\ne 0",
#' "x = {-b \\pm \\sqrt{b^2-4ac} \\over 2a}"
#' )
#' df <- data.frame(formula = eqs)
#' df
#'
#'
#' ft <- flextable(df)
#' ft <- compose(
#' x = ft, j = "formula",
#' value = as_paragraph(as_equation(formula, width = 2, height = .5))
#' )
#' ft <- align(ft, align = "center", part = "all")
#' ft <- width(ft, width = 2)
#' ft
#' }
as_equation <- function(x, width = 1, height = .2, unit = "in", props = NULL) {
width <- convin(unit = unit, x = width)
height <- convin(unit = unit, x = height)
if (length(x) > 1) {
if (length(width) == 1) width <- rep(width, length(x))
if (length(height) == 1) height <- rep(height, length(x))
}
if (is.null(props)) {
props <- default_fptext_prop
}
if (inherits(props, "fp_text")) {
props <- rep(list(props), length(x))
}
if (length(props) > 0 && is.list(props)) {
if (!all(sapply(props, inherits, "fp_text"))) {
stop("`props` should be a list of `fp_text` object(s).")
}
if (length(props) != length(x)) {
stop(sprintf(
"`props` should be a list of same length than `x`: %.0f.",
length(x)
))
}
}
x <- chunk_dataframe(
width = as.double(width),
height = as.double(height),
eq_data = x,
font.size = sapply(props, function(x) x$font.size),
italic = sapply(props, function(x) x$italic),
bold = sapply(props, function(x) x$bold),
underlined = sapply(props, function(x) x$underlined),
strike = sapply(props, function(x) x$strike),
color = sapply(props, function(x) x$color),
shading.color = sapply(props, function(x) x$shading.color),
font.family = sapply(props, function(x) x$font.family),
hansi.family = sapply(props, function(x) x$hansi.family),
eastasia.family = sapply(props, function(x) x$eastasia.family),
cs.family = sapply(props, function(x) x$cs.family),
vertical.align = sapply(props, function(x) x$vertical.align)
)
class(x) <- c("chunk", "data.frame")
x
}
#' @export
#' @title Word dynamic field chunk
#' @description
#' `as_word_field()` inserts a Word field code (e.g. page
#' numbers, dates, cross-references) as a chunk inside a
#' flextable cell. Field codes are Word's mechanism for
#' auto-computed values; see
#' [Microsoft's field-code reference](https://support.microsoft.com/en-us/office/list-of-field-codes-in-word-1ad6d91a-55a7-4a8d-b535-cf7888659a51)
#' for the available codes.
#'
#' The chunk is used with [compose()], [append_chunks()]
#' or [prepend_chunks()]. It only has an effect in Word
#' (docx) output; other formats ignore it. To apply it
#' conditionally, use the post-processing step (see
#' `set_flextable_defaults(post_process_docx = ...)`).
#'
#' **Important**: fields are inserted but not computed.
#' After opening the document in Word, select all text
#' and press `F9` (on macOS: `Fn + F9`) to refresh the
#' field values.
#' @param x computed field strings
#' @param props text properties (see [fp_text_default()] or [officer::fp_text()])
#' object to be used to format the text. If not specified, it will use
#' the default text properties of the cell(s).
#' @param width,height size computed field
#' @param unit unit for width and height, one of "in", "cm", "mm".
#' @family chunk elements for paragraph
#' @examples
#' library(flextable)
#'
#' # define some default values ----
#' set_flextable_defaults(font.size = 22, border.color = "gray")
#'
#' # an example with append_chunks ----
#' pp_docx <- function(x) {
#' x <- add_header_lines(x, "Page ")
#' x <- append_chunks(
#' x = x, i = 1, part = "header", j = 1,
#' as_word_field(x = "Page")
#' )
#' align(x, part = "header", align = "left")
#' }
#' ft_1 <- flextable(cars)
#' ft_1 <- autofit(ft_1)
#' ft_1 <- pp_docx(ft_1)
#'
#' ## or:
#' # set_flextable_defaults(post_process_docx = pp_docx)
#' ## to prevent this line addition when output is not docx
#'
#' # print(ft_1, preview = "docx")
#'
#' # an example with compose ----
#'
#' library(officer)
#' ft_2 <- flextable(head(cars))
#' ft_2 <- add_footer_lines(ft_2, "temp text")
#' ft_2 <- compose(
#' x = ft_2, part = "footer", i = 1, j = 1,
#' as_paragraph(
#' "p. ",
#' as_word_field(x = "Page", width = .05),
#' " on ", as_word_field(x = "NumPages", width = .05)
#' )
#' )
#' ft_2 <- autofit(ft_2, part = c("header", "body"))
#'
#' doc <- read_docx()
#' doc <- body_add_flextable(doc, ft_2)
#' doc <- body_add_break(doc)
#' doc <- body_add_flextable(doc, ft_2)
#' outfile <- print(doc, target = tempfile(fileext = ".docx"))
#'
#' # reset default values ----
#' init_flextable_defaults()
as_word_field <- function(x, props = NULL, width = .1, height = .15, unit = "in") {
width <- convin(unit = unit, x = width)
height <- convin(unit = unit, x = height)
if (is.null(props)) {
props <- default_fptext_prop
}
if (inherits(props, "fp_text")) {
props <- rep(list(props), length(x))
}
if (length(props) > 0 && is.list(props)) {
if (!all(sapply(props, inherits, "fp_text"))) {
stop("`props` should be a list of `fp_text` object(s).")
}
if (length(props) != length(x)) {
stop(sprintf(
"`props` should be a list of same length than `x`: %.0f.",
length(x)
))
}
}
x <- chunk_dataframe(
width = as.double(width),
height = as.double(height),
word_field_data = x,
font.size = sapply(props, function(x) x$font.size),
italic = sapply(props, function(x) x$italic),
bold = sapply(props, function(x) x$bold),
underlined = sapply(props, function(x) x$underlined),
strike = sapply(props, function(x) x$strike),
color = sapply(props, function(x) x$color),
shading.color = sapply(props, function(x) x$shading.color),
font.family = sapply(props, function(x) x$font.family),
hansi.family = sapply(props, function(x) x$hansi.family),
eastasia.family = sapply(props, function(x) x$eastasia.family),
cs.family = sapply(props, function(x) x$cs.family),
vertical.align = sapply(props, function(x) x$vertical.align)
)
class(x) <- c("chunk", "data.frame")
x
}
to_wml_word_field <- function(x, pr_txt) {
xml_elt_1 <- paste0(
"
#' }}
#' @param src image filename
#' @param width,height size of the image file. It can be ignored
#' if parameter `guess_size=TRUE`, see parameter `guess_size`.
#' @param guess_size If package 'magick' is installed, this option
#' can be used (set it to `TRUE` and don't provide values for paramters
#' `width` and `height`). When the flextable will be printed,
#' the images will be read and width and height will be guessed. This
#' should be avoid if possible as it can be an extensive task when
#' several images.
#' @param unit unit for width and height, one of "in", "cm", "mm".
#' @param ... unused argument
#' @family chunk elements for paragraph
#' @note
#' This chunk option requires package officedown in a R Markdown
#' context with Word output format.
#'
#' PowerPoint cannot mix images and text in a paragraph, images
#' are removed when outputing to PowerPoint format.
#' @seealso [compose()], [as_paragraph()]
#' @examples
#' img.file <- file.path(
#' R.home("doc"),
#' "html", "logo.jpg"
#' )
#' if (require("magick")) {
#' myft <- flextable(head(iris))
#' myft <- compose(myft,
#' i = 1:3, j = 1,
#' value = as_paragraph(
#' as_image(src = img.file),
#' " ",
#' as_chunk(Sepal.Length,
#' props = fp_text_default(color = "red")
#' )
#' ),
#' part = "body"
#' )
#' ft <- autofit(myft)
#' ft
#' }
as_image <- function(src, width = NULL, height = NULL, unit = "in", guess_size = TRUE, ...) {
width <- convin(unit = unit, x = width)
height <- convin(unit = unit, x = height)
if (length(src) > 1) {
if (length(width) == 1) width <- rep(width, length(src))
if (length(height) == 1) height <- rep(height, length(src))
}
if (guess_size && (is.null(width) || is.null(height))) {
if (!requireNamespace("magick", quietly = TRUE)) {
stop("package magick is required when using `guess_size` option.")
}
sizes <- lapply(src, function(x) {
z <- magick::image_read(x)
z <- magick::image_data(z)
attr(z, "dim")[-1]
})
sizes <- do.call(rbind, sizes)
width <- sizes[, 1] / 72
height <- sizes[, 2] / 72
}
data <- chunk_dataframe(
width = as.double(width),
height = as.double(height),
img_data = src
)
class(data) <- c("img_src", class(data))
data
}
#' @export
#' @title Mini barplot chunk
#' @description This function is used to insert bars into
#' flextable with functions:
#' - [compose()] and [as_paragraph()],
#' - [append_chunks()],
#' - [prepend_chunks()].
#' @param value values containing the bar size
#' @param max max bar size
#' @param barcol bar color
#' @param bg background color
#' @param width,height size of the resulting png file in inches
#' @param unit unit for width and height, one of "in", "cm", "mm".
#' @note
#' This chunk option requires package officedown in a R Markdown
#' context with Word output format.
#'
#' PowerPoint cannot mix images and text in a paragraph, images
#' are removed when outputing to PowerPoint format.
#' @family chunk elements for paragraph
#' @examples
#' ft <- flextable(head(iris, n = 10))
#'
#' ft <- compose(ft,
#' j = 1,
#' value = as_paragraph(
#' minibar(value = Sepal.Length, max = max(Sepal.Length))
#' ),
#' part = "body"
#' )
#'
#' ft <- autofit(ft)
#' ft
#' @importFrom grDevices as.raster col2rgb rgb
#' @seealso [compose()], [as_paragraph()]
minibar <- function(value, max = NULL, barcol = "#CCCCCC", bg = "transparent", width = 1, height = .2, unit = "in") {
width <- convin(unit = unit, x = width)
height <- convin(unit = unit, x = height)
if (all(is.na(value))) {
max <- 1
}
if (all(is.na(value)) || all(value == 0, na.rm = TRUE)) {
max <- 1
}
value[is.na(value)] <- 0
if (is.null(max)) {
max <- max(value, na.rm = TRUE)
}
stopifnot(value >= 0, max >= 0)
barcol <- rgb(t(col2rgb(barcol)) / 255)
bg <- ifelse(bg == "transparent", bg, rgb(t(col2rgb(bg)) / 255))
if (any(value > max)) {
warning("value > max, truncate to max")
value[value > max] <- max
}
width_ <- as.integer(width * 72)
value <- as.integer((value / max) * width_)
n_empty <- width_ - value
rasters <- mapply(
function(count_on, count_off, bg_on, bg_off) {
as.raster(matrix(c(rep(bg_on, count_on), rep(bg_off, count_off)), nrow = 1))
}, value, n_empty,
bg_on = barcol, bg_off = bg,
SIMPLIFY = FALSE
)
z <- chunk_dataframe(
width = as.double(rep(width, length(value))),
height = as.double(rep(height, length(value))),
img_data = rasters
)
class(z) <- c("img_chunk", class(z))
z
}
#' @export
#' @title Mini linerange chunk
#' @description This function is used to insert lineranges into
#' flextable with functions:
#' - [compose()] and [as_paragraph()],
#' - [append_chunks()],
#' - [prepend_chunks()].
#' @param value values containing the bar size
#' @param min min bar size. Default min of value
#' @param max max bar size. Default max of value
#' @param rangecol bar color
#' @param stickcol jauge color
#' @param bg background color
#' @param width,height size of the resulting png file in inches
#' @param unit unit for width and height, one of "in", "cm", "mm".
#' @param raster_width number of pixels used as width
#' when interpolating value.
#' @note
#' This chunk option requires package officedown in a R Markdown
#' context with Word output format.
#'
#' PowerPoint cannot mix images and text in a paragraph, images
#' are removed when outputing to PowerPoint format.
#' @family chunk elements for paragraph
#' @examples
#' myft <- flextable(head(iris, n = 10))
#'
#' myft <- compose(myft,
#' j = 1,
#' value = as_paragraph(
#' linerange(value = Sepal.Length)
#' ),
#' part = "body"
#' )
#'
#' autofit(myft)
#' @importFrom grDevices as.raster col2rgb rgb
#' @importFrom stats approx
#' @seealso [compose()], [as_paragraph()]
linerange <- function(value, min = NULL, max = NULL, rangecol = "#CCCCCC",
stickcol = "#FF0000", bg = "transparent", width = 1,
height = .2, raster_width = 30, unit = "in") {
width <- convin(unit = unit, x = width)
height <- convin(unit = unit, x = height)
if (all(is.na(value))) {
min <- 0
max <- 1
}
if (raster_width < 2) {
stop("raster_width must be greater than 1")
}
raster_nrow <- 9
raster_center <- 5
if (is.null(max)) {
max <- max(value, na.rm = TRUE)
}
if (is.null(min)) {
min <- min(value, na.rm = TRUE)
}
value[!is.finite(value)] <- max + 1 # to be sure not displayed
stopifnot(!is.null(value), !is.null(min), !is.null(min))
# transform color code
stickcol <- rgb(t(col2rgb(stickcol)) / 255)
rangecol <- rgb(t(col2rgb(rangecol)) / 255)
bg <- ifelse(bg == "transparent", bg, rgb(t(col2rgb(bg)) / 255))
# get value approx on range 1,raster_width
stick_pos <- as.integer(approx(x = c(min, max), y = c(1, raster_width), xout = value)$y)
base <- matrix(bg, nrow = raster_nrow, ncol = raster_width)
base[, 1] <- rangecol
base[, raster_width] <- rangecol
base[raster_center, ] <- rangecol
rasters <- lapply(stick_pos, function(val, def_mat, col) {
newmat <- def_mat
newmat[, val] <- col
as.raster(newmat)
}, base, stickcol)
z <- chunk_dataframe(
width = as.double(rep(width, length(value))),
height = as.double(rep(height, length(value))),
img_data = rasters
)
class(z) <- c("img_chunk", class(z))
z
}
#' @export
#' @title Mini plot chunk
#' @description This function is used to insert mini plots into
#' flextable with functions:
#' - [compose()] and [as_paragraph()],
#' - [append_chunks()],
#' - [prepend_chunks()].
#'
#' Available plots are 'box', 'line', 'points', 'density'.
#' @param value a numeric vector, stored in a list column.
#' @param width,height size of the resulting png file in inches
#' @param type type of the plot: 'box', 'line', 'points' or 'density'.
#' @param free_scale Should scales be free (TRUE or FALSE, the default value).
#' @param unit unit for width and height, one of "in", "cm", "mm".
#' @param ... arguments sent to plot functions (see [par()])
#' @note
#' This chunk option requires package officedown in a R Markdown
#' context with Word output format.
#'
#' PowerPoint cannot mix images and text in a paragraph, images
#' are removed when outputing to PowerPoint format.
#' @family chunk elements for paragraph
#' @examples
#' library(data.table)
#' library(flextable)
#'
#' z <- as.data.table(iris)
#' z <- z[, list(
#' Sepal.Length = mean(Sepal.Length, na.rm = TRUE),
#' z = list(.SD$Sepal.Length)
#' ), by = "Species"]
#'
#' ft <- flextable(z,
#' col_keys = c("Species", "Sepal.Length", "box", "density")
#' )
#' ft <- mk_par(ft, j = "box", value = as_paragraph(
#' plot_chunk(
#' value = z, type = "box",
#' border = "red", col = "transparent"
#' )
#' ))
#' ft <- mk_par(ft, j = "density", value = as_paragraph(
#' plot_chunk(value = z, type = "dens", col = "red")
#' ))
#' ft <- set_table_properties(ft, layout = "autofit", width = .6)
#' ft <- set_header_labels(ft, box = "boxplot", density = "density")
#' theme_vanilla(ft)
#' @importFrom grDevices dev.off dev.list
#' @importFrom graphics boxplot
#' @importFrom stats density
plot_chunk <- function(value, width = 1, height = .2,
type = "box", free_scale = FALSE, unit = "in", ...) {
width <- convin(unit = unit, x = width)
height <- convin(unit = unit, x = height)
type <- match.arg(arg = type, choices = c("box", "line", "points", "density"), several.ok = FALSE)
width <- as.double(rep(width, length(value)))
height <- as.double(rep(height, length(value)))
params <- list(...)
params <- append(
params,
list(
xlab = "", ylab = "", main = "", axes = FALSE
)
)
lims <- NULL
if (!free_scale) {
lims <- range(unlist(value), na.rm = TRUE)
}
files <- mapply(
function(x, width, height, type) {
file <- tempfile(fileext = ".png")
agg_png(
filename = file,
width = width, height = height,
res = 200, units = "in",
background = "transparent"
)
par(mar = rep(0, 4))
parcall <- params
if ("box" %in% type) {
parcall$x <- x
parcall$horizontal <- TRUE
parcall$ylim <- lims
do.call(boxplot, parcall)
} else if ("line" %in% type) {
parcall$x <- seq_along(x)
parcall$y <- x
parcall$type <- "l"
parcall$ylim <- lims
do.call(plot, parcall)
} else if ("points" %in% type) {
parcall$x <- seq_along(x)
parcall$y <- x
parcall$ylim <- lims
do.call(plot, parcall)
} else if ("density" %in% type) {
parcall$x <- density(x)
parcall$xlim <- lims
do.call(plot, parcall)
}
dev.off()
file
},
x = value,
width = width, height = height,
SIMPLIFY = FALSE,
MoreArgs = list(type = type)
)
files <- as.character(unlist(files))
z <- chunk_dataframe(width = width, height = height, img_data = files)
class(z) <- c("img_chunk", class(z))
z
}
#' @export
#' @title ggplot chunk
#' @description This function is used to insert mini gg plots into
#' flextable with functions:
#' - [compose()] and [as_paragraph()],
#' - [append_chunks()],
#' - [prepend_chunks()].
#'
#' @param value gg objects, stored in a list column; or a list
#' of 'ggplot' objects.
#' @param width,height size of the resulting png file.
#' @param unit unit for width and height, one of "in", "cm", "mm".
#' @param res resolution of the png image in ppi
#' @note
#' This chunk option requires package officedown in a R Markdown
#' context with Word output format.
#'
#' PowerPoint cannot mix images and text in a paragraph, images
#' are removed when outputing to PowerPoint format.
#' @family chunk elements for paragraph
#' @examples
#' library(data.table)
#' library(flextable)
#' if (require("ggplot2")) {
#' my_cor_plot <- function(x) {
#' cols <- colnames(x)[sapply(x, is.numeric)]
#' x <- x[, .SD, .SDcols = cols]
#' cormat <- as.data.table(cor(x))
#' cormat$var1 <- colnames(cormat)
#' cormat <- melt(cormat,
#' id.vars = "var1", measure.vars = cormat$var1,
#' variable.name = "var2", value.name = "correlation"
#' )
#' ggplot(data = cormat, aes(x = var1, y = var2, fill = correlation)) +
#' geom_tile() +
#' coord_equal() +
#' scale_fill_gradient2(
#' low = "blue",
#' mid = "white", high = "red", limits = c(-1, 1),
#' guide = "none"
#' ) +
#' theme_void()
#' }
#' z <- as.data.table(iris)
#' z <- z[, list(gg = list(my_cor_plot(.SD))), by = "Species"]
#' ft <- flextable(z)
#' ft <- mk_par(ft,
#' j = "gg",
#' value = as_paragraph(
#' gg_chunk(value = gg, width = 1, height = 1)
#' )
#' )
#' ft
#' }
gg_chunk <- function(value, width = 1, height = .2, unit = "in", res = 300) {
width <- convin(unit = unit, x = width)
height <- convin(unit = unit, x = height)
width <- as.double(rep(width, length(value)))
height <- as.double(rep(height, length(value)))
files <- mapply(
function(x, width, height) {
file <- tempfile(fileext = ".png")
agg_png(
filename = file, width = width, height = height,
units = "in", background = "transparent", res = res
)
print(x)
dev.off()
file
},
x = value,
width = width, height = height,
SIMPLIFY = FALSE
)
files <- as.character(unlist(files))
z <- chunk_dataframe(width = width, height = height, img_data = files)
class(z) <- c("img_chunk", class(z))
z
}
#' @export
#' @title Grid Graphics chunk
#' @description This function is used to insert grid objects into
#' flextable with functions:
#' - [compose()] and [as_paragraph()],
#' - [append_chunks()],
#' - [prepend_chunks()].
#'
#' @param value grid objects, stored in a list column; or a list
#' of grid objects.
#' @param width,height size of the resulting png file
#' @param unit unit for width and height, one of "in", "cm", "mm".
#' @param res resolution of the png image in ppi
#' @note
#' This chunk option requires package officedown in a R Markdown
#' context with Word output format.
#'
#' PowerPoint cannot mix images and text in a paragraph, images
#' are removed when outputing to PowerPoint format.
#' @family chunk elements for paragraph
#' @examples
#' library(flextable)
#' ft_1 <- flextable(head(cars))
#' if (require("grid")) {
#' ft_1 <- prepend_chunks(
#' x = ft_1, i = 2, j = 2,
#' grid_chunk(
#' list(
#' circleGrob(gp = gpar(
#' fill = "#ec11c2",
#' col = "transparent"
#' ))
#' ),
#' width = .15, height = .15
#' )
#' )
#' }
#' ft_1
grid_chunk <- function(value, width = 1, height = .2, unit = "in", res = 300) {
if (!requireNamespace("grid", quietly = TRUE)) {
stop(sprintf(
"'%s' package should be installed to create a flextable from an object of type '%s'.",
"grid", "grid"
))
}
width <- convin(unit = unit, x = width)
height <- convin(unit = unit, x = height)
width <- as.double(rep(width, length(value)))
height <- as.double(rep(height, length(value)))
files <- mapply(
function(x, width, height) {
file <- tempfile(fileext = ".png")
agg_png(
filename = file, width = width, height = height,
units = "in", background = "transparent", res = res
)
grid::grid.draw(x)
dev.off()
file
},
x = value,
width = width, height = height,
SIMPLIFY = FALSE
)
files <- as.character(unlist(files))
z <- chunk_dataframe(width = width, height = height, img_data = files)
class(z) <- c("img_chunk", class(z))
z
}
flextable/R/html_str.R 0000644 0001762 0000144 00000036751 15142654022 014415 0 ustar ligges users gen_raw_html <- function(x,
class = "tabwid",
caption = "",
topcaption = TRUE,
manual_css = "") {
align <- x$properties$align
# for ubiquity and other packages that dump old flextable
if (is.null(align)) align <- "center"
fixed_layout <- x$properties$layout %in% "fixed"
if (!fixed_layout) {
if (x$properties$width > 0) {
# setting width will contraint columns'widths and make word breaks
tbl_width <- paste0("width:", formatC(x$properties$width * 100), "%;")
} else {
tbl_width <- ""
}
tabcss <- paste0("table-layout:auto;", tbl_width)
} else {
tabcss <- ""
}
codes <- html_content_strs(x)
classname <- UUIDgenerate(n = 1, use.time = TRUE)
classname <- gsub("(^[[:alnum:]]+)(.*)$", "cl-\\1", classname)
tabcss <- paste0(".", classname, "{", tabcss, "}")
if (is.null(manual_css) || "" %in% manual_css) {
manual_css_str <- ""
} else {
manual_css_str <- manual_css
}
if (!is.null(x$properties$opts_html$scroll)) {
freeze_first_column <- x$properties$opts_html$scroll$freeze_first_column
if (isTRUE(freeze_first_column)) {
freeze_first_css_th <- paste0(
".", classname, " thead > tr > th:first-child {position:sticky;left:0;z-index:5;}"
)
freeze_first_css_td <- paste0(
".", classname, " tbody > tr > td:first-child {position:sticky;left:0;z-index:3;}"
)
freeze_first_css <- paste0(
c(freeze_first_css_th, freeze_first_css_td),
collapse = ""
)
x$properties$opts_html$extra_css <- paste0(
freeze_first_css,
x$properties$opts_html$extra_css
)
}
if (!is.null(x$properties$opts_html$scroll$height)) {
x$properties$opts_html$extra_css <- paste0(
".", classname, " th {position: sticky;top: 0;z-index: 4;}.", classname, " {border-collapse: separate !important;}",
x$properties$opts_html$extra_css
)
}
}
if (!is.null(x$properties$opts_html$extra_class)) {
classname <- c(
classname, x$properties$opts_html$extra_class)
classname <- paste0(classname, collapse = " ")
}
html <- paste0(
"",
sprintf("")), by = c(".part", ".row_id", ".col_id")] by_columns <- intersect(colnames(cell_data), colnames(data_ref_cells)) cell_data <- merge(cell_data, data_ref_cells, by = by_columns) cell_data <- merge(cell_data, span_data, by = c(".part", ".row_id", ".col_id")) cell_data <- cell_data[, list( td_tag = paste0( ifelse(get(".part") %in% "header", "
#' }}
#'
#' @note
#' when repeating values, they can be merged together with
#' function [merge_h()] and [merge_v()].
#' @inheritParams add_body
#' @examples
#' library(flextable)
#'
#' fun <- function(x) {
#' paste0(
#' c("min: ", "max: "),
#' formatC(range(x))
#' )
#' }
#' new_row <- list(
#' Sepal.Length = fun(iris$Sepal.Length),
#' Sepal.Width = fun(iris$Sepal.Width),
#' Petal.Width = fun(iris$Petal.Width),
#' Petal.Length = fun(iris$Petal.Length)
#' )
#'
#' ft_1 <- flextable(data = head(iris))
#' ft_1 <- add_header(ft_1, values = new_row, top = FALSE)
#' ft_1 <- append_chunks(ft_1, part = "header", i = 2, )
#' ft_1 <- theme_booktabs(ft_1, bold_header = TRUE)
#' ft_1 <- align(ft_1, align = "center", part = "all")
#' ft_1
#' @family functions for row and column operations in a flextable
add_header <- function(x, top = TRUE, ..., values = NULL) {
if (!inherits(x, "flextable")) {
stop(sprintf("Function `%s` supports only flextable objects.", "add_header()"))
}
header_data <- as_new_data(x = x, ..., values = values)
x$header <- add_rows_to_tabpart(x$header, header_data, first = top)
x
}
#' @export
#' @title Add footer rows with one value per column
#'
#' @description
#' Add new rows to the footer where each value maps to a named column.
#' Unlike [add_footer_row()] where labels can span multiple columns,
#' here each value fills exactly one column.
#'
#' If some columns are not provided, they will be replaced by
#' `NA` and displayed as empty.
#' @inheritParams add_body
#' @examples
#' new_row <- as.list(colMeans(iris[, -5]))
#' new_row$Species <- "Means"
#'
#' formatter <- function(x) sprintf("%.1f", x)
#'
#' ft <- flextable(data = head(iris))
#' ft <- add_footer(ft, values = new_row)
#'
#' # cosmetics
#' ft <- compose(
#' x = ft, j = 1:4,
#' value = as_paragraph(
#' as_chunk(., formatter = formatter)
#' ),
#' part = "footer", use_dot = TRUE
#' )
#' ft <- align(ft, part = "footer", align = "right", j = 1:4)
#' ft
#' @family functions for row and column operations in a flextable
add_footer <- function(x, top = TRUE, ..., values = NULL) {
if (!inherits(x, "flextable")) {
stop(sprintf("Function `%s` supports only flextable objects.", "add_footer()"))
}
footer_data <- as_new_data(x = x, ..., values = values)
if (nrow_part(x, "footer") < 1) {
x$footer <- complex_tabpart(data = footer_data, col_keys = x$col_keys, cwidth = .75, cheight = .25)
} else {
x$footer <- add_rows_to_tabpart(x$footer, footer_data, first = top)
}
x
}
# add spanned labels as a single row ----
#' @export
#' @title Add a body row with spanning labels
#'
#' @description Add a single row to the body where labels can span
#' multiple columns (merged cells) via the `colwidths` argument.
#'
#' Labels are associated with a number of columns
#' to merge that default to one if not specified.
#' In this case, you have to make sure that the
#' number of labels is equal to the number of columns displayed.
#'
#' The function can add only one single row by call.
#'
#' Labels can also be formatted with [as_paragraph()].
#'
#' @inheritParams args_x_only
#' @param top should the row be inserted at the top or the bottom.
#' @param values values to add. It can be a `list`, a `character()` vector
#' or a call to [as_paragraph()].
#'
#' If it is a list, it can be a named list with the names of the columns of the
#' original data.frame or the `colkeys`; this is the recommended method because
#' it allows to keep the original data types and therefore allows to perform
#' conditional formatting. If a character, columns of the original data.frame
#' stored in the flextable object are changed to `character()`; this is often
#' not an issue with footer and header but can be inconvenient if adding
#' rows into body as it will change data types to character and prevent
#' efficient conditional formatting.
#'
#' @param colwidths the number of columns to merge in the row for each label
#'
#' @examples
#' library(flextable)
#'
#' ft01 <- fp_text_default(color = "red")
#' ft02 <- fp_text_default(color = "orange")
#'
#' pars <- as_paragraph(
#' as_chunk(c("(1)", "(2)"), props = ft02), " ",
#' as_chunk(
#' c(
#' "My tailor is rich",
#' "My baker is rich"
#' ),
#' props = ft01
#' )
#' )
#'
#' ft_1 <- flextable(head(mtcars))
#' ft_1 <- add_body_row(ft_1,
#' values = pars,
#' colwidths = c(5, 6), top = FALSE
#' )
#' ft_1 <- add_body_row(ft_1,
#' values = pars,
#' colwidths = c(3, 8), top = TRUE
#' )
#' ft_1 <- theme_box(ft_1)
#' ft_1
#'
#' ft_2 <- flextable(head(airquality))
#' ft_2 <- add_body_row(ft_2,
#' values = c("blah", "bleeeh"),
#' colwidths = c(4, 2), top = TRUE
#' )
#' ft_2 <- theme_box(ft_2)
#' ft_2
#' @family functions for row and column operations in a flextable
#' @seealso [flextable()], [set_caption()]
add_body_row <- function(x, top = TRUE, values = list(), colwidths = integer(0)) {
if (!inherits(x, "flextable")) {
stop(sprintf("Function `%s` supports only flextable objects.", "add_body_row()"))
}
if (length(colwidths) < 1) {
colwidths <- rep(1L, length(x$col_keys))
}
if (sum(colwidths) != length(x$col_keys)) {
stop(sprintf(
"sum of colwidths elements must be equal to the number of col_keys: %.0f.",
length(x$col_keys)
))
}
if (is.atomic(values)) {
values <- as.list(values)
}
row_span <- unlist(lapply(colwidths, function(x) {
z <- integer(x)
z[1] <- x
z
}))
col_j <- which(row_span > 0)
body_data <- x$body$dataset[nrow(x$body$dataset) + 1, ]
if (inherits(values, "paragraph")) {
} else if (!is.null(attr(values, "names"))) {
body_data[, names(values)] <- values
} else {
body_data[, which(row_span > 0)] <- values
}
if (nrow_part(x, "body") < 1) {
x$body <- complex_tabpart(
data = body_data, col_keys = x$col_keys,
cwidth = dim(x)$widths, cheight = .25
)
} else {
x$body <- add_rows_to_tabpart(x$body, body_data, first = top)
}
i <- ifelse(top, 1, nrow_part(x, "body"))
x$body$spans$rows[i, ] <- row_span
if (inherits(values, "paragraph")) {
for (j in seq_along(col_j)) {
x <- mk_par(x, i = i, j = col_j[j], value = values[j], part = "body")
}
}
x
}
#' @export
#' @title Add a header row with spanning labels
#'
#' @description Add a single row to the header where labels can span
#' multiple columns (merged cells) via the `colwidths` argument.
#'
#' Labels are associated with a number of columns
#' to merge that default to one if not specified.
#' In this case, you have to make sure that the
#' number of labels is equal to the number of columns displayed.
#'
#' The function can add only one single row by call.
#'
#' Labels can also be formatted with [as_paragraph()].
#'
#' @inheritParams args_x_only
#' @param top should the row be inserted at the
#' top or the bottom. Default to TRUE.
#' @param values values to add, a character vector (as header rows
#' contains only character values/columns), a list
#' or a call to [as_paragraph()].
#' @param colwidths the number of columns used for each label
#' @examples
#' library(flextable)
#'
#' ft01 <- fp_text_default(color = "red")
#' ft02 <- fp_text_default(color = "orange")
#'
#' pars <- as_paragraph(
#' as_chunk(c("(1)", "(2)"), props = ft02), " ",
#' as_chunk(c(
#' "My tailor is rich",
#' "My baker is rich"
#' ), props = ft01)
#' )
#'
#' ft_1 <- flextable(head(mtcars))
#' ft_1 <- add_header_row(ft_1,
#' values = pars,
#' colwidths = c(5, 6), top = FALSE
#' )
#' ft_1 <- add_header_row(ft_1,
#' values = pars,
#' colwidths = c(3, 8), top = TRUE
#' )
#' ft_1
#'
#' ft_2 <- flextable(head(airquality))
#' ft_2 <- add_header_row(ft_2,
#' values = c("Measure", "Time"),
#' colwidths = c(4, 2), top = TRUE
#' )
#' ft_2 <- theme_box(ft_2)
#' ft_2
#' @family functions for row and column operations in a flextable
#' @seealso [flextable()], [set_caption()]
add_header_row <- function(x, top = TRUE, values = character(0), colwidths = integer(0)) {
if (!inherits(x, "flextable")) {
stop(sprintf("Function `%s` supports only flextable objects.", "add_header_row()"))
}
if (length(colwidths) < 1) {
colwidths <- rep(1L, length(x$col_keys))
}
if (sum(colwidths) != length(x$col_keys)) {
stop(sprintf(
"sum of colwidths elements must be equal to the number of col_keys: %.0f.",
length(x$col_keys)
))
}
if (inherits(values, "paragraph")) {
str_values <- vapply(values, function(x) paste0(x$txt, collapse = ""), FUN.VALUE = "")
} else {
str_values <- values
}
header_data <- data_from_char(values = str_values, colwidths = colwidths, col_keys = x$col_keys)
if (nrow_part(x, "header") < 1) {
x$header <- complex_tabpart(data = header_data, col_keys = x$col_keys, cwidth = dim(x)$widths, cheight = .25)
} else {
x$header <- add_rows_to_tabpart(x$header, header_data, first = top)
}
row_span <- unlist(lapply(colwidths, function(x) {
z <- integer(x)
z[1] <- x
z
}))
i <- ifelse(top, 1, nrow(x$header$dataset))
x$header$spans$rows[i, ] <- row_span
if (inherits(values, "paragraph")) {
if (top) {
i <- 1
} else {
i <- nrow_part(x, "header")
}
col_j <- which(row_span > 0)
for (j in seq_along(col_j)) {
x <- mk_par(x, i = i, j = col_j[j], value = values[j], part = "header")
}
}
x
}
#' @export
#' @title Add a footer row with spanning labels
#'
#' @description Add a single row to the footer where labels can span
#' multiple columns (merged cells) via the `colwidths` argument.
#'
#' Labels are associated with a number of columns
#' to merge that default to one if not specified.
#' In this case, you have to make sure that the
#' number of labels is equal to the number of columns displayed.
#'
#' The function can add only one single row by call.
#'
#' Labels can be formatted with [as_paragraph()].
#' @inheritParams add_body_row
#' @family functions for row and column operations in a flextable
#' @seealso [flextable()], [set_caption()]
#' @examples
#' library(flextable)
#'
#' ft01 <- fp_text_default(color = "red")
#' ft02 <- fp_text_default(color = "orange")
#'
#' pars <- as_paragraph(
#' as_chunk(c("(1)", "(2)"), props = ft02), " ",
#' as_chunk(
#' c(
#' "My tailor is rich",
#' "My baker is rich"
#' ),
#' props = ft01
#' )
#' )
#'
#' ft_1 <- flextable(head(mtcars))
#' ft_1 <- add_footer_row(ft_1,
#' values = pars,
#' colwidths = c(5, 6), top = FALSE
#' )
#' ft_1 <- add_footer_row(ft_1,
#' values = pars,
#' colwidths = c(3, 8), top = TRUE
#' )
#' ft_1
#'
#' ft_2 <- flextable(head(airquality))
#' ft_2 <- add_footer_row(ft_2,
#' values = c("Measure", "Time"),
#' colwidths = c(4, 2), top = TRUE
#' )
#' ft_2 <- theme_box(ft_2)
#' ft_2
add_footer_row <- function(x, top = TRUE, values = character(0), colwidths = integer(0)) {
if (!inherits(x, "flextable")) {
stop(sprintf("Function `%s` supports only flextable objects.", "add_footer_row()"))
}
if (sum(colwidths) != length(x$col_keys)) {
stop(sprintf(
"`colwidths` argument specify room for %.0f columns but %.0f are expected.",
sum(colwidths), length(x$col_keys)
))
}
if (is.atomic(values)) {
values <- as.list(values)
}
if (inherits(values, "paragraph")) {
str_values <- vapply(values, function(x) paste0(x$txt, collapse = ""), FUN.VALUE = "")
} else {
str_values <- values
}
footer_data <- data_from_char(values = str_values, colwidths = colwidths, col_keys = x$col_keys)
if (nrow_part(x, "footer") < 1) {
x$footer <- complex_tabpart(data = footer_data, col_keys = x$col_keys, cwidth = dim(x)$widths, cheight = .25)
} else {
x$footer <- add_rows_to_tabpart(x$footer, footer_data, first = top)
}
row_span <- unlist(lapply(colwidths, function(x) {
z <- integer(x)
z[1] <- x
z
}))
i <- ifelse(top, 1, nrow_part(x, "footer"))
x$footer$spans$rows[i, ] <- row_span
col_j <- which(row_span > 0)
if (inherits(values, "paragraph")) {
for (j in seq_along(col_j)) {
x <- mk_par(x, i = i, j = col_j[j], value = values[j], part = "footer")
}
}
x
}
data_from_char <- function(values, colwidths, col_keys) {
if (is.list(values)) {
values <- as.character(unlist(values))
} else if (!is.atomic(values)) {
stop("'values' must be an atomic vector or a list.")
}
values_ <- inverse.rle(structure(list(lengths = colwidths, values = values), class = "rle"))
values_ <- as.list(values_)
names(values_) <- col_keys
as.data.frame(values_, check.names = FALSE, stringsAsFactors = FALSE)
}
# add labels as spanned rows ----
#' @export
#' @title Add full-width rows to the header
#'
#' @description Add one or more rows to the header where each label
#' spans all columns (all cells merged into one). Useful for adding
#' titles or subtitles above the column headers.
#'
#' @inheritParams args_x_only
#' @param values a character vector or a call to [as_paragraph()]
#' to get formated content, each element will
#' be added as a new row.
#' @param top should the row be inserted at the top
#' or the bottom. Default to TRUE.
#' @family functions for row and column operations in a flextable
#' @examples
#' # ex 1----
#' ft_1 <- flextable(head(iris))
#' ft_1 <- add_header_lines(ft_1, values = "blah blah")
#' ft_1 <- add_header_lines(ft_1, values = c("blah 1", "blah 2"))
#' ft_1 <- autofit(ft_1)
#' ft_1
#'
#' # ex 2----
#' ft01 <- fp_text_default(color = "red")
#' ft02 <- fp_text_default(color = "orange")
#' ref <- c("(1)", "(2)")
#' pars <- as_paragraph(
#' as_chunk(ref, props = ft02), " ",
#' as_chunk(rep("My tailor is rich", length(ref)), props = ft01)
#' )
#'
#' ft_2 <- flextable(head(mtcars))
#' ft_2 <- add_header_lines(ft_2, values = pars, top = FALSE)
#' ft_2 <- add_header_lines(ft_2, values = ref, top = TRUE)
#' ft_2 <- add_footer_lines(ft_2, values = "blah", top = TRUE)
#' ft_2 <- add_footer_lines(ft_2, values = pars, top = TRUE)
#' ft_2 <- add_footer_lines(ft_2, values = ref, top = FALSE)
#' ft_2 <- autofit(ft_2)
#' ft_2
add_header_lines <- function(x, values = character(0), top = TRUE) {
if (!inherits(x, "flextable")) {
stop(sprintf("Function `%s` supports only flextable objects.", "add_header_lines()"))
}
values_map <- values
if (top) values_map <- rev(values_map)
if (inherits(values, "paragraph")) {
for (ivalue in seq_len(length(values_map))) {
x <- add_header_row(x, values = "", colwidths = length(x$col_keys), top = top)
if (top) {
i <- 1
} else {
i <- nrow_part(x, "header")
}
x <- mk_par(x, i = i, j = 1, value = values_map[ivalue], part = "header")
}
} else {
for (value in values_map) {
x <- add_header_row(x, values = value, colwidths = length(x$col_keys), top = top)
}
}
x
}
#' @export
#' @title Add full-width rows to the footer
#'
#' @description Add one or more rows to the footer where each label
#' spans all columns (all cells merged into one). Useful for adding
#' footnotes or source notes below the table.
#' @inheritParams add_header_lines
#' @family functions for row and column operations in a flextable
#' @examples
#' ft_1 <- flextable(head(iris))
#' ft_1 <- add_footer_lines(ft_1,
#' values = c("blah 1", "blah 2")
#' )
#' ft_1
add_footer_lines <- function(x, values = character(0), top = FALSE) {
if (!inherits(x, "flextable")) {
stop(sprintf("Function `%s` supports only flextable objects.", "add_footer_lines()"))
}
ivalues <- seq_len(length(values))
if (top) {
ivalues <- rev(ivalues)
}
if (inherits(values, "paragraph")) {
for (ivalue in ivalues) {
x <- add_footer_row(x, values = "", colwidths = length(x$col_keys), top = top)
if (top) {
i <- 1
} else {
i <- nrow_part(x, "footer")
}
x <- mk_par(x, i = i, j = 1, value = values[ivalue], part = "footer")
}
} else {
for (ivalue in ivalues) {
x <- add_footer_row(x,
values = values[ivalue],
colwidths = length(x$col_keys), top = top
)
}
}
x
}
# add header/footer with reference table ----
set_part_df <- function(x, mapping = NULL, key = "col_keys", part) {
keys <- data.frame(
col_keys = x$col_keys,
stringsAsFactors = FALSE
)
names(keys) <- key
part_data <- merge(keys, mapping, by = key, all.x = TRUE, all.y = FALSE, sort = FALSE)
part_data <- part_data[match(keys[[key]], part_data[[key]]), ]
part_data[[key]] <- NULL
part_data <- do.call(rbind, part_data)
dimnames(part_data) <- NULL
part_data <- as.data.frame(part_data, stringsAsFactors = FALSE)
names(part_data) <- x$col_keys
if (length(x$blanks)) {
blank_ <- character(nrow(part_data))
replace_ <- lapply(x$blanks, function(x, bl) bl, blank_)
names(replace_) <- x$blanks
part_data[x$blanks] <- replace_
}
colwidths <- x[[part]]$colwidths
x[[part]] <- eval(
call(
class(x[[part]]),
data = part_data,
col_keys = x$col_keys,
cwidth = .75, cheight = .25
)
)
cheight <- optimal_sizes(x[[part]])$heights
x[[part]]$colwidths <- colwidths
x[[part]]$rowheights <- cheight
x
}
#' @export
#' @rdname set_header_footer_df
#' @name set_header_footer_df
#' @title Replace the entire header or footer from a data frame
#'
#' @description Replace all header or footer rows using a mapping data frame.
#' Unlike [set_header_labels()] which only renames the bottom header row,
#' this function rebuilds the entire header (or footer) structure.
#'
#' The data.frame must contain a column whose values match flextable
#' `col_keys` argument, this column will be used as join key. The
#' other columns will be displayed as header or footer rows. The leftmost column
#' is used as the top header/footer row and the rightmost column
#' is used as the bottom header/footer row.
#'
#' @inheritParams args_x_only
#' @param mapping a `data.frame` specyfing for each colname
#' content of the column.
#' @param key column to use as key when joigning data_mapping.
#' @examples
#' typology <- data.frame(
#' col_keys = c(
#' "Sepal.Length", "Sepal.Width", "Petal.Length",
#' "Petal.Width", "Species"
#' ),
#' what = c("Sepal", "Sepal", "Petal", "Petal", "Species"),
#' measure = c("Length", "Width", "Length", "Width", "Species"),
#' stringsAsFactors = FALSE
#' )
#'
#' ft_1 <- flextable(head(iris))
#' ft_1 <- set_header_df(ft_1, mapping = typology, key = "col_keys")
#' ft_1 <- merge_h(ft_1, part = "header")
#' ft_1 <- merge_v(ft_1, j = "Species", part = "header")
#' ft_1 <- theme_vanilla(ft_1)
#' ft_1 <- fix_border_issues(ft_1)
#' ft_1
#' @family functions for row and column operations in a flextable
set_header_df <- function(x, mapping = NULL, key = "col_keys") {
if (!inherits(x, "flextable")) {
stop(sprintf("Function `%s` supports only flextable objects.", "set_header_df()"))
}
set_part_df(x, mapping = mapping, key = key, part = "header")
}
#' @rdname set_header_footer_df
#' @export
#' @examples
#'
#'
#' typology <- data.frame(
#' col_keys = c(
#' "Sepal.Length", "Sepal.Width", "Petal.Length",
#' "Petal.Width", "Species"
#' ),
#' unit = c("(cm)", "(cm)", "(cm)", "(cm)", ""),
#' stringsAsFactors = FALSE
#' )
#' ft_2 <- set_footer_df(ft_1, mapping = typology, key = "col_keys")
#' ft_2 <- italic(ft_2, italic = TRUE, part = "footer")
#' ft_2 <- theme_booktabs(ft_2)
#' ft_2 <- fix_border_issues(ft_2)
#' ft_2
set_footer_df <- function(x, mapping = NULL, key = "col_keys") {
if (!inherits(x, "flextable")) {
stop(sprintf("Function `%s` supports only flextable objects.", "set_footer_df()"))
}
set_part_df(x, mapping = mapping, key = key, part = "footer")
}
#' @importFrom data.table tstrsplit
#' @export
#' @title Split column names using a separator into multiple rows
#' @description This function is used to separate and place individual
#' labels in their own rows if your variable names contain multiple
#' delimited labels.
#' \if{html}{\out{
#'
#' }}
#' @inheritParams args_x_only
#' @param opts Optional treatments to apply to the resulting header part.
#' This should be a character vector with support for multiple values.
#'
#' Supported values include:
#'
#' - "span-top": This operation spans empty cells with the first non-empty
#' cell, applied column by column.
#' - "center-hspan": Center the cells that are horizontally spanned.
#' - "bottom-vspan": Aligns to the bottom the cells treated at the when "span-top" is applied.
#' - "default-theme": Applies the theme set in `set_flextable_defaults(theme_fun = ...)` to the new header part.
#' @param split a regular expression (unless `fixed = TRUE`)
#' to use for splitting.
#' @param fixed logical. If TRUE match `split` exactly,
#' otherwise use regular expressions.
#' @family functions for row and column operations in a flextable
#' @examples
#' library(flextable)
#'
#' x <- data.frame(
#' Species = as.factor(c("setosa", "versicolor", "virginica")),
#' Sepal.Length_mean = c(5.006, 5.936, 6.588),
#' Sepal.Length_sd = c(0.35249, 0.51617, 0.63588),
#' Sepal.Width_mean = c(3.428, 2.77, 2.974),
#' Sepal.Width_sd = c(0.37906, 0.3138, 0.3225),
#' Petal.Length_mean = c(1.462, 4.26, 5.552),
#' Petal.Length_sd = c(0.17366, 0.46991, 0.55189),
#' Petal.Width_mean = c(0.246, 1.326, 2.026),
#' Petal.Width_sd = c(0.10539, 0.19775, 0.27465)
#' )
#'
#' ft_1 <- flextable(x)
#' ft_1 <- colformat_double(ft_1, digits = 2)
#' ft_1 <- theme_box(ft_1)
#' ft_1 <- separate_header(
#' x = ft_1,
#' opts = c("span-top", "bottom-vspan")
#' )
#' ft_1
separate_header <- function(x,
opts = c(
"span-top", "center-hspan",
"bottom-vspan", "default-theme"
),
split = "[_\\.]",
fixed = FALSE) {
if (nrow_part(x, "header") > 1) {
stop("the flextable object already have additional row(s),\nrun `separate_header()` before any header row augmentation")
}
ref_list <- tstrsplit(x$col_keys, split = split, fill = "", fixed = fixed)
ref_list <- rev(ref_list)
last_names <- ref_list[[1]]
names(last_names) <- x$col_keys
x <- set_header_labels(x, values = last_names)
add_labels <- ref_list[-1]
for (labels in add_labels) {
# dont span ""
tmp_labels <- labels
tmp_labels[tmp_labels %in% ""] <-
paste0("dummy-", seq_len(sum(tmp_labels %in% "")))
rle_labs <- rle(tmp_labels)
rle_labs$values[grepl("^dummy\\-", rle_labs$values)] <- ""
x <- add_header_row(
x = x, top = TRUE,
values = rle_labs$values,
colwidths = rle_labs$lengths
)
}
names(ref_list) <- letters[seq_along(ref_list)]
ref_list <- matrix(unlist(ref_list) %in% "", ncol = length(ref_list))
if ("default-theme" %in% opts) {
tmp <- do.call(
get_flextable_defaults()$theme_fun,
list(x)
)
x$header <- tmp$header
}
if ("span-top" %in% opts) {
for (j in seq_len(nrow(ref_list))) {
if (ref_list[j, 1]) {
to <- rle(ref_list[j, ])$lengths[1] + 1
if (all(x$header$spans$rows[seq(1, to), j] %in% 1)) {#can be v-merged
x <- merge_at(
x = x, i = seq(1, to), j = j,
part = "header"
)
}
if ("bottom-vspan" %in% opts) {
x <- valign(
x = x, i = seq(1, to), j = j,
valign = "bottom", part = "header"
)
}
}
}
}
if ("center-hspan" %in% opts) {
nr <- nrow(x[["header"]]$spans$rows)
header_spans <- fortify_span(x, parts = "header")
header_spans <- header_spans[header_spans$rowspan > 1, ]
header_spans <- split(header_spans$.col_id, header_spans$.row_id)
for (i in seq_along(header_spans)) {
x <- align(
x = x, i = i, j = as.character(header_spans[[i]]),
align = "center", part = "header"
)
}
}
fix_border_issues(x)
}
flextable/R/compact_summary.R 0000644 0001762 0000144 00000015247 15137670731 015772 0 ustar ligges users # helpers ----
.levels_summary <- function(x, max_levels) {
if (length(x) > max_levels) {
paste0(
paste0("'", head(x, n = max_levels), "'", collapse = ", "),
", ..."
)
} else {
paste0("'", x, "'", collapse = ", ")
}
}
.col_summary <- function(col, nm, max_levels) {
na_count <- sum(is.na(col))
non_na <- sum(!is.na(col))
out <- data.frame(
col_name = nm,
col_type = NA_character_,
n = NA_integer_,
na_count = na_count,
min_val = NA_real_,
max_val = NA_real_,
str_val = NA_character_,
data_kind = NA_character_,
stringsAsFactors = FALSE
)
if (is.logical(col)) {
out$col_type <- "logical"
out$n <- non_na
out$data_kind <- "logical"
if (non_na > 0L) {
out$str_val <- paste0(
"TRUE: ",
sum(col, na.rm = TRUE),
", FALSE: ",
sum(!col, na.rm = TRUE)
)
}
} else if (is.numeric(col)) {
out$col_type <- if (is.integer(col)) "integer" else "numeric"
out$n <- non_na
out$data_kind <- "numeric"
if (non_na > 0L) {
out$min_val <- min(col, na.rm = TRUE)
out$max_val <- max(col, na.rm = TRUE)
}
} else if (is.factor(col)) {
levs <- levels(droplevels(col))
out$col_type <- "factor"
out$n <- length(levs)
out$data_kind <- "discrete"
if (length(levs) > 0L) {
out$str_val <- .levels_summary(levs, max_levels = max_levels)
}
} else if (is.character(col)) {
vals <- sort(unique(na.omit(col)))
out$col_type <- "character"
out$n <- length(vals)
out$data_kind <- "discrete"
if (length(vals) > 0L) {
out$str_val <- .levels_summary(vals, max_levels = max_levels)
}
} else if (
inherits(col, "Date") ||
inherits(col, "POSIXt") ||
inherits(col, "hms") ||
inherits(col, "difftime")
) {
out$col_type <- if (inherits(col, "Date")) {
"Date"
} else if (inherits(col, "POSIXt")) {
"POSIXct"
} else {
"hms"
}
out$n <- non_na
out$data_kind <- "range"
if (non_na > 0L) {
out$str_val <- paste0(
format(min(col, na.rm = TRUE)),
" - ",
format(max(col, na.rm = TRUE))
)
}
} else {
return(NULL)
}
out
}
# main ----
#' @export
#' @title Compact Summary of a Dataset
#' @description
#' Produces a compact summary of a data.frame. Each row of the
#' result describes one column of the input with a type-specific
#' synopsis.
#'
#' Supported types and their summaries:
#'
#' - **numeric / integer**: count of non-`NA` values, min and max.
#' - **character**: number of unique values, first values listed.
#' - **factor**: number of levels, levels listed.
#' - **logical**: count of non-`NA` values, counts of `TRUE` and
#' `FALSE`.
#' - **Date**: count of non-`NA` values, date range.
#' - **POSIXct / POSIXlt**: count of non-`NA` values, datetime
#' range.
#' - **hms / difftime**: count of non-`NA` values, time range.
#'
#' Character and factor columns share the same summary layout
#' but report a different type label.
#'
#' The result has class `"compact_summary"` and can be converted
#' into a flextable with [as_flextable()].
#' @param x A data.frame.
#' @param show_type If `TRUE`, a *Type* column is added when the
#' object is rendered as a flextable.
#' @param show_na If `TRUE`, a *NA* column showing the count of
#' missing values per column is added when rendered as a
#' flextable.
#' @param max_levels Maximum number of levels or unique values
#' displayed for factor and character columns. Additional
#' values are replaced by `", ..."`.
#' @return A data.frame with additional class `"compact_summary"`.
#' @examples
#' z <- compact_summary(iris)
#' as_flextable(z)
#'
#' z <- compact_summary(iris, show_type = TRUE, show_na = TRUE)
#' as_flextable(z)
#' @family as_flextable methods
#' @seealso [as_flextable.compact_summary()]
compact_summary <- function(
x,
show_type = FALSE,
show_na = FALSE,
max_levels = 10L
) {
if (!is.data.frame(x)) {
stop("compact_summary() expects a data.frame.", call. = FALSE)
}
summaries <- mapply(
.col_summary,
col = x,
nm = names(x),
MoreArgs = list(max_levels = max_levels),
SIMPLIFY = FALSE
)
result <- rbindlist(Filter(Negate(is.null), summaries))
setDF(result)
if (is.null(result)) {
result <- data.frame(
col_name = character(0),
col_type = character(0),
n = integer(0),
na_count = integer(0),
min_val = numeric(0),
max_val = numeric(0),
str_val = character(0),
data_kind = character(0),
stringsAsFactors = FALSE
)
}
rownames(result) <- NULL
attr(result, "show_type") <- show_type
attr(result, "show_na") <- show_na
class(result) <- c("compact_summary", class(result))
result
}
#' @export
#' @title Transform a 'compact_summary' object into a flextable
#' @description `compact_summary` objects can be transformed into
#' a flextable with method [as_flextable()].
#'
#' Numeric columns are formatted with [formatC()] using the
#' `digits` value stored in the object and the current
#' flextable defaults for `big.mark` and `decimal.mark`.
#' @param x A `compact_summary` object produced by
#' [compact_summary()].
#' @param ... unused arguments.
#' @return A [flextable()] object.
#' @examples
#' z <- compact_summary(iris, show_type = TRUE, show_na = TRUE)
#' as_flextable(z)
#' @family as_flextable methods
as_flextable.compact_summary <- function(x, ...) {
show_type <- attr(x, "show_type")
show_na <- attr(x, "show_na")
z <- get_flextable_defaults()
format_num <- function(val) {
formatC(
val,
format = "f",
big.mark = z$big.mark,
digits = z$digits,
decimal.mark = z$decimal.mark
)
}
col_keys <- "col_name"
if (isTRUE(show_type)) {
col_keys <- c(col_keys, "col_type")
}
col_keys <- c(col_keys, "n")
if (isTRUE(show_na)) {
col_keys <- c(col_keys, "na_count")
}
col_keys <- c(col_keys, "Values")
ft <- flextable(x, col_keys = col_keys)
ft <- set_header_labels(
ft,
col_name = "Column",
col_type = "Type",
n = "N",
na_count = "NA",
Values = "Values"
)
is_num <- which(x$data_kind %in% "numeric")
if (length(is_num) > 0L) {
ft <- mk_par(
ft,
i = is_num,
j = "Values",
value = as_paragraph(
"Min: ",
as_chunk(min_val, formatter = format_num),
", Max: ",
as_chunk(max_val, formatter = format_num)
)
)
}
is_str <- which(!x$data_kind %in% "numeric")
if (length(is_str) > 0L) {
ft <- mk_par(
ft,
i = is_str,
j = "Values",
value = as_paragraph(as_chunk(str_val))
)
}
ft <- colformat_int(ft, j = "n")
if (isTRUE(show_na)) {
ft <- colformat_int(ft, j = "na_count")
}
autofit(ft)
}
flextable/R/nrowcol.R 0000644 0001762 0000144 00000001773 15131745533 014246 0 ustar ligges users #' @export
#' @title Number of rows of a part
#' @family functions for flextable size management
#' @description returns the number of lines in a part of flextable.
#' @inheritParams args_x_part
#' @examples
#' library(flextable)
#' ft <- qflextable(head(cars))
#' nrow_part(ft, part = "body")
nrow_part <- function(x, part = "body") {
if (!inherits(x, "flextable")) {
stop(sprintf("Function `%s` supports only flextable objects.", "nrow_part()"))
}
if (is.null(x[[part]])) {
0
} else if (is.null(x[[part]]$dataset)) {
0
} else {
nrow(x[[part]]$dataset)
}
}
#' @export
#' @title Number of columns
#' @family functions for flextable size management
#' @description returns the number of columns displayed
#' @inheritParams args_x_only
#' @examples
#' library(flextable)
#' ft <- qflextable(head(cars))
#' ncol_keys(ft)
ncol_keys <- function(x) {
if (!inherits(x, "flextable")) {
stop(sprintf("Function `%s` supports only flextable objects.", "ncol_keys()"))
}
length(x$col_keys)
}
flextable/vignettes/ 0000755 0001762 0000144 00000000000 15143405317 014233 5 ustar ligges users flextable/vignettes/overview.Rmd 0000644 0001762 0000144 00000000565 15131745533 016557 0 ustar ligges users ---
title: "Using flextable"
output: rmarkdown::html_vignette
vignette: >
%\VignetteIndexEntry{Using flextable}
%\VignetteEngine{knitr::rmarkdown}
%\VignetteEncoding{UTF-8}
---
The user manual is available here:
https://ardata-fr.github.io/flextable-book/
Help pages of functions are available here:
https://davidgohel.github.io/flextable/reference/index.html
flextable/NAMESPACE 0000644 0001762 0000144 00000023463 15143067476 013464 0 ustar ligges users # Generated by roxygen2: do not edit by hand
S3method(as_flextable,brmsfit)
S3method(as_flextable,compact_summary)
S3method(as_flextable,data.frame)
S3method(as_flextable,gam)
S3method(as_flextable,glm)
S3method(as_flextable,glmmTMB)
S3method(as_flextable,glmmadmb)
S3method(as_flextable,gls)
S3method(as_flextable,grouped_data)
S3method(as_flextable,htest)
S3method(as_flextable,kmeans)
S3method(as_flextable,lm)
S3method(as_flextable,lme)
S3method(as_flextable,merMod)
S3method(as_flextable,nlme)
S3method(as_flextable,pam)
S3method(as_flextable,summarizor)
S3method(as_flextable,table)
S3method(as_flextable,tabular)
S3method(as_flextable,tabulator)
S3method(as_flextable,xtable)
S3method(dim,flextable)
S3method(dim,flextableGrob)
S3method(drawDetails,flextableHighlightedGrob)
S3method(drawDetails,flextableRowPartGrob)
S3method(format_fun,Date)
S3method(format_fun,POSIXt)
S3method(format_fun,character)
S3method(format_fun,default)
S3method(format_fun,double)
S3method(format_fun,factor)
S3method(format_fun,integer)
S3method(format_fun,logical)
S3method(format_fun,pct)
S3method(knit_print,flextable)
S3method(knit_print,run_reference)
S3method(latex_container_str,latex_container_float)
S3method(latex_container_str,latex_container_none)
S3method(latex_container_str,latex_container_wrap)
S3method(makeContext,flextableGrob)
S3method(ph_with,flextable)
S3method(plot,flextable)
S3method(plot,flextableGrob)
S3method(print,flextable)
S3method(print,flextable_defaults)
S3method(print,tabulator)
S3method(rtf_add,flextable)
S3method(summary,tabulator)
S3method(to_html,flextable)
S3method(to_rtf,flextable)
S3method(to_wml,flextable)
export(add_body)
export(add_body_row)
export(add_footer)
export(add_footer_lines)
export(add_footer_row)
export(add_header)
export(add_header_lines)
export(add_header_row)
export(add_latex_dep)
export(align)
export(align_nottext_col)
export(align_text_col)
export(append_chunks)
export(as_b)
export(as_bracket)
export(as_chunk)
export(as_equation)
export(as_flextable)
export(as_grouped_data)
export(as_highlight)
export(as_i)
export(as_image)
export(as_paragraph)
export(as_qmd)
export(as_raster)
export(as_strike)
export(as_sub)
export(as_sup)
export(as_word_field)
export(autofit)
export(before)
export(bg)
export(body_add_flextable)
export(body_replace_flextable_at_bkm)
export(bold)
export(border)
export(border_inner)
export(border_inner_h)
export(border_inner_v)
export(border_outer)
export(border_remove)
export(chunk_dataframe)
export(colformat_char)
export(colformat_date)
export(colformat_datetime)
export(colformat_double)
export(colformat_image)
export(colformat_int)
export(colformat_lgl)
export(colformat_num)
export(color)
export(colorize)
export(compact_summary)
export(compose)
export(continuous_summary)
export(delete_columns)
export(delete_part)
export(delete_rows)
export(df_printer)
export(dim_pretty)
export(empty_blanks)
export(fit_to_width)
export(fix_border_issues)
export(flextable)
export(flextable_dim)
export(flextable_html_dependency)
export(flextable_to_rmd)
export(fmt_2stats)
export(fmt_avg_dev)
export(fmt_dbl)
export(fmt_header_n)
export(fmt_int)
export(fmt_n_percent)
export(fmt_pct)
export(fmt_signif_after_zeros)
export(fmt_summarizor)
export(font)
export(fontsize)
export(footers_flextable_at_bkm)
export(footnote)
export(fp_border_default)
export(fp_text_default)
export(gen_grob)
export(get_flextable_defaults)
export(gg_chunk)
export(grid_chunk)
export(headers_flextable_at_bkm)
export(height)
export(height_all)
export(highlight)
export(hline)
export(hline_bottom)
export(hline_top)
export(hrule)
export(htmltools_value)
export(hyperlink_text)
export(information_data_cell)
export(information_data_chunk)
export(information_data_paragraph)
export(init_flextable_defaults)
export(italic)
export(keep_with_next)
export(labelizor)
export(line_spacing)
export(linerange)
export(lollipop)
export(merge_at)
export(merge_h)
export(merge_h_range)
export(merge_none)
export(merge_v)
export(minibar)
export(mk_par)
export(ncol_keys)
export(nrow_part)
export(padding)
export(paginate)
export(plot_chunk)
export(prepend_chunks)
export(proc_freq)
export(qflextable)
export(regulartable)
export(rotate)
export(save_as_docx)
export(save_as_html)
export(save_as_image)
export(save_as_pptx)
export(save_as_rtf)
export(separate_header)
export(set_caption)
export(set_flextable_defaults)
export(set_footer_df)
export(set_formatter)
export(set_formatter_type)
export(set_header_df)
export(set_header_labels)
export(set_table_properties)
export(shift_table)
export(style)
export(summarizor)
export(surround)
export(tab_settings)
export(tabulator)
export(tabulator_colnames)
export(theme_alafoli)
export(theme_apa)
export(theme_booktabs)
export(theme_borderless)
export(theme_box)
export(theme_tron)
export(theme_tron_legacy)
export(theme_vader)
export(theme_vanilla)
export(theme_zebra)
export(use_df_printer)
export(use_flextable_qmd)
export(use_model_printer)
export(valign)
export(vline)
export(vline_left)
export(vline_right)
export(void)
export(width)
export(wrap_flextable)
import(data.table)
importFrom(data.table,":=")
importFrom(data.table,.GRP)
importFrom(data.table,.N)
importFrom(data.table,.SD)
importFrom(data.table,as.data.table)
importFrom(data.table,data.table)
importFrom(data.table,dcast)
importFrom(data.table,fcase)
importFrom(data.table,fifelse)
importFrom(data.table,first)
importFrom(data.table,fsetdiff)
importFrom(data.table,groupingsets)
importFrom(data.table,is.data.table)
importFrom(data.table,rbindlist)
importFrom(data.table,rleid)
importFrom(data.table,rleidv)
importFrom(data.table,setDF)
importFrom(data.table,setDT)
importFrom(data.table,setcolorder)
importFrom(data.table,setkeyv)
importFrom(data.table,setnames)
importFrom(data.table,setorderv)
importFrom(data.table,shift)
importFrom(data.table,tstrsplit)
importFrom(gdtools,installed_gfonts)
importFrom(gdtools,strings_sizes)
importFrom(grDevices,as.raster)
importFrom(grDevices,col2rgb)
importFrom(grDevices,dev.list)
importFrom(grDevices,dev.off)
importFrom(grDevices,is.raster)
importFrom(grDevices,rgb)
importFrom(graphics,boxplot)
importFrom(graphics,par)
importFrom(graphics,plot)
importFrom(grid,convertHeight)
importFrom(grid,convertWidth)
importFrom(grid,drawDetails)
importFrom(grid,gList)
importFrom(grid,gTree)
importFrom(grid,gpar)
importFrom(grid,grid.draw)
importFrom(grid,grid.layout)
importFrom(grid,grid.newpage)
importFrom(grid,grid.rect)
importFrom(grid,grobDescent)
importFrom(grid,grobHeight)
importFrom(grid,grobWidth)
importFrom(grid,is.grob)
importFrom(grid,makeContext)
importFrom(grid,popViewport)
importFrom(grid,pushViewport)
importFrom(grid,rasterGrob)
importFrom(grid,rectGrob)
importFrom(grid,segmentsGrob)
importFrom(grid,setChildren)
importFrom(grid,textGrob)
importFrom(grid,unit)
importFrom(grid,viewport)
importFrom(grid,vpStack)
importFrom(htmltools,HTML)
importFrom(htmltools,attachDependencies)
importFrom(htmltools,browsable)
importFrom(htmltools,div)
importFrom(htmltools,htmlDependency)
importFrom(htmltools,htmlEscape)
importFrom(htmltools,save_html)
importFrom(htmltools,tagList)
importFrom(htmltools,tags)
importFrom(knitr,asis_output)
importFrom(knitr,fig_path)
importFrom(knitr,include_graphics)
importFrom(knitr,is_html_output)
importFrom(knitr,is_latex_output)
importFrom(knitr,knit_child)
importFrom(knitr,knit_meta_add)
importFrom(knitr,knit_print)
importFrom(knitr,opts_current)
importFrom(knitr,opts_knit)
importFrom(knitr,pandoc_to)
importFrom(knitr,raw_block)
importFrom(knitr,raw_html)
importFrom(knitr,raw_latex)
importFrom(officer,add_slide)
importFrom(officer,body_add_par)
importFrom(officer,body_add_xml)
importFrom(officer,body_set_default_section)
importFrom(officer,cursor_bookmark)
importFrom(officer,fp_border)
importFrom(officer,fp_cell)
importFrom(officer,fp_par)
importFrom(officer,fp_par_lite)
importFrom(officer,fp_tab)
importFrom(officer,fp_tabs)
importFrom(officer,fp_text)
importFrom(officer,fp_text_lite)
importFrom(officer,fpar)
importFrom(officer,ftext)
importFrom(officer,image_to_base64)
importFrom(officer,officer_url_encode)
importFrom(officer,opts_current_table)
importFrom(officer,page_mar)
importFrom(officer,page_size)
importFrom(officer,ph_location_type)
importFrom(officer,ph_with)
importFrom(officer,prop_section)
importFrom(officer,prop_table)
importFrom(officer,read_docx)
importFrom(officer,read_pptx)
importFrom(officer,rtf_add)
importFrom(officer,rtf_doc)
importFrom(officer,run_autonum)
importFrom(officer,run_bookmark)
importFrom(officer,str_encode_to_rtf)
importFrom(officer,table_colwidths)
importFrom(officer,table_layout)
importFrom(officer,table_width)
importFrom(officer,to_html)
importFrom(officer,to_rtf)
importFrom(officer,to_wml)
importFrom(ragg,agg_capture)
importFrom(ragg,agg_png)
importFrom(rlang,call_args)
importFrom(rlang,enquo)
importFrom(rlang,enquos)
importFrom(rlang,eval_tidy)
importFrom(rlang,get_expr)
importFrom(rlang,new_function)
importFrom(rlang,pairlist2)
importFrom(rlang,quo)
importFrom(rlang,quo_name)
importFrom(rlang,quo_text)
importFrom(rlang,sym)
importFrom(rmarkdown,html_document)
importFrom(rmarkdown,latex_dependency)
importFrom(rmarkdown,pandoc_available)
importFrom(rmarkdown,pandoc_version)
importFrom(rmarkdown,pdf_document)
importFrom(rmarkdown,render)
importFrom(stats,AIC)
importFrom(stats,BIC)
importFrom(stats,IQR)
importFrom(stats,approx)
importFrom(stats,as.formula)
importFrom(stats,density)
importFrom(stats,df.residual)
importFrom(stats,logLik)
importFrom(stats,mad)
importFrom(stats,median)
importFrom(stats,na.omit)
importFrom(stats,naprint)
importFrom(stats,nobs)
importFrom(stats,quantile)
importFrom(stats,reshape)
importFrom(stats,runif)
importFrom(stats,sd)
importFrom(stats,setNames)
importFrom(stats,terms)
importFrom(stats,update)
importFrom(utils,browseURL)
importFrom(utils,compareVersion)
importFrom(utils,getFromNamespace)
importFrom(utils,head)
importFrom(utils,modifyList)
importFrom(utils,packageVersion)
importFrom(utils,str)
importFrom(utils,tail)
importFrom(uuid,UUIDgenerate)
importFrom(xml2,as_xml_document)
flextable/NEWS.md 0000644 0001762 0000144 00000120160 15143067476 013333 0 ustar ligges users # flextable 0.9.11
## new features
- new function `wrap_flextable()` enables integration with 'patchwork' layouts.
Flextable objects can be combined with 'ggplot2' plots using `+`, `|`, and `/`
operators. Table headers and footers are aligned with plot panel areas. The
`panel` argument controls alignment (`"body"`, `"full"`, `"rows"`, `"cols"`)
and the `space` argument controls sizing (`"free"`, `"fixed"`, `"free_x"`,
`"free_y"`). `flex_body` stretches body rows to match a neighbouring plot's
panel height; `flex_cols` stretches data columns to match the panel width.
`just` controls horizontal alignment (`"left"`, `"right"`, `"center"`)
when the table is narrower than the panel. S3 methods `ggplot_add.flextable`
and `as_patch.flextable` are registered so that `plot + flextable` works
transparently.
- new function `theme_borderless()` applies a minimal theme with no borders,
bold header, and standard column alignment.
- support strikethrough formatting with `fp_text_default()`.
- new function `as_strike()` to apply strikethrough formatting to text chunks.
- new function `compact_summary()` to create a compact summary of a data.frame
that can be transformed as a flextable with `as_flextable()`.
- `summarizor()`: when using `overall_label` with multiple `by` columns,
an overall level is now added for each grouping column (not only the last one).
This produces margins at every nesting level, including a grand total.
- `footnote()` gains a `symbol_sep` argument to insert a separator
between multiple footnote symbols in the same cell (#699).
- new function `as_qmd()` to embed Quarto markdown (cross-references,
bold/italic, links, math, inline code) inside flextable cells.
Works with HTML, PDF and Word outputs. New function `use_flextable_qmd()`
installs the companion `flextable-qmd` Lua filter extension in
the Quarto project.
## Known limitations
- PDF/LaTeX: a table row whose content is taller than a page cannot be
split across pages (#548). This is a fundamental constraint of LaTeX's
`longtable` environment, which only supports page breaks between rows,
not within a single row. HTML and Word outputs are not affected.
## Internals
- Strings metrics are now computed with `gdtools::strings_sizes()` instead of
`m_str_extents()` and `str_metrics()`, goal is to let 'gdtools' use only 'systemfonts'
and be simplified.
## Issues
- line breaks (`\n`) in captions now render correctly in PDF/LaTeX
output (#663).
- images in google docs should now be sized as expected
- specifying a `word_style` for a paragraph style works now.
The `word_style` values will be ignored if flextable is process by 'rmarkdown'
or 'quarto'.
- `as_flextable.tabulator()`: the N= counts in column headers are now
displayed when there are multiple grouping columns (previously limited
to a single grouping column).
- `footnote()` no longer errors when the row selector `i` matches
zero rows (#712).
- footnote symbols no longer clash with rotated cells in HTML
output (#713).
- PDF/Quarto: the `fontspec` LaTeX package is no longer included when
the PDF engine is `pdflatex`, fixing compilation errors in Quarto
documents using `pdf-engine: pdflatex` (#701, #707). Engine detection
now also reads `QUARTO_EXECUTE_INFO` (Quarto >= 1.8) and nested YAML
(`format > pdf > pdf-engine`).
- inner borders of vertically merged cells no longer show in PDF
output when background color is set (#673).
- PDF/Quarto: footer repetition and longtable part ordering now work
correctly with the default container (`none`) in Quarto output.
- `merge_v()`: vertically merged cell labels now appear at the top of
the merged range in PDF/LaTeX output instead of the bottom (#654).
- vertical alignment (`valign`) in merged cells now works correctly in
PDF/LaTeX output when rows have different heights (#639). Content is
placed in the first (top), middle (center), or last (bottom) row of the
merged range; `\multirow` is no longer used as it miscalculates offsets
with unequal row heights.
- using `by` of `summarizor()` referring to two columns, one of which has
only one unique value no longer causes and error when passed on to
`as_flextable()`.
# flextable 0.9.10
## new features
- It is now possible to not repeat headers'rows along Word pages
by using `set_table_properties(opts_word = list(repeat_headers = FALSE))`.
## Issues
- fix `format_fun.default` so that it works with logical columns.
## Change
- `print.flextable(preview = "log")` use `str()` to show first values of data
instead of `print()` so that when there are ggplot2 v4 objects in the table, the
print is not failing.
# flextable 0.9.9
## new features
- `proc_freq` gains new argument `count_format_fun` to let control the function
that format the count values.
## Issues
- fix compatibility issue with rmarkdown::word_document and quarto introduced with
version `0.9.8`.
## Changes
- Defunct previously deprecated functions `as_raster()`, `lollipop()`
and `set_formatter_type()`.
- Definitively forbid usage of empty symbol `''` with footnotes. Users should
use `add_footer_lines()` instead.
# flextable 0.9.8
## Issues
- `tab_settings()` is now using j argument as expected (#635)
- doc inconsistency for `set_table_properties()` with layout that defaults to
"fixed".
- add_header_row produced an error after using `delete_column()` (#676)
- `fmt_signif_after_zeros()` fixed issue with 0 rounding
- `proc_freq` supports now non syntactically names
# flextable 0.9.7
## new features
- Added support for labelled datasets.
## Changes
- The `fix_border_issues` function is now useless for users, as it is now
called automatically before printing.
## Issues
- fix caption issue that came with no version of bookdown (issue #645),
'bookdown' management of caption has been simplified.
- fix vertical overlapping lines with grid output (issue #644)
- fix broken internal links in PDF file, probably due to a change in knitr or
rmarkdown (issue #632)
- fix right outer border issue in grid format (issue #650)
- fix `flextable_to_rmd()` issue with images in pdf (issue #651)
- fix `flextable_to_rmd()` issue with local chunk `eval` option (issue #631)
- `proc_freq` can now display only the table percentages without the count
using `include.table_count = FALSE`.
- bring back support for 'pagedown' with `pagedown >= 0.20.2`
- flextable now applies defined text-format to empty cells for Word and
Powerpoint outputs.
# flextable 0.9.6
## Changes
- `headers_flextable_at_bkm()` and `footers_flextable_at_bkm()` are defunct.
- `flextable_to_rmd()` is now using `knit_child()` for safer usage from `for`
loops or `if` statements.
- Add explanation about caption limitations in the manual of functions
`save_as_image()` and `ph_with.flextable()`.
- Deprecate `as_raster()` since `gen_grob()` is easier to use and render
nicer.
- BREAKING CHANGE: in `align()`, the default argument value for `align` is now
`"left"`, rather than `c("left", "center", "right", "justify")`. This
returns the default value to how it was in older versions of {flextable}.
- in `align()`, use of the old default `align` argument could cause an
error if the number of columns being adjusted was not a multiple of 4.
- The documentation specified that `align` had to be a single value, when
it could actually accept multiple values. This is why a default value of
`c("left", "center", "right", "justify")`, was problematic. This
documentation has now been updated and new examples included in the
documentation.
- The default `align` argument will now apply left alignment to all
columns in the body.
- If the user specifies an alignment that is invalid, a error will be
displayed.
- The `path` argument now has a signature of `part = c("body", "header",
"footer", "all")`, but because only a single value can be selected, it
will pick `"body"` by default, as before.
- Deprecate `lollipop()` since it produces (ugly) results that can be replaced
by nice results with `gg_chunk()` or `grid_chunk()`.
## Issues
- fix issue with `as_image()` when the table contains no text.
- fix font instruction issue with PDF and quarto
- fix issue with Quarto detection and R > 4.4
- fix `align()` issue with recycling and update documentation
that was wrong about argument `align` that is vectorized over
columns.
# flextable 0.9.5
## new features
- new functions `tab_settings()` to set tabulation marks configuration
for Word and RTF. It works with `officer::fp_tabs()`.
- new function `fmt_signif_after_zero()` to round significant figures after zeros.
## Issues
- `summarizor()` don't stop anymore if table only contain discrete columns.
- `as_flextable.data.frame()` supports 'data.table'
- `footnote()` handle undefined `ref_symbols` argument
- `delete_rows()` does not delete rows if the row selection is empty
- improve `gen_grob()` alignments when wrapping text
- fix horizontal border issue with `gen_grob()` when cells are vertically merged
- Word captions set with `set_caption()` can have no bookmark and have
autonumber used together.
## Changes
- default `tabcolsep` is now set to 2.
- Deprecate `set_formatter_type()`.
- renovate `fmt_2stats()` so that it uses global flextable settings,
i.e. digits, etc.
- refactoring of data structure for content
- footer along pages in PDF are now deactivated by default. It can be
activated with command `set_table_properties(opts_pdf = list(footer_repeat = TRUE))`.
- more argument checkings in `as_chunk()`
# flextable 0.9.4
## Issues
- `ph_with.flextable()` formats widths and heights correctly.
- move image shown in add_footer to footnote where it should be.
- update the documentation and automatically change alignment
'justify' to 'left' for latex output.
- borders'width for grid output are fixed
## new features
- new functions `delete_columns()` and `delete_rows()`
to let users delete rows or columns.
- `save_as_image()` now supports svg export with 'svglite'.
# flextable 0.9.3
## new features
- The `summarizor()` function has been enhanced to offer three new options:
- an empty `by` argument meaning 'no grouping,'
- the ability for users to select numeric statistics to display ("mean_sd," "median_iqr," "range"),
- and the option to specify whether or not to show all NA counts.
## Changes
- `as_flextable.data.frame()` always shows the number of rows even if less than 10
(because I need it!).
## Issues
- Make sure 'gfm' format is rendered as an image.
- As adviced by Ben Bolker, functions `as_flextable.lm()`, `as_flextable.gam()`,
`as_flextable.glm()`, `as_flextable.merMod()` and `as_flextable.htest()`
now respect the global value of `getOption("show.signif.stars")`.
- new argument `add.random` in `as_flextable.merMod()` to let add or not
random effects in the final table.
- drop superfluous semicolons when include.row_percent = FALSE
- Super and subscripts are now correctly
rendered in PDF (thanks to Philippe Grosjean).
- argument `max_iter` of function `fit_to_width` is not
ignored anymore.
## Internals
- rename technical column `part` to `.part` so that
column named `part` can be used.
# flextable 0.9.2
## Issues
- rmarkdown expect list of dependencies to be unnamed.
This property is used in HTML or LaTeX deps resolution to know
when to be recursive
- `dim_pretty()` returns correct numbers when not 'inches'
- `as_flextable.table()` now propagates `...` as expected
- pdf: when table was on two pages, there were duplicated caption entries,
this is fixed thanks to Christophe Dervieux and Nick Bart. Repeating
the caption along pages can be desactivated with command
`set_table_properties(opts_pdf = list(caption_repeat = FALSE))`.
- `as_flextable()` now works on tabular objects and `R < 4.1`.
- `to_html(type = "img")` now use the correct width and height
## Changes
- bookdown has now bookmarks associated with captions and flextable benefits
from this feature.
- In 'Quarto' captions are ignored, which make Quarto captions valid with HTML
and PDF outputs; the responsibility for managing captions lies with the
Quarto framework itself. It does not work with Quarto for Word and should be
possible with Quarto `1.4`.
- `as_flextable.tabular()` now generate tabulated content only if the sub group
contains more than a single row. When possible, row titles are tabulated.
## Deprecated functions
- The functions `footers_flextable_at_bkm` and `headers_flextable_at_bkm` are deprecated.
Instead, we recommend using the `prop_section()` and `block_list()` functions from the `officer` package as alternative solutions. These functions provide more reliable and flexible options for managing footers and headers.
# flextable 0.9.1
## breaking change
- parameter `keepnext` and `ft.keepnext` are defunct, they are replaced
by function `paginate()` that enable nice pagination of tables across pages
or `keep_with_next()` to get total control over rows pagination.
## new features
- add RTF support for captions.
- `set_flextable_defaults()` gains parameter `pct_digits`
(number of digits for percentages) that will be used in relevant
functions (only `proc_freq()` for now).
- new method `as_flextable.table()`.
- new functions `fmt_dbl()`, `fmt_int()` and `fmt_pct()`.
- Support for Word and RTF pagination with function `paginate()`
## internals
- refactor proc_freq and support 1d frequency table
## issues
- colname `type` is now possible when using `tabulator()`.
- value for html dependancies parameter is a list of html-dep as expected.
This solves issue for blogdown and pkgdown introduced in the previous version.
- fix `save_as_html()` ugly default title.
- fix alignment issues when rows are horizontally merged in PDF
# flextable 0.9.0
## new features
- add RTF support for captions.
- enable new labels with `set_header_labels()` from a simple
un-named vector.
- function `set_formatter()` now accepts single function to
be applied to all columns.
- HTML output now can capture google fonts if installed with
`gdtools::register_gfont()`.
- refactor `save_as_html()`: use rmarkdown and add google fonts
if possible (See `gdtools::register_gfont()`).
## issues
- fix `as_flextable.tabular(spread_first_col=TRUE)`
# flextable 0.8.6
In short:
- RTF support,
- revealjs support,
- preserve all aspects within Quarto html format
- use grid graphics for saving as png (no need for "webshot" or "webshot2" packages)
- support for `tables::tabular()`: "Computes a table of summary statistics, cross-classified by various variables"
## new features
- add RTF support with `officer::rtf_add()`.
- new convert `tables::tabular()` to flextable with new
function `as_flextable.tabular()`.
- add `to_html.flextable()` to make easy embedding of
flextable results in HTML (with 'ggiraph' for example).
- add global setting `border.width` (see `?set_flextable_defaults()`)
and set its default value to .75, this setting is
used in theme functions. The old default value was hard coded
to 1 and can be defined during the whole R session with
`set_flextable_defaults(border.width = 1)`.
## internals
- drop 'base64enc' dependency and use 'officer' functions
as replacement.
- Use `officer_url_encode()` to encode URL in office files.
- refactor `knit_print.flextable()` and related functions.
- drop webshot dependency to produce images, now using package
'ragg'.
- refactor captions: knitr context now updates the caption
instead of managing caption value and defined knitr
options.
- use shadow in all HTML output generated via knitr
(i.e. 'Quarto' and 'R Markdown').
## issues
- support revealjs (and probably all RMD formats that generate HTML)
- fix cell's vertical alignments in latex
- fix detection of non transparent background table in latex so that
the correct lines instructions (hhlines or clines) are being used.
- fix `headers_flextable_at_bkm()` and `footers_flextable_at_bkm()`
# flextable 0.8.5
## changes
- use pkgdown features instead of images shots
in the manual examples. The website now shows
flextable results.
## issues
- fix issue with flextable_to_rmd and pdf introduced in `0.8.4`.
- fix caption issue with Word and `body_add_flextable()`.
# flextable 0.8.4
## new features
- new argument `expand_single` in `as_flextable.tabulator()`. If `FALSE`,
groups with only one row will not be expanded with a title row.
- argument `labels` of `labelizor()` now support functions in
addition to named vectors.
- `as.character()` now returns the HTML string of the table
- new method `as_flextable` for data.frame using `df_printer()` function
implementation.
## Issues
- fix mis-calculated columns widths in latex
- fix horizontal lines in latex tables
- adapt latex table container to quarto changes
- Word caption: autonumber works without bookmark
# flextable 0.8.3
## new features
- new argument `expand_single` in `as_grouped_data()`. If FALSE, groups with only one
row will not be expanded with a title row.
- new functions `fmt_avg_dev()`, `fmt_header_n()`, `fmt_n_percent()` and renaming of `fmt_2stats()`
to `fmt_summarizor()` to help working with `tabulator()`. `tabulator()` has also new
internal values that allow N=xxx notes and automatic labels.
- function `set_table_properties()` is now the recommanded way to set
arguments related to format options and alignment in a document. It is
supposed to replace "knitr" chunk options `ft.align`, `ft.split`,
`ft.keepnext`, `ft.tabcolsep`, `ft.arraystretch`, `ft.latex.float`,
`ft.shadow`, `fonts_ignore` although they are all still
supported.
This allows less interaction with the 'R Markdown' or 'Quarto'
eco-system and let to define it globally with `set_flextable_defaults()`.
- HTML scrolling can be activated by calling `set_table_properties()` and
providing a *scroll* value for argument `opts_html`:
`opts_html = list(scroll = list(height = "500px",freeze_first_column = TRUE))`.
- new function `grid_chunk()` to let users add grid graphics
- functions `add_header_row()`, `add_footer_row()`, `add_body_row()`,
`add_header_lines()` and `add_footer_lines()`
now supports formatted paragraph made with `as_paragraph()`.
- captions: support for simple text in addition to `as_paragraph()`
- `summarizor()` can now be transformed directly as a flextable
with method `as_flextable()`.
## Issues
- fix issue with keepnext and `body_add_flextable()`
- fix issue of misordered chunks with `prepend_chunks()`
- argument 'unit' is dropped in `line_spacing()` as it is expected to be a ratio
## Changes
- `ft.keepnext` now default to FALSE as lot of users had issues
with this option.
- function `xtable_to_flextable()` is removed (use `as_flextable()`)
# flextable 0.8.2
## Issues
- prevent docx captions test when pandoc version
is "2.9.2.1" (on CRAN Flavor r-devel-linux-x86_64-fedora-gcc).
# flextable 0.8.1
## Issues
- fix warning with subscript and superscript #456
- prevent usage of gregexec if R < 4.1
- fix for rdocx captions
# flextable 0.8.0
## new features
- flextable now supports "Grid graphics" output format. See `gen_grob()`.
- `labelizor()` is a new function to help change text by labels.
- add support for paragraph settings (made with `fp_par()`) in captions with `set_caption()`.
- captions are now made with `as_paragraph()`
- caption alignments and keep_with_next is now computed instead of being provided by user
- alternative text for Word tables with word_title and word_description
by calling `set_table_properties()` or setting values to knitr chunk options `tab.alt.title` and `tab.alt.description`.
- Word and HTML captions paragraphs settings can be defined by using `set_caption()`.
The alignment of the paragraph can be different from the alignment of the table
with the argument `align_with_table=FALSE`.
- new theme 'APA', `theme_apa` (@rempsyc #426)
- method `as_flextable.tabulator()` gains an argument `spread_first_col` to enable
spreading of the first column of the table as a line separator.
- fix doc links to functions from other packages for future releases
## Issues
- fix caption issue resulting from a clash with variable name 'n' (#443)
- Quarto support
- fix as_grouped_data() with date columns (#438)
- fix footnotes spread over separate lines when 'inline' (#442)
- fix missing caption with rmarkdown pdf output
- fix first horizontal borders repeated issue with Word output
- add empty paragraphs between tables in `save_as_docx()` to avoid Word confusion
- fix `fortify_width()` calculation
# flextable 0.7.3
## new features
- function `as_flextable.tabulator()` gained an argument `label_rows` used for
labels to display in the first column names, i.e. the *row* column names.
- new function `shift_table()` to produce Shift Tables used used in
clinical trial analysis ready to be used by `tabulator()`.
- `as_image()` don't need anymore parameters `width` and
`height` if package 'magick' is available.
## Changes
- `plot.flextable` now default to *grid Graphics*. It produce a plot object
that can be used with packages 'ggplot2', 'patchwork' and 'cowplot'. The raster
version made with 'webshot' and 'magick' pachages is still available, use `plot(..., method = "webshot")`.
## Issues
- fix top borders correction (for docx and pptx)
- check that used colors do not contain NA
- fix HTML scrolling that is always visible to Windows users
- fix "cs.family", "hansi.family" and "eastasia.family" for Word
- fix anti-selectors for bg/color/highlight, a regression from version 0.7.2
- when HTML and layout "autofit", output width is not set when width has been
defined to 0 to avoid unnecessary word breaks (#429).
## Changes
- pptx output is constructed with top and bottom margins whose value is
top and bottom padding of the paragraph and there is no more borders copies
while rendering.
- add visual tests with doconv
- footnote can not be used with "" symbols, use `add_footer_lines()` instead.
# flextable 0.7.2
## Issues
- fix selector issue with numeric values (#409)
# flextable 0.7.1
## new features
* function `as_flextable()` has now methods for
lm, glm, models from package 'lme' and 'lme4',
htest (t.test, chisq.test, ...), gam, kmeans and pam.
* new function `use_model_printer()` to set model automatic
printing as a flextable in an R Markdown document.
* new function `add_body_row()` to add a row in the body part
with eventually merged/spanned columns.
* new function `tabulator_colnames()` to get column names
of a `tabulator` object.
* new function `prepend_chunks()` to prepend chunks of content
in flextable cells as with `as_paragraph()` but without
replacing the whole content.
* addition of chunk function `as_word_field()` to let add 'Word' computed
values into a flextable, as `as_word_field(x = "Page")` for a page number.
* new function `separate_header()` to Separate collapsed
colnames into multiple rows.
* Functions `autofit()` and `dim_pretty()` now support newlines.
* `autofit()` and `dim_pretty()` now have an argument `hspans`
to help specify how horizontally spanned cells should affect
the results.
* PDF output now supports various floating placement options with
knitr option `ft.latex.float`, supported values are 'none'
(the default value), 'float', 'wrap-r', 'wrap-l',
'wrap-i' and 'wrap-o'.
* HTML output have now a scrool bar if width does not fit in the
container. This can be switch off by using the knitr
option `ft.htmlscroll = FALSE`.
* `tabulator()` can display any columns before and
after the columns of displayed aggregations.
## Issues
* fix append_chunks usage by adding `i`, `j` and `part`
at the end of the function arguments, after the `...`.
* add forgotten `supp_data` in the result table of `tabulator()`
* merged horizontal borders are now visible in PowerPoint (#378)
* PowerPoint 'soft returns' are now real 'soft returns'. (#379)
* mapping between argument `j` and `source` when color is a function
(in `bg()`, `highlight()` and `color()`) is now based on colnames
to avoid mistake while mapping. #395
* Fix issue with footnotes forcing rectangular extent for selection;
thanks to Sean Browning
* fix horizontal and vertical alignements when rotating paragraphs for
pptx, docx and html outputs
* links in pptx and docx are not transformed anymore.
* fix handling of special characters in latex
* vertically merged cells now wrap text into the paragraph
## Changes
* refactor the code for pptx and docx output
# flextable 0.7.0
## new features
* new function `append_chunks()` to append chunks of content
in flextable cells as with `as_paragraph()` but without
replacing the whole content.
* new function `tabulator()` and its method
`as_flextable.tabulator()` that help the creation
of tables used in life science industry. It also
comes with function `summarizor()` and sugar function
`fmt_2stats()`.
* `empty_blanks()` gained arguments `width` so that users can also
set blank columns' width.
* pass `...` to `format()` function when using `colformat_num()`. It
makes possible to use arguments for `format()`, for example
`colformat_num(drop0trailing = TRUE)`.
* add knitr chunk option `ft.keepnext` and parameter `keepnext`
to function `body_add_flextable()` that enable the Word option
'keep rows together', so that page break within a table is
avoided when possible.
* new function `add_latex_dep()` to manually add flextable latex
dependencies to the knitr session.
## Issues
* fix Rd files which when converted to HTML had `Using flextable
The user manual is available here:
https://ardata-fr.github.io/flextable-book/
Help pages of functions are available here:
https://davidgohel.github.io/flextable/reference/index.html
flextable/inst/doc/overview.Rmd 0000644 0001762 0000144 00000000565 15131745533 016271 0 ustar ligges users --- title: "Using flextable" output: rmarkdown::html_vignette vignette: > %\VignetteIndexEntry{Using flextable} %\VignetteEngine{knitr::rmarkdown} %\VignetteEncoding{UTF-8} --- The user manual is available here: https://ardata-fr.github.io/flextable-book/ Help pages of functions are available here: https://davidgohel.github.io/flextable/reference/index.html flextable/inst/_extensions/ 0000755 0001762 0000144 00000000000 15143067476 015550 5 ustar ligges users flextable/inst/_extensions/flextable-qmd/ 0000755 0001762 0000144 00000000000 15143353350 020262 5 ustar ligges users flextable/inst/_extensions/flextable-qmd/unwrap-float.lua 0000644 0001762 0000144 00000013724 15143353350 023413 0 ustar ligges users --- unwrap-float : retire le tableau wrapper de Quarto autour des flextables --- --- S'execute au post-render (apres la resolution des refs croisees et --- le rendu des floats). A ce stade, le FloatRefTarget de Quarto a ete --- converti en un Table Pandoc contenant : la caption (en tant que Para --- dans un Div de cellule) + le flextable (en tant que RawBlock openxml). --- On va detecter ces Tables wrapper a cellule unique et les remplace --- par leur contenu (caption + table), ne supprimant que l'enveloppe --- Pandoc tout en preservant tout ce qu'il y a a l'interieur. Sauf si --- deux tableaux qui est une limitation. --- --- Structure attendue au post-render : --- --- tbl-cap-location: top (defaut) tbl-cap-location: bottom --- --- Div.cell Div.cell --- CodeBlock CodeBlock --- Table (wrapper 1x1) Table (wrapper 1x1) --- Cell Cell --- Div.cell Div.cell --- Para <- caption RawBlock(openxml) <- flextable --- RawBlock(openxml) <- flextable Para <- caption --- --- L'ordre Para/RawBlock dans la cellule reflete `tbl-cap-location`. --- Le filtre preserve cet ordre lors de l'aplatissement (unwrap_content). --- --- Hypotheses / pre-requis : --- --- 1. Timing : doit etre declare avec `at: post-render` dans le YAML --- du document (pas dans _extension.yml). A ce stade les FloatRefTarget --- ont deja ete convertis en Table Pandoc par Quarto. --- --- 2. Format : ne s'active que pour la sortie docx (FORMAT:match("docx")). --- --- 3. Un seul flextable par wrapper : chaque chunk avec `tbl-cap` --- doit produire un seul Table wrapper contenant un seul RawBlock(.+)
%s*$", "%1"):gsub("%s+$", "") xref[id] = { text = html, target = t } end end end }) end -- Source 2 : construit depuis les noeuds FloatRefTarget de Quarto -- La table globale `crossref` fournit les prefixes de categorie -- (Figure, Table, ...) et custom_node_data les identifiants des floats. local cr = rawget(_G, "crossref") local cnd = quarto and quarto._quarto and quarto._quarto.ast and quarto._quarto.ast.custom_node_data if cr and cr.categories and cnd then -- Collecte les entrees FloatRefTarget triees par cle (ordre du document) local floats = {} for k, v in pairs(cnd) do if type(v) == "table" and v.t == "FloatRefTarget" and v.identifier then table.insert(floats, { key = k, id = v.identifier, ftype = v.type }) end end table.sort(floats, function(a, b) return a.key < b.key end) -- Compte par type de ref et attribue les numeros local counters = {} for _, f in ipairs(floats) do local rt = ref_type(f.id) if rt and not xref[f.id] then counters[rt] = (counters[rt] or 0) + 1 -- Cherche le prefixe de categorie (ex. "Figure", "Table") local cat = cr.categories.by_ref_type[rt] local prefix = cat and (cat.prefix or cat.name) or rt local label = prefix .. "\u{a0}" .. tostring(counters[rt]) xref[f.id] = { text = label, target = "#" .. f.id } end end end return nil -- ne modifie pas le document end -- Resout les elements Cite via la table des refs croisees ------------------- local function resolve_cites(blocks) local new_blocks = {} for _, block in ipairs(blocks) do local resolved = pandoc.walk_block(block, { Cite = function(el) local id = el.citations[1].id if xref[id] then return pandoc.Link( pandoc.read(xref[id].text, "html").blocks[1].content, xref[id].target ) end -- Repli : conserve le texte de la citation tel quel return el.content end }) table.insert(new_blocks, resolved) end return new_blocks end -- Rend les blocs resolus en chaine inline pour un format donne -------------- local function blocks_to_output(blocks, fmt) local resolved = resolve_cites(blocks) local out = pandoc.write(pandoc.Pandoc(resolved), fmt) -- supprime leenglobant (HTML) ou les retours a la ligne finaux if fmt == "html" then out = out:gsub("^%s*
%s*(.-)%s*
%s*$", "%1") end out = out:gsub("%s+$", "") return out end -- Passe 2a : traite les RawBlocks HTML (sortie knitr {=html}) --------------- local function process_html_raw(html) local modified = false -- spans data-qmd-base64 local work = html for full, encoded in work:gmatch( '(
Formatting can be layered on with a set of functions:
``` r
flextable(head(mtcars)) |>
highlight(i = ~ mpg < 22, j = "disp", color = "#ffe842") |>
bg(
j = c("hp", "drat", "wt"),
bg = scales::col_quantile(palette = c("wheat", "red"), domain = NULL)
) |>
add_footer_lines("The 'mtcars' dataset")
```
``` r
ggplot2::diamonds[, c("cut", "carat", "price", "clarity", "table")] |>
summarizor(by = c("cut")) |>
as_flextable(spread_first_col = TRUE)
```
## Installation
``` r
install.packages("flextable")
```
You can get the development version from GitHub:
``` r
devtools::install_github("davidgohel/flextable")
```
## Resources
- [User guide](https://ardata-fr.github.io/flextable-book/)
- [Reference
manual](https://davidgohel.github.io/flextable/reference/index.html)
- [Gallery of examples](https://ardata.fr/en/flextable-gallery/)
## Bug reports
When you file a [bug
report](https://github.com/davidgohel/flextable/issues), please spend
some time making it easy for us to reproduce. If you take the time to
make the bug report consistent, it will be easier to fix.
flextable/build/ 0000755 0001762 0000144 00000000000 15143405317 013322 5 ustar ligges users flextable/build/vignette.rds 0000644 0001762 0000144 00000000316 15143405317 015661 0 ustar ligges users b```b`aeb`b2 1# '/K-*L- MA-KWHI(ILIEk(AY- Cā I5/17MKjAj^
H vѴpxVaaq: joHf e2|s m MI,F(WJbI^ZP? flextable/man/ 0000755 0001762 0000144 00000000000 15143405317 012776 5 ustar ligges users flextable/man/use_df_printer.Rd 0000644 0001762 0000144 00000001060 15131745533 016276 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/df_printer.R
\name{use_df_printer}
\alias{use_df_printer}
\title{Set data.frame automatic printing as a flextable}
\usage{
use_df_printer()
}
\description{
Define \code{\link[=df_printer]{df_printer()}} as data.frame
print method in an R Markdown document.
In a setup run chunk:
\if{html}{\out{
See https://www.ardata.fr/en/flextable-gallery/2022-06-23-separate-headers/ for the example
shown
}}
}
\examples{
ft_1 <- flextable(head(iris))
ft_1 <- footnote(ft_1,
i = 1, j = 1:3,
value = as_paragraph(
c(
"This is footnote one",
"This is footnote two",
"This is footnote three"
)
),
ref_symbols = c("a", "b", "c"),
part = "header"
)
ft_1 <- valign(ft_1, valign = "bottom", part = "header")
ft_1 <- autofit(ft_1)
ft_2 <- flextable(head(iris))
ft_2 <- autofit(ft_2)
ft_2 <- footnote(ft_2,
i = 1, j = 1:2,
value = as_paragraph(
c(
"This is footnote one",
"This is footnote two"
)
),
ref_symbols = c("a", "b"),
part = "header", inline = TRUE
)
ft_2 <- footnote(ft_2,
i = 1, j = 3:4,
value = as_paragraph(
c(
"This is footnote three",
"This is footnote four"
)
),
ref_symbols = c("c", "d"),
part = "header", inline = TRUE
)
ft_2
ft_3 <- flextable(head(iris))
ft_3 <- autofit(ft_3)
ft_3 <- footnote(
x = ft_3, i = 1:3, j = 1:3,
ref_symbols = "a",
value = as_paragraph("This is footnote one")
)
ft_3
}
flextable/man/theme_vanilla.Rd 0000644 0001762 0000144 00000004507 15142312712 016076 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/themes.R
\name{theme_vanilla}
\alias{theme_vanilla}
\title{Apply vanilla theme}
\usage{
theme_vanilla(x)
}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
}
\description{
Apply theme vanilla to a flextable:
The external horizontal lines of the different parts of
the table (body, header, footer) are black 2 points thick,
the external horizontal lines of the different parts
are black 0.5 point thick. Header text is bold,
text columns are left aligned, other columns are
right aligned.
}
\section{behavior}{
Theme functions are not like 'ggplot2' themes. They are applied to the existing
table \strong{immediately}. If you add a row in the footer, the new row is not formatted
with the theme. The theme function applies the theme only to existing elements
when the function is called.
That is why theme functions should be applied after all elements of the table
have been added (mainly additionnal header or footer rows).
If you want to automatically apply a theme function to each flextable,
you can use the \code{theme_fun} argument of \code{\link[=set_flextable_defaults]{set_flextable_defaults()}}; be
aware that this theme function is applied as the last instruction when
calling \code{flextable()} - so if you add headers or footers to the array,
they will not be formatted with the theme.
You can also use the \code{post_process_html} argument
of \code{\link[=set_flextable_defaults]{set_flextable_defaults()}} (or \code{post_process_pdf},
\code{post_process_docx}, \code{post_process_pptx}) to specify a theme
to be applied systematically before the \code{flextable()} is printed;
in this case, don't forget to take care that the theme doesn't
override any formatting done before the print statement.
}
\examples{
ft <- flextable(head(airquality))
ft <- theme_vanilla(ft)
ft
}
\seealso{
Other functions related to themes:
\code{\link{get_flextable_defaults}()},
\code{\link{set_flextable_defaults}()},
\code{\link{theme_alafoli}()},
\code{\link{theme_apa}()},
\code{\link{theme_booktabs}()},
\code{\link{theme_borderless}()},
\code{\link{theme_box}()},
\code{\link{theme_tron}()},
\code{\link{theme_tron_legacy}()},
\code{\link{theme_vader}()},
\code{\link{theme_zebra}()}
}
\concept{functions related to themes}
flextable/man/tab_settings.Rd 0000644 0001762 0000144 00000004032 15142453603 015752 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/styles.R
\name{tab_settings}
\alias{tab_settings}
\title{Set tabulation marks configuration}
\usage{
tab_settings(x, i = NULL, j = NULL, value = TRUE, part = "body")
}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
\item{i}{row selector, see section \emph{Row selection with the \code{i} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{j}{column selector, see section \emph{Column selection with the \code{j} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{value}{an object generated by \code{\link[officer:fp_tabs]{officer::fp_tabs()}}.}
\item{part}{part selector, see section \emph{Part selection with the \code{part}
parameter} in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.
Value 'all' can be used.}
}
\description{
Define tabulation marks configuration.
Specifying the positions and types of tabulation marks in table
paragraphs helps organize content, especially in clinical tables,
by aligning numbers properly.
}
\examples{
library(officer)
library(flextable)
z <- data.frame(
Statistic = c("Median (Q1 ; Q3)", "Min ; Max"),
Value = c(
"\t999.99\t(99.9 ; 99.9)",
"\t9.99\t(9999.9 ; 99.9)"
)
)
ts <- fp_tabs(
fp_tab(pos = 0.4, style = "decimal"),
fp_tab(pos = 1.4, style = "decimal")
)
zz <- flextable(z)
zz <- tab_settings(zz, j = 2, value = ts)
zz <- width(zz, width = c(1.5, 2))
save_as_docx(zz, path = tempfile(fileext = ".docx"))
}
\seealso{
Other sugar functions for table style:
\code{\link{align}()},
\code{\link{bg}()},
\code{\link{bold}()},
\code{\link{color}()},
\code{\link{empty_blanks}()},
\code{\link{font}()},
\code{\link{fontsize}()},
\code{\link{highlight}()},
\code{\link{italic}()},
\code{\link{keep_with_next}()},
\code{\link{line_spacing}()},
\code{\link{padding}()},
\code{\link{rotate}()},
\code{\link{style}()},
\code{\link{valign}()}
}
\concept{sugar functions for table style}
flextable/man/as_flextable.htest.Rd 0000644 0001762 0000144 00000002434 15137666130 017054 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/as_flextable.R
\name{as_flextable.htest}
\alias{as_flextable.htest}
\title{Transform a 'htest' object into a flextable}
\usage{
\method{as_flextable}{htest}(x, ...)
}
\arguments{
\item{x}{htest object}
\item{...}{unused argument}
}
\description{
produce a flextable describing an
object oof class \code{htest}.
}
\examples{
if (require("stats")) {
M <- as.table(rbind(c(762, 327, 468), c(484, 239, 477)))
dimnames(M) <- list(
gender = c("F", "M"),
party = c("Democrat", "Independent", "Republican")
)
ft_1 <- as_flextable(chisq.test(M))
ft_1
}
}
\seealso{
Other as_flextable methods:
\code{\link{as_flextable}()},
\code{\link{as_flextable.compact_summary}()},
\code{\link{as_flextable.data.frame}()},
\code{\link{as_flextable.gam}()},
\code{\link{as_flextable.glm}()},
\code{\link{as_flextable.grouped_data}()},
\code{\link{as_flextable.kmeans}()},
\code{\link{as_flextable.lm}()},
\code{\link{as_flextable.merMod}()},
\code{\link{as_flextable.pam}()},
\code{\link{as_flextable.summarizor}()},
\code{\link{as_flextable.table}()},
\code{\link{as_flextable.tabular}()},
\code{\link{as_flextable.tabulator}()},
\code{\link{as_flextable.xtable}()},
\code{\link{compact_summary}()}
}
\concept{as_flextable methods}
flextable/man/plot.flextableGrob.Rd 0000644 0001762 0000144 00000000556 15131745533 017034 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/grid_grobs.R
\name{plot.flextableGrob}
\alias{plot.flextableGrob}
\title{plot a flextable grob}
\usage{
\method{plot}{flextableGrob}(x, ...)
}
\arguments{
\item{x}{a flextableGrob object}
\item{...}{additional arguments passed to other functions}
}
\description{
plot a flextable grob
}
flextable/man/add_header.Rd 0000644 0001762 0000144 00000005275 15142341701 015331 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/augment_rows.R
\name{add_header}
\alias{add_header}
\title{Add header rows with one value per column}
\usage{
add_header(x, top = TRUE, ..., values = NULL)
}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
\item{top}{should the rows be inserted at the top or the bottom.}
\item{...}{named arguments (names are data colnames) of values
to add. It is important to insert data of the same type as the
original data, otherwise it will be transformed (probably
into strings if you add a \code{character} where a \code{double} is expected).
This makes possible to still format cell contents with the \verb{colformat_*}
functions, for example \code{\link[=colformat_num]{colformat_num()}}.}
\item{values}{a list of name-value pairs of labels or values,
names should be existing col_key values. This argument can be used
instead of \code{...} for programming purpose (If \code{values} is
supplied argument \code{...} is ignored).}
}
\description{
Add new rows to the header where each value maps to a named column.
Unlike \code{\link[=add_header_row]{add_header_row()}} where labels can span multiple columns,
here each value fills exactly one column.
If some columns are not provided, they will be replaced by
\code{NA} and displayed as empty.
\if{html}{\out{
}}
}
\note{
when repeating values, they can be merged together with
function \code{\link[=merge_h]{merge_h()}} and \code{\link[=merge_v]{merge_v()}}.
}
\examples{
library(flextable)
fun <- function(x) {
paste0(
c("min: ", "max: "),
formatC(range(x))
)
}
new_row <- list(
Sepal.Length = fun(iris$Sepal.Length),
Sepal.Width = fun(iris$Sepal.Width),
Petal.Width = fun(iris$Petal.Width),
Petal.Length = fun(iris$Petal.Length)
)
ft_1 <- flextable(data = head(iris))
ft_1 <- add_header(ft_1, values = new_row, top = FALSE)
ft_1 <- append_chunks(ft_1, part = "header", i = 2, )
ft_1 <- theme_booktabs(ft_1, bold_header = TRUE)
ft_1 <- align(ft_1, align = "center", part = "all")
ft_1
}
\seealso{
Other functions for row and column operations in a flextable:
\code{\link{add_body}()},
\code{\link{add_body_row}()},
\code{\link{add_footer}()},
\code{\link{add_footer_lines}()},
\code{\link{add_footer_row}()},
\code{\link{add_header_lines}()},
\code{\link{add_header_row}()},
\code{\link{delete_columns}()},
\code{\link{delete_part}()},
\code{\link{separate_header}()},
\code{\link{set_header_footer_df}},
\code{\link{set_header_labels}()}
}
\concept{functions for row and column operations in a flextable}
flextable/man/fmt_signif_after_zeros.Rd 0000644 0001762 0000144 00000002103 15131745533 020015 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/summarizor.R
\name{fmt_signif_after_zeros}
\alias{fmt_signif_after_zeros}
\title{Format with significant figures after zeros}
\usage{
fmt_signif_after_zeros(x, digits = 3)
}
\arguments{
\item{x}{numeric values}
\item{digits}{number of digits displayed after the leading zeros}
}
\description{
Rounds significant figures after zeros in numeric vectors.
The number of digits displayed after the leading zeros is
customizable using the \code{digits} parameter.
}
\examples{
x <- data.frame(
x = c(0.00000004567, 2.000003456, 3, pi)
)
ft_1 <- flextable(x)
ft_1 <- align(x = ft_1, j = 1, align = "left")
mk_par(ft_1, value = as_paragraph(
fmt_signif_after_zeros(x)))
}
\seealso{
\code{\link[=tabulator]{tabulator()}}, \code{\link[=mk_par]{mk_par()}}
Other text formatter functions:
\code{\link{fmt_2stats}()},
\code{\link{fmt_avg_dev}()},
\code{\link{fmt_dbl}()},
\code{\link{fmt_header_n}()},
\code{\link{fmt_int}()},
\code{\link{fmt_n_percent}()},
\code{\link{fmt_pct}()}
}
\concept{text formatter functions}
flextable/man/as_flextable.tabular.Rd 0000644 0001762 0000144 00000010132 15137666130 017351 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/as_flextable.tabular.R
\name{as_flextable.tabular}
\alias{as_flextable.tabular}
\title{Transform a 'tables::tabular' object into a flextable}
\usage{
\method{as_flextable}{tabular}(
x,
spread_first_col = FALSE,
fp_p = fp_par(text.align = "center", padding.top = 4),
row_title = as_paragraph(as_chunk(.row_title)),
add_tab = FALSE,
...
)
}
\arguments{
\item{x}{object produced by \code{\link[tables:tabular]{tables::tabular()}}.}
\item{spread_first_col}{if TRUE, first row is spread as a new line separator
instead of being a column. This helps to reduce the width and allows for
clear divisions.}
\item{fp_p}{paragraph formatting properties associated with row titles,
see \code{\link[officer:fp_par]{officer::fp_par()}}.}
\item{row_title}{a call to \code{\link[=as_paragraph]{as_paragraph()}} - it
will be applied to the row titles if any
when \code{spread_first_col=TRUE}.}
\item{add_tab}{adds a tab in front of "list_data"
label lines (located in column \code{.type}).}
\item{...}{unused argument}
}
\description{
Produce a flextable from a 'tabular' object
produced with function \code{\link[tables:tabular]{tables::tabular()}}.
When \code{as_flextable.tabular=TRUE}, the first column is
used as row separator acting as a row title. It can
be formated with arguments \code{fp_p} (the formatting
properties of the paragraph) and \code{row_title} that
specifies the content and eventually formattings
of the content.
Two hidden columns can be used for conditional formatting
after the creation of the flextable (use only when
\code{spread_first_col=TRUE}):
\itemize{
\item The column \code{.row_title} that contains the title label
\item The column \code{.type} that can contain the following values:
\itemize{
\item "one_row": Indicates that there is only one row for this group. In this case, the row is not expanded with a title above.
\item "list_title": Indicates a row that serves as a title for the data that are displayed after it.
\item "list_data": Indicates rows that follow a title and contain data to be displayed.
}
}
The result is paginated (see \code{\link[=paginate]{paginate()}}).
}
\examples{
if (require("tables")) {
set.seed(42)
genders <- c("Male", "Female")
status <- c("low", "medium", "high")
Sex <- factor(sample(genders, 100, rep = TRUE))
Status <- factor(sample(status, 100, rep = TRUE))
z <- rnorm(100) + 5
fmt <- function(x) {
s <- format(x, digits = 2)
even <- ((1:length(s)) \%\% 2) == 0
s[even] <- sprintf("(\%s)", s[even])
s
}
tab <- tabular(
Justify(c) * Heading() * z *
Sex * Heading(Statistic) *
Format(fmt()) *
(mean + sd) ~ Status
)
as_flextable(tab)
}
if (require("tables")) {
tab <- tabular(
(Species + 1) ~ (n = 1) + Format(digits = 2) *
(Sepal.Length + Sepal.Width) * (mean + sd),
data = iris
)
as_flextable(tab)
}
if (require("tables")) {
x <- tabular((Factor(gear, "Gears") + 1)
* ((n = 1) + Percent()
+ (RowPct = Percent("row"))
+ (ColPct = Percent("col")))
~ (Factor(carb, "Carburetors") + 1)
* Format(digits = 1), data = mtcars)
ft <- as_flextable(
x,
spread_first_col = TRUE,
row_title = as_paragraph(
colorize("Gears: ", color = "#666666"),
colorize(as_b(.row_title), color = "red")
)
)
ft
}
if (require("tables")) {
tab <- tabular(
(mean + mean) * (Sepal.Length + Sepal.Width) ~ 1,
data = iris
)
as_flextable(tab)
}
}
\seealso{
Other as_flextable methods:
\code{\link{as_flextable}()},
\code{\link{as_flextable.compact_summary}()},
\code{\link{as_flextable.data.frame}()},
\code{\link{as_flextable.gam}()},
\code{\link{as_flextable.glm}()},
\code{\link{as_flextable.grouped_data}()},
\code{\link{as_flextable.htest}()},
\code{\link{as_flextable.kmeans}()},
\code{\link{as_flextable.lm}()},
\code{\link{as_flextable.merMod}()},
\code{\link{as_flextable.pam}()},
\code{\link{as_flextable.summarizor}()},
\code{\link{as_flextable.table}()},
\code{\link{as_flextable.tabulator}()},
\code{\link{as_flextable.xtable}()},
\code{\link{compact_summary}()}
}
\concept{as_flextable methods}
flextable/man/shift_table.Rd 0000644 0001762 0000144 00000012315 15131745533 015557 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/clintables.R
\name{shift_table}
\alias{shift_table}
\title{Create a shift table}
\usage{
shift_table(
x,
cn_visit = "VISIT",
cn_visit_num = "VISITNUM",
cn_grade = "LBNRIND",
cn_usubjid = "USUBJID",
cn_lab_cat = NA_character_,
cn_is_baseline = "LBBLFL",
baseline_identifier = "Y",
cn_treatment = NA_character_,
grade_levels = c("LOW", "NORMAL", "HIGH"),
grade_labels = c("Low", "Normal", "High")
)
}
\arguments{
\item{x}{Laboratory Tests Results data frame.}
\item{cn_visit}{column name containing visit names, default to "VISIT".}
\item{cn_visit_num}{column name containing visit numbers, default to "VISITNUM".}
\item{cn_grade}{column name containing reference range indicators, default to "LBNRIND".}
\item{cn_usubjid}{column name containing unique subject inditifiers, default to "USUBJID".}
\item{cn_lab_cat}{column name containing lab tests or examination names, default to "LBTEST".}
\item{cn_is_baseline}{column name containing baseline flags, default to "LBBLFL".}
\item{baseline_identifier}{baseline flag value to use for baseline
identification. Its default is "Y".}
\item{cn_treatment}{column name containing treatment names, default to \code{NA}.}
\item{grade_levels}{levels to use for reference range indicators}
\item{grade_labels}{labels to use for reference range indicators}
}
\value{
the shift table as a data.frame. Additionnal elements are provided
in attributes:
\itemize{
\item "VISIT_N": count of unique subject id per visits, labs and eventually
treatments. This element is supposed to be used as value for argument
\code{hidden_data} of function \code{tabulator()}.
\item "FUN_VISIT": a utility function to easily turn \emph{visit} column as a factor
column. It should be applied after the shift table creation.
\item "FUN_GRADE": a utility function to easily turn \emph{grade} column as a factor
column. It adds "MISSING/Missing" and "SUM/Sum" at the end of the set of values specified
in arguments \code{grade_levels} and \code{grade_labels}. It should be applied after the shift
table creation.
}
}
\description{
Create a shift table ready to be used with \code{tabulator()}.
The function is transforming a dataset representing some
'Laboratory Tests Results' structured as \emph{CDISC clinical trial
data sets} format to a dataset representing the shift table.
Shift tables are tables used in clinical trial analysis.
They show the progression of change from the baseline, with the progression
often being along time; the number of subjects is displayed in different
range (e.g. low, normal, or high) at baseline and at selected time points
or intervals.
}
\examples{
\dontshow{
data.table::setDTthreads(1)
}
library(data.table)
library(flextable)
# data simulation ----
USUBJID <- sprintf("01-ABC-\%04.0f", 1:200)
VISITS <- c("SCREENING 1", "WEEK 2", "MONTH 3")
LBTEST <- c("Albumin", "Sodium")
VISITNUM <- seq_along(VISITS)
LBBLFL <- rep(NA_character_, length(VISITNUM))
LBBLFL[1] <- "Y"
VISIT <- data.frame(
VISIT = VISITS, VISITNUM = VISITNUM,
LBBLFL = LBBLFL, stringsAsFactors = FALSE
)
labdata <- expand.grid(
USUBJID = USUBJID, LBTEST = LBTEST,
VISITNUM = VISITNUM,
stringsAsFactors = FALSE
)
setDT(labdata)
labdata <- merge(labdata, VISIT, by = "VISITNUM")
subject_elts <- unique(labdata[, .SD, .SDcols = "USUBJID"])
subject_elts <- unique(subject_elts)
subject_elts[, c("TREAT") := list(
sample(x = c("Treatment", "Placebo"), size = .N, replace = TRUE)
)]
subject_elts[, c("TREAT") := list(
factor(.SD$TREAT, levels = c("Treatment", "Placebo"))
)]
setDF(subject_elts)
labdata <- merge(labdata, subject_elts,
by = "USUBJID", all.x = TRUE, all.y = FALSE
)
labdata[, c("LBNRIND") := list(
sample(
x = c("LOW", "NORMAL", "HIGH"), size = .N,
replace = TRUE, prob = c(.03, .9, .07)
)
)]
setDF(labdata)
# shift table calculation ----
SHIFT_TABLE <- shift_table(
x = labdata, cn_visit = "VISIT",
cn_grade = "LBNRIND",
cn_usubjid = "USUBJID",
cn_lab_cat = "LBTEST",
cn_treatment = "TREAT",
cn_is_baseline = "LBBLFL",
baseline_identifier = "Y",
grade_levels = c("LOW", "NORMAL", "HIGH")
)
# get attrs for post treatment ----
SHIFT_TABLE_VISIT <- attr(SHIFT_TABLE, "VISIT_N")
visit_as_factor <- attr(SHIFT_TABLE, "FUN_VISIT")
range_as_factor <- attr(SHIFT_TABLE, "FUN_GRADE")
# post treatments ----
SHIFT_TABLE$VISIT <- visit_as_factor(SHIFT_TABLE$VISIT)
SHIFT_TABLE$BASELINE <- range_as_factor(SHIFT_TABLE$BASELINE)
SHIFT_TABLE$LBNRIND <- range_as_factor(SHIFT_TABLE$LBNRIND)
SHIFT_TABLE_VISIT$VISIT <- visit_as_factor(SHIFT_TABLE_VISIT$VISIT)
# tabulator ----
my_format <- function(z) {
formatC(z * 100,
digits = 1, format = "f",
flag = "0", width = 4
)
}
tab <- tabulator(
x = SHIFT_TABLE,
hidden_data = SHIFT_TABLE_VISIT,
row_compose = list(
VISIT = as_paragraph(VISIT, "\n(N=", N_VISIT, ")")
),
rows = c("LBTEST", "VISIT", "BASELINE"),
columns = c("TREAT", "LBNRIND"),
`n` = as_paragraph(N),
`\%` = as_paragraph(as_chunk(PCT, formatter = my_format))
)
# as_flextable ----
ft_1 <- as_flextable(
x = tab, separate_with = "VISIT",
label_rows = c(
LBTEST = "Lab Test", VISIT = "Visit",
BASELINE = "Reference Range Indicator"
)
)
ft_1
}
\concept{tools for clinical reporting}
flextable/man/fmt_header_n.Rd 0000644 0001762 0000144 00000001743 15142341701 015700 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/summarizor.R
\name{fmt_header_n}
\alias{fmt_header_n}
\title{Format count as '(N=XX)' for column headers}
\usage{
fmt_header_n(n, newline = TRUE)
}
\arguments{
\item{n}{count values}
\item{newline}{indicates to prefix the text with a new line
(sof return).}
}
\description{
Format counts as \verb{\\n(N=XX)} for appending
sample sizes to column titles.
}
\examples{
library(flextable)
df <- data.frame(zz = 1)
ft_1 <- flextable(df)
ft_1 <- append_chunks(
x = ft_1, j = 1, part = "header",
value = as_chunk(fmt_header_n(200))
)
ft_1 <- autofit(ft_1)
ft_1
}
\seealso{
\code{\link[=tabulator]{tabulator()}}, \code{\link[=mk_par]{mk_par()}}
Other text formatter functions:
\code{\link{fmt_2stats}()},
\code{\link{fmt_avg_dev}()},
\code{\link{fmt_dbl}()},
\code{\link{fmt_int}()},
\code{\link{fmt_n_percent}()},
\code{\link{fmt_pct}()},
\code{\link{fmt_signif_after_zeros}()}
}
\concept{text formatter functions}
flextable/man/flextable_dim.Rd 0000644 0001762 0000144 00000002117 15142341701 016060 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/flextable_sizes.R
\name{flextable_dim}
\alias{flextable_dim}
\title{Get overall width and height of a flextable}
\usage{
flextable_dim(x, unit = "in")
}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
\item{unit}{unit for returned values, one of "in", "cm", "mm".}
}
\description{
Returns the width, height and
aspect ratio of a flextable in a named list.
The aspect ratio is the ratio corresponding to \code{height/width}.
Names of the list are \code{widths}, \code{heights} and \code{aspect_ratio}.
}
\examples{
ftab <- flextable(head(iris))
flextable_dim(ftab)
ftab <- autofit(ftab)
flextable_dim(ftab)
}
\seealso{
Other functions for flextable size management:
\code{\link{autofit}()},
\code{\link{dim.flextable}()},
\code{\link{dim_pretty}()},
\code{\link{fit_to_width}()},
\code{\link{height}()},
\code{\link{hrule}()},
\code{\link{ncol_keys}()},
\code{\link{nrow_part}()},
\code{\link{width}()}
}
\concept{functions for flextable size management}
flextable/man/add_footer_row.Rd 0000644 0001762 0000144 00000005606 15142341701 016264 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/augment_rows.R
\name{add_footer_row}
\alias{add_footer_row}
\title{Add a footer row with spanning labels}
\usage{
add_footer_row(x, top = TRUE, values = character(0), colwidths = integer(0))
}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
\item{top}{should the row be inserted at the top or the bottom.}
\item{values}{values to add. It can be a \code{list}, a \code{character()} vector
or a call to \code{\link[=as_paragraph]{as_paragraph()}}.
If it is a list, it can be a named list with the names of the columns of the
original data.frame or the \code{colkeys}; this is the recommended method because
it allows to keep the original data types and therefore allows to perform
conditional formatting. If a character, columns of the original data.frame
stored in the flextable object are changed to \code{character()}; this is often
not an issue with footer and header but can be inconvenient if adding
rows into body as it will change data types to character and prevent
efficient conditional formatting.}
\item{colwidths}{the number of columns to merge in the row for each label}
}
\description{
Add a single row to the footer where labels can span
multiple columns (merged cells) via the \code{colwidths} argument.
Labels are associated with a number of columns
to merge that default to one if not specified.
In this case, you have to make sure that the
number of labels is equal to the number of columns displayed.
The function can add only one single row by call.
Labels can be formatted with \code{\link[=as_paragraph]{as_paragraph()}}.
}
\examples{
library(flextable)
ft01 <- fp_text_default(color = "red")
ft02 <- fp_text_default(color = "orange")
pars <- as_paragraph(
as_chunk(c("(1)", "(2)"), props = ft02), " ",
as_chunk(
c(
"My tailor is rich",
"My baker is rich"
),
props = ft01
)
)
ft_1 <- flextable(head(mtcars))
ft_1 <- add_footer_row(ft_1,
values = pars,
colwidths = c(5, 6), top = FALSE
)
ft_1 <- add_footer_row(ft_1,
values = pars,
colwidths = c(3, 8), top = TRUE
)
ft_1
ft_2 <- flextable(head(airquality))
ft_2 <- add_footer_row(ft_2,
values = c("Measure", "Time"),
colwidths = c(4, 2), top = TRUE
)
ft_2 <- theme_box(ft_2)
ft_2
}
\seealso{
\code{\link[=flextable]{flextable()}}, \code{\link[=set_caption]{set_caption()}}
Other functions for row and column operations in a flextable:
\code{\link{add_body}()},
\code{\link{add_body_row}()},
\code{\link{add_footer}()},
\code{\link{add_footer_lines}()},
\code{\link{add_header}()},
\code{\link{add_header_lines}()},
\code{\link{add_header_row}()},
\code{\link{delete_columns}()},
\code{\link{delete_part}()},
\code{\link{separate_header}()},
\code{\link{set_header_footer_df}},
\code{\link{set_header_labels}()}
}
\concept{functions for row and column operations in a flextable}
flextable/man/as_flextable.tabulator.Rd 0000644 0001762 0000144 00000007177 15137666130 017733 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/as_flextable_tabulator.R
\name{as_flextable.tabulator}
\alias{as_flextable.tabulator}
\title{Transform a 'tabulator' object into a flextable}
\usage{
\method{as_flextable}{tabulator}(
x,
separate_with = character(0),
big_border = fp_border_default(width = 1.5),
small_border = fp_border_default(width = 0.75),
rows_alignment = "left",
columns_alignment = "center",
label_rows = x$rows,
spread_first_col = FALSE,
expand_single = FALSE,
sep_w = 0.05,
unit = "in",
...
)
}
\arguments{
\item{x}{result from \code{\link[=tabulator]{tabulator()}}}
\item{separate_with}{columns used to sepatate the groups
with an horizontal line.}
\item{big_border, small_border}{big and small border properties defined
by a call to \code{\link[=fp_border_default]{fp_border_default()}} or \code{\link[officer:fp_border]{officer::fp_border()}}.}
\item{rows_alignment, columns_alignment}{alignments to apply to
columns corresponding to \code{rows} and \code{columns}; see arguments
\code{rows} and \code{columns} in \code{\link[=tabulator]{tabulator()}}.}
\item{label_rows}{labels to use for the first column names, i.e.
the \emph{row} column names. It must be a named vector, the values will
be matched based on the names.}
\item{spread_first_col}{if TRUE, first row is spread as a new line separator
instead of being a column. This helps to reduce the width and allows for
clear divisions.}
\item{expand_single}{if FALSE (the default), groups with only one
row will not be expanded with a title row. If TRUE,
single row groups and multi-row groups are all
restructured.}
\item{sep_w}{blank column separators'width to be used. If 0,
blank column separators will not be used.}
\item{unit}{unit of argument \code{sep_w}, one of "in", "cm", "mm".}
\item{...}{unused argument}
}
\description{
\code{\link[=tabulator]{tabulator()}} object can be transformed as a flextable
with method \code{\link[=as_flextable]{as_flextable()}}.
}
\examples{
\dontrun{
library(flextable)
set_flextable_defaults(digits = 2, border.color = "gray")
if (require("stats")) {
dat <- aggregate(breaks ~ wool + tension,
data = warpbreaks, mean
)
cft_1 <- tabulator(
x = dat,
rows = "wool",
columns = "tension",
`mean` = as_paragraph(as_chunk(breaks)),
`(N)` = as_paragraph(
as_chunk(length(breaks))
)
)
ft_1 <- as_flextable(cft_1, sep_w = .1)
ft_1
}
if (require("stats")) {
set_flextable_defaults(
padding = 1, font.size = 9,
border.color = "orange"
)
ft_2 <- as_flextable(cft_1, sep_w = 0)
ft_2
}
if (require("stats")) {
set_flextable_defaults(
padding = 6, font.size = 11,
border.color = "white",
font.color = "white",
background.color = "#333333"
)
ft_3 <- as_flextable(
x = cft_1, sep_w = 0,
rows_alignment = "center",
columns_alignment = "right"
)
ft_3
}
init_flextable_defaults()
}
}
\seealso{
\code{\link[=summarizor]{summarizor()}}, \code{\link[=as_grouped_data]{as_grouped_data()}}
Other as_flextable methods:
\code{\link{as_flextable}()},
\code{\link{as_flextable.compact_summary}()},
\code{\link{as_flextable.data.frame}()},
\code{\link{as_flextable.gam}()},
\code{\link{as_flextable.glm}()},
\code{\link{as_flextable.grouped_data}()},
\code{\link{as_flextable.htest}()},
\code{\link{as_flextable.kmeans}()},
\code{\link{as_flextable.lm}()},
\code{\link{as_flextable.merMod}()},
\code{\link{as_flextable.pam}()},
\code{\link{as_flextable.summarizor}()},
\code{\link{as_flextable.table}()},
\code{\link{as_flextable.tabular}()},
\code{\link{as_flextable.xtable}()},
\code{\link{compact_summary}()}
}
\concept{as_flextable methods}
flextable/man/as_flextable.data.frame.Rd 0000644 0001762 0000144 00000004047 15137666130 017731 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/df_printer.R
\name{as_flextable.data.frame}
\alias{as_flextable.data.frame}
\title{Transform and summarise a 'data.frame' into a flextable
Simple summary of a data.frame as a flextable}
\usage{
\method{as_flextable}{data.frame}(
x,
max_row = 10,
split_colnames = FALSE,
short_strings = FALSE,
short_size = 35,
short_suffix = "...",
do_autofit = TRUE,
show_coltype = TRUE,
color_coltype = "#999999",
...
)
}
\arguments{
\item{x}{a data.frame}
\item{max_row}{The number of rows to print. Default to 10.}
\item{split_colnames}{Should the column names be split
(with non alpha-numeric characters). Default to FALSE.}
\item{short_strings}{Should the character column be shorten.
Default to FALSE.}
\item{short_size}{Maximum length of character column if
\code{short_strings} is TRUE. Default to 35.}
\item{short_suffix}{Suffix to add when character values are shorten.
Default to "...".}
\item{do_autofit}{Use \code{\link[=autofit]{autofit()}} before rendering the table.
Default to TRUE.}
\item{show_coltype}{Show column types.
Default to TRUE.}
\item{color_coltype}{Color to use for column types.
Default to "#999999".}
\item{...}{unused arguments}
}
\description{
It displays the first rows and shows the column types.
If there is only one row, a simplified vertical table is produced.
}
\examples{
as_flextable(mtcars)
}
\seealso{
Other as_flextable methods:
\code{\link{as_flextable}()},
\code{\link{as_flextable.compact_summary}()},
\code{\link{as_flextable.gam}()},
\code{\link{as_flextable.glm}()},
\code{\link{as_flextable.grouped_data}()},
\code{\link{as_flextable.htest}()},
\code{\link{as_flextable.kmeans}()},
\code{\link{as_flextable.lm}()},
\code{\link{as_flextable.merMod}()},
\code{\link{as_flextable.pam}()},
\code{\link{as_flextable.summarizor}()},
\code{\link{as_flextable.table}()},
\code{\link{as_flextable.tabular}()},
\code{\link{as_flextable.tabulator}()},
\code{\link{as_flextable.xtable}()},
\code{\link{compact_summary}()}
}
\concept{as_flextable methods}
flextable/man/colformat_double.Rd 0000644 0001762 0000144 00000003310 15142453603 016602 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/formatters.R
\name{colformat_double}
\alias{colformat_double}
\title{Format double cells}
\usage{
colformat_double(
x,
i = NULL,
j = NULL,
big.mark = get_flextable_defaults()$big.mark,
decimal.mark = get_flextable_defaults()$decimal.mark,
digits = get_flextable_defaults()$digits,
na_str = get_flextable_defaults()$na_str,
nan_str = get_flextable_defaults()$nan_str,
prefix = "",
suffix = ""
)
}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
\item{i}{row selector, see section \emph{Row selection with the \code{i} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{j}{column selector, see section \emph{Column selection with the \code{j} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{big.mark, digits, decimal.mark}{see \code{\link[=formatC]{formatC()}}}
\item{na_str, nan_str}{string to be used for NA and NaN values}
\item{prefix, suffix}{string to be used as prefix or suffix}
}
\description{
Format numeric cells in a flextable using
\code{\link[=formatC]{formatC()}} with explicit control over digits and
decimal mark.
}
\examples{
dat <- mtcars
ft <- flextable(head(dat))
ft <- colformat_double(
x = ft,
big.mark = ",", digits = 2, na_str = "N/A"
)
autofit(ft)
}
\seealso{
Other cells formatters:
\code{\link{colformat_char}()},
\code{\link{colformat_date}()},
\code{\link{colformat_datetime}()},
\code{\link{colformat_image}()},
\code{\link{colformat_int}()},
\code{\link{colformat_lgl}()},
\code{\link{colformat_num}()},
\code{\link{set_formatter}()}
}
\concept{cells formatters}
flextable/man/args_x_j_part.Rd 0000644 0001762 0000144 00000001313 15142453603 016105 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/doc-selectors.R
\name{args_x_j_part}
\alias{args_x_j_part}
\title{internal utils for roxygen tags reuse}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
\item{j}{column selector, see section \emph{Column selection with the \code{j} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{part}{part selector, see section \emph{Part selection with the \code{part}
parameter} in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.
Value 'all' can be used.}
}
\description{
internal utils for roxygen tags reuse
}
\keyword{internal}
flextable/man/tabulator.Rd 0000644 0001762 0000144 00000010457 15142341701 015264 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/as_flextable_tabulator.R
\name{tabulator}
\alias{tabulator}
\alias{summary.tabulator}
\title{Create pivot-style summary tables}
\usage{
tabulator(
x,
rows,
columns,
datasup_first = NULL,
datasup_last = NULL,
hidden_data = NULL,
row_compose = list(),
...
)
\method{summary}{tabulator}(object, ...)
}
\arguments{
\item{x}{an aggregated data.frame}
\item{rows}{column names to use in rows dimensions}
\item{columns}{column names to use in columns dimensions}
\item{datasup_first}{additional data that will be merged with
table and placed after the columns presenting
the row dimensions.}
\item{datasup_last}{additional data that will be merged with
table and placed at the end of the table.}
\item{hidden_data}{additional data that will be merged with
table, the columns are not presented but can be used
with \code{\link[=compose]{compose()}} or \code{\link[=mk_par]{mk_par()}} function.}
\item{row_compose}{a list of call to \code{\link[=as_paragraph]{as_paragraph()}} - these
calls will be applied to the row dimensions (the name is
used to target the displayed column).}
\item{...}{named arguments calling function \code{\link[=as_paragraph]{as_paragraph()}}.
The names are used as labels and the values are evaluated
when the flextable is created.}
\item{object}{an object returned by function
\code{tabulator()}.}
}
\value{
an object of class \code{tabulator}.
}
\description{
It tabulates a data.frame representing an aggregation
which is then transformed as a flextable with
\link[=as_flextable.tabulator]{as_flextable}. The function
allows to define any display with the syntax of flextable in
a table whose layout is showing dimensions of the aggregation
across rows and columns.
\if{html}{\out{
}}
}
\section{Methods (by generic)}{
\itemize{
\item \code{summary(tabulator)}: call \code{summary()} to get
a data.frame describing mappings between variables
and their names in the flextable. This data.frame contains
a column named \code{col_keys} where are stored the names that
can be used for further selections.
}}
\note{
This is very first version of the function; be aware it
can evolve or change.
}
\examples{
\dontrun{
set_flextable_defaults(digits = 2, border.color = "gray")
library(data.table)
# example 1 ----
if (require("stats")) {
dat <- aggregate(breaks ~ wool + tension,
data = warpbreaks, mean
)
cft_1 <- tabulator(
x = dat, rows = "wool",
columns = "tension",
`mean` = as_paragraph(as_chunk(breaks)),
`(N)` = as_paragraph(as_chunk(length(breaks), formatter = fmt_int))
)
ft_1 <- as_flextable(cft_1)
ft_1
}
# example 2 ----
if (require("ggplot2")) {
multi_fun <- function(x) {
list(mean = mean(x), sd = sd(x))
}
dat <- as.data.table(ggplot2::diamonds)
dat <- dat[cut \%in\% c("Fair", "Good", "Very Good")]
dat <- dat[, unlist(lapply(.SD, multi_fun),
recursive = FALSE
),
.SDcols = c("z", "y"),
by = c("cut", "color")
]
tab_2 <- tabulator(
x = dat, rows = "color",
columns = "cut",
`z stats` = as_paragraph(as_chunk(fmt_avg_dev(z.mean, z.sd, digit2 = 2))),
`y stats` = as_paragraph(as_chunk(fmt_avg_dev(y.mean, y.sd, digit2 = 2)))
)
ft_2 <- as_flextable(tab_2)
ft_2 <- autofit(x = ft_2, add_w = .05)
ft_2
}
# example 3 ----
# data.table version
dat <- melt(as.data.table(iris),
id.vars = "Species",
variable.name = "name", value.name = "value"
)
dat <- dat[,
list(
avg = mean(value, na.rm = TRUE),
sd = sd(value, na.rm = TRUE)
),
by = c("Species", "name")
]
# dplyr version
# library(dplyr)
# dat <- iris \%>\%
# pivot_longer(cols = -c(Species)) \%>\%
# group_by(Species, name) \%>\%
# summarise(avg = mean(value, na.rm = TRUE),
# sd = sd(value, na.rm = TRUE),
# .groups = "drop")
tab_3 <- tabulator(
x = dat, rows = c("Species"),
columns = "name",
`mean (sd)` = as_paragraph(
as_chunk(avg),
" (", as_chunk(sd), ")"
)
)
ft_3 <- as_flextable(tab_3)
ft_3
init_flextable_defaults()
}
}
\seealso{
\code{\link[=as_flextable.tabulator]{as_flextable.tabulator()}}, \code{\link[=summarizor]{summarizor()}},
\code{\link[=as_grouped_data]{as_grouped_data()}}, \code{\link[=tabulator_colnames]{tabulator_colnames()}}
}
flextable/man/as_flextable.compact_summary.Rd 0000644 0001762 0000144 00000003056 15137666130 021131 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/compact_summary.R
\name{as_flextable.compact_summary}
\alias{as_flextable.compact_summary}
\title{Transform a 'compact_summary' object into a flextable}
\usage{
\method{as_flextable}{compact_summary}(x, ...)
}
\arguments{
\item{x}{A \code{compact_summary} object produced by
\code{\link[=compact_summary]{compact_summary()}}.}
\item{...}{unused arguments.}
}
\value{
A \code{\link[=flextable]{flextable()}} object.
}
\description{
\code{compact_summary} objects can be transformed into
a flextable with method \code{\link[=as_flextable]{as_flextable()}}.
Numeric columns are formatted with \code{\link[=formatC]{formatC()}} using the
\code{digits} value stored in the object and the current
flextable defaults for \code{big.mark} and \code{decimal.mark}.
}
\examples{
z <- compact_summary(iris, show_type = TRUE, show_na = TRUE)
as_flextable(z)
}
\seealso{
Other as_flextable methods:
\code{\link{as_flextable}()},
\code{\link{as_flextable.data.frame}()},
\code{\link{as_flextable.gam}()},
\code{\link{as_flextable.glm}()},
\code{\link{as_flextable.grouped_data}()},
\code{\link{as_flextable.htest}()},
\code{\link{as_flextable.kmeans}()},
\code{\link{as_flextable.lm}()},
\code{\link{as_flextable.merMod}()},
\code{\link{as_flextable.pam}()},
\code{\link{as_flextable.summarizor}()},
\code{\link{as_flextable.table}()},
\code{\link{as_flextable.tabular}()},
\code{\link{as_flextable.tabulator}()},
\code{\link{as_flextable.xtable}()},
\code{\link{compact_summary}()}
}
\concept{as_flextable methods}
flextable/man/bg.Rd 0000644 0001762 0000144 00000005405 15142453603 013661 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/styles.R
\name{bg}
\alias{bg}
\title{Set background color}
\usage{
bg(x, i = NULL, j = NULL, bg, part = "body", source = j)
}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
\item{i}{row selector, see section \emph{Row selection with the \code{i} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{j}{column selector, see section \emph{Column selection with the \code{j} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{bg}{color to use as background color. If a function, the function must return
a character vector of colors.}
\item{part}{part selector, see section \emph{Part selection with the \code{part}
parameter} in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.
Value 'all' can be used.}
\item{source}{if bg is a function, source specifies the dataset column to be used
as an argument to \code{bg}. This is only useful when j is colored with values contained in
other columns.}
}
\description{
Change the background color of selected rows and
columns of a flextable. A function can be used instead of
fixed colors.
When \code{bg} is a function, it is possible to color cells based on values
located in other columns; using hidden columns (those not used by
argument \code{colkeys}) is a common use case. The argument \code{source}
must be used to define the columns to be used for the color
definition, and the argument \code{j} must be used to define where to apply
the colors and only accepts values from \code{colkeys}.
}
\note{
Word does not allow you to apply transparency to table cells or paragraph shading.
}
\examples{
ft_1 <- flextable(head(mtcars))
ft_1 <- bg(ft_1, bg = "wheat", part = "header")
ft_1 <- bg(ft_1, i = ~ qsec < 18, bg = "#EFEFEF", part = "body")
ft_1 <- bg(ft_1, j = "drat", bg = "#606060", part = "all")
ft_1 <- color(ft_1, j = "drat", color = "white", part = "all")
ft_1
if (require("scales")) {
ft_2 <- flextable(head(iris))
colourer <- col_numeric(
palette = c("wheat", "red"),
domain = c(0, 7)
)
ft_2 <- bg(ft_2,
j = c(
"Sepal.Length", "Sepal.Width",
"Petal.Length", "Petal.Width"
),
bg = colourer, part = "body"
)
ft_2
}
}
\seealso{
Other sugar functions for table style:
\code{\link{align}()},
\code{\link{bold}()},
\code{\link{color}()},
\code{\link{empty_blanks}()},
\code{\link{font}()},
\code{\link{fontsize}()},
\code{\link{highlight}()},
\code{\link{italic}()},
\code{\link{keep_with_next}()},
\code{\link{line_spacing}()},
\code{\link{padding}()},
\code{\link{rotate}()},
\code{\link{style}()},
\code{\link{tab_settings}()},
\code{\link{valign}()}
}
\concept{sugar functions for table style}
flextable/man/body_replace_flextable_at_bkm.Rd 0000644 0001762 0000144 00000001356 15142341701 021260 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/body_add_flextable.R
\name{body_replace_flextable_at_bkm}
\alias{body_replace_flextable_at_bkm}
\title{Add flextable at bookmark location in a Word document}
\usage{
body_replace_flextable_at_bkm(
x,
bookmark,
value,
align = "center",
split = FALSE
)
}
\arguments{
\item{x}{an rdocx object}
\item{bookmark}{bookmark id}
\item{value}{\code{flextable} object}
\item{align}{left, center (default) or right.}
\item{split}{set to TRUE if you want to activate Word
option 'Allow row to break across pages'.}
}
\description{
Use this function if you want to replace a paragraph containing
a bookmark with a flextable. As a side effect, the bookmark will be lost.
}
flextable/man/use_flextable_qmd.Rd 0000644 0001762 0000144 00000003062 15143103216 016742 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/05_content.R
\name{use_flextable_qmd}
\alias{use_flextable_qmd}
\title{Install the flextable-qmd Quarto extension}
\usage{
use_flextable_qmd(path = ".", quiet = FALSE)
}
\arguments{
\item{path}{Path to the Quarto project root. Defaults
to the current working directory.}
\item{quiet}{If \code{TRUE}, suppress informational messages.}
}
\value{
The path to the installed extension (invisibly).
}
\description{
Copies the \code{flextable-qmd} Quarto extension (bundled with
flextable) into the \verb{_extensions/} directory of a
Quarto project. The extension provides Lua filters
that resolve Quarto markdown content produced by
\code{\link[=as_qmd]{as_qmd()}} inside flextable cells for HTML, PDF
and Word (docx) output formats.
After installation, add the filter to your document
or project YAML:
\if{html}{\out{
}}
}
\examples{
library(flextable)
x <- data.frame(
Species = as.factor(c("setosa", "versicolor", "virginica")),
Sepal.Length_mean = c(5.006, 5.936, 6.588),
Sepal.Length_sd = c(0.35249, 0.51617, 0.63588),
Sepal.Width_mean = c(3.428, 2.77, 2.974),
Sepal.Width_sd = c(0.37906, 0.3138, 0.3225),
Petal.Length_mean = c(1.462, 4.26, 5.552),
Petal.Length_sd = c(0.17366, 0.46991, 0.55189),
Petal.Width_mean = c(0.246, 1.326, 2.026),
Petal.Width_sd = c(0.10539, 0.19775, 0.27465)
)
ft_1 <- flextable(x)
ft_1 <- colformat_double(ft_1, digits = 2)
ft_1 <- theme_box(ft_1)
ft_1 <- separate_header(
x = ft_1,
opts = c("span-top", "bottom-vspan")
)
ft_1
}
\seealso{
Other functions for row and column operations in a flextable:
\code{\link{add_body}()},
\code{\link{add_body_row}()},
\code{\link{add_footer}()},
\code{\link{add_footer_lines}()},
\code{\link{add_footer_row}()},
\code{\link{add_header}()},
\code{\link{add_header_lines}()},
\code{\link{add_header_row}()},
\code{\link{delete_columns}()},
\code{\link{delete_part}()},
\code{\link{set_header_footer_df}},
\code{\link{set_header_labels}()}
}
\concept{functions for row and column operations in a flextable}
flextable/man/colformat_image.Rd 0000644 0001762 0000144 00000003202 15142453603 016412 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/formatters.R
\name{colformat_image}
\alias{colformat_image}
\title{Format cells as images}
\usage{
colformat_image(
x,
i = NULL,
j = NULL,
width,
height,
na_str = get_flextable_defaults()$na_str,
nan_str = get_flextable_defaults()$nan_str,
prefix = "",
suffix = ""
)
}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
\item{i}{row selector, see section \emph{Row selection with the \code{i} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{j}{column selector, see section \emph{Column selection with the \code{j} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{width, height}{size of the png file in inches}
\item{na_str, nan_str}{string to be used for NA and NaN values}
\item{prefix, suffix}{string to be used as prefix or suffix}
}
\description{
Format image paths as images in a flextable.
}
\examples{
img.file <- file.path(R.home("doc"), "html", "logo.jpg")
dat <- head(iris)
dat$Species <- as.character(dat$Species)
dat[c(1, 3, 5), "Species"] <- img.file
myft <- flextable(dat)
myft <- colformat_image(
myft,
i = c(1, 3, 5),
j = "Species", width = .20, height = .15
)
ft <- autofit(myft)
ft
}
\seealso{
Other cells formatters:
\code{\link{colformat_char}()},
\code{\link{colformat_date}()},
\code{\link{colformat_datetime}()},
\code{\link{colformat_double}()},
\code{\link{colformat_int}()},
\code{\link{colformat_lgl}()},
\code{\link{colformat_num}()},
\code{\link{set_formatter}()}
}
\concept{cells formatters}
flextable/man/plot_chunk.Rd 0000644 0001762 0000144 00000004713 15143067476 015452 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/chunk_images.R
\name{plot_chunk}
\alias{plot_chunk}
\title{Mini plot chunk}
\usage{
plot_chunk(
value,
width = 1,
height = 0.2,
type = "box",
free_scale = FALSE,
unit = "in",
...
)
}
\arguments{
\item{value}{a numeric vector, stored in a list column.}
\item{width, height}{size of the resulting png file in inches}
\item{type}{type of the plot: 'box', 'line', 'points' or 'density'.}
\item{free_scale}{Should scales be free (TRUE or FALSE, the default value).}
\item{unit}{unit for width and height, one of "in", "cm", "mm".}
\item{...}{arguments sent to plot functions (see \code{\link[=par]{par()}})}
}
\description{
This function is used to insert mini plots into
flextable with functions:
\itemize{
\item \code{\link[=compose]{compose()}} and \code{\link[=as_paragraph]{as_paragraph()}},
\item \code{\link[=append_chunks]{append_chunks()}},
\item \code{\link[=prepend_chunks]{prepend_chunks()}}.
}
Available plots are 'box', 'line', 'points', 'density'.
}
\note{
This chunk option requires package officedown in a R Markdown
context with Word output format.
PowerPoint cannot mix images and text in a paragraph, images
are removed when outputing to PowerPoint format.
}
\examples{
library(data.table)
library(flextable)
z <- as.data.table(iris)
z <- z[, list(
Sepal.Length = mean(Sepal.Length, na.rm = TRUE),
z = list(.SD$Sepal.Length)
), by = "Species"]
ft <- flextable(z,
col_keys = c("Species", "Sepal.Length", "box", "density")
)
ft <- mk_par(ft, j = "box", value = as_paragraph(
plot_chunk(
value = z, type = "box",
border = "red", col = "transparent"
)
))
ft <- mk_par(ft, j = "density", value = as_paragraph(
plot_chunk(value = z, type = "dens", col = "red")
))
ft <- set_table_properties(ft, layout = "autofit", width = .6)
ft <- set_header_labels(ft, box = "boxplot", density = "density")
theme_vanilla(ft)
}
\seealso{
Other chunk elements for paragraph:
\code{\link{as_b}()},
\code{\link{as_bracket}()},
\code{\link{as_chunk}()},
\code{\link{as_equation}()},
\code{\link{as_highlight}()},
\code{\link{as_i}()},
\code{\link{as_image}()},
\code{\link{as_qmd}()},
\code{\link{as_strike}()},
\code{\link{as_sub}()},
\code{\link{as_sup}()},
\code{\link{as_word_field}()},
\code{\link{colorize}()},
\code{\link{gg_chunk}()},
\code{\link{grid_chunk}()},
\code{\link{hyperlink_text}()},
\code{\link{linerange}()},
\code{\link{minibar}()}
}
\concept{chunk elements for paragraph}
flextable/man/as_image.Rd 0000644 0001762 0000144 00000004761 15143067476 015054 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/chunk_images.R
\name{as_image}
\alias{as_image}
\title{Image chunk}
\usage{
as_image(src, width = NULL, height = NULL, unit = "in", guess_size = TRUE, ...)
}
\arguments{
\item{src}{image filename}
\item{width, height}{size of the image file. It can be ignored
if parameter \code{guess_size=TRUE}, see parameter \code{guess_size}.}
\item{unit}{unit for width and height, one of "in", "cm", "mm".}
\item{guess_size}{If package 'magick' is installed, this option
can be used (set it to \code{TRUE} and don't provide values for paramters
\code{width} and \code{height}). When the flextable will be printed,
the images will be read and width and height will be guessed. This
should be avoid if possible as it can be an extensive task when
several images.}
\item{...}{unused argument}
}
\description{
The function lets add images within flextable
objects with functions:
\itemize{
\item \code{\link[=compose]{compose()}} and \code{\link[=as_paragraph]{as_paragraph()}},
\item \code{\link[=append_chunks]{append_chunks()}},
\item \code{\link[=prepend_chunks]{prepend_chunks()}}
\if{html}{\out{
}}
}
}
\note{
This chunk option requires package officedown in a R Markdown
context with Word output format.
PowerPoint cannot mix images and text in a paragraph, images
are removed when outputing to PowerPoint format.
}
\examples{
img.file <- file.path(
R.home("doc"),
"html", "logo.jpg"
)
if (require("magick")) {
myft <- flextable(head(iris))
myft <- compose(myft,
i = 1:3, j = 1,
value = as_paragraph(
as_image(src = img.file),
" ",
as_chunk(Sepal.Length,
props = fp_text_default(color = "red")
)
),
part = "body"
)
ft <- autofit(myft)
ft
}
}
\seealso{
\code{\link[=compose]{compose()}}, \code{\link[=as_paragraph]{as_paragraph()}}
Other chunk elements for paragraph:
\code{\link{as_b}()},
\code{\link{as_bracket}()},
\code{\link{as_chunk}()},
\code{\link{as_equation}()},
\code{\link{as_highlight}()},
\code{\link{as_i}()},
\code{\link{as_qmd}()},
\code{\link{as_strike}()},
\code{\link{as_sub}()},
\code{\link{as_sup}()},
\code{\link{as_word_field}()},
\code{\link{colorize}()},
\code{\link{gg_chunk}()},
\code{\link{grid_chunk}()},
\code{\link{hyperlink_text}()},
\code{\link{linerange}()},
\code{\link{minibar}()},
\code{\link{plot_chunk}()}
}
\concept{chunk elements for paragraph}
flextable/man/as_grouped_data.Rd 0000644 0001762 0000144 00000002106 15142341701 016400 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/as_flextable.R
\name{as_grouped_data}
\alias{as_grouped_data}
\title{Insert group-label rows into a data frame}
\usage{
as_grouped_data(x, groups, columns = NULL, expand_single = TRUE)
}
\arguments{
\item{x}{dataset}
\item{groups}{columns names to be used as row separators.}
\item{columns}{columns names to keep}
\item{expand_single}{if FALSE, groups with only one
row will not be expanded with a title row. If TRUE (the
default), single row groups and multi-row groups are all
restructured.}
}
\description{
Repeated consecutive values of group columns will
be used to define the title of the groups and will
be added as a row title.
}
\examples{
# as_grouped_data -----
library(data.table)
CO2 <- CO2
setDT(CO2)
CO2$conc <- as.integer(CO2$conc)
data_co2 <- dcast(CO2, Treatment + conc ~ Type,
value.var = "uptake", fun.aggregate = mean
)
data_co2
data_co2 <- as_grouped_data(x = data_co2, groups = c("Treatment"))
data_co2
}
\seealso{
\code{\link[=as_flextable.grouped_data]{as_flextable.grouped_data()}}
}
flextable/man/proc_freq.Rd 0000644 0001762 0000144 00000003007 15131745533 015251 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/proc_freq.R
\name{proc_freq}
\alias{proc_freq}
\title{Frequency table}
\usage{
proc_freq(
x,
row = character(),
col = character(),
include.row_percent = TRUE,
include.column_percent = TRUE,
include.table_percent = TRUE,
include.table_count = TRUE,
weight = character(),
count_format_fun = fmt_int,
...
)
}
\arguments{
\item{x}{a \code{data.frame} object containing variable(s) to use for counts.}
\item{row}{\code{characer} column names for row}
\item{col}{\code{characer} column names for column}
\item{include.row_percent}{\code{boolean} whether to include the row percents; defaults to \code{TRUE}}
\item{include.column_percent}{\code{boolean} whether to include the column percents; defaults to \code{TRUE}}
\item{include.table_percent}{\code{boolean} whether to include the table percents; defaults to \code{TRUE}}
\item{include.table_count}{\code{boolean} whether to include the table counts; defaults to \code{TRUE}}
\item{weight}{\code{character} column name for weight}
\item{count_format_fun}{a function to format the count values,
defaults to \link{fmt_int}.}
\item{...}{unused arguments}
}
\description{
This function computes a one or two way
contingency table and creates a flextable from the result.
The function is largely inspired by "PROC FREQ" from "SAS"
and was written with the intent to make it
as compact as possible.
}
\examples{
proc_freq(mtcars, "vs", "gear")
proc_freq(mtcars, "gear", "vs", weight = "wt")
}
flextable/man/vline_right.Rd 0000644 0001762 0000144 00000003531 15142341701 015574 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/borders.R
\name{vline_right}
\alias{vline_right}
\title{Set the right border of the table}
\usage{
vline_right(x, i = NULL, border = NULL, part = "all")
}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
\item{i}{row selector, see section \emph{Row selection with the \code{i} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{border}{border properties defined by a call to
\code{\link[officer:fp_border]{officer::fp_border()}}}
\item{part}{part selector, see section \emph{Part selection with the \code{part}
parameter} in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.
Value 'all' can be used.}
}
\description{
\code{vline_right()} draws a vertical line along the \strong{right edge}
of the table by setting the right border of the last column.
It does not accept a column selector \code{j} because it always
targets the last column.
An optional row selector \code{i} lets you restrict the line to
specific rows.
Unlike \code{\link[=vline]{vline()}}, which adds inner lines to the right of
arbitrary columns, \code{vline_right()} is meant for the outer
right edge of the table.
}
\examples{
library(officer)
std_border <- fp_border(color = "orange")
ft <- flextable(head(iris))
ft <- border_remove(x = ft)
# add a border on the right edge of the table
ft <- vline_right(ft, border = std_border)
ft
}
\seealso{
Other borders management:
\code{\link{border_inner}()},
\code{\link{border_inner_h}()},
\code{\link{border_inner_v}()},
\code{\link{border_outer}()},
\code{\link{border_remove}()},
\code{\link{hline}()},
\code{\link{hline_bottom}()},
\code{\link{hline_top}()},
\code{\link{surround}()},
\code{\link{vline}()},
\code{\link{vline_left}()}
}
\concept{borders management}
flextable/man/fp_border_default.Rd 0000644 0001762 0000144 00000002675 15142341701 016740 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/defaults.R
\name{fp_border_default}
\alias{fp_border_default}
\title{Create border formatting with flextable defaults}
\usage{
fp_border_default(
color = flextable_global$defaults$border.color,
style = "solid",
width = flextable_global$defaults$border.width
)
}
\arguments{
\item{color}{border color - single character value (e.g. "#000000" or "black")}
\item{style}{border style - single character value : See Details for supported
border styles.}
\item{width}{border width - an integer value : 0>= value}
}
\description{
Create a \code{\link[officer:fp_border]{officer::fp_border()}} object whose unspecified
arguments inherit from \code{\link[=set_flextable_defaults]{set_flextable_defaults()}} (border color, width).
Use \code{fp_border_default()} instead of \code{officer::fp_border()} so that
borders automatically match the table's default style.
}
\examples{
library(flextable)
set_flextable_defaults(
border.color = "orange"
)
z <- flextable(head(cars))
z <- theme_vanilla(z)
z <- vline(
z,
j = 1, part = "all",
border = officer::fp_border()
)
z <- vline(
z,
j = 2, part = "all",
border = fp_border_default()
)
z
init_flextable_defaults()
}
\seealso{
\code{\link[=hline]{hline()}}, \code{\link[=vline]{vline()}}
Other functions for defining formatting properties:
\code{\link{fp_text_default}()}
}
\concept{functions for defining formatting properties}
flextable/man/args_selectors_with_all.Rd 0000644 0001762 0000144 00000001566 15142453603 020177 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/doc-selectors.R
\name{args_selectors_with_all}
\alias{args_selectors_with_all}
\title{internal utils for roxygen tags reuse}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
\item{i}{row selector, see section \emph{Row selection with the \code{i} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{j}{column selector, see section \emph{Column selection with the \code{j} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{part}{part selector, see section \emph{Part selection with the \code{part}
parameter} in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.
Value 'all' can be used.}
}
\description{
internal utils for roxygen tags reuse
}
\keyword{internal}
flextable/man/flextable.Rd 0000644 0001762 0000144 00000007302 15142341701 015230 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/flextable.R
\name{flextable}
\alias{flextable}
\alias{qflextable}
\title{Create a flextable from a data frame}
\usage{
flextable(
data,
col_keys = names(data),
cwidth = 0.75,
cheight = 0.25,
defaults = list(),
theme_fun = theme_booktabs,
use_labels = TRUE
)
qflextable(data)
}
\arguments{
\item{data}{dataset}
\item{col_keys}{columns names/keys to display. If some column names are not in
the dataset, they will be added as blank columns by default.}
\item{cwidth, cheight}{initial width and height to use for cell sizes in inches.}
\item{defaults, theme_fun}{deprecated, use \code{\link[=set_flextable_defaults]{set_flextable_defaults()}} instead.}
\item{use_labels}{Logical; if TRUE, any column labels or value labels
present in the dataset will be used for display purposes. Defaults
to TRUE.}
}
\description{
Create a flextable object with function \code{flextable}.
\code{flextable} are designed to make tabular reporting easier for
R users. Functions are available to let you format text, paragraphs and cells;
table cells can be merge vertically or horizontally, row headers can easily
be defined, rows heights and columns widths can be manually set or automatically
computed.
If working with 'R Markdown' documents, you should read about knitr
chunk options in \code{\link[=knit_print.flextable]{knit_print.flextable()}} and about setting
default values with \code{\link[=set_flextable_defaults]{set_flextable_defaults()}}.
}
\section{Reuse frequently used parameters}{
Some default formatting properties are automatically
applied to every flextable you produce.
It is highly recommended to use this function because
its use will minimize the code. For example, instead of
calling the \code{fontsize()} function over and over again for
each new flextable, set the font size default value by
calling (before creating the flextables)
\code{set_flextable_defaults(font.size = 11)}. This is also
a simple way to have homogeneous arrays and make the
documents containing them easier to read.
You can change these default values with function
\code{\link[=set_flextable_defaults]{set_flextable_defaults()}}. You can reset them
with function \code{\link[=init_flextable_defaults]{init_flextable_defaults()}}. You
can access these values by calling \code{\link[=get_flextable_defaults]{get_flextable_defaults()}}.
}
\section{new lines and tabulations}{
The 'flextable' package will translate for you
the new lines expressed in the form \verb{\\n} and
the tabs expressed in the form \verb{\\t}.
The new lines will be transformed into "soft-return",
that is to say a simple carriage return and not a
new paragraph.
Tabs are different depending on the output format:
\itemize{
\item HTML is using entity \emph{em space}
\item Word - a Word 'tab' element
\item PowerPoint - a PowerPoint 'tab' element
\item latex - tag "\\quad "
}
}
\section{flextable parts}{
A \code{flextable} is made of 3 parts: header, body and footer.
Most functions have an argument named \code{part} that will be used
to specify what part of of the table should be modified.
}
\section{qflextable}{
\code{qflextable} is a convenient tool to produce quickly
a flextable for reporting where layout is fixed (see
\code{\link[=set_table_properties]{set_table_properties()}}) and columns
widths are adjusted with \code{\link[=autofit]{autofit()}}.
}
\examples{
ft <- flextable(head(mtcars))
ft
}
\seealso{
\code{\link[=style]{style()}}, \code{\link[=autofit]{autofit()}}, \code{\link[=theme_booktabs]{theme_booktabs()}}, \code{\link[=knit_print.flextable]{knit_print.flextable()}},
\code{\link[=compose]{compose()}}, \code{\link[=footnote]{footnote()}}, \code{\link[=set_caption]{set_caption()}}
}
flextable/man/as_bracket.Rd 0000644 0001762 0000144 00000003043 15143067476 015375 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/05_content.R
\name{as_bracket}
\alias{as_bracket}
\title{Bracket chunk}
\usage{
as_bracket(..., sep = ", ", p = "(", s = ")")
}
\arguments{
\item{...}{text and column names}
\item{sep}{separator}
\item{p}{prefix, default to '('}
\item{s}{suffix, default to ')'}
}
\description{
The function is producing a chunk by
pasting values and add the result in brackets.
It is used to add it to the content of a cell of the
flextable with the functions \code{\link[=compose]{compose()}}, \code{\link[=append_chunks]{append_chunks()}}
or \code{\link[=prepend_chunks]{prepend_chunks()}}.
}
\examples{
ft <- flextable(head(iris),
col_keys = c("Species", "Sepal", "Petal")
)
ft <- set_header_labels(ft, Sepal = "Sepal", Petal = "Petal")
ft <- compose(ft,
j = "Sepal",
value = as_paragraph(as_bracket(Sepal.Length, Sepal.Width))
)
ft <- compose(ft,
j = "Petal",
value = as_paragraph(as_bracket(Petal.Length, Petal.Width))
)
ft
}
\seealso{
Other chunk elements for paragraph:
\code{\link{as_b}()},
\code{\link{as_chunk}()},
\code{\link{as_equation}()},
\code{\link{as_highlight}()},
\code{\link{as_i}()},
\code{\link{as_image}()},
\code{\link{as_qmd}()},
\code{\link{as_strike}()},
\code{\link{as_sub}()},
\code{\link{as_sup}()},
\code{\link{as_word_field}()},
\code{\link{colorize}()},
\code{\link{gg_chunk}()},
\code{\link{grid_chunk}()},
\code{\link{hyperlink_text}()},
\code{\link{linerange}()},
\code{\link{minibar}()},
\code{\link{plot_chunk}()}
}
\concept{chunk elements for paragraph}
flextable/man/information_data_paragraph.Rd 0000644 0001762 0000144 00000002553 15142341701 020630 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/read_structure.R
\name{information_data_paragraph}
\alias{information_data_paragraph}
\title{Get paragraph-level information from a flextable}
\usage{
information_data_paragraph(x)
}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
}
\value{
a data.frame containing information about paragraphs:
\itemize{
\item formatting properties,
\item part (\code{.part}), row (\code{.row_id}) and column (\code{.col_id}).
}
}
\description{
This function takes a flextable object and returns a data.frame containing
information about each paragraph within the flextable. The data.frame includes
details about formatting properties and position within the
row and column.
}
\section{don't use this}{
These data structures should not be used, as they
represent an interpretation of the underlying data
structures, which may evolve over time.
\strong{They are exported to enable two packages that exploit
these structures to make a transition, and should not
remain available for long.}
}
\examples{
ft <- as_flextable(iris)
x <- information_data_paragraph(ft)
head(x)
}
\seealso{
Other information data functions:
\code{\link{information_data_cell}()},
\code{\link{information_data_chunk}()}
}
\concept{information data functions}
\keyword{internal}
flextable/man/as_paragraph.Rd 0000644 0001762 0000144 00000004522 15142341701 015713 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/05_content.R
\name{as_paragraph}
\alias{as_paragraph}
\title{Build a paragraph from chunks}
\usage{
as_paragraph(..., list_values = NULL)
}
\arguments{
\item{...}{chunk elements that are defining the paragraph content.
If a character is used, it is transformed to a chunk object with
function \code{\link[=as_chunk]{as_chunk()}}.}
\item{list_values}{a list of chunk elements that are defining
the paragraph content. If specified argument \code{...} is unused.}
}
\description{
\code{as_paragraph()} assembles one or more chunks into a single paragraph
that defines the content of a flextable cell. Each cell in a flextable
contains exactly one paragraph; a paragraph is an ordered sequence of
chunks.
Chunks are the smallest content units and can be created with
\code{\link[=as_chunk]{as_chunk()}} (formatted text), \code{\link[=as_b]{as_b()}} / \code{\link[=as_i]{as_i()}} (bold / italic
shortcuts), \code{\link[=minibar]{minibar()}} (inline bar), \code{\link[=as_image]{as_image()}} (image),
\code{\link[=gg_chunk]{gg_chunk()}} (ggplot), \code{\link[=as_equation]{as_equation()}} (equation) or
\code{\link[=hyperlink_text]{hyperlink_text()}} (link). Plain character strings passed to
\code{as_paragraph()} are automatically converted to chunks via
\code{\link[=as_chunk]{as_chunk()}}.
The resulting paragraph is passed to the \code{value} argument of
\code{\link[=compose]{compose()}}, \code{\link[=mk_par]{mk_par()}}, \code{\link[=add_header_lines]{add_header_lines()}},
\code{\link[=add_footer_lines]{add_footer_lines()}} or \code{\link[=footnote]{footnote()}} to set cell content.
}
\examples{
library(flextable)
ft <- flextable(airquality[sample.int(150, size = 10), ])
ft <- compose(ft,
j = "Wind",
value = as_paragraph(
as_chunk(Wind, props = fp_text_default(color = "orange")),
" ",
minibar(value = Wind, max = max(airquality$Wind), barcol = "orange", bg = "black", height = .15)
),
part = "body"
)
ft <- autofit(ft)
ft
}
\seealso{
\code{\link[=as_chunk]{as_chunk()}}, \code{\link[=minibar]{minibar()}},
\code{\link[=as_image]{as_image()}}, \code{\link[=hyperlink_text]{hyperlink_text()}}
Other functions for mixed content paragraphs:
\code{\link{append_chunks}()},
\code{\link{compose}()},
\code{\link{prepend_chunks}()}
}
\concept{functions for mixed content paragraphs}
flextable/man/linerange.Rd 0000644 0001762 0000144 00000004136 15143067476 015247 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/chunk_images.R
\name{linerange}
\alias{linerange}
\title{Mini linerange chunk}
\usage{
linerange(
value,
min = NULL,
max = NULL,
rangecol = "#CCCCCC",
stickcol = "#FF0000",
bg = "transparent",
width = 1,
height = 0.2,
raster_width = 30,
unit = "in"
)
}
\arguments{
\item{value}{values containing the bar size}
\item{min}{min bar size. Default min of value}
\item{max}{max bar size. Default max of value}
\item{rangecol}{bar color}
\item{stickcol}{jauge color}
\item{bg}{background color}
\item{width, height}{size of the resulting png file in inches}
\item{raster_width}{number of pixels used as width
when interpolating value.}
\item{unit}{unit for width and height, one of "in", "cm", "mm".}
}
\description{
This function is used to insert lineranges into
flextable with functions:
\itemize{
\item \code{\link[=compose]{compose()}} and \code{\link[=as_paragraph]{as_paragraph()}},
\item \code{\link[=append_chunks]{append_chunks()}},
\item \code{\link[=prepend_chunks]{prepend_chunks()}}.
}
}
\note{
This chunk option requires package officedown in a R Markdown
context with Word output format.
PowerPoint cannot mix images and text in a paragraph, images
are removed when outputing to PowerPoint format.
}
\examples{
myft <- flextable(head(iris, n = 10))
myft <- compose(myft,
j = 1,
value = as_paragraph(
linerange(value = Sepal.Length)
),
part = "body"
)
autofit(myft)
}
\seealso{
\code{\link[=compose]{compose()}}, \code{\link[=as_paragraph]{as_paragraph()}}
Other chunk elements for paragraph:
\code{\link{as_b}()},
\code{\link{as_bracket}()},
\code{\link{as_chunk}()},
\code{\link{as_equation}()},
\code{\link{as_highlight}()},
\code{\link{as_i}()},
\code{\link{as_image}()},
\code{\link{as_qmd}()},
\code{\link{as_strike}()},
\code{\link{as_sub}()},
\code{\link{as_sup}()},
\code{\link{as_word_field}()},
\code{\link{colorize}()},
\code{\link{gg_chunk}()},
\code{\link{grid_chunk}()},
\code{\link{hyperlink_text}()},
\code{\link{minibar}()},
\code{\link{plot_chunk}()}
}
\concept{chunk elements for paragraph}
flextable/man/body_add_flextable.Rd 0000644 0001762 0000144 00000007461 15131745533 017074 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/body_add_flextable.R
\name{body_add_flextable}
\alias{body_add_flextable}
\title{Add flextable into a Word document}
\usage{
body_add_flextable(
x,
value,
align = NULL,
pos = "after",
split = NULL,
topcaption = TRUE,
keepnext = NULL
)
}
\arguments{
\item{x}{an rdocx object}
\item{value}{\code{flextable} object}
\item{align}{left, center (default) or right.
The \code{align} parameter is still supported for the time being, but
we recommend using \code{set_flextable_defaults(table_align = "center")} instead
that will set this default alignment for all flextables during
the R session, or to define alignement for each table with
\code{set_table_properties(align = "center")}.}
\item{pos}{where to add the flextable relative to the cursor,
one of "after", "before", "on" (end of line).}
\item{split}{set to TRUE if you want to activate Word
option 'Allow row to break across pages'.
This argument is still supported for the time being, but
we recommend using \code{set_flextable_defaults(split = TRUE)} instead
that will set this as default setting for all flextables during
the R session, or to define alignement for each table with
\code{\link[=set_table_properties]{set_table_properties()}} with argument \code{opts_word=list(split = TRUE)}
instead.}
\item{topcaption}{if TRUE caption is added before the table, if FALSE,
caption is added after the table.}
\item{keepnext}{Defunct in favor of \code{\link[=paginate]{paginate()}}. The default value
used for \code{keep_with_next} is set with
\code{set_flextable_defaults(keep_with_next = TRUE)}.}
}
\description{
Add a flextable into a Word document
created with 'officer'.
}
\details{
Use the \code{\link[=paginate]{paginate()}} function to define whether the table should
be displayed on one or more pages, and whether the header should be
displayed with the first lines of the table body on the same page.
Use the \code{\link[=set_caption]{set_caption()}} function to define formatted captions
(with \code{\link[=as_paragraph]{as_paragraph()}}) or simple captions (with a string).
\code{topcaption} can be used to insert the caption before the table
(default) or after the table (use \code{FALSE}).
}
\examples{
\dontshow{
init_flextable_defaults()
}
library(officer)
# define global settings
set_flextable_defaults(
split = TRUE,
table_align = "center",
table.layout = "autofit"
)
# produce 3 flextable
ft_1 <- flextable(head(airquality, n = 20))
ft_1 <- color(ft_1, i = ~ Temp > 70, color = "red", j = "Temp")
ft_1 <- highlight(ft_1, i = ~ Wind < 8, color = "yellow", j = "Wind")
ft_1 <- set_caption(
x = ft_1,
autonum = run_autonum(seq_id = "tab"),
caption = "Daily air quality measurements"
)
ft_1 <- paginate(ft_1, init = TRUE, hdr_ftr = TRUE)
ft_2 <- proc_freq(mtcars, "vs", "gear")
ft_2 <- set_caption(
x = ft_2,
autonum = run_autonum(seq_id = "tab", bkm = "mtcars"),
caption = as_paragraph(
as_b("mtcars"), " ",
colorize("table", color = "orange")
),
fp_p = fp_par(keep_with_next = TRUE)
)
ft_2 <- paginate(ft_2, init = TRUE, hdr_ftr = TRUE)
ft_3 <- summarizor(iris, by = "Species")
ft_3 <- as_flextable(ft_3, spread_first_col = TRUE)
ft_3 <- set_caption(
x = ft_3,
autonum = run_autonum(seq_id = "tab"),
caption = "iris summary"
)
ft_3 <- paginate(ft_3, init = TRUE, hdr_ftr = TRUE)
# add the 3 flextable in a new Word document
doc <- read_docx()
doc <- body_add_flextable(doc, value = ft_1)
doc <- body_add_par(doc, value = "")
doc <- body_add_flextable(doc, value = ft_2)
doc <- body_add_par(doc, value = "")
doc <- body_add_flextable(doc, value = ft_3)
fileout <- tempfile(fileext = ".docx")
print(doc, target = fileout)
\dontshow{
init_flextable_defaults()
}
}
\seealso{
\code{\link[=knit_print.flextable]{knit_print.flextable()}}, \code{\link[=save_as_docx]{save_as_docx()}}
}
flextable/man/add_header_row.Rd 0000644 0001762 0000144 00000004547 15142341701 016221 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/augment_rows.R
\name{add_header_row}
\alias{add_header_row}
\title{Add a header row with spanning labels}
\usage{
add_header_row(x, top = TRUE, values = character(0), colwidths = integer(0))
}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
\item{top}{should the row be inserted at the
top or the bottom. Default to TRUE.}
\item{values}{values to add, a character vector (as header rows
contains only character values/columns), a list
or a call to \code{\link[=as_paragraph]{as_paragraph()}}.}
\item{colwidths}{the number of columns used for each label}
}
\description{
Add a single row to the header where labels can span
multiple columns (merged cells) via the \code{colwidths} argument.
Labels are associated with a number of columns
to merge that default to one if not specified.
In this case, you have to make sure that the
number of labels is equal to the number of columns displayed.
The function can add only one single row by call.
Labels can also be formatted with \code{\link[=as_paragraph]{as_paragraph()}}.
}
\examples{
library(flextable)
ft01 <- fp_text_default(color = "red")
ft02 <- fp_text_default(color = "orange")
pars <- as_paragraph(
as_chunk(c("(1)", "(2)"), props = ft02), " ",
as_chunk(c(
"My tailor is rich",
"My baker is rich"
), props = ft01)
)
ft_1 <- flextable(head(mtcars))
ft_1 <- add_header_row(ft_1,
values = pars,
colwidths = c(5, 6), top = FALSE
)
ft_1 <- add_header_row(ft_1,
values = pars,
colwidths = c(3, 8), top = TRUE
)
ft_1
ft_2 <- flextable(head(airquality))
ft_2 <- add_header_row(ft_2,
values = c("Measure", "Time"),
colwidths = c(4, 2), top = TRUE
)
ft_2 <- theme_box(ft_2)
ft_2
}
\seealso{
\code{\link[=flextable]{flextable()}}, \code{\link[=set_caption]{set_caption()}}
Other functions for row and column operations in a flextable:
\code{\link{add_body}()},
\code{\link{add_body_row}()},
\code{\link{add_footer}()},
\code{\link{add_footer_lines}()},
\code{\link{add_footer_row}()},
\code{\link{add_header}()},
\code{\link{add_header_lines}()},
\code{\link{delete_columns}()},
\code{\link{delete_part}()},
\code{\link{separate_header}()},
\code{\link{set_header_footer_df}},
\code{\link{set_header_labels}()}
}
\concept{functions for row and column operations in a flextable}
flextable/man/as_chunk.Rd 0000644 0001762 0000144 00000003631 15143067476 015075 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/05_content.R
\name{as_chunk}
\alias{as_chunk}
\title{Text chunk}
\usage{
as_chunk(x, props = NULL, formatter = format_fun, ...)
}
\arguments{
\item{x}{text or any element that can be formatted as text
with function provided in argument \code{formatter}.}
\item{props}{an \code{\link[=fp_text_default]{fp_text_default()}} or \code{\link[officer:fp_text]{officer::fp_text()}} object to be used to format the text.
If not specified, it will be the default value corresponding to the cell.}
\item{formatter}{a function that will format x as a character vector.}
\item{...}{additional arguments for \code{formatter} function.}
}
\description{
The function lets add formated text in flextable
cells.
It is used to add it to the content of a cell of the
flextable with the functions \code{\link[=compose]{compose()}}, \code{\link[=append_chunks]{append_chunks()}}
or \code{\link[=prepend_chunks]{prepend_chunks()}}.
It should be used inside a call to \code{\link[=as_paragraph]{as_paragraph()}}.
}
\examples{
library(officer)
ft <- flextable(head(iris))
ft <- compose(ft,
j = "Sepal.Length",
value = as_paragraph(
"Sepal.Length value is ",
as_chunk(Sepal.Length, props = fp_text(color = "red"))
),
part = "body"
)
ft <- color(ft, color = "gray40", part = "all")
ft <- autofit(ft)
ft
}
\seealso{
Other chunk elements for paragraph:
\code{\link{as_b}()},
\code{\link{as_bracket}()},
\code{\link{as_equation}()},
\code{\link{as_highlight}()},
\code{\link{as_i}()},
\code{\link{as_image}()},
\code{\link{as_qmd}()},
\code{\link{as_strike}()},
\code{\link{as_sub}()},
\code{\link{as_sup}()},
\code{\link{as_word_field}()},
\code{\link{colorize}()},
\code{\link{gg_chunk}()},
\code{\link{grid_chunk}()},
\code{\link{hyperlink_text}()},
\code{\link{linerange}()},
\code{\link{minibar}()},
\code{\link{plot_chunk}()}
}
\concept{chunk elements for paragraph}
flextable/man/fmt_2stats.Rd 0000644 0001762 0000144 00000003541 15142341701 015351 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/summarizor.R
\name{fmt_2stats}
\alias{fmt_2stats}
\alias{fmt_summarizor}
\title{Format summarizor statistics as text}
\usage{
fmt_2stats(stat, num1, num2, cts, pcts, ...)
fmt_summarizor(stat, num1, num2, cts, pcts, ...)
}
\arguments{
\item{stat}{a character column containing the name of statictics}
\item{num1}{a numeric statistic to display such as a mean or a median}
\item{num2}{a numeric statistic to display such as a standard
deviation or a median absolute deviation.}
\item{cts}{a count to display}
\item{pcts}{a percentage to display}
\item{...}{unused arguments}
}
\description{
Format the output of \code{\link[=summarizor]{summarizor()}} into display strings:
quantitative variables are shown as mean (sd), median (IQR), or range;
qualitative variables are shown as count (percentage).
}
\examples{
library(flextable)
z <- summarizor(iris, by = "Species")
tab_1 <- tabulator(
x = z,
rows = c("variable", "stat"),
columns = "Species",
blah = as_paragraph(
as_chunk(
fmt_summarizor(
stat = stat,
num1 = value1, num2 = value2,
cts = cts, pcts = percent
)
)
)
)
ft_1 <- as_flextable(x = tab_1, separate_with = "variable")
ft_1 <- labelizor(
x = ft_1, j = "stat",
labels = c(
mean_sd = "Moyenne (ecart-type)",
median_iqr = "Mediane (IQR)",
range = "Etendue",
missing = "Valeurs manquantes"
)
)
ft_1 <- autofit(ft_1)
ft_1
}
\seealso{
\code{\link[=summarizor]{summarizor()}}, \code{\link[=tabulator]{tabulator()}}, \code{\link[=mk_par]{mk_par()}}
Other text formatter functions:
\code{\link{fmt_avg_dev}()},
\code{\link{fmt_dbl}()},
\code{\link{fmt_header_n}()},
\code{\link{fmt_int}()},
\code{\link{fmt_n_percent}()},
\code{\link{fmt_pct}()},
\code{\link{fmt_signif_after_zeros}()}
}
\concept{text formatter functions}
flextable/man/hyperlink_text.Rd 0000644 0001762 0000144 00000004107 15143067476 016352 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/05_content.R
\name{hyperlink_text}
\alias{hyperlink_text}
\title{Hyperlink chunk}
\usage{
hyperlink_text(x, props = NULL, formatter = format_fun, url, ...)
}
\arguments{
\item{x}{text or any element that can be formatted as text
with function provided in argument \code{formatter}.}
\item{props}{an \code{\link[=fp_text_default]{fp_text_default()}} or \code{\link[officer:fp_text]{officer::fp_text()}} object to be used to format the text.
If not specified, it will be the default value corresponding to the cell.}
\item{formatter}{a function that will format x as a character vector.}
\item{url}{url to be used}
\item{...}{additional arguments for \code{formatter} function.}
}
\description{
The function lets add hyperlinks within flextable
objects.
It is used to add it to the content of a cell of the
flextable with the functions \code{\link[=compose]{compose()}}, \code{\link[=append_chunks]{append_chunks()}}
or \code{\link[=prepend_chunks]{prepend_chunks()}}.
URL are not encoded, they are preserved 'as is'.
}
\note{
This chunk option requires package officedown in a R Markdown
context with Word output format.
}
\examples{
dat <- data.frame(
col = "Google it",
href = "https://www.google.fr/search?source=hp&q=flextable+R+package",
stringsAsFactors = FALSE
)
ftab <- flextable(dat)
ftab <- compose(
x = ftab, j = "col",
value = as_paragraph(
"This is a link: ",
hyperlink_text(x = col, url = href)
)
)
ftab
}
\seealso{
\code{\link[=compose]{compose()}}
Other chunk elements for paragraph:
\code{\link{as_b}()},
\code{\link{as_bracket}()},
\code{\link{as_chunk}()},
\code{\link{as_equation}()},
\code{\link{as_highlight}()},
\code{\link{as_i}()},
\code{\link{as_image}()},
\code{\link{as_qmd}()},
\code{\link{as_strike}()},
\code{\link{as_sub}()},
\code{\link{as_sup}()},
\code{\link{as_word_field}()},
\code{\link{colorize}()},
\code{\link{gg_chunk}()},
\code{\link{grid_chunk}()},
\code{\link{linerange}()},
\code{\link{minibar}()},
\code{\link{plot_chunk}()}
}
\concept{chunk elements for paragraph}
flextable/man/delete_rows.Rd 0000644 0001762 0000144 00000002021 15131745533 015600 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/augment_rows.R
\name{delete_rows}
\alias{delete_rows}
\title{Delete flextable rows}
\usage{
delete_rows(x, i = NULL, part = "body")
}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
\item{i}{row selector, see section \emph{Row selection with the \code{i} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{part}{part selector, see section \emph{Part selection with the \code{part}
parameter} in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.
Value 'all' can be used.}
}
\description{
The function removes one or more rows
from a 'flextable'.
}
\details{
Deleting one or more rows will result in the deletion
of any span parameters that may have been set previously.
They will have to be redone after this operation or
performed only after this deletion.
}
\examples{
ft <- flextable(head(iris))
ft <- delete_rows(ft, i = 1:5, part = "body")
ft
}
flextable/man/information_data_cell.Rd 0000644 0001762 0000144 00000002515 15142341701 017600 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/read_structure.R
\name{information_data_cell}
\alias{information_data_cell}
\title{Get cell-level information from a flextable}
\usage{
information_data_cell(x)
}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
}
\value{
a data.frame containing information about cells:
\itemize{
\item formatting properties,
\item part (\code{.part}), row (\code{.row_id}) and column (\code{.col_id}).
}
}
\description{
This function takes a flextable object and returns a data.frame containing
information about each cell within the flextable. The data.frame includes
details about formatting properties and position within the
row and column.
}
\section{don't use this}{
These data structures should not be used, as they
represent an interpretation of the underlying data
structures, which may evolve over time.
\strong{They are exported to enable two packages that exploit
these structures to make a transition, and should not
remain available for long.}
}
\examples{
ft <- as_flextable(iris)
x <- information_data_cell(ft)
head(x)
}
\seealso{
Other information data functions:
\code{\link{information_data_chunk}()},
\code{\link{information_data_paragraph}()}
}
\concept{information data functions}
\keyword{internal}
flextable/man/dim.flextableGrob.Rd 0000644 0001762 0000144 00000001101 15131745533 016612 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/grid_grobs.R
\name{dim.flextableGrob}
\alias{dim.flextableGrob}
\title{Get optimal width and height of a flextable grob}
\usage{
\method{dim}{flextableGrob}(x)
}
\arguments{
\item{x}{a flextableGrob object}
}
\value{
a named list with two elements, \code{width} and \code{height}.
Values are expressed in inches.
}
\description{
returns the optimal width and height for the grob,
according to the grob generation parameters.
}
\examples{
ftab <- flextable(head(iris))
gr <- gen_grob(ftab)
dim(gr)
}
flextable/man/width.Rd 0000644 0001762 0000144 00000002665 15142453603 014415 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/flextable_sizes.R
\name{width}
\alias{width}
\title{Set columns width}
\usage{
width(x, j = NULL, width, unit = "in")
}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
\item{j}{column selector, see section \emph{Column selection with the \code{j} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{width}{width in inches}
\item{unit}{unit for width, one of "in", "cm", "mm".}
}
\description{
Defines the widths of one or more columns in the
table. This function will have no effect if you have
used \code{set_table_properties(layout = "autofit")}.
\code{\link[=set_table_properties]{set_table_properties()}} can provide an alternative to fixed-width layouts
that is supported with HTML and Word output that can be set
with \code{set_table_properties(layout = "autofit")}.
}
\details{
Heights are not used when flextable is been rendered into HTML.
}
\examples{
ft <- flextable(head(iris))
ft <- width(ft, width = 1.5)
ft
}
\seealso{
Other functions for flextable size management:
\code{\link{autofit}()},
\code{\link{dim.flextable}()},
\code{\link{dim_pretty}()},
\code{\link{fit_to_width}()},
\code{\link{flextable_dim}()},
\code{\link{height}()},
\code{\link{hrule}()},
\code{\link{ncol_keys}()},
\code{\link{nrow_part}()}
}
\concept{functions for flextable size management}
flextable/man/border.Rd 0000644 0001762 0000144 00000005041 15142453603 014542 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/borders.R
\name{border}
\alias{border}
\title{Set cell borders}
\usage{
border(
x,
i = NULL,
j = NULL,
border = NULL,
border.top = NULL,
border.bottom = NULL,
border.left = NULL,
border.right = NULL,
part = "body"
)
}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
\item{i}{row selector, see section \emph{Row selection with the \code{i} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{j}{column selector, see section \emph{Column selection with the \code{j} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{border}{border (shortcut for top, bottom, left and right)}
\item{border.top}{border top}
\item{border.bottom}{border bottom}
\item{border.left}{border left}
\item{border.right}{border right}
\item{part}{part selector, see section \emph{Part selection with the \code{part}
parameter} in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.
Value 'all' can be used.}
}
\description{
change borders of selected rows and columns of a flextable.
This function is \strong{not to be used by end user} (it requires careful
settings to avoid overlapping borders) but only for programming purposes.
If you need to add borders, use instead other functions:
These set borders for the whole table : \code{\link[=border_outer]{border_outer()}},
\code{\link[=border_inner_h]{border_inner_h()}} and \code{\link[=border_inner_v]{border_inner_v()}}.
To add horizontal or vertical lines in the table at specific location,
use:
\itemize{
\item \code{\link[=hline]{hline()}}: set bottom borders (inner horizontal)
\item \code{\link[=vline]{vline()}}: set right borders (inner vertical)
}
To add following horizontal or vertical lines at
beginning or end of the table, use:
\itemize{
\item \code{\link[=hline_top]{hline_top()}}: set the top border (outer horizontal)
\item \code{\link[=hline_bottom]{hline_bottom()}}: set the bottom border (outer horizontal)
\item \code{\link[=vline_left]{vline_left()}}: set the left border (outer vertical)
\item \code{\link[=vline_right]{vline_right()}}: set the right border (outer vertical)
}
If you want to highlight specific cells with some borders, use
\code{\link[=surround]{surround()}}.
}
\note{
pdf and pptx outputs do not support \code{border()} usage.
}
\examples{
library(officer)
ftab <- flextable(head(mtcars))
ftab <- border(ftab, border.top = fp_border(color = "orange"))
ftab
}
\keyword{internal}
flextable/man/args_x_i_part.Rd 0000644 0001762 0000144 00000001305 15131745533 016111 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/doc-selectors.R
\name{args_x_i_part}
\alias{args_x_i_part}
\title{internal utils for roxygen tags reuse}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
\item{i}{row selector, see section \emph{Row selection with the \code{i} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{part}{part selector, see section \emph{Part selection with the \code{part}
parameter} in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.
Value 'all' can be used.}
}
\description{
internal utils for roxygen tags reuse
}
\keyword{internal}
flextable/man/save_as_image.Rd 0000644 0001762 0000144 00000003606 15140411452 016047 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/printers.R
\name{save_as_image}
\alias{save_as_image}
\title{Save a flextable in a 'png' or 'svg' file}
\usage{
save_as_image(x, path, expand = 10, res = 200, ...)
}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
\item{path}{image file to be created. It should end with '.png'
or '.svg'.}
\item{expand}{space in pixels to add around the table.}
\item{res}{The resolution of the device}
\item{...}{unused arguments}
}
\value{
a string containing the full name of the generated file
}
\description{
Save a flextable as a png or svg image.
This function uses R graphic system to create an image from the flextable,
allowing for high-quality image output. See \code{\link[=gen_grob]{gen_grob()}} for more options.
}
\section{caption}{
It's important to note that captions are not part of the table itself.
This means when exporting a table to PNG or SVG formats (image formats),
the caption won't be included. Captions are intended for document outputs
like Word, HTML, or PDF, where tables are embedded within the document
itself.
}
\examples{
library(gdtools)
register_liberationsans()
set_flextable_defaults(font.family = "Liberation Sans")
ft <- flextable(head(mtcars))
ft <- autofit(ft)
tf <- tempfile(fileext = ".png")
save_as_image(x = ft, path = tf)
init_flextable_defaults()
}
\seealso{
Other flextable print function:
\code{\link{df_printer}()},
\code{\link{flextable_to_rmd}()},
\code{\link{gen_grob}()},
\code{\link{htmltools_value}()},
\code{\link{knit_print.flextable}()},
\code{\link{plot.flextable}()},
\code{\link{print.flextable}()},
\code{\link{save_as_docx}()},
\code{\link{save_as_html}()},
\code{\link{save_as_pptx}()},
\code{\link{save_as_rtf}()},
\code{\link{to_html.flextable}()},
\code{\link{wrap_flextable}()}
}
\concept{flextable print function}
flextable/man/padding.Rd 0000644 0001762 0000144 00000004446 15142453603 014703 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/styles.R
\name{padding}
\alias{padding}
\title{Set paragraph paddings}
\usage{
padding(
x,
i = NULL,
j = NULL,
padding = NULL,
padding.top = NULL,
padding.bottom = NULL,
padding.left = NULL,
padding.right = NULL,
part = "body"
)
}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
\item{i}{row selector, see section \emph{Row selection with the \code{i} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{j}{column selector, see section \emph{Column selection with the \code{j} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{padding}{padding (shortcut for top, bottom, left and right), unit is pts (points).}
\item{padding.top}{padding top, unit is pts (points).}
\item{padding.bottom}{padding bottom, unit is pts (points).}
\item{padding.left}{padding left, unit is pts (points).}
\item{padding.right}{padding right, unit is pts (points).}
\item{part}{part selector, see section \emph{Part selection with the \code{part}
parameter} in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.
Value 'all' can be used.}
}
\description{
Change the padding of selected rows and columns of a flextable.
}
\note{
Padding is not implemented in PDF due to technical infeasibility but
it can be replaced with \code{set_table_properties(opts_pdf = list(tabcolsep = 1))}.
}
\examples{
ft_1 <- flextable(head(iris))
ft_1 <- theme_vader(ft_1)
ft_1 <- padding(ft_1, padding.top = 4, part = "all")
ft_1 <- padding(ft_1, j = 1, padding.right = 40)
ft_1 <- padding(ft_1, i = 3, padding.top = 40)
ft_1 <- padding(ft_1, padding.top = 10, part = "header")
ft_1 <- padding(ft_1, padding.bottom = 10, part = "header")
ft_1 <- autofit(ft_1)
ft_1
}
\seealso{
Other sugar functions for table style:
\code{\link{align}()},
\code{\link{bg}()},
\code{\link{bold}()},
\code{\link{color}()},
\code{\link{empty_blanks}()},
\code{\link{font}()},
\code{\link{fontsize}()},
\code{\link{highlight}()},
\code{\link{italic}()},
\code{\link{keep_with_next}()},
\code{\link{line_spacing}()},
\code{\link{rotate}()},
\code{\link{style}()},
\code{\link{tab_settings}()},
\code{\link{valign}()}
}
\concept{sugar functions for table style}
flextable/man/as_highlight.Rd 0000644 0001762 0000144 00000002543 15143067476 015735 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/05_content.R
\name{as_highlight}
\alias{as_highlight}
\title{Highlight chunk}
\usage{
as_highlight(x, color)
}
\arguments{
\item{x}{value, if a chunk, the chunk will be updated}
\item{color}{color to use as text highlighting color as character vector.}
}
\description{
The function is producing a chunk with
an highlight chunk.
It is used to add it to the content of a cell of the
flextable with the functions \code{\link[=compose]{compose()}}, \code{\link[=append_chunks]{append_chunks()}}
or \code{\link[=prepend_chunks]{prepend_chunks()}}.
}
\examples{
ft <- flextable(head(iris),
col_keys = c("Sepal.Length", "dummy")
)
ft <- compose(ft,
j = "dummy",
value = as_paragraph(as_highlight(Sepal.Length, color = "yellow"))
)
ft
}
\seealso{
Other chunk elements for paragraph:
\code{\link{as_b}()},
\code{\link{as_bracket}()},
\code{\link{as_chunk}()},
\code{\link{as_equation}()},
\code{\link{as_i}()},
\code{\link{as_image}()},
\code{\link{as_qmd}()},
\code{\link{as_strike}()},
\code{\link{as_sub}()},
\code{\link{as_sup}()},
\code{\link{as_word_field}()},
\code{\link{colorize}()},
\code{\link{gg_chunk}()},
\code{\link{grid_chunk}()},
\code{\link{hyperlink_text}()},
\code{\link{linerange}()},
\code{\link{minibar}()},
\code{\link{plot_chunk}()}
}
\concept{chunk elements for paragraph}
flextable/man/args_x_part.Rd 0000644 0001762 0000144 00000001052 15131745533 015600 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/doc-selectors.R
\name{args_x_part}
\alias{args_x_part}
\title{internal utils for roxygen tags reuse}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
\item{part}{part selector, see section \emph{Part selection with the \code{part}
parameter} in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.
Value 'all' can be used.}
}
\description{
internal utils for roxygen tags reuse
}
\keyword{internal}
flextable/man/use_model_printer.Rd 0000644 0001762 0000144 00000001335 15142341701 017001 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/as_flextable.R
\name{use_model_printer}
\alias{use_model_printer}
\title{Set automatic flextable printing for models}
\usage{
use_model_printer()
}
\description{
Define \code{\link[=as_flextable]{as_flextable()}} as
print method in an R Markdown document for models
of class:
\itemize{
\item lm
\item glm
\item models from package 'lme' and 'lme4'
\item htest (t.test, chisq.test, ...)
\item gam
\item kmeans and pam
}
In a setup run chunk:
\if{html}{\out{Wa ¿2Q4 a Yܘi4eik3NXr4 )u_ rqĶ/`t#oeS]Vڇw@8KxH!Nұvj;Fſ&bA}VJlI7LؓDcFWQ|`P #vba=⎡m_AwiLjHu]ׯL:#1I 0%E
n Cs5 $ GzB:B+Y8İ݀z0 bc0 aw*f>C OFi oH
mx¯*
}%|I[Q}̰
B.@I;]- m7 @ K ;=}gxqE 88Qz%7qh8DFnjQn]b낈CT"/ (?vUW=wsN=Yyq_}Jz 3۟.D&B}|mTuh.ObM~2cD#Tu8tnjF"//u_ ?_:#4%bNńsC *Ĉ61BSMV<6'&~r>>z(ůxIZe"X7t #R:S`R2FHj2a| DT6hAL-, RԬRZS))0FH#$5r0>H[ .FT(M0.-eN)8%릔TcAJo"#$5j0>H%[SUg> l%
iRL-F řZ| cHIM#R͉O.N4yo%4?iYRY7ŚR0>H5 iьL)F
s!]Q=NQZϦTM%F śJ| c IM#$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$IҺrG%nRQ#Lx4 W
l a1v1VZ#6>\AX]GG|5FT9 ~xI䴌ZRcc1BӶQ3qC> |pnZ75`eu}8TVZ#Ҳ|f0>hب1& {YĴZRcc1BӷQ)3R_$#80< ؞
<4> t`g6|;8B/ xe îl Hh7}JmE1l?N$31_4̀Lb#Lj*O!,S ^3Fh=H]MFnC E}uuP|%i=Zߎcx7/( oz>+sLӦ-~,w.N궙W czp LӔڎNYGC.wZ0>R2F @B zݻ˙u=*Iq)ud: X\u3_ժ69I}G x.dW !4r.?~_~'2I. K0~ۯdVv2֊i>Burb =ay_SQoH7O+ Kط ZڴŏO6 ` Y f
i(1{g,siߋEcJd7Z1n:%>LǴqMeH RGR3˺_: W^\1h֘3ydWBx2WȖy|+R@I_}د w]ꋲ(4هG s9C%GB̀߰{_7m# 4C^||pFwu~$ݝ|1f:4
) ӝ^JS14#M VbLbfZ''# _,8kqjLwE!ߴcYƱBdfO[2ӛ= N:Y#k[1 ͟!e_=cmf?ԐK@Ry^f>q%iI A@=G ;yb\.OC O
^_ S19+mB͙uNn|[89t]um?ڜ e*gE]ň1ce>zڳy0F iZ2D=0812E2vÿY缡ߴcY9,c̕k ?k3NӮl$zWMZ+7_.Ɯ_ پhܼT l$<)MH|JLCo&n'4+}*X k%k]GZzSDJDmcY,/>̈́pPi^XH^_B}~i06> ҧnȭ7y?i>;4cƨg)A%zS-Xe ̓1H2ȼ!$ ~O@aB।EYY:)u#sߴcUƱܐ mb][lqݟIgŀ4ˤv ُ|3*R1 .C| ue^PcWfڳc+NvƇ5/J 1^ݟpO7Hd TPDp!NZl;緁06`_Kr|Ih9?',bN1f _eaI-ch#M RlLwJ>}cen0Fi-nM :M>Xe +F.g] ,nuq 4+|}4+y 
}}
}
\note{
This is very first version of the function; be aware it
can evolve or change.
}
\examples{
\dontshow{
data.table::setDTthreads(1)
}
z <- summarizor(CO2[-c(1, 4)],
by = "Treatment",
overall_label = "Overall"
)
ft_1 <- as_flextable(z)
ft_1
ft_2 <- as_flextable(z, sep_w = 0, spread_first_col = TRUE)
ft_2
z <- summarizor(CO2[-c(1, 4)])
ft_3 <- as_flextable(z, sep_w = 0, spread_first_col = TRUE)
ft_3
}
\seealso{
\code{\link[=fmt_summarizor]{fmt_summarizor()}}, \code{\link[=labelizor]{labelizor()}}
}
flextable/man/fp_text_default.Rd 0000644 0001762 0000144 00000006062 15142341701 016441 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/defaults.R
\name{fp_text_default}
\alias{fp_text_default}
\title{Create text formatting with flextable defaults}
\usage{
fp_text_default(
color = flextable_global$defaults$font.color,
font.size = flextable_global$defaults$font.size,
bold = FALSE,
italic = FALSE,
underlined = FALSE,
strike = FALSE,
font.family = flextable_global$defaults$font.family,
cs.family = NULL,
eastasia.family = NULL,
hansi.family = NULL,
vertical.align = "baseline",
shading.color = "transparent"
)
}
\arguments{
\item{color}{font color - a single character value specifying
a valid color (e.g. "#000000" or "black").}
\item{font.size}{font size (in point) - 0 or positive integer value.}
\item{bold}{is bold}
\item{italic}{is italic}
\item{underlined}{is underlined}
\item{strike}{is strikethrough}
\item{font.family}{single character value. Specifies the font to
be used to format characters in the Unicode range (U+0000-U+007F).}
\item{cs.family}{optional font to be used to format
characters in a complex script Unicode range. For example, Arabic
text might be displayed using the "Arial Unicode MS" font.}
\item{eastasia.family}{optional font to be used to
format characters in an East Asian Unicode range. For example,
Japanese text might be displayed using the "MS Mincho" font.}
\item{hansi.family}{optional. Specifies the font to be used to format
characters in a Unicode range which does not fall into one of the
other categories.}
\item{vertical.align}{single character value specifying font vertical alignments.
Expected value is one of the following : default \code{'baseline'}
or \code{'subscript'} or \code{'superscript'}}
\item{shading.color}{shading color - a single character value specifying
a valid color (e.g. "#000000" or "black").}
}
\description{
Create a \code{\link[officer:fp_text]{officer::fp_text()}} object whose unspecified
arguments inherit from \code{\link[=set_flextable_defaults]{set_flextable_defaults()}} (font family, size, color).
Use \code{fp_text_default()} instead of \code{officer::fp_text()} when building
chunks with \code{\link[=as_chunk]{as_chunk()}}: only override the properties you need,
and the rest will match the table's default style.
See also \code{\link[=set_flextable_defaults]{set_flextable_defaults()}} to modify the inherited values.
}
\examples{
library(flextable)
set_flextable_defaults(
font.size = 11, font.color = "#303030",
padding = 3, table.layout = "autofit"
)
z <- flextable(head(cars))
z <- compose(
x = z,
i = ~ speed < 6,
j = "speed",
value = as_paragraph(
as_chunk("slow... ", props = fp_text_default(color = "red")),
as_chunk(speed, props = fp_text_default(italic = TRUE))
)
)
z
init_flextable_defaults()
}
\seealso{
\code{\link[=as_chunk]{as_chunk()}}, \code{\link[=compose]{compose()}}, \code{\link[=append_chunks]{append_chunks()}}, \code{\link[=prepend_chunks]{prepend_chunks()}}
Other functions for defining formatting properties:
\code{\link{fp_border_default}()}
}
\concept{functions for defining formatting properties}
flextable/man/as_i.Rd 0000644 0001762 0000144 00000002334 15143067476 014214 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/05_content.R
\name{as_i}
\alias{as_i}
\title{Italic chunk}
\usage{
as_i(x)
}
\arguments{
\item{x}{value, if a chunk, the chunk will be updated}
}
\description{
The function is producing a chunk with
italic font.
It is used to add it to the content of a cell of the
flextable with the functions \code{\link[=compose]{compose()}}, \code{\link[=append_chunks]{append_chunks()}}
or \code{\link[=prepend_chunks]{prepend_chunks()}}.
}
\examples{
ft <- flextable(head(iris),
col_keys = c("Sepal.Length", "dummy")
)
ft <- compose(ft,
j = "dummy",
value = as_paragraph(as_i(Sepal.Length))
)
ft
}
\seealso{
Other chunk elements for paragraph:
\code{\link{as_b}()},
\code{\link{as_bracket}()},
\code{\link{as_chunk}()},
\code{\link{as_equation}()},
\code{\link{as_highlight}()},
\code{\link{as_image}()},
\code{\link{as_qmd}()},
\code{\link{as_strike}()},
\code{\link{as_sub}()},
\code{\link{as_sup}()},
\code{\link{as_word_field}()},
\code{\link{colorize}()},
\code{\link{gg_chunk}()},
\code{\link{grid_chunk}()},
\code{\link{hyperlink_text}()},
\code{\link{linerange}()},
\code{\link{minibar}()},
\code{\link{plot_chunk}()}
}
\concept{chunk elements for paragraph}
flextable/man/hrule.Rd 0000644 0001762 0000144 00000004255 15142341701 014405 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/flextable_sizes.R
\name{hrule}
\alias{hrule}
\title{Set how row heights are determined}
\usage{
hrule(x, i = NULL, rule = "auto", part = "body")
}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
\item{i}{row selector, see section \emph{Row selection with the \code{i} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{rule}{specify the meaning of the height. Possible values
are "atleast" (height should be at least the value specified), "exact"
(height should be exactly the value specified), or the default value "auto"
(height is determined based on the height of the contents, so the value is ignored).}
\item{part}{part selector, see section \emph{Part selection with the \code{part}
parameter} in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.
Value 'all' can be used.}
}
\description{
\code{hrule()} controls whether row heights are automatic,
minimum or fixed. This only affects Word and PowerPoint
outputs; it has no effect on HTML or PDF.
\itemize{
\item \code{"auto"} (default): the row height adjusts to fit the
content; any value set by \code{\link[=height]{height()}} is ignored.
\item \code{"atleast"}: the row is at least as tall as the value
set by \code{\link[=height]{height()}}, but can grow if the content is taller.
\item \code{"exact"}: the row is exactly the height set by
\code{\link[=height]{height()}}; content that overflows is clipped.
}
For PDF see the \code{ft.arraystretch} chunk option.
}
\examples{
ft_1 <- flextable(head(iris))
ft_1 <- width(ft_1, width = 1.5)
ft_1 <- height(ft_1, height = 0.75, part = "header")
ft_1 <- hrule(ft_1, rule = "exact", part = "header")
ft_1
ft_2 <- hrule(ft_1, rule = "auto", part = "header")
ft_2
}
\seealso{
Other functions for flextable size management:
\code{\link{autofit}()},
\code{\link{dim.flextable}()},
\code{\link{dim_pretty}()},
\code{\link{fit_to_width}()},
\code{\link{flextable_dim}()},
\code{\link{height}()},
\code{\link{ncol_keys}()},
\code{\link{nrow_part}()},
\code{\link{width}()}
}
\concept{functions for flextable size management}
flextable/man/regulartable.Rd 0000644 0001762 0000144 00000001412 15131745533 015740 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/flextable.R
\name{regulartable}
\alias{regulartable}
\title{flextable old functions}
\usage{
regulartable(data, col_keys = names(data), cwidth = 0.75, cheight = 0.25)
}
\arguments{
\item{data}{dataset}
\item{col_keys}{columns names/keys to display. If some column names are not in
the dataset, they will be added as blank columns by default.}
\item{cwidth, cheight}{initial width and height to use for cell sizes in inches.}
}
\description{
The function is maintained for compatibility with old codes
mades by users but be aware it produces the same exact object than \code{\link[=flextable]{flextable()}}.
This function should be deprecated then removed in the next versions.
}
\keyword{internal}
flextable/man/as_flextable.pam.Rd 0000644 0001762 0000144 00000002540 15137666130 016500 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/as_flextable.R
\name{as_flextable.pam}
\alias{as_flextable.pam}
\title{Transform a 'pam' object into a flextable}
\usage{
\method{as_flextable}{pam}(x, digits = 4, ...)
}
\arguments{
\item{x}{a \code{\link[cluster:pam]{cluster::pam()}} object}
\item{digits}{number of digits for the numeric columns}
\item{...}{unused argument}
}
\description{
produce a flextable describing a
pam object. The function is only using package 'broom'
that provides the data presented in the resulting flextable.
}
\examples{
if (require("cluster")) {
dat <- as.data.frame(scale(mtcars[1:7]))
cl <- pam(dat, 3)
ft <- as_flextable(cl)
ft
}
}
\seealso{
Other as_flextable methods:
\code{\link{as_flextable}()},
\code{\link{as_flextable.compact_summary}()},
\code{\link{as_flextable.data.frame}()},
\code{\link{as_flextable.gam}()},
\code{\link{as_flextable.glm}()},
\code{\link{as_flextable.grouped_data}()},
\code{\link{as_flextable.htest}()},
\code{\link{as_flextable.kmeans}()},
\code{\link{as_flextable.lm}()},
\code{\link{as_flextable.merMod}()},
\code{\link{as_flextable.summarizor}()},
\code{\link{as_flextable.table}()},
\code{\link{as_flextable.tabular}()},
\code{\link{as_flextable.tabulator}()},
\code{\link{as_flextable.xtable}()},
\code{\link{compact_summary}()}
}
\concept{as_flextable methods}
flextable/man/as_flextable.gam.Rd 0000644 0001762 0000144 00000002675 15137666130 016500 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/as_flextable_gam.R
\name{as_flextable.gam}
\alias{as_flextable.gam}
\title{Transform a 'gam' model into a flextable}
\usage{
\method{as_flextable}{gam}(x, ...)
}
\arguments{
\item{x}{gam model}
\item{...}{unused argument}
}
\description{
produce a flextable describing a
generalized additive model produced by function \code{mgcv::gam}.
\if{html}{\out{
}}
}
\examples{
if (require("mgcv")) {
set.seed(2)
# Simulated data
dat <- gamSim(1, n = 400, dist = "normal", scale = 2)
# basic GAM model
b <- gam(y ~ s(x0) + s(x1) + s(x2) + s(x3), data = dat)
ft <- as_flextable(b)
ft
}
}
\seealso{
Other as_flextable methods:
\code{\link{as_flextable}()},
\code{\link{as_flextable.compact_summary}()},
\code{\link{as_flextable.data.frame}()},
\code{\link{as_flextable.glm}()},
\code{\link{as_flextable.grouped_data}()},
\code{\link{as_flextable.htest}()},
\code{\link{as_flextable.kmeans}()},
\code{\link{as_flextable.lm}()},
\code{\link{as_flextable.merMod}()},
\code{\link{as_flextable.pam}()},
\code{\link{as_flextable.summarizor}()},
\code{\link{as_flextable.table}()},
\code{\link{as_flextable.tabular}()},
\code{\link{as_flextable.tabulator}()},
\code{\link{as_flextable.xtable}()},
\code{\link{compact_summary}()}
}
\concept{as_flextable methods}
flextable/man/theme_vader.Rd 0000644 0001762 0000144 00000004135 15142312712 015546 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/themes.R
\name{theme_vader}
\alias{theme_vader}
\title{Apply Sith Lord Darth Vader theme}
\usage{
theme_vader(x, ...)
}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
\item{...}{unused}
}
\description{
Apply Sith Lord Darth Vader theme to a flextable
}
\section{behavior}{
Theme functions are not like 'ggplot2' themes. They are applied to the existing
table \strong{immediately}. If you add a row in the footer, the new row is not formatted
with the theme. The theme function applies the theme only to existing elements
when the function is called.
That is why theme functions should be applied after all elements of the table
have been added (mainly additionnal header or footer rows).
If you want to automatically apply a theme function to each flextable,
you can use the \code{theme_fun} argument of \code{\link[=set_flextable_defaults]{set_flextable_defaults()}}; be
aware that this theme function is applied as the last instruction when
calling \code{flextable()} - so if you add headers or footers to the array,
they will not be formatted with the theme.
You can also use the \code{post_process_html} argument
of \code{\link[=set_flextable_defaults]{set_flextable_defaults()}} (or \code{post_process_pdf},
\code{post_process_docx}, \code{post_process_pptx}) to specify a theme
to be applied systematically before the \code{flextable()} is printed;
in this case, don't forget to take care that the theme doesn't
override any formatting done before the print statement.
}
\examples{
ft <- flextable(head(airquality))
ft <- theme_vader(ft)
ft
}
\seealso{
Other functions related to themes:
\code{\link{get_flextable_defaults}()},
\code{\link{set_flextable_defaults}()},
\code{\link{theme_alafoli}()},
\code{\link{theme_apa}()},
\code{\link{theme_booktabs}()},
\code{\link{theme_borderless}()},
\code{\link{theme_box}()},
\code{\link{theme_tron}()},
\code{\link{theme_tron_legacy}()},
\code{\link{theme_vanilla}()},
\code{\link{theme_zebra}()}
}
\concept{functions related to themes}
flextable/man/colformat_num.Rd 0000644 0001762 0000144 00000006010 15142453603 016127 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/formatters.R
\name{colformat_num}
\alias{colformat_num}
\title{Format numeric cells with format()}
\usage{
colformat_num(
x,
i = NULL,
j = NULL,
big.mark = get_flextable_defaults()$big.mark,
decimal.mark = get_flextable_defaults()$decimal.mark,
na_str = get_flextable_defaults()$na_str,
nan_str = get_flextable_defaults()$nan_str,
prefix = "",
suffix = "",
...
)
}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
\item{i}{row selector, see section \emph{Row selection with the \code{i} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{j}{column selector, see section \emph{Column selection with the \code{j} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{big.mark, decimal.mark}{see \code{\link[=format]{format()}}}
\item{na_str, nan_str}{string to be used for NA and NaN values}
\item{prefix, suffix}{string to be used as prefix or suffix}
\item{...}{additional argument for function \code{\link[=format]{format()}}, \code{scientific}
and \code{digits} can not be used.}
}
\description{
Format numeric cells in a flextable
using R's \code{\link[=format]{format()}} function.
The function is different from \code{\link[=colformat_double]{colformat_double()}} on numeric type
columns. The function uses the \code{\link[=format]{format()}} function of R on numeric
type columns. So this is normally what you see on the R console
most of the time (but scientific mode is disabled and NA are replaced).
}
\section{format call}{
Function \code{\link[=format]{format()}} is called with the following values:
\itemize{
\item \code{trim} is set to TRUE,
\item \code{scientific} is set to FALSE,
\item \code{big.mark} is set to the value of \code{big.mark} argument,
\item \code{decimal.mark} is set to the value of \code{decimal.mark} argument,
\item other arguments are passed 'as is' to the format function.
}
argument \code{digits} is ignored as it is not the same \code{digits} that users
want, this one will be used by \code{\link[=format]{format()}} and not \code{\link[=formatC]{formatC()}}.
To change the digit argument use \code{options(digits=4)} instead.
This argument will not be changed because \code{colformat_num()}
is supposed to format things roughly as what you see on the R console.
If these functions does not fit your needs, use \code{\link[=set_formatter]{set_formatter()}}
that lets you use any format function.
}
\examples{
dat <- mtcars
dat[2, 1] <- NA
ft <- flextable(head(dat))
ft <- colformat_num(
x = ft,
big.mark = " ", decimal.mark = ",",
na_str = "N/A"
)
ft <- autofit(ft)
ft
}
\seealso{
Other cells formatters:
\code{\link{colformat_char}()},
\code{\link{colformat_date}()},
\code{\link{colformat_datetime}()},
\code{\link{colformat_double}()},
\code{\link{colformat_image}()},
\code{\link{colformat_int}()},
\code{\link{colformat_lgl}()},
\code{\link{set_formatter}()}
}
\concept{cells formatters}
flextable/man/merge_at.Rd 0000644 0001762 0000144 00000002372 15142453603 015054 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/merge_flextable.R
\name{merge_at}
\alias{merge_at}
\title{Merge flextable cells into a single one}
\usage{
merge_at(x, i = NULL, j = NULL, part = "body")
}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
\item{i}{row selector, see section \emph{Row selection with the \code{i} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{j}{column selector, see section \emph{Column selection with the \code{j} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{part}{part selector, see section \emph{Part selection with the \code{part}
parameter} in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.
Value 'all' is not allowed by the function.}
}
\description{
Merge flextable cells into a single one. All
rows and columns must be consecutive.
}
\examples{
ft_merge <- flextable(head(mtcars), cwidth = .5)
ft_merge <- merge_at(ft_merge, i = 1:2, j = 1:2)
ft_merge
}
\seealso{
Other flextable merging function:
\code{\link{merge_h}()},
\code{\link{merge_h_range}()},
\code{\link{merge_none}()},
\code{\link{merge_v}()}
}
\concept{flextable merging function}
flextable/man/font.Rd 0000644 0001762 0000144 00000006070 15142453603 014236 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/styles.R
\name{font}
\alias{font}
\title{Set font}
\usage{
font(
x,
i = NULL,
j = NULL,
fontname,
part = "body",
cs.family = fontname,
hansi.family = fontname,
eastasia.family = fontname
)
}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
\item{i}{row selector, see section \emph{Row selection with the \code{i} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{j}{column selector, see section \emph{Column selection with the \code{j} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{fontname}{single character value, the font family name.
With Word and PowerPoint output, this value specifies the font to
be used for formatting characters in the Unicode range (U+0000-U+007F).}
\item{part}{part selector, see section \emph{Part selection with the \code{part}
parameter} in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.
Value 'all' can be used.}
\item{cs.family}{Optional font to be used for formatting
characters in a complex script Unicode range. For example, Arabic
text might be displayed using the "Arial Unicode MS" font.
Used only with Word and PowerPoint outputs. The default value is the value
of \code{fontname}.}
\item{hansi.family}{Optional font to be used for formatting
characters in a Unicode range that does not fall into one of the
other categories.
Used only with Word and PowerPoint outputs. The default value is the value
of \code{fontname}.}
\item{eastasia.family}{Optional font to be used for
formatting characters in an East Asian Unicode range. For example,
Japanese text might be displayed using the "MS Mincho" font.
Used only with Word and PowerPoint outputs. The default value is the value
of \code{fontname}.}
}
\description{
Change the font of selected rows and columns of a flextable.
Fonts impact the readability and aesthetics of the table. Font families
refer to a set of typefaces that share common design features, such as 'Arial'
and 'Open Sans'.
'Google Fonts' is a popular library of free web fonts that can be
easily integrated into flextable with the \code{\link[gdtools:register_gfont]{gdtools::register_gfont()}} function.
When the output is HTML, the font will be automatically added to the HTML
document.
}
\examples{
library(gdtools)
fontname <- "Brush Script MT"
if (font_family_exists(fontname)) {
ft_1 <- flextable(head(iris))
ft_2 <- font(ft_1, fontname = fontname, part = "header")
ft_2 <- font(ft_2, fontname = fontname, j = 5)
ft_2
}
}
\seealso{
Other sugar functions for table style:
\code{\link{align}()},
\code{\link{bg}()},
\code{\link{bold}()},
\code{\link{color}()},
\code{\link{empty_blanks}()},
\code{\link{fontsize}()},
\code{\link{highlight}()},
\code{\link{italic}()},
\code{\link{keep_with_next}()},
\code{\link{line_spacing}()},
\code{\link{padding}()},
\code{\link{rotate}()},
\code{\link{style}()},
\code{\link{tab_settings}()},
\code{\link{valign}()}
}
\concept{sugar functions for table style}
flextable/man/fmt_int.Rd 0000644 0001762 0000144 00000001536 15142341701 014725 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/summarizor.R
\name{fmt_int}
\alias{fmt_int}
\title{Format numbers as integers}
\usage{
fmt_int(x)
}
\arguments{
\item{x}{numeric values}
}
\description{
Format numeric values as integers (no decimals).
}
\examples{
library(flextable)
df <- data.frame(zz = 1.23)
ft_1 <- flextable(df)
ft_1 <- mk_par(
x = ft_1, j = 1, part = "body",
value = as_paragraph(as_chunk(zz, formatter = fmt_int))
)
ft_1 <- autofit(ft_1)
ft_1
}
\seealso{
\code{\link[=tabulator]{tabulator()}}, \code{\link[=mk_par]{mk_par()}}
Other text formatter functions:
\code{\link{fmt_2stats}()},
\code{\link{fmt_avg_dev}()},
\code{\link{fmt_dbl}()},
\code{\link{fmt_header_n}()},
\code{\link{fmt_n_percent}()},
\code{\link{fmt_pct}()},
\code{\link{fmt_signif_after_zeros}()}
}
\concept{text formatter functions}
flextable/man/merge_none.Rd 0000644 0001762 0000144 00000002306 15142341701 015377 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/merge_flextable.R
\name{merge_none}
\alias{merge_none}
\title{Delete flextable merging information}
\usage{
merge_none(x, part = "all")
}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
\item{part}{part selector, see section \emph{Part selection with the \code{part}
parameter} in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.
Value 'all' can be used.}
}
\description{
Delete all merging information from a flextable.
}
\examples{
typology <- data.frame(
col_keys = c("Sepal.Length", "Sepal.Width", "Petal.Length", "Petal.Width", "Species"),
what = c("Sepal", "Sepal", "Petal", "Petal", "Species"),
measure = c("Length", "Width", "Length", "Width", "Species"),
stringsAsFactors = FALSE
)
ft <- flextable(head(iris))
ft <- set_header_df(ft, mapping = typology, key = "col_keys")
ft <- merge_v(ft, j = c("Species"))
ft <- theme_tron_legacy(merge_none(ft))
ft
}
\seealso{
Other flextable merging function:
\code{\link{merge_at}()},
\code{\link{merge_h}()},
\code{\link{merge_h_range}()},
\code{\link{merge_v}()}
}
\concept{flextable merging function}
flextable/man/args_selectors_without_all.Rd 0000644 0001762 0000144 00000001617 15142453603 020724 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/doc-selectors.R
\name{args_selectors_without_all}
\alias{args_selectors_without_all}
\title{internal utils for roxygen tags reuse}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
\item{i}{row selector, see section \emph{Row selection with the \code{i} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{j}{column selector, see section \emph{Column selection with the \code{j} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{part}{part selector, see section \emph{Part selection with the \code{part}
parameter} in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.
Value 'all' is not allowed by the function.}
}
\description{
internal utils for roxygen tags reuse
}
\keyword{internal}
flextable/man/add_body.Rd 0000644 0001762 0000144 00000004401 15142341701 015024 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/augment_rows.R
\name{add_body}
\alias{add_body}
\title{Add body rows with one value per column}
\usage{
add_body(x, top = TRUE, ..., values = NULL)
}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
\item{top}{should the rows be inserted at the top or the bottom.}
\item{...}{named arguments (names are data colnames) of values
to add. It is important to insert data of the same type as the
original data, otherwise it will be transformed (probably
into strings if you add a \code{character} where a \code{double} is expected).
This makes possible to still format cell contents with the \verb{colformat_*}
functions, for example \code{\link[=colformat_num]{colformat_num()}}.}
\item{values}{a list of name-value pairs of labels or values,
names should be existing col_key values. This argument can be used
instead of \code{...} for programming purpose (If \code{values} is
supplied argument \code{...} is ignored).}
}
\description{
Add new rows to the body where each value maps to a named column,
preserving the original column data types.
Unlike \code{\link[=add_body_row]{add_body_row()}} where labels can span multiple columns,
here each value fills exactly one column.
If some columns are not provided, they will be replaced by
\code{NA} and displayed as empty.
}
\examples{
ft <- flextable(head(iris),
col_keys = c(
"Species", "Sepal.Length", "Petal.Length",
"Sepal.Width", "Petal.Width"
)
)
ft <- add_body(
x = ft, Sepal.Length = 1:5,
Sepal.Width = 1:5 * 2, Petal.Length = 1:5 * 3,
Petal.Width = 1:5 + 10, Species = "Blah", top = FALSE
)
ft <- theme_booktabs(ft)
ft
}
\seealso{
\code{\link[=flextable]{flextable()}}
Other functions for row and column operations in a flextable:
\code{\link{add_body_row}()},
\code{\link{add_footer}()},
\code{\link{add_footer_lines}()},
\code{\link{add_footer_row}()},
\code{\link{add_header}()},
\code{\link{add_header_lines}()},
\code{\link{add_header_row}()},
\code{\link{delete_columns}()},
\code{\link{delete_part}()},
\code{\link{separate_header}()},
\code{\link{set_header_footer_df}},
\code{\link{set_header_labels}()}
}
\concept{functions for row and column operations in a flextable}
flextable/man/hline_bottom.Rd 0000644 0001762 0000144 00000003361 15142453603 015753 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/borders.R
\name{hline_bottom}
\alias{hline_bottom}
\title{Set the bottom border of a table part}
\usage{
hline_bottom(x, j = NULL, border = NULL, part = "body")
}
\arguments{
\item{x}{a 'flextable' object, see \link{flextable-package} to learn how to create
'flextable' object.}
\item{j}{column selector, see section \emph{Column selection with the \code{j} parameter}
in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.}
\item{border}{border properties defined by a call to
\code{\link[officer:fp_border]{officer::fp_border()}}}
\item{part}{part selector, see section \emph{Part selection with the \code{part}
parameter} in <\code{\link[=flextable_selectors]{Selectors in flextable}}>.
Value 'all' can be used.}
}
\description{
\code{hline_bottom()} draws a horizontal line at the \strong{very bottom}
of a table part. It does not accept a row selector \code{i} because
it always targets the last row.
Unlike \code{\link[=hline]{hline()}}, which adds inner lines below arbitrary rows,
\code{hline_bottom()} is meant for the outer bottom edge of a part.
}
\examples{
library(officer)
big_border <- fp_border(color = "orange", width = 3)
ft <- flextable(head(iris))
ft <- border_remove(x = ft)
# add a thick line at the bottom of the body
ft <- hline_bottom(ft, part = "body", border = big_border)
ft
}
\seealso{
Other borders management:
\code{\link{border_inner}()},
\code{\link{border_inner_h}()},
\code{\link{border_inner_v}()},
\code{\link{border_outer}()},
\code{\link{border_remove}()},
\code{\link{hline}()},
\code{\link{hline_top}()},
\code{\link{surround}()},
\code{\link{vline}()},
\code{\link{vline_left}()},
\code{\link{vline_right}()}
}
\concept{borders management}
flextable/man/grid_chunk.Rd 0000644 0001762 0000144 00000003555 15143067476 015424 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/chunk_images.R
\name{grid_chunk}
\alias{grid_chunk}
\title{Grid Graphics chunk}
\usage{
grid_chunk(value, width = 1, height = 0.2, unit = "in", res = 300)
}
\arguments{
\item{value}{grid objects, stored in a list column; or a list
of grid objects.}
\item{width, height}{size of the resulting png file}
\item{unit}{unit for width and height, one of "in", "cm", "mm".}
\item{res}{resolution of the png image in ppi}
}
\description{
This function is used to insert grid objects into
flextable with functions:
\itemize{
\item \code{\link[=compose]{compose()}} and \code{\link[=as_paragraph]{as_paragraph()}},
\item \code{\link[=append_chunks]{append_chunks()}},
\item \code{\link[=prepend_chunks]{prepend_chunks()}}.
}
}
\note{
This chunk option requires package officedown in a R Markdown
context with Word output format.
PowerPoint cannot mix images and text in a paragraph, images
are removed when outputing to PowerPoint format.
}
\examples{
library(flextable)
ft_1 <- flextable(head(cars))
if (require("grid")) {
ft_1 <- prepend_chunks(
x = ft_1, i = 2, j = 2,
grid_chunk(
list(
circleGrob(gp = gpar(
fill = "#ec11c2",
col = "transparent"
))
),
width = .15, height = .15
)
)
}
ft_1
}
\seealso{
Other chunk elements for paragraph:
\code{\link{as_b}()},
\code{\link{as_bracket}()},
\code{\link{as_chunk}()},
\code{\link{as_equation}()},
\code{\link{as_highlight}()},
\code{\link{as_i}()},
\code{\link{as_image}()},
\code{\link{as_qmd}()},
\code{\link{as_strike}()},
\code{\link{as_sub}()},
\code{\link{as_sup}()},
\code{\link{as_word_field}()},
\code{\link{colorize}()},
\code{\link{gg_chunk}()},
\code{\link{hyperlink_text}()},
\code{\link{linerange}()},
\code{\link{minibar}()},
\code{\link{plot_chunk}()}
}
\concept{chunk elements for paragraph}
flextable/man/fmt_n_percent.Rd 0000644 0001762 0000144 00000002607 15142341701 016110 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/summarizor.R
\name{fmt_n_percent}
\alias{fmt_n_percent}
\title{Format count and percentage as text}
\usage{
fmt_n_percent(n, pct, digit = 1)
}
\arguments{
\item{n}{count values}
\item{pct}{percent values}
\item{digit}{number of digits for the percentages}
}
\description{
Format counts and percentages as \verb{n (xx.x\%)}.
If percentages are missing, only the count is shown.
}
\examples{
library(flextable)
df <- structure(
list(
cut = structure(
.Data = 1:5, levels = c(
"Fair", "Good", "Very Good", "Premium", "Ideal"
),
class = c("ordered", "factor")
),
n = c(1610L, 4906L, 12082L, 13791L, 21551L),
pct = c(0.0299, 0.0909, 0.2239, 0.2557, 0.3995)
),
row.names = c(NA, -5L),
class = "data.frame"
)
ft_1 <- flextable(df, col_keys = c("cut", "txt"))
ft_1 <- mk_par(
x = ft_1, j = "txt",
value = as_paragraph(fmt_n_percent(n, pct))
)
ft_1 <- align(ft_1, j = "txt", part = "all", align = "right")
ft_1 <- autofit(ft_1)
ft_1
}
\seealso{
\code{\link[=tabulator]{tabulator()}}, \code{\link[=mk_par]{mk_par()}}
Other text formatter functions:
\code{\link{fmt_2stats}()},
\code{\link{fmt_avg_dev}()},
\code{\link{fmt_dbl}()},
\code{\link{fmt_header_n}()},
\code{\link{fmt_int}()},
\code{\link{fmt_pct}()},
\code{\link{fmt_signif_after_zeros}()}
}
\concept{text formatter functions}
flextable/DESCRIPTION 0000644 0001762 0000144 00000005754 15143546032 013744 0 ustar ligges users Type: Package
Package: flextable
Title: Functions for Tabular Reporting
Version: 0.9.11
Authors@R: c(
person("David", "Gohel", , "david.gohel@ardata.fr", role = c("aut", "cre")),
person("ArData", role = "cph"),
person("Clementine", "Jager", role = "ctb"),
person("Eli", "Daniels", role = "ctb"),
person("Panagiotis", "Skintzos", , "panagiotis.skintzos@ardata.fr", role = "aut"),
person("Quentin", "Fazilleau", role = "ctb"),
person("Maxim", "Nazarov", role = "ctb"),
person("Titouan", "Robert", role = "ctb"),
person("Michael", "Barrowman", role = "ctb"),
person("Atsushi", "Yasumoto", role = "ctb"),
person("Paul", "Julian", role = "ctb"),
person("Sean", "Browning", role = "ctb"),
person("Rémi", "Thériault", role = "ctb",
comment = c(ORCID = "0000-0003-4315-6788")),
person("Samuel", "Jobert", role = "ctb"),
person("Keith", "Newman", role = "ctb")
)
Description: Use a grammar for creating and customizing pretty tables.
The following formats are supported: 'HTML', 'PDF', 'RTF', 'Microsoft
Word', 'Microsoft PowerPoint', R 'Grid Graphics' and 'patchwork'.
'R Markdown', 'Quarto' and the package 'officer' can be used to
produce the result files. The syntax is the same for the user
regardless of the type of output to be produced. A set of functions
allows the creation, definition of cell arrangement, addition of
headers or footers, formatting and definition of cell content with
text and or images. The package also offers a set of high-level
functions that allow tabular reporting of statistical models and the
creation of complex cross tabulations.
License: GPL-3
URL: https://ardata-fr.github.io/flextable-book/,
https://davidgohel.github.io/flextable/
BugReports: https://github.com/davidgohel/flextable/issues
Imports: data.table (>= 1.13.0), gdtools (>= 0.5.0), graphics,
grDevices, grid, htmltools, knitr, officer (>= 0.7.3), ragg,
rlang, rmarkdown (>= 2.0), stats, utils, uuid (>= 0.1-4), xml2
Suggests: bookdown (>= 0.40), broom, broom.mixed, chromote, cluster,
commonmark, doconv (>= 0.3.0), equatags, ggplot2, gtable,
jsonlite, lme4, magick, mgcv, nlme, officedown, patchwork,
pdftools, pkgdown (>= 2.0.0), scales, svglite, tables (>=
0.9.17), testthat (>= 3.0.0), webshot2, withr, xtable
VignetteBuilder: knitr
Config/testthat/edition: 3
Encoding: UTF-8
RoxygenNote: 7.3.3
NeedsCompilation: no
Packaged: 2026-02-12 17:16:00 UTC; davidgohel
Author: David Gohel [aut, cre],
ArData [cph],
Clementine Jager [ctb],
Eli Daniels [ctb],
Panagiotis Skintzos [aut],
Quentin Fazilleau [ctb],
Maxim Nazarov [ctb],
Titouan Robert [ctb],
Michael Barrowman [ctb],
Atsushi Yasumoto [ctb],
Paul Julian [ctb],
Sean Browning [ctb],
Rémi Thériault [ctb] (ORCID: