1.23.1 [skip ci]

* Moved limits into plot/series attributes

* Moved const to args

.github/workflows/SnoopCompile.yml

@@ -69,7 +69,11 @@ jobs:
         uses: actions/download-artifact@v2
 
       - name: CompileBot postprocess
-        run: julia -e 'using Pkg; Pkg.add( PackageSpec(name = "CompileBot", version = "1") ); using CompileBot; CompileBot.postprocess();'
+        run: |
+          ls artifact
+          ls
+          if ! grep -m1 -q 'format' artifact/src/precompile_includer.jl; then sed -i '1 i\#! format: off' artifact/src/precompile_includer.jl; fi
+          julia -e 'using Pkg; Pkg.add( PackageSpec(name = "CompileBot", version = "1") ); using CompileBot; CompileBot.postprocess();'
 
       - name: Create Pull Request
         uses: peter-evans/create-pull-request@v3

.zenodo.json

@@ -401,7 +401,7 @@
             "type": "Other"
         },
         {
-            "name": "Moesè Giodano",
+            "name": "Mosè Giodano",
             "type": "Other"
         },
         {

Project.toml

@@ -1,7 +1,7 @@
 name = "Plots"
 uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
 author = ["Tom Breloff (@tbreloff)"]
-version = "1.22.6"
+version = "1.23.1"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"

deps/SnoopCompile/precompile/precompile_Plots.jl

@@ -77,6 +77,7 @@ function _precompile_()
     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})
@@ -93,6 +94,7 @@ function _precompile_()
     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})
@@ -106,6 +108,7 @@ function _precompile_()
     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}}})
@@ -137,6 +140,7 @@ function _precompile_()
     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}})
@@ -145,10 +149,12 @@ function _precompile_()
     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}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:color, :line, :marker), Tuple{Matrix{Symbol}, Tuple{Symbol, Int64}, Tuple{Matrix{Symbol}, Int64, Float64, Stroke}}},typeof(plot),Vector{Vector{T} where T}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:connections, :title, :xlabel, :ylabel, :zlabel, :legend, :margin, :seriestype), Tuple{Tuple{Vector{Int64}, Vector{Int64}, Vector{Int64}}, String, String, String, String, Symbol, AbsoluteLength, Symbol}},typeof(plot),Vector{Int64},Vector{Int64},Vector{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:fill, :seriestype), Tuple{Bool, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Function})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:fill_z, :alpha, :label, :bar_width, :seriestype), Tuple{StepRange{Int64, Int64}, Vector{Float64}, String, UnitRange{Int64}, Symbol}},typeof(plot),Vector{Int64},Vector{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:framestyle, :title, :color, :layout, :label, :markerstrokewidth, :ticks, :seriestype), Tuple{Matrix{Symbol}, Matrix{String}, Base.ReshapedArray{Int64, 2, UnitRange{Int64}, Tuple{}}, Int64, String, Int64, UnitRange{Int64}, Symbol}},typeof(plot),Vector{Vector{Float64}},Vector{Vector{Float64}}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:grid, :title), Tuple{Tuple{Symbol, Symbol, Symbol, Int64, Float64}, String}},typeof(plot),Vector{Float64}})
     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}})
@@ -210,6 +216,7 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(portfoliocomposition)),Any,typeof(portfoliocomposition),Any,Vararg{Any, N} where N})
     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{Core.kwftype(typeof(yaxis!)),Any,typeof(yaxis!),Any,Any})
     Base.precompile(Tuple{Type{GridLayout},Int64,Vararg{Int64, N} where N})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},AbstractVector{OHLC}})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},PortfolioComposition})
@@ -234,18 +241,24 @@ 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.slice_series_attributes!),Plot{GRBackend},Vector{Dict{Symbol, Any}},Dict{Symbol, Any}})
     Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{GRBackend},DefaultsDict,Symbol,Any})
     Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{GRBackend},Dict{Symbol, Any},Symbol,Any})
     Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{PlotlyBackend},DefaultsDict,Symbol,Any})
     Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{PlotlyBackend},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})
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{Nothing},String})
     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})
@@ -264,15 +277,18 @@ function _precompile_()
     Base.precompile(Tuple{typeof(bbox),AbsoluteLength,AbsoluteLength,AbsoluteLength,AbsoluteLength})
     Base.precompile(Tuple{typeof(bbox),Float64,Float64,Float64,Float64})
     Base.precompile(Tuple{typeof(build_layout),GridLayout,Int64,Vector{Plot}})
+    Base.precompile(Tuple{typeof(convertLegendValue),Symbol})
     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(discrete_value!),Axis,Vector{String}})
     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(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})
@@ -284,9 +300,7 @@ function _precompile_()
     Base.precompile(Tuple{typeof(get_xy),Vector{OHLC}})
     Base.precompile(Tuple{typeof(gr_add_legend),Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), NTuple{9, Float64}},Vector{Float64}})
     Base.precompile(Tuple{typeof(gr_add_legend),Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), Tuple{Int64, Int64, Int64, Float64, Int64, Float64, Float64, Float64, Float64}},Vector{Float64}})
-    Base.precompile(Tuple{typeof(gr_axis_height),Subplot{GRBackend},Axis})
     Base.precompile(Tuple{typeof(gr_display),Subplot{GRBackend},AbsoluteLength,AbsoluteLength,Vector{Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_border),Subplot{GRBackend},Axis,Segments{Tuple{Float64, Float64, Float64}},Function})
     Base.precompile(Tuple{typeof(gr_draw_contour),Series,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Matrix{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_heatmap),Series,Vector{Float64},Vector{Float64},Matrix{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Float64,Float64,Symbol})
@@ -301,6 +315,8 @@ function _precompile_()
     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{Float64},Vector{Float64},Nothing,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_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}})
     Base.precompile(Tuple{typeof(gr_fill_viewport),Vector{Float64},RGBA{Float64}})
@@ -311,6 +327,7 @@ 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}}})
@@ -325,14 +342,12 @@ function _precompile_()
     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),UnitRange{Int64},Symbol,Bool})
     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})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Int64, Int64},Symbol,Symbol})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),StepRange{Int64, Int64},Tuple{Int64, Int64},Symbol,Symbol})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),UnitRange{Int64},Tuple{Float64, Float64},Symbol,Symbol})
-    Base.precompile(Tuple{typeof(partialcircle),Float64,Float64,Int64})
     Base.precompile(Tuple{typeof(partialcircle),Int64,Float64,Int64})
     Base.precompile(Tuple{typeof(plot),Any,Any})
     Base.precompile(Tuple{typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
@@ -340,13 +355,13 @@ function _precompile_()
     Base.precompile(Tuple{typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
     Base.precompile(Tuple{typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend}})
     Base.precompile(Tuple{typeof(processGridArg!),Dict{Symbol, Any},Symbol,Symbol})
-    Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},Int64})
     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},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}})
@@ -356,17 +371,19 @@ function _precompile_()
     Base.precompile(Tuple{typeof(process_annotation),Subplot{PlotlyBackend},Int64,Float64,Tuple{String, Symbol, Int64, String}})
     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(process_axis_arg!),Dict{Symbol, Any},Tuple{Int64, Int64},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{Float64},Float64,Float64,Float64,Float64,Vararg{Float64, N} where N})
+    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, Int64, Float64},Tuple{Int64, Int64, Float64}})
     Base.precompile(Tuple{typeof(resetfontsizes)})
     Base.precompile(Tuple{typeof(scalefontsizes),Float64})
     Base.precompile(Tuple{typeof(series_annotations),Vector{Any}})
     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})
@@ -379,8 +396,10 @@ function _precompile_()
     Base.precompile(Tuple{typeof(unzip),Vector{Tuple{Int64, Int64}}})
     Base.precompile(Tuple{typeof(unzip),Vector{Tuple{Vector{Float64}, Vector{Float64}}}})
     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})
     let fbody = try __lookup_kwbody__(which(font, (Font,Vararg{Any, N} where N,))) catch missing end
@@ -418,4 +437,9 @@ 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/arg_desc.jl

@@ -108,22 +108,22 @@ const _arg_desc = KW(
     :legend_title_font_color => "Color Type. Font color of the legend title",
     :colorbar => "Bool (show the colorbar?) or Symbol (colorbar position).  Symbol values: `:none`, `:best`, `:right`, `:left`, `:top`, `:bottom`, `:legend` (matches legend value) (note: only some may be supported in each backend)",
     :clims => "`:auto`, NTuple{2,Number}, or a function that takes series data in and returns NTuple{2,Number}.  Fixes the limits of the colorbar.",
-    :colorbar_fontfamily      => "String or Symbol. Font family of colobar entries.",
-    :colorbar_ticks           => "Vector of numbers (set the tick values), Tuple of (tickvalues, ticklabels), or `:auto`",
-    :colorbar_tickfontfamily  => "String or Symbol. Font family of colorbar tick labels.",
-    :colorbar_tickfontsize    => "Integer. Font pointsize of colorbar tick entries.",
-    :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.",
+    :colorbar_fontfamily => "String or Symbol. Font family of colobar entries.",
+    :colorbar_ticks => "Vector of numbers (set the tick values), Tuple of (tickvalues, ticklabels), or `:auto`",
+    :colorbar_tickfontfamily => "String or Symbol. Font family of colorbar tick labels.",
+    :colorbar_tickfontsize => "Integer. Font pointsize of colorbar tick entries.",
+    :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_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.",
-    :annotationfontsize       => "Integer. Font pointsize of annotations.",
-    :annotationhalign         => "Symbol. horizontal alignment of annotations, :hcenter, :left, :right or :center.",
-    :annotationvalign         => "Symbol. Vertical alignment of annotations, :vcenter, :top, :bottom or :center.",
-    :annotationrotation       => "Float. Rotation of annotations in degrees.",
-    :annotationcolor          => "Colorant or :match. Color of annotations.",
+    :annotationfontfamily => "String or Symbol. Font family of annotations.",
+    :annotationfontsize => "Integer. Font pointsize of annotations.",
+    :annotationhalign => "Symbol. horizontal alignment of annotations, :hcenter, :left, :right or :center.",
+    :annotationvalign => "Symbol. Vertical alignment of annotations, :vcenter, :top, :bottom or :center.",
+    :annotationrotation => "Float. Rotation of annotations in degrees.",
+    :annotationcolor => "Colorant or :match. Color of annotations.",
     :projection => "Symbol or String.  '3d' or 'polar'",
     :aspect_ratio => "Symbol (:equal or :none) or Number. Plot area is resized so that 1 y-unit is the same size as `aspect_ratio` x-units. With `:none`, images inherit aspect ratio of the plot area.",
     :margin => "Measure (multiply by `mm`, `px`, etc). Base for individual margins... not directly used.  Specifies the extra padding around subplots.",

src/args.jl

@@ -89,6 +89,8 @@ const _allTypes = vcat(
     _3dTypes,
 )
 
+const _z_colored_series = [:contour, :contour3d, :heatmap, :histogram2d, :surface, :hexbin]
+
 const _typeAliases = Dict{Symbol,Symbol}(
     :n             => :none,
     :no            => :none,

src/backends/deprecated/pgfplots.jl

@@ -597,15 +597,25 @@ function _update_plot_object(plt::Plot{PGFPlotsBackend})
         cstr, bg_alpha = pgf_color(plot_color(sp[:legend_background_color]))
         fg_alpha = alpha(plot_color(sp[:legend_foreground_color]))
 
-        push!(style, string(
-            "legend style = {",
-                pgf_linestyle(pgf_thickness_scaling(sp), sp[:legend_foreground_color], fg_alpha, "solid", ), ",",
+        push!(
+            style,
+            string(
+                "legend style = {",
+                pgf_linestyle(
+                    pgf_thickness_scaling(sp),
+                    sp[:legend_foreground_color],
+                    fg_alpha,
+                    "solid",
+                ),
+                ",",
                 "fill = $cstr,",
                 "fill opacity = $bg_alpha,",
                 "text opacity = $(alpha(plot_color(sp[:legend_font_color]))),",
-                "font = ", pgf_font(sp[:legend_font_pointsize], pgf_thickness_scaling(sp)),
-            "}",
-        ))
+                "font = ",
+                pgf_font(sp[:legend_font_pointsize], pgf_thickness_scaling(sp)),
+                "}",
+            ),
+        )
 
         if any(s[:seriestype] == :contour for s in series_list(sp))
             kw[:view] = "{0}{90}"

src/backends/gr.jl

@@ -1024,7 +1024,7 @@ end
 ## Legend
 
 function gr_add_legend(sp, leg, viewport_plotarea)
-    if !(sp[:legend_position] in(:none, :inline))
+    if !(sp[:legend_position] in (:none, :inline))
         GR.savestate()
         GR.selntran(0)
         GR.setscale(0)
@@ -1100,7 +1100,8 @@ function gr_add_legend(sp, leg, viewport_plotarea)
                     ms = first(series[:markersize])
                     msw = first(series[:markerstrokewidth])
                     s, sw = if ms > 0
-                        0.8 * sp[:legend_font_pointsize], 0.8 * sp[:legend_font_pointsize] * msw / ms
+                        0.8 * sp[:legend_font_pointsize],
+                        0.8 * sp[:legend_font_pointsize] * msw / ms
                     else
                         0, 0.8 * sp[:legend_font_pointsize] * msw / 8
                     end
@@ -1302,7 +1303,7 @@ function gr_update_viewport_legend!(viewport_plotarea, sp, leg)
 
     if s isa Tuple{<:Real,Symbol}
         if s[2] === :outer
-            (x,y) = gr_legend_pos(sp, leg, viewport_plotarea) # Dry run, to figure out
+            (x, y) = gr_legend_pos(sp, leg, viewport_plotarea) # Dry run, to figure out
             if x < viewport_plotarea[1]
                 viewport_plotarea[1] +=
                     leg.leftw +

src/backends/inspectdr.jl

@@ -390,33 +390,37 @@ function _inspectdr_setupsubplot(sp::Subplot{InspectDRBackend})
 
     #Modify base layout of new object:
     l = plot.layout.defaults = deepcopy(InspectDR.defaults.plotlayout)
-        #IMPORTANT: Must deepcopy to ensure we don't change layouts of other plots.
-        #Works because plot uses defaults (not user-overwritten `layout.values`)
-        l.frame_canvas.fillcolor = _inspectdr_mapcolor(sp[:background_color_subplot])
-        l.frame_data.fillcolor = _inspectdr_mapcolor(sp[:background_color_inside])
-        l.frame_data.line.color = _inspectdr_mapcolor(xaxis[:foreground_color_axis])
-        l.font_title = InspectDR.Font(sp[:titlefontfamily],
-            _inspectdr_mapptsize(sp[:titlefontsize]),
-            color = _inspectdr_mapcolor(sp[:titlefontcolor])
-        )
-        #Cannot independently control fonts of axes with InspectDR:
-        l.font_axislabel = InspectDR.Font(xaxis[:guidefontfamily],
-            _inspectdr_mapptsize(xaxis[:guidefontsize]),
-            color = _inspectdr_mapcolor(xaxis[:guidefontcolor])
-        )
-        l.font_ticklabel = InspectDR.Font(xaxis[:tickfontfamily],
-            _inspectdr_mapptsize(xaxis[:tickfontsize]),
-            color = _inspectdr_mapcolor(xaxis[:tickfontcolor])
-        )
-        l.enable_legend = (sp[:legend_position] != :none)
-        #l.halloc_legend = 150 #TODO: compute???
-        l.font_legend = InspectDR.Font(sp[:legend_font_family],
-            _inspectdr_mapptsize(sp[:legend_font_pointsize]),
-            color = _inspectdr_mapcolor(sp[:legend_font_color])
-        )
-        l.frame_legend.fillcolor = _inspectdr_mapcolor(sp[:legend_background_color])
-        #_round!() ensures values use integer spacings (looks better on screen):
-        InspectDR._round!(InspectDR.autofit2font!(l, legend_width=10.0)) #10 "em"s wide
+    #IMPORTANT: Must deepcopy to ensure we don't change layouts of other plots.
+    #Works because plot uses defaults (not user-overwritten `layout.values`)
+    l.frame_canvas.fillcolor = _inspectdr_mapcolor(sp[:background_color_subplot])
+    l.frame_data.fillcolor = _inspectdr_mapcolor(sp[:background_color_inside])
+    l.frame_data.line.color = _inspectdr_mapcolor(xaxis[:foreground_color_axis])
+    l.font_title = InspectDR.Font(
+        sp[:titlefontfamily],
+        _inspectdr_mapptsize(sp[:titlefontsize]),
+        color = _inspectdr_mapcolor(sp[:titlefontcolor]),
+    )
+    #Cannot independently control fonts of axes with InspectDR:
+    l.font_axislabel = InspectDR.Font(
+        xaxis[:guidefontfamily],
+        _inspectdr_mapptsize(xaxis[:guidefontsize]),
+        color = _inspectdr_mapcolor(xaxis[:guidefontcolor]),
+    )
+    l.font_ticklabel = InspectDR.Font(
+        xaxis[:tickfontfamily],
+        _inspectdr_mapptsize(xaxis[:tickfontsize]),
+        color = _inspectdr_mapcolor(xaxis[:tickfontcolor]),
+    )
+    l.enable_legend = (sp[:legend_position] != :none)
+    #l.halloc_legend = 150 #TODO: compute???
+    l.font_legend = InspectDR.Font(
+        sp[:legend_font_family],
+        _inspectdr_mapptsize(sp[:legend_font_pointsize]),
+        color = _inspectdr_mapcolor(sp[:legend_font_color]),
+    )
+    l.frame_legend.fillcolor = _inspectdr_mapcolor(sp[:legend_background_color])
+    #_round!() ensures values use integer spacings (looks better on screen):
+    InspectDR._round!(InspectDR.autofit2font!(l, legend_width = 10.0)) #10 "em"s wide
     return
 end
 

src/backends/pgfplotsx.jl

@@ -166,9 +166,8 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
             sp_width > 0 * mm ? push!(axis_opt, "width" => string(axis_width)) : nothing
             sp_height > 0 * mm ? push!(axis_opt, "height" => string(axis_height)) : nothing
             for letter in (:x, :y, :z)
-                if letter != :z ||
-                   RecipesPipeline.is3d(sp)
-                   pgfx_axis!(axis_opt, sp, letter)
+                if letter != :z || RecipesPipeline.is3d(sp)
+                    pgfx_axis!(axis_opt, sp, letter)
                 end
             end
             # Search series for any gradient. In case one series uses a gradient set
@@ -256,11 +255,9 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
                     axis,
                     PGFPlotsX.LegendEntry(
                         PGFPlotsX.Options(
-                            "font" => pgfx_font(
-                                legtfont.pointsize,
-                                pgfx_thickness_scaling(sp),
-                            ),
-                            "text" => legtfont.color
+                            "font" =>
+                                pgfx_font(legtfont.pointsize, pgfx_thickness_scaling(sp)),
+                            "text" => legtfont.color,
                         ),
                         string("\\hspace{-.6cm}{\\textbf{", sp[:legend_title], "}}"),
                         false,
@@ -388,7 +385,8 @@ function pgfx_add_series!(::Val{:path}, axis, series_opt, series, series_func, o
                 end
             end
             if i == 1 &&
-               series[:subplot][:legend_position] != :none && pgfx_should_add_to_legend(series)
+               series[:subplot][:legend_position] != :none &&
+               pgfx_should_add_to_legend(series)
                 pgfx_filllegend!(series_opt, opt)
             end
         end
@@ -822,12 +820,15 @@ function pgfx_get_legend_style(sp)
         "fill" => cstr,
         "fill opacity" => a,
         "text opacity" => alpha(plot_color(sp[:legend_font_color])),
-        "font" => pgfx_font(
-            sp[:legend_font_pointsize],
-            pgfx_thickness_scaling(sp),
-        ),
+        "font" => pgfx_font(sp[:legend_font_pointsize], pgfx_thickness_scaling(sp)),
         "text" => plot_color(sp[:legend_font_color]),
-        "cells" => PGFPlotsX.Options("anchor" => get((left = "west", right = "east", hcenter = "center"), legfont.halign, "west")),
+        "cells" => PGFPlotsX.Options(
+            "anchor" => get(
+                (left = "west", right = "east", hcenter = "center"),
+                legfont.halign,
+                "west",
+            ),
+        ),
         pgfx_get_legend_pos(sp[:legend_position])...,
     )
 end
@@ -957,7 +958,6 @@ end
 pgfx_legend_col(s::Symbol) = s == :horizontal ? -1 : 1
 pgfx_legend_col(n) = n
 
-
 function pgfx_linestyle(plotattributes, i = 1)
     lw = pgfx_thickness_scaling(plotattributes) * get_linewidth(plotattributes, i)
     lc = single_color(get_linecolor(plotattributes, i))
@@ -1454,7 +1454,8 @@ end
 # to fit ticks, tick labels, guides, colorbars, etc.
 function _update_min_padding!(sp::Subplot{PGFPlotsXBackend})
     leg = sp[:legend_position]
-    if leg in (:best, :outertopright, :outerright, :outerbottomright) || (leg isa Tuple && leg[1] >= 1)
+    if leg in (:best, :outertopright, :outerright, :outerbottomright) ||
+       (leg isa Tuple && leg[1] >= 1)
         sp.minpad = (0mm, 0mm, 5mm, 0mm)
     else
         sp.minpad = (0mm, 0mm, 0mm, 0mm)

src/backends/plotly.jl

@@ -342,7 +342,7 @@ function plotly_add_legend!(plotattributes_out::KW, sp::Subplot)
     legend_position = plotly_legend_pos(sp[:legend_position])
     if sp[:legend_position] != :none
         plotattributes_out[:legend_position] = KW(
-            :bgcolor  => rgba_string(sp[:legend_background_color]),
+            :bgcolor => rgba_string(sp[:legend_background_color]),
             :bordercolor => rgba_string(sp[:legend_foreground_color]),
             :borderwidth => 1,
             :traceorder => "normal",

src/backends/pyplot.jl

@@ -1627,7 +1627,7 @@ function py_add_legend(plt::Plot, sp::Subplot, ax)
                         ),
                         linewidth = py_thickness_scale(
                             plt,
-                            hasline * sp[:legendfontsize] / 8,
+                            hasline * sp[:legend_font_pointsize] / 8,
                         ),
                         linestyle = py_linestyle(:path, get_linestyle(series)),
                         solid_capstyle = "butt",
@@ -1635,7 +1635,7 @@ function py_add_legend(plt::Plot, sp::Subplot, ax)
                         dash_capstyle = "butt",
                         dash_joinstyle = "miter",
                         marker = py_marker(_cycle(series[:markershape], 1)),
-                        markersize = py_thickness_scale(plt, 0.8 * sp[:legendfontsize]),
+                        markersize = py_thickness_scale(plt, 0.8 * sp[:legend_font_pointsize]),
                         markeredgecolor = py_color(
                             single_color(get_markerstrokecolor(series)),
                             get_markerstrokealpha(series),
@@ -1646,7 +1646,7 @@ function py_add_legend(plt::Plot, sp::Subplot, ax)
                         ),
                         markeredgewidth = py_thickness_scale(
                             plt,
-                            0.8 * get_markerstrokewidth(series) * sp[:legendfontsize] /
+                            0.8 * get_markerstrokewidth(series) * sp[:legend_font_pointsize] /
                             first(series[:markersize]),
                         ),   # retain the markersize/markerstroke ratio from the markers on the plot
                     )
@@ -1679,11 +1679,21 @@ function py_add_legend(plt::Plot, sp::Subplot, ax)
             leg."set_zorder"(1000)
             if sp[:legend_title] !== nothing
                 leg."set_title"(sp[:legend_title])
-                PyPlot.plt."setp"(leg."get_title"(), color = py_color(sp[:legend_title_font_color]), family = sp[:legend_title_font_family], fontsize = py_thickness_scale(plt, sp[:legend_title_font_pointsize]))
+                PyPlot.plt."setp"(
+                    leg."get_title"(),
+                    color = py_color(sp[:legend_title_font_color]),
+                    family = sp[:legend_title_font_family],
+                    fontsize = py_thickness_scale(plt, sp[:legend_title_font_pointsize]),
+                )
             end
 
             for txt in leg."get_texts"()
-                PyPlot.plt."setp"(txt, color = py_color(sp[:legend_font_color]), family = sp[:legend_font_family], fontsize = py_thickness_scale(plt, sp[:legend_font_pointsize]))
+                PyPlot.plt."setp"(
+                    txt,
+                    color = py_color(sp[:legend_font_color]),
+                    family = sp[:legend_font_family],
+                    fontsize = py_thickness_scale(plt, sp[:legend_font_pointsize]),
+                )
             end
         end
     end

src/colorbars.jl

@@ -5,27 +5,24 @@ process_clims(s::Union{Symbol,Nothing,Missing}) = ignorenan_extrema
 # don't specialize on ::Function otherwise python functions won't work
 process_clims(f) = f
 
-const sp_clims = IdDict{Subplot,Tuple{Float64,Float64}}()
-const series_clims = IdDict{Series,Tuple{Float64,Float64}}()
-
 get_clims(sp::Subplot)::Tuple{Float64,Float64} =
-    haskey(sp_clims, sp) ? sp_clims[sp] : update_clims(sp)
+    haskey(sp.attr, :clims_calculated) ? sp[:clims_calculated] : update_clims(sp)
 get_clims(series::Series)::Tuple{Float64,Float64} =
-    haskey(series_clims, series) ? series_clims[series] : update_clims(series)
-
+    haskey(series.plotattributes, :clims_calculated) ?
+        series[:clims_calculated]::Tuple{Float64,Float64} : update_clims(series)
 get_clims(sp::Subplot, series::Series)::Tuple{Float64,Float64} =
     series[:colorbar_entry] ? get_clims(sp) : get_clims(series)
 
 function update_clims(sp::Subplot, op = process_clims(sp[:clims]))::Tuple{Float64,Float64}
     zmin, zmax = Inf, -Inf
     for series in series_list(sp)
-        if series[:colorbar_entry]
+        if series[:colorbar_entry]::Bool
             zmin, zmax = _update_clims(zmin, zmax, update_clims(series, op)...)
         else
             update_clims(series, op)
         end
     end
-    return sp_clims[sp] = zmin <= zmax ? (zmin, zmax) : (NaN, NaN)
+    return sp[:clims_calculated] = zmin <= zmax ? (zmin, zmax) : (NaN, NaN)
 end
 
 """
@@ -36,10 +33,9 @@ values of the input. The value is stored as a series property, which is retrieve
 """
 function update_clims(series::Series, op = ignorenan_extrema)::Tuple{Float64,Float64}
     zmin, zmax = Inf, -Inf
-    z_colored_series = (:contour, :contour3d, :heatmap, :histogram2d, :surface, :hexbin)
 
     # keeping this unrolled has higher performance
-    if series[:seriestype] ∈ z_colored_series && series[:z] !== nothing
+    if series[:seriestype] ∈ _z_colored_series && series[:z] !== nothing
         zmin, zmax = update_clims(zmin, zmax, series[:z], op)
     end
     if series[:line_z] !== nothing
@@ -51,8 +47,7 @@ function update_clims(series::Series, op = ignorenan_extrema)::Tuple{Float64,Flo
     if series[:fill_z] !== nothing
         zmin, zmax = update_clims(zmin, zmax, series[:fill_z], op)
     end
-
-    return series_clims[series] = zmin <= zmax ? (zmin, zmax) : (NaN, NaN)
+    return series[:clims_calculated] = zmin <= zmax ? (zmin, zmax) : (NaN, NaN)
 end
 
 update_clims(zmin, zmax, vals::AbstractSurface, op)::Tuple{Float64,Float64} =

src/examples.jl

@@ -1232,6 +1232,38 @@ const _examples = PlotExample[
             ),
         ],
     ),
+    PlotExample( # 56
+        "Bar plot customizations",
+        """
+        Width of bars may be specified as `bar_width`. 
+        The bars' baseline may be specified as `fillto`.
+        Each may be scalar, or a vector spcifying one value per bar.
+        """,
+        [
+            :(
+                begin
+                    plot(
+                        bar(
+                            [-1, 0, 2, 3],
+                            [1, 3, 6, 2],
+                            fill_z = 4:-1:1,
+                            alpha = [1, 0.2, 0.8, 0.5],
+                            label = "",
+                            bar_width = 1:4,
+                        ),
+                        bar(
+                            rand(5),
+                            bar_width = 1.2,
+                            alpha = 0.8,
+                            color = [:lightsalmon, :tomato, :crimson, :firebrick, :darkred],
+                            fillto = 0:-0.1:-0.4,
+                            label = "reds",
+                        ),
+                    )
+                end
+            ),
+        ],
+    ),
 ]
 
 # Some constants for PlotDocs and PlotReferenceImages

src/precompile_includer.jl

@@ -1,5 +1,7 @@
+#! format: off
 should_precompile = true
 
+
 # Don't edit the following! Instead change the script for `snoop_bot`.
 ismultios = false
 ismultiversion = false
@@ -7,9 +9,7 @@ ismultiversion = false
 @static if !should_precompile
     # nothing
 elseif !ismultios && !ismultiversion
-    @static if isfile(
-        joinpath(@__DIR__, "../deps/SnoopCompile/precompile/precompile_Plots.jl"),
-    )
+    @static if isfile(joinpath(@__DIR__, "../deps/SnoopCompile/precompile/precompile_Plots.jl"))
         include("../deps/SnoopCompile/precompile/precompile_Plots.jl")
         _precompile_()
     end

src/recipes.jl

@@ -508,6 +508,18 @@ end
         primary := true
         x := xseg.pts
         y := yseg.pts
+        # expand attributes to match indices in new series data
+        for k in _segmenting_vector_attributes ∪ _segmenting_array_attributes
+            v = get(plotattributes, k, nothing)
+            if v isa AVec
+                if eachindex(v) != eachindex(y)
+                    @warn "Indices $(eachindex(v)) of attribute `$k` do not match data indices $(eachindex(y))."
+                end
+                # Each segment is 6 elements long, including the NaN separator.
+                # There is no trailing NaN, so the last repetition is dropped.
+                plotattributes[k] = @view repeat(v; inner = 6)[1:(end - 1)]
+            end
+        end
         ()
     end
 

src/utils.jl

@@ -103,7 +103,10 @@ function series_segments(series::Series, seriestype::Symbol = :path; check = fal
 
     segments = if has_attribute_segments(series)
         Iterators.flatten(map(nan_segments) do r
-                if seriestype in (:scatter, :scatter3d)
+                if seriestype == :shape
+                    warn_on_inconsistent_shape_attr(series, x, y, z, r)
+                    (SeriesSegment(r, first(r)),)
+                elseif seriestype in (:scatter, :scatter3d)
                     (SeriesSegment(i:i, i) for i in r)
                 else
                     (SeriesSegment(i:(i + 1), i) for i in first(r):(last(r) - 1))
@@ -140,6 +143,16 @@ function warn_on_attr_dim_mismatch(series, x, y, z, segments)
     end
 end
 
+function warn_on_inconsistent_shape_attr(series, x, y, z, r)
+    for attr in _segmenting_vector_attributes
+        v = get(series, attr, nothing)
+        if v isa AVec && length(unique(v[r])) > 1
+            @warn "Different values of `$attr` specified for different shape vertices. Only first one will be used."
+            break
+        end
+    end
+end
+
 # helpers to figure out if there are NaN values in a list of array types
 anynan(i::Int, args::Tuple) = any(a -> try
     isnan(_cycle(a, i))
@@ -573,7 +586,6 @@ const _segmenting_array_attributes = :line_z, :fill_z, :marker_z
 function has_attribute_segments(series::Series)
     # we want to check if a series needs to be split into segments just because
     # of its attributes
-    series[:seriestype] == :shape && return false
     # check relevant attributes if they have multiple inputs
     return any(
         series[attr] isa AbstractVector && length(series[attr]) > 1 for

test/test_defaults.jl

@@ -19,7 +19,7 @@ Plots.__init__()
     @test p[1][:legend_font_halign] == :hcenter
     @test p[1][:legend_font_valign] == :vcenter
     @test p[1][:legend_font_rotation] == 0.0
-    @test p[1][:legend_font_color] == RGB{Colors.N0f8}(0.0,0.0,0.0)
+    @test p[1][:legend_font_color] == RGB{Colors.N0f8}(0.0, 0.0, 0.0)
     @test p[1][:legend_position] == :best
     @test p[1][:legend_title] == nothing
     @test p[1][:legend_title_font_family] == "sans-serif"
@@ -27,9 +27,9 @@ Plots.__init__()
     @test p[1][:legend_title_font_halign] == :hcenter
     @test p[1][:legend_title_font_valign] == :vcenter
     @test p[1][:legend_title_font_rotation] == 0.0
-    @test p[1][:legend_title_font_color] == RGB{Colors.N0f8}(0.0,0.0,0.0)
-    @test p[1][:legend_background_color] == RGBA{Float64}(1.0,1.0,1.0,1.0)
-    @test p[1][:legend_foreground_color] == RGB{Colors.N0f8}(0.0,0.0,0.0)
+    @test p[1][:legend_title_font_color] == RGB{Colors.N0f8}(0.0, 0.0, 0.0)
+    @test p[1][:legend_background_color] == RGBA{Float64}(1.0, 1.0, 1.0, 1.0)
+    @test p[1][:legend_foreground_color] == RGB{Colors.N0f8}(0.0, 0.0, 0.0)
 end # testset
 
 @testset "Legend API" begin
@@ -65,6 +65,6 @@ end # testset
     @test p[1][:legend_title_font_valign] == :bottom
     @test p[1][:legend_title_font_rotation] == -5.2
     @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)
+    @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)
 end # testset