1.20.0 [skip ci]

specify relative coordinates
typo
2021-08-03 09:58:28 +02:00 · 2021-08-02 23:30:54 +02:00 · 2021-08-02 21:54:35 +02:00 · 2021-08-02 20:14:40 +02:00 · 2021-08-02 17:28:30 +02:00 · 2021-08-02 16:55:51 +02:00
22 changed files with 813 additions and 477 deletions
@@ -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 }}"


@@ -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' 
@@ -1,7 +1,7 @@
 name = "Plots"
 uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
 author = ["Tom Breloff (@tbreloff)"]
-version = "1.18.2"
+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.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"
@@ -76,6 +76,7 @@ function _precompile_()
    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}, Vector{Float64}},Tuple{Int64, Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Vector{Int64}}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:flip,), Tuple{Bool}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,), Tuple{Symbol}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,), Tuple{typeof(datetimeformatter)}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :flip, :minorgrid, :guide), Tuple{Bool, Bool, Bool, String}},typeof(attr!),Axis})
@@ -83,6 +84,7 @@ function _precompile_()
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :lims, :flip), Tuple{Bool, Tuple{Float64, Float64}, Bool}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :minorgrid, :guide), Tuple{Bool, Bool, String}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :minorgrid, :mirror, :guide), Tuple{Bool, Bool, Bool, String}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid,), Tuple{Bool}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:gridlinewidth, :grid, :gridalpha, :gridstyle, :foreground_color_grid), Tuple{Int64, Bool, Float64, Symbol, RGBA{Float64}}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide,), Tuple{String}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide_position, :guidefontvalign, :mirror, :guide), Tuple{Symbol, Symbol, Bool, String}},typeof(attr!),Axis})
@@ -108,7 +110,7 @@ function _precompile_()
    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})
@@ -129,6 +131,7 @@ function _precompile_()
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Plot{PlotlyBackend},Vector{Int64},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Vector{Int64},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Plot{GRBackend},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Vector{Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!),Plot{GRBackend}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!),Plot{PlotlyBackend}})
@@ -136,7 +139,6 @@ function _precompile_()
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:w,), Tuple{Int64}},typeof(plot!),Plot{GRBackend},Vector{Float64},Vector{Float64},Vararg{Any, N} where N})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:xgrid,), Tuple{Tuple{Symbol, Symbol, Int64, Symbol, Float64}}},typeof(plot!),Plot{GRBackend}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis, :minorgrid), Tuple{Tuple{String, Symbol}, Bool}},typeof(plot!),Plot{GRBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis, :minorgrid), Tuple{Tuple{String, Symbol}, Bool}},typeof(plot!),Plot{PlotlyBackend}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis, :minorgrid), Tuple{Tuple{String, Symbol}, Bool}},typeof(plot!)})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype), Tuple{Vector{Float64}, Tuple{Symbol, Float64, Stroke}, Vector{Float64}, String, Symbol}},typeof(plot!),Plot{GRBackend},Vector{Float64}})
    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}})
@@ -146,13 +148,14 @@ function _precompile_()
    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},Vector{Int64}})
+    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,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},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}})
@@ -243,8 +246,9 @@ 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),Vector{Float64},StepRange{Int64, Int64}})
+    Base.precompile(Tuple{typeof(_cycle),Vector{Float64},UnitRange{Int64}})
+    Base.precompile(Tuple{typeof(_cycle),Vector{Float64},Vector{Int64}})
    Base.precompile(Tuple{typeof(_do_plot_show),Plot{GRBackend},Bool})
    Base.precompile(Tuple{typeof(_do_plot_show),Plot{PlotlyBackend},Bool})
    Base.precompile(Tuple{typeof(_heatmap_edges),Vector{Float64},Bool,Bool})
@@ -262,24 +266,26 @@ function _precompile_()
    Base.precompile(Tuple{typeof(bbox),AbsoluteLength,AbsoluteLength,AbsoluteLength,AbsoluteLength})
    Base.precompile(Tuple{typeof(bbox),Float64,Float64,Float64,Float64})
    Base.precompile(Tuple{typeof(build_layout),GridLayout,Int64,Vector{Plot}})
+    Base.precompile(Tuple{typeof(convertLegendValue),Symbol})
    Base.precompile(Tuple{typeof(convert_to_polar),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64},Tuple{Int64, Float64}})
    Base.precompile(Tuple{typeof(create_grid),Expr})
+    Base.precompile(Tuple{typeof(discrete_value!),Axis,Vector{String}})
    Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64},Vararg{Vector{Float64}, N} where N})
    Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64}})
    Base.precompile(Tuple{typeof(error_zipit),Tuple{Vector{Float64}, Vector{Float64}, Vector{Float64}}})
+    Base.precompile(Tuple{typeof(fakedata),Int64,Int64})
    Base.precompile(Tuple{typeof(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})
    Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Int64, Int64},Vararg{Any, N} where N})
    Base.precompile(Tuple{typeof(get_ticks),UnitRange{Int64},Vector{Float64},Vector{Any},Tuple{Float64, Float64},Vararg{Any, N} where N})
-    Base.precompile(Tuple{typeof(get_xy),OHLC{Float64},Int64,Float64})
    Base.precompile(Tuple{typeof(get_xy),Vector{OHLC}})
    Base.precompile(Tuple{typeof(gr_add_legend),Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), NTuple{9, Float64}},Vector{Float64}})
    Base.precompile(Tuple{typeof(gr_add_legend),Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), Tuple{Int64, 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}})
@@ -289,6 +295,9 @@ function _precompile_()
    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}})
+    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Vector{Int64},Vector{Float64},Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},UnitRange{Int64},Tuple{Vector{Float64}, Vector{Float64}},Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_segments),Series,StepRange{Int64, Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
@@ -300,7 +309,6 @@ function _precompile_()
    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),Subplot{GRBackend},Symbol,Tuple{Vector{Int64}, Vector{String}}})
    Base.precompile(Tuple{typeof(gr_label_ticks_3d),Subplot{GRBackend},Symbol,Tuple{Vector{Float64}, Vector{String}}})
    Base.precompile(Tuple{typeof(gr_polaraxes),Int64,Float64,Subplot{GRBackend}})
    Base.precompile(Tuple{typeof(gr_set_gradient),PlotUtils.ContinuousColorGradient})
@@ -315,8 +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(isvertical),Dict{Symbol, Any}})
-    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})
@@ -337,34 +345,47 @@ function _precompile_()
    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{Int64},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Matrix{PlotUtils.ContinuousColorGradient},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{Bool},Int64})
    Base.precompile(Tuple{typeof(slice_arg),Matrix{RGBA{Float64}},Int64})
    Base.precompile(Tuple{typeof(slice_arg),Matrix{String},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}})
    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),))
+        end
+    end
    let fbody = try __lookup_kwbody__(which(plot!, (Any,))) catch missing end
        if !ismissing(fbody)
            precompile(fbody, (Any,typeof(plot!),Any,))
@@ -385,16 +406,6 @@ function _precompile_()
            precompile(fbody, (Any,typeof(plot),Any,Vararg{Any, 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,))
@@ -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")

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

@@ -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.",
@@ -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,
@@ -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)
@@ -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
@@ -762,12 +762,14 @@ function axis_drawing_info(sp, letter)
                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, 0.012, ax[:tick_direction] !== :none)
+            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.006, true)
+                add_major_or_minor_segments(minor_ticks, ax[:minorgrid], minorgrid_segments, 0.6 / ax_length, true)
            end
        end
    end
@@ -327,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,
@@ -587,80 +590,90 @@ function _initialize_backend(::GastonBackend)
 end

 const _gaston_attr = merge_with_base_supported([
-    # :annotations,
+    :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,
+    :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,
+    :title, :window_title,
+    :guide, :guide_position,
+    :lims, :ticks, :scale, :flip, :rotation,
    :tickfont, :guidefont,
-    # :legendfont,
-    # :grid, :legend,
+    :legendfont, :grid, :legend,
    # :colorbar, :colorbar_title,
    # :fill_z, :line_z, :marker_z, :levels,
-    # :ribbon, :quiver, :arrow,
-    # :orientation,
+    # :ribbon,
+    :quiver,
+    # :arrow, :orientation,
    # :overwrite_figure,
-    # :polar,
+    :polar,
    # :normalize, :weights, :contours,
-    # :aspect_ratio,
+    :aspect_ratio,
    :tick_direction,
    # :framestyle,
    # :camera,
    # :contour_labels,
  ])
-const _gaston_seriestype = [:path,
-                            # :path3d,
-                            :scatter,
-                            :steppre,
-                            # :stepmid,
-                            :steppost,
-                            # :histogram2d,
-                            # :ysticks, :xsticks,
-                            # :contour,
-                            :shape,
-                            # :straightline,
-                            ]

-const _gaston_style = [:auto,
-                       :solid,
-                       :dash,
-                       :dot,
-                       :dashdot,
-                       :dashdotdot
-                       ]
+const _gaston_seriestype = [
+    :path,
+    :path3d,
+    :scatter,
+    :steppre,
+    :stepmid,
+    :steppost,
+    :histogram2d,
+    :ysticks, :xsticks,
+    :contour,
+    :shape,
+    :straightline,
+    :scatter3d,
+    :contour3d,
+    :wireframe,
+    :heatmap,
+    :surface,
+    :mesh3d,
+    :image,
+]

-const _gaston_marker = [:none,
-                        # :auto,
-                        :circle,
-                        :rect,
-                        :diamond,
-                        :utriangle,
-                        :dtriangle,
-                        :pentagon,
-                        :x,
-                        :+
-                        ] #vcat(_allMarkers, Shape)
+const _gaston_style = [
+    :auto,
+   :solid,
+   :dash,
+   :dot,
+   :dashdot,
+   :dashdotdot
+]

-const _gaston_scale = [:identity,
-                       # :ln,
-                       # :log2,
-                       :log10,
-                       ]
+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
@@ -751,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)

@@ -1,315 +1,529 @@
 # https://github.com/mbaz/Gaston.
-const G = Gaston
-const GastonSubplot = G.Plot
-const GASTON_MARKER_SCALING = 1.3 / 5.0
-const GNUPLOT_DPI = 72  # Compensate for DPI with increased resolution

-#
 # --------------------------------------------
 # These functions are called by Plots
 # --------------------------------------------
-#
+
 # Create the window/figure for this backend.
 function _create_backend_figure(plt::Plot{GastonBackend})
-    xsize = plt.attr[:size][1]
-    ysize = plt.attr[:size][2]
-    G.set(termopts="""size $xsize,$ysize""")
-
-    state_handle = G.nexthandle() # for now all the figures will be kept
-    plt.o = G.newfigure(state_handle)
+    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 = G.SubPlot[]
-    grid = size(plt.layout)
-    plt.o.layout = grid
+    plt.o.subplots = Gaston.SubPlot[]

-
-    for sp in plt.subplots
-        gaston_init_subplot(plt, sp)
+    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 in plt.series_list
+    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 = (20mm, 5mm, 2mm, 10mm)
+    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) in (
-    "application/eps"         => "epscairo",   # NEED fixing TODO
-    "image/eps"               => "epslatex",   # NEED fixing TODO
-    "application/pdf"         => "pdfcairo",   # NEED fixing TODO
-    "application/postscript"  => "postscript", # NEED fixing TODO
-    "image/svg+xml"           => "svg",
-    "text/latex"              => "tikz",       # NEED fixing TODO
-    "application/x-tex"       => "epslatex",   # NEED fixing TODO
-    "text/plain"              => "dumb",       # NEED fixing TODO
+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})
-        xsize = plt.attr[:size][1]
-        ysize = plt.attr[:size][2]
-        termopts="""size $xsize,$ysize"""
+        term = String($term); tmpfile = "$(Gaston.tempname()).$term"

-        tmpfile = G.tempname() * "." * $term
-
-        G.save(
-            term = $term,
-            output = tmpfile,
-            handle = plt.o.handle,
-            saveopts = termopts
-        )
+        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

-function _show(io::IO, mime::MIME{Symbol("image/png")},
-               plt::Plot{GastonBackend},)
-    scaling = plt.attr[:dpi] / GNUPLOT_DPI
-    xsize = plt.attr[:size][1] * scaling
-    ysize = plt.attr[:size][2] * scaling
+_display(plt::Plot{GastonBackend}) = display(plt.o)

-    # Scale all plot elements to match Plots.jl DPI standard
-    termopts="""size $xsize,$ysize fontscale $scaling lw $scaling dl $scaling ps $scaling"""
-
-    tmpfile = G.tempname()
-
-    G.save(
-        term = "pngcairo",
-        output = tmpfile,
-        handle = plt.o.handle,
-        saveopts = termopts
-    )
-    while !isfile(tmpfile) end  # avoid race condition with read in next line
-    write(io, read(tmpfile))
-    rm(tmpfile, force=true)
-    nothing
-end
-
-
-function _display(plt::Plot{GastonBackend})
-    display(plt.o)
-end
-#
 # --------------------------------------------
 # These functions are gaston specific
 # --------------------------------------------
-#
-function gaston_init_subplot(plt::Plot{GastonBackend}, sp::Subplot{GastonBackend})
-    dims = RecipesPipeline.is3d(sp) ? 3 : 2

-    axesconf = gaston_parse_axes_args(plt, sp)  # Gnuplot string
-    sp.o = GastonSubplot(dims=dims, axesconf = axesconf, curves = [])
-    push!(plt.o.subplots,  sp.o)
+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)
-    # Gaston.Curve = Plots.Series
-    sp = series[:subplot]
-    g_sp = sp.o  # Gaston subplot object
-
-    seriesconf = gaston_parse_series_args(series)  # Gnuplot string
-    c = G.Curve(series[:x], series[:y], nothing, nothing, seriesconf )
-
-    isfirst = length(g_sp.curves) == 0 ? true : false
-    push!(g_sp.curves, c)
-    G.write_data(c, g_sp.dims, g_sp.datafile, append = isfirst ? false : true)
-end
-
-function gaston_parse_series_args(series::Series)
-    curveconf = String[]
+    sp = series[:subplot]; gsp = sp.o
+    x, y, z = series[:x], series[:y], series[:z]
    st = series[:seriestype]

-    if st == :scatter
-        pt = gaston_marker(series[:markershape])
-        ps = series[:markersize] * GASTON_MARKER_SCALING
-        lc = gaston_color(series[:markercolor])
-        # alpha = series[:markeralpha] # TODO merge alpha with rgb color
-        push!(curveconf, """with points pt $pt ps $ps lc $lc""")
-    elseif st == :path
-        lc = gaston_color(series[:linecolor])
-        dt = gaston_linestyle(series[:linestyle])
-        lw = series[:linewidth]
-        # alpha = series[:linealpha] # TODO merge alpha with rgb color
-        if series[:markershape] == :none # simplepath
-            push!(curveconf, """with lines lc $lc dt $dt lw $lw""")
-        else
-            pt = gaston_marker(series[:markershape])
-            ps = series[:markersize] * GASTON_MARKER_SCALING
-            push!(curveconf, """with lp lc $lc dt $dt lw $lw pt $pt ps $ps""")
+    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
-    elseif st == :shape
-        fc = gaston_color(series[:fillcolor])
-        fs = "solid"
-        lc = gaston_color(series[:linecolor])
-        push!(curveconf, """with filledcurves fc $fc fs $fs border lc $lc""")
-    elseif st == :steppre
-        push!(curveconf, """with steps""")
-    elseif st == :steppost
-        push!(curveconf, """with fsteps""")  # Not sure if not the other way
    end

-    # label
-    push!(curveconf, """title "$(series[:label])" """)
-
-    return join(curveconf, " ")
+    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_parse_axes_args(plt::Plot{GastonBackend}, sp::Subplot{GastonBackend})
+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[]
-    # Standard 2d axis
-    if !ispolar(sp) && !RecipesPipeline.is3d(sp)
-        # TODO
-        # configure grid, axis spines, thickness
-    end

-    for letter in (:x, :y, :z)
-        axis_attr = sp.attr[Symbol(letter, :axis)]
+    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_attr[:guide])"  """)
-        push!(axesconf, """set $(letter)label font "$(axis_attr[:guidefontfamily]), $(axis_attr[:guidefontsize])"  """)
+        push!(axesconf, "set $(letter)label '$(axis[:guide])' $(gaston_font(guidefont(axis)))")
+        mirror = axis[:mirror] ? "mirror" : "nomirror"

-        # Handle ticks
-        # ticksyle
-        push!(axesconf, """set $(letter)tics font "$(axis_attr[:tickfontfamily]), $(axis_attr[:tickfontsize])"  """)
-        push!(axesconf, """set $(letter)tics textcolor rgb "#$(hex(axis_attr[:tickfontcolor], :rrggbb))" """)
-        push!(axesconf, """set $(letter)tics  $(axis_attr[:tick_direction])""")
-
-        mirror = axis_attr[:mirror] ? "mirror" : "nomirror"
-        push!(axesconf, """set $(letter)tics  $(mirror) """)
-
-        logscale = if axis_attr[:scale] == :identity
-            "nologscale"
-        elseif axis_attr[:scale] == :log10
-            "logscale"
+        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)""")
+        push!(axesconf, "set $logscale $letter $base")

-        # tick locations
-        if axis_attr[:ticks] != :native
-            # axis limits
-            from, to = axis_limits(sp, letter)
-            push!(axesconf, """set $(letter)range [$from:$to]""")
+        # 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)))")

-            ticks = get_ticks(sp, axis_attr)
-            gaston_set_ticks!(axesconf, ticks, letter)
+            # 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
-        # set title {"<title-text>"} {offset <offset>} {font "<font>{,<size>}"}{{textcolor | tc} {<colorspec> | default}} {{no}enhanced}1
    end
-    gaston_set_legend!(axesconf, sp) # Set legend params
+    gaston_set_legend!(axesconf, sp, any_label)

-    if sp[:title] != nothing
-        push!(axesconf, """set title '$(sp[:title])' """)
-        push!(axesconf, """set title font '$(sp[:titlefontfamily]), $(sp[:titlefontsize])' """)
+    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)
-
+function gaston_set_ticks!(axesconf, ticks, letter, maj_min, add)
    ticks == :auto && return
-    if ticks == :none || ticks === nothing || ticks == false
-        push!(axesconf, """unset $(letter)tics """)
+    if ticks ∈ (:none, nothing, false)
+        push!(axesconf, "unset $(maj_min)$(letter)tics")
        return
    end

-    ttype = ticksType(ticks)
-    if ttype == :ticks
-        tick_locations = @view ticks[:]
-        gaston_tick_string = []
-        for i in eachindex(tick_locations)
-            lac = tick_locations[i]
-            push!(gaston_tick_string, "$loc")
+    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
-        push!(
-            axesconf,
-            "set $(letter)tics (" * join(gaston_tick_string, ", ") * ")"
-        )
-
    elseif ttype == :ticks_and_labels
-        tick_locations = @view ticks[1][:]
+        tick_locs = @view ticks[1][:]
        tick_labels = @view ticks[2][:]
-        gaston_tick_string = []
-        for i in eachindex(tick_locations)
-            loc = tick_locations[i]
+        for i ∈ eachindex(tick_locs)
            lab = gaston_enclose_tick_string(tick_labels[i])
-            push!(gaston_tick_string, "'$lab' $loc")
+            push!(gaston_ticks, "'$lab' $(tick_locs[i])")
        end
-        push!(
-            axesconf,
-            "set $(letter)tics (" * join(gaston_tick_string, ", ") * ")"
-        )
-
    else
-        error("Invalid input for $(letter)ticks: $ticks")
+        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)
+function gaston_set_legend!(axesconf, sp, any_label)
    leg = sp[:legend]
-    if !(sp[:legend] in(:none, :inline))
-        if leg == :best
-            leg = :topright
-        end
+    if sp[:legend] ∉ (:none, :inline) && any_label
+        leg == :best && (leg = :topright)

-        if occursin("outer", string(leg))
-            push!(axesconf, "set key outside")
-        else
-            push!(axesconf, "set key inside")
+        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
-        positions = ["top", "bottom", "left", "right"]
-        for position in positions
-            if occursin(position, string(leg))
-                push!(axesconf, "set key $position")
-            end
-        end
-        if sp[:legendtitle] != nothing
+        push!(axesconf, "set key $(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 linewidth 1")
-        push!(axesconf, "set key opaque")
-
+        push!(axesconf, "set key box lw 1 opaque")
        push!(axesconf, "set border back")
-        push!(axesconf, """set key font "$(sp[:legendfontfamily]), $(sp[:legendfontsize])"  """)
    else
        push!(axesconf, "set key off")
-
    end
-
+    nothing
 end

-function gaston_marker(marker)
-    marker == :none && return -1
-    marker == :circle && return 7
-    marker == :rect && return 5
-    marker == :diamond && return 28
-    marker == :utriangle && return 9
-    marker == :dtriangle && return 11
-    marker == :+ && return 1
-    marker == :x && return 2
-    marker == :star5 && return 3
-    marker == :pentagon && return 15
-    marker == :pixel && return 0
+# --------------------------------------------
+# Helpers
+# --------------------------------------------

-    @warn("Unsupported marker $marker")
+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

-gaston_color(color) = """rgb "#$(hex(color, :rrggbb))"  """
+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"
@@ -320,12 +534,7 @@ function gaston_linestyle(style)
 end

 function gaston_enclose_tick_string(tick_string)
-    if findfirst("^", tick_string) == nothing
-        return tick_string
-    end
-
-
+    findfirst("^", tick_string) === nothing && return tick_string
    base, power = split(tick_string, "^")
-    power = string("{", power, "}")
-    return string(base, "^", power)
+    return "$base^{$power}"
 end
@@ -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)
@@ -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 isnan(zi)
-            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)
@@ -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()
@@ -984,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)
@@ -1406,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],
@@ -1832,6 +1830,7 @@ 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
@@ -1897,9 +1896,10 @@ function gr_draw_surface(series, x, y, z, clims)
            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 !"))    
+        throw(ArgumentError("Not handled !"))
    end
 end

@@ -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]
@@ -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

@@ -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]
@@ -573,88 +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)"
@@ -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,12 @@ 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, each of which is a tuple of `x`, `y`
-        and `text`.
-        `text` may be a simple `String`, or a `PlotText` object, which can be
-        built with the method `text(string, attrs...)`.
+        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`.
@@ -1241,8 +1242,15 @@ _backend_skips = Dict(
        49, # polar heatmap
        51, # image with custom axes
    ],
-    :inspectdr => [6, 10, 22, 28, 38, 43, 45, 47, 49, 50, 51, 55],
+    :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
+    ],
 )


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

@@ -160,6 +160,7 @@ function plot!(plt1::Plot, plt2::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)
@@ -225,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)

@@ -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
@@ -303,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
@@ -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
@@ -1,4 +1,4 @@
-using Plots: guidefont, series_annotations
+using Plots: guidefont, series_annotations, PLOTS_SEED
 import ImageMagick
 using VisualRegressionTests
 using Plots
@@ -13,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
@@ -68,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
@@ -109,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

@@ -148,4 +148,14 @@ end
    @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
Author	SHA1	Message	Date
Simon Christ	c4681682a1	1.20.0 [skip ci]	2021-08-03 09:58:28 +02:00
t-bltg	a72b4a3481	specify relative coordinates	2021-08-02 23:30:54 +02:00
t-bltg	ff2ae4fe4f	typo	2021-08-02 21:54:35 +02:00
t-bltg	2df85eb0fd	Update examples.jl	2021-08-02 20:14:40 +02:00
t-bltg	508c47895c	Merge pull request #3634 from t-bltg/annotate Allow relative positioning of annotations	2021-08-02 17:28:30 +02:00
t-bltg	07d32197a1	add regression test	2021-08-02 16:55:51 +02:00
t-bltg	d6878a8ea0	remove the need for Plots.pct in annotations	2021-08-02 13:06:02 +02:00
Daniel Schwabeneder	b79a2d32fe	fix series_annotations for bar (#3742 ) * fix series_annotations for bar * fix my typos in bar recipe * fix fillrange of annotation series for groupedbar * fix series_annotations for bar * fix my typos in bar recipe * fix fillrange of annotation series for groupedbar * fix series_annotations for bar * fix my typos in bar recipe * fix fillrange of annotation series for groupedbar * fix series_annotations for bar * fix fillrange of annotation series for groupedbar	2021-08-02 12:58:16 +02:00
t-bltg	7b1941b129	Typo	2021-08-01 18:04:10 +02:00
t-bltg	c6d9332cf1	Gaston: fix polar ticks	2021-08-01 18:03:44 +02:00
t-bltg	670fba56a7	Update examples.jl	2021-08-01 17:55:35 +02:00
t-bltg	9985157eb8	Update backends.jl	2021-08-01 17:54:54 +02:00
t-bltg	9308dd74a8	Update gaston.jl	2021-08-01 17:54:15 +02:00
t-bltg	52be7387f2	Gaston: support polar	2021-08-01 17:53:08 +02:00
t-bltg	a94c49ab95	Gaston: remove unsupported :line, :vline markers	2021-08-01 16:19:16 +02:00
t-bltg	b7c6a65921	Gaston: remove :vline, :hline markers	2021-08-01 16:18:19 +02:00
t-bltg	d8a40f5400	Gaston: remove debug show(...)	2021-08-01 16:12:07 +02:00
t-bltg	e4c8921ae9	Gaston: remove more key entries (e.g. :shape)	2021-08-01 16:11:17 +02:00
t-bltg	fe8d08123c	Gaston: fix wrong series_list causing segfault	2021-08-01 16:00:43 +02:00
t-bltg	defe808619	Gaston: update attributes	2021-08-01 15:23:42 +02:00
t-bltg	85fa05464d	Gaston: reset key on contours	2021-08-01 15:16:46 +02:00
t-bltg	a9a24841fe	Gaston: remove debug	2021-08-01 15:04:52 +02:00
t-bltg	0b989cd33e	Gaston: rework multiplot	2021-08-01 15:04:09 +02:00
t-bltg	773c7a90b4	Gaston: conditional add_to_legend	2021-08-01 14:16:07 +02:00
t-bltg	f49f5d1638	Update gaston.jl	2021-08-01 09:47:36 +02:00
t-bltg	478868a6a2	Merge pull request #3741 from t-bltg/scalefontsizes Rework fontscales - cleanup	2021-08-01 09:31:34 +02:00
t-bltg	806dc3aa43	rework fontscales - cleanup	2021-08-01 09:07:29 +02:00
t-bltg	0f54c86865	Gaston: update examples	2021-08-01 08:46:38 +02:00
t-bltg	5a5864d087	Gaston: rework margins, terminal fontsize and size	2021-08-01 08:35:16 +02:00
t-bltg	baac498532	Merge pull request #3739 from JuliaPlots/Test_SnoopCompile_AutoPR_refs/heads/master [AUTO] Update precompiles [skip ci]	2021-08-01 08:07:35 +02:00
t-bltg	9fba70db5e	Update precompile_*.jl file [skip ci]	2021-08-01 06:00:06 +00:00
t-bltg	af610735eb	Gaston: fix legend font	2021-08-01 07:38:28 +02:00
t-bltg	204adc3e36	Gaston: add flip - add :log2, :ln scales	2021-08-01 07:22:20 +02:00
t-bltg	603dc10788	Gaston: fix broken multiplot	2021-08-01 01:23:44 +02:00
t-bltg	bf16a97cd5	Gaston: fix legendtitle	2021-08-01 01:16:41 +02:00
t-bltg	8ebe9e8204	Gaston: allow additional series	2021-08-01 00:59:02 +02:00
t-bltg	40cc74bea6	Gaston: fix :steppre, :steppost, add histeps	2021-08-01 00:32:33 +02:00
t-bltg	92cad5376b	Update gaston.jl	2021-08-01 00:21:13 +02:00
t-bltg	a3e1a43358	Merge pull request #3738 from t-bltg/segments Gaston: add support for img - rework fonts - fix undef	2021-08-01 00:09:28 +02:00
t-bltg	2fcd907165	Gaston: add support for img - rework fonts - fix undef	2021-08-01 00:08:24 +02:00
t-bltg	2769702687	Merge pull request #3734 from JuliaPlots/Test_SnoopCompile_AutoPR_refs/heads/master [AUTO] Update precompiles [skip ci]	2021-07-31 22:13:31 +02:00
t-bltg	bf43b9ecec	Update precompile_*.jl file [skip ci]	2021-07-31 19:31:14 +00:00
t-bltg	80748eb5e9	Merge pull request #3735 from JuliaPlots/t-bltg-patch-1 GR: remove obsolete method	2021-07-31 21:13:59 +02:00
t-bltg	7863ab9b3b	Update gaston.jl	2021-07-31 20:46:03 +02:00
t-bltg	5bc96cfe68	GR: remove obsolete method	2021-07-31 20:31:58 +02:00
t-bltg	2938950bda	Gaston: missing markers	2021-07-31 20:30:05 +02:00
t-bltg	88b86be17a	Gaston: :hline and :vline are now valid markers	2021-07-31 20:28:37 +02:00
t-bltg	aa6b636793	Gaston: add support for :hline, :vline markers	2021-07-31 20:27:26 +02:00
t-bltg	dc3d302353	Gaston: typo	2021-07-31 19:44:57 +02:00
t-bltg	4ed13644c4	Gaston: minor fixes	2021-07-31 19:21:55 +02:00
t-bltg	34bf55c033	Gaston: blank plot fixes	2021-07-31 19:09:26 +02:00
t-bltg	982c79baa7	Gaston: drop setting termopts in _create_backend_figure	2021-07-31 19:02:29 +02:00
t-bltg	e9b3208d41	Gaston: typo on eval _show	2021-07-31 18:59:49 +02:00
t-bltg	77a9fe3b47	Gaston: add support for background color	2021-07-31 18:50:35 +02:00
t-bltg	4078424f3c	Gaston: add support for annotations	2021-07-31 18:14:40 +02:00
t-bltg	b45400b1d3	Merge pull request #3731 from JuliaPlots/Test_SnoopCompile_AutoPR_refs/heads/t-bltg-patch-1 [AUTO] Update precompiles [skip ci]	2021-07-31 16:43:54 +02:00
t-bltg	dc3e15b4c9	Merge pull request #3730 from JuliaPlots/t-bltg-patch-1 gr_draw_minorgrid should read minorgrid not grid	2021-07-31 16:06:30 +02:00
t-bltg	1e3cb4b4ea	Update precompile_*.jl file [skip ci]	2021-07-31 13:07:29 +00:00
t-bltg	57b48da670	Gaston: conditional label in legend	2021-07-31 15:02:40 +02:00
t-bltg	e9e95968a9	GR: code style	2021-07-31 14:50:16 +02:00
t-bltg	1889f5b7f9	Gaston: add support for major/minor grids	2021-07-31 14:44:34 +02:00
t-bltg	2c72882865	gr_draw_minorgrid should read minorgrid not grid	2021-07-31 14:40:51 +02:00
t-bltg	36a9e3b386	Merge pull request #3729 from t-bltg/minor_ticks Gaston: add minor ticks	2021-07-31 14:35:51 +02:00
t-bltg	03fbc25b33	Gaston: add minor ticks	2021-07-31 14:35:30 +02:00
t-bltg	cbb83e9820	Merge pull request #3728 from t-bltg/markers Gaston: rework markers (filled, empty) - cleanup	2021-07-31 13:57:04 +02:00
t-bltg	4420e2009f	Gaston: rework markers (filled, empty) - cleanup	2021-07-31 13:54:32 +02:00
t-bltg	f394698458	Typo, cleanup	2021-07-31 13:05:23 +02:00
t-bltg	3ec86e983a	Gaston: swap pos and size	2021-07-30 13:29:59 +02:00
t-bltg	5dab21e9ba	Gaston: multiplot, add position	2021-07-30 13:28:22 +02:00
t-bltg	330d3231f6	Gaston: gaston_init_subplot should accept nothing	2021-07-30 13:11:39 +02:00
t-bltg	74b70fc039	Gaston: handle multiple colors	2021-07-30 13:09:59 +02:00
t-bltg	01d5ff1580	Gaston: move update ratios to _update_plot_object	2021-07-30 00:20:38 +02:00
t-bltg	95804039f4	Gaston: Recursive update width/heights from layout	2021-07-29 23:57:58 +02:00
t-bltg	2dec8c1192	Gaston: typo	2021-07-29 22:18:31 +02:00
t-bltg	d3380f4ee8	Gaston: try to respect the layout ratio	2021-07-29 22:16:37 +02:00
t-bltg	cbc0417cea	Gaston: disable legends in contour plots	2021-07-29 21:49:10 +02:00
t-bltg	914ea027d0	Gaston: Unset set size for subplots - Follow Plots.DPI - Cleanup	2021-07-29 19:13:00 +02:00
t-bltg	434656def6	Merge pull request #3727 from t-bltg/debug_mplot Gaston: debug mplot	2021-07-29 18:42:06 +02:00
t-bltg	e16e46db47	Gaston: debug mplot	2021-07-29 18:40:55 +02:00
t-bltg	9e66eb5737	Merge pull request #3725 from johnnychen94/patch-1 add "no changelog" label for SnoopCompile CI	2021-07-29 15:48:56 +02:00
Johnny Chen	5c02648cdd	add "no changelog" label for SnoopCompile CI This excludes PRs created by SnoopCompile CI from the release notes.	2021-07-29 13:57:04 +08:00
t-bltg	fd46fd4add	1.19.4 [skip ci]	2021-07-28 19:21:13 +02:00
t-bltg	ac6c7fda11	Merge pull request #3724 from JuliaPlots/Test_SnoopCompile_AutoPR_refs/heads/master [AUTO] Update precompiles [skip ci]	2021-07-28 19:09:51 +02:00
t-bltg	4755635fbd	Update precompile_*.jl file [skip ci]	2021-07-28 17:08:56 +00:00
t-bltg	c82a3c35ee	Update SnoopCompile.yml	2021-07-28 18:47:15 +02:00
t-bltg	83bce6e895	Update SnoopCompile.yml	2021-07-28 18:45:27 +02:00
t-bltg	07c5019259	Merge pull request #3719 from JuliaPlots/Test_SnoopCompile_AutoPR_refs/heads/master [AUTO] Update precompiles	2021-07-28 18:36:57 +02:00
t-bltg	093181d358	Merge pull request #3721 from t-bltg/inset2 Gaston: update inset_subplots	2021-07-28 18:18:14 +02:00
t-bltg	0085706f6f	Gaston: update inset_subplots	2021-07-28 18:17:43 +02:00
t-bltg	31359610bd	Merge pull request #3720 from t-bltg/inset Gaston: fix lens example	2021-07-28 18:03:45 +02:00
t-bltg	34c6c76cb8	Gaston: fix lens example	2021-07-28 18:02:41 +02:00
t-bltg	734b301abc	Update precompile_*.jl file	2021-07-28 15:38:02 +00:00
t-bltg	e2907b973f	Gaston: change @assert to @error	2021-07-28 17:17:44 +02:00
t-bltg	9e3ff15522	Skip more Gaston unsupported examples	2021-07-28 17:01:05 +02:00
t-bltg	ce8255a462	Merge pull request #3717 from JuliaPlots/Test_SnoopCompile_AutoPR_refs/heads/master [AUTO] Update precompiles	2021-07-28 16:53:53 +02:00
t-bltg	aedb1fbb0b	Update precompile_*.jl file	2021-07-28 13:12:51 +00:00
t-bltg	cebcdfb3b5	Merge pull request #3711 from JuliaPlots/Test_SnoopCompile_AutoPR_refs/heads/master [AUTO] Update precompiles	2021-07-28 14:52:57 +02:00
t-bltg	b4632c8b48	Update precompile_*.jl file	2021-07-28 11:37:41 +00:00
t-bltg	cd4ab0fd24	Merge pull request #3713 from bernd1995/bernd1995-gr-cbarfont Added colorbar font attributes for GR	2021-07-28 13:18:25 +02:00
BerndR	e3cd14944c	Also added supported args	2021-07-28 12:54:11 +02:00
t-bltg	cac0c8d8d3	Gaston: Remove missing debug leftovers	2021-07-28 12:38:49 +02:00
t-bltg	4f352d8e7c	Update docs.yml	2021-07-28 12:07:52 +02:00
t-bltg	aa32561fe8	Merge pull request #3709 from JuliaPlots/Test_SnoopCompile_AutoPR_refs/heads/master [AUTO] Update precompiles	2021-07-28 11:59:22 +02:00
t-bltg	f470e6a590	Update precompile_*.jl file	2021-07-28 09:53:56 +00:00
t-bltg	ca0041639b	Merge pull request #3699 from JuliaPlots/Test_SnoopCompile_AutoPR_refs/heads/master [AUTO] Update precompiles	2021-07-28 11:32:17 +02:00
t-bltg	73208ac3bd	Update precompile_*.jl file	2021-07-28 09:24:48 +00:00
t-bltg	0112e78c50	Merge pull request #3667 from t-bltg/gaston_add Add new gnuplot capabilities (surface, contour, contour3d, scatter3d, wireframe, heatmap, ...)	2021-07-28 11:04:57 +02:00
t-bltg	a3f209b100	Merge pull request #3681 from JuliaPlots/Test_SnoopCompile_AutoPR_refs/heads/master [AUTO] Update precompiles	2021-07-27 21:19:02 +02:00
t-bltg	573c0cf1bf	Merge pull request #3695 from bernd1995/bernd1995-gr-cbarfont Added colorbar font settings for GR	2021-07-27 21:18:36 +02:00
t-bltg	a0c939b7c7	Update gr.jl	2021-07-27 20:42:29 +02:00
BerndR	f4ed35c3b6	Added colorbar font settings	2021-07-27 13:10:25 +02:00
t-bltg	50b0ae3b0f	Update precompile_*.jl file	2021-07-27 10:04:34 +00:00
t-bltg	f049f56e0b	Fix building docs (JuliaPlots/Plots.jl/issues/3664)	2021-07-27 11:41:07 +02:00
t-bltg	6a459d4c22	Update docs.yml	2021-07-27 11:27:19 +02:00
t-bltg	f576456617	Update docs.yml	2021-07-27 11:21:02 +02:00
t-bltg	a7c4eef861	Update docs.yml	2021-07-26 22:28:25 +02:00
t-bltg	741684251c	Update docs.yml	2021-07-26 22:11:21 +02:00
t-bltg	75bd9dbd01	Update docs.yml	2021-07-26 21:54:16 +02:00
t-bltg	42c60a4fd6	Update docs.yml	2021-07-26 21:47:57 +02:00
t-bltg	92caf2e15f	Update docs.yml	2021-07-26 21:25:14 +02:00
t-bltg	99188f7a7e	Update docs.yml	2021-07-26 20:56:29 +02:00
t-bltg	a9d11cb2be	Update docs.yml	2021-07-26 19:15:26 +02:00
t-bltg	8a3fd8f77e	Merge pull request #3679 from JuliaPlots/Test_SnoopCompile_AutoPR_refs/heads/master [AUTO] Update precompiles	2021-07-26 12:02:39 +02:00
t-bltg	bb29abb8a4	Update precompile_*.jl file	2021-07-26 09:52:21 +00:00
t-bltg	b801b2b272	explicit function return, decl - add comments - cleanup	2021-07-26 11:52:13 +02:00
t-bltg	371d9f8dd7	Merge pull request #3677 from JuliaPlots/Test_SnoopCompile_AutoPR_refs/heads/master [AUTO] Update precompiles	2021-07-26 11:27:34 +02:00
t-bltg	49f8e48399	Update precompile_*.jl file	2021-07-25 22:25:42 +00:00
t-bltg	dbc14ac761	Merge pull request #3675 from JuliaPlots/Test_SnoopCompile_AutoPR_refs/heads/master [AUTO] Update precompiles	2021-07-26 00:04:03 +02:00
t-bltg	c0e35f2358	add new gnuplot capabilities (surface, scatter3d, wireframe, ...)	2021-07-25 23:21:09 +02:00
t-bltg	3ce4e23f1b	Update precompile_*.jl file	2021-07-25 19:05:52 +00:00
t-bltg	d4d4d5732b	Update docs.yml	2021-07-25 20:45:59 +02:00
t-bltg	86a732e9c5	Update docs.yml	2021-07-25 19:42:38 +02:00
t-bltg	530768064e	Update docs.yml	2021-07-25 19:33:20 +02:00
t-bltg	89f59532c1	Merge pull request #3672 from JuliaPlots/Test_SnoopCompile_AutoPR_refs/heads/master [AUTO] Update precompiles	2021-07-25 18:53:50 +02:00
t-bltg	c41e586385	revert tol changes [skip ci]	2021-07-25 18:52:45 +02:00
t-bltg	8cbfe74863	Update docs.yml	2021-07-25 18:51:46 +02:00
t-bltg	27032a3e21	Update precompile_*.jl file	2021-07-25 16:33:31 +00:00
t-bltg	07a786a946	Update runtests.jl	2021-07-25 18:05:54 +02:00
t-bltg	ad0f623386	Merge pull request #3670 from JuliaPlots/Test_SnoopCompile_AutoPR_refs/heads/master [AUTO] Update precompiles	2021-07-25 17:59:45 +02:00
t-bltg	4fa567aa5b	Update docs.yml	2021-07-25 17:58:39 +02:00
t-bltg	c5ae99374a	Update runtests.jl	2021-07-25 17:54:52 +02:00
t-bltg	e79740d3bd	Update precompile_*.jl file	2021-07-25 15:49:34 +00:00
t-bltg	dbe6c8dc57	Update docs.yml	2021-07-25 17:47:15 +02:00
t-bltg	9bd075d06b	Merge pull request #3655 from JuliaPlots/Test_SnoopCompile_AutoPR_refs/heads/master [AUTO] Update precompiles	2021-07-25 17:29:39 +02:00
t-bltg	1c68a13d2c	Update docs.yml	2021-07-25 17:24:17 +02:00
t-bltg	86d3097123	Merge pull request #3659 from daschw/gr-tickmarks Make tickmarks the same length for both axes in GR 2D plots	2021-07-25 17:16:12 +02:00
t-bltg	6c2d969316	Update precompile_*.jl file	2021-07-25 12:54:31 +00:00
t-bltg	30e728213e	Merge pull request #3666 from t-bltg/gaston_sp Fix Gaston layout	2021-07-25 14:32:25 +02:00
t-bltg	4c9fd4e4b7	fix gaston layout	2021-07-25 10:52:20 +02:00
Daniel Schwabeneder	458d72b36b	reduce tickmark length	2021-07-24 10:59:06 +02:00
t-bltg	26ddb62a27	Merge pull request #3665 from t-bltg/tol2 More strict on tolerance - drop tol for obsolete version	2021-07-23 20:41:49 +02:00
t-bltg	4aa9d74a28	more strict on tolerance - drop tol for obsolete version	2021-07-23 20:07:08 +02:00
t-bltg	878e590125	Merge pull request #3661 from t-bltg/rng Use a stable RNG in fakedata	2021-07-23 19:50:54 +02:00
Daniel Schwabeneder	4e5b490b6c	make tick length independent of plot size	2021-07-23 19:38:04 +02:00
t-bltg	f3aa61293b	change fakedata rng in tests	2021-07-23 14:47:16 +02:00
t-bltg	cd06648ec3	Switch to Random.GLOBAL_RNG Co-authored-by: Simon Christ <SimonChrist@gmx.de>	2021-07-23 11:02:22 +02:00
t-bltg	fe7d957be3	use a stable RNG in fakedata	2021-07-22 13:00:07 +02:00
t-bltg	a39582c06e	Preempt IMG_TOL with env variable	2021-07-22 02:05:48 +02:00
t-bltg	86fbb39723	Merge pull request #3660 from t-bltg/anim_glob Avoid using global variables in animation.jl	2021-07-22 01:57:03 +02:00
t-bltg	6f49ec112c	avoid using global variables	2021-07-22 01:31:59 +02:00
t-bltg	6594b93126	Add gnuplot to the system dependencies (docs)	2021-07-21 23:49:13 +02:00
Daniel Schwabeneder	f9a1e2e92d	Merge pull request #3656 from JuliaPlots/compathelper/new_version/2021-07-21-00-05-42-160-4162151670 CompatHelper: bump compat for "GeometryBasics" to "0.4"	2021-07-21 22:52:16 +02:00
Daniel Schwabeneder	e58bd8b657	fix minor tick length	2021-07-21 22:39:48 +02:00
Daniel Schwabeneder	5f31ab7169	fix gr tickmarks lengths for 2D plots	2021-07-21 22:30:56 +02:00
t-bltg	b85468162c	Skip failing gaston examples	2021-07-21 21:38:33 +02:00
t-bltg	0550033065	Prepare gaston (gnuplot) for PlotDocs.jl	2021-07-21 19:34:32 +02:00
t-bltg	89db9025c5	1.19.3 [skip ci]	2021-07-21 12:10:19 +02:00
t-bltg	10ed39cf83	Merge pull request #3644 from t-bltg/marker_log Fix computing marker coordinates with log scales	2021-07-21 12:09:34 +02:00
github-actions[bot]	237fa4be7b	CompatHelper: bump compat for "GeometryBasics" to "0.4"	2021-07-21 00:05:47 +00:00
t-bltg	192eb6ffbb	Debugging docs generation	2021-07-20 15:20:03 +02:00
t-bltg	4fc0f85cf1	Merge pull request #3654 from JuliaPlots/Test_SnoopCompile_AutoPR_refs/heads/master [AUTO] Update precompiles	2021-07-20 09:59:27 +02:00
t-bltg	aecce08a0f	Update precompile_*.jl file	2021-07-19 21:37:24 +00:00
t-bltg	3ad2e0674a	Merge pull request #3653 from JuliaPlots/Test_SnoopCompile_AutoPR_refs/heads/master [AUTO] Update precompiles	2021-07-19 23:17:39 +02:00
t-bltg	05f585f8ad	Update precompile_*.jl file	2021-07-19 19:25:33 +00:00
t-bltg	c6ba6dd899	Merge pull request #3652 from JuliaPlots/Test_SnoopCompile_AutoPR_refs/heads/t-bltg-patch-1 [AUTO] Update precompiles	2021-07-19 21:05:57 +02:00
t-bltg	fcf75a195a	Merge pull request #3651 from JuliaPlots/t-bltg-patch-1 Take series alpha into account when drawing contours	2021-07-19 14:31:02 +02:00
t-bltg	3195a67915	Update precompile_*.jl file	2021-07-19 12:22:01 +00:00
t-bltg	aa837bb027	Take series alpha into account when drawing contours	2021-07-19 14:04:01 +02:00
Simon Christ	7bb2a29356	1.19.2 [skip ci]	2021-07-16 12:18:26 +02:00
github-actions[bot]	f0afadf43a	Update precompile_*.jl file (#3648 ) Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>	2021-07-16 12:02:04 +02:00
github-actions[bot]	0525ade990	Update precompile_*.jl file (#3647 ) Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>	2021-07-16 10:52:29 +02:00
Daniel Schwabeneder	6b22f45dd5	fix dpi for GR (#3646 )	2021-07-16 10:30:41 +02:00
Jks Liu	fc0e9a1245	Fix #3440 subplots attributes out of order (#3645 )	2021-07-16 10:29:50 +02:00
Josef Heinen	2ec78be9a1	Update Project.toml bump GR version	2021-07-16 10:28:49 +02:00
github-actions[bot]	4449398614	Update precompile_*.jl file (#3627 ) Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>	2021-07-16 10:26:39 +02:00
t-bltg	946f90d3e4	fix computing marker coordinates with log scales	2021-07-15 12:08:53 +02:00
Simon Christ	c046e6461f	1.19.1 [skip ci]	2021-07-15 09:33:28 +02:00
t-bltg	411de69765	fix plot_title for pyplot (#3642 ) Co-authored-by: t-bltg <t-bltg@users.noreply.github.com>	2021-07-14 22:01:20 +02:00
Simon Christ	4bc6412b46	1.19.0 [skip ci]	2021-07-14 15:51:23 +02:00
Simon Christ	798de8b17c	add the plot_title (#2690 ) * add the plot_title * Update bbs/plot_title (#3604) * add the plot_title * update plot_title for multiple subplots, fix GR warning Co-authored-by: Simon Christ <SimonChrist@gmx.de> Co-authored-by: t-bltg <t-bltg@users.noreply.github.com> * Update plot_title (#3608) * add the plot_title * update plot_title for multiple subplots, fix GR warning * update plot_title * consistency with _subplot_defaults Co-authored-by: Simon Christ <SimonChrist@gmx.de> Co-authored-by: t-bltg <t-bltg@users.noreply.github.com> * custom implementation for pgfplotsx backend * remove `@show` * remove superfluous plot_titleindex Co-authored-by: t-bltg <13423344+t-bltg@users.noreply.github.com> Co-authored-by: t-bltg <t-bltg@users.noreply.github.com>	2021-07-14 15:45:53 +02:00
t-bltg	b0ff0e58b3	InspectDR: Skip more unsupported examples	2021-07-11 21:43:39 +02:00
t-bltg	5cca5e9148	GR: mesh3d, take into account series line attributes	2021-07-11 04:36:22 +02:00
t-bltg	bb493a872a	allow relative positioning of annotations	2021-07-08 18:50:46 +02:00