x = NULL,

y = NULL,

xmin = NULL,

xmax = NULL,

ymin = NULL,

ymax = NULL,

by = NULL,

facet = NULL,

facet.args = NULL,

data = NULL,

type = NULL,

legend = NULL,

main = NULL,

sub = NULL,

xlab = NULL,

ylab = NULL,

ann = par("ann"),

xlim = NULL,

ylim = NULL,

axes = TRUE,

xaxt = NULL,

yaxt = NULL,

xaxs = NULL,

yaxs = NULL,

xaxb = NULL,

yaxb = NULL,

xaxl = NULL,

yaxl = NULL,

log = "",

flip = FALSE,

frame.plot = NULL,

grid = NULL,

palette = NULL,

pch = NULL,

lty = NULL,

lwd = NULL,

col = NULL,

bg = NULL,

fill = NULL,

alpha = NULL,

cex = NULL,

add = FALSE,

draw = NULL,

empty = FALSE,

restore.par = FALSE,

file = NULL,

width = NULL,

height = NULL,

asp = NA,

theme = NULL,

...) {

# Force evaluation of legend if it's a symbol to avoid downstream promise

# issues. Let sanitize_legend handle it

if (!missing(legend) && is.symbol(substitute(legend))) {

legend = legend

}

#

## save parameters and calls -----

#

par_first = get_saved_par("first")

if (is.null(par_first)) set_saved_par("first", par())

# save for tinyplot_add()

assert_logical(add)

if (!add) {

calls = sys.calls()

is_tinyplot_call = function(x) identical(tinyplot, try(eval(x[[1L]]), silent = TRUE))

idx = which(vapply(calls, is_tinyplot_call, FALSE))

if (length(idx) > 0) {

set_environment_variable(.last_call = calls[[idx[1L]]])

}

}

# Save current graphical parameters

opar = par(no.readonly = TRUE)

if (restore.par || !is.null(facet)) {

if (!is.null(file) || !is.null(width) || !is.null(height)) {

opar$new = FALSE # catch for some interfaces

}

on.exit(par(opar), add = TRUE)

}

set_saved_par(when = "before", opar)

# Catch for adding to existing facet plot

if (!is.null(facet) && add) {

recordGraphics(

par(get_saved_par(when = "after")),

list = list(),

env = getNamespace('tinyplot')

)

}

# Ephemeral theme

if (!is.null(theme)) {

if (is.character(theme) && length(theme) == 1) {

tinytheme(theme)

} else if (is.list(theme)) {

do.call(tinytheme, theme)

} else {

warning('Argument `theme` must be a character of length 1 (e.g. "clean"), or a list. Ignoring.')

}

if (is.character(theme) && theme == "default") {

# Reset mar to pre-theme value so legend margin adjustment isn't

# clobbered. Only needed for "default" theme which uses hook = FALSE

# and thus sets par(mar) immediately. (#557)

par(mar = opar$mar)

on.exit(init_tpar(rm_hook = TRUE), add = TRUE)

} else {

dtheme = theme_default

otheme = opar[names(dtheme)]

on.exit(do.call(tinytheme, otheme), add = TRUE)

}

}

#

## settings container -----

#

dots = list(...)

settings_list = list(

# save call to check user input later

call = match.call(),

# save to file & device dimensions

file = file,

width = width,

height = height,

# deparsed input for use in labels

by_dep = deparse1(substitute(by)),

cex_dep = if (!is.null(cex)) deparse1(substitute(cex)) else NULL,

facet_dep = deparse1(substitute(facet)),

x_dep = if (is.null(x)) NULL else deparse1(substitute(x)),

xmax_dep = if (is.null(xmax)) NULL else deparse1(substitute(xmax)),

xmin_dep = if (is.null(xmin)) NULL else deparse1(substitute(xmin)),

y_dep = if (is.null(y)) NULL else deparse1(substitute(y)),

ymax_dep = if (is.null(ymax)) NULL else deparse1(substitute(ymax)),

ymin_dep = if (is.null(ymin)) NULL else deparse1(substitute(ymin)),

# types

type = type,

type_data = NULL,

type_draw = NULL,

type_name = NULL,

# type-specific settings

bubble = FALSE,

bubble_pch = NULL,

bubble_alpha = NULL,

bubble_bg_alpha = NULL,

ygroup = NULL, # for type_ridge()

# data points and labels

x = x,

xmax = xmax,

xmin = xmin,

xlab = xlab,

xlabs = NULL,

y = y,

ymax = ymax,

ymin = ymin,

ylab = ylab,

ylabs = NULL,

# axes

axes = axes,

xaxt = xaxt,

xaxb = xaxb,

xaxl = xaxl,

xaxs = xaxs,

yaxt = yaxt,

yaxb = yaxb,

yaxl = yaxl,

yaxs = yaxs,

frame.plot = frame.plot,

xlim = xlim,

ylim = ylim,

# flags to check user input (useful later on)

null_by = is.null(by),

null_xlim = is.null(xlim),

null_ylim = is.null(ylim),

# when palette functions need pre-processing this check raises error

null_palette = tryCatch(is.null(palette), error = function(e) FALSE),

x_by = identical(x, by), # for "boxplot", "spineplot" and "ridge"

# unevaluated expressions with side effects

draw = substitute(draw),

facet = facet,

facet.args = facet.args,

palette = substitute(palette),

legend = if (add) FALSE else substitute(legend),

# aesthetics

lty = lty,

lwd = lwd,

col = col,

bg = bg,

log = log,

fill = fill,

alpha = alpha,

cex = cex,

pch = if (is.null(pch)) get_tpar("pch", default = NULL) else pch,

# ribbon.alpha overwritten by some type_data() functions

# sanitize_ribbon_alpha: returns default alpha transparency for ribbon-type plots

ribbon.alpha = sanitize_ribbon_alpha(NULL),

# misc

add = add,

by = by,

dodge = NULL,

dots = dots,

flip = flip,

group_offsets = NULL,

offsets_axis = NULL,

type_info = list() # pass type-specific info from type_data to type_draw

)

settings = new.env()

list2env(settings_list, settings)

#

## devices and files -----

#

# Write plot to output file or window with fixed dimensions

setup_device(settings)

if (!is.null(settings$file)) on.exit(dev.off(), add = TRUE)

#

## sanitize arguments -----

#

# extract legend_args from dots

if ("legend_args" %in% names(dots)) {

settings$legend_args = settings$dots[["legend_args"]]

settings$dots$legend_args = NULL # avoid passing both directly and via ...

} else {

settings$legend_args = list(x = NULL)

}

# alias: bg = fill

if (is.null(bg) && !is.null(fill)) settings$bg = fill

# validate types and returns a list with name, data, and draw components

sanitize_type(settings)

# standardize axis arguments and returns consistent axes, xaxt, yaxt, frame.plot

sanitize_axes(settings)

# generate appropriate axis labels based on input data and plot type

sanitize_xylab(settings)

# palette default

if (is.null(settings$palette)) {

settings$palette = get_tpar("palette", default = NULL)

}

# by: coerce character groups to factor

if (!settings$null_by && is.character(settings$by)) {

settings$by = factor(settings$by)

}

# flag if x==by, currently only used for

#

# facet: parse facet formula and prepares variables when facet==by

sanitize_facet(settings)

# x / y processing

# convert characters to factors

# set x automatically when omitted (ex: rect)

# set y automatically when omitted (ex: boxplots)

# combine x, y, xmax, by, facet etc. into a single `datapoints` data.frame

sanitize_datapoints(settings)

#

## transform datapoints using type_data() -----

#

if (!is.null(settings$type_data)) {

settings$type_data(settings, ...)

}

# ensure axis aligment of any added layers

if (!add) {

assign("xlabs_orig", settings[["xlabs"]], envir = get(".tinyplot_env", envir = parent.env(environment())))

assign(".group_offsets", settings[["group_offsets"]], envir = get(".tinyplot_env", envir = parent.env(environment())))

assign(".offsets_axis", settings[["offsets_axis"]], envir = get(".tinyplot_env", envir = parent.env(environment())))

} else {

align_layer(settings)

}

# flip -> swap x and y after type_data, except for boxplots (which has its own bespoke flip logic)

flip_datapoints(settings)

#

## bubble plot -----

#

# Transform cex values for bubble charts. Handles size transformation, legend

# gotchas, and aesthetic sanitization.

# Currently limited to "p" and "text" types, but could expand to others.

bubble(settings)

#

## axis breaks and limits -----

#

# do this after computing yaxb because limits will depend on the previous calculations

if (!add) {

lim_args(settings)

}

#

## facets: count -----

#

# facet_layout processes facet simplification, attribute restoration, and layout

facet_layout(settings)

#

## aesthetics by group -----

#

by_aesthetics(settings)

#

## legends -----

#

prepare_legend(settings)

#

## make settings available in the environment directly -----

#

env2env(settings, environment())

if (legend_draw_flag) {

if (!multi_legend) {

## simple case: single legend only

if (is.null(lgnd_cex)) lgnd_cex = cex * cex_fct_adj

draw_legend(

legend = legend,

legend_args = legend_args,

by_dep = by_dep,

lgnd_labs = lgnd_labs,

type = type,

pch = pch,

lty = lty,

lwd = lwd,

col = col,

bg = bg,

gradient = by_continuous,

cex = lgnd_cex,

has_sub = has_sub

)

} else {

## multi-legend case...

prepare_legend_multi(settings)

env2env(settings, environment(), c("legend_args", "lgby", "lgbub"))

# draw multi-legend

draw_multi_legend(list(lgby, lgbub), position = legend_args[["x"]])

}

has_legend = TRUE

} else if (legend_args[["x"]] == "none" && !isTRUE(add)) {

omar = par("mar")

ooma = par("oma")

topmar_epsilon = 0.1

# Catch to avoid recursive offsets, e.g. repeated tinyplot calls with

# "bottom!" legend position.

restore_margin_inner(ooma)

# clean up for now

rm(omar, ooma, topmar_epsilon)

# Draw new plot

plot.new()

}

#

## title and subtitle -----

#

if (!add) {

draw_title(main, sub, xlab, ylab, legend, legend_args, opar)

}

#

## facets: draw -----

#

# Two-phase plotting logic: First determine and draw all exterior elements

# (facet windows, axes, grid, etc.), then circle back to each facet and