Add ticks getter functions (#3435)

* Add ticks getter functions

* Add tick-getter functions for Plot objects

* Fix boiler-plate code in get_ticks

* Bump minor version + add tests

* Remove kwargs and add subplot test

* Add docstrings

* bump minor version

.github/workflows/SnoopCompile.yml

@@ -21,7 +21,7 @@ jobs:
       fail-fast: false
       matrix:
         version:   # NOTE: the versions below should match those in your botconfig
-          - '1.5'
+          - '1'
         os:        # NOTE: should match the os setting of your botconfig
           - ubuntu-latest
         arch:

Project.toml

@@ -1,7 +1,7 @@
 name = "Plots"
 uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
 author = ["Tom Breloff (@tbreloff)"]
-version = "1.10.2"
+version = "1.13.0"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
@@ -36,20 +36,20 @@ UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
 Contour = "0.5"
 FFMPEG = "0.2, 0.3, 0.4"
 FixedPointNumbers = "0.6, 0.7, 0.8"
-GR = "0.46, 0.47, 0.48, 0.49, 0.50, 0.51, 0.52, 0.53"
+GR = "0.46, 0.47, 0.48, 0.49, 0.50, 0.51, 0.52, 0.53, 0.54, 0.55, 0.57"
 GeometryBasics = "0.2, 0.3.1"
 JSON = "0.21, 1"
-Latexify = "0.14"
+Latexify = "0.14, 0.15"
 Measures = "0.3"
 NaNMath = "0.3"
 PlotThemes = "2"
 PlotUtils = "1"
 RecipesBase = "1"
-RecipesPipeline = "0.2"
+RecipesPipeline = "0.3"
 Reexport = "0.2, 1.0"
 Requires = "1"
 Scratch = "1"
-Showoff = "0.3.1"
+Showoff = "0.3.1, 1.0"
 StatsBase = "0.32, 0.33"
 julia = "1.5"
 
@@ -63,6 +63,7 @@ Images = "916415d5-f1e6-5110-898d-aaa5f9f070e0"
 LibGit2 = "76f85450-5226-5b5a-8eaa-529ad045b433"
 OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
 PGFPlotsX = "8314cec4-20b6-5062-9cdb-752b83310925"
+PlotlyJS = "f0f68f2c-4968-5e81-91da-67840de0976a"
 RDatasets = "ce6b1742-4840-55fa-b093-852dadbb1d8b"
 StableRNGs = "860ef19b-820b-49d6-a774-d7a799459cd3"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
@@ -73,4 +74,4 @@ UnicodePlots = "b8865327-cd53-5732-bb35-84acbb429228"
 VisualRegressionTests = "34922c18-7c2a-561c-bac1-01e79b2c4c92"
 
 [targets]
-test = ["Distributions", "FileIO", "Gtk", "ImageMagick", "Images", "LibGit2", "OffsetArrays", "PGFPlotsX", "HDF5", "RDatasets", "StableRNGs", "StaticArrays", "StatsPlots", "Test", "TestImages", "UnicodePlots", "VisualRegressionTests"]
+test = ["Distributions", "FileIO", "Gtk", "ImageMagick", "Images", "LibGit2", "OffsetArrays", "PGFPlotsX", "PlotlyJS", "HDF5", "RDatasets", "StableRNGs", "StaticArrays", "StatsPlots", "Test", "TestImages", "UnicodePlots", "VisualRegressionTests"]

benchmark/benchmarks.jl

@@ -6,5 +6,5 @@ julia_cmd = split(get(ENV, "TESTCMD", Base.JLOptions().julia_bin))
 
 SUITE["load_plot_display"] = @benchmarkable run(`$julia_cmd --startup-file=no --project -e 'using Plots; display(plot(1:0.1:10, sin.(1:0.1:10)))'`)
 SUITE["load"] = @benchmarkable run(`$julia_cmd --startup-file=no --project -e 'using Plots'`)
-SUITE["plot"] = @benchmarkable p = plot(1:0.1:10, sin.(1:0.1:10))
-SUITE["display"] = @benchmarkable display(p) setup=(p = plot(1:0.1:10, sin.(1:0.1:10)))
+SUITE["plot"] = @benchmarkable p = plot(1:0.1:10, sin.(1:0.1:10)) samples=1 evals=1
+SUITE["display"] = @benchmarkable display(p) setup=(p = plot(1:0.1:10, sin.(1:0.1:10))) samples=1 evals=1

deps/SnoopCompile/precompile/precompile_Plots.jl

@@ -1,3 +1,18 @@
+# Use
+#    @warnpcfail precompile(args...)
+# if you want to be warned when a precompile directive fails
+macro warnpcfail(ex::Expr)
+    modl = __module__
+    file = __source__.file === nothing ? "?" : String(__source__.file)
+    line = __source__.line
+    quote
+        $(esc(ex)) || @warn """precompile directive
+     $($(Expr(:quote, ex)))
+ failed. Please report an issue in $($modl) (after checking for duplicates) or remove this directive.""" _file=$file _line=$line
+    end
+end
+
+
 const __bodyfunction__ = Dict{Method,Any}()
 
 # Find keyword "body functions" (the function that contains the body
@@ -51,287 +66,251 @@ 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})
-    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,),Tuple{Subplot{PlotlyBackend}}},Type{Subplot},PlotlyBackend})
-    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights),Tuple{Bool,Array{Int64,1}}},typeof(_make_hist),Tuple{Array{Float64,1}},Symbol})
-    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights),Tuple{Bool,Nothing}},typeof(_make_hist),Tuple{Array{Float64,1},Array{Float64,1}},Int64})
-    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights),Tuple{Bool,Nothing}},typeof(_make_hist),Tuple{Array{Float64,1},Array{Float64,1}},Tuple{Int64,Int64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights),Tuple{Bool,Nothing}},typeof(_make_hist),Tuple{Array{Float64,1}},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, :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,),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{(: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{(:rotation,),Tuple{Int64}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:scale, :guide),Tuple{Symbol,String}},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{(: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(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle),Tuple{Symbol,Symbol}},typeof(gr_polyline),Array{Int64,1},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle),Tuple{Symbol,Symbol}},typeof(gr_polyline),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle),Tuple{Symbol,Symbol}},typeof(gr_polyline),StepRange{Int64,Int64},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle),Tuple{Symbol,Symbol}},typeof(gr_polyline),UnitRange{Int64},Array{Float64,1}})
-    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(heatmap)),Any,typeof(heatmap),Any,Vararg{Any,N} where N})
+    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(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}, Vector{Float64}},Int64})
+    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{(:formatter,), Tuple{typeof(datetimeformatter)}},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{(: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{Int64, Float64}}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:scale, :guide), Tuple{Symbol, String}},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(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),StepRange{Int64, Int64},Vector{Float64}})
+    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(hline!)),Any,typeof(hline!),Any})
-    Base.precompile(Tuple{Core.kwftype(typeof(lens!)),Any,typeof(lens!),Any,Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype),Tuple{Float64,Symbol}},typeof(plot!),Array{GeometryBasics.Point{2,Float64},1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype),Tuple{Float64,Symbol}},typeof(plot!),Plot{GRBackend},Array{GeometryBasics.Point{2,Float64},1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:annotation,),Tuple{Array{Tuple{Int64,Float64,PlotText},1}}},typeof(plot!)})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:line, :seriestype),Tuple{Tuple{Int64,Symbol,Float64,Array{Symbol,2}},Symbol}},typeof(plot!),Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:line, :seriestype),Tuple{Tuple{Int64,Symbol,Float64,Array{Symbol,2}},Symbol}},typeof(plot!),Plot{GRBackend},Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:lw, :color),Tuple{Int64,Symbol}},typeof(plot!),Function,Float64,Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:lw, :color),Tuple{Int64,Symbol}},typeof(plot!),Plot{GRBackend},Function,Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype),Tuple{Tuple{Int64,Float64,Symbol},Array{Any,1},Symbol}},typeof(plot!),Plot{GRBackend},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype),Tuple{Tuple{Int64,Float64,Symbol},Array{Any,1},Symbol}},typeof(plot!),Plot{PlotlyBackend},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype),Tuple{Tuple{Int64,Float64,Symbol},Array{Any,1},Symbol}},typeof(plot!),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:markersize, :c, :seriestype),Tuple{Int64,Symbol,Symbol}},typeof(plot!),Array{Float64,1}})
-    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!),Array{Int64,1},Array{Float64,1}})
-    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},Array{Int64,1},Vararg{Any,N} where N})
-    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},Array{Int64,1},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,),Tuple{Symbol}},typeof(plot!),Array{Int64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,),Tuple{Symbol}},typeof(plot!),Plot{GRBackend},Array{Int64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,),Tuple{Symbol}},typeof(plot!),Plot{PlotlyBackend},Array{Int64,1}})
-    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!)})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:w,),Tuple{Int64}},typeof(plot!),Array{Float64,1},Array{Float64,1},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:w,),Tuple{Int64}},typeof(plot!),Plot{GRBackend},Array{Float64,1},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,),Tuple{Tuple{String,Symbol}}},typeof(plot!)})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype),Tuple{Array{Float64,1},Tuple{Symbol,Float64,Stroke},Array{Float64,1},String,Symbol}},typeof(plot!),Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype),Tuple{Array{Float64,1},Tuple{Symbol,Float64,Stroke},Array{Float64,1},String,Symbol}},typeof(plot!),Plot{GRBackend},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype),Tuple{Array{Float64,1},Tuple{Symbol,Float64,Stroke},Array{Float64,1},String,Symbol}},typeof(plot!),Plot{PlotlyBackend},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:annotations, :leg),Tuple{Tuple{Int64,Float64,PlotText},Bool}},typeof(plot),Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:arrow,),Tuple{Int64}},typeof(plot),Array{Float64,1},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:aspect_ratio, :seriestype),Tuple{Int64,Symbol}},typeof(plot),Array{String,1},Array{String,1},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:bins, :weights, :seriestype),Tuple{Symbol,Array{Int64,1},Symbol}},typeof(plot),Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:color, :line, :marker),Tuple{Array{Symbol,2},Tuple{Symbol,Int64},Tuple{Array{Symbol,2},Int64,Float64,Stroke}}},typeof(plot),Array{Array{T,1} where T,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:connections, :seriestype),Tuple{Tuple{Array{Int64,1},Array{Int64,1},Array{Int64,1}},Symbol}},typeof(plot),Array{Int64,1},Array{Int64,1},Vararg{Array{Int64,1},N} where N})
-    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}},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:framestyle, :title, :color, :layout, :label, :markerstrokewidth, :ticks, :seriestype),Tuple{Array{Symbol,2},Array{String,2},Base.ReshapedArray{Int64,2,UnitRange{Int64},Tuple{}},Int64,String,Int64,UnitRange{Int64},Symbol}},typeof(plot),Array{Array{Float64,1},1},Array{Array{Float64,1},1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:grid, :title),Tuple{Tuple{Symbol,Symbol,Symbol,Int64,Float64},String}},typeof(plot),Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:lab, :w, :palette, :fill, :α),Tuple{String,Int64,PlotUtils.ContinuousColorGradient,Int64,Float64}},typeof(plot),StepRange{Int64,Int64},Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label, :title, :xlabel, :linewidth, :legend),Tuple{Array{String,2},String,String,Int64,Symbol}},typeof(plot),Array{Function,1},Float64,Vararg{Float64,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label,),Tuple{Array{String,2}}},typeof(plot),Array{AbstractArray{Float64,1},1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :group, :linetype, :linecolor),Tuple{GridLayout,Array{String,1},Array{Symbol,2},Symbol}},typeof(plot),Array{Float64,1}})
-    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},Vararg{Plot{GRBackend},N} where N})
-    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},Vararg{Plot{PlotlyBackend},N} where N})
-    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, :palette, :bg_inside),Tuple{Int64,Array{PlotUtils.ContinuousColorGradient,2},Array{Symbol,2}}},typeof(plot),Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :t, :leg, :ticks, :border),Tuple{GridLayout,Array{Symbol,2},Bool,Nothing,Symbol}},typeof(plot),Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :title, :titlelocation, :left_margin, :bottom_margin, :xrotation),Tuple{GridLayout,Array{String,2},Symbol,Array{Length{:mm,Float64},2},Length{:mm,Float64},Int64}},typeof(plot),Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :xlims),Tuple{GridLayout,Tuple{Int64,Float64}}},typeof(plot),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},Vararg{Plot{GRBackend},N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,),Tuple{Bool}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend},N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,),Tuple{Symbol}},typeof(plot),Array{Tuple{Int64,Real},1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,),Tuple{Symbol}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend},N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,),Tuple{Symbol}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend},N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :lab, :ms),Tuple{Tuple{Array{Symbol,2},Int64},Array{String,2},Int64}},typeof(plot),Array{Array{T,1} where T,1},Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :label, :legendtitle),Tuple{Tuple{Int64,Array{Symbol,2}},Array{String,2},String}},typeof(plot),Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :leg, :fill),Tuple{Int64,Bool,Tuple{Int64,Symbol}}},typeof(plot),Function,Function,Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :marker, :bg, :fg, :xlim, :ylim, :leg),Tuple{Tuple{Int64,Symbol,Symbol},Tuple{Shape,Int64,RGBA{Float64}},Symbol,Symbol,Tuple{Int64,Int64},Tuple{Int64,Int64},Bool}},typeof(plot),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line_z, :linewidth, :legend),Tuple{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Int64,Bool}},typeof(plot),Array{Float64,1},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:m, :lab, :bg, :xlim, :ylim, :seriestype),Tuple{Tuple{Int64,Symbol},Array{String,2},Symbol,Tuple{Int64,Int64},Tuple{Int64,Int64},Symbol}},typeof(plot),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:marker,),Tuple{Bool}},typeof(plot),Array{Union{Missing, Int64},1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:marker_z, :color, :legend, :seriestype),Tuple{typeof(+),Symbol,Bool,Symbol}},typeof(plot),Array{Float64,1},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:nbins, :seriestype),Tuple{Int64,Symbol}},typeof(plot),Array{Float64,1},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:nbins, :show_empty_bins, :normed, :aspect_ratio, :seriestype),Tuple{Tuple{Int64,Int64},Bool,Bool,Int64,Symbol}},typeof(plot),Array{Complex{Float64},1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:proj, :m),Tuple{Symbol,Int64}},typeof(plot),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:projection, :seriestype),Tuple{Symbol,Symbol}},typeof(plot),Array{Int64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:quiver, :seriestype),Tuple{Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}},Symbol}},typeof(plot),Array{Float64,1},Array{Float64,1},Vararg{Array{Float64,1},N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:reg, :fill),Tuple{Bool,Tuple{Int64,Symbol}}},typeof(plot),Array{Float64,1}})
-    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}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype, :markershape, :markersize, :color),Tuple{Array{Symbol,2},Array{Symbol,1},Int64,Array{Symbol,1}}},typeof(plot),Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype,),Tuple{Symbol}},typeof(plot),Array{DateTime,1},UnitRange{Int64},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype,),Tuple{Symbol}},typeof(plot),Array{OHLC,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:st, :xlabel, :ylabel, :zlabel),Tuple{Symbol,String,String,String}},typeof(plot),Array{Float64,1},Array{Float64,1},Vararg{Array{Float64,1},N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title, :l, :seriestype),Tuple{String,Float64,Symbol}},typeof(plot),Array{String,1},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title,),Tuple{Array{String,2}}},typeof(plot),Plot{GRBackend},Plot{GRBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title,),Tuple{Array{String,2}}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend}})
-    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{(:w,),Tuple{Int64}},typeof(plot),Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:xaxis, :background_color, :leg),Tuple{Tuple{String,Tuple{Int64,Int64},StepRange{Int64,Int64},Symbol},RGB{Float64},Bool}},typeof(plot),Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:yflip, :aspect_ratio),Tuple{Bool,Symbol}},typeof(plot),Array{Float64,1},Array{Int64,1},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:zcolor, :m, :leg, :cbar, :w),Tuple{StepRange{Int64,Int64},Tuple{Int64,Float64,Symbol,Stroke},Bool,Bool,Int64}},typeof(plot),Array{Float64,1},Array{Float64,1},Vararg{Any,N} where N})
-    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,Vararg{Any,N} where N})
+    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, PlotText}}}},typeof(plot!)})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:line, :seriestype), Tuple{Tuple{Int64, Symbol, Float64, Matrix{Symbol}}, Symbol}},typeof(plot!),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:line, :seriestype), Tuple{Tuple{Int64, Symbol, Float64, Matrix{Symbol}}, Symbol}},typeof(plot!),Plot{GRBackend},Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:line, :seriestype), Tuple{Tuple{Int64, Symbol, Float64, Matrix{Symbol}}, Symbol}},typeof(plot!),Plot{PlotlyBackend},Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:lw, :color), Tuple{Int64, Symbol}},typeof(plot!),Function,Float64,Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:lw, :color), Tuple{Int64, Symbol}},typeof(plot!),Plot{GRBackend},Function,Vararg{Any, N} where N})
+    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}},Vararg{Any, N} where N})
+    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}},Vararg{Any, N} where N})
+    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!),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},Vararg{Any, N} where N})
+    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},Vararg{Any, N} where N})
+    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!),Vector{Int64}})
+    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},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,), Tuple{Tuple{String, Symbol}}},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{(:aspect_ratio, :seriestype), Tuple{Int64, Symbol}},typeof(plot),Vector{String},Vector{String},Vararg{Any, N} where N})
+    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, :seriestype), Tuple{Tuple{Vector{Int64}, Vector{Int64}, Vector{Int64}}, Symbol}},typeof(plot),Vector{Int64},Vector{Int64},Vararg{Vector{Int64}, N} where N})
+    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}},Vararg{Any, N} where N})
+    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}})
+    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,Vararg{Float64, N} where N})
+    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, :label, :fillrange, :fillalpha), Tuple{Tuple{Int64, Int64}, String, Int64, Float64}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    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},Vararg{Plot{PlotlyBackend}, N} where N})
+    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, :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, :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},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout,), Tuple{Tuple{Int64, Int64}}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout,), Tuple{Tuple{Int64, Int64}}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Bool}},typeof(plot),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},Vararg{Plot{PlotlyBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot),Vector{Tuple{Int64, Real}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :lab, :ms), Tuple{Tuple{Matrix{Symbol}, Int64}, Matrix{String}, Int64}},typeof(plot),Vector{Vector{T} where T},Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :label, :legendtitle), Tuple{Tuple{Int64, Matrix{Symbol}}, Matrix{String}, String}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :leg, :fill), Tuple{Int64, Bool, Tuple{Int64, Symbol}}},typeof(plot),Function,Function,Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :marker, :bg, :fg, :xlim, :ylim, :leg), Tuple{Tuple{Int64, Symbol, Symbol}, Tuple{Shape, Int64, RGBA{Float64}}, Symbol, Symbol, Tuple{Int64, Int64}, Tuple{Int64, Int64}, Bool}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line_z, :linewidth, :legend), Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int64, Bool}},typeof(plot),Vector{Float64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:m, :lab, :bg, :xlim, :ylim, :seriestype), Tuple{Tuple{Int64, Symbol}, Matrix{String}, Symbol, Tuple{Int64, Int64}, Tuple{Int64, Int64}, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:marker,), Tuple{Bool}},typeof(plot),Vector{Union{Missing, Int64}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:marker_z, :color, :legend, :seriestype), Tuple{typeof(+), Symbol, Bool, Symbol}},typeof(plot),Vector{Float64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:markershape, :markersize, :marker_z, :line_z, :linewidth), Tuple{Matrix{Symbol}, Matrix{Int64}, Matrix{Int64}, Matrix{Int64}, Matrix{Int64}}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:markershape, :seriestype, :label), Tuple{Symbol, Symbol, String}},typeof(plot),UnitRange{Int64},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:nbins, :seriestype), Tuple{Int64, Symbol}},typeof(plot),Vector{Float64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:nbins, :show_empty_bins, :normed, :aspect_ratio, :seriestype), Tuple{Tuple{Int64, Int64}, Bool, Bool, Int64, Symbol}},typeof(plot),Vector{ComplexF64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:proj, :m), Tuple{Symbol, Int64}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
+    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},Vararg{Any, N} where N})
+    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},Vararg{Vector{Float64}, N} where N})
+    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{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}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype, :markershape, :markersize, :color), Tuple{Matrix{Symbol}, Vector{Symbol}, Int64, Vector{Symbol}}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot),Vector{DateTime},UnitRange{Int64},Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot),Vector{OHLC}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:st, :xlabel, :ylabel, :zlabel), Tuple{Symbol, String, String, String}},typeof(plot),Vector{Float64},Vector{Float64},Vararg{Vector{Float64}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title, :l, :seriestype), Tuple{String, Float64, Symbol}},typeof(plot),Vector{String},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title,), Tuple{Matrix{String}}},typeof(plot),Plot{GRBackend},Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title,), Tuple{Matrix{String}}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend}})
+    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{(:w,), Tuple{Int64}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:xaxis, :background_color, :leg), Tuple{Tuple{String, Tuple{Int64, Int64}, StepRange{Int64, Int64}, Symbol}, RGB{Float64}, Bool}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:yflip, :aspect_ratio), Tuple{Bool, Symbol}},typeof(plot),Vector{Float64},Vector{Int64},Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:zcolor, :m, :leg, :cbar, :w), Tuple{StepRange{Int64, Int64}, Tuple{Int64, Float64, Symbol, Stroke}, Bool, Bool, Int64}},typeof(plot),Vector{Float64},Vector{Float64},Vararg{Any, N} where N})
+    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,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, :disp),Tuple{Array{Int64,1},Bool}},typeof(test_examples),Symbol})
-    Base.precompile(Tuple{Core.kwftype(typeof(test_examples)),NamedTuple{(:skip,),Tuple{Array{Int64,1}}},typeof(test_examples),Symbol})
-    Base.precompile(Tuple{Type{GridLayout},Int64,Vararg{Int64,N} where N})
-    Base.precompile(Tuple{Type{Shape},Array{Tuple{Float64,Float64},1}})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},AbstractArray{OHLC,1}})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Array{Complex{Float64},1}})
-    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{:histogram2d}},Any,Any,Any})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:hline}},Any,Any,Any})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:pie}},Any,Any,Any})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:quiver}},Any,Any,Any})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:spy}},Any,Any,Any})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:sticks}},Any,Any,Any})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:xerror}},Any,Any,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{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{: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})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:histogram2d}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:hline}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:lens}},AbstractPlot})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:pie}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:quiver}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:steppre}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:sticks}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:vline}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:xerror}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Vector{ComplexF64}})
     Base.precompile(Tuple{typeof(RecipesPipeline.add_series!),Plot{GRBackend},DefaultsDict})
     Base.precompile(Tuple{typeof(RecipesPipeline.add_series!),Plot{PlotlyBackend},DefaultsDict})
-    Base.precompile(Tuple{typeof(RecipesPipeline.plot_setup!),Plot{GRBackend},Dict{Symbol,Any},Array{Dict{Symbol,Any},1}})
-    Base.precompile(Tuple{typeof(RecipesPipeline.plot_setup!),Plot{PlotlyBackend},Dict{Symbol,Any},Array{Dict{Symbol,Any},1}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.plot_setup!),Plot{GRBackend},Dict{Symbol, Any},Vector{Dict{Symbol, Any}}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.plot_setup!),Plot{PlotlyBackend},Dict{Symbol, Any},Vector{Dict{Symbol, Any}}})
     Base.precompile(Tuple{typeof(RecipesPipeline.preprocess_attributes!),Plot{GRBackend},DefaultsDict})
-    Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plot{GRBackend},Array{Dict{Symbol,Any},1},Dict{Symbol,Any}})
-    Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plot{PlotlyBackend},Array{Dict{Symbol,Any},1},Dict{Symbol,Any}})
-    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{GRBackend},DefaultsDict,Symbol,String})
-    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{GRBackend},Dict{Symbol,Any},Symbol,String})
-    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{PlotlyBackend},DefaultsDict,Symbol,String})
-    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{PlotlyBackend},Dict{Symbol,Any},Symbol,String})
-    Base.precompile(Tuple{typeof(_bin_centers),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}})
-    Base.precompile(Tuple{typeof(_cbar_unique),Array{Int64,1},String})
-    Base.precompile(Tuple{typeof(_cbar_unique),Array{Nothing,1},String})
-    Base.precompile(Tuple{typeof(_cbar_unique),Array{PlotUtils.ContinuousColorGradient,1},String})
-    Base.precompile(Tuple{typeof(_cbar_unique),Array{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},1},String})
-    Base.precompile(Tuple{typeof(_cbar_unique),Array{Symbol,1},String})
-    Base.precompile(Tuple{typeof(_cycle),Array{Float64,1},Array{Int64,1}})
-    Base.precompile(Tuple{typeof(_cycle),Array{Float64,1},StepRange{Int64,Int64}})
-    Base.precompile(Tuple{typeof(_cycle),Array{Float64,1},UnitRange{Int64}})
-    Base.precompile(Tuple{typeof(_cycle),Base.OneTo{Int64},Array{Int64,1}})
-    Base.precompile(Tuple{typeof(_cycle),StepRange{Int64,Int64},Array{Int64,1}})
+    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},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{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(_do_plot_show),Plot{GRBackend},Bool})
-    Base.precompile(Tuple{typeof(_do_plot_show),Plot{PlotlyBackend},Bool})
-    Base.precompile(Tuple{typeof(_heatmap_edges),Array{Float64,1},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},Array{Float64,1}})
-    Base.precompile(Tuple{typeof(_preprocess_binlike),DefaultsDict,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1}})
-    Base.precompile(Tuple{typeof(_replace_markershape),Array{Symbol,1}})
+    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(_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_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_periphery),Subplot{GRBackend},Vector{Any}})
+    Base.precompile(Tuple{typeof(_update_subplot_periphery),Subplot{PlotlyBackend},Vector{Any}})
     Base.precompile(Tuple{typeof(backend),PlotlyBackend})
-    Base.precompile(Tuple{typeof(bbox!),Subplot{GRBackend},BoundingBox{Tuple{Length{:mm,Float64},Length{:mm,Float64}},Tuple{Length{:mm,Float64},Length{:mm,Float64}}}})
+    Base.precompile(Tuple{typeof(bbox),AbsoluteLength,AbsoluteLength,AbsoluteLength,AbsoluteLength})
     Base.precompile(Tuple{typeof(bbox),Float64,Float64,Float64,Float64})
-    Base.precompile(Tuple{typeof(bbox),Length{:mm,Float64},Length{:mm,Float64},Length{:mm,Float64},Length{:mm,Float64}})
     Base.precompile(Tuple{typeof(build_layout),GridLayout,Int64})
-    Base.precompile(Tuple{typeof(contour),Any,Vararg{Any,N} where N})
-    Base.precompile(Tuple{typeof(convert_to_polar),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1},Tuple{Int64,Float64}})
+    Base.precompile(Tuple{typeof(contour),Any,Vararg{Any, N} where N})
+    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),Array{Float64,1},Array{Float64,1},Array{Float64,1}})
-    Base.precompile(Tuple{typeof(error_style!),DefaultsDict})
-    Base.precompile(Tuple{typeof(error_zipit),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}})
-    Base.precompile(Tuple{typeof(fakedata),Int64,Vararg{Int64,N} where N})
-    Base.precompile(Tuple{typeof(font),String,Vararg{Any,N} where N})
-    Base.precompile(Tuple{typeof(get_clims),Subplot{GRBackend},Series,Function})
-    Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Array{Float64,1},Array{Any,1}}})
-    Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Array{Float64,1},Array{String,1}}})
-    Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Array{Int64,1},Array{String,1}}})
-    Base.precompile(Tuple{typeof(get_series_color),Array{Symbol,1},Subplot{GRBackend},Int64,Symbol})
-    Base.precompile(Tuple{typeof(get_series_color),Array{Symbol,1},Subplot{PlotlyBackend},Int64,Symbol})
-    Base.precompile(Tuple{typeof(get_xy),Array{OHLC,1}})
-    Base.precompile(Tuple{typeof(get_xy),OHLC{Float64},Int64,Float64})
-    Base.precompile(Tuple{typeof(gr_add_legend),Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor),NTuple{9,Float64}},Array{Float64,1}})
-    Base.precompile(Tuple{typeof(gr_add_legend),Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor),Tuple{Int64,Float64,Float64,Float64,Int64,Float64,Float64,Float64,Float64}},Array{Float64,1}})
-    Base.precompile(Tuple{typeof(gr_display),Subplot{GRBackend},Length{:mm,Float64},Length{:mm,Float64},Array{Float64,1}})
-    Base.precompile(Tuple{typeof(gr_draw_colorbar),GRColorbar,Subplot{GRBackend},Tuple{Float64,Float64},Array{Float64,1}})
-    Base.precompile(Tuple{typeof(gr_draw_contour),Series,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,2},Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_grid),Subplot{GRBackend},Axis,Segments{Tuple{Float64,Float64,Float64}},Function})
-    Base.precompile(Tuple{typeof(gr_draw_grid),Subplot{GRBackend},Axis,Segments{Tuple{Float64,Float64}}})
-    Base.precompile(Tuple{typeof(gr_draw_heatmap),Series,Array{Float64,1},Array{Float64,1},Array{Float64,2},Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_heatmap),Series,Base.OneTo{Int64},Base.OneTo{Int64},Array{Float64,2},Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Array{Int64,1},Array{Float64,1},Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Array{Int64,1},Array{Int64,1},Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Base.OneTo{Int64},Array{Float64,1},Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_markers),Series,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1},Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Array{Float64,1},Array{Float64,1},Int64,Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Array{Float64,1},Array{Float64,1},Nothing,Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Array{Float64,1},Int64,Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Array{Float64,1},Nothing,Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},UnitRange{Int64},Tuple{Array{Float64,1},Array{Float64,1}},Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_segments),Series,StepRange{Int64,Int64},Array{Float64,1},Int64,Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Array{Float64,1},Array{Any,1}},Int64})
-    Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Array{Float64,1},Array{String,1}},Int64})
-    Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Array{Int64,1},Array{String,1}},Int64})
-    Base.precompile(Tuple{typeof(gr_label_ticks),Subplot{GRBackend},Symbol,Tuple{Array{Float64,1},Array{String,1}}})
-    Base.precompile(Tuple{typeof(gr_label_ticks_3d),Subplot{GRBackend},Symbol,Tuple{Array{Float64,1},Array{String,1}}})
+    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(font),String,Vararg{Any, 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_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})
+    Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Int64, Int64},Vararg{Any, N} where N})
+    Base.precompile(Tuple{typeof(get_ticks),UnitRange{Int64},Vector{Float64},Vector{Any},Tuple{Float64, Float64},Vararg{Any, N} where N})
+    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, Float64, Float64, Float64, Int64, Float64, Float64, Float64, Float64}},Vector{Float64}})
+    Base.precompile(Tuple{typeof(gr_display),Subplot{GRBackend},AbsoluteLength,AbsoluteLength,Vector{Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_colorbar),GRColorbar,Subplot{GRBackend},Tuple{Float64, Float64},Vector{Float64}})
+    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_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,UnitRange{Int64},Vector{Float64},Nothing,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_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}})
+    Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Vector{Float64}, Vector{String}},Int64})
+    Base.precompile(Tuple{typeof(gr_label_ticks),Subplot{GRBackend},Symbol,Tuple{Vector{Float64}, 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),Array{Float64,1},Array{Float64,1},Function})
-    Base.precompile(Tuple{typeof(gr_polyline3d),Array{Float64,1},Array{Float64,1},Array{Float64,1}})
     Base.precompile(Tuple{typeof(gr_set_gradient),PlotUtils.ContinuousColorGradient})
-    Base.precompile(Tuple{typeof(gr_viewport_from_bbox),Subplot{GRBackend},BoundingBox{Tuple{Length{:mm,Float64},Length{:mm,Float64}},Tuple{Length{:mm,Float64},Length{:mm,Float64}}},Length{:mm,Float64},Length{:mm,Float64},Array{Float64,1}})
-    Base.precompile(Tuple{typeof(heatmap_edges),Array{Float64,1},Symbol})
+    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}}})
+    Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Vector{Float64},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), Tuple{Int64, Float64, Float64, Float64, Int64, Float64, Float64, Float64, Float64}}})
+    Base.precompile(Tuple{typeof(gr_viewport_from_bbox),Subplot{GRBackend},BoundingBox{Tuple{AbsoluteLength, AbsoluteLength}, Tuple{AbsoluteLength, AbsoluteLength}},AbsoluteLength,AbsoluteLength,Vector{Float64}})
     Base.precompile(Tuple{typeof(heatmap_edges),Base.OneTo{Int64},Symbol})
-    Base.precompile(Tuple{typeof(heatmap_edges),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Symbol})
+    Base.precompile(Tuple{typeof(heatmap_edges),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Symbol,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Symbol,Tuple{Int64, Int64},Bool})
+    Base.precompile(Tuple{typeof(heatmap_edges),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Symbol})
     Base.precompile(Tuple{typeof(heatmap_edges),UnitRange{Int64},Symbol})
-    Base.precompile(Tuple{typeof(ignorenan_minimum),Array{Int64,1}})
-    Base.precompile(Tuple{typeof(iter_segments),Array{Float64,1},Array{Float64,1},UnitRange{Int64}})
-    Base.precompile(Tuple{typeof(iter_segments),Array{Float64,1}})
-    Base.precompile(Tuple{typeof(iter_segments),Base.OneTo{Int64},Array{Float64,1}})
+    Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol,UnitRange{Int64},Symbol,Tuple{Int64, Int64},Bool})
+    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(iter_segments),StepRange{Int64, Int64},Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(layout_args),Int64})
-    Base.precompile(Tuple{typeof(make_fillrange_side),UnitRange{Int64},LinRange{Float64}})
-    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Subplot{GRBackend},Axis,StepRange{Int64,Int64}})
-    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Subplot{GRBackend},Axis,UnitRange{Int64}})
-    Base.precompile(Tuple{typeof(plot!),Any})
-    Base.precompile(Tuple{typeof(plot),Any,Any})
+    Base.precompile(Tuple{typeof(ohlc),Any})
+    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(plot),Any,Any,Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(plot),Any})
-    Base.precompile(Tuple{typeof(processGridArg!),DefaultsDict,Bool,Symbol})
-    Base.precompile(Tuple{typeof(processGridArg!),Dict{Symbol,Any},Symbol,Symbol})
-    Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol,Any},Array{Symbol,2}})
-    Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol,Any},Int64})
-    Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol,Any},Symbol})
-    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol,Any},Array{Symbol,2}})
-    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol,Any},Float64})
-    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol,Any},RGBA{Float64}})
-    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol,Any},Shape})
-    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol,Any},Stroke})
-    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol,Any},Symbol})
+    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},Matrix{Symbol}})
+    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},RGBA{Float64}})
+    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Shape})
+    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{PlotlyBackend},Int64,Float64,PlotText})
-    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,Array{Float64,1}})
-    Base.precompile(Tuple{typeof(quiver_using_arrows),DefaultsDict})
-    Base.precompile(Tuple{typeof(quiver_using_hack),DefaultsDict})
-    Base.precompile(Tuple{typeof(reset_axis_defaults_byletter!)})
-    Base.precompile(Tuple{typeof(slice_arg),Array{Length{:mm,Float64},2},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Array{PlotUtils.ContinuousColorGradient,2},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Array{RGBA{Float64},2},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Array{String,2},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Array{Symbol,2},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Base.ReshapedArray{Int64,2,UnitRange{Int64},Tuple{}},Int64})
+    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(push!),Segments{Tuple{Float64, Float64, Float64}},Tuple{Int64, Float64, Int64},Tuple{Int64, Float64, Int64}})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{Bool},Int64})
     Base.precompile(Tuple{typeof(spy),Any})
-    Base.precompile(Tuple{typeof(straightline_data),Tuple{Float64,Float64},Tuple{Float64,Float64},Array{Float64,1},Array{Float64,1},Int64})
-    Base.precompile(Tuple{typeof(stroke),Int64,Vararg{Any,N} where N})
-    Base.precompile(Tuple{typeof(text),String,Int64,Symbol,Vararg{Symbol,N} where N})
-    Base.precompile(Tuple{typeof(text),String,Symbol,Int64,Vararg{Any,N} where N})
-    Base.precompile(Tuple{typeof(text),String,Symbol})
+    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})
+    Base.precompile(Tuple{typeof(text),String,Int64,Symbol,Vararg{Symbol, N} where N})
+    Base.precompile(Tuple{typeof(text),String,Symbol,Int64,Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(title!),AbstractString})
-    Base.precompile(Tuple{typeof(unzip),Array{GeometryBasics.Point{2,Float64},1}})
+    Base.precompile(Tuple{typeof(unzip),Vector{GeometryBasics.Point2{Float64}}})
     Base.precompile(Tuple{typeof(vline!),Any})
-    Base.precompile(Tuple{typeof(xgrid!),Plot{GRBackend},Symbol,Vararg{Any,N} where N})
+    Base.precompile(Tuple{typeof(xgrid!),Plot{GRBackend},Symbol,Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(xlims),Subplot{PlotlyBackend}})
     Base.precompile(Tuple{typeof(yaxis!),Any,Any})
-    let fbody = try __lookup_kwbody__(which(gr_polyline, (Array{Float64,1},Array{Float64,1},typeof(GR.fillarea),))) catch missing end
+    let fbody = try __lookup_kwbody__(which(bar, (Any,))) catch missing end
         if !ismissing(fbody)
-            precompile(fbody, (Symbol,Symbol,typeof(gr_polyline),Array{Float64,1},Array{Float64,1},typeof(GR.fillarea),))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(plot!, ())) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(plot!),))
+            precompile(fbody, (Any,typeof(bar),Any,))
         end
     end
     let fbody = try __lookup_kwbody__(which(plot!, (Any,))) catch missing end
@@ -339,9 +318,9 @@ function _precompile_()
             precompile(fbody, (Any,typeof(plot!),Any,))
         end
     end
-    let fbody = try __lookup_kwbody__(which(plot!, (Any,Vararg{Any,N} where N,))) catch missing end
+    let fbody = try __lookup_kwbody__(which(plot!, (Any,Vararg{Any, N} where N,))) catch missing end
         if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(plot!),Any,Vararg{Any,N} where N,))
+            precompile(fbody, (Any,typeof(plot!),Any,Vararg{Any, N} where N,))
         end
     end
     let fbody = try __lookup_kwbody__(which(plot, (Any,))) catch missing end
@@ -349,34 +328,24 @@ function _precompile_()
             precompile(fbody, (Any,typeof(plot),Any,))
         end
     end
-    let fbody = try __lookup_kwbody__(which(plot, (Any,Vararg{Any,N} where N,))) catch missing end
+    let fbody = try __lookup_kwbody__(which(plot, (Any,Vararg{Any, N} where N,))) catch missing end
         if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(plot),Any,Vararg{Any,N} where N,))
+            precompile(fbody, (Any,typeof(plot),Any,Vararg{Any, N} where N,))
         end
     end
-    let fbody = try __lookup_kwbody__(which(plot, (Plot,))) catch missing end
+    let fbody = try __lookup_kwbody__(which(plot, (Plot,Plot,Vararg{Plot, N} where N,))) catch missing end
         if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(plot),Plot,))
+            precompile(fbody, (Any,typeof(plot),Plot,Plot,Vararg{Plot, N} where N,))
         end
     end
-    let fbody = try __lookup_kwbody__(which(plot, (Plot,Plot,))) catch missing end
+    let fbody = try __lookup_kwbody__(which(text, (String,Int64,Vararg{Any, N} where N,))) catch missing end
         if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(plot),Plot,Plot,))
+            precompile(fbody, (Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}},typeof(text),String,Int64,Vararg{Any, N} where N,))
         end
     end
-    let fbody = try __lookup_kwbody__(which(plot, (Plot,Plot,Vararg{Plot,N} where N,))) catch missing end
+    let fbody = try __lookup_kwbody__(which(text, (String,Symbol,Vararg{Any, N} where N,))) catch missing end
         if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(plot),Plot,Plot,Vararg{Plot,N} where N,))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(text, (String,Int64,Vararg{Any,N} where N,))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},typeof(text),String,Int64,Vararg{Any,N} where N,))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(text, (String,Symbol,Vararg{Any,N} where N,))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},typeof(text),String,Symbol,Vararg{Any,N} where N,))
+            precompile(fbody, (Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}},typeof(text),String,Symbol,Vararg{Any, N} where N,))
         end
     end
     let fbody = try __lookup_kwbody__(which(title!, (AbstractString,))) catch missing end
@@ -384,14 +353,4 @@ function _precompile_()
             precompile(fbody, (Any,typeof(title!),AbstractString,))
         end
     end
-    let fbody = try __lookup_kwbody__(which(vline!, (Any,))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(vline!),Any,))
-        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

@@ -193,6 +193,7 @@ const _plotly_min_js_filename = "plotly-1.57.1.min.js"
 
 include("types.jl")
 include("utils.jl")
+include("colorbars.jl")
 include("axes.jl")
 include("args.jl")
 include("components.jl")
@@ -211,6 +212,7 @@ include("output.jl")
 include("ijulia.jl")
 include("fileio.jl")
 include("init.jl")
+include("legend.jl")
 
 include("backends/plotly.jl")
 include("backends/gr.jl")

src/arg_desc.jl

@@ -2,164 +2,171 @@
 const _arg_desc = KW(
 
 # series args
-:label 			=> "String type. The label for a series, which appears in a legend.  If empty, no legend entry is added.",
-:seriescolor 		=> "Color Type. The base color for this series.  `:auto` (the default) will select a color from the subplot's `color_palette`, based on the order it was added to the subplot",
-:seriesalpha 		=> "Number in [0,1]. The alpha/opacity override for the series.  `nothing` (the default) means it will take the alpha value of the color.",
-:seriestype 		=> "Symbol. This is the identifier of the type of visualization for this series. Choose from $(_allTypes) or any series recipes which are defined.",
-:linestyle 			=> "Symbol. Style of the line (for path and bar stroke).  Choose from $(_allStyles)",
-:linewidth         	=> "Number. Width of the line (in pixels)",
-:linecolor         	=> "Color Type. Color of the line (for path and bar stroke).  `:match` will take the value from `:seriescolor`, (though histogram/bar types use `:black` as a default).",
-:linealpha         	=> "Number in [0,1]. The alpha/opacity override for the line.  `nothing` (the default) means it will take the alpha value of linecolor.",
-:fillrange         	=> "Number or AbstractVector.  Fills area between fillrange and y for line-types, sets the base for bar/stick types, and similar for other types.",
-:fillcolor         	=> "Color Type. Color of the filled area of path or bar types.  `:match` will take the value from `:seriescolor`.",
-:fillalpha         	=> "Number in [0,1]. The alpha/opacity override for the fill area.  `nothing` (the default) means it will take the alpha value of fillcolor.",
-:markershape       	=> "Symbol, Shape, or AbstractVector. Choose from $(_allMarkers).",
-:markercolor       	=> "Color Type. Color of the interior of the marker or shape. `:match` will take the value from `:seriescolor`.",
-:markeralpha       	=> "Number in [0,1]. The alpha/opacity override for the marker interior.  `nothing` (the default) means it will take the alpha value of markercolor.",
-:markersize        	=> "Number or AbstractVector. Size (radius pixels) of the markers.",
-:markerstrokestyle 	=> "Symbol. Style of the marker stroke (border).  Choose from $(_allStyles)",
-:markerstrokewidth 	=> "Number. Width of the marker stroke (border. in pixels)",
-:markerstrokecolor 	=> "Color Type. Color of the marker stroke (border).  `:match` will take the value from `:foreground_color_subplot`.",
-:markerstrokealpha 	=> "Number in [0,1]. The alpha/opacity override for the marker stroke (border).  `nothing` (the default) means it will take the alpha value of markerstrokecolor.",
-:bins              	=> "Integer, NTuple{2,Integer}, AbstractVector or Symbol. Default is :auto (the Freedman-Diaconis rule). For histogram-types, defines the approximate number of bins to aim for, or the auto-binning algorithm to use (:sturges, :sqrt, :rice, :scott or :fd). For fine-grained control pass a Vector of break values, e.g. `range(minimum(x), stop = maximum(x), length = 25)`",
-:smooth            	=> "Bool.  Add a regression line?",
-:group             	=> "AbstractVector. Data is split into a separate series, one for each unique value in `group`.",
-:x                 	=> "Various. Input data. First Dimension",
-:y                 	=> "Various. Input data. Second Dimension",
-:z                 	=> "Various. Input data. Third Dimension. May be wrapped by a `Surface` for surface and heatmap types.",
-:marker_z          	=> "AbstractVector, Function `f(x,y,z) -> z_value`, or Function `f(x,y) -> z_value`, or nothing. z-values for each series data point, which correspond to the color to be used from a markercolor gradient.",
-:line_z          	=> "AbstractVector, Function `f(x,y,z) -> z_value`, or Function `f(x,y) -> z_value`, or nothing. z-values for each series line segment, which correspond to the color to be used from a linecolor gradient.  Note that for N points, only the first N-1 values are used (one per line-segment).",
-:fill_z                 => "Matrix{Float64} of the same size as z matrix, which specifies the color of the 3D surface; the default value is `nothing`.",
-:levels            	=> "Integer, NTuple{2,Integer}, or AbstractVector. Levels or number of levels (or x-levels/y-levels) for a contour type.",
-:orientation       	=> "Symbol.  Horizontal or vertical orientation for bar types.  Values `:h`, `:hor`, `:horizontal` correspond to horizontal (sideways, anchored to y-axis), and `:v`, `:vert`, and `:vertical` correspond to vertical (the default).",
-:bar_position      	=> "Symbol.  Choose from `:overlay` (default), `:stack`.  (warning: May not be implemented fully)",
-:bar_width              => "nothing or Number. Width of bars in data coordinates. When nothing, chooses based on x (or y when `orientation = :h`).",
-:bar_edges              => "Bool.  Align bars to edges (true), or centers (the default)?",
-:xerror                 => "AbstractVector or 2-Tuple of Vectors. x (horizontal) error relative to x-value.  If 2-tuple of vectors, the first vector corresponds to the left error (and the second to the right)",
-:yerror            	=> "AbstractVector or 2-Tuple of Vectors. y (vertical) error relative to y-value.  If 2-tuple of vectors, the first vector corresponds to the bottom error (and the second to the top)",
-:ribbon            	=> "Number or AbstractVector.  Creates a fillrange around the data points.",
-:quiver            	=> "AbstractVector or 2-Tuple of vectors.  The directional vectors U,V which specify velocity/gradient vectors for a quiver plot.",
-:arrow             	=> "nothing (no arrows), Bool (if true, default arrows), Arrow object, or arg(s) that could be style or head length/widths.  Defines arrowheads that should be displayed at the end of path line segments (just before a NaN and the last non-NaN point).  Used in quiverplot, streamplot, or similar.",
-:normalize         	=> "Bool or Symbol. Histogram normalization mode. Possible values are: false/:none (no normalization, default), true/:pdf (normalize to a discrete Probability Density Function, where the total area of the bins is 1), :probability (bin heights sum to 1) and :density (the area of each bin, rather than the height, is equal to the counts - useful for uneven bin sizes).",
-:weights           	=> "AbstractVector. Used in histogram types for weighted counts.",
-:show_empty_bins    => "Bool. Whether empty bins in a 2D histogram are colored as 0 (true), or transparent (the default).",
-:contours          	=> "Bool. Add contours to the side-grids of 3D plots?  Used in surface/wireframe.",
-:contour_labels         => "Bool. Show labels at the contour lines?",
-:match_dimensions  	=> "Bool. For heatmap types... should the first dimension of a matrix (rows) correspond to the first dimension of the plot (x-axis)?  The default is false, which matches the behavior of Matplotlib, Plotly, and others.  Note: when passing a function for z, the function should still map `(x,y) -> z`.",
-:subplot           	=> "Integer (subplot index) or Subplot object.  The subplot that this series belongs to.",
-:series_annotations     => "AbstractVector of String or PlotText.  These are annotations which are mapped to data points/positions.",
-:primary                => "Bool.  Does this count as a 'real series'?  For example, you could have a path (primary), and a scatter (secondary) as 2 separate series, maybe with different data (see sticks recipe for an example).  The secondary series will get the same color, etc as the primary.",
-:hover 	        	=> "nothing or vector of strings. Text to display when hovering over each data point.",
-:colorbar_entry   => "Bool.  Include this series in the color bar?  Set to `false` to exclude.",
+:label                       => "String type. The label for a series, which appears in a legend.  If empty, no legend entry is added.",
+:seriescolor                 => "Color Type. The base color for this series.  `:auto` (the default) will select a color from the subplot's `color_palette`, based on the order it was added to the subplot",
+:seriesalpha                 => "Number in [0,1]. The alpha/opacity override for the series.  `nothing` (the default) means it will take the alpha value of the color.",
+:seriestype                  => "Symbol. This is the identifier of the type of visualization for this series. Choose from $(_allTypes) or any series recipes which are defined.",
+:linestyle                   => "Symbol. Style of the line (for path and bar stroke).  Choose from $(_allStyles)",
+:linewidth                   => "Number. Width of the line (in pixels)",
+:linecolor                   => "Color Type. Color of the line (for path and bar stroke).  `:match` will take the value from `:seriescolor`, (though histogram/bar types use `:black` as a default).",
+:linealpha                   => "Number in [0,1]. The alpha/opacity override for the line.  `nothing` (the default) means it will take the alpha value of linecolor.",
+:fillrange                   => "Number or AbstractVector.  Fills area between fillrange and y for line-types, sets the base for bar/stick types, and similar for other types.",
+:fillcolor                   => "Color Type. Color of the filled area of path or bar types.  `:match` will take the value from `:seriescolor`.",
+:fillalpha                   => "Number in [0,1]. The alpha/opacity override for the fill area.  `nothing` (the default) means it will take the alpha value of fillcolor.",
+:markershape                 => "Symbol, Shape, or AbstractVector. Choose from $(_allMarkers).",
+:markercolor                 => "Color Type. Color of the interior of the marker or shape. `:match` will take the value from `:seriescolor`.",
+:markeralpha                 => "Number in [0,1]. The alpha/opacity override for the marker interior.  `nothing` (the default) means it will take the alpha value of markercolor.",
+:markersize                  => "Number or AbstractVector. Size (radius pixels) of the markers.",
+:markerstrokestyle           => "Symbol. Style of the marker stroke (border).  Choose from $(_allStyles)",
+:markerstrokewidth           => "Number. Width of the marker stroke (border. in pixels)",
+:markerstrokecolor           => "Color Type. Color of the marker stroke (border).  `:match` will take the value from `:foreground_color_subplot`.",
+:markerstrokealpha           => "Number in [0,1]. The alpha/opacity override for the marker stroke (border).  `nothing` (the default) means it will take the alpha value of markerstrokecolor.",
+:bins                        => "Integer, NTuple{2,Integer}, AbstractVector or Symbol. Default is :auto (the Freedman-Diaconis rule). For histogram-types, defines the approximate number of bins to aim for, or the auto-binning algorithm to use (:sturges, :sqrt, :rice, :scott or :fd). For fine-grained control pass a Vector of break values, e.g. `range(minimum(x), stop = maximum(x), length = 25)`",
+:smooth                      => "Bool.  Add a regression line?",
+:group                       => "AbstractVector. Data is split into a separate series, one for each unique value in `group`.",
+:x                           => "Various. Input data. First Dimension",
+:y                           => "Various. Input data. Second Dimension",
+:z                           => "Various. Input data. Third Dimension. May be wrapped by a `Surface` for surface and heatmap types.",
+:marker_z                    => "AbstractVector, Function `f(x,y,z) -> z_value`, or Function `f(x,y) -> z_value`, or nothing. z-values for each series data point, which correspond to the color to be used from a markercolor gradient.",
+:line_z                      => "AbstractVector, Function `f(x,y,z) -> z_value`, or Function `f(x,y) -> z_value`, or nothing. z-values for each series line segment, which correspond to the color to be used from a linecolor gradient.  Note that for N points, only the first N-1 values are used (one per line-segment).",
+:fill_z                      => "Matrix{Float64} of the same size as z matrix, which specifies the color of the 3D surface; the default value is `nothing`.",
+:levels                      => "Integer, NTuple{2,Integer}, or AbstractVector. Levels or number of levels (or x-levels/y-levels) for a contour type.",
+:orientation                 => "Symbol.  Horizontal or vertical orientation for bar types.  Values `:h`, `:hor`, `:horizontal` correspond to horizontal (sideways, anchored to y-axis), and `:v`, `:vert`, and `:vertical` correspond to vertical (the default).",
+:bar_position                => "Symbol.  Choose from `:overlay` (default), `:stack`.  (warning: May not be implemented fully)",
+:bar_width                   => "nothing or Number. Width of bars in data coordinates. When nothing, chooses based on x (or y when `orientation = :h`).",
+:bar_edges                   => "Bool.  Align bars to edges (true), or centers (the default)?",
+:xerror                      => "AbstractVector or 2-Tuple of Vectors. x (horizontal) error relative to x-value.  If 2-tuple of vectors, the first vector corresponds to the left error (and the second to the right)",
+:yerror                      => "AbstractVector or 2-Tuple of Vectors. y (vertical) error relative to y-value.  If 2-tuple of vectors, the first vector corresponds to the bottom error (and the second to the top)",
+:ribbon                      => "Number or AbstractVector.  Creates a fillrange around the data points.",
+:quiver                      => "AbstractVector or 2-Tuple of vectors.  The directional vectors U,V which specify velocity/gradient vectors for a quiver plot.",
+:arrow                       => "nothing (no arrows), Bool (if true, default arrows), Arrow object, or arg(s) that could be style or head length/widths.  Defines arrowheads that should be displayed at the end of path line segments (just before a NaN and the last non-NaN point).  Used in quiverplot, streamplot, or similar.",
+:normalize                   => "Bool or Symbol. Histogram normalization mode. Possible values are: false/:none (no normalization, default), true/:pdf (normalize to a discrete Probability Density Function, where the total area of the bins is 1), :probability (bin heights sum to 1) and :density (the area of each bin, rather than the height, is equal to the counts - useful for uneven bin sizes).",
+:weights                     => "AbstractVector. Used in histogram types for weighted counts.",
+:show_empty_bins             => "Bool. Whether empty bins in a 2D histogram are colored as 0 (true), or transparent (the default).",
+:contours                    => "Bool. Add contours to the side-grids of 3D plots?  Used in surface/wireframe.",
+:contour_labels              => "Bool. Show labels at the contour lines?",
+:match_dimensions            => "Bool. For heatmap types... should the first dimension of a matrix (rows) correspond to the first dimension of the plot (x-axis)?  The default is false, which matches the behavior of Matplotlib, Plotly, and others.  Note: when passing a function for z, the function should still map `(x,y) -> z`.",
+:subplot                     => "Integer (subplot index) or Subplot object.  The subplot that this series belongs to.",
+:series_annotations          => "AbstractVector of String or PlotText.  These are annotations which are mapped to data points/positions.",
+:primary                     => "Bool.  Does this count as a 'real series'?  For example, you could have a path (primary), and a scatter (secondary) as 2 separate series, maybe with different data (see sticks recipe for an example).  The secondary series will get the same color, etc as the primary.",
+:hover                       => "nothing or vector of strings. Text to display when hovering over each data point.",
+:colorbar_entry              => "Bool.  Include this series in the color bar?  Set to `false` to exclude.",
 
 # plot args
-:plot_title               => "String. Title for the whole plot (not the subplots) (Note: Not currently implemented)",
-:background_color         => "Color Type.  Base color for all backgrounds.",
-:background_color_outside => "Color Type or `:match` (matches `:background_color`).  Color outside the plot area(s)",
-:foreground_color         => "Color Type.  Base color for all foregrounds.",
-:size                     => "NTuple{2,Int}. (width_px, height_px) of the whole Plot",
-:pos                      => "NTuple{2,Int}. (left_px, top_px) position of the GUI window (note: currently unimplemented)",
-:window_title             => "String. Title of the standalone gui-window.",
-:show                     => "Bool.  Should this command open/refresh a GUI/display?  This allows displaying in scripts or functions without explicitly calling `display`",
-:layout                   => "Integer (number of subplots), NTuple{2,Integer} (grid dimensions), AbstractLayout (for example `grid(2,2)`), or the return from the `@layout` macro.  This builds the layout of subplots.",
-:link                     => "Symbol.  How/whether to link axis limits between subplots. Values: `:none`, `:x` (x axes are linked by columns), `:y` (y axes are linked by rows), `:both` (x and y are linked), `:all` (every subplot is linked together regardless of layout position).",
-:overwrite_figure         => "Bool.  Should we reuse the same GUI window/figure when plotting (true) or open a new one (false).",
-:html_output_format       => "Symbol.  When writing html output, what is the format?  `:png` and `:svg` are currently supported.",
-:tex_output_standalone    => "Bool. When writing tex output, should the source include a preamble for a standalone document class.",
-:inset_subplots           => "nothing or vector of 2-tuple (parent,bbox).  optionally pass a vector of (parent,bbox) tuples which are the parent layout and the relative bounding box of inset subplots",
-:dpi 			  => "Number.  Dots Per Inch of output figures",
-:thickness_scaling        => "Number. Scale for the thickness of all line elements like lines, borders, axes, grid lines, ... defaults to 1.",
-:display_type             => "Symbol (`:auto`, `:gui`, or `:inline`).  When supported, `display` will either open a GUI window or plot inline.",
-:extra_kwargs 	          => "Either one of (`:plot`, `:subplot`, `:series`) to specify for which element extra keyword args are collected or a KW (Dict{Symbol,Any}) to pass a map of extra keyword args which may be specific to a backend. Default: `:series`.\n Example: `pgfplotsx(); scatter(1:5, extra_kwargs=Dict(:subplot=>Dict(\"axis line shift\" => \"10pt\"))`",
-:fontfamily               => "String or Symbol.  Default font family for title, legend entries, tick labels and guides",
-:warn_on_unsupported      => "Bool. Warn on unsupported attributes, series types and marker shapes",
+:plot_title                  => "String. Title for the whole plot (not the subplots) (Note: Not currently implemented)",
+:background_color            => "Color Type.  Base color for all backgrounds.",
+:background_color_outside    => "Color Type or `:match` (matches `:background_color`).  Color outside the plot area(s)",
+:foreground_color            => "Color Type.  Base color for all foregrounds.",
+:size                        => "NTuple{2,Int}. (width_px, height_px) of the whole Plot",
+:pos                         => "NTuple{2,Int}. (left_px, top_px) position of the GUI window (note: currently unimplemented)",
+:window_title                => "String. Title of the standalone gui-window.",
+:show                        => "Bool.  Should this command open/refresh a GUI/display?  This allows displaying in scripts or functions without explicitly calling `display`",
+:layout                      => "Integer (number of subplots), NTuple{2,Integer} (grid dimensions), AbstractLayout (for example `grid(2,2)`), or the return from the `@layout` macro.  This builds the layout of subplots.",
+:link                        => "Symbol.  How/whether to link axis limits between subplots. Values: `:none`, `:x` (x axes are linked by columns), `:y` (y axes are linked by rows), `:both` (x and y are linked), `:all` (every subplot is linked together regardless of layout position).",
+:overwrite_figure            => "Bool.  Should we reuse the same GUI window/figure when plotting (true) or open a new one (false).",
+:html_output_format          => "Symbol.  When writing html output, what is the format?  `:png` and `:svg` are currently supported.",
+:tex_output_standalone       => "Bool. When writing tex output, should the source include a preamble for a standalone document class.",
+:inset_subplots              => "nothing or vector of 2-tuple (parent,bbox).  optionally pass a vector of (parent,bbox) tuples which are the parent layout and the relative bounding box of inset subplots",
+:dpi                         => "Number.  Dots Per Inch of output figures",
+:thickness_scaling           => "Number. Scale for the thickness of all line elements like lines, borders, axes, grid lines, ... defaults to 1.",
+:display_type                => "Symbol (`:auto`, `:gui`, or `:inline`).  When supported, `display` will either open a GUI window or plot inline.",
+:extra_kwargs                => "Either one of (`:plot`, `:subplot`, `:series`) to specify for which element extra keyword args are collected or a KW (Dict{Symbol,Any}) to pass a map of extra keyword args which may be specific to a backend. Default: `:series`.\n Example: `pgfplotsx(); scatter(1:5, extra_kwargs=Dict(:subplot=>Dict(\"axis line shift\" => \"10pt\"))`",
+:fontfamily                  => "String or Symbol.  Default font family for title, legend entries, tick labels and guides",
+:warn_on_unsupported         => "Bool. Warn on unsupported attributes, series types and marker shapes",
 
 # subplot args
-:title                    => "String. Subplot title.",
-:titlelocation           => "Symbol. Position of subplot title. Values: `:left`, `:center`, `:right`",
-:titlefontfamily          => "String or Symbol. Font family of subplot title.",
-:titlefontsize            => "Integer. Font pointsize of subplot title.",
-:titlefonthalign          => "Symbol. Font horizontal alignment of subplot title: :hcenter, :left, :right or :center",
-:titlefontvalign          => "Symbol. Font vertical alignment of subplot title: :vcenter, :top, :bottom or :center",
-:titlefontrotation        => "Real. Font rotation of subplot title",
-:titlefontcolor           => "Color Type. Font color of subplot title",
-:background_color_subplot => "Color Type or `:match` (matches `:background_color`).  Base background color of the subplot.",
-:background_color_legend  => "Color Type or `:match` (matches `:background_color_subplot`).  Background color of the legend.",
-:background_color_inside  => "Color Type or `:match` (matches `:background_color_subplot`).  Background color inside the plot area (under the grid).",
-:foreground_color_subplot => "Color Type or `:match` (matches `:foreground_color`).  Base foreground color of the subplot.",
-:foreground_color_legend  => "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). 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)",
-:legendfontfamily         => "String or Symbol. Font family of legend entries.",
-:legendfontsize           => "Integer. Font pointsize of legend entries.",
-:legendfonthalign         => "Symbol. Font horizontal alignment of legend entries: :hcenter, :left, :right or :center",
-:legendfontvalign         => "Symbol. Font vertical alignment of legend entries: :vcenter, :top, :bottom or :center",
-:legendfontrotation       => "Real. Font rotation of legend entries",
-:legendfontcolor          => "Color Type. Font color of legend entries",
-:legendtitle              => "String. Legend title.",
-:legendtitlefontfamily    => "String or Symbol. Font family of the legend title.",
-:legendtitlefontsize           => "Integer. Font pointsize the legend title.",
-:legendtitlefonthalign         => "Symbol. Font horizontal alignment of the legend title: :hcenter, :left, :right or :center",
-:legendtitlefontvalign         => "Symbol. Font vertical alignment of the legend title: :vcenter, :top, :bottom or :center",
-:legendtitlefontrotation       => "Real. Font rotation of the legend title",
-:legendtitlefontcolor          => "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.",
-:legendfont               => "Font. Font of legend items.",
-:legendtitlefont          => "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 or PlotText (created with `text(args...)`)  Add one-off text annotations at the x,y coordinates.",
-: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.",
-:left_margin              => "Measure (multiply by `mm`, `px`, etc) or `:match` (matches `:margin`).  Specifies the extra padding to the left of the subplot.",
-:top_margin               => "Measure (multiply by `mm`, `px`, etc) or `:match` (matches `:margin`).  Specifies the extra padding on the top of the subplot.",
-:right_margin             => "Measure (multiply by `mm`, `px`, etc) or `:match` (matches `:margin`).  Specifies the extra padding to the right of the subplot.",
-:bottom_margin            => "Measure (multiply by `mm`, `px`, etc) or `:match` (matches `:margin`).  Specifies the extra padding on the bottom of the subplot.",
-:subplot_index            => "Integer.  Internal (not set by user).  Specifies the index of this subplot in the Plot's `plt.subplot` list.",
-:colorbar_title           => "String.  Title of colorbar.",
-:framestyle               => "Symbol.  Style of the axes frame. Choose from $(_allFramestyles)",
-:camera                   => "NTuple{2, Real}. Sets the view angle (azimuthal, elevation) for 3D plots",
+:title                       => "String. Subplot title.",
+:titlelocation               => "Symbol. Position of subplot title. Values: `:left`, `:center`, `:right`",
+:titlefontfamily             => "String or Symbol. Font family of subplot title.",
+:titlefontsize               => "Integer. Font pointsize of subplot title.",
+:titlefonthalign             => "Symbol. Font horizontal alignment of subplot title: :hcenter, :left, :right or :center",
+:titlefontvalign             => "Symbol. Font vertical alignment of subplot title: :vcenter, :top, :bottom or :center",
+:titlefontrotation           => "Real. Font rotation of subplot title",
+:titlefontcolor              => "Color Type. Font color of subplot title",
+:background_color_subplot    => "Color Type or `:match` (matches `:background_color`).  Base background color of the subplot.",
+:background_color_legend     => "Color Type or `:match` (matches `:background_color_subplot`).  Background color of the legend.",
+:background_color_inside     => "Color Type or `:match` (matches `:background_color_subplot`).  Background color inside the plot area (under the grid).",
+:foreground_color_subplot    => "Color Type or `:match` (matches `:foreground_color`).  Base foreground color of the subplot.",
+:foreground_color_legend     => "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 is positioned at (angle degrees) (so (90,:outer) is roughly equivalent to :outertop), close to the inside of the axes or the outside if inout=:outer.",
+:legendfontfamily            => "String or Symbol. Font family of legend entries.",
+:legendfontsize              => "Integer. Font pointsize of legend entries.",
+:legendfonthalign            => "Symbol. Font horizontal alignment of legend entries: :hcenter, :left, :right or :center",
+:legendfontvalign            => "Symbol. Font vertical alignment of legend entries: :vcenter, :top, :bottom or :center",
+:legendfontrotation          => "Real. Font rotation of legend entries",
+:legendfontcolor             => "Color Type. Font color of legend entries",
+:legendtitle                 => "String. Legend title.",
+:legendtitlefontfamily       => "String or Symbol. Font family of the legend title.",
+:legendtitlefontsize         => "Integer. Font pointsize the legend title.",
+:legendtitlefonthalign       => "Symbol. Font horizontal alignment of the legend title: :hcenter, :left, :right or :center",
+:legendtitlefontvalign       => "Symbol. Font vertical alignment of the legend title: :vcenter, :top, :bottom or :center",
+:legendtitlefontrotation     => "Real. Font rotation of the legend title",
+:legendtitlefontcolor        => "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.",
+:legendfont                  => "Font. Font of legend items.",
+:legendtitlefont             => "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 or PlotText (created with `text(args...)`)  Add one-off text annotations at the x,y coordinates.",
+: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.",
+:left_margin                 => "Measure (multiply by `mm`, `px`, etc) or `:match` (matches `:margin`).  Specifies the extra padding to the left of the subplot.",
+:top_margin                  => "Measure (multiply by `mm`, `px`, etc) or `:match` (matches `:margin`).  Specifies the extra padding on the top of the subplot.",
+:right_margin                => "Measure (multiply by `mm`, `px`, etc) or `:match` (matches `:margin`).  Specifies the extra padding to the right of the subplot.",
+:bottom_margin               => "Measure (multiply by `mm`, `px`, etc) or `:match` (matches `:margin`).  Specifies the extra padding on the bottom of the subplot.",
+:subplot_index               => "Integer.  Internal (not set by user).  Specifies the index of this subplot in the Plot's `plt.subplot` list.",
+:colorbar_title              => "String.  Title of colorbar.",
+:framestyle                  => "Symbol.  Style of the axes frame. Choose from $(_allFramestyles)",
+:camera                      => "NTuple{2, Real}. Sets the view angle (azimuthal, elevation) for 3D plots",
 
 # axis args
-:guide     		  => "String. Axis guide (label).",
-:guide_position		  => "Symbol. Position of axis guides: :top, :bottom, :left or :right",
-:lims      		  => "NTuple{2,Number} or Symbol. Force axis limits.  Only finite values are used (you can set only the right limit with `xlims = (-Inf, 2)` for example). `:round` widens the limit to the nearest round number ie. [0.1,3.6]=>[0.0,4.0]",
-:ticks     		  => "Vector of numbers (set the tick values), Tuple of (tickvalues, ticklabels), or `:auto`",
-:scale     		  => "Symbol. Scale of the axis: `:none`, `:ln`, `:log2`, `:log10`",
-:rotation  		  => "Number. Degrees rotation of tick labels.",
-:flip      		  => "Bool.  Should we flip (reverse) the axis?",
-:formatter                => "Function, :scientific, :plain or :auto. A method which converts a number to a string for tick labeling.",
-:tickfontfamily           => "String or Symbol. Font family of tick labels.",
-:tickfontsize             => "Integer. Font pointsize of tick labels.",
-:tickfonthalign           => "Symbol. Font horizontal alignment of tick labels: :hcenter, :left, :right or :center",
-:tickfontvalign           => "Symbol. Font vertical alignment of tick labels: :vcenter, :top, :bottom or :center",
-:tickfontrotation         => "Real. Font rotation of tick labels",
-:tickfontcolor            => "Color Type. Font color of tick labels",
-:guidefontfamily          => "String or Symbol. Font family of axes guides.",
-:guidefontsize            => "Integer. Font pointsize of axes guides.",
-:guidefonthalign          => "Symbol. Font horizontal alignment of axes guides: :hcenter, :left, :right or :center",
-:guidefontvalign          => "Symbol. Font vertical alignment of axes guides: :vcenter, :top, :bottom or :center",
-:guidefontrotation        => "Real. Font rotation of axes guides",
-:guidefontcolor           => "Color Type. Font color of axes guides",
-:foreground_color_axis    => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of axis ticks.",
-:foreground_color_border  => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of plot area border (spines).",
-:foreground_color_text    => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of tick labels.",
-:foreground_color_guide   => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of axis guides (axis labels).",
-:mirror                   => "Bool.  Switch the side of the tick labels (right or top).",
-:grid                     => "Bool, Symbol, String or `nothing`. Show the grid lines? `true`, `false`, `:show`, `:hide`, `:yes`, `:no`, `:x`, `:y`, `:z`, `:xy`, ..., `:all`, `:none`, `:off`",
-:foreground_color_grid    => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of grid lines.",
-:gridalpha                => "Number in [0,1]. The alpha/opacity override for the grid lines.",
-:gridstyle                => "Symbol. Style of the grid lines. Choose from $(_allStyles)",
-:gridlinewidth            => "Number. Width of the grid lines (in pixels)",
+:guide                       => "String. Axis guide (label).",
+:guide_position              => "Symbol. Position of axis guides: :top, :bottom, :left or :right",
+:lims                        => "NTuple{2,Number} or Symbol. Force axis limits.  Only finite values are used (you can set only the right limit with `xlims = (-Inf, 2)` for example). `:round` widens the limit to the nearest round number ie. [0.1,3.6]=>[0.0,4.0]",
+:ticks                       => "Vector of numbers (set the tick values), Tuple of (tickvalues, ticklabels), or `:auto`",
+:scale                       => "Symbol. Scale of the axis: `:none`, `:ln`, `:log2`, `:log10`",
+:rotation                    => "Number. Degrees rotation of tick labels.",
+:flip                        => "Bool.  Should we flip (reverse) the axis?",
+:formatter                   => "Function, :scientific, :plain or :auto. A method which converts a number to a string for tick labeling.",
+:tickfontfamily              => "String or Symbol. Font family of tick labels.",
+:tickfontsize                => "Integer. Font pointsize of tick labels.",
+:tickfonthalign              => "Symbol. Font horizontal alignment of tick labels: :hcenter, :left, :right or :center",
+:tickfontvalign              => "Symbol. Font vertical alignment of tick labels: :vcenter, :top, :bottom or :center",
+:tickfontrotation            => "Real. Font rotation of tick labels",
+:tickfontcolor               => "Color Type. Font color of tick labels",
+:guidefontfamily             => "String or Symbol. Font family of axes guides.",
+:guidefontsize               => "Integer. Font pointsize of axes guides.",
+:guidefonthalign             => "Symbol. Font horizontal alignment of axes guides: :hcenter, :left, :right or :center",
+:guidefontvalign             => "Symbol. Font vertical alignment of axes guides: :vcenter, :top, :bottom or :center",
+:guidefontrotation           => "Real. Font rotation of axes guides",
+:guidefontcolor              => "Color Type. Font color of axes guides",
+:foreground_color_axis       => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of axis ticks.",
+:foreground_color_border     => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of plot area border (spines).",
+:foreground_color_text       => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of tick labels.",
+:foreground_color_guide      => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of axis guides (axis labels).",
+:mirror                      => "Bool.  Switch the side of the tick labels (right or top).",
+:grid                        => "Bool, Symbol, String or `nothing`. Show the grid lines? `true`, `false`, `:show`, `:hide`, `:yes`, `:no`, `:x`, `:y`, `:z`, `:xy`, ..., `:all`, `:none`, `:off`",
+:foreground_color_grid       => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of grid lines.",
+:gridalpha                   => "Number in [0,1]. The alpha/opacity override for the grid lines.",
+:gridstyle                   => "Symbol. Style of the grid lines. Choose from $(_allStyles)",
+:gridlinewidth               => "Number. Width of the grid lines (in pixels)",
 :foreground_color_minor_grid => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of minor grid lines.",
-:minorgrid                => "Bool. Adds minor grid lines and ticks to the plot. Set minorticks to change number of gridlines",
-:minorticks               => "Integer. Intervals to divide the gap between major ticks into",
-:minorgridalpha           => "Number in [0,1]. The alpha/opacity override for the minorgrid lines.",
-:minorgridstyle           => "Symbol. Style of the minor grid lines. Choose from $(_allStyles)",
-:minorgridlinewidth       => "Number. Width of the minor grid lines (in pixels)",
-:tick_direction           => "Symbol.  Direction of the ticks. `:in` or `:out`",
-:showaxis                 => "Bool, Symbol or String.  Show the axis. `true`, `false`, `:show`, `:hide`, `:yes`, `:no`, `:x`, `:y`, `:z`, `:xy`, ..., `:all`, `:off`",
-:widen                    => "Bool. Widen the axis limits by a small factor to avoid cut-off markers and lines at the borders. Defaults to `true`.",
-:draw_arrow               => "Bool. Draw arrow at the end of the axis.",
+:minorgrid                   => "Bool. Adds minor grid lines and ticks to the plot. Set minorticks to change number of gridlines",
+:minorticks                  => "Integer. Intervals to divide the gap between major ticks into",
+:minorgridalpha              => "Number in [0,1]. The alpha/opacity override for the minorgrid lines.",
+:minorgridstyle              => "Symbol. Style of the minor grid lines. Choose from $(_allStyles)",
+:minorgridlinewidth          => "Number. Width of the minor grid lines (in pixels)",
+:tick_direction              => "Symbol.  Direction of the ticks. `:in` or `:out`",
+:showaxis                    => "Bool, Symbol or String.  Show the axis. `true`, `false`, `:show`, `:hide`, `:yes`, `:no`, `:x`, `:y`, `:z`, `:xy`, ..., `:all`, `:off`",
+:widen                       => "Bool. Widen the axis limits by a small factor to avoid cut-off markers and lines at the borders. Defaults to `true`.",
+:draw_arrow                  => "Bool. Draw arrow at the end of the axis.",
 )

src/args.jl

@@ -54,7 +54,7 @@ const _3dTypes = [
     :path3d, :scatter3d, :surface, :wireframe, :contour3d, :volume, :mesh3d
 ]
 const _allTypes = vcat([
-    :none, :line, :path, :steppre, :steppost, :sticks, :scatter,
+    :none, :line, :path, :steppre, :stepmid, :steppost, :sticks, :scatter,
     :heatmap, :hexbin, :barbins, :barhist, :histogram, :scatterbins,
     :scatterhist, :stepbins, :stephist, :bins2d, :histogram2d, :histogram3d,
     :density, :bar, :hline, :vline,
@@ -101,7 +101,7 @@ const _typeAliases = Dict{Symbol,Symbol}(
 add_non_underscore_aliases!(_typeAliases)
 
 const _histogram_like = [:histogram, :barhist, :barbins]
-const _line_like = [:line, :path, :steppre, :steppost]
+const _line_like = [:line, :path, :steppre, :stepmid, :steppost]
 const _surface_like = [:contour, :contourf, :contour3d, :heatmap, :surface, :wireframe, :image]
 
 like_histogram(seriestype::Symbol) = seriestype in _histogram_like
@@ -151,54 +151,54 @@ const _shape_keys = Symbol[
 
 const _allMarkers = vcat(:none, :auto, _shape_keys) #sort(collect(keys(_shapes))))
 const _markerAliases = Dict{Symbol,Symbol}(
-    :n            => :none,
-    :no           => :none,
-    :a            => :auto,
-    :ellipse      => :circle,
-    :c            => :circle,
-    :circ         => :circle,
-    :square       => :rect,
-    :sq           => :rect,
-    :r            => :rect,
-    :d            => :diamond,
-    :^            => :utriangle,
-    :ut           => :utriangle,
-    :utri         => :utriangle,
-    :uptri        => :utriangle,
-    :uptriangle   => :utriangle,
-    :v            => :dtriangle,
-    :V            => :dtriangle,
-    :dt           => :dtriangle,
-    :dtri         => :dtriangle,
-    :downtri      => :dtriangle,
-    :downtriangle => :dtriangle,
-    :>            => :rtriangle,
-    :rt           => :rtriangle,
-    :rtri         => :rtriangle,
+    :n             => :none,
+    :no            => :none,
+    :a             => :auto,
+    :ellipse       => :circle,
+    :c             => :circle,
+    :circ          => :circle,
+    :square        => :rect,
+    :sq            => :rect,
+    :r             => :rect,
+    :d             => :diamond,
+    :^             => :utriangle,
+    :ut            => :utriangle,
+    :utri          => :utriangle,
+    :uptri         => :utriangle,
+    :uptriangle    => :utriangle,
+    :v             => :dtriangle,
+    :V             => :dtriangle,
+    :dt            => :dtriangle,
+    :dtri          => :dtriangle,
+    :downtri       => :dtriangle,
+    :downtriangle  => :dtriangle,
+    :>             => :rtriangle,
+    :rt            => :rtriangle,
+    :rtri          => :rtriangle,
     :righttri      => :rtriangle,
     :righttriangle => :rtriangle,
-    :<            => :ltriangle,
-    :lt           => :ltriangle,
-    :ltri         => :ltriangle,
+    :<             => :ltriangle,
+    :lt            => :ltriangle,
+    :ltri          => :ltriangle,
     :lighttri      => :ltriangle,
     :lighttriangle => :ltriangle,
-    # :+            => :cross,
-    :plus         => :cross,
-    # :x            => :xcross,
-    :X            => :xcross,
-    :star         => :star5,
-    :s            => :star5,
-    :star1        => :star5,
-    :s2           => :star8,
-    :star2        => :star8,
-    :p            => :pentagon,
-    :pent         => :pentagon,
-    :h            => :hexagon,
-    :hex          => :hexagon,
-    :hep          => :heptagon,
-    :o            => :octagon,
-    :oct          => :octagon,
-    :spike        => :vline,
+    # :+           => :cross,
+    :plus          => :cross,
+    # :x           => :xcross,
+    :X             => :xcross,
+    :star          => :star5,
+    :s             => :star5,
+    :star1         => :star5,
+    :s2            => :star8,
+    :star2         => :star8,
+    :p             => :pentagon,
+    :pent          => :pentagon,
+    :h             => :hexagon,
+    :hex           => :hexagon,
+    :hep           => :heptagon,
+    :o             => :octagon,
+    :oct           => :octagon,
+    :spike         => :vline,
 )
 
 const _positionAliases = Dict{Symbol,Symbol}(
@@ -273,58 +273,58 @@ const _bar_width = 0.8
 # -----------------------------------------------------------------------------
 
 const _series_defaults = KW(
-    :label             => :auto,
-    :colorbar_entry    => true,
-    :seriescolor       => :auto,
-    :seriesalpha       => nothing,
-    :seriestype        => :path,
-    :linestyle         => :solid,
-    :linewidth         => :auto,
-    :linecolor         => :auto,
-    :linealpha         => nothing,
-    :fillrange         => nothing,   # ribbons, areas, etc
-    :fillcolor         => :match,
-    :fillalpha         => nothing,
-    :markershape       => :none,
-    :markercolor       => :match,
-    :markeralpha       => nothing,
-    :markersize        => 4,
-    :markerstrokestyle => :solid,
-    :markerstrokewidth => 1,
-    :markerstrokecolor => :match,
-    :markerstrokealpha => nothing,
-    :bins              => :auto,        # number of bins for hists
-    :smooth            => false,     # regression line?
-    :group             => nothing,   # groupby vector
-    :x                 => nothing,
-    :y                 => nothing,
-    :z                 => nothing,   # depth for contour, surface, etc
-    :marker_z          => nothing,   # value for color scale
-    :line_z            => nothing,
-    :fill_z            => nothing,
-    :levels            => 15,
-    :orientation       => :vertical,
-    :bar_position      => :overlay,  # for bar plots and histograms: could also be stack (stack up) or dodge (side by side)
-    :bar_width         => nothing,
-    :bar_edges         => false,
-    :xerror            => nothing,
-    :yerror            => nothing,
-    :zerror            => nothing,
-    :ribbon            => nothing,
-    :quiver            => nothing,
-    :arrow             => nothing,   # allows for adding arrows to line/path... call `arrow(args...)`
-    :normalize         => false,     # do we want a normalized histogram?
-    :weights           => nothing,   # optional weights for histograms (1D and 2D)
-    :show_empty_bins   => false,     # should empty bins in 2D histogram be colored as zero (otherwise they are transparent)
-    :contours          => false,     # add contours to 3d surface and wireframe plots
-    :contour_labels    => false,
-    :subplot           => :auto,     # which subplot(s) does this series belong to?
+    :label              => :auto,
+    :colorbar_entry     => true,
+    :seriescolor        => :auto,
+    :seriesalpha        => nothing,
+    :seriestype         => :path,
+    :linestyle          => :solid,
+    :linewidth          => :auto,
+    :linecolor          => :auto,
+    :linealpha          => nothing,
+    :fillrange          => nothing,   # ribbons, areas, etc
+    :fillcolor          => :match,
+    :fillalpha          => nothing,
+    :markershape        => :none,
+    :markercolor        => :match,
+    :markeralpha        => nothing,
+    :markersize         => 4,
+    :markerstrokestyle  => :solid,
+    :markerstrokewidth  => 1,
+    :markerstrokecolor  => :match,
+    :markerstrokealpha  => nothing,
+    :bins               => :auto,        # number of bins for hists
+    :smooth             => false,     # regression line?
+    :group              => nothing,   # groupby vector
+    :x                  => nothing,
+    :y                  => nothing,
+    :z                  => nothing,   # depth for contour, surface, etc
+    :marker_z           => nothing,   # value for color scale
+    :line_z             => nothing,
+    :fill_z             => nothing,
+    :levels             => 15,
+    :orientation        => :vertical,
+    :bar_position       => :overlay,  # for bar plots and histograms: could also be stack (stack up) or dodge (side by side)
+    :bar_width          => nothing,
+    :bar_edges          => false,
+    :xerror             => nothing,
+    :yerror             => nothing,
+    :zerror             => nothing,
+    :ribbon             => nothing,
+    :quiver             => nothing,
+    :arrow              => nothing,   # allows for adding arrows to line/path... call `arrow(args...)`
+    :normalize          => false,     # do we want a normalized histogram?
+    :weights            => nothing,   # optional weights for histograms (1D and 2D)
+    :show_empty_bins    => false,     # should empty bins in 2D histogram be colored as zero (otherwise they are transparent)
+    :contours           => false,     # add contours to 3d surface and wireframe plots
+    :contour_labels     => false,
+    :subplot            => :auto,     # which subplot(s) does this series belong to?
     :series_annotations => nothing,       # a list of annotations which apply to the coordinates of this series
     :primary            => true,     # when true, this "counts" as a series for color selection, etc.  the main use is to allow
                                      #     one logical series to be broken up (path and markers, for example)
     :hover              => nothing,  # text to display when hovering over the data points
     :stride             => (1,1),    # array stride for wireframe/surface, the first element is the row stride and the second is the column stride.
-    :connections	  => nothing,  # tuple of arrays to specifiy connectivity of a 3d mesh
+    :connections        => nothing,  # tuple of arrays to specifiy connectivity of a 3d mesh
     :extra_kwargs       => Dict()
 )
 
@@ -363,104 +363,115 @@ const _plot_defaults = KW(
 
 
 const _subplot_defaults = KW(
-    :title                    => "",
-    :titlelocation            => :center,           # also :left or :right
-    :fontfamily_subplot       => :match,
-    :titlefontfamily          => :match,
-    :titlefontsize            => 14,
-    :titlefonthalign          => :hcenter,
-    :titlefontvalign          => :vcenter,
-    :titlefontrotation        => 0.0,
-    :titlefontcolor           => :match,
-    :background_color_subplot => :match,            # default for other bg colors... match takes plot default
-    :background_color_legend  => :match,            # background of legend
-    :background_color_inside  => :match,            # background inside grid
-    :foreground_color_subplot => :match,            # default for other fg colors... match takes plot default
-    :foreground_color_legend  => :match,            # foreground of legend
-    :foreground_color_title   => :match,            # title color
-    :color_palette            => :auto,
-    :legend                   => :best,
-    :legendtitle              => nothing,
-    :colorbar                 => :legend,
-    :clims                    => :auto,
-    :legendfontfamily         => :match,
-    :legendfontsize           => 8,
-    :legendfonthalign         => :hcenter,
-    :legendfontvalign         => :vcenter,
-    :legendfontrotation       => 0.0,
-    :legendfontcolor          => :match,
-    :legendtitlefontfamily    => :match,
-    :legendtitlefontsize      => 11,
-    :legendtitlefonthalign    => :hcenter,
-    :legendtitlefontvalign    => :vcenter,
-    :legendtitlefontrotation  => 0.0,
-    :legendtitlefontcolor     => :match,
-    :annotations              => [],                # annotation tuples... list of (x,y,annotation)
-    :projection               => :none,             # can also be :polar or :3d
-    :aspect_ratio             => :auto,             # choose from :none or :equal
-    :margin                   => 1mm,
-    :left_margin              => :match,
-    :top_margin               => :match,
-    :right_margin             => :match,
-    :bottom_margin            => :match,
-    :subplot_index            => -1,
-    :colorbar_title                  => "",
-    :colorbar_titlefontsize          => 10,
-    :colorbar_title_location         => :center,           # also :left or :right
-    :colorbar_fontfamily             => :match,
-    :colorbar_titlefontfamily        => :match,
-    :colorbar_titlefonthalign        => :hcenter,
-    :colorbar_titlefontvalign        => :vcenter,
-    :colorbar_titlefontrotation      => 0.0,
-    :colorbar_titlefontcolor         => :match,
-    :framestyle                      => :axes,
-    :camera                          => (30,30),
-    :extra_kwargs                    => Dict()
+    :title                      => "",
+    :titlelocation              => :center,           # also :left or :right
+    :fontfamily_subplot         => :match,
+    :titlefontfamily            => :match,
+    :titlefontsize              => 14,
+    :titlefonthalign            => :hcenter,
+    :titlefontvalign            => :vcenter,
+    :titlefontrotation          => 0.0,
+    :titlefontcolor             => :match,
+    :background_color_subplot   => :match,            # default for other bg colors... match takes plot default
+    :background_color_legend    => :match,            # background of legend
+    :background_color_inside    => :match,            # background inside grid
+    :foreground_color_subplot   => :match,            # default for other fg colors... match takes plot default
+    :foreground_color_legend    => :match,            # foreground of legend
+    :foreground_color_title     => :match,            # title color
+    :color_palette              => :auto,
+    :legend                     => :best,
+    :legendtitle                => nothing,
+    :colorbar                   => :legend,
+    :clims                      => :auto,
+    :colorbar_fontfamily        => :match,
+    :colorbar_ticks             => :auto,
+    :colorbar_tickfontfamily    => :match,
+    :colorbar_tickfontsize      => 8,
+    :colorbar_tickfonthalign    => :hcenter,
+    :colorbar_tickfontvalign    => :vcenter,
+    :colorbar_tickfontrotation  => 0.0,
+    :colorbar_tickfontcolor     => :match,
+    :colorbar_scale             => :identity,
+    :colorbar_formatter         => :auto,
+    :colorbar_discrete_values   => [],
+    :colorbar_continuous_values   => zeros(0),
+    :legendfontfamily           => :match,
+    :legendfontsize             => 8,
+    :legendfonthalign           => :hcenter,
+    :legendfontvalign           => :vcenter,
+    :legendfontrotation         => 0.0,
+    :legendfontcolor            => :match,
+    :legendtitlefontfamily      => :match,
+    :legendtitlefontsize        => 11,
+    :legendtitlefonthalign      => :hcenter,
+    :legendtitlefontvalign      => :vcenter,
+    :legendtitlefontrotation    => 0.0,
+    :legendtitlefontcolor       => :match,
+    :annotations                => [],                # annotation tuples... list of (x,y,annotation)
+    :projection                 => :none,             # can also be :polar or :3d
+    :aspect_ratio               => :auto,             # choose from :none or :equal
+    :margin                     => 1mm,
+    :left_margin                => :match,
+    :top_margin                 => :match,
+    :right_margin               => :match,
+    :bottom_margin              => :match,
+    :subplot_index              => -1,
+    :colorbar_title             => "",
+    :colorbar_titlefontsize     => 10,
+    :colorbar_title_location    => :center,           # also :left or :right
+    :colorbar_titlefontfamily   => :match,
+    :colorbar_titlefonthalign   => :hcenter,
+    :colorbar_titlefontvalign   => :vcenter,
+    :colorbar_titlefontrotation => 0.0,
+    :colorbar_titlefontcolor    => :match,
+    :framestyle                 => :axes,
+    :camera                     => (30,30),
+    :extra_kwargs               => Dict()
 )
 
 const _axis_defaults = KW(
-    :guide     => "",
-    :guide_position => :auto,
-    :lims      => :auto,
-    :ticks     => :auto,
-    :scale     => :identity,
-    :rotation  => 0,
-    :flip      => false,
-    :link      => [],
-    :tickfontfamily         => :match,
-    :tickfontsize           => 8,
-    :tickfonthalign         => :hcenter,
-    :tickfontvalign         => :vcenter,
-    :tickfontrotation       => 0.0,
-    :tickfontcolor          => :match,
-    :guidefontfamily         => :match,
-    :guidefontsize           => 11,
-    :guidefonthalign         => :hcenter,
-    :guidefontvalign         => :vcenter,
-    :guidefontrotation       => 0.0,
-    :guidefontcolor          => :match,
-    :foreground_color_axis   => :match,            # axis border/tick colors,
-    :foreground_color_border => :match,            # plot area border/spines,
-    :foreground_color_text   => :match,            # tick text color,
-    :foreground_color_guide  => :match,            # guide text color,
-    :discrete_values => [],
-    :formatter => :auto,
-    :mirror => false,
-    :grid                     => true,
-    :foreground_color_grid    => :match,            # grid color
-    :gridalpha                => 0.1,
-    :gridstyle                => :solid,
-    :gridlinewidth            => 0.5,
+    :guide                       => "",
+    :guide_position              => :auto,
+    :lims                        => :auto,
+    :ticks                       => :auto,
+    :scale                       => :identity,
+    :rotation                    => 0,
+    :flip                        => false,
+    :link                        => [],
+    :tickfontfamily              => :match,
+    :tickfontsize                => 8,
+    :tickfonthalign              => :hcenter,
+    :tickfontvalign              => :vcenter,
+    :tickfontrotation            => 0.0,
+    :tickfontcolor               => :match,
+    :guidefontfamily             => :match,
+    :guidefontsize               => 11,
+    :guidefonthalign             => :hcenter,
+    :guidefontvalign             => :vcenter,
+    :guidefontrotation           => 0.0,
+    :guidefontcolor              => :match,
+    :foreground_color_axis       => :match,            # axis border/tick colors,
+    :foreground_color_border     => :match,            # plot area border/spines,
+    :foreground_color_text       => :match,            # tick text color,
+    :foreground_color_guide      => :match,            # guide text color,
+    :discrete_values             => [],
+    :formatter                   => :auto,
+    :mirror                      => false,
+    :grid                        => true,
+    :foreground_color_grid       => :match,            # grid color
+    :gridalpha                   => 0.1,
+    :gridstyle                   => :solid,
+    :gridlinewidth               => 0.5,
     :foreground_color_minor_grid => :match,            # grid color
-    :minorgridalpha           => 0.05,
-    :minorgridstyle           => :solid,
-    :minorgridlinewidth       => 0.5,
-    :tick_direction           => :in,
-    :minorticks               => false,
-    :minorgrid                => false,
-    :showaxis                 => true,
-    :widen                    => true,
-    :draw_arrow               => false,
+    :minorgridalpha              => 0.05,
+    :minorgridstyle              => :solid,
+    :minorgridlinewidth          => 0.5,
+    :tick_direction              => :in,
+    :minorticks                  => false,
+    :minorgrid                   => false,
+    :showaxis                    => true,
+    :widen                       => true,
+    :draw_arrow                  => false,
 )
 
 const _suppress_warnings = Set{Symbol}([
@@ -1262,6 +1273,8 @@ end
 convertLegendValue(val::Bool) = val ? :best : :none
 convertLegendValue(val::Nothing) = :none
 convertLegendValue(v::Tuple{S,T}) where {S<:Real, T<:Real} = v
+convertLegendValue(v::Tuple{<:Real,Symbol}) = v
+convertLegendValue(v::Real) = v
 convertLegendValue(v::AbstractArray) = map(convertLegendValue, v)
 
 # -----------------------------------------------------------------------------
@@ -1327,10 +1340,10 @@ const _match_map = KW(
     :background_color_inside  => :background_color_subplot,
     :foreground_color_legend  => :foreground_color_subplot,
     :foreground_color_title   => :foreground_color_subplot,
-    :left_margin   => :margin,
-    :top_margin    => :margin,
-    :right_margin  => :margin,
-    :bottom_margin => :margin,
+    :left_margin              => :margin,
+    :top_margin               => :margin,
+    :right_margin             => :margin,
+    :bottom_margin            => :margin,
     :titlefontfamily          => :fontfamily_subplot,
     :titlefontcolor           => :foreground_color_subplot,
     :legendfontfamily         => :fontfamily_subplot,
@@ -1340,6 +1353,8 @@ const _match_map = KW(
     :colorbar_fontfamily      => :fontfamily_subplot,
     :colorbar_titlefontfamily => :fontfamily_subplot,
     :colorbar_titlefontcolor  => :foreground_color_subplot,
+    :colorbar_tickfontfamily  => :fontfamily_subplot,
+    :colorbar_tickfontcolor   => :foreground_color_subplot,
     :plot_titlefontfamily     => :fontfamily,
     :plot_titlefontcolor      => :foreground_color,
     :tickfontcolor            => :foreground_color_text,
@@ -1578,6 +1593,7 @@ function _update_subplot_args(plt::Plot, sp::Subplot, plotattributes_in, subplot
             lims_warned = true
         end
     end
+    _update_subplot_colorbars(sp)
 end
 
 # -----------------------------------------------------------------------------

src/axes.jl

@@ -137,11 +137,10 @@ const _label_func_tex = Dict{Symbol,Function}(
 labelfunc_tex(scale::Symbol) = get(_label_func_tex, scale, convert_sci_unicode)
 
 
-function optimal_ticks_and_labels(sp::Subplot, axis::Axis, ticks = nothing)
-    amin, amax = axis_limits(sp, axis[:letter])
+function optimal_ticks_and_labels(ticks, alims, scale, formatter)
+    amin, amax = alims
 
     # scale the limits
-    scale = axis[:scale]
     sf = RecipesPipeline.scale_func(scale)
 
     # If the axis input was a Date or DateTime use a special logic to find
@@ -152,7 +151,7 @@ function optimal_ticks_and_labels(sp::Subplot, axis::Axis, ticks = nothing)
     # rather than on the input format
     # TODO: maybe: non-trivial scale (:ln, :log2, :log10) for date/datetime
     if ticks === nothing && scale == :identity
-        if axis[:formatter] == RecipesPipeline.dateformatter
+        if formatter == RecipesPipeline.dateformatter
             # optimize_datetime_ticks returns ticks and labels(!) based on
             # integers/floats corresponding to the DateTime type. Thus, the axes
             # limits, which resulted from converting the Date type to integers,
@@ -163,7 +162,7 @@ function optimal_ticks_and_labels(sp::Subplot, axis::Axis, ticks = nothing)
                 k_min = 2, k_max = 4)
             # Now the ticks are converted back to floats corresponding to Dates.
             return ticks / 864e5, labels
-        elseif axis[:formatter] == RecipesPipeline.datetimeformatter
+        elseif formatter == RecipesPipeline.datetimeformatter
             return optimize_datetime_ticks(amin, amax; k_min = 2, k_max = 4)
         end
     end
@@ -187,14 +186,13 @@ function optimal_ticks_and_labels(sp::Subplot, axis::Axis, ticks = nothing)
             # chosen  ticks is not too much bigger than amin - amax:
             strict_span = false,
         )
-        axis[:lims] = map(RecipesPipeline.inverse_scale_func(scale), (viewmin, viewmax))
+        # axis[:lims] = map(RecipesPipeline.inverse_scale_func(scale), (viewmin, viewmax))
     else
         scaled_ticks = map(sf, (filter(t -> amin <= t <= amax, ticks)))
     end
     unscaled_ticks = map(RecipesPipeline.inverse_scale_func(scale), scaled_ticks)
 
     labels = if any(isfinite, unscaled_ticks)
-        formatter = axis[:formatter]
         if formatter in (:auto, :plain, :scientific, :engineering)
             map(labelfunc(scale, backend()), Showoff.showoff(scaled_ticks, formatter))
         elseif formatter == :latex
@@ -221,52 +219,113 @@ end
 # return (continuous_values, discrete_values) for the ticks on this axis
 function get_ticks(sp::Subplot, axis::Axis; update = true)
     if update || !haskey(axis.plotattributes, :optimized_ticks)
+        dvals = axis[:discrete_values]
         ticks = _transform_ticks(axis[:ticks])
-        if ticks in (:none, nothing, false)
-            axis.plotattributes[:optimized_ticks] = nothing
+        axis.plotattributes[:optimized_ticks] = if ticks isa Symbol && ticks !== :none &&
+            ispolar(sp) && axis[:letter] === :x && !isempty(dvals)
+            collect(0:pi/4:7pi/4), string.(0:45:315)
         else
-            # treat :native ticks as :auto
-            ticks = ticks == :native ? :auto : ticks
-
-            dvals = axis[:discrete_values]
-            cv, dv = if typeof(ticks) <: Symbol
-                if !isempty(dvals)
-                    # discrete ticks...
-                    n = length(dvals)
-                    rng = if ticks == :auto && n > 15
-                        Δ = ceil(Int, n / 10)
-                        Δ:Δ:n
-                    else # if ticks == :all
-                        1:n
-                    end
-                    axis[:continuous_values][rng], dvals[rng]
-                elseif ispolar(axis.sps[1]) && axis[:letter] == :x
-                    #force theta axis to be full circle
-                    (collect(0:pi/4:7pi/4), string.(0:45:315))
-                else
-                    # compute optimal ticks and labels
-                    optimal_ticks_and_labels(sp, axis)
-                end
-            elseif typeof(ticks) <: Union{AVec, Int}
-                if !isempty(dvals) && typeof(ticks) <: Int
-                    rng = Int[round(Int,i) for i in range(1, stop=length(dvals), length=ticks)]
-                    axis[:continuous_values][rng], dvals[rng]
-                else
-                    # override ticks, but get the labels
-                    optimal_ticks_and_labels(sp, axis, ticks)
-                end
-            elseif typeof(ticks) <: NTuple{2, Any}
-                # assuming we're passed (ticks, labels)
-                ticks
-            else
-                error("Unknown ticks type in get_ticks: $(typeof(ticks))")
-            end
-            axis.plotattributes[:optimized_ticks] = (cv, dv)
+            cvals = axis[:continuous_values]
+            alims = axis_limits(sp, axis[:letter])
+            scale = axis[:scale]
+            formatter = axis[:formatter]
+            get_ticks(ticks, cvals, dvals, alims, scale, formatter)
         end
     end
-    axis.plotattributes[:optimized_ticks]
+    return axis.plotattributes[:optimized_ticks]
 end
 
+# Ticks getter functions
+for l in (:x, :y, :z)
+    axis = string(l, "-axis")  # "x-axis"
+    ticks = string(l, "ticks") # "xticks"
+    f = Symbol(ticks)          # :xticks
+    @eval begin
+        """
+            $($f)(p::Plot)
+
+        returns a vector of the $($axis) ticks of the subplots of `p`.
+
+        Example use:
+
+        ```jldoctest
+        julia> p = plot(1:5, $($ticks)=[1,2])
+
+        julia> $($f)(p)
+        1-element Vector{Tuple{Vector{Float64}, Vector{String}}}:
+         ([1.0, 2.0], ["1", "2"])
+        ```
+
+        If `p` consists of a single subplot, you might want to grab
+        only the first element, via
+
+        ```jldoctest
+        julia> $($f)(p)[1]
+        ([1.0, 2.0], ["1", "2"])
+        ```
+
+        or you can call $($f) on the first (only) subplot of `p` via
+
+        ```jldoctest
+        julia> $($f)(p[1])
+        ([1.0, 2.0], ["1", "2"])
+        ```
+        """
+        $f(p::Plot) = get_ticks(p, $(Meta.quot(l)))
+        """
+            $($f)(sp::Subplot)
+
+        returns the $($axis) ticks of the subplot `sp`.
+
+        Note that the ticks are returned as tuples of values and labels:
+
+        ```jldoctest
+        julia> sp = plot(1:5, $($ticks)=[1,2]).subplots[1]
+        Subplot{1}
+
+        julia> $($f)(sp)
+        ([1.0, 2.0], ["1", "2"])
+        ```
+        """
+        $f(sp::Subplot) = get_ticks(sp, $(Meta.quot(l)))
+        export $f
+    end
+end
+# get_ticks from axis symbol :x, :y, or :z
+get_ticks(sp::Subplot, s::Symbol) = get_ticks(sp, sp[Symbol(s, :axis)])
+get_ticks(p::Plot, s::Symbol) = [get_ticks(sp, s) for sp in p.subplots]
+
+function get_ticks(ticks::Symbol, cvals::T, dvals, args...) where T
+    if ticks === :none
+        return T[], String[]
+    elseif !isempty(dvals)
+        n = length(dvals)
+        if ticks === :all || n < 16
+            return cvals, string.(dvals)
+        else
+            Δ = ceil(Int, n / 10)
+            rng = Δ:Δ:n
+            return cvals[rng], string.(dvals[rng])
+        end
+    else
+        return optimal_ticks_and_labels(nothing, args...)
+    end
+end
+get_ticks(ticks::AVec, cvals, dvals, args...) = optimal_ticks_and_labels(ticks, args...)
+function get_ticks(ticks::Int, dvals, cvals, args...)
+    if !isempty(dvals)
+        rng = round.(Int, range(1, stop=length(dvals), length=ticks))
+        cvals[rng], string.(dvals[rng])
+    else
+        optimal_ticks_and_labels(ticks, args...)
+    end
+end
+get_ticks(ticks::NTuple{2, Any}, args...) = ticks
+get_ticks(::Nothing, cvals::T, args...) where T = T[], String[]
+get_ticks(ticks::Bool, args...) =
+    ticks ? get_ticks(:auto, args...) : get_ticks(nothing, args...)
+get_ticks(::T, args...) where T = error("Unknown ticks type in get_ticks: $T")
+
 _transform_ticks(ticks) = ticks
 _transform_ticks(ticks::AbstractArray{T}) where T <: Dates.TimeType = Dates.value.(ticks)
 _transform_ticks(ticks::NTuple{2, Any}) = (_transform_ticks(ticks[1]), ticks[2])
@@ -442,7 +501,7 @@ function widen(lmin, lmax, scale = :identity)
 end
 
 # figure out if widening is a good idea.
-const _widen_seriestypes = (:line, :path, :steppre, :steppost, :sticks, :scatter, :barbins, :barhist, :histogram, :scatterbins, :scatterhist, :stepbins, :stephist, :bins2d, :histogram2d, :bar, :shape, :path3d, :scatter3d)
+const _widen_seriestypes = (:line, :path, :steppre, :stepmid, :steppost, :sticks, :scatter, :barbins, :barhist, :histogram, :scatterbins, :scatterhist, :stepbins, :stephist, :bins2d, :histogram2d, :bar, :shape, :path3d, :scatter3d)
 
 function default_should_widen(axis::Axis)
     should_widen = false
@@ -757,7 +816,7 @@ function axis_drawing_info_3d(sp, letter)
                 # don't show the 0 tick label for the origin framestyle
                 if sp[:framestyle] == :origin && !(ticks in (:none, nothing, false)) && length(ticks) > 1
                     i0 = findfirst(==(0), ticks[1])
-                    if ind !== nothing
+                    if i0 !== nothing
                         deleteat!(ticks[1], i0)
                         deleteat!(ticks[2], i0)
                     end
@@ -815,7 +874,7 @@ function axis_drawing_info_3d(sp, letter)
                     t = invf(f(na0) + 0.006 * (f(na1) - f(na0)) * ticks_in)
                     (na0, t)
                 end
-                for tick in minorticks
+                for tick in minor_ticks
                     if ax[:showaxis]
                         push!(
                             tick_segments,

src/backends.jl

@@ -531,6 +531,10 @@ const _pyplot_attr = merge_with_base_supported([
     :guidefontfamily, :guidefontsize, :guidefontcolor,
     :grid, :gridalpha, :gridstyle, :gridlinewidth,
     :legend, :legendtitle, :colorbar, :colorbar_title, :colorbar_entry,
+    :colorbar_ticks, :colorbar_tickfontfamily, :colorbar_tickfontsize,
+    :colorbar_tickfonthalign, :colorbar_tickfontvalign,
+    :colorbar_tickfontrotation, :colorbar_tickfontcolor,
+    :colorbar_scale,
     :marker_z, :line_z, :fill_z,
     :levels,
     :ribbon, :quiver, :arrow,
@@ -551,6 +555,7 @@ const _pyplot_attr = merge_with_base_supported([
 const _pyplot_seriestype = [
     :path,
     :steppre,
+    :stepmid,
     :steppost,
     :shape,
     :straightline,
@@ -632,6 +637,7 @@ const _hdf5_attr = merge_with_base_supported([
 const _hdf5_seriestype = [
     :path,
     :steppre,
+    :stepmid,
     :steppost,
     :shape,
     :straightline,
@@ -703,7 +709,7 @@ const _inspectdr_attr = merge_with_base_supported([
   ])
 const _inspectdr_style = [:auto, :solid, :dash, :dot, :dashdot]
 const _inspectdr_seriestype = [
-        :path, :scatter, :shape, :straightline, #, :steppre, :steppost
+        :path, :scatter, :shape, :straightline, #, :steppre, :stepmid, :steppost
     ]
 #see: _allMarkers, _shape_keys
 const _inspectdr_marker = Symbol[
@@ -842,6 +848,7 @@ const _pgfplotsx_marker = [
     :rtriangle,
     :cross,
     :xcross,
+    :x,
     :star5,
     :pentagon,
     :hline,

src/backends/gr.jl

@@ -571,6 +571,26 @@ end
 gr_view_xcenter(viewport_plotarea) = 0.5 * (viewport_plotarea[1] + viewport_plotarea[2])
 gr_view_ycenter(viewport_plotarea) = 0.5 * (viewport_plotarea[3] + viewport_plotarea[4])
 
+gr_view_xposition(viewport_plotarea, position) = viewport_plotarea[1] + position * (viewport_plotarea[2] - viewport_plotarea[1])
+gr_view_yposition(viewport_plotarea, position) = viewport_plotarea[3] + position * (viewport_plotarea[4] - viewport_plotarea[3])
+
+function position(symb)
+    if symb == :top || symb == :right
+        return 0.95
+    elseif symb == :left || symb == :bottom
+        return 0.05
+    end
+    return 0.5
+end
+
+function alignment(symb)
+    if symb == :top || symb == :right
+        return GR.TEXT_HALIGN_RIGHT
+    elseif symb == :left || symb == :bottom
+        return GR.TEXT_HALIGN_LEFT
+    end
+    return GR.TEXT_HALIGN_CENTER
+end
 
 # --------------------------------------------------------------------------------------
 
@@ -743,7 +763,7 @@ function _update_min_padding!(sp::Subplot{GRBackend})
         xticks, yticks, zticks = get_ticks(sp, xaxis), get_ticks(sp, yaxis), get_ticks(sp, zaxis)
         # Add margin for x and y ticks
         h = 0mm
-        if !(xticks in (nothing, false, :none))
+        if !isempty(first(xticks))
             gr_set_font(
                 tickfont(xaxis),
                 halign = (:left, :hcenter, :right)[sign(xaxis[:rotation]) + 2],
@@ -754,7 +774,7 @@ function _update_min_padding!(sp::Subplot{GRBackend})
             l = 0.01 + last(gr_get_ticks_size(xticks, xaxis[:rotation]))
             h = max(h, 1mm + get_size(sp)[2] * l * px)
         end
-        if !(yticks in (nothing, false, :none))
+        if !isempty(first(yticks))
             gr_set_font(
                 tickfont(yaxis),
                 halign = (:left, :hcenter, :right)[sign(yaxis[:rotation]) + 2],
@@ -774,7 +794,7 @@ function _update_min_padding!(sp::Subplot{GRBackend})
             end
         end
 
-        if !(zticks in (nothing, false, :none))
+        if !isempty(first(zticks))
             gr_set_font(
                 tickfont(zaxis),
                 halign = (zaxis[:mirror] ? :left : :right),
@@ -825,7 +845,7 @@ function _update_min_padding!(sp::Subplot{GRBackend})
     else
         # Add margin for x and y ticks
         xticks, yticks = get_ticks(sp, sp[:xaxis]), get_ticks(sp, sp[:yaxis])
-        if !(xticks in (nothing, false, :none))
+        if !isempty(first(xticks))
             gr_set_tickfont(sp, :x)
             l = 0.01 + last(gr_get_ticks_size(xticks, sp[:xaxis][:rotation]))
             h = 1mm + get_size(sp)[2] * l * px
@@ -835,7 +855,7 @@ function _update_min_padding!(sp::Subplot{GRBackend})
                 bottompad += h
             end
         end
-        if !(yticks in (nothing, false, :none))
+        if !isempty(first(yticks))
             gr_set_tickfont(sp, :y)
             l = 0.01 + first(gr_get_ticks_size(yticks, sp[:yaxis][:rotation]))
             w = 1mm + get_size(sp)[1] * l * px
@@ -908,10 +928,10 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
     viewport_plotarea = gr_viewport_from_bbox(sp, plotarea(sp), w, h, viewport_canvas)
 
     # update viewport_plotarea
-    gr_update_viewport_ratio!(viewport_plotarea, sp)
     leg = gr_get_legend_geometry(viewport_plotarea, sp)
     gr_update_viewport_legend!(viewport_plotarea, sp, leg)
-    
+    gr_update_viewport_ratio!(viewport_plotarea, sp)
+
     # fill in the plot area background
     gr_fill_plotarea(sp, viewport_plotarea)
 
@@ -1047,7 +1067,24 @@ end
 
 function gr_legend_pos(sp::Subplot, leg, viewport_plotarea)
     s = sp[:legend]
-    typeof(s) <: Symbol || return gr_legend_pos(s, viewport_plotarea)
+    s isa Real && return gr_legend_pos(s, leg, viewport_plotarea)
+    if s isa Tuple{<:Real,Symbol}
+        if s[2] !== :outer
+            return gr_legend_pos(s[1], leg, viewport_plotarea)
+        end
+
+        xaxis, yaxis = sp[:xaxis], sp[:yaxis]
+        xmirror = xaxis[:guide_position] == :top || (xaxis[:guide_position] == :auto && xaxis[:mirror] == true)
+        ymirror = yaxis[:guide_position] == :right || (yaxis[:guide_position] == :auto && yaxis[:mirror] == true)
+        axisclearance = [
+                         !ymirror*gr_axis_width(sp, sp[:yaxis]),
+                         ymirror*gr_axis_width(sp,sp[:yaxis]),
+                         !xmirror*gr_axis_height(sp,sp[:xaxis]),
+                         xmirror*gr_axis_height(sp,sp[:xaxis]),
+                        ]
+        return gr_legend_pos(s[1], leg, viewport_plotarea; axisclearance)
+    end
+    s isa Symbol || return gr_legend_pos(s, viewport_plotarea)
     str = string(s)
     if str == "best"
         str = "topright"
@@ -1081,7 +1118,7 @@ function gr_legend_pos(sp::Subplot, leg, viewport_plotarea)
         end
     elseif occursin("bottom", str)
         if s == :outerbottom
-            ypos = viewport_plotarea[3] - leg.yoffset - leg.h - !xmirror * gr_axis_height(sp, sp[:xaxis])
+            ypos = viewport_plotarea[3] - leg.yoffset  - leg.dy - !xmirror * gr_axis_height(sp, sp[:xaxis])
         else
             ypos = viewport_plotarea[3] + leg.yoffset + leg.h
         end
@@ -1098,6 +1135,27 @@ function gr_legend_pos(v::Tuple{S,T}, viewport_plotarea) where {S<:Real, T<:Real
     (xpos,ypos)
 end
 
+function gr_legend_pos(theta::Real, leg, viewport_plotarea; axisclearance=nothing)
+    xcenter = +(viewport_plotarea[1:2]...)/2
+    ycenter = +(viewport_plotarea[3:4]...)/2
+
+    if isnothing(axisclearance)
+        # Inner
+        # rectangle where the anchor can legally be
+        xmin = viewport_plotarea[1] + leg.xoffset + leg.leftw
+        xmax = viewport_plotarea[2] - leg.xoffset - leg.rightw - leg.textw
+        ymin = viewport_plotarea[3] + leg.yoffset + leg.h
+        ymax = viewport_plotarea[4] - leg.yoffset - leg.dy
+    else
+        # Outer
+        xmin = viewport_plotarea[1] - leg.xoffset - leg.rightw - leg.textw - axisclearance[1]
+        xmax = viewport_plotarea[2] + leg.xoffset + leg.leftw + axisclearance[2]
+        ymin = viewport_plotarea[3] - leg.yoffset - leg.dy - axisclearance[3]
+        ymax = viewport_plotarea[4] + leg.yoffset + leg.h + axisclearance[4]
+    end
+    return legend_pos_from_angle(theta,xmin,xcenter,xmax,ymin,ycenter,ymax)
+end
+
 function gr_get_legend_geometry(viewport_plotarea, sp)
     legendn = 0
     legendw = 0
@@ -1154,12 +1212,28 @@ end
 ## Viewport, window and scale
 
 function gr_update_viewport_legend!(viewport_plotarea, sp, leg)
-    leg_str = string(sp[:legend])
+    s = sp[:legend]
 
     xaxis, yaxis = sp[:xaxis], sp[:yaxis]
     xmirror = xaxis[:guide_position] == :top || (xaxis[:guide_position] == :auto && xaxis[:mirror] == true)
     ymirror = yaxis[:guide_position] == :right || (yaxis[:guide_position] == :auto && yaxis[:mirror] == true)
 
+    if s isa Tuple{<:Real,Symbol}
+        if s[2] === :outer
+            (x,y) = gr_legend_pos(sp, leg, viewport_plotarea) # Dry run, to figure out
+            if x < viewport_plotarea[1]
+                viewport_plotarea[1] += leg.leftw + leg.textw + leg.rightw + leg.xoffset + !ymirror * gr_axis_width(sp, sp[:yaxis])
+            elseif x > viewport_plotarea[2]
+                viewport_plotarea[2] -= leg.leftw + leg.textw + leg.rightw + leg.xoffset
+            end
+            if y < viewport_plotarea[3]
+                viewport_plotarea[3] += leg.h + leg.dy + leg.yoffset + !xmirror * gr_axis_height(sp, sp[:xaxis])
+            elseif y > viewport_plotarea[4]
+                viewport_plotarea[4] -= leg.h + leg.dy + leg.yoffset
+            end
+        end
+    end
+    leg_str = string(s)
     if occursin("outer", leg_str)
         if occursin("right", leg_str)
             viewport_plotarea[2] -= leg.leftw + leg.textw + leg.rightw + leg.xoffset
@@ -1171,7 +1245,7 @@ function gr_update_viewport_legend!(viewport_plotarea, sp, leg)
             viewport_plotarea[3] += leg.h + leg.dy + leg.yoffset + !xmirror * gr_axis_height(sp, sp[:xaxis])
         end
     end
-    if sp[:legend] == :inline
+    if s === :inline
         if sp[:yaxis][:mirror]
             viewport_plotarea[1] += leg.w
         else
@@ -1430,31 +1504,35 @@ end
 
 function gr_label_axis(sp, letter, viewport_plotarea)
     axis = sp[Symbol(letter, :axis)]
+    mirror = axis[:mirror]
     # guide
     if axis[:guide] != ""
         GR.savestate()
         gr_set_font(guidefont(axis), sp)
         guide_position = axis[:guide_position]
         if letter === :y
-            w = 0.03 + gr_axis_width(sp, axis)
             GR.setcharup(-1, 0)
-            if guide_position == :right || (guide_position == :auto && axis[:mirror])
-                GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_BOTTOM)
-                gr_text(viewport_plotarea[2] + w, gr_view_ycenter(viewport_plotarea), axis[:guide])
+            ypos = gr_view_yposition(viewport_plotarea, position(axis[:guidefontvalign]))
+            yalign = alignment(axis[:guidefontvalign])
+            if guide_position === :right || (guide_position == :auto && mirror)
+                GR.settextalign(yalign, GR.TEXT_VALIGN_BOTTOM)
+                xpos = viewport_plotarea[2] + 0.03 + mirror * gr_axis_width(sp, axis)
             else
-                GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_TOP)
-                gr_text(viewport_plotarea[1] - w, gr_view_ycenter(viewport_plotarea), axis[:guide])
+                GR.settextalign(yalign, GR.TEXT_VALIGN_TOP)
+                xpos = viewport_plotarea[1] - 0.03 - !mirror * gr_axis_width(sp, axis)
             end
         else
-            h = 0.015 + gr_axis_height(sp, axis)
-            if guide_position == :top || (guide_position == :auto && axis[:mirror])
-                GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_TOP)
-                gr_text(gr_view_xcenter(viewport_plotarea), viewport_plotarea[4] + h, axis[:guide])
+            xpos = gr_view_xposition(viewport_plotarea, position(axis[:guidefonthalign]))
+            xalign = alignment(axis[:guidefonthalign])
+            if guide_position === :top || (guide_position == :auto && mirror)
+                GR.settextalign(xalign, GR.TEXT_VALIGN_TOP)
+                ypos = viewport_plotarea[4] + 0.015 + (mirror ? gr_axis_height(sp, axis) : 0.015)
             else
-                GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_BOTTOM)
-                gr_text(gr_view_xcenter(viewport_plotarea), viewport_plotarea[3] - h, axis[:guide])
+                GR.settextalign(xalign, GR.TEXT_VALIGN_BOTTOM)
+                ypos = viewport_plotarea[3] - 0.015 - (mirror ? 0.015 : gr_axis_height(sp, axis))
             end
         end
+        gr_text(xpos, ypos, axis[:guide])
         GR.restorestate()
     end
 end
@@ -1464,10 +1542,10 @@ function gr_label_axis_3d(sp, letter)
     if ax[:guide] != ""
         near_letter = letter in (:x, :z) ? :y : :x
         far_letter = letter in (:x, :y) ? :z : :x
-    
+
         nax = sp[Symbol(near_letter, :axis)]
         fax = sp[Symbol(far_letter, :axis)]
-    
+
         amin, amax = axis_limits(sp, letter)
         namin, namax = axis_limits(sp, near_letter)
         famin, famax = axis_limits(sp, far_letter)
@@ -1561,7 +1639,7 @@ function gr_add_series(sp, series)
             gr_draw_markers(series, x, y, clims)
         end
     elseif st === :shape
-        gr_draw_shapes(series, x, y, clims)
+        gr_draw_shapes(series, clims)
     elseif st in (:path3d, :scatter3d)
         gr_draw_segments_3d(series, x, y, z, clims)
         if st === :scatter3d || series[:markershape] !== :none
@@ -1578,10 +1656,8 @@ function gr_add_series(sp, series)
         GR.gr3.clear()
         dmin, dmax = GR.gr3.volume(y.v, 0)
     elseif st === :heatmap
-        if !ispolar(series)
-            # `z` is already transposed, so we need to reverse before passing its size.
-            x, y = heatmap_edges(x, xscale, y, yscale, reverse(size(z)))
-        end
+        # `z` is already transposed, so we need to reverse before passing its size.
+        x, y = heatmap_edges(x, xscale, y, yscale, reverse(size(z)), ispolar(series))
         gr_draw_heatmap(series, x, y, z, clims)
     elseif st === :image
         gr_draw_image(series, x, y, z, clims)
@@ -1615,12 +1691,13 @@ end
 function gr_draw_segments(series, x, y, fillrange, clims)
     st = series[:seriestype]
     if x !== nothing && length(x) > 1
-        segments = iter_segments(series, st)
+        segments = series_segments(series, st)
         # do area fill
         if fillrange !== nothing
             GR.setfillintstyle(GR.INTSTYLE_SOLID)
             fr_from, fr_to = (is_2tuple(fillrange) ? fillrange : (y, fillrange))
-            for (i, rng) in enumerate(segments)
+            for segment in segments
+                i, rng = segment.attr_index, segment.range
                 fc = get_fillcolor(series, clims, i)
                 gr_set_fillcolor(fc)
                 fx = _cycle(x, vcat(rng, reverse(rng)))
@@ -1632,7 +1709,8 @@ function gr_draw_segments(series, x, y, fillrange, clims)
 
         # draw the line(s)
         if st in (:path, :straightline)
-            for (i, rng) in enumerate(segments)
+            for segment in segments
+                i, rng = segment.attr_index, segment.range
                 lc = get_linecolor(series, clims, i)
                 gr_set_line(
                     get_linewidth(series, i), get_linestyle(series, i), lc, series
@@ -1650,8 +1728,9 @@ end
 function gr_draw_segments_3d(series, x, y, z, clims)
     if series[:seriestype] === :path3d && length(x) > 1
         lz = series[:line_z]
-        segments = iter_segments(series, :path3d)
-        for (i, rng) in enumerate(segments)
+        segments = series_segments(series, :path3d)
+        for segment in segments
+            i, rng = segment.attr_index, segment.range
             lc = get_linecolor(series, clims, i)
             gr_set_line(
                 get_linewidth(series, i), get_linestyle(series, i), lc, series
@@ -1676,8 +1755,9 @@ function gr_draw_markers(
 
     shapes = series[:markershape]
     if shapes != :none
-        for (i, rng) in enumerate(iter_segments(series, :scatter))
-            rng = intersect(eachindex(x), rng)
+        for segment in series_segments(series, :scatter)
+            i = segment.attr_index
+            rng = intersect(eachindex(x), segment.range)
             if !isempty(rng)
                 ms = get_thickness_scaling(series) * _cycle(msize, i)
                 msw = get_thickness_scaling(series) * _cycle(strokewidth, i)
@@ -1690,9 +1770,10 @@ function gr_draw_markers(
     end
 end
 
-function gr_draw_shapes(series, x, y, clims)
+function gr_draw_shapes(series, clims)
     x, y = shape_data(series)
-    for (i,rng) in enumerate(iter_segments(x, y))
+    for segment in series_segments(series, :shape)
+        i, rng = segment.attr_index, segment.range
         if length(rng) > 1
             # connect to the beginning
             rng = vcat(rng, rng[1])
@@ -1734,15 +1815,18 @@ function gr_draw_contour(series, x, y, z, clims)
 end
 
 function gr_draw_surface(series, x, y, z, clims)
+
     if series[:seriestype] === :surface
+        fillalpha = get_fillalpha(series)
+        fillcolor = get_fillcolor(series)
         if length(x) == length(y) == length(z)
-            GR.trisurface(x, y, z)
+            x, y, z = GR.gridit(x, y, z, 200, 200)
+        end
+        if (!isnothing(fillalpha) && fillalpha < 1) || alpha(first(fillcolor)) < 1
+            gr_set_transparency(fillcolor, fillalpha)
+            GR.surface(x, y, z, GR.OPTION_COLORED_MESH)
         else
-            try
-                GR.gr3.surface(x, y, z, GR.OPTION_COLORED_MESH)
-            catch
-                GR.surface(x, y, z, GR.OPTION_COLORED_MESH)
-            end
+            GR.gr3.surface(x, y, z, GR.OPTION_COLORED_MESH)
         end
     else # wireframe
         GR.setfillcolorind(0)
@@ -1752,42 +1836,33 @@ end
 
 function gr_draw_heatmap(series, x, y, z, clims)
     fillgrad = _as_gradient(series[:fillcolor])
-    if !ispolar(series)
-        GR.setspace(clims..., 0, 90)
-        w, h = length(x) - 1, length(y) - 1
-        if is_uniformly_spaced(x) && is_uniformly_spaced(y)
-            # For uniformly spaced data use GR.drawimage, which can be
-            # much faster than GR.nonuniformcellarray, especially for
-            # pdf output, and also supports alpha values.
-            # Note that drawimage draws uniformly spaced data correctly
-            # even on log scales, where it is visually non-uniform.
-            colors = plot_color.(get(fillgrad, z, clims), series[:fillalpha])
-            rgba = gr_color.(colors)
-            GR.drawimage(first(x), last(x), last(y), first(y), w, h, rgba)
-        else
-            if something(series[:fillalpha], 1) < 1
-                @warn "GR: transparency not supported in non-uniform heatmaps. Alpha values ignored."
-            end
-            z_normalized = get_z_normalized.(z, clims...)
-            rgba = Int32[round(Int32, 1000 + _i * 255) for _i in z_normalized]
-            GR.nonuniformcellarray(x, y, w, h, rgba)
-        end
+    GR.setspace(clims..., 0, 90)
+    w, h = length(x) - 1, length(y) - 1
+    if !ispolar(series) && is_uniformly_spaced(x) && is_uniformly_spaced(y)
+        # For uniformly spaced data use GR.drawimage, which can be
+        # much faster than GR.nonuniformcellarray, especially for
+        # pdf output, and also supports alpha values.
+        # Note that drawimage draws uniformly spaced data correctly
+        # even on log scales, where it is visually non-uniform.
+        colors = plot_color.(get(fillgrad, z, clims), series[:fillalpha])
+        rgba = gr_color.(colors)
+        GR.drawimage(first(x), last(x), last(y), first(y), w, h, rgba)
     else
-        phimin, phimax = 0.0, 360.0 # nonuniform polar array is not yet supported in GR.jl
-        nx, ny = length(series[:x]), length(series[:y])
-        xmin, xmax, ymin, ymax = gr_xy_axislims(series[:subplot])
-        GR.setwindow(-ymax, ymax, -ymax, ymax)
-        if ymin > 0
-            @warn "'ymin[1] > 0' (rmin) is not yet supported."
-        end
-        if series[:y][end] != ny
-            @warn "Right now only the maximum value of y (r) is taken into account."
+        if something(series[:fillalpha], 1) < 1
+            @warn "GR: transparency not supported in non-uniform heatmaps. Alpha values ignored."
         end
         z_normalized = get_z_normalized.(z, clims...)
         rgba = Int32[round(Int32, 1000 + _i * 255) for _i in z_normalized]
-        GR.polarcellarray(0, 0, phimin, phimax, 0, ymax, nx, ny, rgba)
-        # Right now only the maximum value of y (r) is taken into account.
-        # This is certainly not perfect but nonuniform polar array is not yet supported in GR.jl
+        if !ispolar(series)
+            GR.nonuniformcellarray(x, y, w, h, rgba)
+        else
+            if y[1] < 0
+                @warn "'y[1] < 0' (rmin) is not yet supported."
+            end
+            xmin, xmax, ymin, ymax = gr_xy_axislims(series[:subplot])
+            GR.setwindow(-ymax, ymax, -ymax, ymax)
+            GR.nonuniformpolarcellarray(rad2deg.(x), y, w, h, rgba)
+        end
     end
 end
 

src/backends/inspectdr.jl

@@ -17,9 +17,6 @@ Add in functionality to Plots.jl:
 
 is_marker_supported(::InspectDRBackend, shape::Shape) = true
 
-_inspectdr_to_pixels(bb::BoundingBox) =
-    InspectDR.BoundingBox(to_pixels(left(bb)), to_pixels(right(bb)), to_pixels(top(bb)), to_pixels(bottom(bb)))
-
 #Do we avoid Map to avoid possible pre-comile issues?
 function _inspectdr_mapglyph(s::Symbol)
     s == :rect && return :square
@@ -79,6 +76,58 @@ end
 
 # ---------------------------------------------------------------------------
 
+function _inspectdr_getaxisticks(ticks, gridlines, xfrm)
+    TickCustom = InspectDR.TickCustom
+    _xfrm(coord) = InspectDR.axis2aloc(Float64(coord), xfrm.spec) #Ensure Float64 - in case
+
+    ttype = ticksType(ticks)
+    if ticks == :native
+        #keep current
+    elseif ttype == :ticks_and_labels
+        pos = ticks[1]; labels = ticks[2]; nticks = length(ticks[1])
+        newticks = TickCustom[TickCustom(_xfrm(pos[i]), labels[i]) for i in 1:nticks]
+        gridlines = InspectDR.GridLinesCustom(gridlines)
+        gridlines.major = newticks
+        gridlines.minor = []
+        gridlines.displayminor = false
+    elseif ttype == :ticks
+        nticks = length(ticks)
+        gridlines.major = Float64[_xfrm(t) for t in ticks]
+        gridlines.minor = []
+        gridlines.displayminor = false
+    elseif isnothing(ticks)
+        gridlines.major = []
+        gridlines.minor = []
+    else #Assume ticks == :native
+        #keep current
+    end
+
+    return gridlines #keep current
+end
+
+function _inspectdr_setticks(sp::Subplot, plot, strip, xaxis, yaxis)
+    InputXfrm1D = InspectDR.InputXfrm1D
+    _get_ticks(axis) = :native == axis[:ticks] ? (:native) : get_ticks(sp, axis)
+    wantnative(ticks) = (:native == ticks)
+
+    xticks = _get_ticks(xaxis)
+    yticks = _get_ticks(yaxis)
+
+    if wantnative(xticks) && wantnative(yticks)
+        #Don't "eval" tick values
+        return
+    end
+
+    #TODO: Allow InspectDR to independently "eval" x or y ticks
+    ext = InspectDR.getextents_aloc(plot, 1)
+    grid = InspectDR._eval(strip.grid, plot.xscale, strip.yscale, ext)
+    grid.xlines = _inspectdr_getaxisticks(xticks, grid.xlines, InputXfrm1D(plot.xscale))
+    grid.ylines = _inspectdr_getaxisticks(yticks, grid.ylines, InputXfrm1D(strip.yscale))
+    strip.grid = grid
+end
+
+# ---------------------------------------------------------------------------
+
 function _inspectdr_getscale(s::Symbol, yaxis::Bool)
 #TODO: Support :asinh, :sqrt
     kwargs = yaxis ? (:tgtmajor=>8, :tgtminor=>2) : () #More grid lines on y-axis
@@ -167,6 +216,7 @@ function _series_added(plt::Plot{InspectDRBackend}, series::Series)
     st = series[:seriestype]
     sp = series[:subplot]
     plot = sp.o
+    clims = get_clims(sp, series)
 
     #Don't do anything without a "subplot" object:  Will process later.
     if nothing == plot; return; end
@@ -237,7 +287,7 @@ For st in :shape:
                 color = linecolor, fillcolor = fillcolor
             )
         end
-   elseif st in (:path, :scatter, :straightline) #, :steppre, :steppost)
+   elseif st in (:path, :scatter, :straightline) #, :steppre, :stepmid, :steppost)
         #NOTE: In Plots.jl, :scatter plots have 0-linewidths (I think).
         linewidth = series[:linewidth]
         #More efficient & allows some support for markerstrokewidth:
@@ -256,8 +306,8 @@ For st in :shape:
         wfrm.glyph = InspectDR.glyph(
             shape = _inspectdr_mapglyph(series[:markershape]),
             size = _inspectdr_mapglyphsize(series[:markersize]),
-            color = _inspectdr_mapcolor(plot_color(series[:markerstrokecolor], series[:markerstrokealpha])),
-            fillcolor = _inspectdr_mapcolor(plot_color(series[:markercolor], series[:markeralpha])),
+            color = _inspectdr_mapcolor(plot_color(get_markerstrokecolor(series), get_markerstrokealpha(series))),
+            fillcolor = _inspectdr_mapcolor(plot_color(get_markercolor(series, clims), get_markeralpha(series))),
         )
     end
 
@@ -288,8 +338,8 @@ function _inspectdr_setupsubplot(sp::Subplot{InspectDRBackend})
     ygrid_show = yaxis[:grid]
 
     strip.grid = InspectDR.GridRect(
-    	vmajor=xgrid_show, # vminor=xgrid_show,
-    	hmajor=ygrid_show, # hminor=ygrid_show,
+        vmajor=xgrid_show, # vminor=xgrid_show,
+        hmajor=ygrid_show, # hminor=ygrid_show,
     )
 
         plot.xscale = _inspectdr_getscale(xaxis[:scale], false)
@@ -302,18 +352,27 @@ function _inspectdr_setupsubplot(sp::Subplot{InspectDRBackend})
             xmin, xmax = -rmax, rmax
             ymin, ymax = -rmax, rmax
         end
-        plot.xext = InspectDR.PExtents1D() #reset
-        strip.yext = InspectDR.PExtents1D() #reset
         plot.xext_full = InspectDR.PExtents1D(xmin, xmax)
         strip.yext_full = InspectDR.PExtents1D(ymin, ymax)
+        #Set current extents = full extents (needed for _eval(strip.grid,...))
+        plot.xext = plot.xext_full
+        strip.yext = strip.yext_full
+        _inspectdr_setticks(sp, plot, strip, xaxis, yaxis)
+
     a = plot.annotation
         a.title = sp[:title]
         a.xlabel = xaxis[:guide]; a.ylabels = [yaxis[:guide]]
 
     l = plot.layout
+        #IMPORTANT: Don't forget to actually register changes
+        #(TODO: need to find a better way to set layout properties)
         l[:frame_canvas].fillcolor = _inspectdr_mapcolor(sp[:background_color_subplot])
+            l[:frame_canvas] = l[:frame_canvas] #register changes
         l[:frame_data].fillcolor = _inspectdr_mapcolor(sp[:background_color_inside])
+            l[:frame_data] = l[:frame_data] #register changes
+
         l[:frame_data].line.color = _inspectdr_mapcolor(xaxis[:foreground_color_axis])
+            l[:frame_data] = l[:frame_data] #register changes
         l[:font_title] = InspectDR.Font(sp[:titlefontfamily],
             _inspectdr_mapptsize(sp[:titlefontsize]),
             color = _inspectdr_mapcolor(sp[:titlefontcolor])
@@ -334,6 +393,7 @@ function _inspectdr_setupsubplot(sp::Subplot{InspectDRBackend})
             color = _inspectdr_mapcolor(sp[:legendfontcolor])
         )
         l[:frame_legend].fillcolor = _inspectdr_mapcolor(sp[:background_color_legend])
+            l[:frame_legend] = l[:frame_legend] #register changes
 end
 
 # called just before updating layout bounding boxes... in case you need to prep
@@ -347,8 +407,9 @@ function _before_layout_calcs(plt::Plot{InspectDRBackend})
         #Don't use window_title... probably not what you want.
         #mplot.title = plt[:window_title]
     end
-    mplot.layout[:frame].fillcolor = _inspectdr_mapcolor(plt[:background_color_outside])
 
+    mplot.layout[:frame].fillcolor = _inspectdr_mapcolor(plt[:background_color_outside])
+        mplot.layout[:frame] = mplot.layout[:frame] #register changes
     resize!(mplot.subplots, length(plt.subplots))
     nsubplots = length(plt.subplots)
     for (i, sp) in enumerate(plt.subplots)
@@ -412,11 +473,16 @@ end
 function _update_plot_object(plt::Plot{InspectDRBackend})
     mplot = _inspectdr_getmplot(plt.o)
     if nothing == mplot; return; end
+    mplot.bblist = InspectDR.BoundingBox[]
 
     for (i, sp) in enumerate(plt.subplots)
-        graphbb = _inspectdr_to_pixels(plotarea(sp))
-        plot = mplot.subplots[i]
-        plot.plotbb = InspectDR.plotbounds(plot.layout.values, graphbb)
+        figw, figh = sp.plt[:size]
+        pcts = bbox_to_pcts(sp.bbox, figw*px, figh*px)
+        _left, _bottom, _width, _height = pcts
+        ymax = 1.0-_bottom
+        ymin = ymax - _height
+        bb = InspectDR.BoundingBox(_left, _left+_width, ymin, ymax)
+        push!(mplot.bblist, bb)
     end
 
     gplot = _inspectdr_getgui(plt.o)

src/backends/pgfplotsx.jl

@@ -339,9 +339,10 @@ end
 
 function pgfx_add_series!(::Val{:path}, axis, series_opt, series, series_func, opt)
     # treat segments
-    segments = iter_segments(series, series[:seriestype])
+    segments = collect(series_segments(series, series[:seriestype]))
     sf = opt[:fillrange]
-    for (i, rng) in enumerate(segments)
+    for (k, segment) in enumerate(segments)
+        i, rng = segment.attr_index, segment.range
         segment_opt = PGFPlotsX.Options()
         segment_opt = merge(segment_opt, pgfx_linestyle(opt, i))
         if opt[:markershape] != :none
@@ -396,7 +397,7 @@ function pgfx_add_series!(::Val{:path}, axis, series_opt, series, series_func, o
                 )
                 end
             end
-            if i == 1 &&
+            if k == 1 &&
                series[:subplot][:legend] != :none && pgfx_should_add_to_legend(series)
                 pgfx_filllegend!(series_opt, opt)
             end
@@ -497,6 +498,7 @@ function pgfx_add_series!(::Val{:surface}, axis, series_opt, series, series_func
         "mesh/rows" => length(opt[:x]),
         "mesh/cols" => length(opt[:y]),
         "z buffer" => "sort",
+        "opacity" => get_fillalpha(series),
     )
     pgfx_add_series!(axis, series_opt, series, series_func, opt)
 end
@@ -768,8 +770,26 @@ pgfx_get_legend_pos(k) = get(
     Symbol(k),
     ("at" => string((1.02, 1)), "anchor" => "north west"),
 )
-pgfx_get_legend_pos(t::Tuple) = ("at" => "{$(string(t))}", "anchor" => "north west")
+pgfx_get_legend_pos(t::Tuple{S,T}) where {S<:Real,T<:Real} = ("at" => "{$(string(t))}", "anchor" => "north west")
 pgfx_get_legend_pos(nt::NamedTuple) = ("at" => "{$(string(nt.at))}", "anchor" => string(nt.anchor))
+pgfx_get_legend_pos(theta::Real) = pgfx_get_legend_pos((theta,:inner))
+function pgfx_get_legend_pos(v::Tuple{S,Symbol}) where S <: Real
+    (s,c) = sincosd(v[1])
+    anchors = [
+               "south west" "south" "south east";
+               "west" "center" "east";
+               "north west" "north" "north east";
+              ]
+
+    if v[2] === :inner
+        rect = (0.07,0.5,1.0,0.07,0.52,1.0)
+        anchor = anchors[legend_anchor_index(s),legend_anchor_index(c)]
+    else
+        rect = (-0.15,0.5,1.05,-0.15,0.52,1.1)
+        anchor = anchors[4-legend_anchor_index(s),4-legend_anchor_index(c)]
+    end
+    return ("at"=>"$(string(legend_pos_from_angle(v[1],rect...)))", "anchor"=>anchor)
+end
 
 pgfx_get_colorbar_pos(s) =
     get((left = " left", bottom = " horizontal", top = " horizontal"), s, "")
@@ -836,7 +856,7 @@ function pgfx_colormap(v::Vector{<:Colorant})
 end
 function pgfx_colormap(cg::ColorGradient)
     join(map(1:length(cg)) do i
-        @sprintf("rgb(%.8fcm)=(%.8f,%.8f,%.8f)", cg.values[i], red(cg.colors[i]), green(cg.colors[i]), blue(cg.colors[i]))
+        @sprintf("rgb(%.8f)=(%.8f,%.8f,%.8f)", cg.values[i], red(cg.colors[i]), green(cg.colors[i]), blue(cg.colors[i]))
     end, "\n")
 end
 
@@ -1361,7 +1381,7 @@ function _update_plot_object(plt::Plot{PGFPlotsXBackend})
     plt.o(plt)
 end
 
-for mime in ("application/pdf", "image/png", "image/svg+xml")
+for mime in ("application/pdf", "image/svg+xml")
     @eval function _show(
         io::IO,
         mime::MIME{Symbol($mime)},
@@ -1372,6 +1392,18 @@ for mime in ("application/pdf", "image/png", "image/svg+xml")
     end
 end
 
+    function _show(
+        io::IO,
+        mime::MIME{Symbol("image/png")},
+        plt::Plot{PGFPlotsXBackend},
+    )
+        plt.o.was_shown = true
+        plt_file = tempname() * ".png"
+        PGFPlotsX.pgfsave(plt_file, plt.o.the_plot; dpi=plt[:dpi])
+        write(io, read(plt_file))
+        rm(plt_file; force = true)
+    end
+
 function _show(
     io::IO,
     mime::MIME{Symbol("application/x-tex")},

src/backends/plotly.jl

@@ -384,6 +384,25 @@ end
 
 plotly_legend_pos(v::Tuple{S,T}) where {S<:Real, T<:Real} = (coords=v, xanchor="left", yanchor="top")
 
+plotly_legend_pos(theta::Real) = plotly_legend_pos((theta, :inner))
+
+function plotly_legend_pos(v::Tuple{S,Symbol}) where S<:Real
+    (s,c) = sincosd(v[1])
+    xanchors = ["left", "center", "right"]
+    yanchors = ["bottom", "middle", "top"]
+
+    if v[2] === :inner
+        rect = (0.07,0.5,1.0,0.07,0.52,1.0)
+        xanchor = xanchors[legend_anchor_index(c)]
+        yanchor = yanchors[legend_anchor_index(s)]
+    else
+        rect = (-0.15,0.5,1.05,-0.15,0.52,1.1)
+        xanchor = xanchors[4-legend_anchor_index(c)]
+        yanchor = yanchors[4-legend_anchor_index(s)]
+    end
+    return (coords=legend_pos_from_angle(v[1],rect...), xanchor=xanchor, yanchor=yanchor)
+end
+
 
 function plotly_layout_json(plt::Plot)
     JSON.json(plotly_layout(plt), 4)
@@ -595,9 +614,9 @@ function plotly_series(plt::Plot, series::Series)
     elseif st == :mesh3d
 	plotattributes_out[:type] = "mesh3d"
         plotattributes_out[:x], plotattributes_out[:y], plotattributes_out[:z] = x, y, z
-       
+
 	if series[:connections] !== nothing
-		if typeof(series[:connections]) <: Tuple{Array,Array,Array} 
+		if typeof(series[:connections]) <: Tuple{Array,Array,Array}
 			i,j,k = series[:connections]
 			if !(length(i) == length(j) == length(k))
 				throw(ArgumentError("Argument connections must consist of equally sized arrays."))
@@ -643,7 +662,7 @@ function plotly_series(plt::Plot, series::Series)
 end
 
 function plotly_series_shapes(plt::Plot, series::Series, clims)
-    segments = iter_segments(series)
+    segments = collect(series_segments(series))
     plotattributes_outs = Vector{KW}(undef, length(segments))
 
     # TODO: create a plotattributes_out for each polygon
@@ -662,7 +681,8 @@ function plotly_series_shapes(plt::Plot, series::Series, clims)
         for (letter, data) in zip((:x, :y), shape_data(series, 100))
     )
 
-    for (i,rng) in enumerate(segments)
+    for segment in segments
+        i, rng = segment.attr_index, segment.range
         length(rng) < 2 && continue
 
         # to draw polygons, we actually draw lines with fill
@@ -705,14 +725,16 @@ function plotly_series_segments(series::Series, plotattributes_base::KW, x, y, z
     hasfillrange = st in (:path, :scatter, :scattergl, :straightline) &&
         (isa(series[:fillrange], AbstractVector) || isa(series[:fillrange], Tuple))
 
-    segments = iter_segments(series, st)
+    segments = collect(series_segments(series, st))
     plotattributes_outs = fill(KW(), (hasfillrange ? 2 : 1 ) * length(segments))
 
     needs_scatter_fix = !isscatter && hasmarker && !any(isnan,y) && length(segments) > 1
 
-    for (i,rng) in enumerate(segments)
+    for (k, segment) in enumerate(segments)
+        i, rng = segment.attr_index, segment.range
+        
         plotattributes_out = deepcopy(plotattributes_base)
-        plotattributes_out[:showlegend] = i==1 ? should_add_to_legend(series) : false
+        plotattributes_out[:showlegend] = k==1 ? should_add_to_legend(series) : false
         plotattributes_out[:legendgroup] = series[:label]
 
         # set the type
@@ -767,6 +789,8 @@ function plotly_series_segments(series::Series, plotattributes_base::KW, x, y, z
                 :width => get_linewidth(series, i),
                 :shape => if st == :steppre
                     "vh"
+                elseif st == :stepmid
+                    "hvh"
                 elseif st == :steppost
                     "hv"
                 else
@@ -805,9 +829,9 @@ function plotly_series_segments(series::Series, plotattributes_base::KW, x, y, z
                 delete!(plotattributes_out, :fillcolor)
             end
 
-            plotattributes_outs[(2 * i - 1):(2 * i)] = [plotattributes_out_fillrange, plotattributes_out]
+            plotattributes_outs[(2k-1):(2k)] = [plotattributes_out_fillrange, plotattributes_out]
         else
-            plotattributes_outs[i] = plotattributes_out
+            plotattributes_outs[k] = plotattributes_out
         end
     end
 

src/backends/plotlyjs.jl

@@ -39,8 +39,7 @@ _show(io::IO, ::MIME"text/html", plt::Plot{PlotlyJSBackend}) = write(io, standal
 _display(plt::Plot{PlotlyJSBackend}) = display(plotlyjs_syncplot(plt))
 
 function PlotlyJS.WebIO.render(plt::Plot{PlotlyJSBackend})
-    plt_html = sprint(show, MIME("text/html"), plt)
-    return PlotlyJS.WebIO.render(PlotlyJS.WebIO.dom"div"(innerHTML=plt_html))
+    return PlotlyJS.WebIO.render(plotlyjs_syncplot(plt))
 end
 
 function closeall(::PlotlyJSBackend)

src/backends/pyplot.jl

@@ -152,12 +152,14 @@ end
 
 function py_stepstyle(seriestype::Symbol)
     seriestype == :steppost && return "steps-post"
+    seriestype == :stepmid && return "steps-mid"
     seriestype == :steppre && return "steps-pre"
     return "default"
 end
 
 function py_fillstepstyle(seriestype::Symbol)
     seriestype == :steppost && return "post"
+    seriestype == :stepmid && return "mid"
     seriestype == :steppre && return "pre"
     return nothing
 end
@@ -205,9 +207,15 @@ function fix_xy_lengths!(plt::Plot{PyPlotBackend}, series::Series)
     end
 end
 
-py_linecolormap(series::Series)       = py_colormap(series[:linecolor])
-py_markercolormap(series::Series)     = py_colormap(series[:markercolor])
-py_fillcolormap(series::Series)       = py_colormap(series[:fillcolor])
+function py_linecolormap(series::Series)
+    py_colormap(cgrad(series[:linecolor], alpha=get_linealpha(series)))
+end
+function py_markercolormap(series::Series)
+    py_colormap(cgrad(series[:markercolor], alpha=get_markeralpha(series)))
+end
+function py_fillcolormap(series::Series)
+    py_colormap(cgrad(series[:fillcolor], alpha=get_fillalpha(series)))
+end
 
 # ---------------------------------------------------------------------------
 
@@ -372,8 +380,10 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
     vmin, vmax = clims = get_clims(sp, series)
 
     # Dict to store extra kwargs
-    if st == :wireframe
-        extrakw = KW()          # vmin, vmax cause an error for wireframe plot
+    if st == :wireframe || st == :hexbin
+        # vmin, vmax cause an error for wireframe plot
+        # We are not supporting clims for hexbin as calculation of bins is not trivial
+        extrakw = KW()
     else
         extrakw = KW(:vmin => vmin, :vmax => vmax)
     end
@@ -400,7 +410,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
     # for each plotting command, optionally build and add a series handle to the list
 
     # line plot
-    if st in (:path, :path3d, :steppre, :steppost, :straightline)
+    if st in (:path, :path3d, :steppre, :stepmid, :steppost, :straightline)
         if maximum(series[:linewidth]) > 0
             # TODO: check LineCollection alternative for speed
             # if length(segments) > 1 && (any(typeof(series[attr]) <: AbstractVector for attr in (:fillcolor, :fillalpha)) || series[:fill_z] !== nothing) && !(typeof(series[:linestyle]) <: AbstractVector)
@@ -432,9 +442,10 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
             #     end
             #     push!(handles, handle)
             # else
-            for (i, rng) in enumerate(iter_segments(series, st))
+            for (k, segment) in enumerate(series_segments(series, st))
+                i, rng = segment.attr_index, segment.range
                 handle = ax."plot"((arg[rng] for arg in xyargs)...;
-                                   label = i == 1 ? series[:label] : "",
+                                   label = k == 1 ? series[:label] : "",
                                    zorder = series[:series_plotindex],
                                    color = py_color(single_color(get_linecolor(series, clims, i)), get_linealpha(series, i)),
                                    linewidth = py_thickness_scale(plt, get_linewidth(series, i)),
@@ -476,19 +487,20 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
 
     # add markers?
     if series[:markershape] != :none && st in (
-        :path, :scatter, :path3d, :scatter3d, :steppre, :steppost, :bar
+        :path, :scatter, :path3d, :scatter3d, :steppre, :stepmid, :steppost, :bar
     )
-        for (i, rng) in enumerate(iter_segments(series, :scatter))
+        for segment in series_segments(series, :scatter)
+            i, rng = segment.attr_index, segment.range
             xyargs = if st == :bar && !isvertical(series)
                 if RecipesPipeline.is3d(sp)
                     y[rng], x[rng], z[rng]
                 else
                     y[rng], x[rng]
-                end        
+                end
             else
                 if RecipesPipeline.is3d(sp)
                     x[rng], y[rng], z[rng]
-                else 
+                else
                     x[rng], y[rng]
                 end
             end
@@ -508,16 +520,17 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
     end
 
     if st == :hexbin
-        handle = ax."hexbin"(x, y,
+        extrakw[:mincnt] = get(series[:extra_kwargs], :mincnt, nothing)
+        extrakw[:edgecolors] = get(series[:extra_kwargs], :edgecolors, py_color(get_linecolor(series)))
+        handle = ax."hexbin"(x, y;
             label = series[:label],
             C = series[:weights],
             gridsize = series[:bins]==:auto ? 100 : series[:bins],  # 100 is the default value
             linewidths = py_thickness_scale(plt, series[:linewidth]),
-            edgecolors = py_color(get_linecolor(series)),
             alpha = series[:fillalpha],
             cmap = py_fillcolormap(series),  # applies to the pcolorfast object
             zorder = series[:series_plotindex],
-            # extrakw...  # We are not supporting clims for hexbin as calculation of bins is not trivial
+            extrakw...
         )
         push!(handles, handle)
     end
@@ -670,7 +683,8 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
 
     if st == :shape
         handle = []
-        for (i, rng) in enumerate(iter_segments(series))
+        for segment in series_segments(series)
+            i, rng = segment.attr_index, segment.range
             if length(rng) > 1
                 path = pypath."Path"(hcat(x[rng], y[rng]))
                 patches = pypatches."PathPatch"(
@@ -697,7 +711,8 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
     # handle area filling
     fillrange = series[:fillrange]
     if fillrange !== nothing && st != :contour
-        for (i, rng) in enumerate(iter_segments(series))
+        for segment in series_segments(series)
+            i, rng = segment.attr_index, segment.range
             f, dim1, dim2 = if isvertical(series)
                 :fill_between, x[rng], y[rng]
             else
@@ -744,7 +759,7 @@ function py_surround_latextext(latexstring, env)
 end
 
 
-function py_set_ticks(ax, ticks, letter, env)
+function py_set_ticks(sp, ax, ticks, letter, env)
     ticks == :auto && return
     axis = getproperty(ax, Symbol(letter,"axis"))
     if ticks == :none || ticks === nothing || ticks == false
@@ -762,7 +777,7 @@ function py_set_ticks(ax, ticks, letter, env)
     elseif ttype == :ticks_and_labels
         axis."set_ticks"(ticks[1])
 
-        if pyrcparams["text.usetex"]
+        if get(sp[:extra_kwargs], :rawticklabels, false)
             tick_labels = ticks[2]
         else
             tick_labels = [py_surround_latextext(ticklabel, env) for ticklabel in ticks[2]]
@@ -794,36 +809,52 @@ function py_compute_axis_minval(sp::Subplot, axis::Axis)
     minval
 end
 
-function py_set_scale(ax, sp::Subplot, axis::Axis)
-    scale = axis[:scale]
-    letter = axis[:letter]
+function py_set_scale(ax, sp::Subplot, scale::Symbol, letter::Symbol)
     scale in supported_scales() || return @warn("Unhandled scale value in pyplot: $scale")
     func = getproperty(ax, Symbol("set_", letter, "scale"))
     if PyPlot.version ≥ v"3.3" # https://matplotlib.org/3.3.0/api/api_changes.html
-        letter = Symbol("")
+        pyletter = Symbol("")
+    else
+        pyletter = letter
     end
     kw = KW()
     arg = if scale == :identity
         "linear"
     else
-        kw[Symbol(:base,letter)] = if scale == :ln
+        kw[Symbol(:base, pyletter)] = if scale == :ln
             ℯ
         elseif scale == :log2
             2
         elseif scale == :log10
             10
         end
-        kw[Symbol(:linthresh,letter)] = NaNMath.max(1e-16, py_compute_axis_minval(sp, axis))
+        axis = sp[Symbol(letter, :axis)]
+        kw[Symbol(:linthresh, pyletter)] = NaNMath.max(1e-16, py_compute_axis_minval(sp, axis))
         "symlog"
     end
     func(arg; kw...)
 end
 
+function py_set_scale(ax, sp::Subplot, axis::Axis)
+    scale = axis[:scale]
+    letter = axis[:letter]
+    py_set_scale(ax, sp, scale, letter)
+end
+
+function py_set_spine_color(spines, color)
+    for loc in spines
+        spines[loc]."set_color"(color)
+    end
+end
+
+function py_set_spine_color(spines::Dict, color)
+    for (loc, spine) in spines
+        spine."set_color"(color)
+    end
+end
 
 function py_set_axis_colors(sp, ax, a::Axis)
-    for (loc, spine) in ax.spines
-        spine."set_color"(py_color(a[:foreground_color_border]))
-    end
+    py_set_spine_color(ax.spines, py_color(a[:foreground_color_border]))
     axissym = Symbol(a[:letter], :axis)
     if PyPlot.PyCall.hasproperty(ax, axissym)
         tickcolor = sp[:framestyle] in (:zerolines, :grid) ? py_color(plot_color(a[:foreground_color_grid], a[:gridalpha])) : py_color(a[:foreground_color_axis])
@@ -921,7 +952,7 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
             kw[:spacing] = "proportional"
 
             if RecipesPipeline.is3d(sp) || ispolar(sp)
-                cbax = fig."add_axes"([0.9, 0.1, 0.03, 0.8])
+                cbax = fig."add_axes"([0.9, 0.1, 0.03, 0.8], label=string("cbar", sp[:subplot_index]))
                 cb = fig."colorbar"(handle; cax=cbax, kw...)
             else
                 # divider approach works only with 2d plots
@@ -946,7 +977,7 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
                     colorbar_orientation="horizontal"
                 end
 
-                cbax = divider.append_axes(colorbar_position, size="5%", pad=colorbar_pad)  # Reasonable value works most of the usecases
+                cbax = divider.append_axes(colorbar_position, size="5%", pad=colorbar_pad, label=string("cbar", sp[:subplot_index]))  # Reasonable value works most of the usecases
                 cb = fig."colorbar"(handle; cax=cbax, orientation = colorbar_orientation, kw...)
 
                 if sp[:colorbar] == :left
@@ -959,24 +990,31 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
 
             end
 
-            cb."set_label"(sp[:colorbar_title],size=py_thickness_scale(plt, sp[:yaxis][:guidefontsize]),family=sp[:yaxis][:guidefontfamily], color = py_color(sp[:yaxis][:guidefontcolor]))
+            cb."set_label"(sp[:colorbar_title],size=py_thickness_scale(plt, sp[:colorbar_titlefontsize]),family=sp[:colorbar_titlefontfamily], color = py_color(sp[:colorbar_titlefontcolor]))
 
             # cb."formatter".set_useOffset(false)   # This for some reason does not work, must be a pyplot bug, instead this is a workaround:
             cb."formatter".set_powerlimits((-Inf, Inf))
             cb."update_ticks"()
 
+            env = "\\mathregular"  # matches the outer fonts https://matplotlib.org/tutorials/text/mathtext.html
+            ticks = get_colorbar_ticks(sp)
+
             if sp[:colorbar] in (:top, :bottom)
                 axis = sp[:xaxis]  # colorbar inherits from x axis
                 cbar_axis = cb."ax"."xaxis"
+                ticks_letter=:x
             else
                 axis = sp[:yaxis]  # colorbar inherits from y axis
                 cbar_axis = cb."ax"."yaxis"
+                ticks_letter=:y
             end
+            py_set_scale(cb.ax, sp, sp[:colorbar_scale], ticks_letter)
+            sp[:colorbar_ticks] == :native ? nothing : py_set_ticks(sp, cb.ax, ticks, ticks_letter, env)
 
             for lab in cbar_axis."get_ticklabels"()
-                  lab."set_fontsize"(py_thickness_scale(plt, axis[:tickfontsize]))
-                  lab."set_family"(axis[:tickfontfamily])
-                  lab."set_color"(py_color(axis[:tickfontcolor]))
+                  lab."set_fontsize"(py_thickness_scale(plt, sp[:colorbar_tickfontsize]))
+                  lab."set_family"(sp[:colorbar_tickfontfamily])
+                  lab."set_color"(py_color(sp[:colorbar_tickfontcolor]))
             end
 
             # Adjust thickness of the cbar ticks
@@ -995,6 +1033,7 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
             sp.attr[:cbar_ax] = cbax
         end
 
+
         # framestyle
         if !ispolar(sp) && !RecipesPipeline.is3d(sp)
             for pos in ("left", "right", "top", "bottom")
@@ -1005,16 +1044,20 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
             # Then set visible some of them
             if sp[:framestyle] == :semi
                 intensity = 0.5
-                ax.spines["right"]."set_alpha"(intensity)
-                ax.spines["top"]."set_alpha"(intensity)
-                ax.spines["right"]."set_linewidth"(py_thickness_scale(plt, intensity))
-                ax.spines["top"]."set_linewidth"(py_thickness_scale(plt, intensity))
+
+                spine = sp[:yaxis][:mirror] ? "left" : "right"
+                ax.spines[spine]."set_alpha"(intensity)
+                ax.spines[spine]."set_linewidth"(py_thickness_scale(plt, intensity))
+
+                spine = sp[:xaxis][:mirror] ? "bottom" : "top"
+                ax.spines[spine]."set_linewidth"(py_thickness_scale(plt, intensity))
+                ax.spines[spine]."set_alpha"(intensity)
             elseif sp[:framestyle] == :box
                 ax.tick_params(top=true)   # Add ticks too
                 ax.tick_params(right=true) # Add ticks too
             elseif sp[:framestyle] in (:axes, :origin)
-                ax.spines["right"]."set_visible"(false)
-                ax.spines["top"]."set_visible"(false)
+                sp[:xaxis][:mirror] ? ax.spines["bottom"]."set_visible"(false) : ax.spines["top"]."set_visible"(false)
+                sp[:yaxis][:mirror] ? ax.spines["left"]."set_visible"(false) : ax.spines["right"]."set_visible"(false)
                 if sp[:framestyle] == :origin
                     ax.spines["bottom"]."set_position"("zero")
                     ax.spines["left"]."set_position"("zero")
@@ -1028,6 +1071,16 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
                     ax."axvline"(x = 0, color = py_color(sp[:yaxis][:foreground_color_axis]), lw = py_thickness_scale(plt, 0.75))
                 end
             end
+
+            if sp[:xaxis][:mirror]
+                ax.xaxis."set_label_position"("top")     # the guides
+                sp[:framestyle] == :box ? nothing : ax.xaxis."tick_top"()
+            end
+
+            if sp[:yaxis][:mirror]
+                ax.yaxis."set_label_position"("right")     # the guides
+                sp[:framestyle] == :box ? nothing : ax.yaxis."tick_right"()
+            end
         end
 
         # axis attributes
@@ -1078,7 +1131,7 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
             # workaround to set mathtext.fontspec per Text element
             env = "\\mathregular"  # matches the outer fonts https://matplotlib.org/tutorials/text/mathtext.html
 
-            axis[:ticks] == :native ? nothing : py_set_ticks(ax, ticks, letter, env)
+            axis[:ticks] == :native ? nothing : py_set_ticks(sp, ax, ticks, letter, env)
             # Tick marks
             intensity = 0.5  # This value corresponds to scaling of other grid elements
             pyaxis."set_tick_params"(
@@ -1239,11 +1292,10 @@ function _update_min_padding!(sp::Subplot{PyPlotBackend})
 
 
     # optionally add the width of colorbar labels and colorbar to rightpad
-    # if haskey(sp.attr, :cbar_ax)
-    #     bb = py_bbox(sp.attr[:cbar_handle]."ax"."get_yticklabels"())
-    #     sp.attr[:cbar_width] = width(bb) + (sp[:colorbar_title] == "" ? 0px : 30px)
-    #     rightpad = rightpad + sp.attr[:cbar_width]
-    # end
+    if RecipesPipeline.is3d(sp) && haskey(sp.attr, :cbar_ax)
+        bb = py_bbox(sp.attr[:cbar_handle]."ax"."get_yticklabels"())
+        sp.attr[:cbar_width] = width(bb) + (sp[:colorbar_title] == "" ? 0px : 30px)
+    end
 
     # add in the user-specified margin
     leftpad   += sp[:left_margin]
@@ -1282,44 +1334,26 @@ end
 
 # -----------------------------------------------------------------
 
-py_legend_pos(pos::Symbol) = get(
-    (
-        right = "right",
-        left = "center left",
-        top = "upper center",
-        bottom = "lower center",
-        bottomleft = "lower left",
-        bottomright = "lower right",
-        topright = "upper right",
-        topleft = "upper left",
-        outerright = "center left",
-        outerleft = "right",
-        outertop = "lower center",
-        outerbottom = "upper center",
-        outerbottomleft = "lower right",
-        outerbottomright = "lower left",
-        outertopright = "upper left",
-        outertopleft = "upper right",
-    ),
-    pos,
-    "best",
-)
-py_legend_pos(pos) = "lower left"
+py_legend_pos(pos::Tuple{S,T}) where {S<:Real,T<:Real} = "lower left"
+
+function py_legend_pos(pos::Tuple{<:Real,Symbol})
+    (s,c) = sincosd(pos[1])
+    if pos[2] === :outer
+        s = -s
+        c = -c
+    end
+    yanchors = ["lower","center","upper"]
+    xanchors = ["left","center","right"]
+    return join([yanchors[legend_anchor_index(s)], xanchors[legend_anchor_index(c)]], ' ')
+end
+
+function py_legend_bbox(pos::Tuple{T,Symbol}) where T<:Real
+    if pos[2] === :outer
+        return legend_pos_from_angle(pos[1],-0.15,0.5,1.0,-0.15,0.5,1.0)
+    end
+    legend_pos_from_angle(pos[1],0.0,0.5,1.0,0.0,0.5,1.0)
+end
 
-py_legend_bbox(pos::Symbol) = get(
-    (
-        outerright = (1.0, 0.5, 0.0, 0.0),
-        outerleft = (-0.15, 0.5, 0.0, 0.0),
-        outertop = (0.5, 1.0, 0.0, 0.0),
-        outerbottom = (0.5, -0.15, 0.0, 0.0),
-        outerbottomleft = (-0.15, 0.0, 0.0, 0.0),
-        outerbottomright = (1.0, 0.0, 0.0, 0.0),
-        outertopright = (1.0, 1.0, 0.0, 0.0),
-        outertopleft = (-0.15, 1.0, 0.0, 0.0),
-    ),
-    pos,
-    (0.0, 0.0, 1.0, 1.0),
-)
 py_legend_bbox(pos) = pos
 
 function py_add_legend(plt::Plot, sp::Subplot, ax)
@@ -1341,7 +1375,7 @@ function py_add_legend(plt::Plot, sp::Subplot, ax)
                             linestyle = py_linestyle(series[:seriestype], get_linestyle(series)),
                             capstyle = "butt"
                         )
-                    elseif series[:seriestype] in (:path, :straightline, :scatter, :steppre, :steppost)
+                    elseif series[:seriestype] in (:path, :straightline, :scatter, :steppre, :stepmid, :steppost)
                         hasline = get_linewidth(series) > 0
                         PyPlot.plt."Line2D"((0, 1),(0,0),
                             color = py_color(single_color(get_linecolor(series, clims)), get_linealpha(series)),
@@ -1365,6 +1399,7 @@ function py_add_legend(plt::Plot, sp::Subplot, ax)
 
         # if anything was added, call ax.legend and set the colors
         if !isempty(handles)
+            leg = legend_angle(leg)
             leg = ax."legend"(handles,
                 labels,
                 loc = py_legend_pos(leg),
@@ -1375,7 +1410,7 @@ function py_add_legend(plt::Plot, sp::Subplot, ax)
                 edgecolor = py_color(sp[:foreground_color_legend]),
                 framealpha = alpha(plot_color(sp[:background_color_legend])),
                 fancybox = false,  # makes the legend box square
-                borderpad=0.8      # to match GR legendbox
+                borderpad = 0.8      # to match GR legendbox
             )
             frame = leg."get_frame"()
             frame."set_linewidth"(py_thickness_scale(plt, 1))

src/colorbars.jl

@@ -0,0 +1,90 @@
+# These functions return an operator for use in `get_clims(::Seres, op)`
+process_clims(lims::Tuple{<:Number,<:Number}) = (zlims -> ifelse.(isfinite.(lims), lims, zlims)) ∘ ignorenan_extrema
+process_clims(s::Union{Symbol,Nothing,Missing}) = ignorenan_extrema
+# don't specialize on ::Function otherwise python functions won't work
+process_clims(f) = f
+
+function get_clims(sp::Subplot, op=process_clims(sp[:clims]))
+    zmin, zmax = Inf, -Inf
+    for series in series_list(sp)
+        if series[:colorbar_entry]
+            zmin, zmax = _update_clims(zmin, zmax, get_clims(series, op)...)
+        end
+    end
+    return zmin <= zmax ? (zmin, zmax) : (NaN, NaN)
+end
+
+function get_clims(sp::Subplot, series::Series, op=process_clims(sp[:clims]))
+    zmin, zmax = if series[:colorbar_entry]
+        get_clims(sp, op)
+    else
+        get_clims(series, op)
+    end
+    return zmin <= zmax ? (zmin, zmax) : (NaN, NaN)
+end
+
+"""
+    get_clims(::Series, op=Plots.ignorenan_extrema)
+
+Finds the limits for the colorbar by taking the "z-values" for the series and passing them into `op`,
+which must return the tuple `(zmin, zmax)`. The default op is the extrema of the finite
+values of the input.
+"""
+function get_clims(series::Series, op=ignorenan_extrema)
+    zmin, zmax = Inf, -Inf
+    z_colored_series = (:contour, :contour3d, :heatmap, :histogram2d, :surface, :hexbin)
+    for vals in (series[:seriestype] in z_colored_series ? series[:z] : nothing, series[:line_z], series[:marker_z], series[:fill_z])
+        if (typeof(vals) <: AbstractSurface) && (eltype(vals.surf) <: Union{Missing, Real})
+            zmin, zmax = _update_clims(zmin, zmax, op(vals.surf)...)
+        elseif (vals !== nothing) && (eltype(vals) <: Union{Missing, Real})
+            zmin, zmax = _update_clims(zmin, zmax, op(vals)...)
+        end
+    end
+    return zmin <= zmax ? (zmin, zmax) : (NaN, NaN)
+end
+
+_update_clims(zmin, zmax, emin, emax) = NaNMath.min(zmin, emin), NaNMath.max(zmax, emax)
+
+@enum ColorbarStyle cbar_gradient cbar_fill cbar_lines
+
+function colorbar_style(series::Series)
+    colorbar_entry = series[:colorbar_entry]
+    if !(colorbar_entry isa Bool)
+        @warn "Non-boolean colorbar_entry ignored."
+        colorbar_entry = true
+    end
+
+    if !colorbar_entry
+        nothing
+    elseif isfilledcontour(series)
+        cbar_fill
+    elseif iscontour(series)
+        cbar_lines
+    elseif series[:seriestype] ∈ (:heatmap,:surface) ||
+            any(series[z] !== nothing for z ∈ [:marker_z,:line_z,:fill_z])
+        cbar_gradient
+    else
+        nothing
+    end
+end
+
+hascolorbar(series::Series) = colorbar_style(series) !== nothing
+hascolorbar(sp::Subplot) = sp[:colorbar] != :none && any(hascolorbar(s) for s in series_list(sp))
+
+function get_colorbar_ticks(sp::Subplot; update = true)
+    if update || !haskey(sp.attr, :colorbar_optimized_ticks)
+        ticks = _transform_ticks(sp[:colorbar_ticks])
+        cvals = sp[:colorbar_continuous_values]
+        dvals = sp[:colorbar_discrete_values]
+        clims = get_clims(sp)
+        scale = sp[:colorbar_scale]
+        formatter = sp[:colorbar_formatter]
+        sp.attr[:colorbar_optimized_ticks] =
+            get_ticks(ticks, cvals, dvals, clims, scale, formatter)
+    end
+    return sp.attr[:colorbar_optimized_ticks]
+end
+
+function _update_subplot_colorbars(sp::Subplot)
+    # Dynamic callback from the pipeline if needed
+end

src/components.jl

@@ -42,15 +42,11 @@ function coords(shape::Shape)
     shape.x, shape.y
 end
 
+#coords(shapes::AVec{Shape}) = unzip(map(coords, shapes))
 function coords(shapes::AVec{Shape})
-    length(shapes) == 0 && return zeros(0), zeros(0)
-    xs = map(get_xs, shapes)
-    ys = map(get_ys, shapes)
-    x, y = map(copy, coords(shapes[1]))
-    for shape in shapes[2:end]
-        nanappend!(x, shape.x)
-        nanappend!(y, shape.y)
-    end
+    c = map(coords, shapes)
+    x = [q[1] for q in c]
+    y = [q[2] for q in c]
     x, y
 end
 

src/examples.jl

@@ -1029,23 +1029,40 @@ const _examples = PlotExample[
         "Vectors of markershapes and segments",
         "",
         [quote
+            using Base.Iterators: cycle, take
+
             yv = ones(9)
             ys = [1; 1; NaN; ones(6)]
-            plot(
-                5 .- [yv 2ys 3yv 4ys],
+            y = 5 .- [yv 2ys 3yv 4ys]
+
+            plt_color_rows = plot(
+                y,
                 seriestype = [:path :path :scatter :scatter],
-                markershape = [:utriangle, :rect],
+                markershape = collect(take(cycle((:utriangle, :rect)), 9)),
                 markersize = 8,
-                color = [:red, :black],
+                color = collect(take(cycle((:red, :black)), 9))
             )
+
+            plt_z_cols = plot(
+                y,
+                markershape = [:utriangle :x :circle :square],
+                markersize = [5 10 10 5],
+                marker_z = [5 4 3 2],
+                line_z = [1 3 3 1],
+                linewidth = [1 10 5 1]
+            )
+
+            plot(plt_color_rows, plt_z_cols)
         end]
     ),
     PlotExample( # 49
         "Polar heatmaps",
         "",
         [quote
-            z = (1:4) .+ (1:8)'
-            heatmap(z, projection = :polar)
+        x = range(0, 2π, length=9)
+        y = 0:4
+        z = (1:4) .+ (1:8)'
+        heatmap(x, y, z, projection = :polar)
         end]
     ),
     PlotExample( # 50
@@ -1102,6 +1119,49 @@ const _examples = PlotExample[
             quiver(x,y,z, quiver=(u,v,w))
         end]
     ),
+    PlotExample( # 53
+        "Step Types",
+        "A comparison of the various step-like `seriestype`s",
+        [
+            :(
+              begin
+                  x = 1:5
+                  y = [1, 2, 3, 2, 1]
+                  default(shape=:circle)
+                  plot(
+                       plot(x, y, markershape=:circle, seriestype=:steppre, label="steppre"),
+                       plot(x, y, markershape=:circle, seriestype=:stepmid, label="stepmid"),
+                       plot(x, y, markershape=:circle, seriestype=:steppost, label="steppost"),
+                       layout=(3,1)
+                      )
+              end
+            ),
+        ],
+    ),
+    PlotExample( # 54
+        "Guide positions and alignment",
+        "",
+        [
+            :(
+              begin
+                plot(
+                    rand(10, 4),
+                    layout=4,
+                    xguide="x guide",
+                    yguide="y guide",
+                    xguidefonthalign=[:left :right :right :left],
+                    yguidefontvalign=[:top :bottom :bottom :top],
+                    xguideposition=:top,
+                    yguideposition=[:right :left :right :left],
+                    ymirror=[false true true false],
+                    xmirror=[false false true true],
+                    legend=false,
+                    seriestype=[:bar :scatter :path :stepmid]
+                )
+              end
+            ),
+        ],
+    ),
 ]
 
 # Some constants for PlotDocs and PlotReferenceImages

src/legend.jl

@@ -0,0 +1,59 @@
+"""
+```julia
+legend_pos_from_angle(theta, xmin, xcenter, xmax, ymin, ycenter, ymax, inout)
+```
+
+Return `(x,y)` at an angle `theta` degrees from
+`(xcenter,ycenter)` on a rectangle defined by (`xmin`,
+`xmax`, `ymin`, `ymax`).
+"""
+function legend_pos_from_angle(theta, xmin, xcenter, xmax, ymin, ycenter, ymax)
+    (s,c) = sincosd(theta)
+    x = c < 0 ? (xmin-xcenter)/c : (xmax-xcenter)/c
+    y = s < 0 ? (ymin-ycenter)/s : (ymax-ycenter)/s
+    A = min(x,y)
+    return (xcenter + A*c, ycenter + A*s)
+end
+
+
+"""
+Split continuous range `[-1,1]` evenly into an integer `[1,2,3]`
+"""
+function legend_anchor_index(x)
+    x<-1//3 && return 1
+    x<1//3 && return 2
+    return 3
+end
+
+"""
+Turn legend argument into a (theta, :inner) or (theta, :outer) tuple.
+For backends where legend position is given in normal coordinates (0,0) -- (1,1),
+so :topleft exactly corresponds to (45, :inner) etc.
+
+If `leg` is a (::Real,::Real) tuple, keep it as is.
+"""
+legend_angle(leg::Real) = (leg,:inner)
+legend_angle(leg::Tuple{S,T}) where {S<:Real,T<:Real} = leg
+legend_angle(leg::Tuple{S,Symbol}) where S<:Real = leg
+legend_angle(leg::Symbol) = get(
+                                (
+                                 topleft            =   (135,:inner),
+                                 top                =   (90, :inner),
+                                 topright           =   (45, :inner),
+                                 left               =   (180,:inner),
+                                 right              =   (0,  :inner),
+                                 bottomleft         =   (225,:inner),
+                                 bottom             =   (270,:inner),
+                                 bottomright        =   (315,:inner),
+                                 outertopleft       =   (135,:outer),
+                                 outertop           =   (90, :outer),
+                                 outertopright      =   (45, :outer),
+                                 outerleft          =   (180,:outer),
+                                 outerright         =   (0,  :outer),
+                                 outerbottomleft    =   (225,:outer),
+                                 outerbottom        =   (270,:outer),
+                                 outerbottomright   =   (315,:outer),
+                                ),
+                                leg,
+                                (45, :inner)
+                               )

src/pipeline.jl

@@ -5,13 +5,24 @@
 function RecipesPipeline.warn_on_recipe_aliases!(
     plt::Plot,
     plotattributes::AKW,
-    recipe_type,
-    signature_string
+    recipe_type::Symbol,
+    @nospecialize(args)
 )
     for k in keys(plotattributes)
         if !is_default_attribute(k)
             dk = get(_keyAliases, k, k)
             if k !== dk
+                if recipe_type == :user
+                    signature_string = RecipesPipeline.userrecipe_signature_string(args)
+                elseif recipe_type == :type
+                    signature_string = RecipesPipeline.typerecipe_signature_string(args)
+                elseif recipe_type == :plot
+                    signature_string = RecipesPipeline.plotrecipe_signature_string(args)
+                elseif recipe_type == :series
+                    signature_string = RecipesPipeline.seriesrecipe_signature_string(args)
+                else
+                    throw(ArgumentError("Invalid recipe type `$recipe_type`"))
+                end
                 @warn "Attribute alias `$k` detected in the $recipe_type recipe defined for the signature $signature_string. To ensure expected behavior it is recommended to use the default attribute `$dk`."
             end
             plotattributes[dk] = RecipesPipeline.pop_kw!(plotattributes, k)
@@ -130,7 +141,7 @@ function _add_smooth_kw(kw_list::Vector{KW}, kw::AKW)
 end
 
 
-RecipesPipeline.get_axis_limits(plt::Plot, f, letter) = axis_limits(plt[1], letter)
+RecipesPipeline.get_axis_limits(plt::Plot, letter) = axis_limits(plt[1], letter)
 
 
 ## Plot recipes

src/plot.jl

@@ -43,8 +43,8 @@ The main plot command. Use `plot` to create a new plot object, and `plot!` to ad
 
 There are lots of ways to pass in data, and lots of keyword arguments... just try it and it will likely work as expected.
 When you pass in matrices, it splits by columns. To see the list of available attributes, use the `plotattr([attr])`
-function, where `attr` is the symbol `:Series:`, `:Subplot:`, `:Plot` or `:Axis`. Pass any attribute to `plotattr`
-as a String to look up its docstring; e.g. `plotattr("seriestype")`.
+function, where `attr` is the symbol `:Series`, `:Subplot`, `:Plot`, or `:Axis`. Pass any attribute to `plotattr`
+as a String to look up its docstring, e.g., `plotattr("seriestype")`.
 """
 function plot(args...; kw...)
     @nospecialize
@@ -218,4 +218,4 @@ function plot!(sp::Subplot, args...; kw...)
     @nospecialize
     plt = sp.plt
     plot!(plt, args...; kw..., subplot = findfirst(isequal(sp), plt.subplots))
-end
+end

src/recipes.jl

@@ -165,49 +165,81 @@ end
     x := x
     y := y
     seriestype := :scatter
+    @series begin
+        ()
+    end
     @series begin
         seriestype := :path
         label := ""
         primary := false
         ()
     end
+    primary := false
     ()
 end
 @deps scatterpath path scatter
 
+
+# ---------------------------------------------------------------------------
+# regression line and scatter
+
+# plots line corresponding to linear regression of y on a constant and x
+@recipe function f(::Type{Val{:linearfit}}, x, y, z)
+    x := x
+    y := y
+    seriestype := :scatter
+    @series begin
+        ()
+    end
+    @series begin
+        y := mean(y) .+ cov(x, y) / var(x) .* (x .- mean(x))
+        seriestype := :path
+        label := ""
+        primary := false
+        ()
+    end
+    primary := false
+    ()
+end
+
+
 @specialize
 
 
 # ---------------------------------------------------------------------------
 # steps
 
-make_steps(x, st) = x
-function make_steps(x::AbstractArray, st)
+make_steps(x, st, even) = x
+function make_steps(x::AbstractArray, st, even)
     n = length(x)
     n == 0 && return zeros(0)
-    newx = zeros(2n - 1)
-    for i = 1:n
+    newx = zeros(2n - (even ? 0 : 1))
+    newx[1] = x[1]
+    for i = 2:n
         idx = 2i - 1
-        newx[idx] = x[i]
-        if i > 1
+        if st == :mid
+            newx[idx] = newx[idx-1] = (x[i] + x[i-1]) / 2
+        else
+            newx[idx] = x[i]
             newx[idx - 1] = x[st == :pre ? i : i - 1]
         end
     end
+    even && (newx[end] = x[end])
     return newx
 end
-make_steps(t::Tuple, st) = Tuple(make_steps(ti, st) for ti in t)
+make_steps(t::Tuple, st, even) = Tuple(make_steps(ti, st, even) for ti in t)
 
 
 @nospecialize
 
 # create a path from steps
 @recipe function f(::Type{Val{:steppre}}, x, y, z)
-    plotattributes[:x] = make_steps(x, :post)
-    plotattributes[:y] = make_steps(y, :pre)
+    plotattributes[:x] = make_steps(x, :post, false)
+    plotattributes[:y] = make_steps(y, :pre, false)
     seriestype := :path
 
     # handle fillrange
-    plotattributes[:fillrange] = make_steps(plotattributes[:fillrange], :pre)
+    plotattributes[:fillrange] = make_steps(plotattributes[:fillrange], :pre, false)
 
     # create a secondary series for the markers
     if plotattributes[:markershape] != :none
@@ -226,13 +258,38 @@ end
 @deps steppre path scatter
 
 # create a path from steps
-@recipe function f(::Type{Val{:steppost}}, x, y, z)
-    plotattributes[:x] = make_steps(x, :pre)
-    plotattributes[:y] = make_steps(y, :post)
+@recipe function f(::Type{Val{:stepmid}}, x, y, z)
+    plotattributes[:x] = make_steps(x, :mid, true)
+    plotattributes[:y] = make_steps(y, :post, true)
     seriestype := :path
 
     # handle fillrange
-    plotattributes[:fillrange] = make_steps(plotattributes[:fillrange], :post)
+    plotattributes[:fillrange] = make_steps(plotattributes[:fillrange], :post, true)
+
+    # create a secondary series for the markers
+    if plotattributes[:markershape] != :none
+        @series begin
+            seriestype := :scatter
+            x := x
+            y := y
+            label := ""
+            primary := false
+            ()
+        end
+        markershape := :none
+    end
+    ()
+end
+@deps stepmid path scatter
+
+# create a path from steps
+@recipe function f(::Type{Val{:steppost}}, x, y, z)
+    plotattributes[:x] = make_steps(x, :pre, false)
+    plotattributes[:y] = make_steps(y, :post, false)
+    seriestype := :path
+
+    # handle fillrange
+    plotattributes[:fillrange] = make_steps(plotattributes[:fillrange], :post, false)
 
     # create a secondary series for the markers
     if plotattributes[:markershape] != :none
@@ -398,7 +455,7 @@ end
     bw = plotattributes[:bar_width]
     hw = if bw === nothing
         if nx > 1
-            0.5 * _bar_width * ignorenan_minimum(filter(x -> x > 0, diff(procx)))
+            0.5 * _bar_width * ignorenan_minimum(filter(x -> x > 0, diff(sort(procx))))
         else
             0.5 * _bar_width
         end
@@ -415,6 +472,15 @@ end
         fillto = map(x -> _is_positive(x) ? typeof(baseline)(x) : baseline, fillto)
     end
 
+    if !isnothing(plotattributes[:series_annotations])
+        if isvertical(plotattributes)
+            annotations := (x,y,plotattributes[:series_annotations].strs,:bottom)
+        else
+            annotations := (y,x,plotattributes[:series_annotations].strs,:left)
+        end
+        series_annotations := nothing
+    end
+
     # create the bar shapes by adding x/y segments
     xseg, yseg = Segments(), Segments()
     for i = 1:ny
@@ -1364,6 +1430,16 @@ end
 
 @recipe function f(shapes::AVec{Shape})
     seriestype --> :shape
+    # For backwards compatibility, column vectors of segmenting attributes are 
+    # interpreted as having one element per shape
+    for attr in union(_segmenting_array_attributes, _segmenting_vector_attributes)
+        v = get(plotattributes, attr, nothing)
+        if v isa AVec || v isa AMat && size(v,2) == 1
+            @warn "Column vector attribute `$attr` reinterpreted as row vector (one value per shape).\n" *
+                    "Pass a row vector instead (e.g. using `permutedims`) to suppress this warning."
+            plotattributes[attr] = permutedims(v)
+        end
+    end
     coords(shapes)
 end
 

src/shorthands.jl

@@ -57,6 +57,7 @@ Plot a histogram.
 # Example
 ```julia-repl
 julia> histogram([1,2,1,1,4,3,8],bins=0:8)
+julia> histogram([1,2,1,1,4,3,8],bins=0:8,weights=weights([4,7,3,9,12,2,6]))
 ```
 """
 @shorthands histogram

src/utils.jl

@@ -53,10 +53,16 @@ function Base.push!(segments::Segments{T}, vs::AVec) where T
 end
 
 
+struct SeriesSegment
+    # indexes of this segement in series data vectors
+    range::UnitRange
+    # index into vector-valued attributes corresponding to this segment
+    attr_index::Int 
+end
+
 # -----------------------------------------------------
 # helper to manage NaN-separated segments
-
-mutable struct SegmentsIterator
+struct NaNSegmentsIterator
     args::Tuple
     n1::Int
     n2::Int
@@ -66,29 +72,47 @@ function iter_segments(args...)
     tup = Plots.wraptuple(args)
     n1 = minimum(map(firstindex, tup))
     n2 = maximum(map(lastindex, tup))
-    SegmentsIterator(tup, n1, n2)
+    NaNSegmentsIterator(tup, n1, n2)
 end
 
-function iter_segments(series::Series, seriestype::Symbol = :path)
+function series_segments(series::Series, seriestype::Symbol = :path)
     x, y, z = series[:x], series[:y], series[:z]
-    if x === nothing
-        return UnitRange{Int}[]
-    elseif has_attribute_segments(series)
-        if any(isnan,y)
-            return [iter_segments(y)...]
-        elseif seriestype in (:scatter, :scatter3d)
-            return [[i] for i in eachindex(y)]
-        else
-            return [i:(i + 1) for i in firstindex(y):lastindex(y)-1]
-        end
+    (x === nothing || isempty(x)) && return UnitRange{Int}[]
+
+    args = RecipesPipeline.is3d(series) ? (x, y, z) : (x, y)
+    nan_segments = collect(iter_segments(args...))
+
+    result = if has_attribute_segments(series)
+        Iterators.flatten(map(nan_segments) do r
+            if 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)
+            end 
+        end)
     else
-        segs = UnitRange{Int}[]
-        args = RecipesPipeline.is3d(series) ? (x, y, z) : (x, y)
-        for seg in iter_segments(args...)
-            push!(segs, seg)
+        (SeriesSegment(r, 1) for r in nan_segments)
+    end 
+
+    seg_range = UnitRange(minimum(first(seg.range) for seg in result),
+                                maximum(last(seg.range) for seg in result))
+    for attr in _segmenting_vector_attributes
+        v = get(series, attr, nothing)
+        if v isa AVec && eachindex(v) != seg_range
+            @warn "Indices $(eachindex(v)) of attribute `$attr` does not match data indices $seg_range."
+            if any(v -> !isnothing(v) && any(isnan, v), (x,y,z))
+                @info """Data contains NaNs or missing values, and indices of `$attr` vector do not match data indices.
+                    If you intend elements of `$attr` to apply to individual NaN-separated segements in the data,
+                    pass each segment in a separate vector instead, and use a row vector for `$attr`. Legend entries 
+                    may be suppressed by passing an empty label.
+                    For example,
+                        plot([1:2,1:3], [[4,5],[3,4,5]], label=["y" ""], $attr=[1 2])
+                    """
+            end
         end
-        return segs
     end
+
+    return result
 end
 
 # helpers to figure out if there are NaN values in a list of array types
@@ -97,7 +121,7 @@ anynan(args::Tuple) = i -> anynan(i,args)
 anynan(istart::Int, iend::Int, args::Tuple) = any(anynan(args), istart:iend)
 allnan(istart::Int, iend::Int, args::Tuple) = all(anynan(args), istart:iend)
 
-function Base.iterate(itr::SegmentsIterator, nextidx::Int = itr.n1)
+function Base.iterate(itr::NaNSegmentsIterator, nextidx::Int = itr.n1)
     i = findfirst(!anynan(itr.args), nextidx:itr.n2)
     i === nothing && return nothing
     nextval = nextidx + i - 1
@@ -107,6 +131,7 @@ function Base.iterate(itr::SegmentsIterator, nextidx::Int = itr.n1)
 
     nextval:nextnan-1, nextnan
 end
+Base.IteratorSize(::NaNSegmentsIterator) = Base.SizeUnknown()
 
 # Find minimal type that can contain NaN and x
 # To allow use of NaN separated segments with categorical x axis
@@ -212,24 +237,24 @@ createSegments(z) = collect(repeat(reshape(z,1,:),2,1))[2:end]
 
 sortedkeys(plotattributes::Dict) = sort(collect(keys(plotattributes)))
 
-function _heatmap_edges(v::AVec, isedges::Bool = false)
-    length(v) == 1 && return v[1] .+ [-0.5, 0.5]
+function _heatmap_edges(v::AVec, isedges::Bool = false, ispolar::Bool = false)
+    length(v) == 1 && return v[1] .+ [ispolar ? max(-v[1], -0.5) : -0.5, 0.5]
     if isedges return v end
     # `isedges = true` means that v is a vector which already describes edges
     # and does not need to be extended.
     vmin, vmax = ignorenan_extrema(v)
-    extra_min = (v[2] - v[1]) / 2
+    extra_min = ispolar ? min(v[1], (v[2] - v[1]) / 2) : (v[2] - v[1]) / 2
     extra_max = (v[end] - v[end - 1]) / 2
     vcat(vmin-extra_min, 0.5 * (v[1:end-1] + v[2:end]), vmax+extra_max)
 end
 
 "create an (n+1) list of the outsides of heatmap rectangles"
-function heatmap_edges(v::AVec, scale::Symbol = :identity, isedges::Bool = false)
+function heatmap_edges(v::AVec, scale::Symbol = :identity, isedges::Bool = false, ispolar::Bool = false)
     f, invf = RecipesPipeline.scale_func(scale), RecipesPipeline.inverse_scale_func(scale)
-    map(invf, _heatmap_edges(map(f,v), isedges))
+    map(invf, _heatmap_edges(map(f,v), isedges, ispolar))
 end
 
-function heatmap_edges(x::AVec, xscale::Symbol, y::AVec, yscale::Symbol, z_size::Tuple{Int, Int})
+function heatmap_edges(x::AVec, xscale::Symbol, y::AVec, yscale::Symbol, z_size::Tuple{Int, Int}, ispolar::Bool = false)
     nx, ny = length(x), length(y)
     # ismidpoints = z_size == (ny, nx) # This fails some tests, but would actually be
     # the correct check, since (4, 3) != (3, 4) and a missleading plot is produced.
@@ -241,7 +266,7 @@ function heatmap_edges(x::AVec, xscale::Symbol, y::AVec, yscale::Symbol, z_size:
                 or `size(z) == (length(y)+1, length(x)+1))` (x & y define edges).""")
     end
     x, y = heatmap_edges(x, xscale, isedges),
-           heatmap_edges(y, yscale, isedges)
+           heatmap_edges(y, yscale, isedges, ispolar) # special handle for `r` in polar plots 
     return x, y
 end
 
@@ -403,79 +428,6 @@ xlims(sp_idx::Int = 1) = xlims(current(), sp_idx)
 ylims(sp_idx::Int = 1) = ylims(current(), sp_idx)
 zlims(sp_idx::Int = 1) = zlims(current(), sp_idx)
 
-# These functions return an operator for use in `get_clims(::Seres, op)`
-process_clims(lims::Tuple{<:Number,<:Number}) = (zlims -> ifelse.(isfinite.(lims), lims, zlims)) ∘ ignorenan_extrema
-process_clims(s::Union{Symbol,Nothing,Missing}) = ignorenan_extrema
-# don't specialize on ::Function otherwise python functions won't work
-process_clims(f) = f
-
-function get_clims(sp::Subplot, op=process_clims(sp[:clims]))
-    zmin, zmax = Inf, -Inf
-    for series in series_list(sp)
-        if series[:colorbar_entry]
-            zmin, zmax = _update_clims(zmin, zmax, get_clims(series, op)...)
-        end
-    end
-    return zmin <= zmax ? (zmin, zmax) : (NaN, NaN)
-end
-
-function get_clims(sp::Subplot, series::Series, op=process_clims(sp[:clims]))
-    zmin, zmax = if series[:colorbar_entry]
-        get_clims(sp, op)
-    else
-        get_clims(series, op)
-    end
-    return zmin <= zmax ? (zmin, zmax) : (NaN, NaN)
-end
-
-"""
-    get_clims(::Series, op=Plots.ignorenan_extrema)
-
-Finds the limits for the colorbar by taking the "z-values" for the series and passing them into `op`,
-which must return the tuple `(zmin, zmax)`. The default op is the extrema of the finite
-values of the input.
-"""
-function get_clims(series::Series, op=ignorenan_extrema)
-    zmin, zmax = Inf, -Inf
-    z_colored_series = (:contour, :contour3d, :heatmap, :histogram2d, :surface, :hexbin)
-    for vals in (series[:seriestype] in z_colored_series ? series[:z] : nothing, series[:line_z], series[:marker_z], series[:fill_z])
-        if (typeof(vals) <: AbstractSurface) && (eltype(vals.surf) <: Union{Missing, Real})
-            zmin, zmax = _update_clims(zmin, zmax, op(vals.surf)...)
-        elseif (vals !== nothing) && (eltype(vals) <: Union{Missing, Real})
-            zmin, zmax = _update_clims(zmin, zmax, op(vals)...)
-        end
-    end
-    return zmin <= zmax ? (zmin, zmax) : (NaN, NaN)
-end
-
-_update_clims(zmin, zmax, emin, emax) = NaNMath.min(zmin, emin), NaNMath.max(zmax, emax)
-
-@enum ColorbarStyle cbar_gradient cbar_fill cbar_lines
-
-function colorbar_style(series::Series)
-    colorbar_entry = series[:colorbar_entry]
-    if !(colorbar_entry isa Bool)
-        @warn "Non-boolean colorbar_entry ignored."
-        colorbar_entry = true
-    end
-
-    if !colorbar_entry
-        nothing
-    elseif isfilledcontour(series)
-        cbar_fill
-    elseif iscontour(series)
-        cbar_lines
-    elseif series[:seriestype] ∈ (:heatmap,:surface) ||
-            any(series[z] !== nothing for z ∈ [:marker_z,:line_z,:fill_z])
-        cbar_gradient
-    else
-        nothing
-    end
-end
-
-hascolorbar(series::Series) = colorbar_style(series) !== nothing
-hascolorbar(sp::Subplot) = sp[:colorbar] != :none && any(hascolorbar(s) for s in series_list(sp))
-
 iscontour(series::Series) = series[:seriestype] in (:contour, :contour3d)
 isfilledcontour(series::Series) = iscontour(series) && series[:fillrange] !== nothing
 
@@ -572,39 +524,34 @@ function get_markerstrokewidth(series, i::Int = 1)
     _cycle(series[:markerstrokewidth], i)
 end
 
+const _segmenting_vector_attributes = (
+    :seriescolor,
+    :seriesalpha,
+    :linecolor,
+    :linealpha,
+    :linewidth,
+    :linestyle,
+    :fillcolor,
+    :fillalpha,
+    :markercolor,
+    :markeralpha,
+    :markersize,
+    :markerstrokecolor,
+    :markerstrokealpha,
+    :markerstrokewidth,
+    :markershape,
+)
+
+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
-    for letter in (:x, :y, :z)
-        # If we have NaNs in the data they define the segments and
-        # SegmentsIterator is used
-        series[letter] !== nothing && NaN in collect(series[letter]) && return false
-    end
     series[:seriestype] == :shape && return false
-    # ... else we check relevant attributes if they have multiple inputs
-    return any(
-        (typeof(series[attr]) <: AbstractVector && length(series[attr]) > 1)
-        for
-        attr in [
-            :seriescolor,
-            :seriesalpha,
-            :linecolor,
-            :linealpha,
-            :linewidth,
-            :linestyle,
-            :fillcolor,
-            :fillalpha,
-            :markercolor,
-            :markeralpha,
-            :markersize,
-            :markerstrokecolor,
-            :markerstrokealpha,
-            :markerstrokewidth,
-            :markershape,
-        ]
-    ) || any(
-        typeof(series[attr]) <: AbstractArray for attr in (:line_z, :fill_z, :marker_z)
-    )
+    # check relevant attributes if they have multiple inputs
+    return any(series[attr] isa AbstractVector && length(series[attr]) > 1
+                for attr in _segmenting_vector_attributes
+        ) || any(series[attr] isa AbstractArray for attr in _segmenting_array_attributes)
 end
 
 function get_aspect_ratio(sp)

test/runtests.jl

@@ -18,12 +18,12 @@ using RecipesBase
     @test Plots.plotly_local_file_path[] === nothing
     temp = Plots.use_local_dependencies[]
     withenv("PLOTS_HOST_DEPENDENCY_LOCAL" => true) do
-        Plots.__init__()
-        @test Plots.plotly_local_file_path[] isa String
-        @test isfile(Plots.plotly_local_file_path[])
-        @test Plots.use_local_dependencies[] = true
-        @test_nowarn Plots._init_ijulia_plotting()
-    end
+    Plots.__init__()
+    @test Plots.plotly_local_file_path[] isa String
+    @test isfile(Plots.plotly_local_file_path[])
+    @test Plots.use_local_dependencies[] = true
+    @test_nowarn Plots._init_ijulia_plotting()
+end
     Plots.plotly_local_file_path[] = nothing
     Plots.use_local_dependencies[] = temp
 end # testset
@@ -43,7 +43,7 @@ reference_dir(args...) = joinpath(homedir(), ".julia", "dev", "PlotReferenceImag
 function reference_file(backend, i, version)
     refdir = reference_dir("Plots", string(backend))
     fn = "ref$i.png"
-    versions = sort(VersionNumber.(readdir(refdir)), rev = true)
+    versions = sort(VersionNumber.(readdir(refdir)), rev=true)
 
     reffn = joinpath(refdir, string(version), fn)
     for v in versions
@@ -107,7 +107,7 @@ const IMG_TOL = VERSION < v"1.4" && Sys.iswindows() ? 1e-1 : is_ci() ? 1e-2 : 1e
         @static if haskey(ENV, "APPVEYOR")
             @info "Skipping GR image comparison tests on AppVeyor"
         else
-            image_comparison_facts(:gr, tol=IMG_TOL, skip = Plots._backend_skips[:gr])
+            image_comparison_facts(:gr, tol=IMG_TOL, skip=Plots._backend_skips[:gr])
         end
     end
 
@@ -139,6 +139,15 @@ const IMG_TOL = VERSION < v"1.4" && Sys.iswindows() ? 1e-1 : is_ci() ? 1e-2 : 1e
         @test isa(display(p), Nothing) == true
     end
 
+    @testset "PlotlyJS" begin
+        @test plotlyjs() == Plots.PlotlyJSBackend()
+        @test backend() == Plots.PlotlyJSBackend()
+
+        p = plot(rand(10))
+        @test isa(p, Plots.Plot) == true
+        @test_broken isa(display(p), Nothing) == true
+    end
+
 end
 
 @testset "Axes" begin
@@ -147,27 +156,40 @@ end
     @test typeof(axis) == Plots.Axis
     @test Plots.discrete_value!(axis, "HI") == (0.5, 1)
     @test Plots.discrete_value!(axis, :yo) == (1.5, 2)
-    @test Plots.ignorenan_extrema(axis) == (0.5,1.5)
+    @test Plots.ignorenan_extrema(axis) == (0.5, 1.5)
     @test axis[:discrete_map] == Dict{Any,Any}(:yo  => 2, "HI" => 1)
 
-    Plots.discrete_value!(axis, ["x$i" for i=1:5])
-    Plots.discrete_value!(axis, ["x$i" for i=0:2])
+    Plots.discrete_value!(axis, ["x$i" for i = 1:5])
+    Plots.discrete_value!(axis, ["x$i" for i = 0:2])
     @test Plots.ignorenan_extrema(axis) == (0.5, 7.5)
 end
 
 @testset "NoFail" begin
-    plots = [histogram([1, 0, 0, 0, 0, 0]),
-             plot([missing]),
-             plot([missing; 1:4]),
-             plot([fill(missing,10); 1:4]),
-             plot([1 1; 1 missing]),
-             plot(["a" "b"; missing "d"], [1 2; 3 4])]
-    for plt in plots
-        display(plt)
+    #ensure backend with tested display
+    @test unicodeplots() == Plots.UnicodePlotsBackend()
+    @test backend() == Plots.UnicodePlotsBackend()
+
+    @testset "Plot" begin
+        plots = [histogram([1, 0, 0, 0, 0, 0]),
+                 plot([missing]),
+                 plot([missing; 1:4]),
+                 plot([fill(missing, 10); 1:4]),
+                 plot([1 1; 1 missing]),
+                 plot(["a" "b"; missing "d"], [1 2; 3 4])]
+        for plt in plots
+            display(plt)
+        end
+        @test_nowarn plot(x -> x^2, 0, 2)
+    end
+
+    @testset "Bar" begin
+       p = bar([3,2,1], [1,2,3]);
+       @test isa(p, Plots.Plot)
+       @test isa(display(p), Nothing) == true
     end
-    @test_nowarn plot(x->x^2,0,2)
 end
 
+
 @testset "EmptyAnim" begin
     anim = @animate for i in []
     end
@@ -175,16 +197,10 @@ end
     @test_throws ArgumentError gif(anim)
 end
 
-@testset "Segments" begin
-    function segments(args...)
-        segs = UnitRange{Int}[]
-        for seg in iter_segments(args...)
-            push!(segs,seg)
-        end
-        segs
-    end
+@testset "NaN-separated Segments" begin
+    segments(args...) = collect(iter_segments(args...))
 
-    nan10 = fill(NaN,10)
+    nan10 = fill(NaN, 10)
     @test segments(11:20) == [1:10]
     @test segments([NaN]) == []
     @test segments(nan10) == []
@@ -196,10 +212,10 @@ end
 end
 
 @testset "Utils" begin
-    zipped = ([(1,2)], [("a","b")], [(1,"a"),(2,"b")],
-              [(1,2),(3,4)], [(1,2,3),(3,4,5)], [(1,2,3,4),(3,4,5,6)],
-              [(1,2.0),(missing,missing)], [(1,missing),(missing,"a")],
-              [(missing,missing)], [(missing,missing,missing),("a","b","c")])
+    zipped = ([(1, 2)], [("a", "b")], [(1, "a"),(2, "b")],
+              [(1, 2),(3, 4)], [(1, 2, 3),(3, 4, 5)], [(1, 2, 3, 4),(3, 4, 5, 6)],
+              [(1, 2.0),(missing, missing)], [(1, missing),(missing, "a")],
+              [(missing, missing)], [(missing, missing, missing),("a", "b", "c")])
     for z in zipped
         @test isequal(collect(zip(Plots.unzip(z)...)), z)
         @test isequal(collect(zip(Plots.unzip(GeometryBasics.Point.(z))...)), z)

test/test_axes.jl

@@ -21,3 +21,13 @@ end # testset
     @test Plots.get_ticks(p2[1], p2[1][:xaxis])[2] == string.('C':3:'Z')
     @test Plots.get_ticks(p3[1], p3[1][:xaxis])[2] == string.('A':'Z')
 end
+
+@testset "Ticks getter functions" begin
+    ticks1 = ([1,2,3], ("a","b","c"))
+    ticks2 = ([4,5], ("e","f"))
+    p1 = plot(1:5, 1:5, 1:5, xticks=ticks1, yticks=ticks1, zticks=ticks1)
+    p2 = plot(1:5, 1:5, 1:5, xticks=ticks2, yticks=ticks2, zticks=ticks2)
+    p = plot(p1, p2)
+    @test xticks(p) == yticks(p) == zticks(p) == [ticks1, ticks2]
+    @test xticks(p[1]) == yticks(p[1]) == zticks(p[1]) == ticks1
+end

test/test_recipes.jl

@@ -31,3 +31,19 @@ end # testset
     sticks = plot(tri, seriestype = :sticks)
     @test length(sticks) == 1
 end
+
+@testset "framestyle axes" begin
+    pl = plot(-1:1, -1:1, -1:1)
+    sp = pl.subplots[1]
+    defaultret = Plots.axis_drawing_info_3d(sp, :x)
+    for letter in [:x, :y, :z]
+        for fr in [:box :semi :origin :zerolines :grid :none]
+            prevha = UInt64(0)
+            push!(sp.attr, :framestyle => fr)
+            ret = Plots.axis_drawing_info_3d(sp, letter)
+            ha = hash(string(ret))
+            @test ha != prevha
+            prevha = ha
+        end
+    end
+end