1.18.0 [skip ci]

Gnuplot (GASTON) backend testing (#3177 )
* gnuplot * minimal working gnuplot * more params * new series and axis params * saving figures * gnuplot version 0.1
2021-07-05 17:53:42 +02:00 · 2021-07-05 17:52:59 +02:00 · 2021-07-05 15:19:03 +02:00 · 2021-07-05 15:16:19 +02:00 · 2021-07-05 15:01:53 +02:00 · 2021-07-05 13:25:20 +02:00
17 changed files with 666 additions and 203 deletions
@@ -1,7 +1,7 @@
 name = "Plots"
 uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
 author = ["Tom Breloff (@tbreloff)"]
-version = "1.16.7"
+version = "1.18.0"

 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
@@ -68,32 +68,20 @@ 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})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :minorgrid, :guide), Tuple{Bool, Bool, String}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :minorgrid, :mirror, :guide), Tuple{Bool, Bool, Bool, String}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid,), Tuple{Bool}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:gridlinewidth, :grid, :gridalpha, :gridstyle, :foreground_color_grid), Tuple{Int64, Bool, Float64, Symbol, RGBA{Float64}}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide,), Tuple{String}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide_position, :guidefontvalign, :mirror, :guide), Tuple{Symbol, Symbol, Bool, String}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guidefonthalign, :guide_position, :mirror, :guide), Tuple{Symbol, Symbol, Bool, String}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims, :flip, :ticks, :guide), Tuple{Tuple{Int64, Int64}, Bool, StepRange{Int64, Int64}, String}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Float64, Float64}}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Int64, Float64}}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Int64, Int64}}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(: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{(:shape,), Tuple{Symbol}},typeof(default)})
    Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:titlefont, :legendfontsize, :guidefont, :tickfont, :guide, :framestyle, :yminorgrid), Tuple{Tuple{Int64, String}, Int64, Tuple{Int64, Symbol}, Tuple{Int64, Symbol}, String, Symbol, Bool}},typeof(default)})
    Base.precompile(Tuple{Core.kwftype(typeof(font)),NamedTuple{(:family, :pointsize, :halign, :valign, :rotation, :color), Tuple{String, Int64, Symbol, Symbol, Float64, RGBA{Float64}}},typeof(font)})
@@ -103,70 +91,67 @@ function _precompile_()
    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),UnitRange{Int64},UnitRange{Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),UnitRange{Int64},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),Vector{Int64},Vector{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(gr_set_font)),NamedTuple{(:halign, :valign, :rotation, :color), Tuple{Symbol, Symbol, Int64, RGBA{Float64}}},typeof(gr_set_font),Font,Subplot{GRBackend}})
    Base.precompile(Tuple{Core.kwftype(typeof(hline!)),Any,typeof(hline!),Any})
-    Base.precompile(Tuple{Core.kwftype(typeof(pie)),Any,typeof(pie),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{(:layout, :margin), Tuple{GridLayout, AbsoluteLength}},typeof(plot!),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:legend,), Tuple{Bool}},typeof(plot!),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:legend,), Tuple{Bool}},typeof(plot!),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot!),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot!),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
    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{(:lw, :color), Tuple{Int64, Symbol}},typeof(plot!),Function,Float64,Irrational{:π}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:lw, :color), Tuple{Int64, Symbol}},typeof(plot!),Plot{GRBackend},Function,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{GRBackend},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype), Tuple{Tuple{Int64, Float64, Symbol}, Vector{Any}, Symbol}},typeof(plot!),Plot{PlotlyBackend},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype), Tuple{Tuple{Int64, Float64, Symbol}, Vector{Any}, Symbol}},typeof(plot!),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:markersize, :c, :seriestype), Tuple{Int64, Symbol, Symbol}},typeof(plot!),Plot{GRBackend},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:markersize, :c, :seriestype), Tuple{Int64, Symbol, Symbol}},typeof(plot!),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!),Plot{GRBackend},Vector{Int64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Plot{PlotlyBackend},Vector{Int64},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Vector{Int64},Vector{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Plot{GRBackend},Vector{Int64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Vector{Int64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!),Plot{GRBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!),Plot{PlotlyBackend}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!)})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:w,), Tuple{Int64}},typeof(plot!),Plot{GRBackend},Vector{Float64},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{(: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{(:aspect_ratio, :seriestype), Tuple{Int64, Symbol}},typeof(plot),Vector{String},Vector{String},Matrix{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:bins, :weights, :seriestype), Tuple{Symbol, Vector{Int64}, Symbol}},typeof(plot),Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:color, :line, :marker), Tuple{Matrix{Symbol}, Tuple{Symbol, Int64}, Tuple{Matrix{Symbol}, Int64, Float64, Stroke}}},typeof(plot),Vector{Vector{T} where T}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:connections, :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{(:connections, :seriestype), Tuple{Tuple{Vector{Int64}, Vector{Int64}, Vector{Int64}}, Symbol}},typeof(plot),Vector{Int64},Vector{Int64},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:fill, :seriestype), Tuple{Bool, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Function})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(: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, :title, :xlabel, :linewidth, :legend), Tuple{Matrix{String}, String, String, Int64, Symbol}},typeof(plot),Vector{Function},Float64,Float64})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label,), Tuple{Matrix{String}}},typeof(plot),Vector{AbstractVector{Float64}}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(: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, :label, :fillrange, :fillalpha), Tuple{Tuple{Int64, Int64}, String, Int64, Float64}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :label, :fillrange, :fillalpha), Tuple{Tuple{Int64, Int64}, String, Int64, Float64}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :link), Tuple{Int64, Symbol}},typeof(plot),Plot{GRBackend},Plot{GRBackend}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :link), Tuple{Int64, Symbol}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :margin), Tuple{GridLayout, AbsoluteLength}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :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{(:layout, :xlims), Tuple{GridLayout, Tuple{Int64, Float64}}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout,), Tuple{Tuple{Int64, Int64}}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout,), Tuple{Tuple{Int64, Int64}}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Bool}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Bool}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot),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, :leg, :fill), Tuple{Int64, Bool, Tuple{Int64, Symbol}}},typeof(plot),Function,Function,Int64,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{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, :markersize, :lab, :bg, :xlim, :ylim, :seriestype), Tuple{Matrix{Symbol}, Int64, Matrix{String}, Symbol, Tuple{Int64, Int64}, Tuple{Int64, Int64}, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Matrix{Float64}})
@@ -177,34 +162,31 @@ function _precompile_()
    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{(:projection, :seriestype), Tuple{Symbol, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},UnitRange{Int64},Matrix{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:quiver, :seriestype), Tuple{Tuple{Vector{Float64}, Vector{Float64}, Vector{Float64}}, Symbol}},typeof(plot),Vector{Float64},Vector{Float64},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:reg, :fill), Tuple{Bool, Tuple{Int64, Symbol}}},typeof(plot),Vector{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{Int64}},typeof(plot),UnitRange{Int64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}},typeof(plot),UnitRange{Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{Tuple{LinRange{Float64}, LinRange{Float64}}}},typeof(plot),UnitRange{Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{typeof(sqrt)}},typeof(plot),UnitRange{Int64}})
    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),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot),Vector{DateTime},UnitRange{Int64},Matrix{Float64}})
    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{(:st, :xlabel, :ylabel, :zlabel), Tuple{Symbol, String, String, String}},typeof(plot),Vector{Float64},Vector{Float64},Vector{Float64}})
    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, :xflip, :yflip, :zflip, :zlabel, :grid, :ylabel, :minorgrid, :xlabel, :seriestype), Tuple{String, Bool, Bool, Bool, String, Bool, String, Bool, String, Symbol}},typeof(plot),Vector{Float64},Vector{Float64},Function})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title, :xmirror, :ymirror, :zmirror, :zlabel, :grid, :ylabel, :minorgrid, :xlabel, :seriestype), Tuple{String, Bool, Bool, Bool, String, Bool, String, Bool, String, Symbol}},typeof(plot),Vector{Float64},Vector{Float64},Function})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title, :zlabel, :grid, :ylabel, :minorgrid, :xlabel, :seriestype), Tuple{String, String, Bool, String, Bool, String, Symbol}},typeof(plot),Vector{Float64},Vector{Float64},Function})
    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(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},UnitRange{Int64}})
    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{Vector{Int64}, Bool}},typeof(test_examples),Symbol})
    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{: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})
@@ -213,7 +195,6 @@ function _precompile_()
    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{:spy}},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})
@@ -236,12 +217,7 @@ function _precompile_()
    Base.precompile(Tuple{typeof(_cbar_unique),Vector{PlotUtils.ContinuousColorGradient},String})
    Base.precompile(Tuple{typeof(_cbar_unique),Vector{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}},String})
    Base.precompile(Tuple{typeof(_cbar_unique),Vector{Symbol},String})
-    Base.precompile(Tuple{typeof(_cycle),Base.OneTo{Int64},Vector{Int64}})
-    Base.precompile(Tuple{typeof(_cycle),StepRange{Int64, Int64},Vector{Int64}})
-    Base.precompile(Tuple{typeof(_cycle),Vector{Float64},StepRange{Int64, Int64}})
-    Base.precompile(Tuple{typeof(_cycle),Vector{Float64},UnitRange{Int64}})
    Base.precompile(Tuple{typeof(_do_plot_show),Plot{GRBackend},Bool})
-    Base.precompile(Tuple{typeof(_heatmap_edges),Vector{Float64},Bool,Bool})
    Base.precompile(Tuple{typeof(_plot!),Plot,Any,Any})
    Base.precompile(Tuple{typeof(_preprocess_barlike),DefaultsDict,Base.OneTo{Int64},Vector{Float64}})
    Base.precompile(Tuple{typeof(_preprocess_binlike),DefaultsDict,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
@@ -250,21 +226,19 @@ function _precompile_()
    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(axis_limits),Subplot{GRBackend},Symbol,Bool,Bool})
+    Base.precompile(Tuple{typeof(axis_limits),Subplot{PlotlyBackend},Symbol,Bool,Bool})
    Base.precompile(Tuple{typeof(backend),PlotlyBackend})
    Base.precompile(Tuple{typeof(bbox),AbsoluteLength,AbsoluteLength,AbsoluteLength,AbsoluteLength})
    Base.precompile(Tuple{typeof(bbox),Float64,Float64,Float64,Float64})
-    Base.precompile(Tuple{typeof(build_layout),GridLayout,Int64})
-    Base.precompile(Tuple{typeof(contour),Any,Vararg{Any, N} where N})
-    Base.precompile(Tuple{typeof(convertLegendValue),Symbol})
+    Base.precompile(Tuple{typeof(bottompad),EmptyLayout})
+    Base.precompile(Tuple{typeof(build_layout),GridLayout,Int64,Vector{Plot}})
    Base.precompile(Tuple{typeof(convert_to_polar),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64},Tuple{Int64, Float64}})
    Base.precompile(Tuple{typeof(create_grid),Expr})
-    Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64},Vararg{Vector{Float64}, N} where N})
    Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64}})
    Base.precompile(Tuple{typeof(error_zipit),Tuple{Vector{Float64}, Vector{Float64}, Vector{Float64}}})
-    Base.precompile(Tuple{typeof(expand_extrema!),Axis,Base.OneTo{Int64}})
    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})
@@ -273,7 +247,7 @@ function _precompile_()
    Base.precompile(Tuple{typeof(get_xy),OHLC{Float64},Int64,Float64})
    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_add_legend),Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), Tuple{Int64, Int64, Int64, Float64, Int64, Float64, Float64, Float64, Float64}},Vector{Float64}})
    Base.precompile(Tuple{typeof(gr_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}})
@@ -282,8 +256,7 @@ function _precompile_()
    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Int64,Int64,Shape{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Float64,Tuple{Float64, Float64},Int64,Float64,Int64,Symbol})
    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Int64,Tuple{Float64, Float64},Int64,Int64,Int64,Symbol})
-    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Base.OneTo{Int64},Vector{Float64},Tuple{Float64, Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_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},Int64,Int64})
    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}})
@@ -293,14 +266,12 @@ function _precompile_()
    Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Vector{Float64},Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_fill_viewport),Vector{Float64},RGBA{Float64}})
    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}}})
+    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, Int64, Int64, 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,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Symbol,Tuple{Int64, Int64},Bool})
@@ -311,7 +282,7 @@ function _precompile_()
    Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol})
    Base.precompile(Tuple{typeof(ignorenan_minimum),Vector{Int64}})
    Base.precompile(Tuple{typeof(layout_args),Int64})
-    Base.precompile(Tuple{typeof(make_fillrange_side),UnitRange{Int64},LinRange{Float64}})
+    Base.precompile(Tuple{typeof(make_fillrange_side),UnitRange{Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}})
    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Function})
    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Symbol})
    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Int64, Float64},Symbol,Symbol})
@@ -319,29 +290,26 @@ function _precompile_()
    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,Any})
    Base.precompile(Tuple{typeof(plot),Any})
-    Base.precompile(Tuple{typeof(processFillArg),Dict{Symbol, Any},Symbol})
-    Base.precompile(Tuple{typeof(processGridArg!),DefaultsDict,Bool,Symbol})
+    Base.precompile(Tuple{typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{typeof(plot),Plot{GRBackend},Plot{GRBackend}})
+    Base.precompile(Tuple{typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
+    Base.precompile(Tuple{typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend}})
    Base.precompile(Tuple{typeof(processGridArg!),Dict{Symbol, Any},Symbol,Symbol})
    Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},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{Float64, Float64}})
-    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Stroke})
    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Symbol})
    Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,PlotText})
    Base.precompile(Tuple{typeof(process_annotation),Subplot{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},String,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(slice_arg),Base.ReshapedArray{Int64, 2, UnitRange{Int64}, Tuple{}},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Matrix{Bool},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Matrix{Int64},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Matrix{PlotUtils.ContinuousColorGradient},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Matrix{RGBA{Float64}},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Matrix{String},Int64})
+    Base.precompile(Tuple{typeof(resetfontsizes)})
    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})
@@ -353,11 +321,8 @@ 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(gr_polyline, (Vector{Float64},Vector{Float64},typeof(GR.fillarea),))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Symbol,Symbol,typeof(gr_polyline),Vector{Float64},Vector{Float64},typeof(GR.fillarea),))
-        end
-    end
+    isdefined(Plots, Symbol("#add_major_or_minor_segments#126")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#126")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64}},Float64,Bool})
+    isdefined(Plots, Symbol("#add_major_or_minor_segments#127")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#127")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64, Float64}},Float64,Bool})
    let fbody = try __lookup_kwbody__(which(plot!, (Any,))) catch missing end
        if !ismissing(fbody)
            precompile(fbody, (Any,typeof(plot!),Any,))
@@ -378,11 +343,6 @@ function _precompile_()
            precompile(fbody, (Any,typeof(plot),Any,Vararg{Any, N} where N,))
        end
    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,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,))
@@ -853,15 +853,17 @@ function axis_drawing_info_3d(sp, letter)
                        )
                    end
                    if grid
+                        fa0_, fa1_ = reverse_if((fa0, fa1), ax[:mirror])
+                        ga0_, ga1_ = reverse_if((ga0, ga1), ax[:mirror])
                        push!(
                            segments,
-                            sort_3d_axes(tick, ga0, fa0, letter),
-                            sort_3d_axes(tick, ga1, fa0, letter),
+                            sort_3d_axes(tick, ga0_, fa0_, letter),
+                            sort_3d_axes(tick, ga1_, fa0_, letter),
                        )
                        push!(
                            segments,
-                            sort_3d_axes(tick, ga1, fa0, letter),
-                            sort_3d_axes(tick, ga1, fa1, letter),
+                            sort_3d_axes(tick, ga1_, fa0_, letter),
+                            sort_3d_axes(tick, ga1_, fa1_, letter),
                        )
                    end
                end
@@ -256,6 +256,7 @@ end
@init_backend PGFPlotsX
@init_backend InspectDR
@init_backend HDF5
+@init_backend Gaston

 # ---------------------------------------------------------

@@ -574,6 +575,92 @@ const _pyplot_style = [:auto, :solid, :dash, :dot, :dashdot]
 const _pyplot_marker = vcat(_allMarkers, :pixel)
 const _pyplot_scale = [:identity, :ln, :log2, :log10]

+# ------------------------------------------------------------------------------
+# Gaston
+
+function _initialize_backend(::GastonBackend)
+    @eval Main begin
+        import Gaston
+        export Gaston
+    end
+end
+
+const _gaston_attr = merge_with_base_supported([
+    # :annotations,
+    # :background_color_legend,
+    # :background_color_inside,
+    # :background_color_outside,
+    # :foreground_color_legend,
+    # :foreground_color_grid, :foreground_color_axis,
+    # :foreground_color_text, :foreground_color_border,
+    :label,
+    # :seriescolor, :seriesalpha,
+    :linecolor, :linestyle, :linewidth, :linealpha,
+    :markershape, :markercolor, :markersize, :markeralpha,
+    # :markerstrokewidth, :markerstrokecolor, :markerstrokealpha, :markerstrokestyle,
+    # :fillrange, :fillcolor, :fillalpha,
+    # :bins,
+    # :bar_width, :bar_edges,
+    # :title,
+    # :window_title,
+    :guide,
+    # :guide_position,
+    :lims, :ticks, :scale, # :flip, :rotation,
+    :tickfont, :guidefont,
+    # :legendfont,
+    # :grid, :legend,
+    # :colorbar, :colorbar_title,
+    # :fill_z, :line_z, :marker_z, :levels,
+    # :ribbon, :quiver, :arrow,
+    # :orientation,
+    # :overwrite_figure,
+    # :polar,
+    # :normalize, :weights, :contours,
+    # :aspect_ratio,
+    :tick_direction,
+    # :framestyle,
+    # :camera,
+    # :contour_labels,
+  ])
+const _gaston_seriestype = [:path,
+                            # :path3d,
+                            :scatter,
+                            :steppre,
+                            # :stepmid,
+                            :steppost,
+                            # :histogram2d,
+                            # :ysticks, :xsticks,
+                            # :contour,
+                            :shape,
+                            # :straightline,
+                            ]
+
+const _gaston_style = [:auto,
+                       :solid,
+                       :dash,
+                       :dot,
+                       :dashdot,
+                       :dashdotdot
+                       ]
+
+const _gaston_marker = [:none,
+                        # :auto,
+                        :circle,
+                        :rect,
+                        :diamond,
+                        :utriangle,
+                        :dtriangle,
+                        :pentagon,
+                        :x,
+                        :+
+                        ] #vcat(_allMarkers, Shape)
+
+const _gaston_scale = [:identity,
+                       # :ln,
+                       # :log2,
+                       :log10,
+                       ]
+
 # ------------------------------------------------------------------------------
 # unicodeplots

@@ -0,0 +1,331 @@
+# https://github.com/mbaz/Gaston.
+const G = Gaston
+const GastonSubplot = G.Plot
+const GASTON_MARKER_SCALING = 1.3 / 5.0
+const GNUPLOT_DPI = 72  # Compensate for DPI with increased resolution
+
+#
+# --------------------------------------------
+# These functions are called by Plots
+# --------------------------------------------
+#
+# Create the window/figure for this backend.
+function _create_backend_figure(plt::Plot{GastonBackend})
+    xsize = plt.attr[:size][1]
+    ysize = plt.attr[:size][2]
+    G.set(termopts="""size $xsize,$ysize""")
+
+    state_handle = G.nexthandle() # for now all the figures will be kept
+    plt.o = G.newfigure(state_handle)
+end
+
+
+function _before_layout_calcs(plt::Plot{GastonBackend})
+    # Initialize all the subplots first
+    plt.o.subplots = G.SubPlot[]
+    grid = size(plt.layout)
+    plt.o.layout = grid
+
+
+    for sp in plt.subplots
+        gaston_init_subplot(plt, sp)
+    end
+
+    # Then add the series (curves in gaston)
+    for series in plt.series_list
+        gaston_add_series(plt, series)
+    end
+end
+
+function _update_min_padding!(sp::Subplot{GastonBackend})
+    sp.minpad = (20mm, 5mm, 2mm, 10mm)
+end
+
+function _update_plot_object(plt::Plot{GastonBackend})
+end
+
+for (mime, term) in (
+    "application/eps"         => "epscairo",   # NEED fixing TODO
+    "image/eps"               => "epslatex",   # NEED fixing TODO
+    "application/pdf"         => "pdfcairo",   # NEED fixing TODO
+    "application/postscript"  => "postscript", # NEED fixing TODO
+    "image/svg+xml"           => "svg",
+    "text/latex"              => "tikz",       # NEED fixing TODO
+    "application/x-tex"       => "epslatex",   # NEED fixing TODO
+    "text/plain"              => "dumb",       # NEED fixing TODO
+)
+    @eval function _show(io::IO, ::MIME{Symbol($mime)}, plt::Plot{GastonBackend})
+        xsize = plt.attr[:size][1]
+        ysize = plt.attr[:size][2]
+        termopts="""size $xsize,$ysize"""
+
+        tmpfile = G.tempname() * "." * $term
+
+        G.save(
+            term = $term,
+            output = tmpfile,
+            handle = plt.o.handle,
+            saveopts = termopts
+        )
+        while !isfile(tmpfile) end  # avoid race condition with read in next line
+        write(io, read(tmpfile))
+        rm(tmpfile, force=true)
+        nothing
+
+    end
+end
+
+function _show(io::IO, mime::MIME{Symbol("image/png")},
+               plt::Plot{GastonBackend},)
+    scaling = plt.attr[:dpi] / GNUPLOT_DPI
+    xsize = plt.attr[:size][1] * scaling
+    ysize = plt.attr[:size][2] * scaling
+
+    # Scale all plot elements to match Plots.jl DPI standard
+    termopts="""size $xsize,$ysize fontscale $scaling lw $scaling dl $scaling ps $scaling"""
+
+    tmpfile = G.tempname()
+
+    G.save(
+        term = "pngcairo",
+        output = tmpfile,
+        handle = plt.o.handle,
+        saveopts = termopts
+    )
+    while !isfile(tmpfile) end  # avoid race condition with read in next line
+    write(io, read(tmpfile))
+    rm(tmpfile, force=true)
+    nothing
+end
+
+
+function _display(plt::Plot{GastonBackend})
+    display(plt.o)
+end
+#
+# --------------------------------------------
+# These functions are gaston specific
+# --------------------------------------------
+#
+function gaston_init_subplot(plt::Plot{GastonBackend}, sp::Subplot{GastonBackend})
+    dims = RecipesPipeline.is3d(sp) ? 3 : 2
+
+    axesconf = gaston_parse_axes_args(plt, sp)  # Gnuplot string
+    sp.o = GastonSubplot(dims=dims, axesconf = axesconf, curves = [])
+    push!(plt.o.subplots,  sp.o)
+
+end
+
+function gaston_add_series(plt::Plot{GastonBackend}, series::Series)
+    # Gaston.Curve = Plots.Series
+    sp = series[:subplot]
+    g_sp = sp.o  # Gaston subplot object
+
+    seriesconf = gaston_parse_series_args(series)  # Gnuplot string
+    c = G.Curve(series[:x], series[:y], nothing, nothing, seriesconf )
+
+    isfirst = length(g_sp.curves) == 0 ? true : false
+    push!(g_sp.curves, c)
+    G.write_data(c, g_sp.dims, g_sp.datafile, append = isfirst ? false : true)
+end
+
+function gaston_parse_series_args(series::Series)
+    curveconf = String[]
+    st = series[:seriestype]
+
+    if st == :scatter
+        pt = gaston_marker(series[:markershape])
+        ps = series[:markersize] * GASTON_MARKER_SCALING
+        lc = gaston_color(series[:markercolor])
+        # alpha = series[:markeralpha] # TODO merge alpha with rgb color
+        push!(curveconf, """with points pt $pt ps $ps lc $lc""")
+    elseif st == :path
+        lc = gaston_color(series[:linecolor])
+        dt = gaston_linestyle(series[:linestyle])
+        lw = series[:linewidth]
+        # alpha = series[:linealpha] # TODO merge alpha with rgb color
+        if series[:markershape] == :none # simplepath
+            push!(curveconf, """with lines lc $lc dt $dt lw $lw""")
+        else
+            pt = gaston_marker(series[:markershape])
+            ps = series[:markersize] * GASTON_MARKER_SCALING
+            push!(curveconf, """with lp lc $lc dt $dt lw $lw pt $pt ps $ps""")
+        end
+    elseif st == :shape
+        fc = gaston_color(series[:fillcolor])
+        fs = "solid"
+        lc = gaston_color(series[:linecolor])
+        push!(curveconf, """with filledcurves fc $fc fs $fs border lc $lc""")
+    elseif st == :steppre
+        push!(curveconf, """with steps""")
+    elseif st == :steppost
+        push!(curveconf, """with fsteps""")  # Not sure if not the other way
+    end
+
+    # label
+    push!(curveconf, """title "$(series[:label])" """)
+
+    return join(curveconf, " ")
+end
+
+function gaston_parse_axes_args(plt::Plot{GastonBackend}, sp::Subplot{GastonBackend})
+    axesconf = String[]
+    # Standard 2d axis
+    if !ispolar(sp) && !RecipesPipeline.is3d(sp)
+        # TODO
+        # configure grid, axis spines, thickness
+    end
+
+    for letter in (:x, :y, :z)
+        axis_attr = sp.attr[Symbol(letter, :axis)]
+        # label names
+        push!(axesconf, """set $(letter)label "$(axis_attr[:guide])"  """)
+        push!(axesconf, """set $(letter)label font "$(axis_attr[:guidefontfamily]), $(axis_attr[:guidefontsize])"  """)
+
+        # Handle ticks
+        # ticksyle
+        push!(axesconf, """set $(letter)tics font "$(axis_attr[:tickfontfamily]), $(axis_attr[:tickfontsize])"  """)
+        push!(axesconf, """set $(letter)tics textcolor rgb "#$(hex(axis_attr[:tickfontcolor], :rrggbb))" """)
+        push!(axesconf, """set $(letter)tics  $(axis_attr[:tick_direction])""")
+
+        mirror = axis_attr[:mirror] ? "mirror" : "nomirror"
+        push!(axesconf, """set $(letter)tics  $(mirror) """)
+
+        logscale = if axis_attr[:scale] == :identity
+            "nologscale"
+        elseif axis_attr[:scale] == :log10
+            "logscale"
+        end
+        push!(axesconf, """set $logscale $(letter)""")
+
+        # tick locations
+        if axis_attr[:ticks] != :native
+            # axis limits
+            from, to = axis_limits(sp, letter)
+            push!(axesconf, """set $(letter)range [$from:$to]""")
+
+            ticks = get_ticks(sp, axis_attr)
+            gaston_set_ticks!(axesconf, ticks, letter)
+        end
+        # set title {"<title-text>"} {offset <offset>} {font "<font>{,<size>}"}{{textcolor | tc} {<colorspec> | default}} {{no}enhanced}1
+    end
+    gaston_set_legend!(axesconf, sp) # Set legend params
+
+    if sp[:title] != nothing
+        push!(axesconf, """set title '$(sp[:title])' """)
+        push!(axesconf, """set title font '$(sp[:titlefontfamily]), $(sp[:titlefontsize])' """)
+    end
+
+    return join(axesconf, "\n")
+end
+
+function gaston_set_ticks!(axesconf, ticks, letter)
+
+    ticks == :auto && return
+    if ticks == :none || ticks === nothing || ticks == false
+        push!(axesconf, """unset $(letter)tics """)
+        return
+    end
+
+    ttype = ticksType(ticks)
+    if ttype == :ticks
+        tick_locations = @view ticks[:]
+        gaston_tick_string = []
+        for i in eachindex(tick_locations)
+            lac = tick_locations[i]
+            push!(gaston_tick_string, "$loc")
+        end
+        push!(
+            axesconf,
+            "set $(letter)tics (" * join(gaston_tick_string, ", ") * ")"
+        )
+
+    elseif ttype == :ticks_and_labels
+        tick_locations = @view ticks[1][:]
+        tick_labels = @view ticks[2][:]
+        gaston_tick_string = []
+        for i in eachindex(tick_locations)
+            loc = tick_locations[i]
+            lab = gaston_enclose_tick_string(tick_labels[i])
+            push!(gaston_tick_string, "'$lab' $loc")
+        end
+        push!(
+            axesconf,
+            "set $(letter)tics (" * join(gaston_tick_string, ", ") * ")"
+        )
+
+    else
+        error("Invalid input for $(letter)ticks: $ticks")
+    end
+end
+
+function gaston_set_legend!(axesconf, sp)
+    leg = sp[:legend]
+    if !(sp[:legend] in(:none, :inline))
+        if leg == :best
+            leg = :topright
+        end
+
+        if occursin("outer", string(leg))
+            push!(axesconf, "set key outside")
+        else
+            push!(axesconf, "set key inside")
+        end
+        positions = ["top", "bottom", "left", "right"]
+        for position in positions
+            if occursin(position, string(leg))
+                push!(axesconf, "set key $position")
+            end
+        end
+        if sp[:legendtitle] != nothing
+            push!(axesconf, "set key title '$(sp[:legendtitle])'")
+        end
+        push!(axesconf, "set key box linewidth 1")
+        push!(axesconf, "set key opaque")
+
+        push!(axesconf, "set border back")
+        push!(axesconf, """set key font "$(sp[:legendfontfamily]), $(sp[:legendfontsize])"  """)
+    else
+        push!(axesconf, "set key off")
+
+    end
+
+end
+
+function gaston_marker(marker)
+    marker == :none && return -1
+    marker == :circle && return 7
+    marker == :rect && return 5
+    marker == :diamond && return 28
+    marker == :utriangle && return 9
+    marker == :dtriangle && return 11
+    marker == :+ && return 1
+    marker == :x && return 2
+    marker == :star5 && return 3
+    marker == :pentagon && return 15
+    marker == :pixel && return 0
+
+    @warn("Unsupported marker $marker")
+    return 1
+end
+
+gaston_color(color) = """rgb "#$(hex(color, :rrggbb))"  """
+
+function gaston_linestyle(style)
+    style == :solid && return "1"
+    style == :dash && return "2"
+    style == :dot && return "3"
+    style == :dashdot && return "4"
+    style == :dashdotdot && return "5"
+end
+
+function gaston_enclose_tick_string(tick_string)
+    if findfirst("^", tick_string) == nothing
+        return tick_string
+    end
+
+
+    base, power = split(tick_string, "^")
+    power = string("{", power, "}")
+    return string(base, "^", power)
+end
@@ -355,9 +355,9 @@ end

 # draw ONE symbol marker
 function gr_draw_marker(series, xi, yi, clims, i, msize, strokewidth, shape::Symbol)
-    GR.setborderwidth(strokewidth);
-    gr_set_bordercolor(get_markerstrokecolor(series, i));
-    gr_set_markercolor(get_markercolor(series, clims, i));
+    GR.setborderwidth(strokewidth)
+    gr_set_bordercolor(get_markerstrokecolor(series, i))
+    gr_set_markercolor(get_markercolor(series, clims, i))
    gr_set_transparency(get_markeralpha(series, i))
    GR.setmarkertype(gr_markertype(shape))
    GR.setmarkersize(0.3msize / gr_nominal_size(series))
@@ -1162,25 +1162,25 @@ function gr_legend_pos(theta::Real, leg, viewport_plotarea; axisclearance=nothin
 end

 function gr_get_legend_geometry(viewport_plotarea, sp)
-    legendn = 0
-    legendw = 0
+    legendn = legendw = dy = 0
    if sp[:legend] != :none
        GR.savestate()
        GR.selntran(0)
        GR.setscale(0)
        if sp[:legendtitle] !== nothing
            gr_set_font(legendtitlefont(sp), sp)
+            legendn += 1
            tbx, tby = gr_inqtext(0, 0, string(sp[:legendtitle]))
            legendw = tbx[3] - tbx[1]
-            legendn += 1
+            dy = tby[3] - tby[1]
        end
        gr_set_font(legendfont(sp), sp)
        for series in series_list(sp)
            should_add_to_legend(series) || continue
            legendn += 1
-            lab = series[:label]
-            tbx, tby = gr_inqtext(0, 0, string(lab))
+            tbx, tby = gr_inqtext(0, 0, string(series[:label]))
            legendw = max(legendw, tbx[3] - tbx[1]) # Holds text width right now
+            dy = max(dy, tby[3] - tby[1])
        end

        GR.setscale(1)
@@ -1197,7 +1197,8 @@ function gr_get_legend_geometry(viewport_plotarea, sp)
    x_legend_offset = (viewport_plotarea[2] - viewport_plotarea[1]) / 30
    y_legend_offset = (viewport_plotarea[4] - viewport_plotarea[3]) / 30

-    dy = gr_point_mult(sp) * sp[:legendfontsize] * 1.75
+    dy *= get(sp[:extra_kwargs], :legend_hfactor, 1)
+
    legendh = dy * legendn

    return (
@@ -1287,12 +1288,22 @@ function gr_set_window(sp, viewport_plotarea)
        gr_set_viewport_polar(viewport_plotarea)
    else
        xmin, xmax, ymin, ymax = gr_xy_axislims(sp)
+        needs_3d = needs_any_3d_axes(sp)
+        if needs_3d
+            zmin, zmax = gr_z_axislims(sp)
+            zok = zmax > zmin
+        else
+            zok = true
+        end
+
        scaleop = 0
-        if xmax > xmin && ymax > ymin
-            sp[:xaxis][:scale] == :log10 && (scaleop |= GR.OPTION_X_LOG)
-            sp[:yaxis][:scale] == :log10 && (scaleop |= GR.OPTION_Y_LOG)
-            sp[:xaxis][:flip]            && (scaleop |= GR.OPTION_FLIP_X)
-            sp[:yaxis][:flip]            && (scaleop |= GR.OPTION_FLIP_Y)
+        if xmax > xmin && ymax > ymin && zok
+            sp[:xaxis][:scale] == :log10             && (scaleop |= GR.OPTION_X_LOG)
+            sp[:yaxis][:scale] == :log10             && (scaleop |= GR.OPTION_Y_LOG)
+            needs_3d && sp[:zaxis][:scale] == :log10 && (scaleop |= GR.OPTION_Z_LOG)
+            sp[:xaxis][:flip]                        && (scaleop |= GR.OPTION_FLIP_X)
+            sp[:yaxis][:flip]                        && (scaleop |= GR.OPTION_FLIP_Y)
+            needs_3d && sp[:zaxis][:flip]            && (scaleop |= GR.OPTION_FLIP_Z)
            # NOTE: setwindow sets the "data coordinate" limits of the current "viewport"
            GR.setwindow(xmin, xmax, ymin, ymax)
            GR.setscale(scaleop)
@@ -1315,8 +1326,14 @@ function gr_draw_axes(sp, viewport_plotarea)
    if RecipesPipeline.is3d(sp)
        # set space
        xmin, xmax, ymin, ymax = gr_xy_axislims(sp)
-        zmin, zmax = axis_limits(sp, :z)
-        GR.setspace(zmin, zmax, round.(Int, sp[:camera])...)
+        zmin, zmax = gr_z_axislims(sp)
+
+        camera = round.(Int, sp[:camera])
+
+        warn_invalid(val) = if val < 0 || val > 90 @warn "camera: $(val)° ∉ [0°, 90°]" end
+        warn_invalid.(camera)
+
+        GR.setspace(zmin, zmax, camera...)

        # fill the plot area
        gr_set_fill(plot_color(sp[:background_color_inside]))
@@ -1327,7 +1344,7 @@ function gr_draw_axes(sp, viewport_plotarea)
        GR.fillarea(x_bg, y_bg)

        for letter in (:x, :y, :z)
-            gr_draw_axis_3d(sp, letter)
+            gr_draw_axis_3d(sp, letter, viewport_plotarea)
        end
    elseif ispolar(sp)
        r = gr_set_viewport_polar(viewport_plotarea)
@@ -1357,7 +1374,7 @@ function gr_draw_axis(sp, letter, viewport_plotarea)
    gr_label_axis(sp, letter, viewport_plotarea)
 end

-function gr_draw_axis_3d(sp, letter)
+function gr_draw_axis_3d(sp, letter, viewport_plotarea)
    ax = axis_drawing_info_3d(sp, letter)
    axis = sp[Symbol(letter, :axis)]

@@ -1369,8 +1386,10 @@ function gr_draw_axis_3d(sp, letter)
    gr_draw_ticks(sp, axis, ax.tick_segments, gr_polyline3d)

    # labels
+    GR.setscale(0)
    gr_label_ticks_3d(sp, letter, ax.ticks)
    gr_label_axis_3d(sp, letter)
+    gr_set_window(sp, viewport_plotarea)
 end

 function gr_draw_grid(sp, axis, segments, func = gr_polyline)
@@ -1445,13 +1464,14 @@ function gr_label_ticks(sp, letter, ticks)
    oamin, oamax = axis_limits(sp, oletter)
    gr_set_tickfont(sp, letter)
    out_factor = ifelse(axis[:tick_direction] === :out, 1.5, 1)
-    x_offset = isy ? (axis[:mirror] ? 1 : -1) * 1.5e-2 * out_factor : 0
-    y_offset = isy ? 0 : (axis[:mirror] ? 1 : -1) * 8e-3 * out_factor
+    x_offset = isy ? -1.5e-2 * out_factor : 0
+    y_offset = isy ? 0 : -8e-3 * out_factor

    ov = sp[:framestyle] == :origin ? 0 : xor(oaxis[:flip], axis[:mirror]) ? oamax : oamin
+    sgn = axis[:mirror] ? -1 : 1
    for (cv, dv) in zip(ticks...)
        x, y = GR.wctondc(reverse_if((cv, ov), isy)...)
-        gr_text(x + x_offset, y + y_offset, dv)
+        gr_text(x + sgn * x_offset, y + sgn * y_offset, dv)
    end
 end

@@ -1483,8 +1503,8 @@ function gr_label_ticks_3d(sp, letter, ticks)
    xax, yax, zax = getindex.(Ref(sp), asyms)

    gr_set_tickfont(sp, letter)
-    nt = sp[:framestyle] == :origin ? 0 : xor(ax[:mirror], nax[:flip]) ? n1 : n0
-    ft = sp[:framestyle] == :origin ? 0 : xor(ax[:mirror], fax[:flip]) ? famax : famin
+    nt = sp[:framestyle] == :origin ? 0 : ax[:mirror] ? n1 : n0
+    ft = sp[:framestyle] == :origin ? 0 : ax[:mirror] ? famax : famin

    xoffset = if letter === :x
        (sp[:yaxis][:mirror] ? 1 : -1) * 1e-2 * (sp[:xaxis][:tick_direction] == :out ? 1.5 : 1)
@@ -1501,7 +1521,10 @@ function gr_label_ticks_3d(sp, letter, ticks)
        0
    end

-    for (cv, dv) in zip(ticks...)
+    cvs, dvs = ticks
+    ax[:flip] && reverse!(cvs)
+
+    for (cv, dv) in zip((cvs, dvs)...)
        xi, yi = gr_w3tondc(sort_3d_axes(cv, nt, ft, letter)...)
        gr_text(xi + xoffset, yi + yoffset, dv)
    end
@@ -1570,8 +1593,8 @@ function gr_label_axis_3d(sp, letter)
            # color = ax[:guidefontcolor],
        )
        ag = (amin + amax) / 2
-        ng = xor(ax[:mirror], nax[:flip]) ? n1 : n0
-        fg = xor(ax[:mirror], fax[:flip]) ? famax : famin
+        ng = ax[:mirror] ? n1 : n0
+        fg = ax[:mirror] ? famax : famin
        x, y = gr_w3tondc(sort_3d_axes(ag, ng, fg, letter)...)
        if letter in (:x, :y)
            h = gr_axis_height(sp, ax)
@@ -1582,7 +1605,8 @@ function gr_label_axis_3d(sp, letter)
            y_offset = 0
        end
        letter === :z && GR.setcharup(-1, 0)
-        gr_text(x + x_offset, y + y_offset, ax[:guide])
+        sgn = ax[:mirror] ? -1 : 1
+        gr_text(x + sgn * x_offset, y + sgn * y_offset, ax[:guide])
        GR.restorestate()
    end
 end
@@ -1700,7 +1724,7 @@ end
 function gr_draw_segments(series, x, y, fillrange, clims)
    st = series[:seriestype]
    if x !== nothing && length(x) > 1
-        segments = series_segments(series, st)
+        segments = series_segments(series, st; check=true)
        # do area fill
        if fillrange !== nothing
            GR.setfillintstyle(GR.INTSTYLE_SOLID)
@@ -1737,7 +1761,7 @@ end
 function gr_draw_segments_3d(series, x, y, z, clims)
    if series[:seriestype] === :path3d && length(x) > 1
        lz = series[:line_z]
-        segments = series_segments(series, :path3d)
+        segments = series_segments(series, :path3d; check=true)
        for segment in segments
            i, rng = segment.attr_index, segment.range
            lc = get_linecolor(series, clims, i)
@@ -1824,22 +1848,25 @@ function gr_draw_contour(series, x, y, z, clims)
 end

 function gr_draw_surface(series, x, y, z, clims)
-
+    e_kwargs = series[:extra_kwargs]
    if series[:seriestype] === :surface
        fillalpha = get_fillalpha(series)
        fillcolor = get_fillcolor(series)
-        if length(x) == length(y) == length(z)
-            x, y, z = GR.gridit(x, y, z, 200, 200)
+        # NOTE: setting nx = 0 or ny = 0 disables GR.gridit interpolation
+        nx, ny = get(e_kwargs, :nx, 200), get(e_kwargs, :ny, 200)
+        if length(x) == length(y) == length(z) && nx > 0 && ny > 0
+            x, y, z = GR.gridit(x, y, z, nx, ny)
        end
+        d_opt = get(e_kwargs, :display_option, GR.OPTION_COLORED_MESH)
        if (!isnothing(fillalpha) && fillalpha < 1) || alpha(first(fillcolor)) < 1
            gr_set_transparency(fillcolor, fillalpha)
-            GR.surface(x, y, z, GR.OPTION_COLORED_MESH)
+            GR.surface(x, y, z, d_opt)
        else
-            GR.gr3.surface(x, y, z, GR.OPTION_COLORED_MESH)
+            GR.gr3.surface(x, y, z, d_opt)
        end
-    else # wireframe
+    else  # wireframe
        GR.setfillcolorind(0)
-        GR.surface(x, y, z, GR.OPTION_FILLED_MESH)
+        GR.surface(x, y, z, get(e_kwargs, :display_option, GR.OPTION_FILLED_MESH))
    end
 end

@@ -327,7 +327,7 @@ end

 function pgfx_add_series!(::Val{:path}, axis, series_opt, series, series_func, opt)
    # treat segments
-    segments = collect(series_segments(series, series[:seriestype]))
+    segments = collect(series_segments(series, series[:seriestype]; check=true))
    sf = opt[:fillrange]
    for (k, segment) in enumerate(segments)
        i, rng = segment.attr_index, segment.range
@@ -663,7 +663,7 @@ function plotly_series(plt::Plot, series::Series)
 end

 function plotly_series_shapes(plt::Plot, series::Series, clims)
-    segments = series_segments(series)
+    segments = series_segments(series; check=true)
    plotattributes_outs = Vector{KW}(undef, length(segments))

    # TODO: create a plotattributes_out for each polygon
@@ -442,7 +442,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
            #     end
            #     push!(handles, handle)
            # else
-            for (k, segment) in enumerate(series_segments(series, st))
+            for (k, segment) in enumerate(series_segments(series, st; check=true))
                i, rng = segment.attr_index, segment.range
                handle = ax."plot"((arg[rng] for arg in xyargs)...;
                                   label = k == 1 ? series[:label] : "",
@@ -1163,15 +1163,61 @@ const _examples = PlotExample[
            ),
        ],
    ),
+    PlotExample( # 55
+        "3D axis flip / mirror",
+        "",
+        [
+            :(
+              begin
+                using LinearAlgebra
+                scalefontsizes(.4)
+
+                x, y = collect(-6:0.5:10), collect(-8:0.5:8)
+
+                args = x, y, (x, y) -> sinc(norm([x, y]) / π)
+                kwargs = Dict(:xlabel=>"x", :ylabel=>"y", :zlabel=>"z", :grid=>true, :minorgrid=>true)
+
+                plots = [wireframe(args..., title = "wire"; kwargs...)]
+
+                for ax ∈ (:x, :y, :z)
+                    push!(plots, wireframe(
+                        args...,
+                        title = "wire-flip-$ax",
+                        xflip = ax == :x,
+                        yflip = ax == :y,
+                        zflip = ax == :z;
+                        kwargs...,
+                    ))
+                end
+
+                for ax ∈ (:x, :y, :z)
+                    push!(plots, wireframe(
+                        args...,
+                        title = "wire-mirror-$ax",
+                        xmirror = ax == :x,
+                        ymirror = ax == :y,
+                        zmirror = ax == :z;
+                        kwargs...,
+                    ))
+                end
+
+                plt = plot(plots..., layout=(@layout [_ ° _; ° ° °; ° ° °]), margin=0Plots.px)
+
+                resetfontsizes()
+                plt
+              end
+            ),
+        ],
+    ),
 ]

 # Some constants for PlotDocs and PlotReferenceImages
 _animation_examples = [2, 31]
 _backend_skips = Dict(
    :gr => [25, 30, 47],
-    :pyplot => [2, 25, 30, 31, 47, 49],
-    :plotlyjs => [2, 21, 24, 25, 30, 31, 49, 51],
-    :plotly => [2, 21, 24, 25, 30, 31, 49, 50, 51],
+    :pyplot => [2, 25, 30, 31, 47, 49, 55],
+    :plotlyjs => [2, 21, 24, 25, 30, 31, 49, 51, 55],
+    :plotly => [2, 21, 24, 25, 30, 31, 49, 50, 51, 55],
    :pgfplotsx => [
        2, # animation
        6, # images
@@ -70,6 +70,11 @@ function __init__()
        include(fn)
    end

+    @require Gaston = "4b11ee91-296f-5714-9832-002c20994614" begin
+        fn = joinpath(@__DIR__, "backends", "gaston.jl")
+        include(fn)
+    end
+
    @require IJulia = "7073ff75-c697-5162-941a-fcdaad2a7d2a" begin
        if IJulia.inited
            _init_ijulia_plotting()
@@ -494,34 +494,42 @@ layout_args(huh) = error("unhandled layout type $(typeof(huh)): $huh")

 function build_layout(args...)
    layout, n = layout_args(args...)
-    build_layout(layout, n)
+    build_layout(layout, n, Array{Plot}(undef, 0))
 end

-# # just a single subplot
-# function build_layout(sp::Subplot, n::Integer)
-#     sp, Subplot[sp], SubplotMap(gensym() => sp)
-# end

-# n is the number of subplots... build a grid and initialize the inner subplots recursively
-function build_layout(layout::GridLayout, n::Integer)
+# n is the number of subplots...
+function build_layout(layout::GridLayout, n::Integer, plts::AVec{Plot})
    nr, nc = size(layout)
    subplots = Subplot[]
    spmap = SubplotMap()
+    empty = isempty(plts)
    i = 0
-    for r=1:nr, c=1:nc
-        l = layout[r,c]
+    for r = 1:nr, c = 1:nc
+        l = layout[r, c]
        if isa(l, EmptyLayout) && !get(l.attr, :blank, false)
-            sp = Subplot(backend(), parent=layout)
-            layout[r,c] = sp
-            push!(subplots, sp)
-            spmap[attr(l,:label,gensym())] = sp
+            if empty
+                # initialize the inner subplots recursively
+                sp = Subplot(backend(), parent=layout)
+                layout[r, c] = sp
+                push!(subplots, sp)
+                spmap[attr(l,:label,gensym())] = sp
+                inc = 1
+            else
+                # build a layout from a list of existing Plot objects
+                plt = popfirst!(plts)  # grab the first plot out of the list
+                layout[r, c] = plt.layout
+                append!(subplots, plt.subplots)
+                merge!(spmap, plt.spmap)
+                inc = length(plt.subplots)
+            end
            if get(l.attr, :width, :auto) != :auto
                layout.widths[c] = attr(l,:width)
            end
            if get(l.attr, :height, :auto) != :auto
                layout.heights[r] = attr(l,:height)
            end
-            i += 1
+            i += inc
        elseif isa(l, GridLayout)
            # sub-grid
            if get(l.attr, :width, :auto) != :auto
@@ -530,11 +538,11 @@ function build_layout(layout::GridLayout, n::Integer)
            if get(l.attr, :height, :auto) != :auto
                layout.heights[r] = attr(l,:height)
            end
-            l, sps, m = build_layout(l, n-i)
+            l, sps, m = build_layout(l, n - i, plts)
            append!(subplots, sps)
            merge!(spmap, m)
            i += length(sps)
-        elseif isa(l, Subplot)
+        elseif isa(l, Subplot) && empty
            error("Subplot exists. Cannot re-use existing layout.  Please make a new one.")
        end
        i >= n && break  # only add n subplots
@@ -543,45 +551,6 @@ function build_layout(layout::GridLayout, n::Integer)
    layout, subplots, spmap
 end

-# build a layout from a list of existing Plot objects
-# TODO... much of the logic overlaps with the method above... can we merge?
-function build_layout(layout::GridLayout, numsp::Integer, plts::AVec{Plot})
-    nr, nc = size(layout)
-    subplots = Subplot[]
-    spmap = SubplotMap()
-    i = 0
-    for r=1:nr, c=1:nc
-        l = layout[r,c]
-        if isa(l, EmptyLayout) && !get(l.attr, :blank, false)
-            plt = popfirst!(plts)  # grab the first plot out of the list
-            layout[r,c] = plt.layout
-            append!(subplots, plt.subplots)
-            merge!(spmap, plt.spmap)
-            if get(l.attr, :width, :auto) != :auto
-                layout.widths[c] = attr(l,:width)
-            end
-            if get(l.attr, :height, :auto) != :auto
-                layout.heights[r] = attr(l,:height)
-            end
-            i += length(plt.subplots)
-        elseif isa(l, GridLayout)
-            # sub-grid
-            if get(l.attr, :width, :auto) != :auto
-                layout.widths[c] = attr(l,:width)
-            end
-            if get(l.attr, :height, :auto) != :auto
-                layout.heights[r] = attr(l,:height)
-            end
-            l, sps, m = build_layout(l, numsp-i, plts)
-            append!(subplots, sps)
-            merge!(spmap, m)
-            i += length(sps)
-        end
-        i >= numsp && break  # only add n subplots
-    end
-    layout, subplots, spmap
-end
-

 # ----------------------------------------------------------------------
 # @layout macro
@@ -338,6 +338,14 @@ function _override_seriestype_check(plotattributes::AKW, st::Symbol)
    st
 end

+function needs_any_3d_axes(sp::Subplot)
+    any(
+        RecipesPipeline.needs_3d_axes(
+            _override_seriestype_check(s.plotattributes, s.plotattributes[:seriestype])
+        ) for s in series_list(sp)
+    )
+end
+
 function _expand_subplot_extrema(sp::Subplot, plotattributes::AKW, st::Symbol)
    # adjust extrema and discrete info
    if st == :image
@@ -90,19 +90,20 @@ function plot(args...; kw...)
 end

 # build a new plot from existing plots
-# note: we split into plt1 and plts_tail so we can dispatch correctly
-plot(plt1::Plot, plts_tail::Plot...; kw...) = plot!(deepcopy(plt1), deepcopy.(plts_tail)...; kw...)
-function plot!(plt1::Plot, plts_tail::Plot...; kw...)
+# note: we split into plt1, plt2 and plts_tail so we can dispatch correctly
+plot(plt1::Plot, plt2::Plot, plts_tail::Plot...; kw...) = plot!(deepcopy(plt1), deepcopy(plt2), deepcopy.(plts_tail)...; kw...)
+function plot!(plt1::Plot, plt2::Plot, plts_tail::Plot...; kw...)
    @nospecialize
    plotattributes = KW(kw)
    RecipesPipeline.preprocess_attributes!(plotattributes)

    # build our plot vector from the args
-    n = length(plts_tail) + 1
+    n = length(plts_tail) + 2
    plts = Array{Plot}(undef, n)
    plts[1] = plt1
+    plts[2] = plt2
    for (i,plt) in enumerate(plts_tail)
-        plts[i+1] = plt
+        plts[i+2] = plt
    end

    # compute the layout
@@ -186,6 +187,7 @@ function plot!(args...; kw...)
 end

 # this adds to a specific plot... most plot commands will flow through here
+plot(plt::Plot, args...; kw...) = plot!(deepcopy(plt), args...; kw...)
 function plot!(plt::Plot, args...; kw...)
    @nospecialize
    plotattributes = KW(kw)
@@ -75,13 +75,28 @@ function iter_segments(args...)
    NaNSegmentsIterator(tup, n1, n2)
 end

-function series_segments(series::Series, seriestype::Symbol = :path)
+function series_segments(series::Series, seriestype::Symbol=:path; check=false)
    x, y, z = series[:x], series[:y], series[:z]
    (x === nothing || isempty(x)) && return UnitRange{Int}[]

    args = RecipesPipeline.is3d(series) ? (x, y, z) : (x, y)
    nan_segments = collect(iter_segments(args...))

+    if check
+        scales = :xscale, :yscale, :zscale
+        for (n, s) ∈ enumerate(args)
+            scale = get(series, scales[n], :identity)
+            if scale ∈ _logScales
+                for (i, v) ∈ enumerate(s)
+                    if v <= 0
+                        @warn "Invalid negative or zero value $v found at series index $i for $(scale) based $(scales[n])"
+                        @debug "" exception=(DomainError(v), stacktrace())
+                    end
+                end
+            end
+        end
+    end
+
    segments = if has_attribute_segments(series)
        Iterators.flatten(map(nan_segments) do r
            if seriestype in (:scatter, :scatter3d)
@@ -30,6 +30,7 @@ end
 end # testset

 include("test_defaults.jl")
+include("test_pipeline.jl")
 include("test_axes.jl")
 include("test_axis_letter.jl")
 include("test_components.jl")
@@ -0,0 +1,10 @@
+using Plots, Test
+
+@testset "plot" begin
+    pl = plot(1:5)
+    pl2 = plot(pl, tex_output_standalone = true)
+    @test pl[:tex_output_standalone] == false
+    @test pl2[:tex_output_standalone] == true
+    plot!(pl, tex_output_standalone = true)
+    @test pl[:tex_output_standalone] == true
+end
Author	SHA1	Message	Date
Simon Christ	c9f7c6b45d	1.18.0 [skip ci]	2021-07-05 17:53:42 +02:00
Zhanibek	e58fdf970f	Gnuplot (GASTON) backend testing (#3177 ) * gnuplot * minimal working gnuplot * more params * new series and axis params * saving figures * gnuplot version 0.1	2021-07-05 17:52:59 +02:00
github-actions[bot]	c97900f7ee	Update precompile_*.jl file (#3616 ) Co-authored-by: t-bltg <t-bltg@users.noreply.github.com>	2021-07-05 15:19:03 +02:00
Simon Christ	1b881619e3	1.17.0 [skip ci]	2021-07-05 15:16:19 +02:00
t-bltg	fbd5d79d49	Merge pull request #3590 from t-bltg/warn GR: 3D, warn on invalid rotation or tilt	2021-07-05 15:01:53 +02:00
Simon Christ	db7420fd5f	fix dispatches for `plot` and `plot!` (#3602 ) * fix dispatches * fix tests	2021-07-05 13:25:20 +02:00
t-bltg	09356ee3b5	Merge pull request #3609 from t-bltg/simplify_layouts Simplify build_layout logic	2021-07-05 12:50:14 +02:00
t-bltg	0122d70640	Merge pull request #3601 from t-bltg/warn_log Warn on invalid value for log scale based series	2021-07-05 12:13:36 +02:00
t-bltg	5974d0ac31	revert fix for failing CI (#3611 ) Co-authored-by: t-bltg <t-bltg@users.noreply.github.com>	2021-07-05 11:24:22 +02:00
t-bltg	ef93aa87be	Merge pull request #3610 from t-bltg/dist_bug Bypass JuliaStats/Distributions.jl/issues/1358	2021-07-04 19:22:33 +02:00
t-bltg	88ebb8152d	bypass JuliaStats/Distributions.jl/issues/1358	2021-07-04 19:00:28 +02:00
t-bltg	124d2d6aa3	issue warning only once - apply to other backends	2021-07-04 15:48:16 +02:00
t-bltg	cdbafd60c8	Merge pull request #3598 from t-bltg/legend Fix Latex sub/super-scripts in legends	2021-07-04 15:34:44 +02:00
t-bltg	5eb62abb25	simplify build_layout logic	2021-07-04 15:07:09 +02:00
t-bltg	3f110d6a6c	Merge pull request #3591 from t-bltg/surf_opts GR: expose surface(...) display options, fix hardcoded constants	2021-07-04 12:50:55 +02:00
t-bltg	293b43013b	allow spacing via extra_kwargs	2021-07-03 20:05:53 +02:00
t-bltg	3536acbcc8	warn on invalid value for log scale based series	2021-07-03 14:44:53 +02:00
Simon Christ	0ca5bc9124	1.16.8 [skip ci]	2021-07-02 21:27:21 +02:00
t-bltg	14b38354da	fix #3558	2021-07-02 20:26:24 +02:00
t-bltg	06c551ba51	Skip example 55 for PyPlot, Plotlyjs and Plotly PgfPlotsX looks ok	2021-07-02 16:57:35 +02:00
t-bltg	f63ee6d79e	enhance example 55 (#3596 ) Co-authored-by: t-bltg <t-bltg@users.noreply.github.com>	2021-07-02 15:06:36 +02:00
github-actions[bot]	b3f698c460	Update precompile_*.jl file (#3592 ) Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>	2021-07-02 09:42:25 +02:00
Simon Christ	829860fa2d	use sinc in example 55	2021-07-02 09:17:56 +02:00
Simon Christ	1523ef67d5	simplify example 55	2021-07-01 21:41:35 +02:00
github-actions[bot]	e049b082f3	[AUTO] Update precompiles (#3573 ) * add tests for series_annotations in layouts * add methods for matrices of annotations * defensive copy on plot(plots) * seperate in plot(plots) and plot!(plots) * Update precompile_*.jl file Co-authored-by: Simon Christ <SimonChrist@gmx.de> Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>	2021-07-01 18:40:58 +02:00
Simon Christ	f78899a1ef	return plot object	2021-07-01 18:28:50 +02:00
t-bltg	e42b4ad34d	GR: surface, add the possibility to override the hardcoded nx and ny in GR.gridit(...)	2021-07-01 16:54:07 +02:00
t-bltg	a7c629f775	GR: expose surface(...) display options	2021-07-01 15:08:36 +02:00
t-bltg	1ddc673201	GR: 3D, warn on invalid rotation or tilt	2021-07-01 14:02:30 +02:00
t-bltg	bba971f7ea	GR: fix axis flip / mirror in 3D plots (#3584 ) * fix axis flip in 3D plots * add mwe as example - fix needs_3d_axes * fix major / minor grids when mirroring Co-authored-by: t-bltg <t-bltg@users.noreply.github.com>	2021-06-30 22:50:09 +02:00