1.24.1 [skip ci]

Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>

Project.toml

@@ -1,7 +1,7 @@
 name = "Plots"
 uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
 author = ["Tom Breloff (@tbreloff)"]
-version = "1.23.4"
+version = "1.24.1"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
@@ -38,7 +38,7 @@ UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
 Contour = "0.5"
 FFMPEG = "0.2 - 0.4"
 FixedPointNumbers = "0.6 - 0.8"
-GR = "0.62"
+GR = "0.62.1"
 GeometryBasics = "0.2, 0.3.1, 0.4"
 JSON = "0.21, 1"
 Latexify = "0.14 - 0.15"
@@ -46,7 +46,7 @@ Measures = "0.3"
 NaNMath = "0.3"
 PlotThemes = "2"
 PlotUtils = "1"
-RecipesBase = "1"
+RecipesBase = "1.2"
 RecipesPipeline = "0.3.5, 0.4"
 Reexport = "0.2, 1.0"
 Requires = "1"

deps/SnoopCompile/precompile/precompile_Plots.jl

@@ -66,8 +66,6 @@ end
 
 function _precompile_()
     ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
-    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:label, :blank), Tuple{Symbol, Bool}},Type{EmptyLayout}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:label, :width, :height), Tuple{Symbol, Symbol, Length{:pct, Float64}}},Type{EmptyLayout}})
     Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{GridLayout}},Type{Subplot},GRBackend})
     Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{GridLayout}},Type{Subplot},PlotlyBackend})
     Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{Subplot{GRBackend}}},Type{Subplot},GRBackend})
@@ -76,28 +74,20 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}, Vector{Float64}},Tuple{Int64, Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Vector{Int64}}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:flip,), Tuple{Bool}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,), Tuple{Symbol}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,), Tuple{typeof(datetimeformatter)}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :flip, :minorgrid, :guide), Tuple{Bool, Bool, Bool, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :lims), Tuple{Bool, Tuple{Float64, Float64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :lims, :flip), Tuple{Bool, Tuple{Float64, Float64}, Bool}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :minorgrid, :guide), Tuple{Bool, Bool, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :minorgrid, :mirror, :guide), Tuple{Bool, Bool, Bool, String}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid,), Tuple{Bool}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:gridlinewidth, :grid, :gridalpha, :gridstyle, :foreground_color_grid), Tuple{Int64, Bool, Float64, Symbol, RGBA{Float64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide,), Tuple{String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide_position, :guidefontvalign, :mirror, :guide), Tuple{Symbol, Symbol, Bool, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guidefonthalign, :guide_position, :mirror, :guide), Tuple{Symbol, Symbol, Bool, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims, :flip, :ticks, :guide), Tuple{Tuple{Int64, Int64}, Bool, StepRange{Int64, Int64}, String}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Float64, Float64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Int64, Float64}}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Int64, Int64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:minorgrid, :scale, :guide), Tuple{Bool, Symbol, String}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:minorgrid,), Tuple{Bool}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:rotation,), Tuple{Int64}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,), Tuple{Nothing}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,), Tuple{UnitRange{Int64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:shape,), Tuple{Symbol}},typeof(default)})
     Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:titlefont, :legendfontsize, :guidefont, :tickfont, :guide, :framestyle, :yminorgrid), Tuple{Tuple{Int64, String}, Int64, Tuple{Int64, Symbol}, Tuple{Int64, Symbol}, String, Symbol, Bool}},typeof(default)})
     Base.precompile(Tuple{Core.kwftype(typeof(font)),NamedTuple{(:family, :pointsize, :halign, :valign, :rotation, :color), Tuple{String, Int64, Symbol, Symbol, Float64, RGBA{Float64}}},typeof(font)})
@@ -107,13 +97,11 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),UnitRange{Int64},UnitRange{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),UnitRange{Int64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),Vector{Int64},Vector{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(gr_set_font)),NamedTuple{(:halign, :valign, :rotation), Tuple{Symbol, Symbol, Int64}},typeof(gr_set_font),Font,Subplot{GRBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(gr_set_font)),NamedTuple{(:rotation, :color), Tuple{Int64, RGBA{Float64}}},typeof(gr_set_font),Font,Subplot{GRBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Plot{GRBackend},Vector{GeometryBasics.Point2{Float64}}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{GeometryBasics.Point2{Float64}}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Vector{GeometryBasics.Point2{Float64}}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:annotation,), Tuple{Vector{Tuple{Int64, Float64, Tuple{String, Any, Any, Any}}}}},typeof(plot!)})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:layout, :margin), Tuple{GridLayout, AbsoluteLength}},typeof(plot!),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:layout, :margin), Tuple{Matrix{Any}, AbsoluteLength}},typeof(plot!),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:legend,), Tuple{Bool}},typeof(plot!),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:legend,), Tuple{Bool}},typeof(plot!),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot!),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
@@ -126,28 +114,19 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype), Tuple{Tuple{Int64, Float64, Symbol}, Vector{Any}, Symbol}},typeof(plot!),Plot{GRBackend},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype), Tuple{Tuple{Int64, Float64, Symbol}, Vector{Any}, Symbol}},typeof(plot!),Plot{PlotlyBackend},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype), Tuple{Tuple{Int64, Float64, Symbol}, Vector{Any}, Symbol}},typeof(plot!),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:markersize, :c, :seriestype), Tuple{Int64, Symbol, Symbol}},typeof(plot!),Plot{GRBackend},Vector{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:markersize, :c, :seriestype), Tuple{Int64, Symbol, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:markersize, :c, :seriestype), Tuple{Int64, Symbol, Symbol}},typeof(plot!),Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Plot{GRBackend},Vector{Int64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Plot{PlotlyBackend},Vector{Int64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Vector{Int64},Vector{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Plot{GRBackend},Vector{Int64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Vector{Int64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!),Plot{GRBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!),Plot{PlotlyBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!)})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:w,), Tuple{Int64}},typeof(plot!),Plot{GRBackend},Vector{Float64},Vector{Float64},Vararg{Any, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:xgrid,), Tuple{Tuple{Symbol, Symbol, Int64, Symbol, Float64}}},typeof(plot!),Plot{GRBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis, :minorgrid), Tuple{Tuple{String, Symbol}, Bool}},typeof(plot!),Plot{GRBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis, :minorgrid), Tuple{Tuple{String, Symbol}, Bool}},typeof(plot!),Plot{PlotlyBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis, :minorgrid), Tuple{Tuple{String, Symbol}, Bool}},typeof(plot!)})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype), Tuple{Vector{Float64}, Tuple{Symbol, Float64, Stroke}, Vector{Float64}, String, Symbol}},typeof(plot!),Plot{GRBackend},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype), Tuple{Vector{Float64}, Tuple{Symbol, Float64, Stroke}, Vector{Float64}, String, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype), Tuple{Vector{Float64}, Tuple{Symbol, Float64, Stroke}, Vector{Float64}, String, Symbol}},typeof(plot!),Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:annotations, :leg), Tuple{Tuple{Int64, Float64, PlotText}, Bool}},typeof(plot),Vector{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:arrow,), Tuple{Int64}},typeof(plot),Vector{Float64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:aspect_ratio, :seriestype), Tuple{Int64, Symbol}},typeof(plot),Vector{String},Vector{String},Matrix{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:bar_width, :alpha, :color, :fillto, :label, :seriestype), Tuple{Float64, Float64, Vector{Symbol}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, String, Symbol}},typeof(plot),Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:bins, :weights, :seriestype), Tuple{Symbol, Vector{Int64}, Symbol}},typeof(plot),Vector{Float64}})
@@ -160,18 +139,17 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:lab, :w, :palette, :fill, :α), Tuple{String, Int64, PlotUtils.ContinuousColorGradient, Int64, Float64}},typeof(plot),StepRange{Int64, Int64},Matrix{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label, :title, :xlabel, :linewidth, :legend), Tuple{Matrix{String}, String, String, Int64, Symbol}},typeof(plot),Vector{Function},Float64,Float64})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label,), Tuple{Matrix{String}}},typeof(plot),Vector{AbstractVector{Float64}}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:labels,), Tuple{Matrix{String}}},typeof(plot),PortfolioComposition})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :group, :linetype, :linecolor), Tuple{GridLayout, Vector{String}, Matrix{Symbol}, Symbol}},typeof(plot),Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :group, :linetype, :linecolor), Tuple{Matrix{Any}, Vector{String}, Matrix{Symbol}, Symbol}},typeof(plot),Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :label, :fillrange, :fillalpha), Tuple{Tuple{Int64, Int64}, String, Int64, Float64}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :label, :fillrange, :fillalpha), Tuple{Tuple{Int64, Int64}, String, Int64, Float64}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :link), Tuple{Int64, Symbol}},typeof(plot),Plot{GRBackend},Plot{GRBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :link), Tuple{Int64, Symbol}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :margin), Tuple{GridLayout, AbsoluteLength}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :margin), Tuple{Matrix{Any}, AbsoluteLength}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :palette, :bg_inside), Tuple{Int64, Matrix{PlotUtils.ContinuousColorGradient}, Matrix{Symbol}}},typeof(plot),Matrix{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :t, :leg, :ticks, :border), Tuple{GridLayout, Matrix{Symbol}, Bool, Nothing, Symbol}},typeof(plot),Matrix{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :title, :titlelocation, :left_margin, :bottom_margin, :xrotation), Tuple{GridLayout, Matrix{String}, Symbol, Matrix{AbsoluteLength}, AbsoluteLength, Int64}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :t, :leg, :ticks, :border), Tuple{Matrix{Any}, Matrix{Symbol}, Bool, Nothing, Symbol}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :title, :titlelocation, :left_margin, :bottom_margin, :xrotation), Tuple{Matrix{Any}, Matrix{String}, Symbol, Matrix{AbsoluteLength}, AbsoluteLength, Int64}},typeof(plot),Matrix{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :xguide, :yguide, :xguidefonthalign, :yguidefontvalign, :xguideposition, :yguideposition, :ymirror, :xmirror, :legend, :seriestype), Tuple{Int64, String, String, Matrix{Symbol}, Matrix{Symbol}, Symbol, Matrix{Symbol}, Matrix{Bool}, Matrix{Bool}, Bool, Matrix{Symbol}}},typeof(plot),Matrix{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :xlims), Tuple{GridLayout, Tuple{Int64, Float64}}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :xlims), Tuple{Matrix{Any}, Tuple{Int64, Float64}}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout,), Tuple{Tuple{Int64, Int64}}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout,), Tuple{Tuple{Int64, Int64}}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Bool}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
@@ -195,7 +173,6 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:projection, :seriestype), Tuple{Symbol, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},UnitRange{Int64},Matrix{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:quiver, :seriestype), Tuple{Tuple{Vector{Float64}, Vector{Float64}, Vector{Float64}}, Symbol}},typeof(plot),Vector{Float64},Vector{Float64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:reg, :fill), Tuple{Bool, Tuple{Int64, Symbol}}},typeof(plot),Vector{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{Int64}},typeof(plot),UnitRange{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}},typeof(plot),UnitRange{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{Tuple{LinRange{Float64}, LinRange{Float64}}}},typeof(plot),UnitRange{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{typeof(sqrt)}},typeof(plot),UnitRange{Int64}})
@@ -217,9 +194,9 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(scatter!)),Any,typeof(scatter!),Any})
     Base.precompile(Tuple{Core.kwftype(typeof(test_examples)),NamedTuple{(:skip,), Tuple{Vector{Int64}}},typeof(test_examples),Symbol})
     Base.precompile(Tuple{Type{GridLayout},Int64,Vararg{Int64, N} where N})
+    Base.precompile(Tuple{Type{NaNSegmentsIterator},Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Vector{Float64}},Int64,Int64})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},AbstractVector{OHLC}})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},PortfolioComposition})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:barbins}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:barhist}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:bar}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:bins2d}},Any,Any,Any})
@@ -240,7 +217,6 @@ function _precompile_()
     Base.precompile(Tuple{typeof(RecipesPipeline.preprocess_attributes!),Plot{GRBackend},DefaultsDict})
     Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plot{GRBackend},Vector{Dict{Symbol, Any}},Dict{Symbol, Any}})
     Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plot{PlotlyBackend},Vector{Dict{Symbol, Any}},Dict{Symbol, Any}})
-    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{GRBackend},Dict{Symbol, Any},Symbol,Any})
     Base.precompile(Tuple{typeof(_bin_centers),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}})
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{Float64},String})
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{Int64},String})
@@ -248,22 +224,17 @@ function _precompile_()
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{PlotUtils.ContinuousColorGradient},String})
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}},String})
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{Symbol},String})
-    Base.precompile(Tuple{typeof(_cycle),Base.OneTo{Int64},Vector{Int64}})
-    Base.precompile(Tuple{typeof(_cycle),ColorPalette,Int64})
-    Base.precompile(Tuple{typeof(_cycle),StepRange{Int64, Int64},Vector{Int64}})
-    Base.precompile(Tuple{typeof(_cycle),Vector{Float64},StepRange{Int64, Int64}})
-    Base.precompile(Tuple{typeof(_cycle),Vector{Float64},UnitRange{Int64}})
-    Base.precompile(Tuple{typeof(_cycle),Vector{Float64},Vector{Int64}})
     Base.precompile(Tuple{typeof(_do_plot_show),Plot{GRBackend},Bool})
     Base.precompile(Tuple{typeof(_do_plot_show),Plot{PlotlyBackend},Bool})
     Base.precompile(Tuple{typeof(_heatmap_edges),Vector{Float64},Bool,Bool})
     Base.precompile(Tuple{typeof(_plot!),Plot,Any,Any})
     Base.precompile(Tuple{typeof(_preprocess_barlike),DefaultsDict,Base.OneTo{Int64},Vector{Float64}})
     Base.precompile(Tuple{typeof(_preprocess_binlike),DefaultsDict,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
-    Base.precompile(Tuple{typeof(_replace_markershape),Vector{Symbol}})
     Base.precompile(Tuple{typeof(_update_min_padding!),GridLayout})
     Base.precompile(Tuple{typeof(_update_subplot_args),Plot{GRBackend},Subplot{GRBackend},Dict{Symbol, Any},Int64,Bool})
     Base.precompile(Tuple{typeof(_update_subplot_args),Plot{PlotlyBackend},Subplot{PlotlyBackend},Dict{Symbol, Any},Int64,Bool})
+    Base.precompile(Tuple{typeof(_update_subplot_legend),Subplot{GRBackend},Dict{Symbol, Any}})
+    Base.precompile(Tuple{typeof(_update_subplot_legend),Subplot{PlotlyBackend},Dict{Symbol, Any}})
     Base.precompile(Tuple{typeof(_update_subplot_periphery),Subplot{GRBackend},Vector{Any}})
     Base.precompile(Tuple{typeof(_update_subplot_periphery),Subplot{PlotlyBackend},Vector{Any}})
     Base.precompile(Tuple{typeof(axis_limits),Subplot{GRBackend},Symbol,Bool,Bool})
@@ -273,19 +244,14 @@ function _precompile_()
     Base.precompile(Tuple{typeof(bbox),Float64,Float64,Float64,Float64})
     Base.precompile(Tuple{typeof(build_layout),GridLayout,Int64,Vector{Plot}})
     Base.precompile(Tuple{typeof(convert_to_polar),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64},Tuple{Int64, Float64}})
-    Base.precompile(Tuple{typeof(create_grid),Expr})
     Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64},Vararg{Vector{Float64}, N} where N})
     Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64}})
     Base.precompile(Tuple{typeof(error_zipit),Tuple{Vector{Float64}, Vector{Float64}, Vector{Float64}}})
-    Base.precompile(Tuple{typeof(expand_extrema!),Axis,StepRange{Int64, Int64}})
     Base.precompile(Tuple{typeof(fakedata),Int64,Int64})
-    Base.precompile(Tuple{typeof(fakedata),MersenneTwister,Int64,Vararg{Int64, N} where N})
     Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Vector{Float64}, Vector{String}}})
     Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Vector{Int64}, Vector{String}}})
     Base.precompile(Tuple{typeof(get_series_color),SubArray{Symbol, 1, Vector{Symbol}, Tuple{UnitRange{Int64}}, true},Subplot{GRBackend},Int64,Symbol})
-    Base.precompile(Tuple{typeof(get_series_color),SubArray{Symbol, 1, Vector{Symbol}, Tuple{UnitRange{Int64}}, true},Subplot{PlotlyBackend},Int64,Symbol})
     Base.precompile(Tuple{typeof(get_series_color),Vector{Symbol},Subplot{GRBackend},Int64,Symbol})
-    Base.precompile(Tuple{typeof(get_series_color),Vector{Symbol},Subplot{PlotlyBackend},Int64,Symbol})
     Base.precompile(Tuple{typeof(get_ticks),StepRange{Int64, Int64},Vector{Float64},Vector{Any},Tuple{Int64, Int64},Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Float64, Float64},Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Int64, Float64},Vararg{Any, N} where N})
@@ -302,12 +268,10 @@ function _precompile_()
     Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Int64,Int64,Shape{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Float64,Tuple{Float64, Float64},Int64,Float64,Int64,Symbol})
     Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Int64,Tuple{Float64, Float64},Int64,Int64,Int64,Symbol})
-    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Base.OneTo{Int64},Vector{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},UnitRange{Int64},Tuple{Vector{Float64}, Vector{Float64}},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,StepRange{Int64, Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Vector{Float64},Vector{Float64},Int64,Tuple{Float64, Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Vector{Int64},Vector{Float64},Nothing,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_shapes),Series,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Matrix{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Vector{Float64},Tuple{Float64, Float64}})
@@ -319,7 +283,6 @@ function _precompile_()
     Base.precompile(Tuple{typeof(gr_label_ticks),Subplot{GRBackend},Symbol,Tuple{Vector{Int64}, Vector{String}}})
     Base.precompile(Tuple{typeof(gr_label_ticks_3d),Subplot{GRBackend},Symbol,Tuple{Vector{Float64}, Vector{String}}})
     Base.precompile(Tuple{typeof(gr_polaraxes),Int64,Float64,Subplot{GRBackend}})
-    Base.precompile(Tuple{typeof(gr_polyline),Vector{Float64},Vector{Float64},Function})
     Base.precompile(Tuple{typeof(gr_set_gradient),PlotUtils.ContinuousColorGradient})
     Base.precompile(Tuple{typeof(gr_text),Float64,Float64,String})
     Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Vector{Float64},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), NTuple{9, Float64}}})
@@ -333,8 +296,8 @@ function _precompile_()
     Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol,Vector{Float64},Symbol,Tuple{Int64, Int64},Bool})
     Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol})
     Base.precompile(Tuple{typeof(ignorenan_minimum),Vector{Int64}})
-    Base.precompile(Tuple{typeof(make_fillrange_side),UnitRange{Int64},LinRange{Float64}})
-    Base.precompile(Tuple{typeof(make_steps),Vector{Float64},Symbol,Bool})
+    Base.precompile(Tuple{typeof(layout_args),NamedTuple{(:label, :blank), Tuple{Symbol, Bool}}})
+    Base.precompile(Tuple{typeof(layout_args),NamedTuple{(:label, :width, :height), Tuple{Symbol, Symbol, Float64}}})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Function})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Symbol})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Int64, Float64},Symbol,Symbol})
@@ -350,12 +313,9 @@ function _precompile_()
     Base.precompile(Tuple{typeof(processGridArg!),Dict{Symbol, Any},Symbol,Symbol})
     Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},Matrix{Symbol}})
     Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},Symbol})
-    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Bool})
-    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Float64})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Matrix{Symbol}})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},RGBA{Float64}})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Shape{Float64, Float64}})
-    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Stroke})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Symbol})
     Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,PlotText})
     Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,Tuple{String, Int64, Symbol, Symbol}})
@@ -366,20 +326,13 @@ function _precompile_()
     Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},StepRange{Int64, Int64},Symbol})
     Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},Symbol,Symbol})
     Base.precompile(Tuple{typeof(push!),Plot{GRBackend},Float64,Vector{Float64}})
-    Base.precompile(Tuple{typeof(quiver_using_arrows),DefaultsDict})
-    Base.precompile(Tuple{typeof(reset_axis_defaults_byletter!)})
+    Base.precompile(Tuple{typeof(push!),Segments{Tuple{Float64, Float64, Float64}},Tuple{Float64, Float64, Float64},Tuple{Float64, Float64, Float64}})
+    Base.precompile(Tuple{typeof(push!),Segments{Tuple{Float64, Float64, Float64}},Tuple{Int64, Float64, Int64},Tuple{Float64, Float64, Int64}})
     Base.precompile(Tuple{typeof(resetfontsizes)})
     Base.precompile(Tuple{typeof(scalefontsizes),Float64})
     Base.precompile(Tuple{typeof(series_annotations),Vector{Any}})
-    Base.precompile(Tuple{typeof(set_RGBA_alpha),Int64,RGBA{Float64}})
     Base.precompile(Tuple{typeof(slice_arg),Base.ReshapedArray{Int64, 2, UnitRange{Int64}, Tuple{}},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Matrix{AbsoluteLength},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Matrix{Bool},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Matrix{Int64},Int64})
     Base.precompile(Tuple{typeof(slice_arg),Matrix{PlotUtils.ContinuousColorGradient},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Matrix{RGBA{Float64}},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Matrix{String},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Matrix{Symbol},Int64})
     Base.precompile(Tuple{typeof(spy),Any})
     Base.precompile(Tuple{typeof(straightline_data),Tuple{Float64, Float64},Tuple{Float64, Float64},Vector{Float64},Vector{Float64},Int64})
     Base.precompile(Tuple{typeof(stroke),Int64,Vararg{Any, N} where N})
@@ -389,14 +342,13 @@ function _precompile_()
     Base.precompile(Tuple{typeof(unzip),Vector{Tuple{Float64, Float64}}})
     Base.precompile(Tuple{typeof(unzip),Vector{Tuple{Int64, Int64}}})
     Base.precompile(Tuple{typeof(unzip),Vector{Tuple{Vector{Float64}, Vector{Float64}}}})
-    Base.precompile(Tuple{typeof(update_clims),Float64,Float64,SubArray{Int64, 1, Vector{Int64}, Tuple{UnitRange{Int64}}, true},typeof(ignorenan_extrema)})
     Base.precompile(Tuple{typeof(vline!),Any})
     Base.precompile(Tuple{typeof(warn_on_attr_dim_mismatch),Series,Vector{Float64},Vector{Float64},Nothing,Base.Iterators.Flatten{Vector{Tuple{SeriesSegment}}}})
     Base.precompile(Tuple{typeof(xgrid!),Plot{GRBackend},Symbol,Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(xlims),Subplot{PlotlyBackend}})
     isdefined(Plots, Symbol("#4#8")) && Base.precompile(Tuple{getfield(Plots, Symbol("#4#8")),UnitRange{Int64}})
-    isdefined(Plots, Symbol("#add_major_or_minor_segments#120")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#120")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64}},Float64,Bool})
-    isdefined(Plots, Symbol("#add_major_or_minor_segments#121")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#121")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64, Float64}},Float64,Bool})
+    isdefined(Plots, Symbol("#add_major_or_minor_segments#122")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#122")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64}},Float64,Bool})
+    isdefined(Plots, Symbol("#add_major_or_minor_segments#123")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#123")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64, Float64}},Float64,Bool})
     let fbody = try __lookup_kwbody__(which(font, (Font,Vararg{Any, N} where N,))) catch missing end
         if !ismissing(fbody)
             precompile(fbody, (Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}},typeof(font),Font,Vararg{Any, N} where N,))
@@ -432,9 +384,4 @@ function _precompile_()
             precompile(fbody, (Any,typeof(title!),AbstractString,))
         end
     end
-    let fbody = try __lookup_kwbody__(which(yaxis!, (Any,Vararg{Any, N} where N,))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(yaxis!),Any,Vararg{Any, N} where N,))
-        end
-    end
 end

src/Plots.jl

@@ -25,7 +25,7 @@ using SparseArrays
 using FFMPEG
 
 @reexport using RecipesBase
-import RecipesBase: plot, plot!, animate, is_explicit
+import RecipesBase: plot, plot!, animate, is_explicit, grid
 using Base.Meta
 @reexport using PlotUtils
 @reexport using PlotThemes
@@ -42,7 +42,6 @@ export
     grid,
     bbox,
     plotarea,
-    @layout,
     KW,
 
     wrap,
@@ -167,6 +166,8 @@ const BBox = Measures.Absolute2DBox
 const px = AbsoluteLength(0.254)
 const pct = Length{:pct,Float64}(1.0)
 
+Base.convert(::Type{<:Measure}, x::Float64) = x * pct
+
 Base.:*(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value * m2.value)
 Base.:*(m1::Length{:pct}, m2::AbsoluteLength) = AbsoluteLength(m2.value * m1.value)
 Base.:/(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value / m2.value)

src/arg_desc.jl

@@ -92,7 +92,8 @@ const _arg_desc = KW(
     :legend_foreground_color => "Color Type or `:match` (matches `:foreground_color_subplot`).  Foreground color of the legend.",
     :foreground_color_title => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of subplot title.",
     :color_palette => "Vector of colors (cycle through) or color gradient (generate list from gradient) or `:auto` (generate a color list using `Colors.distiguishable_colors` and custom seed colors chosen to contrast with the background).  The color palette is a color list from which series colors are automatically chosen.",
-    :legend => "Bool (show the legend?) or (x,y) tuple or Symbol (legend position) or angle or (angle,inout) tuple. Bottom left corner of legend is placed at (x,y).  Symbol values: `:none`; `:best`; `:inline`; `:inside`; `:legend`; any valid combination of `:(outer ?)(top/bottom ?)(right/left ?)`, i.e.: `:top`, `:topright`, `:outerleft`, `:outerbottomright` ... (note: only some may be supported in each backend)",
+    :legend_position => "Bool (show the legend?) or (x,y) tuple or Symbol (legend position) or angle or (angle,inout) tuple. Bottom left corner of legend is placed at (x,y).  Symbol values: `:none`; `:best`; `:inline`; `:inside`; `:legend`; any valid combination of `:(outer ?)(top/bottom ?)(right/left ?)`, i.e.: `:top`, `:topright`, `:outerleft`, `:outerbottomright` ... (note: only some may be supported in each backend)",
+    :legend_title_font => "Font. Font of the legend title.",
     :legend_font_family => "String or Symbol. Font family of legend entries.",
     :legend_font_pointsize => "Integer. Font pointsize of legend entries.",
     :legend_font_halign => "Symbol. Font horizontal alignment of legend entries: :hcenter, :left, :right or :center",
@@ -115,7 +116,7 @@ const _arg_desc = KW(
     :colorbar_tickfontcolor => "Color Type. Font color of colorbar tick entries",
     :colorbar_scale => "Symbol. Scale of the colorbar axis: `:none`, `:ln`, `:log2`, `:log10`",
     :colorbar_formatter => "Function, :scientific, :plain or :auto. A method which converts a number to a string for tick labeling.",
-    :legendfont => "Font. Font of legend items.",
+    :legend_font => "Font. Font of legend items.",
     :legend_titlefont => "Font. Font of the legend title.",
     :annotations => "(x,y,text) tuple(s).  Can be a single tuple or a list of them.  Text can be String, PlotText (created with `text(args...)`), or a tuple of arguments to `text` (e.g., `(\"Label\", 8, :red, :top)`). Add one-off text annotations at the x,y coordinates.",
     :annotationfontfamily => "String or Symbol. Font family of annotations.",

src/args.jl

@@ -1483,8 +1483,7 @@ function RecipesPipeline.preprocess_attributes!(plotattributes::AKW)
     end
 
     # fonts
-    for fontname in
-        (:titlefont, :legendfont, :legendtitlefont, :plot_titlefont, :colorbar_titlefont)
+    for fontname in (:titlefont, :legendtitlefont, :plot_titlefont, :colorbar_titlefont)
         args = RecipesPipeline.pop_kw!(plotattributes, fontname, ())
         for arg in wraptuple(args)
             processFontArg!(plotattributes, fontname, arg)
@@ -1744,7 +1743,7 @@ function slice_arg!(
 )
     v = get(plotattributes_in, k, plotattributes_out[k])
     plotattributes_out[k] =
-        if haskey(plotattributes_in, k) && typeof(v) <: AMat && !isempty(v)
+        if haskey(plotattributes_in, k) && typeof(v) <: AMat && !isempty(v) && !(k in _plot_args)
             slice_arg(v, idx)
         else
             v
@@ -1947,6 +1946,25 @@ function _update_subplot_colors(sp::Subplot)
     return
 end
 
+function _update_subplot_legend(sp::Subplot, plotattributes_in)
+    f_attr = NamedTuple(
+        k => plotattributes_in[Symbol(:legend_font_, k)] for
+        k in (:family, :pointsize, :valign, :halign, :rotation, :color) if
+        haskey(plotattributes_in, Symbol(:legend_font_, k))
+    )
+    match_attr = NamedTuple(
+        (
+            lk = Symbol(:legend_font_, k);
+            k =>
+                haskey(_match_map, lk) ? sp[lk] :
+                haskey(plotattributes_in, :legend_font) ?
+                getproperty(plotattributes_in[:legend_font], k) :
+                default(plotattributes_in, lk)
+        ) for k in (:family, :pointsize, :valign, :halign, :rotation, :color)
+    )
+    sp.attr[:legend_font] = font(; merge(match_attr, f_attr)...)
+end
+
 function _update_axis(
     plt::Plot,
     sp::Subplot,

src/backends/gr.jl

@@ -228,7 +228,8 @@ end
 gr_inqtext(x, y, s) = gr_inqtext(x, y, string(s))
 
 function gr_inqtext(x, y, s::AbstractString)
-    if (occursin('\\', s) || occursin("10^{", s)) && match(r".*\$[^\$]+?\$.*", s) == nothing
+    if (occursin('\\', s) || occursin("10^{", s)) &&
+       match(r".*\$[^\$]+?\$.*", String(s)) == nothing
         GR.inqtextext(x, y, s)
     else
         GR.inqtext(x, y, s)
@@ -238,7 +239,8 @@ end
 gr_text(x, y, s) = gr_text(x, y, string(s))
 
 function gr_text(x, y, s::AbstractString)
-    if (occursin('\\', s) || occursin("10^{", s)) && match(r".*\$[^\$]+?\$.*", s) == nothing
+    if (occursin('\\', s) || occursin("10^{", s)) &&
+       match(r".*\$[^\$]+?\$.*", String(s)) == nothing
         GR.textext(x, y, s)
     else
         GR.text(x, y, s)
@@ -573,7 +575,7 @@ function gr_draw_colorbar(cbar::GRColorbar, sp::Subplot, clims, viewport_plotare
         GR.setscale(2)
     end
     GR.axes(0, ztick, xmax, zmin, 0, 1, 0.005)
-    
+
     title = if isa(sp[:colorbar_title], PlotText)
         sp[:colorbar_title]
     else
@@ -953,7 +955,7 @@ end
 
 function gr_clims(args...)
     if args[1][:clims] != :auto
-        return args[1][:clims]
+        return get_clims(args[1])
     end
     lo, hi = get_clims(args...)
     if lo == hi
@@ -998,7 +1000,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
 
     # init the colorbar
     cbar = GRColorbar()
-    
+
     for series in series_list(sp)
         gr_add_series(sp, series)
         gr_update_colorbar!(cbar, series)
@@ -1243,21 +1245,26 @@ function gr_get_legend_geometry(viewport_plotarea, sp)
     if sp[:legend_position] != :none
         GR.savestate()
         GR.selntran(0)
+        GR.setcharup(0, 1)
         GR.setscale(0)
         if sp[:legend_title] !== nothing
             gr_set_font(legendtitlefont(sp), sp)
             legendn += 1
             tbx, tby = gr_inqtext(0, 0, string(sp[:legend_title]))
-            legendw = tbx[3] - tbx[1]
-            dy = tby[3] - tby[1]
+            l, r = extrema(tbx)
+            b, t = extrema(tby)
+            legendw = r - l
+            dy = t - b
         end
         gr_set_font(legendfont(sp), sp)
         for series in series_list(sp)
             should_add_to_legend(series) || continue
             legendn += 1
             tbx, tby = gr_inqtext(0, 0, string(series[:label]))
-            legendw = max(legendw, tbx[3] - tbx[1]) # Holds text width right now
-            dy = max(dy, tby[3] - tby[1])
+            l, r = extrema(tbx)
+            b, t = extrema(tby)
+            legendw = max(legendw, r - l) # Holds text width right now
+            dy = max(dy, t - b)
         end
 
         GR.setscale(1)
@@ -2116,10 +2123,11 @@ function gr_draw_heatmap(series, x, y, z, clims)
             get_z_normalized.(z_log, log10.(clims)...), z_log
         end
         rgba = Int32[round(Int32, 1000 + _i * 255) for _i in z_normalized]
-        background_color_ind = gr_getcolorind(plot_color(series[:subplot][:background_color_inside]))
+        background_color_ind =
+            gr_getcolorind(plot_color(series[:subplot][:background_color_inside]))
         for i in eachindex(rgba)
             if isnan(_z[i])
-                rgba[i] = background_color_ind 
+                rgba[i] = background_color_ind
             end
         end
         if !ispolar(series)

src/components.jl

@@ -246,6 +246,7 @@ function font(args...; kw...)
 
     for arg in args
         T = typeof(arg)
+        @assert arg !== :match
 
         if T == Font
             family = arg.family
@@ -269,12 +270,12 @@ function font(args...; kw...)
             catch
                 family = string(arg)
             end
-        elseif typeof(arg) <: Integer
+        elseif T <: Integer
             pointsize = arg
-        elseif typeof(arg) <: Real
+        elseif T <: Real
             rotation = convert(Float64, arg)
         else
-            @warn "Unused font arg: $arg ($(typeof(arg)))"
+            @warn "Unused font arg: $arg ($T)"
         end
     end
 

src/layouts.jl

@@ -269,6 +269,9 @@ Base.getindex(layout::GridLayout, r::Int, c::Int) = layout.grid[r, c]
 function Base.setindex!(layout::GridLayout, v, r::Int, c::Int)
     layout.grid[r, c] = v
 end
+function Base.setindex!(layout::GridLayout, v, ci::CartesianIndex)
+    layout.grid[ci] = v
+end
 
 leftpad(layout::GridLayout)   = layout.minpad[1]
 toppad(layout::GridLayout)    = layout.minpad[2]
@@ -491,6 +494,19 @@ function layout_args(sztup::NTuple{3,Integer})
     GridLayout(nr, nc), n
 end
 
+layout_args(nt::NamedTuple) = EmptyLayout(;nt...), 1
+
+function layout_args(m::AbstractVecOrMat)
+    sz = size(m)
+    nr = sz[1]
+    nc = get(sz, 2, 1)
+    gl = GridLayout(nr, nc)
+    for ci in CartesianIndices(m)
+        gl[ci] = layout_args(m[ci])[1]
+    end
+    layout_args(gl)
+end
+
 # compute number of subplots
 function layout_args(layout::GridLayout)
     # recursively get the size of the grid
@@ -498,7 +514,7 @@ function layout_args(layout::GridLayout)
     layout, n
 end
 
-layout_args(n_override::Integer, layout::GridLayout) = layout_args(layout)
+layout_args(n_override::Integer, layout::Union{AbstractVecOrMat,GridLayout}) = layout_args(layout)
 
 layout_args(huh) = error("unhandled layout type $(typeof(huh)): $huh")
 
@@ -562,137 +578,6 @@ function build_layout(layout::GridLayout, n::Integer, plts::AVec{Plot})
     layout, subplots, spmap
 end
 
-# ----------------------------------------------------------------------
-# @layout macro
-
-function add_layout_pct!(kw::AKW, v::Expr, idx::Integer, nidx::Integer)
-    # dump(v)
-    # something like {0.2w}?
-    if v.head == :call && v.args[1] == :*
-        num = v.args[2]
-        if length(v.args) == 3 && isa(num, Number)
-            units = v.args[3]
-            if units == :h
-                return kw[:h] = num * pct
-            elseif units == :w
-                return kw[:w] = num * pct
-            elseif units in (:pct, :px, :mm, :cm, :inch)
-                idx == 1 && (kw[:w] = v)
-                (idx == 2 || nidx == 1) && (kw[:h] = v)
-                # return kw[idx == 1 ? :w : :h] = v
-            end
-        end
-    end
-    error("Couldn't match layout curly (idx=$idx): $v")
-end
-
-function add_layout_pct!(kw::AKW, v::Number, idx::Integer)
-    # kw[idx == 1 ? :w : :h] = v*pct
-    idx == 1 && (kw[:w] = v * pct)
-    (idx == 2 || nidx == 1) && (kw[:h] = v * pct)
-end
-
-isrow(v) = isa(v, Expr) && v.head in (:hcat, :row)
-iscol(v) = isa(v, Expr) && v.head == :vcat
-rowsize(v) = isrow(v) ? length(v.args) : 1
-
-function create_grid(expr::Expr)
-    if iscol(expr)
-        create_grid_vcat(expr)
-    elseif isrow(expr)
-        :(
-            let cell = GridLayout(1, $(length(expr.args)))
-                $(
-                    [
-                        :(cell[1, $i] = $(create_grid(v))) for
-                        (i, v) in enumerate(expr.args)
-                    ]...
-                )
-                cell
-            end
-        )
-
-    elseif expr.head == :curly
-        create_grid_curly(expr)
-    else
-        # if it's something else, just return that (might be an existing layout?)
-        esc(expr)
-    end
-end
-
-function create_grid_vcat(expr::Expr)
-    rowsizes = map(rowsize, expr.args)
-    rmin, rmax = extrema(rowsizes)
-    if rmin > 0 && rmin == rmax
-        # we have a grid... build the whole thing
-        # note: rmin is the number of columns
-        nr = length(expr.args)
-        nc = rmin
-        body = Expr(:block)
-        for r in 1:nr
-            arg = expr.args[r]
-            if isrow(arg)
-                for (c, item) in enumerate(arg.args)
-                    push!(body.args, :(cell[$r, $c] = $(create_grid(item))))
-                end
-            else
-                push!(body.args, :(cell[$r, 1] = $(create_grid(arg))))
-            end
-        end
-        :(
-            let cell = GridLayout($nr, $nc)
-                $body
-                cell
-            end
-        )
-    else
-        # otherwise just build one row at a time
-        :(
-            let cell = GridLayout($(length(expr.args)), 1)
-                $(
-                    [
-                        :(cell[$i, 1] = $(create_grid(v))) for
-                        (i, v) in enumerate(expr.args)
-                    ]...
-                )
-                cell
-            end
-        )
-    end
-end
-
-function create_grid_curly(expr::Expr)
-    kw = KW()
-    for (i, arg) in enumerate(expr.args[2:end])
-        add_layout_pct!(kw, arg, i, length(expr.args) - 1)
-    end
-    s = expr.args[1]
-    if isa(s, Expr) && s.head == :call && s.args[1] == :grid
-        create_grid(
-            :(grid(
-                $(s.args[2:end]...),
-                width = $(get(kw, :w, QuoteNode(:auto))),
-                height = $(get(kw, :h, QuoteNode(:auto))),
-            )),
-        )
-    elseif isa(s, Symbol)
-        :(EmptyLayout(
-            label = $(QuoteNode(s)),
-            width = $(get(kw, :w, QuoteNode(:auto))),
-            height = $(get(kw, :h, QuoteNode(:auto))),
-        ))
-    else
-        error("Unknown use of curly brackets: $expr")
-    end
-end
-
-function create_grid(s::Symbol)
-    :(EmptyLayout(label = $(QuoteNode(s)), blank = $(s == :_)))
-end
-
-macro layout(mat::Expr)
-    create_grid(mat)
-end
 
 # -------------------------------------------------------------------------
 

src/pipeline.jl

@@ -243,12 +243,12 @@ function _subplot_setup(plt::Plot, plotattributes::AKW, kw_list::Vector{KW})
                     attr[get_attr_symbol(letter, k)] = v
                 end
             end
-            for k in (:scale,), letter in (:x, :y, :z)
-                # Series recipes may need access to this information
-                lk = get_attr_symbol(letter, k)
-                if haskey(attr, lk)
-                    kw[lk] = attr[lk]
-                end
+        end
+        for k in (:scale,), letter in (:x, :y, :z)
+            # Series recipes may need access to this information
+            lk = get_attr_symbol(letter, k)
+            if haskey(attr, lk)
+                kw[lk] = attr[lk]
             end
         end
         sp_attrs[sp] = attr
@@ -263,6 +263,7 @@ function _subplot_setup(plt::Plot, plotattributes::AKW, kw_list::Vector{KW})
             get(sp_attrs, sp, KW())
         end
         _update_subplot_args(plt, sp, attr, idx, false)
+        _update_subplot_legend(sp, attr)
     end
 
     # do we need to link any axes together?

src/utils.jl

@@ -513,7 +513,7 @@ for comp in (:line, :fill, :marker)
             end
         end
 
-        $get_compcolor(series, clims, i::Int = 1) =
+        $get_compcolor(series, clims::Tuple{<:Number, <:Number}, i::Int = 1) =
             $get_compcolor(series, clims[1], clims[2], i)
 
         function $get_compcolor(series, i::Int = 1)
@@ -994,14 +994,7 @@ titlefont(sp::Subplot) = font(;
     color = sp[:titlefontcolor],
 )
 
-legendfont(sp::Subplot) = font(;
-    family = sp[:legend_font_family],
-    pointsize = sp[:legend_font_pointsize],
-    valign = sp[:legend_font_valign],
-    halign = sp[:legend_font_halign],
-    rotation = sp[:legend_font_rotation],
-    color = sp[:legend_font_color],
-)
+legendfont(sp::Subplot) = sp[:legend_font]
 
 legendtitlefont(sp::Subplot) = font(;
     family = sp[:legend_title_font_family],
@@ -1253,4 +1246,5 @@ const _attrsymbolcache = Dict{Symbol,Dict{Symbol,Symbol}}()
 get_attr_symbol(letter::Symbol, keyword::String) = get_attr_symbol(letter, Symbol(keyword))
 get_attr_symbol(letter::Symbol, keyword::Symbol) = _attrsymbolcache[letter][keyword]
 
-texmath2unicode(s::AbstractString, pat=r"\$([^$]+)\$") = replace(s, pat => m->UnicodeFun.to_latex(m[2:(length(m)-1)]))
+texmath2unicode(s::AbstractString, pat = r"\$([^$]+)\$") =
+    replace(s, pat => m -> UnicodeFun.to_latex(m[2:(length(m) - 1)]))

test/runtests.jl

@@ -201,8 +201,10 @@ end
           Plots.process_clims(:auto)
 
     @test (==)(
-        Plots.texmath2unicode(raw"Equation $y = \alpha \cdot x + \beta$ and eqn $y = \sin(x)^2$"),
-        raw"Equation y = α ⋅ x + β and eqn y = sin(x)²"
+        Plots.texmath2unicode(
+            raw"Equation $y = \alpha \cdot x + \beta$ and eqn $y = \sin(x)^2$",
+        ),
+        raw"Equation y = α ⋅ x + β and eqn y = sin(x)²",
     )
 end
 

test/test_defaults.jl

@@ -6,7 +6,7 @@ Plots.__init__()
 @testset "Loading theme" begin
     pl = plot(1:5)
     @test pl[1][1][:seriescolor] == RGBA(colorant"black")
-    @test guidefont(pl[1][:xaxis]).family == "palantino"
+    @test Plots.guidefont(pl[1][:xaxis]).family == "palantino"
 end
 
 empty!(PLOTS_DEFAULTS)
@@ -67,4 +67,17 @@ end # testset
     @test p[1][:legend_title_font_color] == :blue
     @test p[1][:legend_background_color] == RGBA{Float64}(0.0, 1.0, 1.0, 1.0)
     @test p[1][:legend_foreground_color] == RGBA{Float64}(0.0, 0.5019607843137255, 0.0, 1.0)
+
+    #setting whole font
+    sp = plot(
+        1:5,
+        legendfont = font(12),
+        legend_font_halign = :left,
+        foreground_color_subplot = :red,
+    )[1]
+    @test Plots.legendfont(sp).pointsize == 12
+    @test Plots.legendfont(sp).halign == :left
+    # match mechanism
+    @test sp[:legend_font_color] == sp[:foreground_color_subplot]
+    @test Plots.legendfont(sp).color == sp[:foreground_color_subplot]
 end # testset