1.14.0 [skip ci]

* add legend stylings

* fix center and default case

* Update precompile_*.jl file

Co-authored-by: Simon Christ <simonchrist@gmx.de>
Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>

.gitignore

@@ -12,3 +12,4 @@ dev/
 test/tmpplotsave.hdf5
 /.benchmarkci
 /benchmark/*.json
+.vscode/

Project.toml

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

README.md

@@ -18,6 +18,9 @@
 [![][docs-img]][docs-url]
 [![Codecov](https://codecov.io/gh/JuliaPlots/Plots.jl/branch/master/graph/badge.svg)](https://codecov.io/gh/JuliaPlots/Plots.jl)
 
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.4725318.svg)](https://doi.org/10.5281/zenodo.4725318)
+
+
 #### Created by Tom Breloff (@tbreloff)
 
 #### Maintained by the [JuliaPlots members](https://github.com/orgs/JuliaPlots/people)

deps/SnoopCompile/precompile/precompile_Plots.jl

@@ -68,10 +68,16 @@ 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, 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{(: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})
@@ -80,8 +86,12 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide_position, :guidefontvalign, :mirror, :guide), Tuple{Symbol, Symbol, Bool, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guidefonthalign, :guide_position, :mirror, :guide), Tuple{Symbol, Symbol, Bool, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims, :flip, :ticks, :guide), Tuple{Tuple{Int64, Int64}, Bool, StepRange{Int64, Int64}, String}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Float64, Float64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Int64, Float64}}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Int64, Int64}}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(: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{UnitRange{Int64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:shape,), Tuple{Symbol}},typeof(default)})
     Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:titlefont, :legendfontsize, :guidefont, :tickfont, :guide, :framestyle, :yminorgrid), Tuple{Tuple{Int64, String}, Int64, Tuple{Int64, Symbol}, Tuple{Int64, Symbol}, String, Symbol, Bool}},typeof(default)})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
@@ -103,12 +113,15 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype), Tuple{Tuple{Int64, Float64, Symbol}, Vector{Any}, Symbol}},typeof(plot!),Plot{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!),Plot{PlotlyBackend},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:markersize, :c, :seriestype), Tuple{Int64, Symbol, Symbol}},typeof(plot!),Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Plot{GRBackend},Vector{Int64},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!),Plot{PlotlyBackend},Vector{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!),Plot{GRBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!),Plot{PlotlyBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!)})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:w,), Tuple{Int64}},typeof(plot!),Plot{GRBackend},Vector{Float64},Vararg{Any, N} where N})
@@ -118,6 +131,7 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype), Tuple{Vector{Float64}, Tuple{Symbol, Float64, Stroke}, Vector{Float64}, String, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype), Tuple{Vector{Float64}, Tuple{Symbol, Float64, Stroke}, Vector{Float64}, String, Symbol}},typeof(plot!),Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:annotations, :leg), Tuple{Tuple{Int64, Float64, PlotText}, Bool}},typeof(plot),Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:arrow,), Tuple{Int64}},typeof(plot),Vector{Float64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:aspect_ratio, :seriestype), Tuple{Int64, Symbol}},typeof(plot),Vector{String},Vector{String},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}})
@@ -128,7 +142,6 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:lab, :w, :palette, :fill, :α), Tuple{String, Int64, PlotUtils.ContinuousColorGradient, Int64, Float64}},typeof(plot),StepRange{Int64, Int64},Matrix{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label, :title, :xlabel, :linewidth, :legend), Tuple{Matrix{String}, String, String, Int64, Symbol}},typeof(plot),Vector{Function},Float64,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})
@@ -149,7 +162,7 @@ function _precompile_()
     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, :marker, :bg, :fg, :xlim, :ylim, :leg), Tuple{Tuple{Int64, Symbol, Symbol}, Tuple{Shape{Float64, Float64}, 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}}})
@@ -162,6 +175,8 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:projection, :seriestype), Tuple{Symbol, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},UnitRange{Int64},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{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{Matrix{Symbol}, Vector{Symbol}, Int64, Vector{Symbol}}},typeof(plot),Matrix{Float64}})
@@ -184,6 +199,7 @@ function _precompile_()
     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{:barbins}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:barhist}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:bar}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:bins2d}},Any,Any,Any})
@@ -214,6 +230,8 @@ function _precompile_()
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{PlotUtils.ContinuousColorGradient},String})
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}},String})
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{Symbol},String})
+    Base.precompile(Tuple{typeof(_cycle),StepRange{Int64, Int64},Vector{Int64}})
+    Base.precompile(Tuple{typeof(_cycle),Vector{Float64},UnitRange{Int64}})
     Base.precompile(Tuple{typeof(_do_plot_show),Plot{GRBackend},Bool})
     Base.precompile(Tuple{typeof(_heatmap_edges),Vector{Float64},Bool,Bool})
     Base.precompile(Tuple{typeof(_plot!),Plot,Any,Any})
@@ -231,11 +249,13 @@ function _precompile_()
     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),Vector{Float64},Vector{Float64},Vector{Float64},Vararg{Vector{Float64}, N} where N})
     Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64}})
     Base.precompile(Tuple{typeof(error_zipit),Tuple{Vector{Float64}, Vector{Float64}, Vector{Float64}}})
     Base.precompile(Tuple{typeof(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_series_color),Vector{Symbol},Subplot{GRBackend},Int64,Symbol})
     Base.precompile(Tuple{typeof(get_ticks),StepRange{Int64, Int64},Vector{Float64},Vector{Any},Tuple{Int64, Int64},Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Float64, Float64},Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Int64, Float64},Vararg{Any, N} where N})
@@ -248,18 +268,26 @@ function _precompile_()
     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_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Int64,Int64,Shape{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Base.OneTo{Int64},Vector{Float64},Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_markers),Series,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64},Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_markers),Series,UnitRange{Int64},Vector{Float64},Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Vector{Int64},Vector{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},UnitRange{Int64},Tuple{Vector{Float64}, Vector{Float64}},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,StepRange{Int64, Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_segments),Series,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_segments),Series,Vector{Float64},Vector{Float64},Nothing,Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments_3d),Series,Vector{Float64},Vector{Float64},UnitRange{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_get_ticks_size),Tuple{Vector{Int64}, 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),Vector{Float64},Vector{Float64},Function})
     Base.precompile(Tuple{typeof(gr_set_gradient),PlotUtils.ContinuousColorGradient})
     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}}})
@@ -272,31 +300,39 @@ function _precompile_()
     Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol,Vector{Float64},Symbol,Tuple{Int64, Int64},Bool})
     Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol})
     Base.precompile(Tuple{typeof(ignorenan_minimum),Vector{Int64}})
-    Base.precompile(Tuple{typeof(iter_segments),StepRange{Int64, Int64},Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(layout_args),Int64})
-    Base.precompile(Tuple{typeof(ohlc),Any})
+    Base.precompile(Tuple{typeof(make_fillrange_side),UnitRange{Int64},LinRange{Float64}})
+    Base.precompile(Tuple{typeof(make_steps),Vector{Float64},Symbol,Bool})
+    Base.precompile(Tuple{typeof(make_steps),Vector{Int64},Symbol,Bool})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Function})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Symbol})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Int64, Float64},Symbol,Symbol})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Int64, Int64},Symbol,Symbol})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),StepRange{Int64, Int64},Tuple{Int64, Int64},Symbol,Symbol})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),UnitRange{Int64},Tuple{Float64, Float64},Symbol,Symbol})
+    Base.precompile(Tuple{typeof(partialcircle),Int64,Float64,Int64})
     Base.precompile(Tuple{typeof(plot),Any,Any,Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(plot),Any})
+    Base.precompile(Tuple{typeof(processFontArg!),Dict{Symbol, Any},Symbol,Symbol})
+    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},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},Shape{Float64, Float64}})
     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(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(setindex!),GridLayout,EmptyLayout,Int64,Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Base.ReshapedArray{Int64, 2, UnitRange{Int64}, Tuple{}},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{AbsoluteLength},Int64})
     Base.precompile(Tuple{typeof(slice_arg),Matrix{Bool},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{PlotUtils.ContinuousColorGradient},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{RGBA{Float64}},Int64})
     Base.precompile(Tuple{typeof(spy),Any})
     Base.precompile(Tuple{typeof(straightline_data),Tuple{Float64, Float64},Tuple{Float64, Float64},Vector{Float64},Vector{Float64},Int64})
     Base.precompile(Tuple{typeof(stroke),Int64,Vararg{Any, N} where N})
@@ -308,11 +344,6 @@ function _precompile_()
     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(bar, (Any,))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(bar),Any,))
-        end
-    end
     let fbody = try __lookup_kwbody__(which(plot!, (Any,))) catch missing end
         if !ismissing(fbody)
             precompile(fbody, (Any,typeof(plot!),Any,))

src/arg_desc.jl

@@ -165,7 +165,7 @@ const _arg_desc = KW(
 :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`",
+:tick_direction              => "Symbol.  Direction of the ticks. `:in`, `:out` or `:none`",
 :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/axes.jl

@@ -235,6 +235,66 @@ function get_ticks(sp::Subplot, axis::Axis; update = true)
     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[]
@@ -637,17 +697,19 @@ function axis_drawing_info(sp, letter)
         if !(ax[:ticks] in (:none, nothing, false))
             f = RecipesPipeline.scale_func(oax[:scale])
             invf = RecipesPipeline.inverse_scale_func(oax[:scale])
-            tick_start, tick_stop = if sp[:framestyle] == :origin
-                t = invf(f(0) + 0.012 * (f(oamax) - f(oamin)))
-                (-t, t)
-            else
-                ticks_in = ax[:tick_direction] == :out ? -1 : 1
-                t = invf(f(oa1) + 0.012 * (f(oa2) - f(oa1)) * ticks_in)
-                (oa1, t)
+            if ax[:tick_direction] !== :none
+                tick_start, tick_stop = if sp[:framestyle] == :origin
+                    t = invf(f(0) + 0.012 * (f(oamax) - f(oamin)))
+                    (-t, t)
+                else
+                    ticks_in = ax[:tick_direction] == :out ? -1 : 1
+                    t = invf(f(oa1) + 0.012 * (f(oa2) - f(oa1)) * ticks_in)
+                    (oa1, t)
+                end
             end
 
             for tick in ticks[1]
-                if ax[:showaxis]
+                if ax[:showaxis] && ax[:tick_direction] !== :none
                     push!(
                         tick_segments,
                         reverse_if((tick, tick_start), isy),
@@ -774,18 +836,20 @@ function axis_drawing_info_3d(sp, letter)
         if !(ax[:ticks] in (:none, nothing, false))
             f = RecipesPipeline.scale_func(nax[:scale])
             invf = RecipesPipeline.inverse_scale_func(nax[:scale])
-            tick_start, tick_stop = if sp[:framestyle] == :origin
-                t = invf(f(0) + 0.012 * (f(namax) - f(namin)))
-                (-t, t)
-            else
-                ticks_in = ax[:tick_direction] == :out ? -1 : 1
-                t = invf(f(na0) + 0.012 * (f(na1) - f(na0)) * ticks_in)
-                (na0, t)
+            if ax[:tick_direction] !== :none
+                tick_start, tick_stop = if sp[:framestyle] == :origin
+                    t = invf(f(0) + 0.012 * (f(namax) - f(namin)))
+                    (-t, t)
+                else
+                    ticks_in = ax[:tick_direction] == :out ? -1 : 1
+                    t = invf(f(na0) + 0.012 * (f(na1) - f(na0)) * ticks_in)
+                    (na0, t)
+                end
             end
 
             ga0, ga1 = sp[:framestyle] in (:origin, :zerolines) ? (namin, namax) : (na0, na1)
             for tick in ticks[1]
-                if ax[:showaxis]
+                if ax[:showaxis] && ax[:tick_direction] !== :none
                     push!(
                         tick_segments,
                         sort_3d_axes(tick, tick_start, fa0, letter),
@@ -815,7 +879,7 @@ function axis_drawing_info_3d(sp, letter)
                     (na0, t)
                 end
                 for tick in minor_ticks
-                    if ax[:showaxis]
+                    if ax[:showaxis] && ax[:tick_direction] !== :none
                         push!(
                             tick_segments,
                             sort_3d_axes(tick, tick_start, fa0, letter),

src/backends/inspectdr.jl

@@ -363,37 +363,37 @@ function _inspectdr_setupsubplot(sp::Subplot{InspectDRBackend})
         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],
+    #Modify base layout of new object:
+    l = plot.layout.defaults = deepcopy(InspectDR.defaults.plotlayout)
+        #IMPORTANT: Must deepcopy to ensure we don't change layouts of other plots.
+        #Works because plot uses defaults (not user-overwritten `layout.values`)
+        l.frame_canvas.fillcolor = _inspectdr_mapcolor(sp[:background_color_subplot])
+        l.frame_data.fillcolor = _inspectdr_mapcolor(sp[:background_color_inside])
+        l.frame_data.line.color = _inspectdr_mapcolor(xaxis[:foreground_color_axis])
+        l.font_title = InspectDR.Font(sp[:titlefontfamily],
             _inspectdr_mapptsize(sp[:titlefontsize]),
             color = _inspectdr_mapcolor(sp[:titlefontcolor])
         )
         #Cannot independently control fonts of axes with InspectDR:
-        l[:font_axislabel] = InspectDR.Font(xaxis[:guidefontfamily],
+        l.font_axislabel = InspectDR.Font(xaxis[:guidefontfamily],
             _inspectdr_mapptsize(xaxis[:guidefontsize]),
             color = _inspectdr_mapcolor(xaxis[:guidefontcolor])
         )
-        l[:font_ticklabel] = InspectDR.Font(xaxis[:tickfontfamily],
+        l.font_ticklabel = InspectDR.Font(xaxis[:tickfontfamily],
             _inspectdr_mapptsize(xaxis[:tickfontsize]),
             color = _inspectdr_mapcolor(xaxis[:tickfontcolor])
         )
-        l[:enable_legend] = (sp[:legend] != :none)
-        #l[:halloc_legend] = 150 #TODO: compute???
-        l[:font_legend] = InspectDR.Font(sp[:legendfontfamily],
+        l.enable_legend = (sp[:legend] != :none)
+        #l.halloc_legend = 150 #TODO: compute???
+        l.font_legend = InspectDR.Font(sp[:legendfontfamily],
             _inspectdr_mapptsize(sp[:legendfontsize]),
             color = _inspectdr_mapcolor(sp[:legendfontcolor])
         )
-        l[:frame_legend].fillcolor = _inspectdr_mapcolor(sp[:background_color_legend])
-            l[:frame_legend] = l[:frame_legend] #register changes
+        l.frame_legend.fillcolor = _inspectdr_mapcolor(sp[:background_color_legend])
+
+        #_round!() ensures values use integer spacings (looks better on screen):
+        InspectDR._round!(InspectDR.autofit2font!(l, legend_width=10.0)) #10 "em"s wide
+    return
 end
 
 # called just before updating layout bounding boxes... in case you need to prep

src/backends/pgfplotsx.jl

@@ -131,9 +131,6 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
             axis_height = sp_height - (tpad + bpad)
             axis_width = sp_width - (rpad + lpad)
 
-            cstr = plot_color(sp[:background_color_legend])
-            a = alpha(cstr)
-            fg_alpha = alpha(plot_color(sp[:foreground_color_legend]))
             title_cstr = plot_color(sp[:titlefontcolor])
             title_a = alpha(title_cstr)
             title_loc = sp[:titlelocation]
@@ -142,7 +139,6 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
             axis_opt = PGFPlotsX.Options(
                 "point meta max" => get_clims(sp)[2],
                 "point meta min" => get_clims(sp)[1],
-                "legend cell align" => "left",
                 "title" => sp[:title],
                 "title style" => PGFPlotsX.Options(
                         pgfx_get_title_pos(title_loc)...,
@@ -154,22 +150,7 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
                     "draw opacity" => title_a,
                     "rotate" => sp[:titlefontrotation],
                 ),
-                "legend style" => PGFPlotsX.Options(
-                    pgfx_linestyle(
-                        pgfx_thickness_scaling(sp),
-                        sp[:foreground_color_legend],
-                        fg_alpha,
-                        "solid",
-                    ) => nothing,
-                    "fill" => cstr,
-                    "fill opacity" => a,
-                    "text opacity" => alpha(plot_color(sp[:legendfontcolor])),
-                    "font" => pgfx_font(
-                        sp[:legendfontsize],
-                        pgfx_thickness_scaling(sp),
-                    ),
-                    "text" => plot_color(sp[:legendfontcolor]),
-                ),
+                "legend style" => pgfx_get_legend_style(sp),
                 "axis background/.style" => PGFPlotsX.Options(
                     "fill" => bgc_inside,
                     "opacity" => bgc_inside_a,
@@ -183,8 +164,6 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
             nothing
             sp_height > 0 * mm ? push!(axis_opt, "height" => string(axis_height)) :
             nothing
-            # legend position
-            push!(axis_opt["legend style"], pgfx_get_legend_pos(sp[:legend])...)
             for letter in (:x, :y, :z)
                 if letter != :z || RecipesPipeline.is3d(sp)
                     pgfx_axis!(axis_opt, sp, letter)
@@ -225,16 +204,22 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
             @label colorbar_end
 
             if hascolorbar(sp)
+                cticks = get_colorbar_ticks(sp)[2]
                 colorbar_style = PGFPlotsX.Options(
                     "title" => sp[:colorbar_title],
-                    "xticklabel style" => pgfx_get_ticklabel_style(sp, sp[:xaxis]),
-                    "yticklabel style" => pgfx_get_ticklabel_style(sp, sp[:yaxis]),
                 )
                 if sp[:colorbar] === :top
                     push!(colorbar_style,
                         "at" => string((0.5, 1.05)),
                         "anchor" => "south",
+                        "xtick" => string("{", join(cticks, ","), "}"),
                         "xticklabel pos" => "upper",
+                        "xticklabel style" => pgfx_get_colorbar_ticklabel_style(sp),
+                    )
+                else
+                    push!(colorbar_style,
+                        "ytick" => string("{", join(cticks, ","), "}"),
+                        "yticklabel style" => pgfx_get_colorbar_ticklabel_style(sp),
                     )
                 end
                 push!(
@@ -242,6 +227,8 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
                     string("colorbar", pgfx_get_colorbar_pos(sp[:colorbar])) => nothing,
                     "colorbar style" => colorbar_style,
                 )
+            else
+                push!(axis_opt, "colorbar" => "false") 
             end
             if RecipesPipeline.is3d(sp)
                 azim, elev = sp[:camera]
@@ -791,6 +778,31 @@ function pgfx_get_legend_pos(v::Tuple{S,Symbol}) where S <: Real
     return ("at"=>"$(string(legend_pos_from_angle(v[1],rect...)))", "anchor"=>anchor)
 end
 
+function pgfx_get_legend_style(sp)
+    cstr = plot_color(sp[:background_color_legend])
+    a = alpha(cstr)
+    fg_alpha = alpha(plot_color(sp[:foreground_color_legend]))
+    legfont = legendfont(sp)
+    PGFPlotsX.Options(
+        pgfx_linestyle(
+            pgfx_thickness_scaling(sp),
+            sp[:foreground_color_legend],
+            fg_alpha,
+            "solid",
+        ) => nothing,
+        "fill" => cstr,
+        "fill opacity" => a,
+        "text opacity" => alpha(plot_color(sp[:legendfontcolor])),
+        "font" => pgfx_font(
+            sp[:legendfontsize],
+            pgfx_thickness_scaling(sp),
+        ),
+        "text" => plot_color(sp[:legendfontcolor]),
+        "cells" => PGFPlotsX.Options("anchor" => get((left = "west", right = "east", hcenter = "center"), legfont.halign, "west")),
+        pgfx_get_legend_pos(sp[:legend])...,
+    )
+end
+
 pgfx_get_colorbar_pos(s) =
     get((left = " left", bottom = " horizontal", top = " horizontal"), s, "")
 pgfx_get_colorbar_pos(b::Bool) = ""
@@ -809,15 +821,23 @@ function pgfx_get_ticklabel_style(sp, axis)
     return PGFPlotsX.Options(
         "font" => pgfx_font(
             axis[:tickfontsize], pgfx_thickness_scaling(sp)
-        ),
-        "color" => cstr,
+        ), "color" => cstr,
         "draw opacity" => alpha(cstr),
         "rotate" => axis[:tickfontrotation],
     )
 end
 
+function pgfx_get_colorbar_ticklabel_style(sp)
+    cstr = plot_color(sp[:colorbar_tickfontcolor])
+    return PGFPlotsX.Options(
+        "font" => pgfx_font(
+            sp[:colorbar_tickfontsize], pgfx_thickness_scaling(sp)
+        ), "color" => cstr,
+        "draw opacity" => alpha(cstr),
+        "rotate" => sp[:colorbar_tickfontrotation],
+    )
+end
 ## --------------------------------------------------------------------------------------
-# Generates a colormap for pgfplots based on a ColorGradient
 pgfx_arrow(::Nothing) = "every arrow/.append style={-}"
 function pgfx_arrow(arr::Arrow, side = arr.side)
     components = String[]
@@ -848,6 +868,7 @@ function pgfx_filllegend!(series_opt, opt)
               }""")
 end
 
+# Generates a colormap for pgfplots based on a ColorGradient
 pgfx_colormap(cl::PlotUtils.AbstractColorList) = pgfx_colormap(color_list(cl))
 function pgfx_colormap(v::Vector{<:Colorant})
     join(map(v) do c
@@ -1261,11 +1282,18 @@ function pgfx_axis!(opt::PGFPlotsX.Options, sp::Subplot, letter)
         else
             push!(opt, string(letter, "ticklabels") => "{}")
         end
-        push!(
-            opt,
-            string(letter, "tick align") =>
-                (axis[:tick_direction] == :out ? "outside" : "inside"),
-        )
+        if axis[:tick_direction] === :none
+            push!(
+                opt,
+                string(letter, "tick style") => "draw=none",
+            )
+        else
+            push!(
+                opt,
+                string(letter, "tick align") =>
+                    (axis[:tick_direction] == :out ? "outside" : "inside"),
+            )
+        end
         push!(
             opt, string(letter, "ticklabel style") => pgfx_get_ticklabel_style(sp, axis)
         )

src/backends/plotly.jl

@@ -143,7 +143,8 @@ function plotly_axis(axis, sp, anchor = nothing, domain = nothing)
         :zerolinecolor => rgba_string(axis[:foreground_color_axis]),
         :showline   => framestyle in (:box, :axes) && axis[:showaxis],
         :linecolor  => rgba_string(plot_color(axis[:foreground_color_axis])),
-        :ticks      => axis[:tick_direction] == :out ? "outside" : "inside",
+        :ticks      => axis[:tick_direction] === :out ? "outside" : 
+                       axis[:tick_direction] === :in ? "inside" : "",
         :mirror     => framestyle == :box,
         :showticklabels => axis[:showaxis],
     )
@@ -662,7 +663,7 @@ function plotly_series(plt::Plot, series::Series)
 end
 
 function plotly_series_shapes(plt::Plot, series::Series, clims)
-    segments = collect(series_segments(series))
+    segments = series_segments(series)
     plotattributes_outs = Vector{KW}(undef, length(segments))
 
     # TODO: create a plotattributes_out for each polygon
@@ -681,7 +682,7 @@ function plotly_series_shapes(plt::Plot, series::Series, clims)
         for (letter, data) in zip((:x, :y), shape_data(series, 100))
     )
 
-    for segment in segments
+    for (k, segment) in enumerate(segments)
         i, rng = segment.attr_index, segment.range
         length(rng) < 2 && continue
 
@@ -701,10 +702,10 @@ function plotly_series_shapes(plt::Plot, series::Series, clims)
                 :dash => string(get_linestyle(series, i)),
             )
         end
-        plotattributes_out[:showlegend] = i==1 ? should_add_to_legend(series) : false
+        plotattributes_out[:showlegend] = k==1 ? should_add_to_legend(series) : false
         plotly_polar!(plotattributes_out, series)
         plotly_hover!(plotattributes_out, _cycle(series[:hover], i))
-        plotattributes_outs[i] = plotattributes_out
+        plotattributes_outs[k] = plotattributes_out
     end
     if series[:fill_z] !== nothing
         push!(plotattributes_outs, plotly_colorbar_hack(series, plotattributes_base, :fill))

src/backends/pyplot.jl

@@ -1022,7 +1022,7 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
             cbar_axis."set_tick_params"(
                 direction = axis[:tick_direction] == :out ? "out" : "in",
                 width=py_thickness_scale(plt, intensity),
-                length= 5 * py_thickness_scale(plt, intensity)
+                length = axis[:tick_direction] == :none ? 0 : 5 * py_thickness_scale(plt, intensity)
             )
 
 
@@ -1137,7 +1137,7 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
             pyaxis."set_tick_params"(
                 direction = axis[:tick_direction] == :out ? "out" : "in",
                 width=py_thickness_scale(plt, intensity),
-                length= 5 * py_thickness_scale(plt, intensity)
+                length = axis[:tick_direction] == :none ? 0 : 5 * py_thickness_scale(plt, intensity)
                                      )
 
             getproperty(ax, Symbol("set_", letter, "label"))(axis[:guide])
@@ -1176,7 +1176,8 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
                 pyaxis."set_tick_params"(
                     which = "minor",
                     direction = axis[:tick_direction] == :out ? "out" : "in",
-                    width=py_thickness_scale(plt, intensity))
+                    length = axis[:tick_direction] == :none ? 0 : py_thickness_scale(plt, intensity),
+                )
             end
 
             if axis[:minorgrid]
@@ -1186,7 +1187,8 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
                 pyaxis."set_tick_params"(
                     which = "minor",
                     direction = axis[:tick_direction] == :out ? "out" : "in",
-                    width=py_thickness_scale(plt, intensity))
+                    length = axis[:tick_direction] == :none ? 0 : py_thickness_scale(plt, intensity)
+                )
 
                 pyaxis."grid"(true,
                     which = "minor",

src/components.jl

@@ -9,9 +9,9 @@ compute_angle(v::P2) = (angle = atan(v[2], v[1]); angle < 0 ? 2π - angle : angl
 
 # -------------------------------------------------------------
 
-struct Shape
-    x::Vector{Float64}
-    y::Vector{Float64}
+struct Shape{X<:Number, Y<:Number}
+    x::Vector{X}
+    y::Vector{Y}
     # function Shape(x::AVec, y::AVec)
     #     # if x[1] != x[end] || y[1] != y[end]
     #     #     new(vcat(x, x[1]), vcat(y, y[1]))
@@ -52,7 +52,7 @@ end
 
 "get an array of tuples of points on a circle with radius `r`"
 function partialcircle(start_θ, end_θ, n = 20, r=1)
-    Tuple{Float64,Float64}[(r*cos(u),r*sin(u)) for u in range(start_θ, stop=end_θ, length=n)]
+    [(r*cos(u), r*sin(u)) for u in range(start_θ, stop=end_θ, length=n)]
 end
 
 "interleave 2 vectors into each other (like a zipper's teeth)"
@@ -205,9 +205,12 @@ function rotate!(shape::Shape, Θ::Real, c = center(shape))
 end
 
 "rotate an object in space"
-function rotate(shape::Shape, Θ::Real, c = center(shape))
-    shapecopy = deepcopy(shape)
-    rotate!(shapecopy, Θ, c)
+function rotate(shape::Shape, θ::Real, c = center(shape))
+    x, y = coords(shape)
+    cx, cy = c
+    x_new = rotate_x.(x, y, θ, cx, cy)
+    y_new = rotate_y.(x, y, θ, cx, cy)
+    Shape(x_new, y_new)
 end
 
 # -----------------------------------------------------------------------

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

@@ -1,6 +1,11 @@
 using Plots, Test
 
 @testset "Shapes" begin
+    @testset "Type" begin
+        square = Shape([(0,0.0),(1,0.0),(1,1.0),(0,1.0)])
+        @test isa(square, Shape{Int64, Float64})
+    end
+
     @testset "Copy" begin
         square = Shape([(0,0),(1,0),(1,1),(0,1)])
         square2 = Shape(square)