Type:	Package
Title:	Functions for Tabular Reporting
Version:	0.9.11
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], Samuel Jobert [ctb], Keith Newman [ctb]
Maintainer:	David Gohel <david.gohel@ardata.fr>
Repository:	CRAN
Date/Publication:	2026-02-13 07:00:42 UTC

flextable: Functions for Tabular Reporting

Description

The flextable package facilitates access to and manipulation of tabular reporting elements from R.

The documentation of functions can be opened with command help(package = "flextable").

flextable() function is producing flexible tables where each cell can contain several chunks of text with their own set of formatting properties (bold, font color, etc.). Function mk_par() lets customise text of cells.

Each cell holds a single paragraph composed of inline chunks (see as_paragraph()). This means cell content is strictly inline: bold, italic, links, images, equations, inline code, etc. Block-level structures (multiple paragraphs, bullet lists, headings or fenced code blocks) cannot be placed inside a cell. Soft line breaks (⁠\n⁠) are however supported.

The as_flextable() function is used to transform specific objects into flextable objects. For example, you can transform a crosstab produced with the 'tables' package into a flextable which can then be formatted, annotated or augmented with footnotes.

In order to reduce the homogenization efforts and the number of functions to be called, it is recommended to define formatting properties such as font, border color, number of decimals displayed which will then be applied by default. See set_flextable_defaults() for more details.

Table Structure

A flextable is composed of three distinct parts:

• header: By default, contains one row with the column names from the data.frame

• body: Contains the actual data from the data.frame

• footer: Empty by default, but can contain content (commonly used for footnotes or #' summary rows)

       HEADER         <- Column names, labels, spanning headers
--------------------
        BODY          <- Data rows
--------------------
       FOOTER         <- Summary rows, notes, footnotes (optional)

A basic flextable has:

• in the part 'header': 1 row with column names

• in the part 'body': as many rows as there are in the input data.frame

• no footer

Rows and columns can be added or removed to the basic flextable:

• Add new rows in header with add_header(), add_header_row(), add_header_lines() and set_header_labels().

• Add new rows in footer with add_footer(), add_footer_lines(), set_header_footer_df() and add_footer_row().

• Add new rows in body with add_body() and add_body_row().

• Delete columns with delete_columns().

• Delete a part with delete_part().

• Use column names to separate a simple header row into multiple nested rows with separate_header().

Selectors in flextable

Selectors are a core feature of flextable that allow you to specify which parts (part), rows (i) and columns (j) should be affected by formatting, styling, or content operations. See the corresponding manual: <Selectors in flextable>.

Author(s)

Maintainer: David Gohel david.gohel@ardata.fr

Authors:

• Panagiotis Skintzos panagiotis.skintzos@ardata.fr

Other contributors:

• ArData [copyright holder]

• Clementine Jager [contributor]

• Eli Daniels [contributor]

• Quentin Fazilleau [contributor]

• Maxim Nazarov [contributor]

• Titouan Robert [contributor]

• Michael Barrowman [contributor]

• Atsushi Yasumoto [contributor]

• Paul Julian [contributor]

• Sean Browning [contributor]

• Rémi Thériault (ORCID) [contributor]

• Samuel Jobert [contributor]

• Keith Newman [contributor]

See Also

https://davidgohel.github.io/flextable/, https://ardata-fr.github.io/flextable-book/, flextable()

Add body rows with one value per column

Description

Add new rows to the body where each value maps to a named column, preserving the original column data types. Unlike 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 NA and displayed as empty.

Usage

add_body(x, top = TRUE, ..., values = NULL)

Arguments

See Also

flextable()

Other functions for row and column operations in a flextable: add_body_row(), add_footer(), add_footer_lines(), add_footer_row(), add_header(), add_header_lines(), add_header_row(), delete_columns(), delete_part(), separate_header(), set_header_footer_df, set_header_labels()

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

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().

Usage

add_body_row(x, top = TRUE, values = list(), colwidths = integer(0))

Arguments

See Also

flextable(), set_caption()

Other functions for row and column operations in a flextable: add_body(), add_footer(), add_footer_lines(), add_footer_row(), add_header(), add_header_lines(), add_header_row(), delete_columns(), delete_part(), separate_header(), set_header_footer_df, set_header_labels()

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

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.

Usage

add_footer(x, top = TRUE, ..., values = NULL)

Arguments

See Also

Other functions for row and column operations in a flextable: add_body(), add_body_row(), add_footer_lines(), add_footer_row(), add_header(), add_header_lines(), add_header_row(), delete_columns(), delete_part(), separate_header(), set_header_footer_df, set_header_labels()

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

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.

Usage

add_footer_lines(x, values = character(0), top = FALSE)

Arguments

See Also

Other functions for row and column operations in a flextable: add_body(), add_body_row(), add_footer(), add_footer_row(), add_header(), add_header_lines(), add_header_row(), delete_columns(), delete_part(), separate_header(), set_header_footer_df, set_header_labels()

Examples

ft_1 <- flextable(head(iris))
ft_1 <- add_footer_lines(ft_1,
  values = c("blah 1", "blah 2")
)
ft_1

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().

Usage

add_footer_row(x, top = TRUE, values = character(0), colwidths = integer(0))

Arguments

See Also

flextable(), set_caption()

Other functions for row and column operations in a flextable: add_body(), add_body_row(), add_footer(), add_footer_lines(), add_header(), add_header_lines(), add_header_row(), delete_columns(), delete_part(), separate_header(), set_header_footer_df, set_header_labels()

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 header rows with one value per column

Description

Add new rows to the header where each value maps to a named column. Unlike 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 NA and displayed as empty.

Usage

add_header(x, top = TRUE, ..., values = NULL)

Arguments

Note

when repeating values, they can be merged together with function merge_h() and merge_v().

See Also

Other functions for row and column operations in a flextable: add_body(), add_body_row(), add_footer(), add_footer_lines(), add_footer_row(), add_header_lines(), add_header_row(), delete_columns(), delete_part(), separate_header(), set_header_footer_df, set_header_labels()

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

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.

Usage

add_header_lines(x, values = character(0), top = TRUE)

Arguments

See Also

Other functions for row and column operations in a flextable: add_body(), add_body_row(), add_footer(), add_footer_lines(), add_footer_row(), add_header(), add_header_row(), delete_columns(), delete_part(), separate_header(), set_header_footer_df, set_header_labels()

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 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().

Usage

add_header_row(x, top = TRUE, values = character(0), colwidths = integer(0))

Arguments

See Also

flextable(), set_caption()

Other functions for row and column operations in a flextable: add_body(), add_body_row(), add_footer(), add_footer_lines(), add_footer_row(), add_header(), add_header_lines(), delete_columns(), delete_part(), separate_header(), set_header_footer_df, set_header_labels()

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

Add latex dependencies

Description

Manually add flextable latex dependencies to the knitr session via knitr::knit_meta_add().

When enabling caching in 'R Markdown' documents for PDF output, the flextable cached result is used directly. Call add_latex_dep() in a non cached chunk so that flextable latex dependencies are added to knitr metadata.

Usage

add_latex_dep(float = FALSE, wrapfig = FALSE)

Arguments

See Also

knit_print.flextable()

Examples

add_latex_dep()

Set text alignment

Description

Change the text alignment of selected rows and columns of a flextable.

Usage

align(
  x,
  i = NULL,
  j = NULL,
  align = "left",
  part = c("body", "header", "footer", "all")
)

align_text_col(x, align = "left", header = TRUE, footer = TRUE)

align_nottext_col(x, align = "right", header = TRUE, footer = TRUE)

Arguments

See Also

Other sugar functions for table style: bg(), bold(), color(), empty_blanks(), font(), fontsize(), highlight(), italic(), keep_with_next(), line_spacing(), padding(), rotate(), style(), tab_settings(), valign()

Examples

# Table of 6 columns
ft_car <- flextable(head(mtcars)[, 2:7])

# All 6 columns right aligned
align(ft_car, align = "right", part = "all")

# Manually specify alignment of each column
align(
  ft_car,
  align = c("left", "right", "left", "center", "center", "right"),
  part = "all"
)

# Center-align column 2 and left-align column 5
align(ft_car, j = c(2, 5), align = c("center", "left"), part = "all")

# Alternate left and center alignment across columns 1-4 for header only
align(ft_car, j = 1:4, align = c("left", "center"), part = "header")
ftab <- flextable(mtcars)
ftab <- align_text_col(ftab, align = "left")
ftab <- align_nottext_col(ftab, align = "right")
ftab

Append chunks to flextable content

Description

append chunks (for example chunk as_chunk()) in a flextable.

Usage

append_chunks(x, ..., i = NULL, j = NULL, part = "body")

Arguments

See Also

as_chunk(), as_sup(), as_sub(), colorize()

Other functions for mixed content paragraphs: as_paragraph(), compose(), prepend_chunks()

Examples

library(flextable)
img.file <- file.path(R.home("doc"), "html", "logo.jpg")

ft_1 <- flextable(head(cars))

ft_1 <- append_chunks(ft_1,
  # where to append
  i = c(1, 3, 5),
  j = 1,
  # what to append
  as_chunk(" "),
  as_image(src = img.file, width = .20, height = .15)
)
ft_1 <- set_table_properties(ft_1, layout = "autofit")
ft_1

internal utils for roxygen tags reuse

Description

internal utils for roxygen tags reuse

Arguments

internal utils for roxygen tags reuse

Description

internal utils for roxygen tags reuse

Arguments

internal utils for roxygen tags reuse

Description

internal utils for roxygen tags reuse

Arguments

internal utils for roxygen tags reuse

Description

internal utils for roxygen tags reuse

Arguments

internal utils for roxygen tags reuse

Description

internal utils for roxygen tags reuse

Arguments

internal utils for roxygen tags reuse

Description

internal utils for roxygen tags reuse

Arguments

internal utils for roxygen tags reuse

Description

internal utils for roxygen tags reuse

Arguments

internal utils for roxygen tags reuse

Description

internal utils for roxygen tags reuse

Arguments

internal utils for roxygen tags reuse

Description

internal utils for roxygen tags reuse

Arguments

internal utils for roxygen tags reuse

Description

internal utils for roxygen tags reuse

Arguments

internal utils for roxygen tags reuse

Description

internal utils for roxygen tags reuse

Arguments

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().

Usage

as_b(x)

Arguments

See Also

Other chunk elements for paragraph: as_bracket(), as_chunk(), as_equation(), as_highlight(), as_i(), as_image(), as_qmd(), as_strike(), as_sub(), as_sup(), as_word_field(), colorize(), gg_chunk(), grid_chunk(), hyperlink_text(), linerange(), minibar(), plot_chunk()

Examples

ft <- flextable(head(iris),
  col_keys = c("Sepal.Length", "dummy")
)

ft <- compose(ft,
  j = "dummy",
  value = as_paragraph(
    as_b(Sepal.Length)
  )
)

ft

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().

Usage

as_bracket(..., sep = ", ", p = "(", s = ")")

Arguments

See Also

Other chunk elements for paragraph: as_b(), as_chunk(), as_equation(), as_highlight(), as_i(), as_image(), as_qmd(), as_strike(), as_sub(), as_sup(), as_word_field(), colorize(), gg_chunk(), grid_chunk(), hyperlink_text(), linerange(), minibar(), plot_chunk()

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

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().

Usage

as_chunk(x, props = NULL, formatter = format_fun, ...)

Arguments

See Also

Other chunk elements for paragraph: as_b(), as_bracket(), as_equation(), as_highlight(), as_i(), as_image(), as_qmd(), as_strike(), as_sub(), as_sup(), as_word_field(), colorize(), gg_chunk(), grid_chunk(), hyperlink_text(), linerange(), minibar(), plot_chunk()

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

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.

Usage

as_equation(x, width = 1, height = 0.2, unit = "in", props = NULL)

Arguments

See Also

Other chunk elements for paragraph: as_b(), as_bracket(), as_chunk(), as_highlight(), as_i(), as_image(), as_qmd(), as_strike(), as_sub(), as_sup(), as_word_field(), colorize(), gg_chunk(), grid_chunk(), hyperlink_text(), linerange(), minibar(), plot_chunk()

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
}

Method to transform objects into flextables

Description

This is a convenient function to let users create flextable bindings from any objects. Users should consult documentation of corresponding method to understand the details and see what arguments can be used.

Usage

as_flextable(x, ...)

Arguments

See Also

Other as_flextable methods: as_flextable.compact_summary(), as_flextable.data.frame(), as_flextable.gam(), as_flextable.glm(), as_flextable.grouped_data(), as_flextable.htest(), as_flextable.kmeans(), as_flextable.lm(), as_flextable.merMod(), as_flextable.pam(), as_flextable.summarizor(), as_flextable.table(), as_flextable.tabular(), as_flextable.tabulator(), as_flextable.xtable(), compact_summary()

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.

Usage

## S3 method for class 'compact_summary'
as_flextable(x, ...)

Arguments

Value

A flextable() object.

See Also

Other as_flextable methods: as_flextable(), as_flextable.data.frame(), as_flextable.gam(), as_flextable.glm(), as_flextable.grouped_data(), as_flextable.htest(), as_flextable.kmeans(), as_flextable.lm(), as_flextable.merMod(), as_flextable.pam(), as_flextable.summarizor(), as_flextable.table(), as_flextable.tabular(), as_flextable.tabulator(), as_flextable.xtable(), compact_summary()

Examples

z <- compact_summary(iris, show_type = TRUE, show_na = TRUE)
as_flextable(z)

Transform and summarise a 'data.frame' into a flextable Simple summary of a data.frame as a flextable

Description

It displays the first rows and shows the column types. If there is only one row, a simplified vertical table is produced.

Usage

## S3 method for class 'data.frame'
as_flextable(
  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

See Also

Other as_flextable methods: as_flextable(), as_flextable.compact_summary(), as_flextable.gam(), as_flextable.glm(), as_flextable.grouped_data(), as_flextable.htest(), as_flextable.kmeans(), as_flextable.lm(), as_flextable.merMod(), as_flextable.pam(), as_flextable.summarizor(), as_flextable.table(), as_flextable.tabular(), as_flextable.tabulator(), as_flextable.xtable(), compact_summary()

Examples

as_flextable(mtcars)

Transform a 'gam' model into a flextable

Description

produce a flextable describing a generalized additive model produced by function mgcv::gam.

Usage

## S3 method for class 'gam'
as_flextable(x, ...)

Arguments

See Also

Other as_flextable methods: as_flextable(), as_flextable.compact_summary(), as_flextable.data.frame(), as_flextable.glm(), as_flextable.grouped_data(), as_flextable.htest(), as_flextable.kmeans(), as_flextable.lm(), as_flextable.merMod(), as_flextable.pam(), as_flextable.summarizor(), as_flextable.table(), as_flextable.tabular(), as_flextable.tabulator(), as_flextable.xtable(), compact_summary()

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
}

Transform a 'glm' object into a flextable

Description

produce a flextable describing a generalized linear model produced by function glm.

You can remove significance stars by setting options options(show.signif.stars = FALSE).

Usage

## S3 method for class 'glm'
as_flextable(x, ...)

Arguments

See Also

Other as_flextable methods: as_flextable(), as_flextable.compact_summary(), as_flextable.data.frame(), as_flextable.gam(), as_flextable.grouped_data(), as_flextable.htest(), as_flextable.kmeans(), as_flextable.lm(), as_flextable.merMod(), as_flextable.pam(), as_flextable.summarizor(), as_flextable.table(), as_flextable.tabular(), as_flextable.tabulator(), as_flextable.xtable(), compact_summary()

Examples

if (require("broom")) {
  dat <- attitude
  dat$high.rating <- (dat$rating > 70)
  probit.model <- glm(high.rating ~ learning + critical +
    advance, data = dat, family = binomial(link = "probit"))
  ft <- as_flextable(probit.model)
  ft
}

Transform a 'grouped_data' object into a flextable

Description

Produce a flextable from a table produced by function as_grouped_data().

Usage

## S3 method for class 'grouped_data'
as_flextable(x, col_keys = NULL, hide_grouplabel = FALSE, ...)

Arguments

See Also

as_grouped_data()

Other as_flextable methods: as_flextable(), as_flextable.compact_summary(), as_flextable.data.frame(), as_flextable.gam(), as_flextable.glm(), as_flextable.htest(), as_flextable.kmeans(), as_flextable.lm(), as_flextable.merMod(), as_flextable.pam(), as_flextable.summarizor(), as_flextable.table(), as_flextable.tabular(), as_flextable.tabulator(), as_flextable.xtable(), compact_summary()

Examples

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 <- as_grouped_data(x = data_co2, groups = c("Treatment"))

ft <- as_flextable(data_co2)
ft <- add_footer_lines(ft, "dataset CO2 has been used for this flextable")
ft <- add_header_lines(ft, "mean of carbon dioxide uptake in grass plants")
ft <- set_header_labels(ft, conc = "Concentration")
ft <- autofit(ft)
ft <- width(ft, width = c(1, 1, 1))
ft

Transform a 'htest' object into a flextable

Description

produce a flextable describing an object oof class htest.

Usage

## S3 method for class 'htest'
as_flextable(x, ...)

Arguments

See Also

Other as_flextable methods: as_flextable(), as_flextable.compact_summary(), as_flextable.data.frame(), as_flextable.gam(), as_flextable.glm(), as_flextable.grouped_data(), as_flextable.kmeans(), as_flextable.lm(), as_flextable.merMod(), as_flextable.pam(), as_flextable.summarizor(), as_flextable.table(), as_flextable.tabular(), as_flextable.tabulator(), as_flextable.xtable(), compact_summary()

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
}

Transform a 'kmeans' object into a flextable

Description

produce a flextable describing a kmeans object. The function is only using package 'broom' that provides the data presented in the resulting flextable.

Usage

## S3 method for class 'kmeans'
as_flextable(x, digits = 4, ...)

Arguments

See Also

Other as_flextable methods: as_flextable(), as_flextable.compact_summary(), as_flextable.data.frame(), as_flextable.gam(), as_flextable.glm(), as_flextable.grouped_data(), as_flextable.htest(), as_flextable.lm(), as_flextable.merMod(), as_flextable.pam(), as_flextable.summarizor(), as_flextable.table(), as_flextable.tabular(), as_flextable.tabulator(), as_flextable.xtable(), compact_summary()

Examples

if (require("stats")) {
  cl <- kmeans(scale(mtcars[1:7]), 5)
  ft <- as_flextable(cl)
  ft
}

Transform a 'lm' object into a flextable

Description

produce a flextable describing a linear model produced by function lm.

You can remove significance stars by setting options options(show.signif.stars = FALSE).

Usage

## S3 method for class 'lm'
as_flextable(x, ...)

Arguments

See Also

Other as_flextable methods: as_flextable(), as_flextable.compact_summary(), as_flextable.data.frame(), as_flextable.gam(), as_flextable.glm(), as_flextable.grouped_data(), as_flextable.htest(), as_flextable.kmeans(), as_flextable.merMod(), as_flextable.pam(), as_flextable.summarizor(), as_flextable.table(), as_flextable.tabular(), as_flextable.tabulator(), as_flextable.xtable(), compact_summary()

Examples

if (require("broom")) {
  lmod <- lm(rating ~ complaints + privileges +
    learning + raises + critical, data = attitude)
  ft <- as_flextable(lmod)
  ft
}

Transform a 'merMod' or 'lme' object into a flextable

Description

produce a flextable describing a mixed model. The function is only using package 'broom.mixed' that provides the data presented in the resulting flextable.

You can remove significance stars by setting options options(show.signif.stars = FALSE).

Usage

## S3 method for class 'merMod'
as_flextable(x, add.random = TRUE, ...)

## S3 method for class 'lme'
as_flextable(x, add.random = TRUE, ...)

## S3 method for class 'gls'
as_flextable(x, add.random = TRUE, ...)

## S3 method for class 'nlme'
as_flextable(x, add.random = TRUE, ...)

## S3 method for class 'brmsfit'
as_flextable(x, add.random = TRUE, ...)

## S3 method for class 'glmmTMB'
as_flextable(x, add.random = TRUE, ...)

## S3 method for class 'glmmadmb'
as_flextable(x, add.random = TRUE, ...)

Arguments

See Also

Other as_flextable methods: as_flextable(), as_flextable.compact_summary(), as_flextable.data.frame(), as_flextable.gam(), as_flextable.glm(), as_flextable.grouped_data(), as_flextable.htest(), as_flextable.kmeans(), as_flextable.lm(), as_flextable.pam(), as_flextable.summarizor(), as_flextable.table(), as_flextable.tabular(), as_flextable.tabulator(), as_flextable.xtable(), compact_summary()

Examples

if (require("broom.mixed") && require("nlme")) {
  m1 <- lme(distance ~ age, data = Orthodont)
  ft <- as_flextable(m1)
  ft
}

Transform a 'pam' object into a flextable

Description

produce a flextable describing a pam object. The function is only using package 'broom' that provides the data presented in the resulting flextable.

Usage

## S3 method for class 'pam'
as_flextable(x, digits = 4, ...)

Arguments

See Also

Other as_flextable methods: as_flextable(), as_flextable.compact_summary(), as_flextable.data.frame(), as_flextable.gam(), as_flextable.glm(), as_flextable.grouped_data(), as_flextable.htest(), as_flextable.kmeans(), as_flextable.lm(), as_flextable.merMod(), as_flextable.summarizor(), as_flextable.table(), as_flextable.tabular(), as_flextable.tabulator(), as_flextable.xtable(), compact_summary()

Examples

if (require("cluster")) {
  dat <- as.data.frame(scale(mtcars[1:7]))
  cl <- pam(dat, 3)
  ft <- as_flextable(cl)
  ft
}

Transform a 'summarizor' object into a flextable

Description

summarizor object should be transformed into a flextable with method as_flextable().

Usage

## S3 method for class 'summarizor'
as_flextable(x, ...)

Arguments

See Also

Other as_flextable methods: as_flextable(), as_flextable.compact_summary(), as_flextable.data.frame(), as_flextable.gam(), as_flextable.glm(), as_flextable.grouped_data(), as_flextable.htest(), as_flextable.kmeans(), as_flextable.lm(), as_flextable.merMod(), as_flextable.pam(), as_flextable.table(), as_flextable.tabular(), as_flextable.tabulator(), as_flextable.xtable(), compact_summary()

Examples

z <- summarizor(CO2[-c(1, 4)],
  by = "Treatment",
  overall_label = "Overall"
)
ft_1 <- as_flextable(z, spread_first_col = TRUE)
ft_1 <- prepend_chunks(ft_1,
  i = ~ is.na(variable), j = 1,
  as_chunk("\t")
)
ft_1 <- autofit(ft_1)
ft_1

Transform a 'table' object into a flextable

Description

produce a flextable describing a count table produced by function table().

This function uses the proc_freq() function.

Usage

## S3 method for class 'table'
as_flextable(x, ...)

Arguments

See Also

Other as_flextable methods: as_flextable(), as_flextable.compact_summary(), as_flextable.data.frame(), as_flextable.gam(), as_flextable.glm(), as_flextable.grouped_data(), as_flextable.htest(), as_flextable.kmeans(), as_flextable.lm(), as_flextable.merMod(), as_flextable.pam(), as_flextable.summarizor(), as_flextable.tabular(), as_flextable.tabulator(), as_flextable.xtable(), compact_summary()

Examples

tab <- with(warpbreaks, table(wool, tension))
ft <- as_flextable(tab)
ft

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()).

Usage

## S3 method for class 'tabular'
as_flextable(
  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

See Also

Other as_flextable methods: as_flextable(), as_flextable.compact_summary(), as_flextable.data.frame(), as_flextable.gam(), as_flextable.glm(), as_flextable.grouped_data(), as_flextable.htest(), as_flextable.kmeans(), as_flextable.lm(), as_flextable.merMod(), as_flextable.pam(), as_flextable.summarizor(), as_flextable.table(), as_flextable.tabulator(), as_flextable.xtable(), compact_summary()

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)
}

Transform a 'tabulator' object into a flextable

Description

tabulator() object can be transformed as a flextable with method as_flextable().

Usage

## S3 method for class 'tabulator'
as_flextable(
  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

See Also

summarizor(), as_grouped_data()

Other as_flextable methods: as_flextable(), as_flextable.compact_summary(), as_flextable.data.frame(), as_flextable.gam(), as_flextable.glm(), as_flextable.grouped_data(), as_flextable.htest(), as_flextable.kmeans(), as_flextable.lm(), as_flextable.merMod(), as_flextable.pam(), as_flextable.summarizor(), as_flextable.table(), as_flextable.tabular(), as_flextable.xtable(), compact_summary()

Examples

## Not run: 
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()

## End(Not run)

Transform a 'xtable' object into a flextable

Description

Get a flextable object from a xtable object.

Usage

## S3 method for class 'xtable'
as_flextable(
  x,
  text.properties = fp_text_default(),
  format.args = getOption("xtable.format.args", NULL),
  rowname_col = "rowname",
  hline.after = getOption("xtable.hline.after", c(-1, 0, nrow(x))),
  NA.string = getOption("xtable.NA.string", ""),
  include.rownames = TRUE,
  rotate.colnames = getOption("xtable.rotate.colnames", FALSE),
  ...
)

Arguments

See Also

Other as_flextable methods: as_flextable(), as_flextable.compact_summary(), as_flextable.data.frame(), as_flextable.gam(), as_flextable.glm(), as_flextable.grouped_data(), as_flextable.htest(), as_flextable.kmeans(), as_flextable.lm(), as_flextable.merMod(), as_flextable.pam(), as_flextable.summarizor(), as_flextable.table(), as_flextable.tabular(), as_flextable.tabulator(), compact_summary()

Examples

library(officer)
if( require("xtable") ){

  data(tli)
  tli.table <- xtable(tli[1:10, ])
  align(tli.table) <- rep("r", 6)
  align(tli.table) <- "|r|r|clr|r|"
  ft_1 <- as_flextable(
    tli.table,
    rotate.colnames = TRUE,
    include.rownames = FALSE)
  ft_1 <- height(ft_1, i = 1, part = "header", height = 1)
  ft_1

  
  Grade3 <- c("A","B","B","A","B","C","C","D","A","B",
    "C","C","C","D","B","B","D","C","C","D")
  Grade6 <- c("A","A","A","B","B","B","B","B","C","C",
    "A","C","C","C","D","D","D","D","D","D")
  Cohort <- table(Grade3, Grade6)
  ft_2 <- as_flextable(xtable(Cohort))
  ft_2 <- set_header_labels(ft_2, rowname = "Grade 3")
  ft_2 <- autofit(ft_2)
  ft_2 <- add_header(ft_2, A = "Grade 6")
  ft_2 <- merge_at(ft_2, i = 1, j = seq_len( ncol(Cohort) ) + 1,
    part = "header" )
  ft_2 <- bold(ft_2, j = 1, bold = TRUE, part = "body")
  ft_2 <- height_all(ft_2, part = "header", height = .4)
  ft_2

  temp.ts <- ts(cumsum(1 + round(rnorm(100), 0)),
    start = c(1954, 7), frequency = 12)
  ft_3 <- as_flextable(x = xtable(temp.ts, digits = 0),
    NA.string = "-")
  ft_3
  
  detach("package:xtable", unload = TRUE)
}

Insert group-label rows into a data frame

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.

Usage

as_grouped_data(x, groups, columns = NULL, expand_single = TRUE)

Arguments

See Also

as_flextable.grouped_data()

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

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().

Usage

as_highlight(x, color)

Arguments

See Also

Other chunk elements for paragraph: as_b(), as_bracket(), as_chunk(), as_equation(), as_i(), as_image(), as_qmd(), as_strike(), as_sub(), as_sup(), as_word_field(), colorize(), gg_chunk(), grid_chunk(), hyperlink_text(), linerange(), minibar(), plot_chunk()

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

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().

Usage

as_i(x)

Arguments

See Also

Other chunk elements for paragraph: as_b(), as_bracket(), as_chunk(), as_equation(), as_highlight(), as_image(), as_qmd(), as_strike(), as_sub(), as_sup(), as_word_field(), colorize(), gg_chunk(), grid_chunk(), hyperlink_text(), linerange(), minibar(), plot_chunk()

Examples

ft <- flextable(head(iris),
  col_keys = c("Sepal.Length", "dummy")
)

ft <- compose(ft,
  j = "dummy",
  value = as_paragraph(as_i(Sepal.Length))
)

ft

Image chunk

Description

The function lets add images within flextable objects with functions:

• compose() and as_paragraph(),

• append_chunks(),

• prepend_chunks()

Usage

as_image(src, width = NULL, height = NULL, unit = "in", guess_size = TRUE, ...)

Arguments

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.

See Also

compose(), as_paragraph()

Other chunk elements for paragraph: as_b(), as_bracket(), as_chunk(), as_equation(), as_highlight(), as_i(), as_qmd(), as_strike(), as_sub(), as_sup(), as_word_field(), colorize(), gg_chunk(), grid_chunk(), hyperlink_text(), linerange(), minibar(), plot_chunk()

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
}

Build a paragraph from chunks

Description

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 as_chunk() (formatted text), as_b() / as_i() (bold / italic shortcuts), minibar() (inline bar), as_image() (image), gg_chunk() (ggplot), as_equation() (equation) or hyperlink_text() (link). Plain character strings passed to as_paragraph() are automatically converted to chunks via as_chunk().

The resulting paragraph is passed to the value argument of compose(), mk_par(), add_header_lines(), add_footer_lines() or footnote() to set cell content.

Usage

as_paragraph(..., list_values = NULL)

Arguments

See Also

as_chunk(), minibar(), as_image(), hyperlink_text()

Other functions for mixed content paragraphs: append_chunks(), compose(), prepend_chunks()

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

Quarto inline markdown chunk

Description

as_qmd() creates a chunk for inline Quarto markdown content (text-level) that fits within a table cell paragraph. This enables cross-references (⁠@fig-xxx⁠, ⁠@tbl-xxx⁠), links, bold/italic, math, inline code, shortcodes and other inline Quarto markdown features inside flextable cells.

It is not designed for block-level elements such as headings, bullet lists or fenced code blocks.

The chunk is used with compose(), append_chunks() or prepend_chunks(). It requires the flextable-qmd Lua filter extension (see use_flextable_qmd()) and works with HTML, PDF and Word (docx) Quarto output formats.

Usage

as_qmd(x, display = x)

Arguments

Setup

1. Install the extension once per project:

flextable::use_flextable_qmd()

1. Add the filter to your Quarto document YAML. For HTML and PDF, a single line is enough:

filters:
  - flextable-qmd

For Word (docx), an additional post-render filter removes the wrapper table that Quarto adds around labelled flextables:

filters:
  - flextable-qmd
  - at: post-render
    path: _extensions/flextable-qmd/unwrap-float.lua

Supported markdown

• Cross-references: ⁠@fig-xxx⁠, ⁠@tbl-xxx⁠

• Bold / italic: ⁠**bold**⁠, ⁠*italic*⁠

• Inline code: `code`

• Links: ⁠[text](url)⁠ (internal and external)

• Math: ⁠$\\alpha + \\beta$⁠

• Shortcodes and other Quarto markdown constructs

Limitations

Each table cell in a flextable contains a single paragraph built from inline chunks (see as_paragraph()). There is no mechanism to insert block-level structures (multiple paragraphs, lists, headings, fenced code blocks, callouts, etc.) inside a cell. Because as_qmd() produces one of these inline chunks, only inline markdown is supported.

See Also

use_flextable_qmd() to install the Lua filter extension, knit_print.flextable() for rendering options in knitr documents.

Other chunk elements for paragraph: as_b(), as_bracket(), as_chunk(), as_equation(), as_highlight(), as_i(), as_image(), as_strike(), as_sub(), as_sup(), as_word_field(), colorize(), gg_chunk(), grid_chunk(), hyperlink_text(), linerange(), minibar(), plot_chunk()

Examples

library(flextable)

dat <- data.frame(
  label = c("Bold", "Link", "Code"),
  content = c(
    "This is **bold** text",
    "Visit [Quarto](https://quarto.org)",
    "Use `print()` here"
  )
)
ft <- flextable(dat)
ft <- mk_par(ft, j = "content",
  value = as_paragraph(as_qmd(content)))
ft

Transform a flextable into a raster

Description

Function is now defunct, use gen_grob() instead.

Usage

as_raster(...)

Arguments

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().

Usage

as_strike(x)

Arguments

See Also

Other chunk elements for paragraph: as_b(), as_bracket(), as_chunk(), as_equation(), as_highlight(), as_i(), as_image(), as_qmd(), as_sub(), as_sup(), as_word_field(), colorize(), gg_chunk(), grid_chunk(), hyperlink_text(), linerange(), minibar(), plot_chunk()

Examples

ft <- flextable(head(iris),
  col_keys = c("Sepal.Length", "dummy")
)

ft <- compose(ft,
  j = "dummy",
  value = as_paragraph(
    as_strike(Sepal.Length)
  )
)

ft

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().

Usage

as_sub(x)

Arguments

See Also

Other chunk elements for paragraph: as_b(), as_bracket(), as_chunk(), as_equation(), as_highlight(), as_i(), as_image(), as_qmd(), as_strike(), as_sup(), as_word_field(), colorize(), gg_chunk(), grid_chunk(), hyperlink_text(), linerange(), minibar(), plot_chunk()

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

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().

Usage

as_sup(x)

Arguments

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().

See Also

Other chunk elements for paragraph: as_b(), as_bracket(), as_chunk(), as_equation(), as_highlight(), as_i(), as_image(), as_qmd(), as_strike(), as_sub(), as_word_field(), colorize(), gg_chunk(), grid_chunk(), hyperlink_text(), linerange(), minibar(), plot_chunk()

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

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 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.

Usage

as_word_field(x, props = NULL, width = 0.1, height = 0.15, unit = "in")

Arguments

See Also

Other chunk elements for paragraph: as_b(), as_bracket(), as_chunk(), as_equation(), as_highlight(), as_i(), as_image(), as_qmd(), as_strike(), as_sub(), as_sup(), colorize(), gg_chunk(), grid_chunk(), hyperlink_text(), linerange(), minibar(), plot_chunk()

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()

Adjust cell widths and heights

Description

compute and apply optimized widths and heights (minimum estimated widths and heights for each table columns and rows in inches returned by function dim_pretty()).

This function is to be used when the table widths and heights should be adjusted to fit the size of the content.

The function does not let you adjust a content that is too wide in a paginated document. It simply calculates the width of the columns so that each content has the minimum width necessary to display the content on one line.

Note that this function is not related to 'Microsoft Word' Autofit feature.

There is an alternative to fixed-width layouts that works well with HTML and Word output that can be set with set_table_properties(layout = "autofit"), see set_table_properties().

Usage

autofit(
  x,
  add_w = 0.1,
  add_h = 0.1,
  part = c("body", "header"),
  unit = "in",
  hspans = "none"
)

Arguments

See Also

Other functions for flextable size management: dim.flextable(), dim_pretty(), fit_to_width(), flextable_dim(), height(), hrule(), ncol_keys(), nrow_part(), width()

Examples

ft_1 <- flextable(head(mtcars))
ft_1
ft_2 <- autofit(ft_1)
ft_2

Detect rows before a given value

Description

Returns a logical vector indicating which elements of x appear before the first occurrence of any of the entries values. Useful as a row selector in hline() to insert a border above a summary row such as "Total".

Usage

before(x, entries)

Arguments

See Also

hline()

Examples

library(flextable)
library(officer)

dat <- data.frame(
  stringsAsFactors = FALSE,
  check.names = FALSE,
  Level = c("setosa", "versicolor", "virginica", "<NA>", "Total"),
  Freq = as.integer(c(50, 50, 50, 0, 150)),
  `% Valid` = c(
    100 / 3,
    100 / 3, 100 / 3, NA, 100
  ),
  `% Valid Cum.` = c(100 / 3, 100 * 2 / 3, 100, NA, 100),
  `% Total` = c(
    100 / 3,
    100 / 3, 100 / 3, 0, 100
  ),
  `% Total Cum.` = c(
    100 / 3,
    100 * 2 / 3, 100, 100, 100
  )
)

ft <- flextable(dat)
ft <- hline(ft,
  i = ~ before(Level, "Total"),
  border = fp_border_default(width = 2)
)
ft

Set background color

Description

Change the background color of selected rows and columns of a flextable. A function can be used instead of fixed colors.

When 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 colkeys) is a common use case. The argument source must be used to define the columns to be used for the color definition, and the argument j must be used to define where to apply the colors and only accepts values from colkeys.

Usage

bg(x, i = NULL, j = NULL, bg, part = "body", source = j)

Arguments

Note

Word does not allow you to apply transparency to table cells or paragraph shading.

See Also

Other sugar functions for table style: align(), bold(), color(), empty_blanks(), font(), fontsize(), highlight(), italic(), keep_with_next(), line_spacing(), padding(), rotate(), style(), tab_settings(), valign()

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
}

Add flextable into a Word document

Description

Add a flextable into a Word document created with 'officer'.

Usage

body_add_flextable(
  x,
  value,
  align = NULL,
  pos = "after",
  split = NULL,
  topcaption = TRUE,
  keepnext = NULL
)

Arguments

Details

Use the 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 set_caption() function to define formatted captions (with as_paragraph()) or simple captions (with a string). topcaption can be used to insert the caption before the table (default) or after the table (use FALSE).

See Also

knit_print.flextable(), save_as_docx()

Examples

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)

Add flextable at bookmark location in a Word document

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.

Usage

body_replace_flextable_at_bkm(
  x,
  bookmark,
  value,
  align = "center",
  split = FALSE
)

Arguments

Set bold font

Description

Change the font weight of selected rows and columns of a flextable.

Usage

bold(x, i = NULL, j = NULL, bold = TRUE, part = "body")

Arguments

See Also

Other sugar functions for table style: align(), bg(), color(), empty_blanks(), font(), fontsize(), highlight(), italic(), keep_with_next(), line_spacing(), padding(), rotate(), style(), tab_settings(), valign()

Examples

ft <- flextable(head(iris))
ft <- bold(ft, bold = TRUE, part = "header")

Set cell borders

Description

change borders of selected rows and columns of a flextable. This function is 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 : border_outer(), border_inner_h() and border_inner_v().

To add horizontal or vertical lines in the table at specific location, use:

• hline(): set bottom borders (inner horizontal)

• vline(): set right borders (inner vertical)

To add following horizontal or vertical lines at beginning or end of the table, use:

• hline_top(): set the top border (outer horizontal)

• hline_bottom(): set the bottom border (outer horizontal)

• vline_left(): set the left border (outer vertical)

• vline_right(): set the right border (outer vertical)

If you want to highlight specific cells with some borders, use surround().

Usage

border(
  x,
  i = NULL,
  j = NULL,
  border = NULL,
  border.top = NULL,
  border.bottom = NULL,
  border.left = NULL,
  border.right = NULL,
  part = "body"
)

Arguments

Note

pdf and pptx outputs do not support border() usage.

Examples

library(officer)
ftab <- flextable(head(mtcars))
ftab <- border(ftab, border.top = fp_border(color = "orange"))
ftab

Set all inner borders

Description

The function is applying a vertical and horizontal borders to inner content of one or all parts of a flextable.

Usage

border_inner(x, border = NULL, part = "all")

Arguments

See Also

Other borders management: border_inner_h(), border_inner_v(), border_outer(), border_remove(), hline(), hline_bottom(), hline_top(), surround(), vline(), vline_left(), vline_right()

Examples

library(officer)
std_border <- fp_border(color = "orange", width = 1)

dat <- iris[c(1:5, 51:55, 101:105), ]
ft <- flextable(dat)
ft <- border_remove(x = ft)

# add inner vertical borders
ft <- border_inner(ft, border = std_border)
ft

Set inner horizontal borders

Description

The function is applying a border to inner content of one or all parts of a flextable.

Usage

border_inner_h(x, border = NULL, part = "body")

Arguments

See Also

Other borders management: border_inner(), border_inner_v(), border_outer(), border_remove(), hline(), hline_bottom(), hline_top(), surround(), vline(), vline_left(), vline_right()

Examples

library(officer)
std_border <- fp_border(color = "orange", width = 1)

dat <- iris[c(1:5, 51:55, 101:105), ]
ft <- flextable(dat)
ft <- border_remove(x = ft)

# add inner horizontal borders
ft <- border_inner_h(ft, border = std_border)
ft

Set inner vertical borders

Description

The function is applying a vertical border to inner content of one or all parts of a flextable.

Usage

border_inner_v(x, border = NULL, part = "all")

Arguments

See Also

Other borders management: border_inner(), border_inner_h(), border_outer(), border_remove(), hline(), hline_bottom(), hline_top(), surround(), vline(), vline_left(), vline_right()

Examples

library(officer)
std_border <- fp_border(color = "orange", width = 1)

dat <- iris[c(1:5, 51:55, 101:105), ]
ft <- flextable(dat)
ft <- border_remove(x = ft)

# add inner vertical borders
ft <- border_inner_v(ft, border = std_border)
ft

Set outer borders

Description

The function is applying a border to outer cells of one or all parts of a flextable.

Usage

border_outer(x, border = NULL, part = "all")

Arguments

See Also

Other borders management: border_inner(), border_inner_h(), border_inner_v(), border_remove(), hline(), hline_bottom(), hline_top(), surround(), vline(), vline_left(), vline_right()

Examples

library(officer)
big_border <- fp_border(color = "red", width = 2)

dat <- iris[c(1:5, 51:55, 101:105), ]
ft <- flextable(dat)
ft <- border_remove(x = ft)

# add outer borders
ft <- border_outer(ft, part = "all", border = big_border)
ft

Remove borders

Description

The function is deleting all borders of the flextable object.

Usage

border_remove(x)

Arguments

See Also

Other borders management: border_inner(), border_inner_h(), border_inner_v(), border_outer(), hline(), hline_bottom(), hline_top(), surround(), vline(), vline_left(), vline_right()

Examples

dat <- iris[c(1:5, 51:55, 101:105), ]
ft_1 <- flextable(dat)
ft_1 <- theme_box(ft_1)
ft_1

# remove all borders
ft_2 <- border_remove(x = ft_1)
ft_2

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.

Usage

chunk_dataframe(...)

Arguments

Value

a data.frame with an additional class "chunk" that makes it suitable for beeing used in as_paragraph()

text pattern with default values

chunk_dataframe(txt = c("any text", "other text"))

text pattern with bold set to TRUE

chunk_dataframe(
  txt = c("any text", "other text"),
  bold = c(TRUE, TRUE))

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") )

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") )

images pattern

chunk_dataframe(width = width, height = height, img_data = files )

Format character cells

Description

Format character cells in a flextable.

Usage

colformat_char(
  x,
  i = NULL,
  j = NULL,
  na_str = get_flextable_defaults()$na_str,
  nan_str = get_flextable_defaults()$nan_str,
  prefix = "",
  suffix = ""
)

Arguments

See Also

Other cells formatters: colformat_date(), colformat_datetime(), colformat_double(), colformat_image(), colformat_int(), colformat_lgl(), colformat_num(), set_formatter()

Examples

dat <- iris
z <- flextable(head(dat))
ft <- colformat_char(
  x = z, j = "Species", suffix = "!"
)
z <- autofit(z)
z

Format date cells

Description

Format date cells in a flextable.

Usage

colformat_date(
  x,
  i = NULL,
  j = NULL,
  fmt_date = get_flextable_defaults()$fmt_date,
  na_str = get_flextable_defaults()$na_str,
  nan_str = get_flextable_defaults()$nan_str,
  prefix = "",
  suffix = ""
)

Arguments

See Also

Other cells formatters: colformat_char(), colformat_datetime(), colformat_double(), colformat_image(), colformat_int(), colformat_lgl(), colformat_num(), set_formatter()

Examples

dat <- data.frame(
  z = Sys.Date() + 1:3,
  w = Sys.Date() - 1:3
)
ft <- flextable(dat)
ft <- colformat_date(x = ft)
ft <- autofit(ft)
ft

Format datetime cells

Description

Format datetime cells in a flextable.

Usage

colformat_datetime(
  x,
  i = NULL,
  j = NULL,
  fmt_datetime = get_flextable_defaults()$fmt_datetime,
  na_str = get_flextable_defaults()$na_str,
  nan_str = get_flextable_defaults()$nan_str,
  prefix = "",
  suffix = ""
)

Arguments

See Also

Other cells formatters: colformat_char(), colformat_date(), colformat_double(), colformat_image(), colformat_int(), colformat_lgl(), colformat_num(), set_formatter()

Examples

dat <- data.frame(
  z = Sys.time() + (1:3) * 24,
  w = Sys.Date() - (1:3) * 24
)
ft <- flextable(dat)
ft <- colformat_datetime(x = ft)
ft <- autofit(ft)
ft

Format double cells

Description

Format numeric cells in a flextable using formatC() with explicit control over digits and decimal mark.

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

See Also

Other cells formatters: colformat_char(), colformat_date(), colformat_datetime(), colformat_image(), colformat_int(), colformat_lgl(), colformat_num(), set_formatter()

Examples

dat <- mtcars
ft <- flextable(head(dat))
ft <- colformat_double(
  x = ft,
  big.mark = ",", digits = 2, na_str = "N/A"
)
autofit(ft)

Format cells as images

Description

Format image paths as images in a flextable.

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

See Also

Other cells formatters: colformat_char(), colformat_date(), colformat_datetime(), colformat_double(), colformat_int(), colformat_lgl(), colformat_num(), set_formatter()

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

Format integer cells

Description

Format integer cells in a flextable.

Usage

colformat_int(
  x,
  i = NULL,
  j = NULL,
  big.mark = get_flextable_defaults()$big.mark,
  na_str = get_flextable_defaults()$na_str,
  nan_str = get_flextable_defaults()$nan_str,
  prefix = "",
  suffix = ""
)

Arguments

See Also

Other cells formatters: colformat_char(), colformat_date(), colformat_datetime(), colformat_double(), colformat_image(), colformat_lgl(), colformat_num(), set_formatter()

Examples

z <- flextable(head(mtcars))
j <- c("vs", "am", "gear", "carb")
z <- colformat_int(x = z, j = j, prefix = "# ")
z

Format logical cells

Description

Format logical cells in a flextable.

Usage

colformat_lgl(
  x,
  i = NULL,
  j = NULL,
  true = "true",
  false = "false",
  na_str = get_flextable_defaults()$na_str,
  nan_str = get_flextable_defaults()$nan_str,
  prefix = "",
  suffix = ""
)

Arguments

See Also

Other cells formatters: colformat_char(), colformat_date(), colformat_datetime(), colformat_double(), colformat_image(), colformat_int(), colformat_num(), set_formatter()

Examples

dat <- data.frame(a = c(TRUE, FALSE), b = c(FALSE, TRUE))

z <- flextable(dat)
z <- colformat_lgl(x = z, j = c("a", "b"))
autofit(z)

Format numeric cells with format()

Description

Format numeric cells in a flextable using R's format() function.

The function is different from colformat_double() on numeric type columns. The function uses the 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).

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

format call

Function format() is called with the following values:

• trim is set to TRUE,

• scientific is set to FALSE,

• big.mark is set to the value of big.mark argument,

• decimal.mark is set to the value of decimal.mark argument,

• other arguments are passed 'as is' to the format function.

argument digits is ignored as it is not the same digits that users want, this one will be used by format() and not formatC(). To change the digit argument use options(digits=4) instead.

This argument will not be changed because 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 set_formatter() that lets you use any format function.

See Also

Other cells formatters: colformat_char(), colformat_date(), colformat_datetime(), colformat_double(), colformat_image(), colformat_int(), colformat_lgl(), set_formatter()

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

Set font color

Description

Change the text color of selected rows and columns of a flextable. A function can be used instead of fixed colors.

When color is a function, it is possible to color cells based on values located in other columns; using hidden columns (those not used by argument colkeys) is a common use case. The argument source must be used to define the columns to be used for the color definition, and the argument j must be used to define where to apply the colors and only accepts values from colkeys.

Usage

color(x, i = NULL, j = NULL, color, part = "body", source = j)

Arguments

See Also

Other sugar functions for table style: align(), bg(), bold(), empty_blanks(), font(), fontsize(), highlight(), italic(), keep_with_next(), line_spacing(), padding(), rotate(), style(), tab_settings(), valign()

Examples

ft <- flextable(head(mtcars))
ft <- color(ft, color = "orange", part = "header")
ft <- color(ft,
  color = "red",
  i = ~ qsec < 18 & vs < 1
)
ft

if (require("scales")) {
  scale <- scales::col_numeric(domain = c(-1, 1), palette = "RdBu")
  x <- as.data.frame(cor(iris[-5]))
  x <- cbind(
    data.frame(
      colname = colnames(x),
      stringsAsFactors = FALSE
    ),
    x
  )
}

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().

Usage

colorize(x, color)

Arguments

See Also

Other chunk elements for paragraph: as_b(), as_bracket(), as_chunk(), as_equation(), as_highlight(), as_i(), as_image(), as_qmd(), as_strike(), as_sub(), as_sup(), as_word_field(), gg_chunk(), grid_chunk(), hyperlink_text(), linerange(), minibar(), plot_chunk()

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

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().

Usage

compact_summary(x, show_type = FALSE, show_na = FALSE, max_levels = 10L)

Arguments

Value

A data.frame with additional class "compact_summary".

See Also

as_flextable.compact_summary()

Other as_flextable methods: as_flextable(), as_flextable.compact_summary(), as_flextable.data.frame(), as_flextable.gam(), as_flextable.glm(), as_flextable.grouped_data(), as_flextable.htest(), as_flextable.kmeans(), as_flextable.lm(), as_flextable.merMod(), as_flextable.pam(), as_flextable.summarizor(), as_flextable.table(), as_flextable.tabular(), as_flextable.tabulator(), as_flextable.xtable()

Examples

z <- compact_summary(iris)
as_flextable(z)

z <- compact_summary(iris, show_type = TRUE, show_na = TRUE)
as_flextable(z)

Set cell content from paragraph chunks

Description

Modify flextable displayed values with eventually mixed content paragraphs.

Function is handling complex formatting as image insertion with as_image(), superscript with as_sup(), formated text with as_chunk() and several other chunk functions.

Function mk_par is another name for compose as there is an unwanted conflict with package 'purrr'.

If you only need to add some content at the end or the beginning of paragraphs and keep existing content as it is, functions append_chunks() and prepend_chunks() should be prefered.

Usage

compose(x, i = NULL, j = NULL, value, part = "body", use_dot = FALSE)

mk_par(x, i = NULL, j = NULL, value, part = "body", use_dot = FALSE)

Arguments

See Also

fp_text_default(), as_chunk(), as_b(), as_word_field(), labelizor()

Other functions for mixed content paragraphs: append_chunks(), as_paragraph(), prepend_chunks()

Examples

ft_1 <- flextable(head(cars, n = 5), col_keys = c("speed", "dist", "comment"))
ft_1 <- mk_par(
  x = ft_1, j = "comment",
  i = ~ dist > 9,
  value = as_paragraph(
    colorize(as_i("speed: "), color = "gray"),
    as_sup(sprintf("%.0f", speed))
  )
)
ft_1 <- set_table_properties(ft_1, layout = "autofit")
ft_1

# using `use_dot = TRUE` ----
set.seed(8)
dat <- iris[sample.int(n = 150, size = 10), ]
dat <- dat[order(dat$Species), ]


ft_2 <- flextable(dat)
ft_2 <- mk_par(ft_2,
  j = ~ . - Species,
  value = as_paragraph(
    minibar(.,
      barcol = "white",
      height = .1
    )
  ), use_dot = TRUE
)
ft_2 <- theme_vader(ft_2)
ft_2 <- autofit(ft_2)
ft_2

Summarize continuous variables as a flextable

Description

create a data.frame summary for continuous variables

Usage

continuous_summary(
  dat,
  columns = NULL,
  by = character(0),
  hide_grouplabel = TRUE,
  digits = 3
)

Arguments

Examples

ft_1 <- continuous_summary(iris, names(iris)[1:4],
  by = "Species",
  hide_grouplabel = FALSE
)
ft_1

Delete flextable columns

Description

The function removes one or more columns from a 'flextable'.

Usage

delete_columns(x, j = NULL)

Arguments

Details

Deleting one or more columns 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.

See Also

Other functions for row and column operations in a flextable: add_body(), add_body_row(), add_footer(), add_footer_lines(), add_footer_row(), add_header(), add_header_lines(), add_header_row(), delete_part(), separate_header(), set_header_footer_df, set_header_labels()

Examples

ft <- flextable(head(iris))
ft <- delete_columns(ft, j = "Species")
ft

Delete flextable part

Description

indicate to not print a part of the flextable, i.e. an header, footer or the body.

Usage

delete_part(x, part = "header")

Arguments

See Also

Other functions for row and column operations in a flextable: add_body(), add_body_row(), add_footer(), add_footer_lines(), add_footer_row(), add_header(), add_header_lines(), add_header_row(), delete_columns(), separate_header(), set_header_footer_df, set_header_labels()

Examples

ft <- flextable(head(iris))
ft <- delete_part(x = ft, part = "header")
ft

Delete flextable rows

Description

The function removes one or more rows from a 'flextable'.

Usage

delete_rows(x, i = NULL, part = "body")

Arguments

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

data.frame automatic printing as a flextable

Description

Create a summary from a data.frame as a flextable. This function is to be used in an R Markdown document.

To use that function, you must declare it in the part df_print of the 'YAML' header of your R Markdown document:

---
df_print: !expr function(x) flextable::df_printer(x)
---

We notice an unexpected behavior with bookdown. When using bookdown it is necessary to use use_df_printer() instead in a setup run chunk:

use_df_printer()

Usage

df_printer(dat, ...)

Arguments

Details

'knitr' chunk options are available to customize the output:

• ft_max_row: The number of rows to print. Default to 10.

• ft_split_colnames: Should the column names be split (with non alpha-numeric characters). Default to FALSE.

• ft_short_strings: Should the character column be shorten. Default to FALSE.

• ft_short_size: Maximum length of character column if ft_short_strings is TRUE. Default to 35.

• ft_short_suffix: Suffix to add when character values are shorten. Default to "...".

• ft_do_autofit: Use autofit() before rendering the table. Default to TRUE.

• ft_show_coltype: Show column types. Default to TRUE.

• ft_color_coltype: Color to use for column types. Default to "#999999".

See Also

Other flextable print function: flextable_to_rmd(), gen_grob(), htmltools_value(), knit_print.flextable(), plot.flextable(), print.flextable(), save_as_docx(), save_as_html(), save_as_image(), save_as_pptx(), save_as_rtf(), to_html.flextable(), wrap_flextable()

Examples

df_printer(head(mtcars))

Get column widths and row heights of a flextable

Description

returns widths and heights for each table columns and rows. Values are expressed in inches.

Usage

## S3 method for class 'flextable'
dim(x)

Arguments

See Also

Other functions for flextable size management: autofit(), dim_pretty(), fit_to_width(), flextable_dim(), height(), hrule(), ncol_keys(), nrow_part(), width()

Examples

ftab <- flextable(head(iris))
dim(ftab)

Get optimal width and height of a flextable grob

Description

returns the optimal width and height for the grob, according to the grob generation parameters.

Usage

## S3 method for class 'flextableGrob'
dim(x)

Arguments

Value

a named list with two elements, width and height. Values are expressed in inches.

Examples

ftab <- flextable(head(iris))
gr <- gen_grob(ftab)
dim(gr)

Calculate optimal column widths and row heights

Description

return minimum estimated widths and heights for each table columns and rows in inches.

Usage

dim_pretty(x, part = "all", unit = "in", hspans = "none")

Arguments

See Also

Other functions for flextable size management: autofit(), dim.flextable(), fit_to_width(), flextable_dim(), height(), hrule(), ncol_keys(), nrow_part(), width()

Examples

ftab <- flextable(head(mtcars))
dim_pretty(ftab)

Make blank columns transparent

Description

Blank columns are set as transparent. This is a shortcut function that deletes top and bottom borders, changes the background color to transparent, displays empty content, and sets blank column widths.

Usage

empty_blanks(x, width = 0.05, unit = "in", part = "all")

Arguments

See Also

Other sugar functions for table style: align(), bg(), bold(), color(), font(), fontsize(), highlight(), italic(), keep_with_next(), line_spacing(), padding(), rotate(), style(), tab_settings(), valign()

Examples

typology <- data.frame(
  col_keys = c(
    "Sepal.Length", "Sepal.Width", "Petal.Length",
    "Petal.Width", "Species"
  ),
  what = c("Sepal", "Sepal", "Petal", "Petal", " "),
  measure = c("Length", "Width", "Length", "Width", "Species"),
  stringsAsFactors = FALSE
)
typology

ftab <- flextable(head(iris), col_keys = c(
  "Species",
  "break1", "Sepal.Length", "Sepal.Width",
  "break2", "Petal.Length", "Petal.Width"
))
ftab <- set_header_df(ftab, mapping = typology, key = "col_keys")
ftab <- merge_h(ftab, part = "header")
ftab <- theme_vanilla(ftab)
ftab <- empty_blanks(ftab)
ftab <- width(ftab, j = c(2, 5), width = .1)
ftab

Fit a flextable to a maximum width

Description

decrease font size for each cell incrementally until it fits a given max_width.

Usage

fit_to_width(x, max_width, inc = 1L, max_iter = 20, unit = "in")

Arguments

See Also

Other functions for flextable size management: autofit(), dim.flextable(), dim_pretty(), flextable_dim(), height(), hrule(), ncol_keys(), nrow_part(), width()

Examples

ft_1 <- qflextable(head(mtcars))
ft_1 <- width(ft_1, width = 1)
ft_1

ft_2 <- fit_to_width(ft_1, max_width = 4)
ft_2

Fix border issues when cells are merged

Description

When cells are merged, the rendered borders will be those of the first cell. If a column is made of three merged cells, the bottom border that will be seen will be the bottom border of the first cell in the column. From a user point of view, this is wrong, the bottom should be the one defined for cell 3. This function modify the border values to avoid that effect.

Note since version ⁠0.9.7⁠ that the function is called automatically before rendering, user should not have to call this function anymore.

Usage

fix_border_issues(x, part = "all")

Arguments

Examples

library(officer)
dat <- data.frame(a = 1:5, b = 6:10)
ft <- flextable(dat)
ft <- theme_box(ft)
ft <- merge_at(ft, i = 4:5, j = 1, part = "body")
ft <- hline(ft,
  i = 5, part = "body",
  border = fp_border(color = "red", width = 5)
)
print(ft)
ft <- fix_border_issues(ft)
print(ft)

Create a flextable from a data frame

Description

Create a flextable object with function flextable.

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 knit_print.flextable() and about setting default values with set_flextable_defaults().

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

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 fontsize() function over and over again for each new flextable, set the font size default value by calling (before creating the flextables) 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 set_flextable_defaults(). You can reset them with function init_flextable_defaults(). You can access these values by calling get_flextable_defaults().

new lines and tabulations

The 'flextable' package will translate for you the new lines expressed in the form ⁠\n⁠ and the tabs expressed in the form ⁠\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:

• HTML is using entity em space

• Word - a Word 'tab' element

• PowerPoint - a PowerPoint 'tab' element

• latex - tag "\quad "

flextable parts

A flextable is made of 3 parts: header, body and footer.

Most functions have an argument named part that will be used to specify what part of of the table should be modified.

qflextable

qflextable is a convenient tool to produce quickly a flextable for reporting where layout is fixed (see set_table_properties()) and columns widths are adjusted with autofit().

See Also

style(), autofit(), theme_booktabs(), knit_print.flextable(), compose(), footnote(), set_caption()

Examples

ft <- flextable(head(mtcars))
ft

Get overall width and height of a flextable

Description

Returns the width, height and aspect ratio of a flextable in a named list. The aspect ratio is the ratio corresponding to height/width.

Names of the list are widths, heights and aspect_ratio.

Usage

flextable_dim(x, unit = "in")

Arguments

See Also

Other functions for flextable size management: autofit(), dim.flextable(), dim_pretty(), fit_to_width(), height(), hrule(), ncol_keys(), nrow_part(), width()

Examples

ftab <- flextable(head(iris))
flextable_dim(ftab)
ftab <- autofit(ftab)
flextable_dim(ftab)

htmlDependency for flextable objects

Description

When using loops in an R Markdown for HTML document, the htmlDependency object for flextable must also be added at least once.

Usage

flextable_html_dependency()

Examples

if (require("htmltools")) {
  div(flextable_html_dependency())
}

Selectors in flextable

Description

Selectors are a core feature of flextable that allow you to specify which parts (part), rows (i) and columns (j) should be affected by formatting, styling, or content operations.

Many flextable functions support these selectors, including bg(), bold(), color(), padding(), fontsize(), italic(), align(), mk_par(), hline(), vline(), and many others.

Selectors make conditional formatting easy and enable seamless piping of multiple operations using ⁠%>%⁠ or ⁠|>⁠.

Row selection with the i parameter

The i parameter is used to select specific rows in a flextable for formatting, styling, or content operations.

When i = NULL (the default), operations apply to all rows.

i = ~ condition           # Formula (body only)
i = 1:5                   # Integer vector
i = c(TRUE, FALSE, ...)   # Logical vector
i = NULL                  # All rows (default)

Best practices:

• Use formulas (i = ~ condition) for conditional selection in body

• Use integers for positional selection in any part.

• Use nrow_part() for dynamic row selection

Column selection with the j parameter

The j parameter is used to select specific columns in a flextable for formatting, styling, or content operations.

When j = NULL (the default), operations apply to all columns.

j = ~ col1 + col2         # Formula (select multiple)
j = ~ . - col1            # Formula (exclude columns)
j = c("col1", "col2")     # Character vector (recommended)
j = 1:5                   # Integer vector
j = c(TRUE, FALSE, ...)   # Logical vector
j = NULL                  # All columns (default)

Best practices:

• Use character vectors (j = c("col1", "col2")) for clarity and maintainability.

• Use formulas (j = ~ col1 + col2) for excluding columns.

• Avoid integer positions when possible (less maintainable).

• Column selectors work with all parts (header, body, footer, all).

Part selection with the part parameter

The part parameter specifies which section of the flextable should be affected by formatting, styling, or content operations.

part = "body"    # Data rows (default)
part = "header"  # Header rows
part = "footer"  # Footer rows
part = "all"     # All parts

• When part = "body" (the default), operations apply only to the data rows.

• When part = "all", the operation is applied to each part independently.

Formula row selectors (i = ~ condition) CANNOT be used with:

• part = "header" - Headers contain only character values

• part = "footer" - Footers contain only character values

• part = "all" - Header/footer are character-only while body has original data types

This restriction exists because formula selectors evaluate conditions using the actual data types from your dataset (numeric, logical, etc.). Headers and footers store only character representations of values, so conditional expressions like i = ~ price < 330 cannot be evaluated on them.

Advanced Programming with Selectors

Function nrow_part() returns the number of lines in a part.

# Format the last row differently
ft <- flextable(iris[48:52,])
ft <- bold(ft, i = nrow_part(ft, part = "body"))

# Add footnote to last row
ft <- footnote(
  ft,
  i = nrow_part(ft, part = "body"), j = 1:4,
  value = as_paragraph("Calculated mean")
)
ft

Function ncol_keys() returns the number of columns.

# Get column count
ncol_keys(ft)

# Useful for programmatic selection
ncols <- ncol_keys(ft)
ft <- bg(ft, j = rep(c(TRUE, FALSE), length.out = ncols), bg = "#f0f0f0")
ft

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.

Usage

flextable_to_rmd(x, ...)

Arguments

See Also

Other flextable print function: df_printer(), gen_grob(), htmltools_value(), knit_print.flextable(), plot.flextable(), print.flextable(), save_as_docx(), save_as_html(), save_as_image(), save_as_pptx(), save_as_rtf(), to_html.flextable(), wrap_flextable()

Examples

## Not run: 
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"
  )
}

## End(Not run)

Format summarizor statistics as text

Description

Format the output of summarizor() into display strings: quantitative variables are shown as mean (sd), median (IQR), or range; qualitative variables are shown as count (percentage).

Usage

fmt_2stats(stat, num1, num2, cts, pcts, ...)

fmt_summarizor(stat, num1, num2, cts, pcts, ...)

Arguments

See Also

summarizor(), tabulator(), mk_par()

Other text formatter functions: fmt_avg_dev(), fmt_dbl(), fmt_header_n(), fmt_int(), fmt_n_percent(), fmt_pct(), fmt_signif_after_zeros()

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

Format mean and standard deviation as text

Description

Format means and standard deviations as mean (sd).

Usage

fmt_avg_dev(avg, dev, digit1 = 1, digit2 = 1)

Arguments

See Also

tabulator(), mk_par()

Other text formatter functions: fmt_2stats(), fmt_dbl(), fmt_header_n(), fmt_int(), fmt_n_percent(), fmt_pct(), fmt_signif_after_zeros()

Examples

library(flextable)

df <- data.frame(avg = 1:3 * 3, sd = 1:3)

ft_1 <- flextable(df, col_keys = "avg")
ft_1 <- mk_par(
  x = ft_1, j = 1, part = "body",
  value = as_paragraph(fmt_avg_dev(avg = avg, dev = sd))
)
ft_1 <- autofit(ft_1)
ft_1

Format numbers as doubles

Description

Format numeric values with decimal digits, using the flextable default settings for separators and precision.

Usage

fmt_dbl(x)

Arguments

See Also

tabulator(), mk_par()

Other text formatter functions: fmt_2stats(), fmt_avg_dev(), fmt_header_n(), fmt_int(), fmt_n_percent(), fmt_pct(), fmt_signif_after_zeros()

Examples

library(flextable)

df <- data.frame(zz = .45)

ft_1 <- flextable(df)
ft_1 <- mk_par(
  x = ft_1, j = 1, part = "body",
  value = as_paragraph(as_chunk(zz, formatter = fmt_dbl))
)
ft_1 <- autofit(ft_1)
ft_1

Format count as '(N=XX)' for column headers

Description

Format counts as ⁠\n(N=XX)⁠ for appending sample sizes to column titles.

Usage

fmt_header_n(n, newline = TRUE)

Arguments

See Also

tabulator(), mk_par()

Other text formatter functions: fmt_2stats(), fmt_avg_dev(), fmt_dbl(), fmt_int(), fmt_n_percent(), fmt_pct(), fmt_signif_after_zeros()

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

Format numbers as integers

Description

Format numeric values as integers (no decimals).

Usage

fmt_int(x)

Arguments

See Also

tabulator(), mk_par()

Other text formatter functions: fmt_2stats(), fmt_avg_dev(), fmt_dbl(), fmt_header_n(), fmt_n_percent(), fmt_pct(), fmt_signif_after_zeros()

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

Format count and percentage as text

Description

Format counts and percentages as ⁠n (xx.x%)⁠. If percentages are missing, only the count is shown.

Usage

fmt_n_percent(n, pct, digit = 1)

Arguments

See Also

tabulator(), mk_par()

Other text formatter functions: fmt_2stats(), fmt_avg_dev(), fmt_dbl(), fmt_header_n(), fmt_int(), fmt_pct(), fmt_signif_after_zeros()

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

Format numbers as percentages

Description

Format numeric values as percentages (e.g. "45.0%").

Usage

fmt_pct(x)

Arguments

See Also

tabulator(), mk_par()

Other text formatter functions: fmt_2stats(), fmt_avg_dev(), fmt_dbl(), fmt_header_n(), fmt_int(), fmt_n_percent(), fmt_signif_after_zeros()

Examples

library(flextable)

df <- data.frame(zz = .45)

ft_1 <- flextable(df)
ft_1 <- mk_par(
  x = ft_1, j = 1, part = "body",
  value = as_paragraph(as_chunk(zz, formatter = fmt_pct))
)
ft_1 <- autofit(ft_1)
ft_1

Format with significant figures after zeros

Description

Rounds significant figures after zeros in numeric vectors. The number of digits displayed after the leading zeros is customizable using the digits parameter.

Usage

fmt_signif_after_zeros(x, digits = 3)

Arguments

See Also

tabulator(), mk_par()

Other text formatter functions: fmt_2stats(), fmt_avg_dev(), fmt_dbl(), fmt_header_n(), fmt_int(), fmt_n_percent(), fmt_pct()

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)))

Set font

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 gdtools::register_gfont() function. When the output is HTML, the font will be automatically added to the HTML document.

Usage

font(
  x,
  i = NULL,
  j = NULL,
  fontname,
  part = "body",
  cs.family = fontname,
  hansi.family = fontname,
  eastasia.family = fontname
)

Arguments

See Also

Other sugar functions for table style: align(), bg(), bold(), color(), empty_blanks(), fontsize(), highlight(), italic(), keep_with_next(), line_spacing(), padding(), rotate(), style(), tab_settings(), valign()

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
}

Set font size

Description

Change the font size of selected rows and columns of a flextable.

Usage

fontsize(x, i = NULL, j = NULL, size = 11, part = "body")

Arguments

See Also

Other sugar functions for table style: align(), bg(), bold(), color(), empty_blanks(), font(), highlight(), italic(), keep_with_next(), line_spacing(), padding(), rotate(), style(), tab_settings(), valign()

Examples

ft <- flextable(head(iris))
ft <- fontsize(ft, size = 14, part = "header")
ft <- fontsize(ft, size = 14, j = 2)
ft <- fontsize(ft, size = 7, j = 3)
ft

Add flextable at a bookmark location in document's footer

Description

Function is now defunct, use officer::prop_section() instead.

Usage

footers_flextable_at_bkm(...)

Arguments

Add footnotes to flextable

Description

The function let add footnotes to a flextable object by adding some symbols in the flextable and associated notes in the footer of the flextable.

Symbols are added to the cells designated by the selection i and j. If you use i = c(1,3) and j = c(2,5), then you will add the symbols (or the repeated symbol) to cells ⁠[1,2]⁠ and ⁠[3,5]⁠.

Usage

footnote(
  x,
  i = NULL,
  j = NULL,
  value,
  ref_symbols = NULL,
  part = "body",
  inline = FALSE,
  sep = "; ",
  symbol_sep = ""
)

Arguments

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

Create border formatting with flextable defaults

Description

Create a officer::fp_border() object whose unspecified arguments inherit from set_flextable_defaults() (border color, width).

Use fp_border_default() instead of officer::fp_border() so that borders automatically match the table's default style.

Usage

fp_border_default(
  color = flextable_global$defaults$border.color,
  style = "solid",
  width = flextable_global$defaults$border.width
)

Arguments

See Also

hline(), vline()

Other functions for defining formatting properties: fp_text_default()

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()

Create text formatting with flextable defaults

Description

Create a officer::fp_text() object whose unspecified arguments inherit from set_flextable_defaults() (font family, size, color).

Use fp_text_default() instead of officer::fp_text() when building chunks with as_chunk(): only override the properties you need, and the rest will match the table's default style.

See also set_flextable_defaults() to modify the inherited values.

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

See Also

as_chunk(), compose(), append_chunks(), prepend_chunks()

Other functions for defining formatting properties: fp_border_default()

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()

Render a flextable as a graphic object

Description

gen_grob() converts a flextable into a Grid Graphics object (grob) that can be drawn on any R graphic device. This is the function behind save_as_image() and the patchwork integration (wrap_flextable()).

Typical uses:

• embed a flextable in a ggplot2 plot (via wrap_flextable() or cowplot)

• export a flextable as a PNG or SVG image (via save_as_image())

Text wrapping and scaling are supported. The fit argument controls how the table adapts to the available space (fixed size, auto-fit width, or fill the device).

Not recommended for very large tables because the grid calculations can be slow.

Limitations: equations (as_equation()) and hyperlinks (officer::hyperlink_ftext()) are not rendered.

Use a 'ragg', 'svglite' or 'ggiraph' device for correct rendering.

Usage

gen_grob(
  x,
  ...,
  fit = c("auto", "width", "fixed"),
  scaling = c("min", "full", "fixed"),
  wrapping = TRUE,
  autowidths = TRUE,
  just = NULL
)

Arguments

Value

a grob (gTree) object made with package grid

size

The size of the flextable can be known by using the method dim on the grob.

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.

See Also

Other flextable print function: df_printer(), flextable_to_rmd(), htmltools_value(), knit_print.flextable(), plot.flextable(), print.flextable(), save_as_docx(), save_as_html(), save_as_image(), save_as_pptx(), save_as_rtf(), to_html.flextable(), wrap_flextable()

Examples

library(ragg)
library(gdtools)
register_liberationsans()

set_flextable_defaults(font.family = "Liberation Sans")

ft <- flextable(head(mtcars))
gr <- gen_grob(ft)

plot(gr)

Get flextable defaults formatting properties

Description

The current formatting properties are automatically applied to every flextable you produce. These default values are returned by this function.

Usage

get_flextable_defaults()

Value

a list containing default values.

See Also

Other functions related to themes: set_flextable_defaults(), theme_alafoli(), theme_apa(), theme_booktabs(), theme_borderless(), theme_box(), theme_tron(), theme_tron_legacy(), theme_vader(), theme_vanilla(), theme_zebra()

Examples

get_flextable_defaults()

ggplot chunk

Description

This function is used to insert mini gg plots into flextable with functions:

• compose() and as_paragraph(),

• append_chunks(),

• prepend_chunks().

Usage

gg_chunk(value, width = 1, height = 0.2, unit = "in", res = 300)

Arguments

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.

See Also

Other chunk elements for paragraph: as_b(), as_bracket(), as_chunk(), as_equation(), as_highlight(), as_i(), as_image(), as_qmd(), as_strike(), as_sub(), as_sup(), as_word_field(), colorize(), grid_chunk(), hyperlink_text(), linerange(), minibar(), plot_chunk()

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
}

Grid Graphics chunk

Description

This function is used to insert grid objects into flextable with functions:

• compose() and as_paragraph(),

• append_chunks(),

• prepend_chunks().

Usage

grid_chunk(value, width = 1, height = 0.2, unit = "in", res = 300)

Arguments

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.

See Also

Other chunk elements for paragraph: as_b(), as_bracket(), as_chunk(), as_equation(), as_highlight(), as_i(), as_image(), as_qmd(), as_strike(), as_sub(), as_sup(), as_word_field(), colorize(), gg_chunk(), hyperlink_text(), linerange(), minibar(), plot_chunk()

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

Add flextable at a bookmark location in document's header

Description

Function is now defunct, use officer::prop_section() instead.

Usage

headers_flextable_at_bkm(...)

Arguments

Set flextable rows height

Description

control rows height for a part of the flextable when the line height adjustment is "atleast" or "exact" (see hrule()).

Usage

height(x, i = NULL, height, part = "body", unit = "in")

height_all(x, height, part = "all", unit = "in")

Arguments

height_all

height_all is a convenient function for setting the same height to all rows (selected with argument part).

Note

This function has no effect when the rule for line height is set to "auto" (see hrule()), which is the default case, except with PowerPoint which does not support this automatic line height adjustment feature.

See Also

Other functions for flextable size management: autofit(), dim.flextable(), dim_pretty(), fit_to_width(), flextable_dim(), hrule(), ncol_keys(), nrow_part(), width()

Examples

ft_1 <- flextable(head(iris))
ft_1 <- height(ft_1, height = .5)
ft_1 <- hrule(ft_1, rule = "exact")
ft_1


ft_2 <- flextable(head(iris))
ft_2 <- height_all(ft_2, height = 1)
ft_2 <- hrule(ft_2, rule = "exact")
ft_2

Set text highlight color

Description

Change the text highlight color of selected rows and columns of a flextable. A function can be used instead of fixed colors.

When color is a function, it is possible to color cells based on values located in other columns; using hidden columns (those not used by argument colkeys) is a common use case. The argument source must be used to define the columns to be used for the color definition, and the argument j must be used to define where to apply the colors and only accepts values from colkeys.

Usage

highlight(x, i = NULL, j = NULL, color = "yellow", part = "body", source = j)

Arguments

See Also

Other sugar functions for table style: align(), bg(), bold(), color(), empty_blanks(), font(), fontsize(), italic(), keep_with_next(), line_spacing(), padding(), rotate(), style(), tab_settings(), valign()

Examples

my_color_fun <- function(x) {
  out <- rep("yellow", length(x))
  out[x < quantile(x, .75)] <- "pink"
  out[x < quantile(x, .50)] <- "wheat"
  out[x < quantile(x, .25)] <- "gray90"
  out
}
ft <- flextable(head(mtcars, n = 10))
ft <- highlight(ft, j = "disp", i = ~ disp > 200, color = "yellow")
ft <- highlight(ft, j = ~ drat + wt + qsec, color = my_color_fun)
ft

Set horizontal borders below selected rows

Description

hline() draws a horizontal line below each selected row by setting the bottom border of cells at row i (and the top border of cells at row i + 1 so that the line renders consistently across output formats).

Use the i selector to target specific rows (e.g. a formula such as ~ before(col, "Total")). When i is NULL (the default) the border is added below every row, which produces a full grid of inner horizontal lines.

For the outer edges of the table, use hline_top() and hline_bottom() instead; those always target the very first or very last row of a part.

Usage

hline(x, i = NULL, j = NULL, border = NULL, part = "body")

Arguments

See Also

Other borders management: border_inner(), border_inner_h(), border_inner_v(), border_outer(), border_remove(), hline_bottom(), hline_top(), surround(), vline(), vline_left(), vline_right()

Examples

library(officer)
std_border <- fp_border(color = "gray")

ft <- flextable(head(iris))
ft <- border_remove(x = ft)

# add horizontal borders below every row
ft <- hline(ft, part = "all", border = std_border)
ft

Set the bottom border of a table part

Description

hline_bottom() draws a horizontal line at the very bottom of a table part. It does not accept a row selector i because it always targets the last row.

Unlike hline(), which adds inner lines below arbitrary rows, hline_bottom() is meant for the outer bottom edge of a part.

Usage

hline_bottom(x, j = NULL, border = NULL, part = "body")

Arguments

See Also

Other borders management: border_inner(), border_inner_h(), border_inner_v(), border_outer(), border_remove(), hline(), hline_top(), surround(), vline(), vline_left(), vline_right()

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

Set the top border of a table part

Description

hline_top() draws a horizontal line at the very top of a table part. It does not accept a row selector i because it always targets the first row.

When the part above exists (e.g. header above body), the line is stored as the bottom border of that adjacent part so that it renders seamlessly.

Unlike hline(), which adds inner lines below arbitrary rows, hline_top() is meant for the outer top edge of a part.

Usage

hline_top(x, j = NULL, border = NULL, part = "body")

Arguments