1.20.0 [skip ci]

Allow relative positioning of annotations

.github/ISSUE_TEMPLATE/bug.md

@@ -28,5 +28,5 @@ inspectdr    |     |     |
 ### Versions
 
 Plots.jl version:
-Backend  version (`]st -m`):
+Backend  version (`]st -m <backend(s)>`):
 Output of `versioninfo()`:

.github/workflows/SnoopCompile.yml

@@ -75,9 +75,11 @@ jobs:
         uses: peter-evans/create-pull-request@v3
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
-          commit-message: Update precompile_*.jl file
-          title: "[AUTO] Update precompiles"
-          labels: SnoopCompile
+          commit-message: Update precompile_*.jl file [skip ci]
+          title: "[AUTO] Update precompiles [skip ci]"
+          labels: |
+            SnoopCompile
+            no changelog
           branch: "Test_SnoopCompile_AutoPR_${{ github.ref }}"
 
 

.github/workflows/ci.yml

@@ -71,7 +71,10 @@ jobs:
 
       # Run tests
       - name: Run Graphical test
-        run:  $TESTCMD --project -e 'using Pkg; Pkg.test(coverage=true);'
+        run:  |
+          $TESTCMD --project -e 'using Pkg; Pkg.test(coverage=true);'
+          $TESTCMD -e 'using Pkg; Pkg.activate(tempdir()); Pkg.develop(path=abspath(".")); Pkg.add("StatsPlots"); Pkg.test("StatsPlots");'
+          $TESTCMD -e 'using Pkg; Pkg.activate(tempdir()); Pkg.develop(path=abspath(".")); Pkg.add("GraphRecipes"); Pkg.test("GraphRecipes");'
 
       - name: Codecov
         uses: julia-actions/julia-uploadcodecov@latest

.github/workflows/docs.yml

@@ -38,7 +38,8 @@ jobs:
             texlive-latex-extra \
             texlive-luatex \
             ghostscript-x \
-            libgconf2-4
+            libgconf2-4 \
+            gnuplot
           sudo fc-cache -vr
             
       - name: build documentation
@@ -46,5 +47,10 @@ jobs:
           PYTHON: ""
           DOCUMENTER_KEY: ${{ secrets.DOCUMENTER_KEY }}
         run: |
-          xvfb-run julia --color=yes --project=docs/ -e 'using Pkg; Pkg.develop(PackageSpec(path=pwd())); Pkg.add(PackageSpec(name="Plots", rev=split(ENV["GITHUB_REF"], "/", limit=3)[3])); Pkg.instantiate()' 
+          export JULIA_DEBUG=Documenter
+          export PLOTDOCS_ANSICOLOR=true
+          export GKSwstype=nul  # Plots.jl/issues/3664
+          xvfb-run julia --color=yes --project=docs/ -e 'using Pkg; Pkg.develop(PackageSpec(path=pwd())); Pkg.add(PackageSpec(name="Plots", rev=split(ENV["GITHUB_REF"], "/", limit=3)[3])); Pkg.instantiate()'
+          # xvfb-run julia --color=yes --project=docs/ -e 'using Pkg; pkg"add Documenter#master"'
+          xvfb-run julia --color=yes --project=docs/ -e 'using Pkg; pkg"st -m"'
           xvfb-run julia --color=yes --project=docs/ -e 'withenv("GITHUB_REPOSITORY" => "JuliaPlots/PlotDocs.jl") do; include("docs/make.jl"); end' 

.zenodo.json

@@ -15,8 +15,9 @@
             "type": "ProjectLeader"
         },
         {
-            "affiliation": "GLOBE Institute",
+            "affiliation": "GLOBE Institute, University of Copenhagen",
             "name": "Michael Krabbe Borregaard",
+            "orcid": "0000-0002-8146-8435",
             "type": "ProjectLeader"
         },
         {
@@ -452,8 +453,10 @@
             "type": "Other"
         },
         {
+            "affiliation": "University of Graz",
             "name": "Bernd Riederer",
-            "type": "Other"
+            "type": "Other",
+            "orcid": "0000-0001-8390-0087"
         },
         {
             "name": "Christina Lee",
@@ -681,6 +684,14 @@
             "affiliation": "University of Cambridge",
             "name": "Will Tebbutt",
             "type": "Other"
+        },
+        {
+            "name": "@t-bltg",
+            "type": "Other"
+        }
+        {
+            "name": "Fred Callaway",
+            "type": "Other"
         }
     ],
     "upload_type": "software"

Project.toml

@@ -1,7 +1,7 @@
 name = "Plots"
 uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
 author = ["Tom Breloff (@tbreloff)"]
-version = "1.15.0"
+version = "1.20.0"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
@@ -36,8 +36,8 @@ UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
 Contour = "0.5"
 FFMPEG = "0.2, 0.3, 0.4"
 FixedPointNumbers = "0.6, 0.7, 0.8"
-GR = "0.46, 0.47, 0.48, 0.49, 0.50, 0.51, 0.52, 0.53, 0.54, 0.55, 0.57"
-GeometryBasics = "0.2, 0.3.1"
+GR = "0.53, 0.54, 0.55, 0.57, 0.58"
+GeometryBasics = "0.2, 0.3.1, 0.4"
 JSON = "0.21, 1"
 Latexify = "0.14, 0.15"
 Measures = "0.3"

deps/SnoopCompile/precompile/precompile_Plots.jl

@@ -79,8 +79,11 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:flip,), Tuple{Bool}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,), Tuple{Symbol}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,), Tuple{typeof(datetimeformatter)}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :flip, :minorgrid, :guide), Tuple{Bool, Bool, Bool, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :lims), Tuple{Bool, Tuple{Float64, Float64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :lims, :flip), Tuple{Bool, Tuple{Float64, Float64}, Bool}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :minorgrid, :guide), Tuple{Bool, Bool, String}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :minorgrid, :mirror, :guide), Tuple{Bool, Bool, Bool, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid,), Tuple{Bool}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:gridlinewidth, :grid, :gridalpha, :gridstyle, :foreground_color_grid), Tuple{Int64, Bool, Float64, Symbol, RGBA{Float64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide,), Tuple{String}},typeof(attr!),Axis})
@@ -90,38 +93,42 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Float64, Float64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Int64, Float64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Int64, Int64}}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:minorgrid, :scale, :guide), Tuple{Bool, Symbol, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(: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)})
+    Base.precompile(Tuple{Core.kwftype(typeof(font)),NamedTuple{(:family, :pointsize, :valign, :halign, :rotation, :color), Tuple{String, Int64, Symbol, Symbol, Float64, RGBA{Float64}}},typeof(font)})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),StepRange{Int64, Int64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),UnitRange{Int64},UnitRange{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),UnitRange{Int64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),Vector{Int64},Vector{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(gr_set_font)),NamedTuple{(:halign, :valign, :rotation), Tuple{Symbol, Symbol, Int64}},typeof(gr_set_font),Font,Subplot{GRBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(gr_set_font)),NamedTuple{(: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(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{(:annotation,), Tuple{Vector{Tuple{Int64, Float64, Tuple{String, Any, Any, Any}}}}},typeof(plot!)})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:layout, :margin), Tuple{GridLayout, AbsoluteLength}},typeof(plot!),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(: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!),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!),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}})
@@ -129,48 +136,50 @@ function _precompile_()
     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{(:w,), Tuple{Int64}},typeof(plot!),Plot{GRBackend},Vector{Float64},Vector{Float64},Vararg{Any, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:xgrid,), Tuple{Tuple{Symbol, Symbol, Int64, Symbol, Float64}}},typeof(plot!),Plot{GRBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis,), Tuple{Tuple{String, Symbol}}},typeof(plot!)})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis, :minorgrid), Tuple{Tuple{String, Symbol}, Bool}},typeof(plot!),Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis, :minorgrid), Tuple{Tuple{String, Symbol}, Bool}},typeof(plot!)})
     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, :title, :xlabel, :ylabel, :zlabel, :legend, :margin, :seriestype), Tuple{Tuple{Vector{Int64}, Vector{Int64}, Vector{Int64}}, String, String, String, String, Symbol, AbsoluteLength, Symbol}},typeof(plot),Vector{Int64},Vector{Int64},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:fill, :seriestype), Tuple{Bool, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Function})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(: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{(:labels,), Tuple{Matrix{String}}},typeof(plot),PortfolioComposition})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :group, :linetype, :linecolor), Tuple{GridLayout, Vector{String}, Matrix{Symbol}, Symbol}},typeof(plot),Vector{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :label, :fillrange, :fillalpha), Tuple{Tuple{Int64, Int64}, String, Int64, Float64}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :label, :fillrange, :fillalpha), Tuple{Tuple{Int64, Int64}, String, Int64, Float64}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :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, :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{(: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}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:marker,), Tuple{Bool}},typeof(plot),Vector{Union{Missing, Int64}}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:marker_z, :color, :legend, :seriestype), Tuple{typeof(+), Symbol, Bool, Symbol}},typeof(plot),Vector{Float64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:markershape, :markersize, :marker_z, :line_z, :linewidth), Tuple{Matrix{Symbol}, Matrix{Int64}, Matrix{Int64}, Matrix{Int64}, Matrix{Int64}}},typeof(plot),Matrix{Float64}})
@@ -178,29 +187,30 @@ 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}})
@@ -236,9 +246,6 @@ function _precompile_()
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{PlotUtils.ContinuousColorGradient},String})
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}},String})
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{Symbol},String})
-    Base.precompile(Tuple{typeof(_cycle),Base.OneTo{Int64},Vector{Int64}})
-    Base.precompile(Tuple{typeof(_cycle),ColorPalette,Int64})
-    Base.precompile(Tuple{typeof(_cycle),StepRange{Int64, Int64},Vector{Int64}})
     Base.precompile(Tuple{typeof(_cycle),Vector{Float64},StepRange{Int64, Int64}})
     Base.precompile(Tuple{typeof(_cycle),Vector{Float64},UnitRange{Int64}})
     Base.precompile(Tuple{typeof(_cycle),Vector{Float64},Vector{Int64}})
@@ -248,28 +255,28 @@ function _precompile_()
     Base.precompile(Tuple{typeof(_plot!),Plot,Any,Any})
     Base.precompile(Tuple{typeof(_preprocess_barlike),DefaultsDict,Base.OneTo{Int64},Vector{Float64}})
     Base.precompile(Tuple{typeof(_preprocess_binlike),DefaultsDict,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
-    Base.precompile(Tuple{typeof(_replace_markershape),Vector{Symbol}})
     Base.precompile(Tuple{typeof(_update_min_padding!),GridLayout})
     Base.precompile(Tuple{typeof(_update_subplot_args),Plot{GRBackend},Subplot{GRBackend},Dict{Symbol, Any},Int64,Bool})
     Base.precompile(Tuple{typeof(_update_subplot_args),Plot{PlotlyBackend},Subplot{PlotlyBackend},Dict{Symbol, Any},Int64,Bool})
     Base.precompile(Tuple{typeof(_update_subplot_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(build_layout),GridLayout,Int64,Vector{Plot}})
+    Base.precompile(Tuple{typeof(convertLegendValue),Symbol})
     Base.precompile(Tuple{typeof(convert_to_polar),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64},Tuple{Int64, Float64}})
     Base.precompile(Tuple{typeof(create_grid),Expr})
     Base.precompile(Tuple{typeof(discrete_value!),Axis,Vector{String}})
     Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64},Vararg{Vector{Float64}, N} where N})
     Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64}})
     Base.precompile(Tuple{typeof(error_zipit),Tuple{Vector{Float64}, Vector{Float64}, Vector{Float64}}})
-    Base.precompile(Tuple{typeof(font),String,Vararg{Any, N} where N})
+    Base.precompile(Tuple{typeof(fakedata),Int64,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_series_color),Vector{Symbol},Subplot{PlotlyBackend},Int64,Symbol})
     Base.precompile(Tuple{typeof(get_ticks),StepRange{Int64, Int64},Vector{Float64},Vector{Any},Tuple{Int64, Int64},Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Float64, Float64},Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Int64, Float64},Vararg{Any, N} where N})
@@ -277,12 +284,16 @@ function _precompile_()
     Base.precompile(Tuple{typeof(get_ticks),UnitRange{Int64},Vector{Float64},Vector{Any},Tuple{Float64, Float64},Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(get_xy),Vector{OHLC}})
     Base.precompile(Tuple{typeof(gr_add_legend),Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), NTuple{9, Float64}},Vector{Float64}})
-    Base.precompile(Tuple{typeof(gr_add_legend),Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), Tuple{Int64, Float64, Float64, Float64, Int64, Float64, Float64, Float64, Float64}},Vector{Float64}})
+    Base.precompile(Tuple{typeof(gr_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_clims),Subplot{GRBackend},Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(gr_display),Subplot{GRBackend},AbsoluteLength,AbsoluteLength,Vector{Float64}})
     Base.precompile(Tuple{typeof(gr_draw_colorbar),GRColorbar,Subplot{GRBackend},Tuple{Float64, Float64},Vector{Float64}})
     Base.precompile(Tuple{typeof(gr_draw_contour),Series,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Matrix{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_heatmap),Series,Vector{Float64},Vector{Float64},Matrix{Float64},Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Float64,Float64,Symbol})
     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}})
@@ -294,15 +305,15 @@ function _precompile_()
     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_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})
@@ -312,7 +323,8 @@ function _precompile_()
     Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol,Vector{Float64},Symbol,Tuple{Int64, Int64},Bool})
     Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol})
     Base.precompile(Tuple{typeof(ignorenan_minimum),Vector{Int64}})
-    Base.precompile(Tuple{typeof(layout_args),Int64})
+    Base.precompile(Tuple{typeof(leftpad),EmptyLayout})
+    Base.precompile(Tuple{typeof(locate_annotation),Subplot{GRBackend},Int64,Float64,PlotText})
     Base.precompile(Tuple{typeof(make_fillrange_side),UnitRange{Int64},LinRange{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})
@@ -321,42 +333,54 @@ 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(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(processMinorGridArg!),Dict{Symbol, Any},Bool,Symbol})
     Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,PlotText})
+    Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,Tuple{String, Int64, Symbol, Symbol}})
+    Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,Tuple{String, Symbol, Int64, String}})
     Base.precompile(Tuple{typeof(process_annotation),Subplot{PlotlyBackend},Int64,Float64,PlotText})
+    Base.precompile(Tuple{typeof(process_annotation),Subplot{PlotlyBackend},Int64,Float64,Tuple{String, Int64, Symbol, Symbol}})
+    Base.precompile(Tuple{typeof(process_annotation),Subplot{PlotlyBackend},Int64,Float64,Tuple{String, Symbol, Int64, String}})
     Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},StepRange{Int64, Int64},Symbol})
     Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},Symbol,Symbol})
     Base.precompile(Tuple{typeof(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(push!),Segments{Tuple{Float64, Float64}},Tuple{Int64, Int64},Tuple{Int64, Float64}})
     Base.precompile(Tuple{typeof(reset_axis_defaults_byletter!)})
+    Base.precompile(Tuple{typeof(resetfontsizes)})
+    Base.precompile(Tuple{typeof(scalefontsizes),Float64})
     Base.precompile(Tuple{typeof(slice_arg),Base.ReshapedArray{Int64, 2, UnitRange{Int64}, Tuple{}},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Matrix{AbsoluteLength},Int64})
     Base.precompile(Tuple{typeof(slice_arg),Matrix{Bool},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Matrix{Int64},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Matrix{PlotUtils.ContinuousColorGradient},Int64})
     Base.precompile(Tuple{typeof(slice_arg),Matrix{RGBA{Float64}},Int64})
     Base.precompile(Tuple{typeof(slice_arg),Matrix{String},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Matrix{Symbol},Int64})
     Base.precompile(Tuple{typeof(spy),Any})
     Base.precompile(Tuple{typeof(straightline_data),Tuple{Float64, Float64},Tuple{Float64, Float64},Vector{Float64},Vector{Float64},Int64})
     Base.precompile(Tuple{typeof(stroke),Int64,Vararg{Any, N} where N})
-    Base.precompile(Tuple{typeof(text),String,Int64,Symbol,Vararg{Symbol, N} where N})
-    Base.precompile(Tuple{typeof(text),String,Symbol,Int64,Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(title!),AbstractString})
     Base.precompile(Tuple{typeof(unzip),Vector{GeometryBasics.Point2{Float64}}})
     Base.precompile(Tuple{typeof(vline!),Any})
     Base.precompile(Tuple{typeof(xgrid!),Plot{GRBackend},Symbol,Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(xlims),Subplot{PlotlyBackend}})
-    Base.precompile(Tuple{typeof(yaxis!),Any,Any})
+    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#126")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#126")),Vector{Int64},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(font, (Font,Vararg{Any, N} where N,))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}},typeof(font),Font,Vararg{Any, N} where N,))
+        end
+    end
     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),))
@@ -382,29 +406,9 @@ 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,))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(text, (String,Symbol,Vararg{Any, N} where N,))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}},typeof(text),String,Symbol,Vararg{Any, N} where N,))
-        end
-    end
     let fbody = try __lookup_kwbody__(which(title!, (AbstractString,))) catch missing end
         if !ismissing(fbody)
             precompile(fbody, (Any,typeof(title!),AbstractString,))
         end
     end
-    let fbody = try __lookup_kwbody__(which(yaxis!, (Any,Vararg{Any, N} where N,))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(yaxis!),Any,Vararg{Any, N} where N,))
-        end
-    end
 end

src/Plots.jl

@@ -118,7 +118,6 @@ export
     scalefontsizes,
     resetfontsizes
 
-
 # ---------------------------------------------------------
 
 import NaNMath # define functions that ignores NaNs. To overcome the destructive effects of https://github.com/JuliaLang/julia/pull/12563
@@ -250,6 +249,7 @@ end
 # ---------------------------------------------------------
 
 const CURRENT_BACKEND = CurrentBackend(:none)
+const PLOTS_SEED = 1234
 
 include("precompile_includer.jl")
 

src/animation.jl

@@ -170,18 +170,19 @@ function _animate(forloop::Expr, args...; callgif = false)
   end
 
   push!(block.args, :(if $filterexpr; Plots.frame($animsym); end))
-  push!(block.args, :(global $countersym += 1))
+  push!(block.args, :($countersym += 1))
 
   # add a final call to `gif(anim)`?
   retval = callgif ? :(Plots.gif($animsym)) : animsym
 
   # full expression:
   esc(quote
-    $freqassert             # if filtering, check frequency is an Integer > 0
-    $animsym = Plots.Animation()  # init animation object
-    global $countersym = 1         # init iteration counter
-    $forloop                # for loop, saving a frame after each iteration
-    $retval                 # return the animation object, or the gif
+    $freqassert                     # if filtering, check frequency is an Integer > 0
+    $animsym = Plots.Animation()    # init animation object
+    let $countersym = 1             # init iteration counter
+      $forloop                      # for loop, saving a frame after each iteration
+    end
+    $retval                         # return the animation object, or the gif
   end)
 end
 

src/arg_desc.jl

@@ -16,14 +16,14 @@ const _arg_desc = KW(
 :markershape                 => "Symbol, Shape, or AbstractVector. Choose from $(_allMarkers).",
 :markercolor                 => "Color Type. Color of the interior of the marker or shape. `:match` will take the value from `:seriescolor`.",
 :markeralpha                 => "Number in [0,1]. The alpha/opacity override for the marker interior.  `nothing` (the default) means it will take the alpha value of markercolor.",
-:markersize                  => "Number or AbstractVector. Size (radius pixels) of the markers.",
+:markersize                  => "Number or AbstractVector. Size (radius pixels) of the markers",
 :markerstrokestyle           => "Symbol. Style of the marker stroke (border).  Choose from $(_allStyles)",
-:markerstrokewidth           => "Number. Width of the marker stroke (border. in pixels)",
+:markerstrokewidth           => "Number. Width of the marker stroke (border) in pixels",
 :markerstrokecolor           => "Color Type. Color of the marker stroke (border).  `:match` will take the value from `:foreground_color_subplot`.",
 :markerstrokealpha           => "Number in [0,1]. The alpha/opacity override for the marker stroke (border).  `nothing` (the default) means it will take the alpha value of markerstrokecolor.",
 :bins                        => "Integer, NTuple{2,Integer}, AbstractVector or Symbol. Default is :auto (the Freedman-Diaconis rule). For histogram-types, defines the approximate number of bins to aim for, or the auto-binning algorithm to use (:sturges, :sqrt, :rice, :scott or :fd). For fine-grained control pass a Vector of break values, e.g. `range(minimum(x), stop = maximum(x), length = 25)`",
 :smooth                      => "Bool.  Add a regression line?",
-:group                       => "AbstractVector. Data is split into a separate series, one for each unique value in `group`.",
+:group                       => "AbstractVector. Data is split into a separate series, one for each unique value in `group`",
 :x                           => "Various. Input data. First Dimension",
 :y                           => "Various. Input data. Second Dimension",
 :z                           => "Various. Input data. Third Dimension. May be wrapped by a `Surface` for surface and heatmap types.",
@@ -42,7 +42,7 @@ const _arg_desc = KW(
 :arrow                       => "nothing (no arrows), Bool (if true, default arrows), Arrow object, or arg(s) that could be style or head length/widths.  Defines arrowheads that should be displayed at the end of path line segments (just before a NaN and the last non-NaN point).  Used in quiverplot, streamplot, or similar.",
 :normalize                   => "Bool or Symbol. Histogram normalization mode. Possible values are: false/:none (no normalization, default), true/:pdf (normalize to a discrete Probability Density Function, where the total area of the bins is 1), :probability (bin heights sum to 1) and :density (the area of each bin, rather than the height, is equal to the counts - useful for uneven bin sizes).",
 :weights                     => "AbstractVector. Used in histogram types for weighted counts.",
-:show_empty_bins             => "Bool. Whether empty bins in a 2D histogram are colored as 0 (true), or transparent (the default).",
+:show_empty_bins             => "Bool. Whether empty bins in a 2D histogram are colored as 0 (true), or transparent (the default)",
 :contours                    => "Bool. Add contours to the side-grids of 3D plots?  Used in surface/wireframe.",
 :contour_labels              => "Bool. Show labels at the contour lines?",
 :match_dimensions            => "Bool. For heatmap types... should the first dimension of a matrix (rows) correspond to the first dimension of the plot (x-axis)?  The default is false, which matches the behavior of Matplotlib, Plotly, and others.  Note: when passing a function for z, the function should still map `(x,y) -> z`.",
@@ -53,7 +53,8 @@ const _arg_desc = KW(
 :colorbar_entry              => "Bool.  Include this series in the color bar?  Set to `false` to exclude.",
 
 # plot args
-:plot_title                  => "String. Title for the whole plot (not the subplots) (Note: Not currently implemented)",
+:plot_title                  => "String. Title for the whole plot (not the subplots)",
+:plot_titlevspan             => "Number in [0,1]. Vertical span of the whole plot title (fraction of the plot height)",
 :background_color            => "Color Type.  Base color for all backgrounds.",
 :background_color_outside    => "Color Type or `:match` (matches `:background_color`).  Color outside the plot area(s)",
 :foreground_color            => "Color Type.  Base color for all foregrounds.",
@@ -115,7 +116,7 @@ const _arg_desc = KW(
 :colorbar_formatter          => "Function, :scientific, :plain or :auto. A method which converts a number to a string for tick labeling.",
 :legendfont                  => "Font. Font of legend items.",
 :legendtitlefont             => "Font. Font of the legend title.",
-:annotations                 => "(x,y,text) tuple(s).  Can be a single tuple or a list of them.  Text can be String or PlotText (created with `text(args...)`)  Add one-off text annotations at the x,y coordinates.",
+:annotations                 => "(x,y,text) tuple(s).  Can be a single tuple or a list of them.  Text can be String, PlotText (created with `text(args...)`), or a tuple of arguments to `text` (e.g., `(\"Label\", 8, :red, :top)`).  Add one-off text annotations at the x,y coordinates.",
 :annotationfontfamily        => "String or Symbol. Font family of annotations.",
 :annotationfontsize          => "Integer. Font pointsize of annotations.",
 :annotationhalign            => "Symbol. horizontal alignment of annotations, :hcenter, :left, :right or :center.",
@@ -137,7 +138,12 @@ const _arg_desc = KW(
 # axis args
 :guide                       => "String. Axis guide (label).",
 :guide_position              => "Symbol. Position of axis guides: :top, :bottom, :left or :right",
-:lims                        => "NTuple{2,Number} or Symbol. Force axis limits.  Only finite values are used (you can set only the right limit with `xlims = (-Inf, 2)` for example). `:round` widens the limit to the nearest round number ie. [0.1,3.6]=>[0.0,4.0]",
+:lims                        => """
+                                NTuple{2,Number} or Symbol. Force axis limits. Only finite values are used (you can set only the right limit with `xlims = (-Inf, 2)` for example).
+                                `:round` widens the limit to the nearest round number ie. [0.1,3.6]=>[0.0,4.0]
+                                `:symmetric` sets the limits to be symmetric around zero.
+                                Set widen=true to widen the specified limits (as occurs when lims are not specified).
+                                """,
 :ticks                       => "Vector of numbers (set the tick values), Tuple of (tickvalues, ticklabels), or `:auto`",
 :scale                       => "Symbol. Scale of the axis: `:none`, `:ln`, `:log2`, `:log10`",
 :rotation                    => "Number. Degrees rotation of tick labels.",
@@ -173,6 +179,9 @@ const _arg_desc = KW(
 :minorgridlinewidth          => "Number. Width of the minor grid lines (in pixels)",
 :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`.",
+:widen                       => """
+                                Bool or :auto. Widen the axis limits by a small factor to avoid cut-off markers and lines at the borders.
+                                Defaults to `:auto`, which widens unless limits were manually set.
+                                """,
 :draw_arrow                  => "Bool. Draw arrow at the end of the axis.",
 )

src/args.jl

@@ -331,13 +331,15 @@ const _series_defaults = KW(
 
 const _plot_defaults = KW(
     :plot_title                  => "",
+    :plot_titleindex             => 0,
     :plot_titlefontsize          => 16,
-    :plot_title_location         => :center,           # also :left or :right
+    :plot_titlelocation          => :center,           # also :left or :right
     :plot_titlefontfamily        => :match,
     :plot_titlefonthalign        => :hcenter,
     :plot_titlefontvalign        => :vcenter,
     :plot_titlefontrotation      => 0.0,
     :plot_titlefontcolor         => :match,
+    :plot_titlevspan             => 0.05,              # vertical span of the plot title, here 5%
     :background_color            => colorant"white",   # default for all backgrounds,
     :background_color_outside    => :match,            # background outside grid,
     :foreground_color            => :auto,             # default for all foregrounds, and title color,
@@ -476,7 +478,7 @@ const _axis_defaults = KW(
     :minorticks                  => false,
     :minorgrid                   => false,
     :showaxis                    => true,
-    :widen                       => true,
+    :widen                       => :auto,
     :draw_arrow                  => false,
 )
 
@@ -522,12 +524,25 @@ const _initial_defaults = deepcopy(_all_defaults)
 const _initial_axis_defaults = deepcopy(_axis_defaults)
 
 # to be able to reset font sizes to initial values
-const _initial_fontsizes = Dict(:titlefontsize  => _subplot_defaults[:titlefontsize],
-                                :legendfontsize => _subplot_defaults[:legendfontsize],
-                                :legendtitlefontsize => _subplot_defaults[:legendtitlefontsize],
-                                :annotationfontsize => _subplot_defaults[:annotationfontsize],
-                                :tickfontsize   => _axis_defaults[:tickfontsize],
-                                :guidefontsize  => _axis_defaults[:guidefontsize])
+const _initial_plt_fontsizes = Dict(
+    :plot_titlefontsize => _plot_defaults[:plot_titlefontsize],
+)
+
+const _initial_sp_fontsizes = Dict(
+    :titlefontsize => _subplot_defaults[:titlefontsize],
+    :legendfontsize => _subplot_defaults[:legendfontsize],
+    :legendtitlefontsize => _subplot_defaults[:legendtitlefontsize],
+    :annotationfontsize => _subplot_defaults[:annotationfontsize],
+    :colorbar_tickfontsize => _subplot_defaults[:colorbar_tickfontsize],
+    :colorbar_titlefontsize => _subplot_defaults[:colorbar_titlefontsize],
+)
+
+const _initial_ax_fontsizes = Dict(
+    :tickfontsize  => _axis_defaults[:tickfontsize],
+    :guidefontsize => _axis_defaults[:guidefontsize],
+)
+
+const _initial_fontsizes = merge(_initial_plt_fontsizes, _initial_sp_fontsizes, _initial_ax_fontsizes)
 
 const _internal_args =
     [:plot_object, :series_plotindex, :markershape_to_add, :letter, :idxfilter]
@@ -546,8 +561,7 @@ const _all_subplot_args = sort(union([_subplot_args; _magic_subplot_args]))
 const _all_series_args = sort(union([_series_args; _magic_series_args]))
 const _all_plot_args = _plot_args
 
-const _all_args =
-    sort(union([_all_axis_args; _all_subplot_args; _all_series_args; _all_plot_args]))
+const _all_args = sort(union([_all_axis_args; _all_subplot_args; _all_series_args; _all_plot_args]))
 
 is_subplot_attr(k) = k in _all_subplot_args
 is_series_attr(k) = k in _all_series_args
@@ -569,9 +583,7 @@ function aliasesAndAutopick(plotattributes::AKW, sym::Symbol, aliases::Dict{Symb
     end
 end
 
-function aliases(aliasMap::Dict{Symbol,Symbol}, val)
-    sortedkeys(filter((k,v)-> v==val, aliasMap))
-end
+aliases(aliasMap::Dict{Symbol,Symbol}, val) = sortedkeys(filter((k,v)-> v==val, aliasMap))
 
 # -----------------------------------------------------------------------------
 
@@ -774,9 +786,7 @@ function default(; reset = true, kw...)
     end
 end
 
-function default(plotattributes::AKW, k::Symbol)
-    get(plotattributes, k, default(k))
-end
+default(plotattributes::AKW, k::Symbol) = get(plotattributes, k, default(k))
 
 function reset_defaults()
     foreach(merge!, _all_defaults, _initial_defaults)
@@ -1139,7 +1149,7 @@ function RecipesPipeline.preprocess_attributes!(plotattributes::AKW)
     RecipesPipeline.reset_kw!(plotattributes, :marker)
     if haskey(plotattributes, :markershape)
         plotattributes[:markershape] = _replace_markershape(plotattributes[:markershape])
-        if plotattributes[:markershape] == :none && plotattributes[:seriestype] in (:scatter, :scatterbins, :scatterhist, :scatter3d) #the default should be :auto, not :none, so that :none can be set explicitly and would be respected
+        if plotattributes[:markershape] == :none && get(plotattributes, :seriestype, :path) in (:scatter, :scatterbins, :scatterhist, :scatter3d) #the default should be :auto, not :none, so that :none can be set explicitly and would be respected
             plotattributes[:markershape] = :circle
         end
     elseif anymarker
@@ -1425,9 +1435,7 @@ function Base.getindex(axis::Axis, k::Symbol)
     end
 end
 
-function Base.getindex(series::Series, k::Symbol)
-    series.plotattributes[k]
-end
+Base.getindex(series::Series, k::Symbol) = series.plotattributes[k]
 
 Base.setindex!(plt::Plot, v, k::Symbol)      = (plt.attr[k] = v)
 Base.setindex!(sp::Subplot, v, k::Symbol)    = (sp.attr[k] = v)
@@ -1609,9 +1617,7 @@ end
 
 has_black_border_for_default(st) = error("The seriestype attribute only accepts Symbols, you passed the $(typeof(st)) $st.")
 has_black_border_for_default(st::Function) = error("The seriestype attribute only accepts Symbols, you passed the function $st.")
-function has_black_border_for_default(st::Symbol)
-    like_histogram(st) || st in (:hexbin, :bar, :shape)
-end
+has_black_border_for_default(st::Symbol) = like_histogram(st) || st in (:hexbin, :bar, :shape)
 
 # converts a symbol or string into a Colorant or ColorGradient
 # and assigns a color automatically
@@ -1624,9 +1630,7 @@ function get_series_color(c, sp::Subplot, n::Int, seriestype)
     plot_color(c)
 end
 
-function get_series_color(c::AbstractArray, sp::Subplot, n::Int, seriestype)
-    map(x->get_series_color(x, sp, n, seriestype), c)
-end
+get_series_color(c::AbstractArray, sp::Subplot, n::Int, seriestype) =  map(x->get_series_color(x, sp, n, seriestype), c)
 
 function ensure_gradient!(plotattributes::AKW, csym::Symbol, asym::Symbol)
     if plotattributes[csym] isa ColorPalette

src/axes.jl

@@ -172,8 +172,9 @@ function optimal_ticks_and_labels(ticks, alims, scale, formatter)
         scaled_ticks = optimize_ticks(
             sf(amin),
             sf(amax);
-            k_min = 4, # minimum number of ticks
+            k_min = scale ∈ _logScales ? 2 : 4, # minimum number of ticks
             k_max = 8, # maximum number of ticks
+            scale = scale,
         )[1]
     elseif typeof(ticks) <: Int
         scaled_ticks, viewmin, viewmax = optimize_ticks(
@@ -185,6 +186,7 @@ function optimal_ticks_and_labels(ticks, alims, scale, formatter)
             # `strict_span = false` rewards cases where the span of the
             # chosen  ticks is not too much bigger than amin - amax:
             strict_span = false,
+            scale = scale,
         )
         # axis[:lims] = map(RecipesPipeline.inverse_scale_func(scale), (viewmin, viewmax))
     else
@@ -331,30 +333,48 @@ _transform_ticks(ticks::AbstractArray{T}) where T <: Dates.TimeType = Dates.valu
 _transform_ticks(ticks::NTuple{2, Any}) = (_transform_ticks(ticks[1]), ticks[2])
 
 function get_minor_ticks(sp, axis, ticks)
-    axis[:minorticks] in (:none, nothing, false) && !axis[:minorgrid] && return nothing
+    axis[:minorticks] ∈ (:none, nothing, false) && !axis[:minorgrid] && return nothing
     ticks = ticks[1]
     length(ticks) < 2 && return nothing
 
     amin, amax = axis_limits(sp, axis[:letter])
-    #Add one phantom tick either side of the ticks to ensure minor ticks extend to the axis limits
-    if length(ticks) > 2
-        ratio = (ticks[3] - ticks[2])/(ticks[2] - ticks[1])
-    elseif axis[:scale] in (:none, :identity)
-        ratio = 1
-    else
-        return nothing
-    end
-    first_step = ticks[2] - ticks[1]
-    last_step = ticks[end] - ticks[end-1]
-    ticks =  [ticks[1] - first_step/ratio; ticks; ticks[end] + last_step*ratio]
+    scale = axis[:scale]
+    log_scaled = scale ∈ _logScales
+    base = get(_logScaleBases, scale, nothing)
+
+    # add one phantom tick either side of the ticks to ensure minor ticks extend to the axis limits
+    if log_scaled
+        sub = round(Int, log(base, ticks[2] / ticks[1]))
+        ticks = [ticks[1] / base; ticks; ticks[end] * base]
+    else
+        sub = 1  # unused
+        ratio = length(ticks) > 2 ? (ticks[3] - ticks[2]) / (ticks[2] - ticks[1]) : 1
+        first_step = ticks[2] - ticks[1]
+        last_step = ticks[end] - ticks[end-1]
+        ticks = [ticks[1] - first_step / ratio; ticks; ticks[end] + last_step * ratio]
+    end
+
+    # default to 9 intervals between major ticks for log10 scale and 5 intervals otherwise
+    n_default = (scale == :log10) ? 9 : 5
+    n = typeof(axis[:minorticks]) <: Integer && axis[:minorticks] > 1 ? axis[:minorticks] : n_default
 
-    #Default to 5 intervals between major ticks
-    n = typeof(axis[:minorticks]) <: Integer && axis[:minorticks] > 1 ? axis[:minorticks] : 5
     minorticks = typeof(ticks[1])[]
-    for (i,hi) in enumerate(ticks[2:end])
+    for (i, hi) ∈ enumerate(ticks[2:end])
         lo = ticks[i]
         if isfinite(lo) && isfinite(hi) && hi > lo
-            append!(minorticks,collect(lo + (hi-lo)/n :(hi-lo)/n: hi - (hi-lo)/2n))
+            if log_scaled
+                for e ∈ 1:sub
+                    lo_ = lo * base^(e - 1)
+                    hi_ = lo_ * base
+                    step = (hi_ - lo_) / n
+                    append!(minorticks, collect(
+                        lo_ + (e > 1 ? 0 : step) : step : hi_ - (e < sub ? 0 : step / 2)
+                    ))
+                end
+            else
+                step = (hi - lo) / n
+                append!(minorticks, collect(lo + step : step : hi - step / 2))
+            end
         end
     end
     minorticks[amin .<= minorticks .<= amax]
@@ -492,35 +512,38 @@ end
 # -------------------------------------------------------------------------
 
 # push the limits out slightly
-function widen(lmin, lmax, scale = :identity)
+function widen(lmin, lmax, scale=:identity)
     f, invf = RecipesPipeline.scale_func(scale), RecipesPipeline.inverse_scale_func(scale)
     span = f(lmax) - f(lmin)
     # eps = NaNMath.max(1e-16, min(1e-2span, 1e-10))
     eps = NaNMath.max(1e-16, 0.03span)
-    invf(f(lmin)-eps), invf(f(lmax)+eps)
+    invf(f(lmin) - eps), invf(f(lmax) + eps)
 end
 
 # figure out if widening is a good idea.
 const _widen_seriestypes = (:line, :path, :steppre, :stepmid, :steppost, :sticks, :scatter, :barbins, :barhist, :histogram, :scatterbins, :scatterhist, :stepbins, :stephist, :bins2d, :histogram2d, :bar, :shape, :path3d, :scatter3d)
 
 function default_should_widen(axis::Axis)
-    should_widen = false
-    if !(is_2tuple(axis[:lims]) || axis[:lims] == :round)
-        for sp in axis.sps
-            for series in series_list(sp)
-                if series.plotattributes[:seriestype] in _widen_seriestypes
-                    should_widen = true
-                end
+    if axis[:widen] isa Bool
+        return axis[:widen]
+    end
+    # automatic behavior: widen if limits aren't specified and series type is appropriate
+    (is_2tuple(axis[:lims]) || axis[:lims] == :round) && return false
+    for sp in axis.sps
+        for series in series_list(sp)
+            if series.plotattributes[:seriestype] in _widen_seriestypes
+                return true
             end
         end
     end
-    should_widen
+    false
 end
 
-function round_limits(amin,amax)
-    scale = 10^(1-round(log10(amax - amin)))
-    amin = floor(amin*scale)/scale
-    amax = ceil(amax*scale)/scale
+function round_limits(amin, amax, scale)
+    base = get(_logScaleBases, scale, 10.)
+    factor = base^(1 - round(log(base, amax - amin)))
+    amin = floor(amin * factor) / factor
+    amax = ceil(amax * factor) / factor
     amin, amax
 end
 
@@ -533,13 +556,20 @@ function axis_limits(sp, letter, should_widen = default_should_widen(sp[Symbol(l
     has_user_lims = (isa(lims, Tuple) || isa(lims, AVec)) && length(lims) == 2
     if has_user_lims
         lmin, lmax = lims
-        if lmin != :auto && isfinite(lmin)
+        if lmin == :auto
+        elseif isfinite(lmin)
             amin = lmin
         end
-        if lmax != :auto && isfinite(lmax)
+        if lmax == :auto
+        elseif isfinite(lmax)
             amax = lmax
         end
     end
+    if lims == :symmetric
+        aval = max(abs(amin), abs(amax))
+        amin = -aval
+        amax = aval
+    end
     if amax <= amin && isfinite(amin)
         amax = amin + 1.0
     end
@@ -550,20 +580,23 @@ function axis_limits(sp, letter, should_widen = default_should_widen(sp[Symbol(l
         if axis[:letter] == :x
             amin, amax = 0, 2pi
         elseif lims == :auto
-            #widen max radius so ticks dont overlap with theta axis
+            # widen max radius so ticks dont overlap with theta axis
             0, amax + 0.1 * abs(amax - amin)
         else
             amin, amax
         end
-    elseif should_widen && axis[:widen]
+    elseif should_widen
         widen(amin, amax, axis[:scale])
     elseif lims == :round
-        round_limits(amin,amax)
+        round_limits(amin, amax, axis[:scale])
     else
         amin, amax
     end
 
-    if !has_user_lims && consider_aspect && letter in (:x, :y) && !(sp[:aspect_ratio] in (:none, :auto) || RecipesPipeline.is3d(:sp))
+    if (
+        !has_user_lims && consider_aspect && letter in (:x, :y) &&
+        !(sp[:aspect_ratio] in (:none, :auto) || RecipesPipeline.is3d(:sp))
+    )
         aspect_ratio = isa(sp[:aspect_ratio], Number) ? sp[:aspect_ratio] : 1
         plot_ratio = height(plotarea(sp)) / width(plotarea(sp))
         dist = amax - amin
@@ -694,62 +727,50 @@ function axis_drawing_info(sp, letter)
                 )
             end
         end
-        if !(ax[:ticks] in (:none, nothing, false))
+        if ax[:ticks] ∉ (:none, nothing, false)
             f = RecipesPipeline.scale_func(oax[:scale])
             invf = RecipesPipeline.inverse_scale_func(oax[:scale])
-            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] && ax[:tick_direction] !== :none
-                    push!(
-                        tick_segments,
-                        reverse_if((tick, tick_start), isy),
-                        reverse_if((tick, tick_stop), isy),
-                    )
+            add_major_or_minor_segments(ticks, grid, segments, factor, cond) = begin
+                ticks === nothing && return
+                if cond
+                    tick_start, tick_stop = if sp[:framestyle] == :origin
+                        t = invf(f(0) + factor * (f(oamax) - f(oamin)))
+                        (-t, t)
+                    else
+                        ticks_in = ax[:tick_direction] == :out ? -1 : 1
+                        t = invf(f(oa1) + factor * (f(oa2) - f(oa1)) * ticks_in)
+                        (oa1, t)
+                    end
                 end
-                if ax[:grid]
-                    push!(
-                        grid_segments,
-                        reverse_if((tick, oamin), isy),
-                        reverse_if((tick, oamax), isy),
-                    )
-                end
-            end
 
-            if !(ax[:minorticks] in (:none, nothing, false)) || ax[:minorgrid]
-                tick_start, tick_stop = if sp[:framestyle] == :origin
-                    t = invf(f(0) + 0.006 * (f(oamax) - f(oamin)))
-                    (-t, t)
-                else
-                    t = invf(f(oa1) + 0.006 * (f(oa2) - f(oa1)) * ticks_in)
-                    (oa1, t)
-                end
-                for tick in minor_ticks
-                    if ax[:showaxis]
+                for tick in ticks
+                    if ax[:showaxis] && cond
                         push!(
                             tick_segments,
                             reverse_if((tick, tick_start), isy),
                             reverse_if((tick, tick_stop), isy),
                         )
                     end
-                    if ax[:minorgrid] 
+                    if grid
                         push!(
-                            minorgrid_segments,
+                            segments,
                             reverse_if((tick, oamin), isy),
                             reverse_if((tick, oamax), isy),
                         )
                     end
                 end
             end
+
+            ax_length = letter === :x ? height(sp.plotarea).value : width(sp.plotarea).value
+
+            # add major grid segments
+            add_major_or_minor_segments(ticks[1], ax[:grid], grid_segments, 1.2 / ax_length, ax[:tick_direction] !== :none)
+
+            # add minor grid segments
+            if ax[:minorticks] ∉ (:none, nothing, false) || ax[:minorgrid]
+                add_major_or_minor_segments(minor_ticks, ax[:minorgrid], minorgrid_segments, 0.6 / ax_length, true)
+            end
         end
     end
 
@@ -832,74 +853,57 @@ function axis_drawing_info_3d(sp, letter)
                 )
             end
         end
-        # TODO this can be simplified, we do almost the same thing twice for grid and minorgrid
-        if !(ax[:ticks] in (:none, nothing, false))
+
+        if ax[:ticks] ∉ (:none, nothing, false)
             f = RecipesPipeline.scale_func(nax[:scale])
             invf = RecipesPipeline.inverse_scale_func(nax[:scale])
-            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] && ax[:tick_direction] !== :none
-                    push!(
-                        tick_segments,
-                        sort_3d_axes(tick, tick_start, fa0, letter),
-                        sort_3d_axes(tick, tick_stop, fa0, letter),
-                    )
-                end
-                if ax[:grid]
-                    push!(
-                        grid_segments,
-                        sort_3d_axes(tick, ga0, fa0, letter),
-                        sort_3d_axes(tick, ga1, fa0, letter),
-                    )
-                    push!(
-                        grid_segments,
-                        sort_3d_axes(tick, ga1, fa0, letter),
-                        sort_3d_axes(tick, ga1, fa1, letter),
-                    )
-                end
-            end
 
-            if !(ax[:minorticks] in (:none, nothing, false)) || ax[:minorgrid]
-                tick_start, tick_stop = if sp[:framestyle] == :origin
-                    t = invf(f(0) + 0.006 * (f(namax) - f(namin)))
-                    (-t, t)
-                else
-                    t = invf(f(na0) + 0.006 * (f(na1) - f(na0)) * ticks_in)
-                    (na0, t)
+            add_major_or_minor_segments(ticks, grid, segments, factor, cond) = begin
+                ticks === nothing && return
+                if cond
+                    tick_start, tick_stop = if sp[:framestyle] == :origin
+                        t = invf(f(0) + factor * (f(namax) - f(namin)))
+                        (-t, t)
+                    else
+                        ticks_in = ax[:tick_direction] == :out ? -1 : 1
+                        t = invf(f(na0) + factor * (f(na1) - f(na0)) * ticks_in)
+                        (na0, t)
+                    end
                 end
-                for tick in minor_ticks
-                    if ax[:showaxis] && ax[:tick_direction] !== :none
+
+                for tick in ticks
+                    if ax[:showaxis] && cond
                         push!(
                             tick_segments,
                             sort_3d_axes(tick, tick_start, fa0, letter),
                             sort_3d_axes(tick, tick_stop, fa0, letter),
                         )
                     end
-                    if ax[:minorgrid]
+                    if grid
+                        fa0_, fa1_ = reverse_if((fa0, fa1), ax[:mirror])
+                        ga0_, ga1_ = reverse_if((ga0, ga1), ax[:mirror])
                         push!(
-                            minorgrid_segments,
-                            sort_3d_axes(tick, ga0, fa0, letter),
-                            sort_3d_axes(tick, ga1, fa0, letter),
+                            segments,
+                            sort_3d_axes(tick, ga0_, fa0_, letter),
+                            sort_3d_axes(tick, ga1_, fa0_, letter),
                         )
                         push!(
-                            minorgrid_segments,
-                            sort_3d_axes(tick, ga1, fa0, letter),
-                            sort_3d_axes(tick, ga1, fa1, letter),
+                            segments,
+                            sort_3d_axes(tick, ga1_, fa0_, letter),
+                            sort_3d_axes(tick, ga1_, fa1_, letter),
                         )
                     end
                 end
             end
+
+            # add major grid segments
+            add_major_or_minor_segments(ticks[1], ax[:grid], grid_segments, 0.012, ax[:tick_direction] !== :none)
+
+            # add minor grid segments
+            if ax[:minorticks] ∉ (:none, nothing, false) || ax[:minorgrid]
+                add_major_or_minor_segments(minor_ticks, ax[:minorgrid], minorgrid_segments, 0.006, true)
+            end
         end
     end
 

src/backends.jl

@@ -256,6 +256,7 @@ end
 @init_backend PGFPlotsX
 @init_backend InspectDR
 @init_backend HDF5
+@init_backend Gaston
 
 # ---------------------------------------------------------
 
@@ -326,6 +327,9 @@ const _gr_attr = merge_with_base_supported([
     :guidefontrotation, :guidefontcolor,
     :grid, :gridalpha, :gridstyle, :gridlinewidth,
     :legend, :legendtitle, :colorbar, :colorbar_title, :colorbar_entry,
+    :colorbar_titlefontfamily, :colorbar_titlefontsize,
+    :colorbar_titlefontvalign, :colorbar_titlefonthalign,
+    :colorbar_titlefontrotation, :colorbar_titlefontcolor,
     :fill_z, :line_z, :marker_z, :levels,
     :ribbon, :quiver,
     :orientation,
@@ -352,6 +356,7 @@ const _gr_seriestype = [
     :scatter3d,
     :surface,
     :wireframe,
+    :mesh3d,
     :volume,
     :shape,
 ]
@@ -574,6 +579,102 @@ 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,
+    :scatter3d,
+    :contour3d,
+    :wireframe,
+    :heatmap,
+    :surface,
+    :mesh3d,
+    :image,
+]
+
+const _gaston_style = [
+    :auto,
+   :solid,
+   :dash,
+   :dot,
+   :dashdot,
+   :dashdotdot
+]
+
+const _gaston_marker = [
+    :none,
+    :auto,
+    :pixel,
+    :cross,
+    :xcross,
+    :+,
+    :x,
+    :star5,
+    :rect,
+    :circle,
+    :utriangle,
+    :dtriangle,
+    :diamond,
+    :pentagon,
+    # :hline,
+    # :vline,
+]
+
+const _gaston_scale = [:identity, :ln, :log2, :log10]
+
 # ------------------------------------------------------------------------------
 # unicodeplots
 
@@ -663,7 +764,7 @@ const HDF5PLOT_MAP_TELEM2STR = Dict{Type, String}()
 
 #Don't really like this global variable... Very hacky
 mutable struct HDF5Plot_PlotRef
-	ref::Union{Plot, Nothing}
+    ref::Union{Plot, Nothing}
 end
 const HDF5PLOT_PLOTREF = HDF5Plot_PlotRef(nothing)
 

src/backends/gaston.jl

@@ -0,0 +1,540 @@
+# https://github.com/mbaz/Gaston.
+
+# --------------------------------------------
+# These functions are called by Plots
+# --------------------------------------------
+
+# Create the window/figure for this backend.
+function _create_backend_figure(plt::Plot{GastonBackend})
+    state_handle = Gaston.nexthandle() # for now all the figures will be kept
+    plt.o = Gaston.newfigure(state_handle)
+end
+
+function _before_layout_calcs(plt::Plot{GastonBackend})
+    # Initialize all the subplots first
+    plt.o.subplots = Gaston.SubPlot[]
+
+    n1 = n2 = 0
+    if length(plt.inset_subplots) > 0
+        n1, sps = gaston_get_subplots(0, plt.inset_subplots, plt.layout)
+        gaston_init_subplots(plt, sps)
+    end
+
+    if length(plt.subplots) > 0
+        n2, sps = gaston_get_subplots(0, plt.subplots, plt.layout)
+    end
+
+    if (n = n1 + n2) != length(plt.subplots)
+        @error "Gaston: $n != $(length(plt.subplots))"
+    end
+
+    plt.o.layout = gaston_init_subplots(plt, sps)
+
+    # Then add the series (curves in gaston)
+    for series ∈ plt.series_list
+        gaston_add_series(plt, series)
+    end
+    
+    for sp ∈ plt.subplots
+        sp === nothing && continue
+        for ann in sp[:annotations]
+            x, y, val = locate_annotation(sp, ann...)
+            sp.o.axesconf *= "\nset label '$(val.str)' at $x,$y $(gaston_font(val.font))"
+        end
+    end
+    nothing
+end
+
+function _update_min_padding!(sp::Subplot{GastonBackend})
+    sp.minpad = 0mm, 0mm, 0mm, 0mm
+end
+
+function _update_plot_object(plt::Plot{GastonBackend})
+    # respect the layout ratio
+    dat = gaston_multiplot_pos_size(plt.layout, (0, 0, 1, 1))
+    gaston_multiplot_pos_size!(dat)
+end
+
+for (mime, term) ∈ (
+    "application/eps"        => "epscairo",
+    "image/eps"              => "epslatex",
+    "application/pdf"        => "pdfcairo",
+    "application/postscript" => "postscript",
+    "image/png"              => "png",
+    "image/svg+xml"          => "svg",
+    "text/latex"             => "tikz",
+    "application/x-tex"      => "epslatex",
+    "text/plain"             => "dumb",
+)
+    @eval function _show(io::IO, ::MIME{Symbol($mime)}, plt::Plot{GastonBackend})
+        term = String($term); tmpfile = "$(Gaston.tempname()).$term"
+
+        Gaston.save(term=term, output=tmpfile, handle=plt.o.handle, saveopts=gaston_saveopts(plt))
+        while !isfile(tmpfile) end  # avoid race condition with read in next line
+        write(io, read(tmpfile))
+        rm(tmpfile, force=true)
+        nothing
+    end
+end
+
+_display(plt::Plot{GastonBackend}) = display(plt.o)
+
+# --------------------------------------------
+# These functions are gaston specific
+# --------------------------------------------
+
+function gaston_saveopts(plt::Plot{GastonBackend})
+    saveopts = String["size $(join(plt.attr[:size], ","))"]
+
+    push!(saveopts, gaston_font(plottitlefont(plt), rot=false, align=false, color=false, scale=1))
+
+    push!(saveopts, "background $(gaston_color(plt.attr[:background_color]))")
+
+    # push!(saveopts, "title '$(plt.attr[:window_title])'")
+
+    # Scale all plot elements to match Plots.jl DPI standard
+    scaling = plt.attr[:dpi] / Plots.DPI
+    push!(saveopts, "fontscale $scaling lw $scaling dl $scaling ps $scaling")
+    
+    return join(saveopts, " ")
+end
+
+function gaston_get_subplots(n, plt_subplots, layout)
+    nr, nc = size(layout)
+    sps = Array{Any}(nothing, nr, nc)
+    for r ∈ 1:nr, c ∈ 1:nc  # NOTE: col major
+        l = layout[r, c]
+        if l isa GridLayout
+            n, sub = gaston_get_subplots(n, plt_subplots, l)
+            sps[r, c] = size(sub) == (1, 1) ? only(sub) : sub
+        else
+            sps[r, c] = get(l.attr, :blank, false) ? nothing : plt_subplots[n += 1]
+        end
+    end
+    return n, sps
+end
+
+function gaston_init_subplots(plt, sps)
+    sz = nr, nc = size(sps)
+    for c ∈ 1:nc, r ∈ 1:nr  # NOTE: row major
+        sp = sps[r, c]
+        if sp isa Subplot || sp === nothing
+            gaston_init_subplot(plt, sp)
+        else
+            gaston_init_subplots(plt, sp)
+            sz = max.(sz, size(sp))
+        end
+    end
+    return sz
+end
+
+function gaston_init_subplot(plt::Plot{GastonBackend}, sp::Union{Nothing,Subplot{GastonBackend}})
+    if sp === nothing
+        push!(plt.o.subplots, sp)
+    else
+        dims = RecipesPipeline.is3d(sp) || sp.attr[:projection] == "3d" || needs_any_3d_axes(sp) ? 3 : 2
+        any_label = false
+        for series ∈ series_list(sp)
+            if dims == 2 && series[:seriestype] ∈ (:heatmap, :contour)
+                dims = 3  # we need heatmap/contour to use splot, not plot
+            end
+            any_label |= should_add_to_legend(series)
+        end
+        sp.o = Gaston.Plot(
+            dims=dims, curves=[], axesconf=gaston_parse_axes_args(plt, sp, dims, any_label),
+        )
+        push!(plt.o.subplots, sp.o)
+    end
+    nothing
+end
+
+function gaston_multiplot_pos_size(layout, parent_xy_wh)
+    nr, nc = size(layout)
+    dat = Array{Any}(nothing, nr, nc)
+    for r ∈ 1:nr, c ∈ 1:nc
+        l = layout[r, c]
+        # width and height (pct) are multiplicative (parent)
+        w = layout.widths[c].value * parent_xy_wh[3]
+        h = layout.heights[r].value * parent_xy_wh[4]
+        if isa(l, EmptyLayout)
+            dat[r, c] = (c - 1) * w, (r - 1) * h, w, h, nothing
+        else
+            # previous position (origin)
+            prev_r = r > 1 ? dat[r - 1, c] : nothing
+            prev_c = c > 1 ? dat[r, c - 1] : nothing
+            prev_r isa Array && (prev_r = prev_r[end, end])
+            prev_c isa Array && (prev_c = prev_c[end, end])
+            x = prev_c !== nothing ? prev_c[1] + prev_c[3] : parent_xy_wh[1]
+            y = prev_r !== nothing ? prev_r[2] + prev_r[4] : parent_xy_wh[2]
+            if l isa GridLayout
+                sub = gaston_multiplot_pos_size(l, (x, y, w, h))
+                dat[r, c] = size(sub) == (1, 1) ? only(sub) : sub
+            else
+                dat[r, c] = x, y, w, h, l
+            end
+        end
+    end
+    return dat
+end
+
+function gaston_multiplot_pos_size!(dat)
+    nr, nc = size(dat)
+    for r ∈ 1:nr, c ∈ 1:nc
+        xy_wh_sp = dat[r, c]
+        if xy_wh_sp isa Array
+            gaston_multiplot_pos_size!(xy_wh_sp)
+        elseif xy_wh_sp isa Tuple
+            x, y, w, h, sp = xy_wh_sp
+            sp === nothing && continue
+            sp.o === nothing && continue
+            # gnuplot screen coordinates: bottom left at 0,0 and top right at 1,1
+            sp.o.axesconf = "set origin $x, $(1 - y - h)\nset size $w, $h\n" * sp.o.axesconf
+        end
+    end
+    nothing
+end
+
+function gaston_add_series(plt::Plot{GastonBackend}, series::Series)
+    sp = series[:subplot]; gsp = sp.o
+    x, y, z = series[:x], series[:y], series[:z]
+    st = series[:seriestype]
+
+    curves = []
+    if gsp.dims == 2 && z === nothing
+        for (n, seg) ∈ enumerate(series_segments(series, st; check=true))
+            i, rng = seg.attr_index, seg.range
+            for sc ∈ gaston_seriesconf!(sp, series, i, n == 1)
+                push!(curves, Gaston.Curve(x[rng], y[rng], nothing, nothing, sc))
+            end
+        end
+    else
+        if z isa Surface
+            z = z.surf
+            if st == :image
+                z = Float32.(Gray.(z))
+                nr, nc = size(z)
+                lx = length(x)
+                if lx == 2 && lx != nr
+                    x = collect(range(x[1], x[2], length=nr))
+                end
+                ly = length(y)
+                if ly == 2 && ly != nc
+                    y = collect(range(y[1], y[2], length=nc))
+                end
+            elseif st == :heatmap
+                length(x) == size(z, 2) + 1 && (x = @view x[1:end-1])
+                length(y) == size(z, 1) + 1 && (y = @view y[1:end-1])
+            end
+        end
+        for sc ∈ gaston_seriesconf!(sp, series, 1, true)
+            push!(curves, Gaston.Curve(x, y, z, nothing, sc))
+        end
+    end
+
+    for c ∈ curves
+        append = length(gsp.curves) > 0; push!(gsp.curves, c)
+        Gaston.write_data(c, gsp.dims, gsp.datafile, append=append)
+    end
+    nothing
+end
+
+function gaston_seriesconf!(sp::Subplot{GastonBackend}, series::Series, i::Int, add_to_legend::Bool)
+    #=
+    gnuplot abbreviations (see gnuplot/src/set.c)
+    ---------------------------------------------
+    dl: dashlength
+    dt: dashtype
+    fc: fillcolor
+    fs: fillstyle
+    lc: linecolor
+    lp: linespoints
+    ls: linestyle
+    lt: linetype
+    lw: linewidth
+    pi: pointinterval
+    pn: pointnumber
+    ps: pointscale
+    pt: pointtype
+    tc: textcolor
+    w: with 
+    =#
+    gsp = sp.o; st = series[:seriestype]; extra = []
+    add_to_legend &= should_add_to_legend(series)
+    curveconf = String[add_to_legend ? "title '$(series[:label])'" : "notitle"]
+
+    clims = get_clims(sp, series)
+    if st ∈ (:scatter, :scatter3d)
+        lc, dt, lw = gaston_lc_ls_lw(series, clims, i)
+        pt, ps, mc = gaston_mk_ms_mc(series, clims, i)
+        push!(curveconf, "w points pt $pt ps $ps lc $mc")
+    elseif st ∈ (:path, :straightline, :path3d)
+        lc, dt, lw = gaston_lc_ls_lw(series, clims, i)
+        if series[:markershape] == :none  # simplepath
+            push!(curveconf, "w lines lc $lc dt $dt lw $lw")
+        else
+            pt, ps, mc = gaston_mk_ms_mc(series, clims, i)
+            push!(curveconf, "w lp lc $mc dt $dt lw $lw pt $pt ps $ps")
+        end
+    elseif st == :shape
+        fc = gaston_color(get_fillcolor(series, i), get_fillalpha(series, i))
+        lc, _ = gaston_lc_ls_lw(series, clims, i)
+        push!(curveconf, "w filledcurves fc $fc fs solid border lc $lc")
+    elseif st ∈ (:steppre, :stepmid, :steppost)
+        step = if st == :steppre
+            "fsteps"
+        elseif st == :stepmid
+            "histeps"
+        elseif st == :steppost
+            "steps"
+        end
+        push!(curveconf, "w $step")
+        lc, dt, lw = gaston_lc_ls_lw(series, clims, i)
+        push!(extra, "w points lc $lc dt $dt lw $lw notitle")
+    elseif st == :image
+        palette = gaston_palette(series[:seriescolor])
+        gsp.axesconf *= "\nset palette model RGB defined $palette"
+        push!(curveconf, "w image pixels")
+    elseif st ∈ (:contour, :contour3d)
+        push!(curveconf, "w lines")
+        st == :contour && (gsp.axesconf *= "\nset view map\nunset surface")  # 2D
+        levels = join(map(string, collect(contour_levels(series, clims))), ", ")
+        gsp.axesconf *= "\nset contour base\nset cntrparam levels discrete $levels"
+    elseif st ∈ (:surface, :heatmap)
+        push!(curveconf, "w pm3d")
+        palette = gaston_palette(series[:seriescolor])
+        gsp.axesconf *= "\nset palette model RGB defined $palette"
+        st == :heatmap && (gsp.axesconf *= "\nset view map")
+    elseif st == :wireframe
+        lc, dt, lw = gaston_lc_ls_lw(series, clims, i)
+        push!(curveconf, "w lines lc $lc dt $dt lw $lw")
+    else
+        @warn "Gaston: $st is not implemented yet"
+    end
+
+    return [join(curveconf, " "), extra...]
+end
+
+function gaston_parse_axes_args(
+    plt::Plot{GastonBackend}, sp::Subplot{GastonBackend}, dims::Int, any_label::Bool
+)
+    # axesconf = String["set margins 2, 2, 2, 2"]  # left, right, bottom, top
+    axesconf = String[]
+
+    polar = ispolar(sp) && dims == 2  # cannot splot in polar coordinates
+
+    for letter ∈ (:x, :y, :z)
+        (letter == :z && dims == 2) && continue
+        axis = sp.attr[Symbol(letter, :axis)]
+        # label names
+        push!(axesconf, "set $(letter)label '$(axis[:guide])' $(gaston_font(guidefont(axis)))")
+        mirror = axis[:mirror] ? "mirror" : "nomirror"
+
+        if axis[:scale] == :identity
+            logscale, base = "nologscale", ""
+        elseif axis[:scale] == :log10
+            logscale, base = "logscale", "10"
+        elseif axis[:scale] == :log2
+            logscale, base = "logscale", "2"
+        elseif axis[:scale] == :ln
+            logscale, base = "logscale", "e"
+        end
+        push!(axesconf, "set $logscale $letter $base")
+
+        # handle ticks
+        if polar
+            push!(axesconf, "set size square\nunset $(letter)tics")
+        else
+            push!(axesconf, "set $(letter)tics $(mirror) $(axis[:tick_direction]) $(gaston_font(tickfont(axis)))")
+
+            # major tick locations
+            if axis[:ticks] != :native
+                if axis[:flip]
+                    hi, lo = axis_limits(sp, letter)
+                else
+                    lo, hi = axis_limits(sp, letter)
+                end
+                push!(axesconf, "set $(letter)range [$lo:$hi]")
+
+                ticks = get_ticks(sp, axis)
+                gaston_set_ticks!(axesconf, ticks, letter, "", "")
+
+                if axis[:minorticks] != :native
+                    minor_ticks = get_minor_ticks(sp, axis, ticks)
+                    gaston_set_ticks!(axesconf, minor_ticks, letter, "m", "add")
+                end
+            end
+        end
+
+        if axis[:grid]
+            push!(axesconf, "set grid " * (polar ? "polar" : "$(letter)tics"))
+            axis[:minorgrid] && push!(axesconf, "set grid " * (polar ? "polar" : "m$(letter)tics"))
+        end
+
+        ratio = get_aspect_ratio(sp)
+        if ratio != :none
+            ratio == :equal && (ratio = -1)
+            push!(axesconf, "set size ratio $ratio")
+        end
+    end
+    gaston_set_legend!(axesconf, sp, any_label)
+
+    if hascolorbar(sp)
+        push!(axesconf, "set cbtics $(gaston_font(colorbartitlefont(sp)))")
+    end
+
+    if sp[:title] !== nothing
+        push!(axesconf, "set title '$(sp[:title])' $(gaston_font(titlefont(sp)))")
+    end
+
+    if polar
+        push!(axesconf, "unset border\nset polar\nset border polar")
+        tmin, tmax = axis_limits(sp, :x, false, false)
+        rmin, rmax = axis_limits(sp, :y, false, false)
+        rticks = get_ticks(sp, :y)
+        if (ttype = ticksType(rticks)) == :ticks
+            gaston_ticks = string.(rticks)
+        elseif ttype == :ticks_and_labels
+            gaston_ticks = String["'$l' $t" for (t, l) ∈ zip(rticks...)]
+        end
+        push!(axesconf, "set rtics ( " * join(gaston_ticks, ", ") * " ) $(gaston_font(tickfont(sp.attr[:yaxis])))")
+        push!(axesconf, "set trange [$(min(0, tmin)):$(max(2π, tmax))]")
+        push!(axesconf, "set rrange [$rmin:$rmax]")
+        push!(axesconf, "set ttics 0,30 format \"%g\".GPVAL_DEGREE_SIGN $(gaston_font(tickfont(sp.attr[:xaxis])))")
+        push!(axesconf, "set mttics 3")
+    end
+
+    return join(axesconf, "\n")
+end
+
+function gaston_set_ticks!(axesconf, ticks, letter, maj_min, add)
+    ticks == :auto && return
+    if ticks ∈ (:none, nothing, false)
+        push!(axesconf, "unset $(maj_min)$(letter)tics")
+        return
+    end
+
+    gaston_ticks = String[]
+    if (ttype = ticksType(ticks)) == :ticks
+        tick_locs = @view ticks[:]
+        for i ∈ eachindex(tick_locs)
+            tick = if maj_min == "m"
+                "'' $(tick_locs[i]) 1"  # see gnuplot manual 'Mxtics'
+            else
+                "$(tick_locs[i])"
+            end
+            push!(gaston_ticks, tick)
+        end
+    elseif ttype == :ticks_and_labels
+        tick_locs = @view ticks[1][:]
+        tick_labels = @view ticks[2][:]
+        for i ∈ eachindex(tick_locs)
+            lab = gaston_enclose_tick_string(tick_labels[i])
+            push!(gaston_ticks, "'$lab' $(tick_locs[i])")
+        end
+    else
+        gaston_ticks = nothing
+        @error "Gaston: invalid input for $(maj_min)$(letter)ticks: $ticks"
+    end
+    if gaston_ticks !== nothing
+        push!(axesconf, "set $(letter)tics $add (" * join(gaston_ticks, ", ") * ")")
+    end
+    nothing
+end
+
+function gaston_set_legend!(axesconf, sp, any_label)
+    leg = sp[:legend]
+    if sp[:legend] ∉ (:none, :inline) && any_label
+        leg == :best && (leg = :topright)
+
+        push!(axesconf, "set key " * (occursin("outer", string(leg)) ? "outside" : "inside"))
+        for position ∈ ("top", "bottom", "left", "right")
+            occursin(position, string(leg)) && push!(axesconf, "set key $position")
+        end
+        push!(axesconf, "set key $(gaston_font(legendfont(sp), rot=false, align=false))")
+        if sp[:legendtitle] !== nothing
+            # NOTE: cannot use legendtitlefont(sp) as it will override legendfont
+            push!(axesconf, "set key title '$(sp[:legendtitle])'")
+        end
+        push!(axesconf, "set key box lw 1 opaque")
+        push!(axesconf, "set border back")
+    else
+        push!(axesconf, "set key off")
+    end
+    nothing
+end
+
+# --------------------------------------------
+# Helpers
+# --------------------------------------------
+
+function gaston_font(f; rot=true, align=true, color=true, scale=1)
+    font = String["font '$(f.family),$(round(Int, scale * f.pointsize))'"]
+    align && push!(font, "$(gaston_halign(f.halign))")
+    rot && push!(font, "rotate by $(f.rotation)")
+    color && push!(font, "textcolor $(gaston_color(f.color))")
+    return join(font, " ")
+end
+
+gaston_halign(k) = (left=:left, hcenter=:center, right=:right)[k]
+gaston_valign(k) = (top=:top, vcenter=:center, bottom=:bottom)[k]
+
+gaston_alpha(alpha) = alpha === nothing ? 0 : alpha
+
+gaston_lc_ls_lw(series::Series, clims, i::Int) = (
+    gaston_color(get_linecolor(series, clims, i), get_linealpha(series, i)),
+    gaston_linestyle(get_linestyle(series, i)),
+    get_linewidth(series, i),
+)
+
+gaston_mk_ms_mc(series::Series, clims, i::Int) = (
+    gaston_marker(_cycle(series[:markershape], i), get_markeralpha(series, i)),
+    _cycle(series[:markersize], i) * 1.3 / 5,
+    gaston_color(get_markercolor(series, clims, i), get_markeralpha(series, i)),
+)
+
+function gaston_palette(gradient)
+    palette = String[]; n = -1
+    for rgba ∈ gradient  # FIXME: naive conversion, inefficient ?
+        push!(palette, "$(n += 1) $(rgba.r) $(rgba.g) $(rgba.b)")
+    end
+    return '(' * join(palette, ", ") * ')'
+end
+
+function gaston_marker(marker, alpha)
+    # NOTE: :rtriangle, :ltriangle, :hexagon, :heptagon, :octagon seems unsupported by gnuplot
+    filled = gaston_alpha(alpha) == 0
+    marker == :none && return -1
+    marker == :pixel && return 0
+    marker ∈ (:+, :cross) && return 1
+    marker ∈ (:x, :xcross) && return 2
+    marker == :star5 && return 3
+    marker == :rect && return filled ? 5 : 4
+    marker == :circle && return filled ? 7 : 6
+    marker == :utriangle && return filled ? 9 : 8
+    marker == :dtriangle && return filled ? 11 : 10
+    marker == :diamond && return filled ? 13 : 12
+    marker == :pentagon && return filled ? 15 : 14
+
+    @warn "Gaston: unsupported marker $marker"
+    return 1
+end
+
+function gaston_color(col, alpha=0)
+    col = single_color(col)  # in case of gradients
+    col = alphacolor(col, gaston_alpha(alpha))  # add a default alpha if non existent
+    return "rgb '#$(hex(col, :aarrggbb))'"
+end
+
+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)
+    findfirst("^", tick_string) === nothing && return tick_string
+    base, power = split(tick_string, "^")
+    return "$base^{$power}"
+end

src/backends/gr.jl

@@ -326,13 +326,15 @@ end
 # draw ONE Shape
 function gr_draw_marker(series, xi, yi, clims, i, msize, strokewidth, shape::Shape)
     sx, sy = coords(shape)
-    # convert to ndc coords (percentages of window)
-    GR.selntran(0)
+    # convert to ndc coords (percentages of window) ...
     w, h = get_size(series)
     f = msize / (w + h)
+
     xi, yi = GR.wctondc(xi, yi)
-    xs = xi .+ sx .* f
-    ys = yi .+ sy .* f
+
+    # ... convert back to world coordinates
+    xs_ys = GR.ndctowc.(xi .+ sx .* f, yi .+ sy .* f)
+    xs, ys = getindex.(xs_ys, 1), getindex.(xs_ys, 2)
 
     # draw the interior
     mc = get_markercolor(series, clims, i)
@@ -345,7 +347,6 @@ function gr_draw_marker(series, xi, yi, clims, i, msize, strokewidth, shape::Sha
     gr_set_line(strokewidth, :solid, msc, series)
     gr_set_transparency(msc, get_markerstrokealpha(series, i))
     GR.polyline(xs, ys)
-    GR.selntran(1)
 end
 
 function gr_nominal_size(s)
@@ -355,9 +356,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))
@@ -399,14 +400,6 @@ function gr_set_font(f::Font, s; halign = f.halign, valign = f.valign,
     GR.settextalign(gr_halign(halign), gr_valign(valign))
 end
 
-function gr_nans_to_infs!(z)
-    for (i,zi) in enumerate(z)
-        if zi == NaN
-            z[i] = Inf
-        end
-    end
-end
-
 function gr_w3tondc(x, y, z)
     xw, yw, zw = GR.wc3towc(x, y, z)
     x, y = GR.wctondc(xw, yw)
@@ -524,7 +517,7 @@ function gr_draw_colorbar(cbar::GRColorbar, sp::Subplot, clims, viewport_plotare
         levels = _cbar_unique(contour_levels.(series, Ref(clims)), "levels")
         # GR implicitly uses the maximal z value as the highest level
         if levels[end] < clims[2]
-            @warn("GR: highest contour level less than maximal z value is not supported.")
+            @warn "GR: highest contour level less than maximal z value is not supported."
             # replace levels, rather than assign to levels[end], to ensure type
             # promotion in case levels is an integer array
             levels = [levels[1:end-1]; clims[2]]
@@ -558,11 +551,16 @@ function gr_draw_colorbar(cbar::GRColorbar, sp::Subplot, clims, viewport_plotare
     gr_set_line(1, :solid, plot_color(:black), sp)
     GR.axes(0, ztick, xmax, zmin, 0, 1, 0.005)
 
-    gr_set_font(guidefont(sp[:yaxis]), sp)
+    title = if isa(sp[:colorbar_title], PlotText)
+        sp[:colorbar_title]
+    else
+        text(sp[:colorbar_title], colorbartitlefont(sp))
+    end
+    gr_set_font(title.font, sp)
     GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_TOP)
     GR.setcharup(-1, 0)
     gr_text(
-        viewport_plotarea[2] + 0.1, gr_view_ycenter(viewport_plotarea), sp[:colorbar_title]
+        viewport_plotarea[2] + 0.1, gr_view_ycenter(viewport_plotarea), title.str
     )
 
     GR.restorestate()
@@ -612,7 +610,7 @@ end
 function gr_display(plt::Plot, fmt="")
     GR.clearws()
 
-    dpi_factor = plt[:dpi] / Plots.DPI
+    dpi_factor = fmt == "png" ? plt[:dpi] / Plots.DPI : 1
 
     # collect some monitor/display sizes in meters and pixels
     display_width_meters, display_height_meters, display_width_px, display_height_px = GR.inqdspsize()
@@ -651,12 +649,17 @@ end
 
 function gr_set_tickfont(sp, letter)
     axis = sp[Symbol(letter, :axis)]
+
+    # invalidate alignment changes for small rotations (|θ| < 45°)
+    trigger(rot) = abs(sind(rot)) < abs(cosd(rot)) ? 0 : sign(rot)
+
+    rot = axis[:rotation]
     if letter === :x || (RecipesPipeline.is3d(sp) && letter === :y)
-        halign = (:left, :hcenter, :right)[sign(axis[:rotation]) + 2]
-        valign = (axis[:mirror] ? :bottom : :top)
+        halign = (:left, :hcenter, :right)[trigger(rot) + 2]
+        valign = (axis[:mirror] ? :bottom : :top, :vcenter)[trigger(abs(rot)) + 1]
     else
-        halign = (axis[:mirror] ? :left : :right)
-        valign = (:top, :vcenter, :bottom)[sign(axis[:rotation]) + 2]
+        halign = (axis[:mirror] ? :left : :right, :hcenter)[trigger(abs(rot)) + 1]
+        valign = (:top, :vcenter, :bottom)[trigger(rot) + 2]
     end
     gr_set_font(
         tickfont(axis),
@@ -979,7 +982,7 @@ end
 ## Legend
 
 function gr_add_legend(sp, leg, viewport_plotarea)
-    if !(sp[:legend] in(:none, :inline))
+    if sp[:legend] ∉ (:none, :inline)
         GR.savestate()
         GR.selntran(0)
         GR.setscale(0)
@@ -1157,25 +1160,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)
@@ -1192,7 +1195,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 (
@@ -1282,12 +1286,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)
@@ -1310,8 +1324,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]))
@@ -1322,7 +1342,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)
@@ -1352,7 +1372,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)]
 
@@ -1364,8 +1384,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)
@@ -1382,7 +1404,7 @@ function gr_draw_grid(sp, axis, segments, func = gr_polyline)
 end
 
 function gr_draw_minorgrid(sp, axis, segments, func = gr_polyline)
-    if axis[:grid]
+    if axis[:minorgrid]
         gr_set_line(
             axis[:minorgridlinewidth],
             axis[:minorgridstyle],
@@ -1440,13 +1462,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
 
@@ -1478,8 +1501,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)
@@ -1496,7 +1519,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
@@ -1510,8 +1536,10 @@ function gr_label_axis(sp, letter, viewport_plotarea)
         GR.savestate()
         gr_set_font(guidefont(axis), sp)
         guide_position = axis[:guide_position]
+        angle = float(axis[:guidefontrotation])  # github.com/JuliaPlots/Plots.jl/issues/3089
         if letter === :y
-            GR.setcharup(-1, 0)
+            angle += 180.  # default angle = 0. should yield GR.setcharup(-1, 0) i.e. 180°
+            GR.setcharup(cosd(angle), sind(angle))
             ypos = gr_view_yposition(viewport_plotarea, position(axis[:guidefontvalign]))
             yalign = alignment(axis[:guidefontvalign])
             if guide_position === :right || (guide_position == :auto && mirror)
@@ -1522,6 +1550,8 @@ function gr_label_axis(sp, letter, viewport_plotarea)
                 xpos = viewport_plotarea[1] - 0.03 - !mirror * gr_axis_width(sp, axis)
             end
         else
+            angle += 90.  # default angle = 0. should yield GR.setcharup(0, 1) i.e. 90°
+            GR.setcharup(cosd(angle), sind(angle))
             xpos = gr_view_xposition(viewport_plotarea, position(axis[:guidefonthalign]))
             xalign = alignment(axis[:guidefonthalign])
             if guide_position === :top || (guide_position == :auto && mirror)
@@ -1561,8 +1591,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)
@@ -1573,7 +1603,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
@@ -1649,7 +1680,7 @@ function gr_add_series(sp, series)
         end
     elseif st === :contour
         gr_draw_contour(series, x, y, z, clims)
-    elseif st in (:surface, :wireframe)
+    elseif st in (:surface, :wireframe, :mesh3d)
         gr_draw_surface(series, x, y, z, clims)
     elseif st === :volume
         sp[:legend] = :none
@@ -1691,7 +1722,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)
@@ -1728,7 +1759,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)
@@ -1799,13 +1830,14 @@ end
 function gr_draw_contour(series, x, y, z, clims)
     GR.setspace(clims[1], clims[2], 0, 90)
     gr_set_line(get_linewidth(series), get_linestyle(series), get_linecolor(series), series)
+    gr_set_transparency(get_fillalpha(series))
     is_lc_black = let black=plot_color(:black)
         plot_color(series[:linecolor]) in (black,[black])
     end
     h = gr_contour_levels(series, clims)
     if series[:fillrange] !== nothing
         if series[:fillcolor] != series[:linecolor] && !is_lc_black
-            @warn("GR: filled contour only supported with black contour lines")
+            @warn "GR: filled contour only supported with black contour lines"
         end
         GR.contourf(x, y, h, z, series[:contour_labels] == true ? 1 : 0)
     else
@@ -1815,22 +1847,59 @@ function gr_draw_contour(series, x, y, z, clims)
 end
 
 function gr_draw_surface(series, x, y, z, clims)
-
-    if series[:seriestype] === :surface
+    e_kwargs = series[:extra_kwargs]
+    st = series[:seriestype]
+    if st === :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
+    elseif st === :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))
+    elseif st === :mesh3d
+        @warn "GR: mesh3d is experimental (no face colors)"
+        conn = series[:connections]
+        if typeof(conn) <: Tuple{Array, Array, Array}
+            ci, cj, ck = conn
+            if !(length(ci) == length(cj) == length(ck))
+                throw(ArgumentError("Argument connections must consist of equally sized arrays."))
+            end
+        else
+            throw(ArgumentError("Argument connections has to be a tuple of three arrays."))
+        end
+        X = zeros(eltype(x), 4length(ci))
+        Y = zeros(eltype(y), 4length(cj))
+        Z = zeros(eltype(z), 4length(ck))
+        @inbounds for I ∈ 1:length(ci)
+            i = ci[I] + 1  # connections are 0-based
+            j = cj[I] + 1
+            k = ck[I] + 1
+            m = 4(I - 1) + 1; n = m + 1; o = m + 2; p = m + 3
+            X[m] = X[p] = x[i]
+            Y[m] = Y[p] = y[i]
+            Z[m] = Z[p] = z[i]
+            X[n] = x[j]
+            Y[n] = y[j]
+            Z[n] = z[j]
+            X[o] = x[k]
+            Y[o] = y[k]
+            Z[o] = z[k]
+        end
+        gr_set_line(get_linewidth(series), get_linestyle(series), get_linecolor(series), series)
+        GR.polyline3d(X, Y, Z)
+    else
+        throw(ArgumentError("Not handled !"))
     end
 end
 

src/backends/pgfplotsx.jl

@@ -118,11 +118,22 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
         end
 
         for sp in plt.subplots
-            bb1 = sp.plotarea
             bb2 = bbox(sp)
+            dx, dy = bb2.x0
+            sp_width = width(bb2)
+            sp_height = height(bb2)
+            if sp[:subplot_index] == plt[:plot_titleindex]
+                x = dx + sp_width / 2 - 10mm # FIXME: get rid of magic constant
+                y = dy + sp_height / 2
+                pgfx_add_annotation!(the_plot, x, y, PlotText(plt[:plot_title], plottitlefont(plt)), pgfx_thickness_scaling(plt);
+                    cs = "",
+                    options = PGFPlotsX.Options("anchor" => "center")
+                )
+                continue
+            end
+
             sp_width = width(bb2)
             sp_height = height(bb2)
-            dx, dy = bb2.x0
             lpad = leftpad(sp) + sp[:left_margin]
             rpad = rightpad(sp) + sp[:right_margin]
             tpad = toppad(sp) + sp[:top_margin]
@@ -131,7 +142,6 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
             dy += tpad
             axis_height = sp_height - (tpad + bpad)
             axis_width = sp_width - (rpad + lpad)
-
             title_cstr = plot_color(sp[:titlefontcolor])
             title_a = alpha(title_cstr)
             title_loc = sp[:titlelocation]
@@ -229,7 +239,7 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
                     "colorbar style" => colorbar_style,
                 )
             else
-                push!(axis_opt, "colorbar" => "false") 
+                push!(axis_opt, "colorbar" => "false")
             end
             if RecipesPipeline.is3d(sp)
                 azim, elev = sp[:camera]
@@ -327,7 +337,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
@@ -452,7 +462,7 @@ function pgfx_add_series!(::Val{:path}, axis, series_opt, series, series_func, o
                 ),
             )
         end
-        pgfx_add_legend!(axis, series, opt, i)
+        pgfx_add_legend!(axis, series, opt, k)
     end # for segments
     # get that last marker
     if !isnothing(opt[:y]) && !any(isnan, opt[:y]) && opt[:markershape] isa AVec
@@ -889,7 +899,7 @@ function pgfx_framestyle(style::Symbol)
         return style
     else
         default_style = get((semi = :box,), style, :axes)
-        @warn( "Framestyle :$style is not (yet) supported by the PGFPlotsX backend. :$default_style was cosen instead.",)
+        @warn "Framestyle :$style is not (yet) supported by the PGFPlotsX backend. :$default_style was chosen instead."
         default_style
     end
 end
@@ -999,24 +1009,27 @@ function pgfx_marker(plotattributes, i = 1)
     )
 end
 
-function pgfx_add_annotation!(o, x, y, val, thickness_scaling = 1)
+function pgfx_add_annotation!(o, x, y, val, thickness_scaling = 1; cs = "axis cs:", options = PGFPlotsX.Options())
     # Construct the style string.
     cstr = val.font.color
     a = alpha(cstr)
     push!(
         o,
-        [
+        join([
             "\\node",
-            PGFPlotsX.Options(
-                get((center = "", left = "right", right = "left"), val.font.halign, "") =>
-                    nothing,
-                "color" => cstr,
-                "draw opacity" => convert(Float16, a),
-                "rotate" => val.font.rotation,
-                "font" => pgfx_font(val.font.pointsize, thickness_scaling),
-            ),
-            " at (axis cs:$x, $y) {$(val.str)};",
-        ],
+            sprint(PGFPlotsX.print_tex, merge(
+                PGFPlotsX.Options(
+                    get((hcenter = "", left = "right", right = "left"), val.font.halign, "") =>
+                        nothing,
+                    "color" => cstr,
+                    "draw opacity" => convert(Float16, a),
+                    "rotate" => val.font.rotation,
+                    "font" => pgfx_font(val.font.pointsize, thickness_scaling),
+                ),
+                options
+            )),
+            string(" at (", cs, x, ",", y, ") {", val.str, "};"),
+        ]),
     )
 end
 
@@ -1081,7 +1094,7 @@ end
 function pgfx_fillrange_series!(axis, series, series_func, i, fillrange, rng)
     fillrange_opt = PGFPlotsX.Options("line width" => "0", "draw opacity" => "0")
     fillrange_opt = merge(fillrange_opt, pgfx_fillstyle(series, i))
-    fillrange_opt = merge(fillrange_opt, pgfx_marker(series, i))
+    push!(fillrange_opt, "mark" => "none") # no markers on fillranges
     push!(fillrange_opt, "forget plot" => nothing)
     opt = series.plotattributes
     args = RecipesPipeline.is3d(series) ? (opt[:x][rng], opt[:y][rng], opt[:z][rng]) :

src/backends/plotly.jl

@@ -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
@@ -953,8 +953,7 @@ function plotly_html_body(plt, style = nothing)
         <div id=\"$(uuid)\" style=\"$(style)\"></div>
         <script>
         $(requirejs_prefix)
-        PLOT = document.getElementById('$(uuid)');
-        Plotly.plot(PLOT, $(plotly_series_json(plt)), $(plotly_layout_json(plt)));
+        $(js_body(plt, uuid))
         $(requirejs_suffix)
         </script>
     """
@@ -963,7 +962,7 @@ end
 
 function js_body(plt::Plot, uuid)
     js = """
-        PLOT = document.getElementById('$(uuid)');
+        var PLOT = document.getElementById('$(uuid)');
         Plotly.plot(PLOT, $(plotly_series_json(plt)), $(plotly_layout_json(plt)));
     """
 end
@@ -987,7 +986,7 @@ end
 
 
 function _show(io::IO, ::MIME"text/html", plt::Plot{PlotlyBackend})
-    write(io, standalone_html(plt))
+    write(io, embeddable_html(plt))
 end
 
 

src/backends/plotlyjs.jl

@@ -34,7 +34,7 @@ _show(io::IO, mime::MIME"application/vnd.plotly.v1+json", plt::Plot{PlotlyJSBack
 html_head(plt::Plot{PlotlyJSBackend}) = plotly_html_head(plt)
 html_body(plt::Plot{PlotlyJSBackend}) = plotly_html_body(plt)
 
-_show(io::IO, ::MIME"text/html", plt::Plot{PlotlyJSBackend}) = write(io, standalone_html(plt))
+_show(io::IO, ::MIME"text/html", plt::Plot{PlotlyJSBackend}) = write(io, embeddable_html(plt))
 
 _display(plt::Plot{PlotlyJSBackend}) = display(plotlyjs_syncplot(plt))
 

src/backends/pyplot.jl

@@ -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] : "",

src/backends/web.jl

@@ -19,6 +19,10 @@ function standalone_html(plt::AbstractPlot; title::AbstractString = get(plt.attr
     """
 end
 
+function embeddable_html(plt::AbstractPlot)
+    html_head(plt) * html_body(plt)
+end
+
 function open_browser_window(filename::AbstractString)
     @static if Sys.isapple()
         return run(`open $(filename)`)

src/components.jl

@@ -43,7 +43,7 @@ function coords(shape::Shape)
 end
 
 #coords(shapes::AVec{Shape}) = unzip(map(coords, shapes))
-function coords(shapes::AVec{Shape})
+function coords(shapes::AVec{<:Shape})
     c = map(coords, shapes)
     x = [q[1] for q in c]
     y = [q[2] for q in c]
@@ -288,7 +288,7 @@ function font(args...;kw...)
 
   for symbol in keys(kw)
     if symbol == :family
-      family = kw[:family]
+      family = string(kw[:family])
     elseif symbol == :pointsize
       pointsize = kw[:pointsize]
     elseif symbol == :halign
@@ -327,12 +327,12 @@ end
 Scales all **current** font sizes by `factor`. For example `scalefontsizes(1.1)` increases all current font sizes by 10%. To reset to initial sizes, use `scalefontsizes()`
 """
 function scalefontsizes(factor::Number)
-    for k in (:titlefontsize, :legendfontsize, :legendtitlefontsize)
+    for k in keys(merge(_initial_plt_fontsizes, _initial_sp_fontsizes))
         scalefontsize(k, factor)
     end
 
     for letter in (:x,:y,:z)
-        for k in (:guidefontsize, :tickfontsize)
+        for k in keys(_initial_ax_fontsizes)
             scalefontsize(Symbol(letter, k), factor)
         end
     end
@@ -344,7 +344,7 @@ end
 Resets font sizes to initial default values.
 """
 function scalefontsizes()
-    for k in (:titlefontsize, :legendfontsize, :legendtitlefontsize)
+    for k in keys(merge(_initial_plt_fontsizes, _initial_sp_fontsizes))
         f = default(k)
         if k in keys(_initial_fontsizes)
             factor = f / _initial_fontsizes[k]
@@ -353,7 +353,7 @@ function scalefontsizes()
     end
 
     for letter in (:x,:y,:z)
-        for k in (:guidefontsize, :tickfontsize)
+        for k in keys(_initial_ax_fontsizes)
             if k in keys(_initial_fontsizes)
                 f = default(Symbol(letter, k))
                 factor = f / _initial_fontsizes[k]
@@ -474,6 +474,11 @@ mutable struct SeriesAnnotations
     baseshape::Union{Shape, AbstractVector{Shape}, Nothing}
     scalefactor::Tuple
 end
+
+series_annotations(scalar) = series_annotations([scalar])
+function series_annotations(anns::AMat)
+  map(series_annotations, anns)
+end
 function series_annotations(strs::AbstractVector, args...)
     fnt = font()
     shp = nothing
@@ -568,87 +573,93 @@ function Base.iterate(ea::EachAnn, i = 1)
     ((_cycle(ea.x,i), _cycle(ea.y,i), str, fnt), i+1)
 end
 
+# -----------------------------------------------------------------------
 annotations(::Nothing) = []
 annotations(anns::AVec) = anns
+annotations(anns::AMat) = map(annotations, anns)
 annotations(anns) = Any[anns]
 annotations(sa::SeriesAnnotations) = sa
 
+_annotationfont(sp::Subplot) = Plots.font(;
+  family=sp[:annotationfontfamily],
+  pointsize=sp[:annotationfontsize],
+  halign=sp[:annotationhalign],
+  valign=sp[:annotationvalign],
+  rotation=sp[:annotationrotation],
+  color=sp[:annotationcolor],
+)
+
+_annotation(sp, font, lab, pos...; alphabet="abcdefghijklmnopqrstuvwxyz") = (
+  if lab == :auto
+    (pos..., text("($(alphabet[sp[:subplot_index]]))", font))
+  else
+    (pos..., isa(lab, PlotText) ? lab : isa(lab, Tuple) ? text(lab[1], font, lab[2:end]...) : text(lab, font))
+  end
+)
+
 # Expand arrays of coordinates, positions and labels into induvidual annotations
 # and make sure labels are of type PlotText
-function process_annotation(sp::Subplot, xs, ys, labs, font = nothing)
+function process_annotation(sp::Subplot, xs, ys, labs, font=_annotationfont(sp))
     anns = []
     labs = makevec(labs)
     xlength = length(methods(length, (typeof(xs),))) == 0 ? 1 : length(xs)
     ylength = length(methods(length, (typeof(ys),))) == 0 ? 1 : length(ys)
-    if isnothing(font)
-        font = Plots.font(;
-                    family=sp[:annotationfontfamily],
-                    pointsize=sp[:annotationfontsize],
-                    halign=sp[:annotationhalign],
-                    valign=sp[:annotationvalign],
-                    rotation=sp[:annotationrotation],
-                    color=sp[:annotationcolor],
-                         )
-    end
     for i in 1:max(xlength, ylength, length(labs))
       x, y, lab = _cycle(xs, i), _cycle(ys, i), _cycle(labs, i)
-        x = typeof(x) <: TimeType ? Dates.value(x) : x
-        y = typeof(y) <: TimeType ? Dates.value(y) : y
-        if lab == :auto
-            alphabet = "abcdefghijklmnopqrstuvwxyz"
-            push!(anns, (x, y, text(string("(", alphabet[sp[:subplot_index]], ")"), font)))
-        else
-            push!(anns, (x, y, isa(lab, PlotText) ? lab : isa(lab, Tuple) ? text(lab[1], font, lab[2:end]...) : text(lab, font)))
-        end
-    end
-    anns
-end
-function process_annotation(sp::Subplot, positions::Union{AVec{Symbol},Symbol}, labs, font = nothing)
-    anns = []
-    positions, labs = makevec(positions), makevec(labs)
-    if isnothing(font)
-        font = Plots.font(;
-                          family=sp[:annotationfontfamily],
-                          pointsize=sp[:annotationfontsize],
-                          halign=sp[:annotationhalign],
-                          valign=sp[:annotationvalign],
-                          rotation=sp[:annotationrotation],
-                          color=sp[:annotationcolor],
-                         )
-    end
-    for i in 1:max(length(positions), length(labs))
-        pos, lab = _cycle(positions, i), _cycle(labs, i)
-        pos = get(_positionAliases, pos, pos)
-        if lab == :auto
-            alphabet = "abcdefghijklmnopqrstuvwxyz"
-            push!(anns, (pos, text(string("(", alphabet[sp[:subplot_index]], ")"), font)))
-        else
-            push!(anns, (pos, isa(lab, PlotText) ? lab : isa(lab, Tuple) ? text(lab[1], font, lab[2:end]...) : text(lab, font)))
-        end
+      x = typeof(x) <: TimeType ? Dates.value(x) : x
+      y = typeof(y) <: TimeType ? Dates.value(y) : y
+      push!(anns, _annotation(sp, font, lab, x, y))
     end
     anns
 end
 
-function process_any_label(lab, font=Font())
-    lab isa Tuple ? text(lab...) : text( lab, font )
+function process_annotation(sp::Subplot, positions::Union{AVec{Symbol},Symbol,Tuple}, labs, font=_annotationfont(sp))
+    anns = []
+    positions, labs = makevec(positions), makevec(labs)
+    for i in 1:max(length(positions), length(labs))
+        pos, lab = _cycle(positions, i), _cycle(labs, i)
+        push!(anns, _annotation(sp, font, lab, get(_positionAliases, pos, pos)))
+    end
+    anns
 end
+
+process_any_label(lab, font=Font()) = lab isa Tuple ? text(lab...) : text(lab, font)
+
+_relative_position(xmin, xmax, pos::Length{:pct}) = xmin + pos.value * (xmax - xmin)
+
 # Give each annotation coordinates based on specified position
-function locate_annotation(sp::Subplot, pos::Symbol, lab::PlotText)
-    position_multiplier = Dict{Symbol, Tuple{Float64,Float64}}(
-        :topleft       => (0.1, 0.9),
-        :topcenter     => (0.5, 0.9),
-        :topright      => (0.9, 0.9),
-        :bottomleft    => (0.1, 0.1),
-        :bottomcenter  => (0.5, 0.1),
-        :bottomright   => (0.9, 0.1),
+function locate_annotation(
+  sp::Subplot, pos::Symbol, label::PlotText;
+  position_multiplier=Dict{Symbol, Tuple{Float64,Float64}}(
+    :topleft       => (0.1pct, 0.9pct),
+    :topcenter     => (0.5pct, 0.9pct),
+    :topright      => (0.9pct, 0.9pct),
+    :bottomleft    => (0.1pct, 0.1pct),
+    :bottomcenter  => (0.5pct, 0.1pct),
+    :bottomright   => (0.9pct, 0.1pct),
+  )
+)
+    x, y = position_multiplier[pos]
+    (
+      _relative_position(axis_limits(sp, :x)..., x),
+      _relative_position(axis_limits(sp, :y)..., y),
+      label
     )
-    xmin, xmax = ignorenan_extrema(sp[:xaxis])
-    ymin, ymax = ignorenan_extrema(sp[:yaxis])
-    x, y = (xmin, ymin).+ position_multiplier[pos].* (xmax - xmin, ymax - ymin)
-    (x, y, lab)
 end
 locate_annotation(sp::Subplot, x, y, label::PlotText) = (x, y, label)
 locate_annotation(sp::Subplot, x, y, z, label::PlotText) = (x, y, z, label)
+
+locate_annotation(sp::Subplot, rel::NTuple{2,<:Number}, label::PlotText) = (
+  _relative_position(axis_limits(sp, :x)..., rel[1] * Plots.pct),
+  _relative_position(axis_limits(sp, :y)..., rel[2] * Plots.pct),
+  label
+)
+locate_annotation(sp::Subplot, rel::NTuple{3,<:Number}, label::PlotText) = (
+  _relative_position(axis_limits(sp, :x)..., rel[1] * Plots.pct),
+  _relative_position(axis_limits(sp, :y)..., rel[2] * Plots.pct),
+  _relative_position(axis_limits(sp, :z)..., rel[3] * Plots.pct),
+  label
+)
 # -----------------------------------------------------------------------
 
 "type which represents z-values for colors and sizes (and anything else that might come up)"

src/examples.jl

@@ -115,7 +115,7 @@ const _examples = PlotExample[
                     )
                     vline!([5, 10])
                     title!("TITLE")
-                    yaxis!("YLABEL", :log10)
+                    yaxis!("YLABEL", :log10, minorgrid = true)
                 end
             ),
         ],
@@ -128,8 +128,7 @@ const _examples = PlotExample[
             :(
                 begin
                     import FileIO
-                    path =
-                            download("http://juliaplots.org/PlotReferenceImages.jl/Plots/pyplot/0.7.0/ref1.png")
+                    path = download("http://juliaplots.org/PlotReferenceImages.jl/Plots/pyplot/0.7.0/ref1.png")
                     img = FileIO.load(path)
                     plot(img)
                 end
@@ -370,10 +369,21 @@ const _examples = PlotExample[
         "Annotations",
         """
         The `annotations` keyword is used for text annotations in data-coordinates.  Pass in a
-        tuple (x,y,text) or a vector of annotations.  `annotate!(ann)` is shorthand for `plot!(;
-        annotation=ann)`.  Series annotations are used for annotating individual data points.
-        They require only the annotation... x/y values are computed.  A `PlotText` object can be
-        build with the method `text(string, attr...)`, which wraps font and color attributes.
+        tuple `(x, y, text)`, a vector of annotations, each of which is a tuple of `x`, `y`
+        and `text`. You can position annotations using relative coordinates with the syntax
+        `((px, py), text)`, where for example `px=.25` positions the annotation at `25%` of
+        the subplot's axis width.
+        `text` may be a simple `String`, or a `PlotText` object, which can be built with the
+        method `text(string, attrs...)`.
+        This wraps font and color attributes and allows you to set text styling.
+        `text` may also be a tuple `(string, attrs...)` of arguments which are passed
+        to `Plots.text`.
+
+        `annotate!(ann)` is shorthand for `plot!(; annotation=ann)`.
+
+        Series annotations are used for annotating individual data points.
+        They require only the annotation; x/y values are computed.  Series annotations
+        require either plain `String`s or `PlotText` objects.
         """,
         [
             :(
@@ -385,11 +395,11 @@ const _examples = PlotExample[
                         leg = false,
                     )
                     annotate!([
-                        (5, y[5], Plots.text("this is #5", 16, :red, :center)),
+                        (5, y[5], ("this is #5", 16, :red, :center)),
                         (
                             10,
                             y[10],
-                            Plots.text("this is #10", :right, 20, "courier"),
+                            ("this is #10", :right, 20, "courier"),
                         ),
                     ])
                     scatter!(
@@ -998,33 +1008,37 @@ const _examples = PlotExample[
         end]
     ),
     PlotExample( # 47
-	"Mesh3d",
-	"""
-	Allows to plot arbitrary 3d meshes. If only x,y,z are given the mesh is generated automatically.
-	You can also specify the connections using the connections keyword.
-    The connections are specified using a tuple of vectors. Each vector contains the 0-based indices of one point of a triangle,
-	such that elements at the same position of these vectors form a triangle.
-	""",
-	[
-		:(
-		  begin
-			# specify the vertices
-			x=[0, 1, 2, 0]
-			y=[0, 0, 1, 2]
-			z=[0, 2, 0, 1]
+        "Mesh3d",
+        """
+        Allows to plot arbitrary 3d meshes. If only x,y,z are given the mesh is generated automatically.
+        You can also specify the connections using the connections keyword.
+        The connections are specified using a tuple of vectors. Each vector contains the 0-based indices of one point of a triangle,
+        such that elements at the same position of these vectors form a triangle.
+        """,
+        [
+            :(
+                begin
+                    # specify the vertices
+                    x=[0, 1, 2, 0]
+                    y=[0, 0, 1, 2]
+                    z=[0, 2, 0, 1]
 
-			# specify the triangles
-			# every column is one triangle,
-			# where the values denote the indices of the vertices of the triangle
-			i=[0, 0, 0, 1]
-			j=[1, 2, 3, 2]
-			k=[2, 3, 1, 3]
+                    # specify the triangles
+                    # every column is one triangle,
+                    # where the values denote the indices of the vertices of the triangle
+                    i=[0, 0, 0, 1]
+                    j=[1, 2, 3, 2]
+                    k=[2, 3, 1, 3]
 
-			# the four triangles gives above give a tetrahedron
-			mesh3d(x,y,z;connections=(i,j,k))
-		  end
-		),
-	],
+                    # the four triangles gives above give a tetrahedron
+                    mesh3d(
+                        x, y, z; connections=(i, j, k),
+                        title="triangles", xlabel="x", ylabel="y", zlabel="z",
+                        legend=:none, margin=2Plots.mm
+                    )
+                end
+            ),
+        ],
     ),
     PlotExample( # 48
         "Vectors of markershapes and segments",
@@ -1163,15 +1177,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],
+    :gr => [25, 30],
+    :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
@@ -1182,6 +1242,15 @@ _backend_skips = Dict(
         49, # polar heatmap
         51, # image with custom axes
     ],
+    :inspectdr => [4, 6, 10, 22, 24, 28, 30, 38, 43, 45, 47, 48, 49, 50, 51, 55],
+    :unicodeplots => [6, 10, 22, 24, 28, 38, 43, 45, 47, 49, 50, 51, 55],
+    :gaston => [
+        2,  # animations
+        31,  # animations
+        47,  # TODO: support mesh3d
+        49,  # TODO: support polar
+        50,  # TODO: 1D data not supported for pm3d
+    ],
 )
 
 

src/init.jl

@@ -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()

src/layouts.jl

@@ -406,7 +406,7 @@ end
 
 # ----------------------------------------------------------------------
 
-calc_num_subplots(layout::AbstractLayout) = 1
+calc_num_subplots(layout::AbstractLayout) = get(layout.attr, :blank, false) ? 0 : 1
 function calc_num_subplots(layout::GridLayout)
     tot = 0
     for l in layout.grid
@@ -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
@@ -775,9 +744,17 @@ end
 
 "Adds a new, empty subplot overlayed on top of `sp`, with a mirrored y-axis and linked x-axis."
 function twinx(sp::Subplot)
-    sp[:right_margin] = max(sp[:right_margin], 30px)
-    plot!(sp.plt, inset = (sp[:subplot_index], bbox(0,0,1,1)))
+    plot!(sp.plt,
+        inset = (sp[:subplot_index], bbox(0,0,1,1)),
+        right_margin = sp[:right_margin],
+        left_margin = sp[:left_margin],
+        top_margin = sp[:top_margin],
+        bottom_margin = sp[:bottom_margin],
+    )
     twinsp = sp.plt.subplots[end]
+    twinsp[:xaxis][:grid] = false
+    twinsp[:yaxis][:grid] = false
+    twinsp[:xaxis][:showaxis] = false
     twinsp[:yaxis][:mirror] = true
     twinsp[:background_color_inside] = RGBA{Float64}(0,0,0,0)
     link_axes!(sp[:xaxis], twinsp[:xaxis])

src/pipeline.jl

@@ -141,7 +141,7 @@ function _add_smooth_kw(kw_list::Vector{KW}, kw::AKW)
 end
 
 
-RecipesPipeline.get_axis_limits(plt::Plot, letter) = axis_limits(plt[1], letter)
+RecipesPipeline.get_axis_limits(plt::Plot, letter) = axis_limits(plt[1], letter, false)
 
 
 ## Plot recipes
@@ -243,10 +243,17 @@ function _subplot_setup(plt::Plot, plotattributes::AKW, kw_list::Vector{KW})
         attr = KW()
         for (k, v) in collect(kw)
             if is_subplot_attr(k) || is_axis_attr(k)
-                attr[k] = pop!(kw, k)
+                v = pop!(kw, k)
+                if sps isa AbstractArray && v isa AbstractArray && length(v) == length(sps)
+                    v = v[series_idx(kw_list, kw)]
+                end
+                attr[k] = v
             end
             if is_axis_attr_noletter(k)
                 v = pop!(kw, k)
+                if sps isa AbstractArray && v isa AbstractArray && length(v) == length(sps)
+                    v = v[series_idx(kw_list, kw)]
+                end
                 for letter in (:x, :y, :z)
                     attr[Symbol(letter, k)] = v
                 end
@@ -262,6 +269,7 @@ function _subplot_setup(plt::Plot, plotattributes::AKW, kw_list::Vector{KW})
         sp_attrs[sp] = attr
     end
 
+    _add_plot_title!(plt)
     # override subplot/axis args.  `sp_attrs` take precendence
     for (idx, sp) in enumerate(plt.subplots)
         attr = if !haskey(plotattributes, :subplot) || plotattributes[:subplot] == idx
@@ -274,12 +282,37 @@ function _subplot_setup(plt::Plot, plotattributes::AKW, kw_list::Vector{KW})
 
     # do we need to link any axes together?
     link_axes!(plt.layout, plt[:link])
+    return nothing
 end
 
 function series_idx(kw_list::AVec{KW}, kw::AKW)
     Int(kw[:series_plotindex]) - Int(kw_list[1][:series_plotindex]) + 1
 end
 
+function _add_plot_title!(plt)
+    plot_title = plt[:plot_title]
+    if plot_title != ""
+        the_layout = plt.layout
+        vspan = plt[:plot_titlevspan]
+        plt.layout = grid(2, 1, heights=(vspan, 1 - vspan))
+        plt.layout.grid[1, 1] = subplot = Subplot(plt.backend, parent=plt.layout[1, 1])
+        plt.layout.grid[2, 1] = the_layout
+        subplot.plt = plt
+        # propagate arguments plt[:plot_titleXXX] --> subplot[:titleXXX]
+        for sym ∈ filter(x -> startswith(string(x), "plot_title"), keys(_plot_defaults))
+            subplot[Symbol(string(sym)[length("plot_") + 1:end])] = plt[sym]
+        end
+        top = plt.backend isa PyPlotBackend ? nothing : 0mm
+        bot = 0mm
+        plt[:force_minpad] = nothing, top, nothing, bot
+        subplot[:subplot_index] = last(plt.subplots)[:subplot_index] + 1
+        plt[:plot_titleindex] = subplot[:subplot_index]
+        subplot[:framestyle] = :none
+        subplot[:margin] = 0px
+        push!(plt.subplots, subplot)
+    end
+    return nothing
+end
 
 ## Series recipes
 
@@ -313,7 +346,7 @@ function _prepare_subplot(plt::Plot{T}, plotattributes::AKW) where {T}
     st = _override_seriestype_check(plotattributes, st)
 
     # change to a 3d projection for this subplot?
-    if RecipesPipeline.needs_3d_axes(st)
+    if RecipesPipeline.needs_3d_axes(st) || (st == :quiver && plotattributes[:z] !== nothing)
         sp.attr[:projection] = "3d"
     end
 
@@ -329,7 +362,7 @@ function _override_seriestype_check(plotattributes::AKW, st::Symbol)
     # do we want to override the series type?
     if !RecipesPipeline.is3d(st) && !(st in (:contour, :contour3d, :quiver))
         z = plotattributes[:z]
-        if !isa(z, Nothing) &&
+        if z !== nothing &&
            (size(plotattributes[:x]) == size(plotattributes[:y]) == size(z))
             st = (st == :scatter ? :scatter3d : :path3d)
             plotattributes[:seriestype] = st
@@ -338,6 +371,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

src/plot.jl

@@ -23,7 +23,38 @@ current(plot::AbstractPlot) = (CURRENT_PLOT.nullableplot = plot)
 
 Base.string(plt::Plot) = "Plot{$(plt.backend) n=$(plt.n)}"
 Base.print(io::IO, plt::Plot) = print(io, string(plt))
-Base.show(io::IO, plt::Plot) = print(io, string(plt))
+function Base.show(io::IO, plt::Plot)
+    print(io, string(plt))
+    sp_ekwargs = getindex.(plt.subplots, :extra_kwargs)
+    s_ekwargs = getindex.(plt.series_list, :extra_kwargs)
+    if isempty(plt[:extra_plot_kwargs]) && all(isempty, sp_ekwargs) && all(isempty, s_ekwargs)
+        return
+    end
+    print(io,"\nCaptured extra kwargs:\n")
+    do_show = true
+    for (key, value) in plt[:extra_plot_kwargs]
+        do_show && println(io, "  Plot:")
+        println(io, " "^4, key, ": ", value)
+        do_show = false
+    end
+    do_show = true
+    for (i, ekwargs) in enumerate(sp_ekwargs)
+        for (key, value) in ekwargs
+            do_show && println(io, "  SubplotPlot{$i}:")
+            println(io, " "^4, key, ": ", value)
+            do_show = false
+        end
+        do_show = true
+    end
+    for (i, ekwargs) in enumerate(s_ekwargs)
+        for (key, value) in ekwargs
+            do_show && println(io, "  Series{$i}:")
+            println(io, " "^4, key, ": ", value)
+            do_show = false
+        end
+        do_show = true
+    end
+end
 
 getplot(plt::Plot) = plt
 getattr(plt::Plot, idx::Int = 1) = plt.attr
@@ -59,18 +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
-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
@@ -127,6 +160,7 @@ function plot(plt1::Plot, plts_tail::Plot...; kw...)
             cmdidx += 1
         end
     end
+    _add_plot_title!(plt)
 
     # first apply any args for the subplots
     for (idx,sp) in enumerate(plt.subplots)
@@ -154,6 +188,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)
@@ -191,6 +226,16 @@ function prepare_output(plt::Plot)
         _update_min_padding!(sp)
     end
 
+    # spedific to :plot_title see _add_plot_title!
+    force_minpad = get(plt, :force_minpad, ())
+    if !isempty(force_minpad)
+        for i ∈ eachindex(plt.layout.grid)
+            plt.layout.grid[i].minpad = Tuple(
+                i === nothing ? j : i for (i, j) ∈ zip(force_minpad, plt.layout.grid[i].minpad)
+            )
+        end
+    end
+
     # now another pass down, to update the bounding boxes
     update_child_bboxes!(plt.layout)
 

src/recipes.jl

@@ -472,16 +472,6 @@ end
         fillto = map(x -> _is_positive(x) ? typeof(baseline)(x) : baseline, fillto)
     end
 
-    if !isnothing(plotattributes[:series_annotations])
-        if isvertical(plotattributes)
-            annotations := (x,y,plotattributes[:series_annotations].strs,:bottom)
-        else
-            annotations := (y,x,plotattributes[:series_annotations].strs,:left)
-        end
-        series_annotations := nothing
-    end
-
-    # create the bar shapes by adding x/y segments
     xseg, yseg = Segments(), Segments()
     for i = 1:ny
         yi = procy[i]
@@ -507,15 +497,30 @@ end
     # switch back
     if !isvertical(plotattributes)
         xseg, yseg = yseg, xseg
+	    x, y = y, x
     end
 
-
     # reset orientation
     orientation := default(:orientation)
 
-    x := xseg.pts
-    y := yseg.pts
-    seriestype := :shape
+    # draw the bar shapes
+    @series begin
+        seriestype := :shape
+        series_annotations := nothing
+        primary := true
+        x := xseg.pts
+        y := yseg.pts
+        ()
+    end
+
+    # add empty series
+    primary := false
+    seriestype := :scatter
+    markersize := 0
+    markeralpha := 0
+    fillrange := nothing
+    x := x
+    y := y
     ()
 end
 @deps bar shape
@@ -1428,9 +1433,9 @@ end
     coords(shape)
 end
 
-@recipe function f(shapes::AVec{Shape})
+@recipe function f(shapes::AVec{<:Shape})
     seriestype --> :shape
-    # For backwards compatibility, column vectors of segmenting attributes are 
+    # For backwards compatibility, column vectors of segmenting attributes are
     # interpreted as having one element per shape
     for attr in union(_segmenting_array_attributes, _segmenting_vector_attributes)
         v = get(plotattributes, attr, nothing)
@@ -1443,7 +1448,7 @@ end
     coords(shapes)
 end
 
-@recipe function f(shapes::AMat{Shape})
+@recipe function f(shapes::AMat{<:Shape})
     seriestype --> :shape
     for j in axes(shapes, 2)
         @series coords(vec(shapes[:, j]))

src/shorthands.jl

@@ -453,12 +453,14 @@ Add annotations to an existing plot.
 # Arguments
 
 - `anns`: An `AbstractVector` of tuples of the form `(x,y,text)`. The `text` object
-          can be a `String` or `PlotText`.
+          can be a `String`, `PlotText` PlotText (created with `text(args...)`),
+          or a tuple of arguments to `text` (e.g., `("Label", 8, :red, :top)`).
 
 # Example
 ```julia-repl
 julia> plot(1:10)
 julia> annotate!([(7,3,"(7,3)"),(3,7,text("hey", 14, :left, :top, :green))])
+julia> annotate!([(4, 4, ("More text", 8, 45.0, :bottom, :red))])
 ```
 """
 annotate!(anns...; kw...)             = plot!(; annotation = anns, kw...)

src/utils.jl

@@ -57,7 +57,7 @@ struct SeriesSegment
     # indexes of this segement in series data vectors
     range::UnitRange
     # index into vector-valued attributes corresponding to this segment
-    attr_index::Int 
+    attr_index::Int
 end
 
 # -----------------------------------------------------
@@ -75,24 +75,40 @@ 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())
+                        break
+                    end
+                end
+            end
+        end
+    end
+
     segments = if has_attribute_segments(series)
         Iterators.flatten(map(nan_segments) do r
             if seriestype in (:scatter, :scatter3d)
                 (SeriesSegment(i:i, i) for i in r)
             else
                 (SeriesSegment(i:i+1, i) for i in first(r):last(r)-1)
-            end 
+            end
         end)
     else
         (SeriesSegment(r, 1) for r in nan_segments)
-    end 
+    end
 
     warn_on_attr_dim_mismatch(series, x, y, z, segments)
     return segments
@@ -109,7 +125,7 @@ function warn_on_attr_dim_mismatch(series, x, y, z, segments)
             if any(v -> !isnothing(v) && any(isnan, v), (x,y,z))
                 @info """Data contains NaNs or missing values, and indices of `$attr` vector do not match data indices.
                     If you intend elements of `$attr` to apply to individual NaN-separated segements in the data,
-                    pass each segment in a separate vector instead, and use a row vector for `$attr`. Legend entries 
+                    pass each segment in a separate vector instead, and use a row vector for `$attr`. Legend entries
                     may be suppressed by passing an empty label.
                     For example,
                         plot([1:2,1:3], [[4,5],[3,4,5]], label=["y" ""], $attr=[1 2])
@@ -270,7 +286,7 @@ function heatmap_edges(x::AVec, xscale::Symbol, y::AVec, yscale::Symbol, z_size:
                 or `size(z) == (length(y)+1, length(x)+1))` (x & y define edges).""")
     end
     x, y = heatmap_edges(x, xscale, isedges),
-           heatmap_edges(y, yscale, isedges, ispolar) # special handle for `r` in polar plots 
+           heatmap_edges(y, yscale, isedges, ispolar) # special handle for `r` in polar plots
     return x, y
 end
 
@@ -287,10 +303,12 @@ function convert_to_polar(theta, r, r_extrema = ignorenan_extrema(r))
     x, y
 end
 
-function fakedata(sz...)
+fakedata(sz::Int...) = fakedata(Random.seed!(PLOTS_SEED), sz...)
+
+function fakedata(rng::AbstractRNG, sz...)
     y = zeros(sz...)
     for r in 2:size(y,1)
-        y[r,:] = 0.95 * vec(y[r-1,:]) + randn(size(y,2))
+        y[r,:] = 0.95 * vec(y[r-1,:]) + randn(rng, size(y,2))
     end
     y
 end
@@ -939,67 +957,67 @@ ignorenan_extrema(plt::Plot) = (xmin(plt), xmax(plt))
 # ---------------------------------------------------------------
 # get fonts from objects:
 
-plottitlefont(p::Plot) = font(
-    p[:plot_titlefontfamily],
-    p[:plot_titlefontsize],
-    p[:plot_titlefontvalign],
-    p[:plot_titlefonthalign],
-    p[:plot_titlefontrotation],
-    p[:plot_titlefontcolor],
+plottitlefont(p::Plot) = font(;
+    family = p[:plot_titlefontfamily],
+    pointsize = p[:plot_titlefontsize],
+    valign = p[:plot_titlefontvalign],
+    halign = p[:plot_titlefonthalign],
+    rotation = p[:plot_titlefontrotation],
+    color = p[:plot_titlefontcolor],
 )
 
-colorbartitlefont(sp::Subplot) = font(
-    sp[:colorbar_titlefontfamily],
-    sp[:colorbar_titlefontsize],
-    sp[:colorbar_titlefontvalign],
-    sp[:colorbar_titlefonthalign],
-    sp[:colorbar_titlefontrotation],
-    sp[:colorbar_titlefontcolor],
+colorbartitlefont(sp::Subplot) = font(;
+    family = sp[:colorbar_titlefontfamily],
+    pointsize = sp[:colorbar_titlefontsize],
+    valign = sp[:colorbar_titlefontvalign],
+    halign = sp[:colorbar_titlefonthalign],
+    rotation = sp[:colorbar_titlefontrotation],
+    color = sp[:colorbar_titlefontcolor],
 )
 
-titlefont(sp::Subplot) = font(
-    sp[:titlefontfamily],
-    sp[:titlefontsize],
-    sp[:titlefontvalign],
-    sp[:titlefonthalign],
-    sp[:titlefontrotation],
-    sp[:titlefontcolor],
+titlefont(sp::Subplot) = font(;
+    family = sp[:titlefontfamily],
+    pointsize = sp[:titlefontsize],
+    valign = sp[:titlefontvalign],
+    halign = sp[:titlefonthalign],
+    rotation = sp[:titlefontrotation],
+    color = sp[:titlefontcolor],
 )
 
-legendfont(sp::Subplot) = font(
-    sp[:legendfontfamily],
-    sp[:legendfontsize],
-    sp[:legendfontvalign],
-    sp[:legendfonthalign],
-    sp[:legendfontrotation],
-    sp[:legendfontcolor],
+legendfont(sp::Subplot) = font(;
+    family = sp[:legendfontfamily],
+    pointsize = sp[:legendfontsize],
+    valign = sp[:legendfontvalign],
+    halign = sp[:legendfonthalign],
+    rotation = sp[:legendfontrotation],
+    color = sp[:legendfontcolor],
 )
 
-legendtitlefont(sp::Subplot) = font(
-    sp[:legendtitlefontfamily],
-    sp[:legendtitlefontsize],
-    sp[:legendtitlefontvalign],
-    sp[:legendtitlefonthalign],
-    sp[:legendtitlefontrotation],
-    sp[:legendtitlefontcolor],
+legendtitlefont(sp::Subplot) = font(;
+    family = sp[:legendtitlefontfamily],
+    pointsize = sp[:legendtitlefontsize],
+    valign = sp[:legendtitlefontvalign],
+    halign = sp[:legendtitlefonthalign],
+    rotation = sp[:legendtitlefontrotation],
+    color = sp[:legendtitlefontcolor],
 )
 
-tickfont(ax::Axis) = font(
-    ax[:tickfontfamily],
-    ax[:tickfontsize],
-    ax[:tickfontvalign],
-    ax[:tickfonthalign],
-    ax[:tickfontrotation],
-    ax[:tickfontcolor],
+tickfont(ax::Axis) = font(;
+    family = ax[:tickfontfamily],
+    pointsize = ax[:tickfontsize],
+    valign = ax[:tickfontvalign],
+    halign = ax[:tickfonthalign],
+    rotation = ax[:tickfontrotation],
+    color = ax[:tickfontcolor],
 )
 
-guidefont(ax::Axis) = font(
-    ax[:guidefontfamily],
-    ax[:guidefontsize],
-    ax[:guidefontvalign],
-    ax[:guidefonthalign],
-    ax[:guidefontrotation],
-    ax[:guidefontcolor],
+guidefont(ax::Axis) = font(;
+    family = ax[:guidefontfamily],
+    pointsize = ax[:guidefontsize],
+    valign = ax[:guidefontvalign],
+    halign = ax[:guidefonthalign],
+    rotation = ax[:guidefontrotation],
+    color = ax[:guidefontcolor],
 )
 
 # ---------------------------------------------------------------

test/imgcomp.jl

@@ -6,14 +6,14 @@ function replace_rand!(ex::Expr)
    for arg in ex.args
        replace_rand!(arg)
    end
-   if ex.head === :call && ex.args[1] ∈ (:rand, :randn)
+   if ex.head === :call && ex.args[1] ∈ (:rand, :randn, :(Plots.fakedata))
        pushfirst!(ex.args, ex.args[1])
        ex.args[2] = :rng
    end
 end
 function fix_rand!(ex)
     replace_rand!(ex)
-    pushfirst!(ex.args[1].args, :(rng = StableRNG(1234)))
+    pushfirst!(ex.args[1].args, :(rng = StableRNG(PLOTS_SEED)))
 end
 
 function image_comparison_tests(
@@ -35,6 +35,7 @@ function image_comparison_tests(
     fn = "ref$idx.png"
     reffn = reference_file(pkg, idx, _current_plots_version)
     newfn = joinpath(reference_path(pkg, _current_plots_version), fn)
+    @debug example.exprs
 
     # test function
     func = (fn, idx) -> begin

test/runtests.jl

@@ -1,3 +1,4 @@
+using Plots: guidefont, series_annotations, PLOTS_SEED
 import ImageMagick
 using VisualRegressionTests
 using Plots
@@ -12,7 +13,6 @@ import GeometryBasics
 using Dates
 using RecipesBase
 
-
 @testset "Plotly standalone" begin
     @test_nowarn Plots._init_ijulia_plotting()
     @test Plots.plotly_local_file_path[] === nothing
@@ -29,6 +29,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")
@@ -66,30 +67,30 @@ end
 
 include("imgcomp.jl")
 # don't actually show the plots
-Random.seed!(1234)
+Random.seed!(PLOTS_SEED)
 default(show=false, reuse=true)
 is_ci() = get(ENV, "CI", "false") == "true"
-const IMG_TOL = VERSION < v"1.4" && Sys.iswindows() ? 1e-1 : is_ci() ? 1e-2 : 1e-3
+const PLOTS_IMG_TOL = parse(Float64, get(ENV, "PLOTS_IMG_TOL", is_ci() ? "1e-4" : "1e-5"))
 
 ## Uncomment the following lines to update reference images for different backends
 
 # @testset "GR" begin
-#     image_comparison_facts(:gr, tol=IMG_TOL, skip = Plots._backend_skips[:gr])
+#     image_comparison_facts(:gr, tol=PLOTS_IMG_TOL, skip = Plots._backend_skips[:gr])
 # end
 #
 # plotly()
 # @testset "Plotly" begin
-#     image_comparison_facts(:plotly, tol=IMG_TOL, skip = Plots._backend_skips[:plotlyjs])
+#     image_comparison_facts(:plotly, tol=PLOTS_IMG_TOL, skip = Plots._backend_skips[:plotlyjs])
 # end
 #
 # pyplot()
 # @testset "PyPlot" begin
-#     image_comparison_facts(:pyplot, tol=IMG_TOL, skip = Plots._backend_skips[:pyplot])
+#     image_comparison_facts(:pyplot, tol=PLOTS_IMG_TOL, skip = Plots._backend_skips[:pyplot])
 # end
 #
 # pgfplotsx()
 # @testset "PGFPlotsX" begin
-#     image_comparison_facts(:pgfplotsx, tol=IMG_TOL, skip = Plots._backend_skips[:pgfplotsx])
+#     image_comparison_facts(:pgfplotsx, tol=PLOTS_IMG_TOL, skip = Plots._backend_skips[:pgfplotsx])
 # end
 
 # 10 Histogram2D
@@ -107,7 +108,7 @@ const IMG_TOL = VERSION < v"1.4" && Sys.iswindows() ? 1e-1 : is_ci() ? 1e-2 : 1e
         @static if haskey(ENV, "APPVEYOR")
             @info "Skipping GR image comparison tests on AppVeyor"
         else
-            image_comparison_facts(:gr, tol=IMG_TOL, skip=Plots._backend_skips[:gr])
+            image_comparison_facts(:gr, tol=PLOTS_IMG_TOL, skip=Plots._backend_skips[:gr])
         end
     end
 

test/test_axes.jl

@@ -31,3 +31,35 @@ end
     @test xticks(p) == yticks(p) == zticks(p) == [ticks1, ticks2]
     @test xticks(p[1]) == yticks(p[1]) == zticks(p[1]) == ticks1
 end
+
+@testset "Axis limits" begin
+    pl = plot(1:5, xlims=:symmetric, widen = false)
+    @test Plots.xlims(pl) == (-5, 5)
+
+    pl = plot(1:3)
+    @test Plots.xlims(pl) == Plots.widen(1,3)
+
+    pl = plot([1.05,2.0,2.95], ylims=:round)
+    @test Plots.ylims(pl) == (1, 3)
+
+    pl = plot(1:3, xlims=(1,5))
+    @test Plots.xlims(pl) == (1, 5)
+
+    pl = plot(1:3, xlims=(1,5), widen=true)
+    @test Plots.xlims(pl) == Plots.widen(1, 5)
+end
+
+@testset "3D Axis" begin
+    ql = quiver([1, 2], [2, 1], [3, 4], quiver = ([1, -1], [0, 0], [1, -0.5]), arrow=true)
+    @test ql[1][:projection] == "3d"
+end
+
+@testset "twinx" begin
+    pl = plot(1:10, margin = 2Plots.cm)
+    twpl = twinx(pl)
+    pl! = plot!(twinx(), -(1:10))
+    @test twpl[:right_margin] == 2Plots.cm
+    @test twpl[:left_margin] == 2Plots.cm
+    @test twpl[:top_margin] == 2Plots.cm
+    @test twpl[:bottom_margin] == 2Plots.cm
+end

test/test_components.jl

@@ -2,56 +2,67 @@ 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})
+        square = Shape([(0, 0.0), (1, 0.0), (1, 1.0), (0, 1.0)])
+        @test isa(square, Shape{Int64,Float64})
+        @test coords(square) isa Tuple{Vector{S},Vector{T}} where {T,S}
     end
 
     @testset "Copy" begin
-        square = Shape([(0,0),(1,0),(1,1),(0,1)])
+        square = Shape([(0, 0), (1, 0), (1, 1), (0, 1)])
         square2 = Shape(square)
         @test square2.x == square.x
         @test square2.y == square.y
     end
 
     @testset "Center" begin
-        square = Shape([(0,0),(1,0),(1,1),(0,1)])
-        @test Plots.center(square) == (0.5,0.5)
+        square = Shape([(0, 0), (1, 0), (1, 1), (0, 1)])
+        @test Plots.center(square) == (0.5, 0.5)
     end
 
     @testset "Translate" begin
-        square = Shape([(0,0),(1,0),(1,1),(0,1)])
-        squareUp = Shape([(0,1),(1,1),(1,2),(0,2)])
-        squareUpRight = Shape([(1,1),(2,1),(2,2),(1,2)])
+        square = Shape([(0, 0), (1, 0), (1, 1), (0, 1)])
+        squareUp = Shape([(0, 1), (1, 1), (1, 2), (0, 2)])
+        squareUpRight = Shape([(1, 1), (2, 1), (2, 2), (1, 2)])
 
-        @test Plots.translate(square,0,1).x == squareUp.x
-        @test Plots.translate(square,0,1).y == squareUp.y
+        @test Plots.translate(square, 0, 1).x == squareUp.x
+        @test Plots.translate(square, 0, 1).y == squareUp.y
 
-        @test Plots.center(translate!(square,1)) == (1.5,1.5)
+        @test Plots.center(translate!(square, 1)) == (1.5, 1.5)
     end
 
     @testset "Rotate" begin
         # 2 radians rotation matrix
         R2 = [cos(2) sin(2); -sin(2) cos(2)]
         coords = [0 0; 1 0; 1 1; 0 1]'
-        coordsRotated2 = R2*(coords.-0.5).+0.5
+        coordsRotated2 = R2 * (coords .- 0.5) .+ 0.5
 
-        square = Shape([(0,0),(1,0),(1,1),(0,1)])
+        square = Shape([(0, 0), (1, 0), (1, 1), (0, 1)])
 
         # make a new, rotated square
         square2 = Plots.rotate(square, -2)
-        @test square2.x ≈ coordsRotated2[1,:]
-        @test square2.y ≈ coordsRotated2[2,:]
+        @test square2.x ≈ coordsRotated2[1, :]
+        @test square2.y ≈ coordsRotated2[2, :]
 
         # unrotate the new square in place
         rotate!(square2, 2)
-        @test square2.x ≈ coords[1,:]
-        @test square2.y ≈ coords[2,:]
+        @test square2.x ≈ coords[1, :]
+        @test square2.y ≈ coords[2, :]
+    end
+
+    @testset "Plot" begin
+        ang = range(0, 2π, length = 60)
+        ellipse(x, y, w, h) = Shape(w * sin.(ang) .+ x, h * cos.(ang) .+ y)
+        myshapes = [ellipse(x, rand(), rand(), rand()) for x = 1:4]
+        @test coords(myshapes) isa Tuple{Vector{Vector{S}},Vector{Vector{T}}} where {T,S}
+        local p
+        @test_nowarn p = plot(myshapes)
+        @test p[1][1][:seriestype] == :shape
     end
 end
 
 @testset "Brush" begin
     @testset "Colors" begin
-        baseline = brush(1, RGB(0,0,0))
+        baseline = brush(1, RGB(0, 0, 0))
         @test brush(:black) == baseline
         @test brush("black") == baseline
     end
@@ -65,7 +76,7 @@ end
     end
     @testset "Bad Argument" begin
         # using test_logs because test_warn seems to not work anymore
-        @test_logs (:warn,"Unused brush arg: nothing (Nothing)") begin
+        @test_logs (:warn, "Unused brush arg: nothing (Nothing)") begin
             brush(nothing)
         end
     end
@@ -73,44 +84,78 @@ end
 
 @testset "Fonts" begin
     @testset "Scaling" begin
-        sizesToCheck = [:titlefontsize, :legendfontsize, :legendtitlefontsize,
-            :xtickfontsize, :ytickfontsize, :ztickfontsize,
-            :xguidefontsize, :yguidefontsize, :zguidefontsize,]
+        sizesToCheck = [
+            :titlefontsize,
+            :legendfontsize,
+            :legendtitlefontsize,
+            :xtickfontsize,
+            :ytickfontsize,
+            :ztickfontsize,
+            :xguidefontsize,
+            :yguidefontsize,
+            :zguidefontsize,
+        ]
         # get inital font sizes
-        initialSizes = [Plots.default(s) for s in sizesToCheck ]
+        initialSizes = [Plots.default(s) for s in sizesToCheck]
 
         #scale up font sizes
         scalefontsizes(2)
 
         # get inital font sizes
-        doubledSizes = [Plots.default(s) for s in sizesToCheck ]
+        doubledSizes = [Plots.default(s) for s in sizesToCheck]
 
-        @test doubledSizes == initialSizes*2
+        @test doubledSizes == initialSizes * 2
 
         # reset font sizes
         resetfontsizes()
 
-        finalSizes = [Plots.default(s) for s in sizesToCheck ]
+        finalSizes = [Plots.default(s) for s in sizesToCheck]
 
         @test finalSizes == initialSizes
     end
 end
 
 @testset "Series Annotations" begin
-    square = Shape([(0,0),(1,0),(1,1),(0,1)])
-    @test_logs (:warn,"Unused SeriesAnnotations arg: triangle (Symbol)") begin
-        p = plot([1,2,3],
-            series_annotations=(["a"],
-                                 2,    # pass a scale factor
-                                 (1,4), # pass two scale factors (overwrites first one)
-                                 square, # pass a shape
-                                 font(:courier), # pass an annotation font
-                                 :triangle  # pass an incorrect argument
-                            ))
+    square = Shape([(0, 0), (1, 0), (1, 1), (0, 1)])
+    @test_logs (:warn, "Unused SeriesAnnotations arg: triangle (Symbol)") begin
+        p = plot(
+            [1, 2, 3],
+            series_annotations = (
+                ["a"],
+                2,    # pass a scale factor
+                (1, 4), # pass two scale factors (overwrites first one)
+                square, # pass a shape
+                font(:courier), # pass an annotation font
+                :triangle,  # pass an incorrect argument
+            ),
+        )
         sa = p.series_list[1].plotattributes[:series_annotations]
         @test sa.strs == ["a"]
         @test sa.font.family == "courier"
         @test sa.baseshape == square
-        @test sa.scalefactor == (1,4)
+        @test sa.scalefactor == (1, 4)
     end
+    spl = scatter(
+        4.53 .* [1/1 1/2 1/3 1/4 1/5],
+        [0 0 0 0 0],
+        layout = (5, 1),
+        ylims = (-1.1, 1.1),
+        xlims = (0, 5),
+        series_annotations = permutedims([["1/1"],["1/2"],["1/3"],["1/4"],["1/5"]]),
+    )
+    @test spl.series_list[1].plotattributes[:series_annotations].strs == ["1/1"]
+    @test spl.series_list[2].plotattributes[:series_annotations].strs == ["1/2"]
+    @test spl.series_list[3].plotattributes[:series_annotations].strs == ["1/3"]
+    @test spl.series_list[4].plotattributes[:series_annotations].strs == ["1/4"]
+    @test spl.series_list[5].plotattributes[:series_annotations].strs == ["1/5"]
+
+    p = plot([1, 2], annotations=(1.5, 2, text("foo", :left)))
+    x, y, txt = p.subplots[end][:annotations][end]
+    @test (x, y) == (1.5, 2)
+    @test txt.str == "foo"
+
+    p = plot([1, 2], annotations=((.1, .5), :auto))
+    pos, txt = p.subplots[end][:annotations][end]
+    @test pos == (.1, .5)
+    @test txt.str == "(a)"
 end

test/test_defaults.jl

@@ -1,10 +1,12 @@
 using Plots, Test
 
-const PLOTS_DEFAULTS = Dict(:theme => :wong2)
+const PLOTS_DEFAULTS = Dict(:theme => :wong2, :fontfamily => :palantino)
 Plots.__init__()
 
 @testset "Loading theme" begin
-    @test plot(1:5)[1][1][:seriescolor] == RGBA(colorant"black")
+    pl = plot(1:5)
+    @test pl[1][1][:seriescolor] == RGBA(colorant"black")
+    @test guidefont(pl[1][:xaxis]).family == "palantino"
 end
 
 empty!(PLOTS_DEFAULTS)

test/test_pgfplotsx.jl

@@ -338,6 +338,16 @@ end
       plots = filter(x -> x isa PGFPlotsX.Plot, axis.contents)
       @test length(plots) == 9
    end # testset
+   @testset "Groups and Subplots" begin
+      group = rand(map((i->begin
+                    "group $(i)"
+                end), 1:4), 100)
+      pl = plot(rand(100), layout = @layout([a b; c]), group = group, linetype = [:bar :scatter :steppre], linecolor = :match)
+      Plots._update_plot_object(pl)
+      axis = Plots.pgfx_axes(pl.o)[1]
+      legend_entries = filter(x -> x isa PGFPlotsX.LegendEntry, axis.contents)
+      @test length(legend_entries) == 2
+   end
 end # testset
 
 @testset "Extra kwargs" begin

test/test_pipeline.jl

@@ -0,0 +1,19 @@
+using Plots, Test
+using RecipesPipeline
+
+@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
+
+@testset "get_axis_limits" begin
+    x = [.1, 5]
+    p1 = plot(x, [5, .1], yscale=:log10)
+    p2 = plot!(identity)
+    @test all(RecipesPipeline.get_axis_limits(p1, :x) .== x)
+    @test all(RecipesPipeline.get_axis_limits(p2, :x) .== x)
+end