1.16.1 [skip ci]

fix fontfamily (#3542 )
* fix fontfamily * Update test_defaults.jl
2021-06-04 15:39:51 +02:00 · 2021-06-04 15:36:40 +02:00 · 2021-06-03 19:00:39 +02:00 · 2021-06-03 19:00:06 +02:00 · 2021-06-03 17:36:51 +02:00 · 2021-06-03 17:35:42 +02:00
25 changed files with 1116 additions and 188 deletions
@@ -71,7 +71,10 @@ jobs:

      # Run tests
      - name: Run Graphical test
-        run:  $TESTCMD --project -e 'using Pkg; Pkg.test(coverage=true);'
+        run:  |
+          $TESTCMD --project -e 'using Pkg; Pkg.test(coverage=true);'
+          $TESTCMD -e 'using Pkg; Pkg.activate(tempdir()); Pkg.develop(path=abspath(".")); Pkg.add("StatsPlots"); Pkg.test("StatsPlots");'
+          $TESTCMD -e 'using Pkg; Pkg.activate(tempdir()); Pkg.develop(path=abspath(".")); Pkg.add("GraphRecipes"); Pkg.test("GraphRecipes");'

      - name: Codecov
        uses: julia-actions/julia-uploadcodecov@latest
@@ -0,0 +1,50 @@
+name: docs
+
+on:
+ push:
+  branches:
+    - master
+  tags: '*'
+ 
+jobs:
+  Build_docs:
+    runs-on: ubuntu-18.04
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          repository: JuliaPlots/PlotDocs.jl
+      - uses: julia-actions/setup-julia@v1
+      - name: Cache artifacts
+        uses: actions/cache@v1
+        env:
+          cache-name: cache-artifacts
+        with:
+          path: ~/.julia/artifacts 
+          key: ${{ runner.os }}-test-${{ env.cache-name }}-${{ hashFiles('**/Project.toml') }}
+          restore-keys: |
+            ${{ runner.os }}-test-${{ env.cache-name }}-
+            ${{ runner.os }}-test-
+            ${{ runner.os }}-
+      - name: Install dependencies
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y qt5-default \
+            ttf-mscorefonts-installer \
+            poppler-utils \
+            pdf2svg \
+            texlive-latex-base \
+            texlive-binaries \
+            texlive-pictures \
+            texlive-latex-extra \
+            texlive-luatex \
+            ghostscript-x \
+            libgconf2-4
+          sudo fc-cache -vr
+            
+      - name: build documentation
+        env: 
+          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()' 
+          xvfb-run julia --color=yes --project=docs/ -e 'withenv("GITHUB_REPOSITORY" => "JuliaPlots/PlotDocs.jl") do; include("docs/make.jl"); end' 
@@ -12,3 +12,4 @@ dev/
 test/tmpplotsave.hdf5
 /.benchmarkci
 /benchmark/*.json
+.vscode/
@@ -0,0 +1,693 @@
+{
+    "title": "Plots.jl",
+    "license": "MIT",
+    "creators": [
+        {
+            "affiliation": "Elemental Cognition",
+            "name": "Tom Breloff"
+        }
+    ],
+    "contributors":[
+        {
+            "affiliation": "TU Wien",
+            "name": "Daniel Schwabeneder",
+            "orcid": "0000-0002-0412-0777",
+            "type": "ProjectLeader"
+        },
+        {
+            "affiliation": "GLOBE Institute",
+            "name": "Michael Krabbe Borregaard",
+            "type": "ProjectLeader"
+        },
+        {
+            "affiliation": "Leibniz Universit\u00e4t Hannover",
+            "name": "Simon Christ",
+            "orcid": "0000-0002-5866-1472",
+            "type": "ProjectLeader"
+        },
+        {
+            "affiliation": "Forschungszentrum J\u00fclich",
+            "name": "Josef Heinen",
+            "orcid": "0000-0001-6509-1925",
+            "type": "ProjectMember"
+        },
+        {
+            "name": "Yuval",
+            "type": "Other"
+        },
+        {
+            "name": "Andrew Palugniok",
+            "type": "ProjectMember"
+        },
+        {
+            "affiliation": "@beacon-biosignals",
+            "name": "Simon Danisch",
+            "type": "Other"
+        },
+        {
+            "affiliation": "Veos Digital (https://veos.digital/)",
+            "name": "Pietro Vertechi",
+            "type": "ProjectMember"
+        },
+        {
+            "affiliation": "Korea Advanced Inst. of Science and Technology (KAIST)",
+            "name": "Zhanibek Omarov",
+            "type": "ProjectMember",
+            "orcid": "0000-0002-8783-8791"
+        },
+        {
+            "name": "Thatcher Chamberlin",
+            "type": "Other"
+        },
+        {
+            "name": "@ma-laforge",
+            "type": "ProjectMember"
+        },
+        {
+            "affiliation": "Massachusetts Institute of Technology",
+            "name": "Christopher Rackauckas",
+            "orcid": "0000-0001-5850-0663",
+            "type": "Other"
+        },
+        {
+            "affiliation": "Max Planck Institute for Physics",
+            "name": "Oliver Schulz",
+            "type": "Other"
+        },
+        {
+            "affiliation": "@JuliaComputing",
+            "name": "Sebastian Pfitzner",
+            "type": "Other"
+        },
+        {
+            "name": "Takafumi Arakaki",
+            "type": "Other"
+        },
+        {
+            "affiliation": "University of Manitoba",
+            "name": "Amin Yahyaabadi",
+            "type": "Other"
+        },
+        {
+            "name": "Jack Devine",
+            "type": "Other"
+        },
+        {
+            "name": "Sebastian Pech",
+            "type": "Other"
+        },
+        {
+            "affiliation": "@JuliaComputing",
+            "name": "Patrick Kofod Mogensen",
+            "type": "Other",
+            "orcid": "0000-0002-4910-1932"
+        },
+        {
+            "name": "Samuel S. Watson",
+            "type": "Other"
+        },
+        {
+            "affiliation": "UC Davis",
+            "name": "Naoki Saito",
+            "orcid": "0000-0001-5234-4719",
+            "type": "Other"
+        },
+        {
+            "affiliation": "University of Southern California (USC)",
+            "name": "Benoit Pasquier",
+            "orcid": "0000-0002-3838-5976",
+            "type": "Other"
+        },
+        {
+            "affiliation": "NTNU Trondheim",
+            "name": "Ronny Bergmann",
+            "orcid": "0000-0001-8342-7218",
+            "type": "Other"
+        },
+        {
+            "name": "Andy Nowacki",
+            "affiliation": "University of Leeds",
+            "orcid": "0000-0001-7669-7383",
+            "type": "Other"
+        },
+        {
+            "name": "Ian Butterworth",
+            "type": "Other"
+        },
+        {
+            "affiliation": "Lund University",
+            "name": "David Gustavsson",
+            "type": "Other"
+        },
+        {
+            "name": "Anshul Singhvi",
+            "type": "Other"
+        },
+        {
+            "name": "david-macmahon",
+            "type": "Other"
+        },
+        {
+            "name": "Fredrik Ekre",
+            "type": "Other"
+        },
+        {
+            "name": "Maaz Bin Tahir Saeed",
+            "type": "Other"
+        },
+        {
+            "name": "Kristoffer Carlsson",
+            "type": "Other"
+        },
+        {
+            "name": "Will Kearney",
+            "type": "Other"
+        },
+        {
+            "name": "Niklas Korsbo",
+            "type": "Other"
+        },
+        {
+            "name": "Miles Lucas",
+            "type": "Other"
+        },
+        {
+            "name": "@Godisemo",
+            "type": "Other"
+        },
+        {
+            "name": "Florian Oswald",
+            "type": "Other"
+        },
+        {
+            "name": "Diego Javier Zea",
+            "type": "Other"
+        },
+        {
+            "name": "@WillRam",
+            "type": "Other"
+        },
+        {
+            "name": "Fedor Bezrukov",
+            "type": "Other"
+        },
+        {
+            "name": "Spencer Lyon",
+            "type": "Other"
+        },
+        {
+            "name": "Darwin Darakananda",
+            "type": "Other"
+        },
+        {
+            "name": "Lukas Hauertmann",
+            "type": "Other"
+        },
+        {
+            "name": "Huckleberry Febbo",
+            "type": "Other"
+        },
+        {
+            "name": "@H-M-H",
+            "type": "Other"
+        },
+        {
+            "name": "Josh Day",
+            "type": "Other"
+        },
+        {
+            "name": "@wfgra",
+            "type": "Other"
+        },
+        {
+            "name": "Sheehan Olver",
+            "type": "Other"
+        },
+        {
+            "name": "Jerry Ling",
+            "type": "Other"
+        },
+        {
+            "name": "Jks Liu",
+            "type": "Other"
+        },
+        {
+            "name": "Seth Axen",
+            "type": "Other"
+        },
+        {
+            "name": "@o01eg",
+            "type": "Other"
+        },
+        {
+            "name": "Sebastian Micluța-Câmpeanu",
+            "type": "Other"
+        },
+        {
+            "name": "Tim Holy",
+            "type": "Other"
+        },
+        {
+            "name": "Tony Kelman",
+            "type": "Other"
+        },
+        {
+            "name": "Antoine Levitt",
+            "type": "Other"
+        },
+        {
+            "name": "Iblis Lin",
+            "type": "Other"
+        },
+        {
+            "name": "Harry Scholes",
+            "type": "Other"
+        },
+        {
+            "name": "@djsegal",
+            "type": "Other"
+        },
+        {
+            "name": "Goran Nakerst",
+            "type": "Other"
+        },
+        {
+            "name": "Felix Hagemann",
+            "type": "Other"
+        },
+        {
+            "name": "Matthieu Gomez",
+            "type": "Other"
+        },
+        {
+            "name": "@biggsbiggsby",
+            "type": "Other"
+        },
+        {
+            "name": "Jonathan Anderson",
+            "type": "Other"
+        },
+        {
+            "name": "Michael Kraus",
+            "type": "Other"
+        },
+        {
+            "name": "Carlo Lucibello",
+            "type": "Other"
+        },
+        {
+            "name": "Robin Deits",
+            "type": "Other"
+        },
+        {
+            "name": "Misha Mkhasenko",
+            "type": "Other"
+        },
+        {
+            "name": "Benoît Legat",
+            "type": "Other"
+        },
+        {
+            "name": "Steven G. Johnson",
+            "type": "Other"
+        },
+        {
+            "name": "John Verzani",
+            "type": "Other"
+        },
+        {
+            "name": "Mattias Fält",
+            "type": "Other"
+        },
+        {
+            "name": "Rashika Karki",
+            "type": "Other"
+        },
+        {
+            "name": "Morten Piibeleht",
+            "type": "Other"
+        },
+        {
+            "name": "Filippo Vicentini",
+            "type": "Other"
+        },
+        {
+            "name": "David Anthoff",
+            "type": "Other"
+        },
+        {
+            "name": "Leon Wabeke",
+            "type": "Other"
+        },
+        {
+            "name": "Yusuke Kominami",
+            "type": "Other"
+        },
+        {
+            "name": "Oscar Dowson",
+            "type": "Other"
+        },
+        {
+            "name": "Max G",
+            "type": "Other"
+        },
+        {
+            "name": "Fabian Greimel",
+            "type": "Other"
+        },
+        {
+            "name": "Jérémy",
+            "type": "Other"
+        },
+        {
+            "name": "Pearl Li",
+            "type": "Other"
+        },
+        {
+            "name": "David P. Sanders",
+            "type": "Other"
+        },
+        {
+            "name": "Asbjørn Nilsen Riseth",
+            "type": "Other"
+        },
+        {
+            "name": "Jan Weidner",
+            "type": "Other"
+        },
+        {
+            "name": "@jakkor2",
+            "type": "Other"
+        },
+        {
+            "name": "Pablo Zubieta",
+            "type": "Other"
+        },
+        {
+            "name": "Hamza Yusuf Çakır",
+            "type": "Other"
+        },
+        {
+            "name": "John Rinehart",
+            "type": "Other"
+        },
+        {
+            "name": "Martin Biel",
+            "type": "Other"
+        },
+        {
+            "name": "Moritz Schauer",
+            "type": "Other"
+        },
+        {
+            "name": "Moesè Giodano",
+            "type": "Other"
+        },
+        {
+            "name": "@olegshtch",
+            "type": "Other"
+        },
+        {
+            "name": "Leon Shen",
+            "type": "Other"
+        },
+        {
+            "name": "Jeff Fessler",
+            "type": "Other"
+        },
+        {
+            "name": "@hustf",
+            "type": "Other"
+        },
+        {
+            "name": "Asim H Dar",
+            "type": "Other"
+        },
+        {
+            "name": "@8uurg",
+            "type": "Other"
+        },
+        {
+            "name": "Abel Siqueira",
+            "type": "Other"
+        },
+        {
+            "name": "Adrian Dawid",
+            "type": "Other"
+        },
+        {
+            "name": "Alberto Lusiani",
+            "type": "Other"
+        },
+        {
+            "name": "Balázs Mezei",
+            "type": "Other"
+        },
+        {
+            "name": "Ben Ide",
+            "type": "Other"
+        },
+        {
+            "name": "Benjamin Lungwitz",
+            "type": "Other"
+        },
+        {
+            "affiliation": "University of Graz",
+            "name": "Bernd Riederer",
+            "type": "Other",
+            "orcid": "0000-0001-8390-0087"
+        },
+        {
+            "name": "Christina Lee",
+            "type": "Other"
+        },
+        {
+            "name": "Christof Stocker",
+            "type": "Other"
+        },
+        {
+            "name": "Christoph Finkensiep",
+            "type": "Other"
+        },
+        {
+            "name": "@Cornelius-G",
+            "type": "Other"
+        },
+        {
+            "name": "Daniel Høegh",
+            "type": "Other"
+        },
+        {
+            "name": "Denny Biasiolli",
+            "type": "Other"
+        },
+        {
+            "name": "Dieter Castel",
+            "type": "Other"
+        },
+        {
+            "name": "Elliot Saba",
+            "type": "Other"
+        },
+        {
+            "name": "Fengyang Wang",
+            "type": "Other"
+        },
+        {
+            "name": "Fons van der Plas",
+            "type": "Other"
+        },
+        {
+            "name": "Fredrik Bagge Carlson",
+            "type": "Other"
+        },
+        {
+            "name": "Graham Smith",
+            "type": "Other"
+        },
+        {
+            "name": "Hayato Ikoma",
+            "type": "Other"
+        },
+        {
+            "name": "Hessam Mehr",
+            "type": "Other"
+        },
+        {
+            "name": "@InfiniteChai",
+            "type": "Other"
+        },
+        {
+            "name": "Jack Dunn",
+            "type": "Other"
+        },
+        {
+            "name": "Jeff Bezanson",
+            "type": "Other"
+        },
+        {
+            "name": "Jeff Eldredge",
+            "type": "Other"
+        },
+        {
+            "name": "Jinay Jain",
+            "type": "Other"
+        },
+        {
+            "name": "Johan Blåbäck",
+            "type": "Other"
+        },
+        {
+            "name": "@jmert",
+            "type": "Other"
+        },
+        {
+            "name": "Lakshya Khatri",
+            "type": "Other"
+        },
+        {
+            "name": "Lia Siegelmann",
+            "type": "Other"
+        },
+        {
+            "name": "@marekkukan-tw",
+            "type": "Other"
+        },
+        {
+            "affiliation": "ETH Zurich",
+            "name": "Mauro Werder",
+            "type": "Other",
+            "orcid": "0000-0003-0137-9377"
+        },
+        {
+            "name": "Maxim Grechkin",
+            "type": "Other"
+        },
+        {
+            "name": "Michael Cawte",
+            "type": "Other"
+        },
+        {
+            "name": "@milesfrain",
+            "type": "Other"
+        },
+        {
+            "name": "Nicholas Bauer",
+            "type": "Other"
+        },
+        {
+            "name": "Nicolau Leal Werneck",
+            "type": "Other"
+        },
+        {
+            "name": "@nilshg",
+            "type": "Other"
+        },
+        {
+            "name": "Oliver Evans",
+            "type": "Other"
+        },
+        {
+            "name": "Peter Gagarinov",
+            "type": "Other"
+        },
+        {
+            "name": "Páll Haraldsson",
+            "type": "Other"
+        },
+        {
+            "name": "Rik Huijzer",
+            "type": "Other"
+        },
+        {
+            "name": "Romain Franconville",
+            "type": "Other"
+        },
+        {
+            "name": "Ronan Pigott",
+            "type": "Other"
+        },
+        {
+            "name": "Roshan Shariff",
+            "type": "Other"
+        },
+        {
+            "name": "Scott Thomas",
+            "type": "Other"
+        },
+        {
+            "name": "Sebastian Rollén",
+            "type": "Other"
+        },
+        {
+            "name": "Seth Bromberger",
+            "type": "Other"
+        },
+        {
+            "name": "Siva Swaminathan",
+            "type": "Other"
+        },
+        {
+            "name": "Tim DuBois",
+            "type": "Other"
+        },
+        {
+            "name": "Travis DePrato",
+            "type": "Other"
+        },
+        {
+            "name": "Will Thompson",
+            "type": "Other"
+        },
+        {
+            "name": "Yakir Luc Gagnon",
+            "type": "Other"
+        },
+        {
+            "name": "Benjamin Chislett",
+            "type": "Other"
+        },
+        {
+            "name": "@hhaensel",
+            "type": "Other"
+        },
+        {
+            "name": "@improbable22",
+            "type": "Other"
+        },
+        {
+            "name": "Johannes Fleck",
+            "type": "Other"
+        },
+        {
+            "name": "Peter Czaban",
+            "type": "Other"
+        },
+        {
+            "name": "@innerlee",
+            "type": "Other"
+        },
+        {
+            "name": "Mats Cronqvist",
+            "type": "Other"
+        },
+        {
+            "name": "Shi Pengcheng",
+            "type": "Other"
+        },
+        {
+            "name": "@wg030",
+            "type": "Other"
+        },
+        {
+            "affiliation": "University of Cambridge",
+            "name": "Will Tebbutt",
+            "type": "Other"
+        },
+        {
+            "name": "@t-bltg",
+            "type": "Other"
+        }
+    ],
+    "upload_type": "software"
+}
@@ -1,7 +1,7 @@
 name = "Plots"
 uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
 author = ["Tom Breloff (@tbreloff)"]
-version = "1.13.0"
+version = "1.16.1"

 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
@@ -36,7 +36,7 @@ UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
 Contour = "0.5"
 FFMPEG = "0.2, 0.3, 0.4"
 FixedPointNumbers = "0.6, 0.7, 0.8"
-GR = "0.46, 0.47, 0.48, 0.49, 0.50, 0.51, 0.52, 0.53, 0.54, 0.55, 0.57"
+GR = "0.53, 0.54, 0.55, 0.57"
 GeometryBasics = "0.2, 0.3.1"
 JSON = "0.21, 1"
 Latexify = "0.14, 0.15"
@@ -18,6 +18,10 @@
 [![][docs-img]][docs-url]
 [![Codecov](https://codecov.io/gh/JuliaPlots/Plots.jl/branch/master/graph/badge.svg)](https://codecov.io/gh/JuliaPlots/Plots.jl)

+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.4725317.svg)](https://doi.org/10.5281/zenodo.4725317)
+This is the DOI for all Versions, please follow the link to get the DOI for a specific version.
+
+
 #### Created by Tom Breloff (@tbreloff)

 #### Maintained by the [JuliaPlots members](https://github.com/orgs/JuliaPlots/people)
@@ -68,28 +68,44 @@ function _precompile_()
    ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:label, :blank), Tuple{Symbol, Bool}},Type{EmptyLayout}})
    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:label, :width, :height), Tuple{Symbol, Symbol, Length{:pct, Float64}}},Type{EmptyLayout}})
+    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{GridLayout}},Type{Subplot},GRBackend})
+    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{GridLayout}},Type{Subplot},PlotlyBackend})
+    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{Subplot{GRBackend}}},Type{Subplot},GRBackend})
+    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{Subplot{PlotlyBackend}}},Type{Subplot},PlotlyBackend})
    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}, Vector{Float64}},Int64})
    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}, Vector{Float64}},Tuple{Int64, Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Vector{Int64}}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:flip,), Tuple{Bool}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,), Tuple{Symbol}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,), Tuple{typeof(datetimeformatter)}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :lims), Tuple{Bool, Tuple{Float64, Float64}}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :lims, :flip), Tuple{Bool, Tuple{Float64, Float64}, Bool}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid,), Tuple{Bool}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:gridlinewidth, :grid, :gridalpha, :gridstyle, :foreground_color_grid), Tuple{Int64, Bool, Float64, Symbol, RGBA{Float64}}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide,), Tuple{String}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide_position, :guidefontvalign, :mirror, :guide), Tuple{Symbol, Symbol, Bool, String}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guidefonthalign, :guide_position, :mirror, :guide), Tuple{Symbol, Symbol, Bool, String}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims, :flip, :ticks, :guide), Tuple{Tuple{Int64, Int64}, Bool, StepRange{Int64, Int64}, String}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Float64, Float64}}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Int64, Float64}}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Int64, Int64}}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:rotation,), Tuple{Int64}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:scale, :guide), Tuple{Symbol, String}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,), Tuple{Nothing}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,), Tuple{UnitRange{Int64}}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:shape,), Tuple{Symbol}},typeof(default)})
    Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:titlefont, :legendfontsize, :guidefont, :tickfont, :guide, :framestyle, :yminorgrid), Tuple{Tuple{Int64, String}, Int64, Tuple{Int64, Symbol}, Tuple{Int64, Symbol}, String, Symbol, Bool}},typeof(default)})
+    Base.precompile(Tuple{Core.kwftype(typeof(font)),NamedTuple{(:family, :pointsize, :halign, :valign, :rotation, :color), Tuple{String, Int64, Symbol, Symbol, Float64, RGBA{Float64}}},typeof(font)})
+    Base.precompile(Tuple{Core.kwftype(typeof(font)),NamedTuple{(:family, :pointsize, :valign, :halign, :rotation, :color), Tuple{String, Int64, Symbol, Symbol, Float64, RGBA{Float64}}},typeof(font)})
    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),StepRange{Int64, Int64},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),UnitRange{Int64},UnitRange{Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),UnitRange{Int64},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),Vector{Int64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(gr_set_font)),NamedTuple{(:halign, :valign, :rotation, :color), Tuple{Symbol, Symbol, Int64, RGBA{Float64}}},typeof(gr_set_font),Font,Subplot{GRBackend}})
    Base.precompile(Tuple{Core.kwftype(typeof(hline!)),Any,typeof(hline!),Any})
+    Base.precompile(Tuple{Core.kwftype(typeof(pie)),Any,typeof(pie),Any,Vararg{Any, N} where N})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Plot{GRBackend},Vector{GeometryBasics.Point2{Float64}}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{GeometryBasics.Point2{Float64}}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Vector{GeometryBasics.Point2{Float64}}})
@@ -108,7 +124,9 @@ 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},Vararg{Any, N} where N})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Vector{Int64},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Plot{GRBackend},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!),Plot{GRBackend}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!),Plot{PlotlyBackend}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!)})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:w,), Tuple{Int64}},typeof(plot!),Plot{GRBackend},Vector{Float64},Vararg{Any, N} where N})
@@ -118,6 +136,7 @@ function _precompile_()
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype), Tuple{Vector{Float64}, Tuple{Symbol, Float64, Stroke}, Vector{Float64}, String, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype), Tuple{Vector{Float64}, Tuple{Symbol, Float64, Stroke}, Vector{Float64}, String, Symbol}},typeof(plot!),Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:annotations, :leg), Tuple{Tuple{Int64, Float64, PlotText}, Bool}},typeof(plot),Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:arrow,), Tuple{Int64}},typeof(plot),Vector{Float64},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:aspect_ratio, :seriestype), Tuple{Int64, Symbol}},typeof(plot),Vector{String},Vector{String},Vararg{Any, N} where N})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:bins, :weights, :seriestype), Tuple{Symbol, Vector{Int64}, Symbol}},typeof(plot),Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:color, :line, :marker), Tuple{Matrix{Symbol}, Tuple{Symbol, Int64}, Tuple{Matrix{Symbol}, Int64, Float64, Stroke}}},typeof(plot),Vector{Vector{T} where T}})
@@ -128,7 +147,6 @@ function _precompile_()
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:lab, :w, :palette, :fill, :α), Tuple{String, Int64, PlotUtils.ContinuousColorGradient, Int64, Float64}},typeof(plot),StepRange{Int64, Int64},Matrix{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label, :title, :xlabel, :linewidth, :legend), Tuple{Matrix{String}, String, String, Int64, Symbol}},typeof(plot),Vector{Function},Float64,Vararg{Float64, N} where N})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label,), Tuple{Matrix{String}}},typeof(plot),Vector{AbstractVector{Float64}}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:labels,), Tuple{Matrix{String}}},typeof(plot),PortfolioComposition})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :group, :linetype, :linecolor), Tuple{GridLayout, Vector{String}, Matrix{Symbol}, Symbol}},typeof(plot),Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :label, :fillrange, :fillalpha), Tuple{Tuple{Int64, Int64}, String, Int64, Float64}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :label, :fillrange, :fillalpha), Tuple{Tuple{Int64, Int64}, String, Int64, Float64}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
@@ -149,9 +167,9 @@ function _precompile_()
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :lab, :ms), Tuple{Tuple{Matrix{Symbol}, Int64}, Matrix{String}, Int64}},typeof(plot),Vector{Vector{T} where T},Matrix{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :label, :legendtitle), Tuple{Tuple{Int64, Matrix{Symbol}}, Matrix{String}, String}},typeof(plot),Matrix{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :leg, :fill), Tuple{Int64, Bool, Tuple{Int64, Symbol}}},typeof(plot),Function,Function,Vararg{Any, N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :marker, :bg, :fg, :xlim, :ylim, :leg), Tuple{Tuple{Int64, Symbol, Symbol}, Tuple{Shape, Int64, RGBA{Float64}}, Symbol, Symbol, Tuple{Int64, Int64}, Tuple{Int64, Int64}, Bool}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :marker, :bg, :fg, :xlim, :ylim, :leg), Tuple{Tuple{Int64, Symbol, Symbol}, Tuple{Shape{Float64, Float64}, Int64, RGBA{Float64}}, Symbol, Symbol, Tuple{Int64, Int64}, Tuple{Int64, Int64}, Bool}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line_z, :linewidth, :legend), Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int64, Bool}},typeof(plot),Vector{Float64},Vector{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:m, :lab, :bg, :xlim, :ylim, :seriestype), Tuple{Tuple{Int64, Symbol}, Matrix{String}, Symbol, Tuple{Int64, Int64}, Tuple{Int64, Int64}, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:m, :markersize, :lab, :bg, :xlim, :ylim, :seriestype), Tuple{Matrix{Symbol}, Int64, Matrix{String}, Symbol, Tuple{Int64, Int64}, Tuple{Int64, Int64}, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Matrix{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:marker,), Tuple{Bool}},typeof(plot),Vector{Union{Missing, Int64}}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:marker_z, :color, :legend, :seriestype), Tuple{typeof(+), Symbol, Bool, Symbol}},typeof(plot),Vector{Float64},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:markershape, :markersize, :marker_z, :line_z, :linewidth), Tuple{Matrix{Symbol}, Matrix{Int64}, Matrix{Int64}, Matrix{Int64}, Matrix{Int64}}},typeof(plot),Matrix{Float64}})
@@ -162,6 +180,8 @@ function _precompile_()
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:projection, :seriestype), Tuple{Symbol, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},UnitRange{Int64},Vararg{Any, N} where N})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:quiver, :seriestype), Tuple{Tuple{Vector{Float64}, Vector{Float64}, Vector{Float64}}, Symbol}},typeof(plot),Vector{Float64},Vector{Float64},Vararg{Vector{Float64}, N} where N})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:reg, :fill), Tuple{Bool, Tuple{Int64, Symbol}}},typeof(plot),Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{Int64}},typeof(plot),UnitRange{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}},typeof(plot),UnitRange{Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{Tuple{LinRange{Float64}, LinRange{Float64}}}},typeof(plot),UnitRange{Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{typeof(sqrt)}},typeof(plot),UnitRange{Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype, :markershape, :markersize, :color), Tuple{Matrix{Symbol}, Vector{Symbol}, Int64, Vector{Symbol}}},typeof(plot),Matrix{Float64}})
@@ -184,6 +204,7 @@ function _precompile_()
    Base.precompile(Tuple{Type{GridLayout},Int64,Vararg{Int64, N} where N})
    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},AbstractVector{OHLC}})
    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},PortfolioComposition})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:barbins}},Any,Any,Any})
    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:barhist}},Any,Any,Any})
    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:bar}},Any,Any,Any})
    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:bins2d}},Any,Any,Any})
@@ -192,6 +213,7 @@ function _precompile_()
    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:lens}},AbstractPlot})
    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:pie}},Any,Any,Any})
    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:quiver}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:spy}},Any,Any,Any})
    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:steppre}},Any,Any,Any})
    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:sticks}},Any,Any,Any})
    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:vline}},Any,Any,Any})
@@ -214,6 +236,10 @@ function _precompile_()
    Base.precompile(Tuple{typeof(_cbar_unique),Vector{PlotUtils.ContinuousColorGradient},String})
    Base.precompile(Tuple{typeof(_cbar_unique),Vector{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}},String})
    Base.precompile(Tuple{typeof(_cbar_unique),Vector{Symbol},String})
+    Base.precompile(Tuple{typeof(_cycle),Base.OneTo{Int64},Vector{Int64}})
+    Base.precompile(Tuple{typeof(_cycle),StepRange{Int64, Int64},Vector{Int64}})
+    Base.precompile(Tuple{typeof(_cycle),Vector{Float64},StepRange{Int64, Int64}})
+    Base.precompile(Tuple{typeof(_cycle),Vector{Float64},UnitRange{Int64}})
    Base.precompile(Tuple{typeof(_do_plot_show),Plot{GRBackend},Bool})
    Base.precompile(Tuple{typeof(_heatmap_edges),Vector{Float64},Bool,Bool})
    Base.precompile(Tuple{typeof(_plot!),Plot,Any,Any})
@@ -229,18 +255,22 @@ function _precompile_()
    Base.precompile(Tuple{typeof(bbox),Float64,Float64,Float64,Float64})
    Base.precompile(Tuple{typeof(build_layout),GridLayout,Int64})
    Base.precompile(Tuple{typeof(contour),Any,Vararg{Any, N} where N})
+    Base.precompile(Tuple{typeof(convertLegendValue),Symbol})
    Base.precompile(Tuple{typeof(convert_to_polar),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64},Tuple{Int64, Float64}})
    Base.precompile(Tuple{typeof(create_grid),Expr})
+    Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64},Vararg{Vector{Float64}, N} where N})
    Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64}})
    Base.precompile(Tuple{typeof(error_zipit),Tuple{Vector{Float64}, Vector{Float64}, Vector{Float64}}})
-    Base.precompile(Tuple{typeof(font),String,Vararg{Any, N} where N})
+    Base.precompile(Tuple{typeof(expand_extrema!),Axis,Base.OneTo{Int64}})
    Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Vector{Float64}, Vector{String}}})
    Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Vector{Int64}, Vector{String}}})
+    Base.precompile(Tuple{typeof(get_series_color),Vector{Symbol},Subplot{GRBackend},Int64,Symbol})
    Base.precompile(Tuple{typeof(get_ticks),StepRange{Int64, Int64},Vector{Float64},Vector{Any},Tuple{Int64, Int64},Vararg{Any, N} where N})
    Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Float64, Float64},Vararg{Any, N} where N})
    Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Int64, Float64},Vararg{Any, N} where N})
    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, Float64, Float64, Float64, Int64, Float64, Float64, Float64, Float64}},Vector{Float64}})
@@ -248,18 +278,26 @@ function _precompile_()
    Base.precompile(Tuple{typeof(gr_draw_colorbar),GRColorbar,Subplot{GRBackend},Tuple{Float64, Float64},Vector{Float64}})
    Base.precompile(Tuple{typeof(gr_draw_contour),Series,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Matrix{Float64},Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_heatmap),Series,Vector{Float64},Vector{Float64},Matrix{Float64},Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Float64,Float64,Symbol})
+    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Int64,Int64,Shape{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Float64,Tuple{Float64, Float64},Int64,Float64,Int64,Symbol})
+    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Int64,Tuple{Float64, Float64},Int64,Int64,Int64,Symbol})
+    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Base.OneTo{Int64},Vector{Float64},Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_markers),Series,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64},Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},UnitRange{Int64},Tuple{Vector{Float64}, Vector{Float64}},Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_segments),Series,StepRange{Int64, Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_segments),Series,UnitRange{Int64},Vector{Float64},Nothing,Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Vector{Float64},Vector{Float64},Int64,Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_shapes),Series,Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Matrix{Float64},Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Vector{Float64},Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_fill_viewport),Vector{Float64},RGBA{Float64}})
    Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Vector{Float64}, Vector{String}},Int64})
+    Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Vector{Int64}, Vector{String}},Int64})
    Base.precompile(Tuple{typeof(gr_label_ticks),Subplot{GRBackend},Symbol,Tuple{Vector{Float64}, Vector{String}}})
    Base.precompile(Tuple{typeof(gr_label_ticks_3d),Subplot{GRBackend},Symbol,Tuple{Vector{Float64}, Vector{String}}})
    Base.precompile(Tuple{typeof(gr_polaraxes),Int64,Float64,Subplot{GRBackend}})
+    Base.precompile(Tuple{typeof(gr_polyline),Vector{Float64},Vector{Float64},Function})
    Base.precompile(Tuple{typeof(gr_set_gradient),PlotUtils.ContinuousColorGradient})
    Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Vector{Float64},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), NTuple{9, Float64}}})
    Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Vector{Float64},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), Tuple{Int64, Float64, Float64, Float64, Int64, Float64, Float64, Float64, Float64}}})
@@ -272,31 +310,38 @@ function _precompile_()
    Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol,Vector{Float64},Symbol,Tuple{Int64, Int64},Bool})
    Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol})
    Base.precompile(Tuple{typeof(ignorenan_minimum),Vector{Int64}})
-    Base.precompile(Tuple{typeof(iter_segments),StepRange{Int64, Int64},Vararg{Any, N} where N})
    Base.precompile(Tuple{typeof(layout_args),Int64})
-    Base.precompile(Tuple{typeof(ohlc),Any})
+    Base.precompile(Tuple{typeof(make_fillrange_side),UnitRange{Int64},LinRange{Float64}})
    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Function})
    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Symbol})
    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Int64, Float64},Symbol,Symbol})
    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Int64, Int64},Symbol,Symbol})
    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),StepRange{Int64, Int64},Tuple{Int64, Int64},Symbol,Symbol})
    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),UnitRange{Int64},Tuple{Float64, Float64},Symbol,Symbol})
+    Base.precompile(Tuple{typeof(partialcircle),Int64,Float64,Int64})
    Base.precompile(Tuple{typeof(plot),Any,Any,Vararg{Any, N} where N})
    Base.precompile(Tuple{typeof(plot),Any})
+    Base.precompile(Tuple{typeof(processFillArg),Dict{Symbol, Any},Symbol})
+    Base.precompile(Tuple{typeof(processGridArg!),DefaultsDict,Bool,Symbol})
    Base.precompile(Tuple{typeof(processGridArg!),Dict{Symbol, Any},Symbol,Symbol})
    Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},Matrix{Symbol}})
    Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},Symbol})
    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Matrix{Symbol}})
    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},RGBA{Float64}})
-    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Shape})
+    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Shape{Float64, Float64}})
+    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Stroke})
    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Symbol})
    Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,PlotText})
    Base.precompile(Tuple{typeof(process_annotation),Subplot{PlotlyBackend},Int64,Float64,PlotText})
    Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},StepRange{Int64, Int64},Symbol})
    Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},Symbol,Symbol})
    Base.precompile(Tuple{typeof(push!),Plot{GRBackend},Float64,Vector{Float64}})
-    Base.precompile(Tuple{typeof(push!),Segments{Tuple{Float64, Float64, Float64}},Tuple{Int64, Float64, Int64},Tuple{Int64, Float64, Int64}})
+    Base.precompile(Tuple{typeof(slice_arg),Base.ReshapedArray{Int64, 2, UnitRange{Int64}, Tuple{}},Int64})
    Base.precompile(Tuple{typeof(slice_arg),Matrix{Bool},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{Int64},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{PlotUtils.ContinuousColorGradient},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{RGBA{Float64}},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{String},Int64})
    Base.precompile(Tuple{typeof(spy),Any})
    Base.precompile(Tuple{typeof(straightline_data),Tuple{Float64, Float64},Tuple{Float64, Float64},Vector{Float64},Vector{Float64},Int64})
    Base.precompile(Tuple{typeof(stroke),Int64,Vararg{Any, N} where N})
@@ -308,9 +353,9 @@ function _precompile_()
    Base.precompile(Tuple{typeof(xgrid!),Plot{GRBackend},Symbol,Vararg{Any, N} where N})
    Base.precompile(Tuple{typeof(xlims),Subplot{PlotlyBackend}})
    Base.precompile(Tuple{typeof(yaxis!),Any,Any})
-    let fbody = try __lookup_kwbody__(which(bar, (Any,))) catch missing end
+    let fbody = try __lookup_kwbody__(which(gr_polyline, (Vector{Float64},Vector{Float64},typeof(GR.fillarea),))) catch missing end
        if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(bar),Any,))
+            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
@@ -137,8 +137,8 @@ end
 # -----------------------------------------------

 function _animate(forloop::Expr, args...; callgif = false)
-  if forloop.head != :for
-    error("@animate macro expects a for-block. got: $(forloop.head)")
+  if forloop.head ∉ (:for, :while)
+    error("@animate macro expects a for- or while-block. got: $(forloop.head)")
  end

  # add the call to frame to the end of each iteration
@@ -116,6 +116,12 @@ const _arg_desc = KW(
 :legendfont                  => "Font. Font of legend items.",
 :legendtitlefont             => "Font. Font of the legend title.",
 :annotations                 => "(x,y,text) tuple(s).  Can be a single tuple or a list of them.  Text can be String or PlotText (created with `text(args...)`)  Add one-off text annotations at the x,y coordinates.",
+:annotationfontfamily        => "String or Symbol. Font family of annotations.",
+:annotationfontsize          => "Integer. Font pointsize of annotations.",
+:annotationhalign            => "Symbol. horizontal alignment of annotations, :hcenter, :left, :right or :center.",
+:annotationvalign            => "Symbol. Vertical alignment of annotations, :vcenter, :top, :bottom or :center.",
+:annotationrotation          => "Float. Rotation of annotations in degrees.",
+:annotationcolor             => "Colorant or :match. Color of annotations.",
 :projection                  => "Symbol or String.  '3d' or 'polar'",
 :aspect_ratio                => "Symbol (:equal or :none) or Number. Plot area is resized so that 1 y-unit is the same size as `aspect_ratio` x-units. With `:none`, images inherit aspect ratio of the plot area.",
 :margin                      => "Measure (multiply by `mm`, `px`, etc). Base for individual margins... not directly used.  Specifies the extra padding around subplots.",
@@ -165,7 +171,7 @@ const _arg_desc = KW(
 :minorgridalpha              => "Number in [0,1]. The alpha/opacity override for the minorgrid lines.",
 :minorgridstyle              => "Symbol. Style of the minor grid lines. Choose from $(_allStyles)",
 :minorgridlinewidth          => "Number. Width of the minor grid lines (in pixels)",
-:tick_direction              => "Symbol.  Direction of the ticks. `:in` or `:out`",
+:tick_direction              => "Symbol.  Direction of the ticks. `:in`, `:out` or `:none`",
 :showaxis                    => "Bool, Symbol or String.  Show the axis. `true`, `false`, `:show`, `:hide`, `:yes`, `:no`, `:x`, `:y`, `:z`, `:xy`, ..., `:all`, `:off`",
 :widen                       => "Bool. Widen the axis limits by a small factor to avoid cut-off markers and lines at the borders. Defaults to `true`.",
 :draw_arrow                  => "Bool. Draw arrow at the end of the axis.",
@@ -408,6 +408,12 @@ const _subplot_defaults = KW(
    :legendtitlefontrotation    => 0.0,
    :legendtitlefontcolor       => :match,
    :annotations                => [],                # annotation tuples... list of (x,y,annotation)
+    :annotationfontfamily       => :match,
+    :annotationfontsize         => 14,
+    :annotationhalign           => :hcenter,
+    :annotationvalign           => :vcenter,
+    :annotationrotation         => 0.0,
+    :annotationcolor            => :match,
    :projection                 => :none,             # can also be :polar or :3d
    :aspect_ratio               => :auto,             # choose from :none or :equal
    :margin                     => 1mm,
@@ -519,6 +525,7 @@ const _initial_axis_defaults = deepcopy(_axis_defaults)
 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])

@@ -1359,6 +1366,8 @@ const _match_map = KW(
    :plot_titlefontcolor      => :foreground_color,
    :tickfontcolor            => :foreground_color_text,
    :guidefontcolor           => :foreground_color_guide,
+    :annotationfontfamily     => :fontfamily_subplot,
+    :annotationcolor          => :foreground_color_subplot,
 )

 # these can match values from the parent container (axis --> subplot --> plot)
@@ -533,13 +533,20 @@ function axis_limits(sp, letter, should_widen = default_should_widen(sp[Symbol(l
    has_user_lims = (isa(lims, Tuple) || isa(lims, AVec)) && length(lims) == 2
    if has_user_lims
        lmin, lmax = lims
-        if lmin != :auto && isfinite(lmin)
+        if lmin == :auto
+        elseif isfinite(lmin)
            amin = lmin
        end
-        if lmax != :auto && isfinite(lmax)
+        if lmax == :auto
+        elseif isfinite(lmax)
            amax = lmax
        end
    end
+    if lims == :symmetric
+        aval = max(abs(amin), abs(amax))
+        amin = -aval
+        amax = aval
+    end
    if amax <= amin && isfinite(amin)
        amax = amin + 1.0
    end
@@ -697,17 +704,19 @@ function axis_drawing_info(sp, letter)
        if !(ax[:ticks] in (:none, nothing, false))
            f = RecipesPipeline.scale_func(oax[:scale])
            invf = RecipesPipeline.inverse_scale_func(oax[:scale])
-            tick_start, tick_stop = if sp[:framestyle] == :origin
-                t = invf(f(0) + 0.012 * (f(oamax) - f(oamin)))
-                (-t, t)
-            else
-                ticks_in = ax[:tick_direction] == :out ? -1 : 1
-                t = invf(f(oa1) + 0.012 * (f(oa2) - f(oa1)) * ticks_in)
-                (oa1, t)
+            if ax[:tick_direction] !== :none
+                tick_start, tick_stop = if sp[:framestyle] == :origin
+                    t = invf(f(0) + 0.012 * (f(oamax) - f(oamin)))
+                    (-t, t)
+                else
+                    ticks_in = ax[:tick_direction] == :out ? -1 : 1
+                    t = invf(f(oa1) + 0.012 * (f(oa2) - f(oa1)) * ticks_in)
+                    (oa1, t)
+                end
            end

            for tick in ticks[1]
-                if ax[:showaxis]
+                if ax[:showaxis] && ax[:tick_direction] !== :none
                    push!(
                        tick_segments,
                        reverse_if((tick, tick_start), isy),
@@ -834,18 +843,20 @@ function axis_drawing_info_3d(sp, letter)
        if !(ax[:ticks] in (:none, nothing, false))
            f = RecipesPipeline.scale_func(nax[:scale])
            invf = RecipesPipeline.inverse_scale_func(nax[:scale])
-            tick_start, tick_stop = if sp[:framestyle] == :origin
-                t = invf(f(0) + 0.012 * (f(namax) - f(namin)))
-                (-t, t)
-            else
-                ticks_in = ax[:tick_direction] == :out ? -1 : 1
-                t = invf(f(na0) + 0.012 * (f(na1) - f(na0)) * ticks_in)
-                (na0, t)
+            if ax[:tick_direction] !== :none
+                tick_start, tick_stop = if sp[:framestyle] == :origin
+                    t = invf(f(0) + 0.012 * (f(namax) - f(namin)))
+                    (-t, t)
+                else
+                    ticks_in = ax[:tick_direction] == :out ? -1 : 1
+                    t = invf(f(na0) + 0.012 * (f(na1) - f(na0)) * ticks_in)
+                    (na0, t)
+                end
            end

            ga0, ga1 = sp[:framestyle] in (:origin, :zerolines) ? (namin, namax) : (na0, na1)
            for tick in ticks[1]
-                if ax[:showaxis]
+                if ax[:showaxis] && ax[:tick_direction] !== :none
                    push!(
                        tick_segments,
                        sort_3d_axes(tick, tick_start, fa0, letter),
@@ -875,7 +886,7 @@ function axis_drawing_info_3d(sp, letter)
                    (na0, t)
                end
                for tick in minor_ticks
-                    if ax[:showaxis]
+                    if ax[:showaxis] && ax[:tick_direction] !== :none
                        push!(
                            tick_segments,
                            sort_3d_axes(tick, tick_start, fa0, letter),
@@ -401,7 +401,7 @@ end

 function gr_nans_to_infs!(z)
    for (i,zi) in enumerate(z)
-        if zi == NaN
+        if isnan(zi)
            z[i] = Inf
        end
    end
@@ -1510,8 +1510,10 @@ function gr_label_axis(sp, letter, viewport_plotarea)
        GR.savestate()
        gr_set_font(guidefont(axis), sp)
        guide_position = axis[:guide_position]
+        angle = float(axis[:guidefontrotation])  # github.com/JuliaPlots/Plots.jl/issues/3089
        if letter === :y
-            GR.setcharup(-1, 0)
+            angle += 180.  # default angle = 0. should yield GR.setcharup(-1, 0) i.e. 180°
+            GR.setcharup(cosd(angle), sind(angle))
            ypos = gr_view_yposition(viewport_plotarea, position(axis[:guidefontvalign]))
            yalign = alignment(axis[:guidefontvalign])
            if guide_position === :right || (guide_position == :auto && mirror)
@@ -1522,6 +1524,8 @@ function gr_label_axis(sp, letter, viewport_plotarea)
                xpos = viewport_plotarea[1] - 0.03 - !mirror * gr_axis_width(sp, axis)
            end
        else
+            angle += 90.  # default angle = 0. should yield GR.setcharup(0, 1) i.e. 90°
+            GR.setcharup(cosd(angle), sind(angle))
            xpos = gr_view_xposition(viewport_plotarea, position(axis[:guidefonthalign]))
            xalign = alignment(axis[:guidefonthalign])
            if guide_position === :top || (guide_position == :auto && mirror)
@@ -363,37 +363,37 @@ function _inspectdr_setupsubplot(sp::Subplot{InspectDRBackend})
        a.title = sp[:title]
        a.xlabel = xaxis[:guide]; a.ylabels = [yaxis[:guide]]

-    l = plot.layout
-        #IMPORTANT: Don't forget to actually register changes
-        #(TODO: need to find a better way to set layout properties)
-        l[:frame_canvas].fillcolor = _inspectdr_mapcolor(sp[:background_color_subplot])
-            l[:frame_canvas] = l[:frame_canvas] #register changes
-        l[:frame_data].fillcolor = _inspectdr_mapcolor(sp[:background_color_inside])
-            l[:frame_data] = l[:frame_data] #register changes
-
-        l[:frame_data].line.color = _inspectdr_mapcolor(xaxis[:foreground_color_axis])
-            l[:frame_data] = l[:frame_data] #register changes
-        l[:font_title] = InspectDR.Font(sp[:titlefontfamily],
+    #Modify base layout of new object:
+    l = plot.layout.defaults = deepcopy(InspectDR.defaults.plotlayout)
+        #IMPORTANT: Must deepcopy to ensure we don't change layouts of other plots.
+        #Works because plot uses defaults (not user-overwritten `layout.values`)
+        l.frame_canvas.fillcolor = _inspectdr_mapcolor(sp[:background_color_subplot])
+        l.frame_data.fillcolor = _inspectdr_mapcolor(sp[:background_color_inside])
+        l.frame_data.line.color = _inspectdr_mapcolor(xaxis[:foreground_color_axis])
+        l.font_title = InspectDR.Font(sp[:titlefontfamily],
            _inspectdr_mapptsize(sp[:titlefontsize]),
            color = _inspectdr_mapcolor(sp[:titlefontcolor])
        )
        #Cannot independently control fonts of axes with InspectDR:
-        l[:font_axislabel] = InspectDR.Font(xaxis[:guidefontfamily],
+        l.font_axislabel = InspectDR.Font(xaxis[:guidefontfamily],
            _inspectdr_mapptsize(xaxis[:guidefontsize]),
            color = _inspectdr_mapcolor(xaxis[:guidefontcolor])
        )
-        l[:font_ticklabel] = InspectDR.Font(xaxis[:tickfontfamily],
+        l.font_ticklabel = InspectDR.Font(xaxis[:tickfontfamily],
            _inspectdr_mapptsize(xaxis[:tickfontsize]),
            color = _inspectdr_mapcolor(xaxis[:tickfontcolor])
        )
-        l[:enable_legend] = (sp[:legend] != :none)
-        #l[:halloc_legend] = 150 #TODO: compute???
-        l[:font_legend] = InspectDR.Font(sp[:legendfontfamily],
+        l.enable_legend = (sp[:legend] != :none)
+        #l.halloc_legend = 150 #TODO: compute???
+        l.font_legend = InspectDR.Font(sp[:legendfontfamily],
            _inspectdr_mapptsize(sp[:legendfontsize]),
            color = _inspectdr_mapcolor(sp[:legendfontcolor])
        )
-        l[:frame_legend].fillcolor = _inspectdr_mapcolor(sp[:background_color_legend])
-            l[:frame_legend] = l[:frame_legend] #register changes
+        l.frame_legend.fillcolor = _inspectdr_mapcolor(sp[:background_color_legend])
+
+        #_round!() ensures values use integer spacings (looks better on screen):
+        InspectDR._round!(InspectDR.autofit2font!(l, legend_width=10.0)) #10 "em"s wide
+    return
 end

 # called just before updating layout bounding boxes... in case you need to prep
@@ -82,6 +82,7 @@ function surface_to_vecs(x::AVec, y::AVec, s::Union{AMat,Surface})
    end
    return xn, yn, zn
 end
+surface_to_vecs(x::AVec, y::AVec, z::AVec) = x, y, z

 function Base.push!(pgfx_plot::PGFPlotsXPlot, item)
    push!(pgfx_plot.the_plot, item)
@@ -131,9 +132,6 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
            axis_height = sp_height - (tpad + bpad)
            axis_width = sp_width - (rpad + lpad)

-            cstr = plot_color(sp[:background_color_legend])
-            a = alpha(cstr)
-            fg_alpha = alpha(plot_color(sp[:foreground_color_legend]))
            title_cstr = plot_color(sp[:titlefontcolor])
            title_a = alpha(title_cstr)
            title_loc = sp[:titlelocation]
@@ -142,7 +140,6 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
            axis_opt = PGFPlotsX.Options(
                "point meta max" => get_clims(sp)[2],
                "point meta min" => get_clims(sp)[1],
-                "legend cell align" => "left",
                "title" => sp[:title],
                "title style" => PGFPlotsX.Options(
                        pgfx_get_title_pos(title_loc)...,
@@ -154,22 +151,7 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
                    "draw opacity" => title_a,
                    "rotate" => sp[:titlefontrotation],
                ),
-                "legend style" => PGFPlotsX.Options(
-                    pgfx_linestyle(
-                        pgfx_thickness_scaling(sp),
-                        sp[:foreground_color_legend],
-                        fg_alpha,
-                        "solid",
-                    ) => nothing,
-                    "fill" => cstr,
-                    "fill opacity" => a,
-                    "text opacity" => alpha(plot_color(sp[:legendfontcolor])),
-                    "font" => pgfx_font(
-                        sp[:legendfontsize],
-                        pgfx_thickness_scaling(sp),
-                    ),
-                    "text" => plot_color(sp[:legendfontcolor]),
-                ),
+                "legend style" => pgfx_get_legend_style(sp),
                "axis background/.style" => PGFPlotsX.Options(
                    "fill" => bgc_inside,
                    "opacity" => bgc_inside_a,
@@ -183,8 +165,6 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
            nothing
            sp_height > 0 * mm ? push!(axis_opt, "height" => string(axis_height)) :
            nothing
-            # legend position
-            push!(axis_opt["legend style"], pgfx_get_legend_pos(sp[:legend])...)
            for letter in (:x, :y, :z)
                if letter != :z || RecipesPipeline.is3d(sp)
                    pgfx_axis!(axis_opt, sp, letter)
@@ -225,16 +205,22 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
            @label colorbar_end

            if hascolorbar(sp)
+                cticks = get_colorbar_ticks(sp)[2]
                colorbar_style = PGFPlotsX.Options(
                    "title" => sp[:colorbar_title],
-                    "xticklabel style" => pgfx_get_ticklabel_style(sp, sp[:xaxis]),
-                    "yticklabel style" => pgfx_get_ticklabel_style(sp, sp[:yaxis]),
                )
                if sp[:colorbar] === :top
                    push!(colorbar_style,
                        "at" => string((0.5, 1.05)),
                        "anchor" => "south",
+                        "xtick" => string("{", join(cticks, ","), "}"),
                        "xticklabel pos" => "upper",
+                        "xticklabel style" => pgfx_get_colorbar_ticklabel_style(sp),
+                    )
+                else
+                    push!(colorbar_style,
+                        "ytick" => string("{", join(cticks, ","), "}"),
+                        "yticklabel style" => pgfx_get_colorbar_ticklabel_style(sp),
                    )
                end
                push!(
@@ -242,6 +228,8 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
                    string("colorbar", pgfx_get_colorbar_pos(sp[:colorbar])) => nothing,
                    "colorbar style" => colorbar_style,
                )
+            else
+                push!(axis_opt, "colorbar" => "false")
            end
            if RecipesPipeline.is3d(sp)
                azim, elev = sp[:camera]
@@ -464,7 +452,7 @@ function pgfx_add_series!(::Val{:path}, axis, series_opt, series, series_func, o
                ),
            )
        end
-        pgfx_add_legend!(axis, series, opt, i)
+        pgfx_add_legend!(axis, series, opt, k)
    end # for segments
    # get that last marker
    if !isnothing(opt[:y]) && !any(isnan, opt[:y]) && opt[:markershape] isa AVec
@@ -492,13 +480,14 @@ function pgfx_add_series!(::Val{:scatter3d}, axis, series_opt, series, series_fu
 end

 function pgfx_add_series!(::Val{:surface}, axis, series_opt, series, series_func, opt)
+    alpha = get_fillalpha(series)
    push!(
        series_opt,
        "surf" => nothing,
-        "mesh/rows" => length(opt[:x]),
-        "mesh/cols" => length(opt[:y]),
+        "mesh/rows" => length(unique(opt[:x])), # unique if its all vectors
+        "mesh/cols" => length(unique(opt[:y])),
        "z buffer" => "sort",
-        "opacity" => get_fillalpha(series),
+        "opacity" => alpha === nothing ? 1.0 : alpha,
    )
    pgfx_add_series!(axis, series_opt, series, series_func, opt)
 end
@@ -791,6 +780,31 @@ function pgfx_get_legend_pos(v::Tuple{S,Symbol}) where S <: Real
    return ("at"=>"$(string(legend_pos_from_angle(v[1],rect...)))", "anchor"=>anchor)
 end

+function pgfx_get_legend_style(sp)
+    cstr = plot_color(sp[:background_color_legend])
+    a = alpha(cstr)
+    fg_alpha = alpha(plot_color(sp[:foreground_color_legend]))
+    legfont = legendfont(sp)
+    PGFPlotsX.Options(
+        pgfx_linestyle(
+            pgfx_thickness_scaling(sp),
+            sp[:foreground_color_legend],
+            fg_alpha,
+            "solid",
+        ) => nothing,
+        "fill" => cstr,
+        "fill opacity" => a,
+        "text opacity" => alpha(plot_color(sp[:legendfontcolor])),
+        "font" => pgfx_font(
+            sp[:legendfontsize],
+            pgfx_thickness_scaling(sp),
+        ),
+        "text" => plot_color(sp[:legendfontcolor]),
+        "cells" => PGFPlotsX.Options("anchor" => get((left = "west", right = "east", hcenter = "center"), legfont.halign, "west")),
+        pgfx_get_legend_pos(sp[:legend])...,
+    )
+end
+
 pgfx_get_colorbar_pos(s) =
    get((left = " left", bottom = " horizontal", top = " horizontal"), s, "")
 pgfx_get_colorbar_pos(b::Bool) = ""
@@ -809,15 +823,23 @@ function pgfx_get_ticklabel_style(sp, axis)
    return PGFPlotsX.Options(
        "font" => pgfx_font(
            axis[:tickfontsize], pgfx_thickness_scaling(sp)
-        ),
-        "color" => cstr,
+        ), "color" => cstr,
        "draw opacity" => alpha(cstr),
        "rotate" => axis[:tickfontrotation],
    )
 end

+function pgfx_get_colorbar_ticklabel_style(sp)
+    cstr = plot_color(sp[:colorbar_tickfontcolor])
+    return PGFPlotsX.Options(
+        "font" => pgfx_font(
+            sp[:colorbar_tickfontsize], pgfx_thickness_scaling(sp)
+        ), "color" => cstr,
+        "draw opacity" => alpha(cstr),
+        "rotate" => sp[:colorbar_tickfontrotation],
+    )
+end
 ## --------------------------------------------------------------------------------------
-# Generates a colormap for pgfplots based on a ColorGradient
 pgfx_arrow(::Nothing) = "every arrow/.append style={-}"
 function pgfx_arrow(arr::Arrow, side = arr.side)
    components = String[]
@@ -848,6 +870,7 @@ function pgfx_filllegend!(series_opt, opt)
              }""")
 end

+# Generates a colormap for pgfplots based on a ColorGradient
 pgfx_colormap(cl::PlotUtils.AbstractColorList) = pgfx_colormap(color_list(cl))
 function pgfx_colormap(v::Vector{<:Colorant})
    join(map(v) do c
@@ -1261,11 +1284,18 @@ function pgfx_axis!(opt::PGFPlotsX.Options, sp::Subplot, letter)
        else
            push!(opt, string(letter, "ticklabels") => "{}")
        end
-        push!(
-            opt,
-            string(letter, "tick align") =>
-                (axis[:tick_direction] == :out ? "outside" : "inside"),
-        )
+        if axis[:tick_direction] === :none
+            push!(
+                opt,
+                string(letter, "tick style") => "draw=none",
+            )
+        else
+            push!(
+                opt,
+                string(letter, "tick align") =>
+                    (axis[:tick_direction] == :out ? "outside" : "inside"),
+            )
+        end
        push!(
            opt, string(letter, "ticklabel style") => pgfx_get_ticklabel_style(sp, axis)
        )
@@ -7,7 +7,7 @@ function _plotly_framestyle(style::Symbol)
        return style
    else
        default_style = get((semi = :box, origin = :zerolines), style, :axes)
-        @warn("Framestyle :$style is not supported by Plotly and PlotlyJS. :$default_style was cosen instead.")
+        @warn("Framestyle :$style is not supported by Plotly and PlotlyJS. :$default_style was chosen instead.")
        default_style
    end
 end
@@ -143,7 +143,8 @@ function plotly_axis(axis, sp, anchor = nothing, domain = nothing)
        :zerolinecolor => rgba_string(axis[:foreground_color_axis]),
        :showline   => framestyle in (:box, :axes) && axis[:showaxis],
        :linecolor  => rgba_string(plot_color(axis[:foreground_color_axis])),
-        :ticks      => axis[:tick_direction] == :out ? "outside" : "inside",
+        :ticks      => axis[:tick_direction] === :out ? "outside" : 
+                       axis[:tick_direction] === :in ? "inside" : "",
        :mirror     => framestyle == :box,
        :showticklabels => axis[:showaxis],
    )
@@ -662,7 +663,7 @@ function plotly_series(plt::Plot, series::Series)
 end

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

    # TODO: create a plotattributes_out for each polygon
@@ -681,7 +682,7 @@ function plotly_series_shapes(plt::Plot, series::Series, clims)
        for (letter, data) in zip((:x, :y), shape_data(series, 100))
    )

-    for segment in segments
+    for (k, segment) in enumerate(segments)
        i, rng = segment.attr_index, segment.range
        length(rng) < 2 && continue

@@ -701,10 +702,10 @@ function plotly_series_shapes(plt::Plot, series::Series, clims)
                :dash => string(get_linestyle(series, i)),
            )
        end
-        plotattributes_out[:showlegend] = i==1 ? should_add_to_legend(series) : false
+        plotattributes_out[:showlegend] = k==1 ? should_add_to_legend(series) : false
        plotly_polar!(plotattributes_out, series)
        plotly_hover!(plotattributes_out, _cycle(series[:hover], i))
-        plotattributes_outs[i] = plotattributes_out
+        plotattributes_outs[k] = plotattributes_out
    end
    if series[:fill_z] !== nothing
        push!(plotattributes_outs, plotly_colorbar_hack(series, plotattributes_base, :fill))
@@ -952,8 +953,7 @@ function plotly_html_body(plt, style = nothing)
        <div id=\"$(uuid)\" style=\"$(style)\"></div>
        <script>
        $(requirejs_prefix)
-        PLOT = document.getElementById('$(uuid)');
-        Plotly.plot(PLOT, $(plotly_series_json(plt)), $(plotly_layout_json(plt)));
+        $(js_body(plt, uuid))
        $(requirejs_suffix)
        </script>
    """
@@ -962,7 +962,7 @@ end

 function js_body(plt::Plot, uuid)
    js = """
-        PLOT = document.getElementById('$(uuid)');
+        var PLOT = document.getElementById('$(uuid)');
        Plotly.plot(PLOT, $(plotly_series_json(plt)), $(plotly_layout_json(plt)));
    """
 end
@@ -1022,7 +1022,7 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
            cbar_axis."set_tick_params"(
                direction = axis[:tick_direction] == :out ? "out" : "in",
                width=py_thickness_scale(plt, intensity),
-                length= 5 * py_thickness_scale(plt, intensity)
+                length = axis[:tick_direction] == :none ? 0 : 5 * py_thickness_scale(plt, intensity)
            )


@@ -1063,8 +1063,14 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
                    ax.spines["left"]."set_position"("zero")
                end
            elseif sp[:framestyle] in (:grid, :none, :zerolines)
-                for (loc, spine) in ax.spines
-                    spine."set_visible"(false)
+                if PyPlot.version >= v"3.4.1" # that is one where it worked, the API change may have some other value
+                    for spine in ax.spines
+                        ax.spines[string(spine)]."set_visible"(false)
+                    end
+                else
+                    for (loc, spine) in ax.spines
+                        spine."set_visible"(false)
+                    end
                end
                if sp[:framestyle] == :zerolines
                    ax."axhline"(y = 0, color = py_color(sp[:xaxis][:foreground_color_axis]), lw = py_thickness_scale(plt, 0.75))
@@ -1137,7 +1143,7 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
            pyaxis."set_tick_params"(
                direction = axis[:tick_direction] == :out ? "out" : "in",
                width=py_thickness_scale(plt, intensity),
-                length= 5 * py_thickness_scale(plt, intensity)
+                length = axis[:tick_direction] == :none ? 0 : 5 * py_thickness_scale(plt, intensity)
                                     )

            getproperty(ax, Symbol("set_", letter, "label"))(axis[:guide])
@@ -1176,7 +1182,8 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
                pyaxis."set_tick_params"(
                    which = "minor",
                    direction = axis[:tick_direction] == :out ? "out" : "in",
-                    width=py_thickness_scale(plt, intensity))
+                    length = axis[:tick_direction] == :none ? 0 : py_thickness_scale(plt, intensity),
+                )
            end

            if axis[:minorgrid]
@@ -1186,7 +1193,8 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
                pyaxis."set_tick_params"(
                    which = "minor",
                    direction = axis[:tick_direction] == :out ? "out" : "in",
-                    width=py_thickness_scale(plt, intensity))
+                    length = axis[:tick_direction] == :none ? 0 : py_thickness_scale(plt, intensity)
+                )

                pyaxis."grid"(true,
                    which = "minor",
@@ -9,9 +9,9 @@ compute_angle(v::P2) = (angle = atan(v[2], v[1]); angle < 0 ? 2π - angle : angl

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

-struct Shape
-    x::Vector{Float64}
-    y::Vector{Float64}
+struct Shape{X<:Number, Y<:Number}
+    x::Vector{X}
+    y::Vector{Y}
    # function Shape(x::AVec, y::AVec)
    #     # if x[1] != x[end] || y[1] != y[end]
    #     #     new(vcat(x, x[1]), vcat(y, y[1]))
@@ -43,7 +43,7 @@ function coords(shape::Shape)
 end

 #coords(shapes::AVec{Shape}) = unzip(map(coords, shapes))
-function coords(shapes::AVec{Shape})
+function coords(shapes::AVec{<:Shape})
    c = map(coords, shapes)
    x = [q[1] for q in c]
    y = [q[2] for q in c]
@@ -52,7 +52,7 @@ end

 "get an array of tuples of points on a circle with radius `r`"
 function partialcircle(start_θ, end_θ, n = 20, r=1)
-    Tuple{Float64,Float64}[(r*cos(u),r*sin(u)) for u in range(start_θ, stop=end_θ, length=n)]
+    [(r*cos(u), r*sin(u)) for u in range(start_θ, stop=end_θ, length=n)]
 end

 "interleave 2 vectors into each other (like a zipper's teeth)"
@@ -205,9 +205,12 @@ function rotate!(shape::Shape, Θ::Real, c = center(shape))
 end

 "rotate an object in space"
-function rotate(shape::Shape, Θ::Real, c = center(shape))
-    shapecopy = deepcopy(shape)
-    rotate!(shapecopy, Θ, c)
+function rotate(shape::Shape, θ::Real, c = center(shape))
+    x, y = coords(shape)
+    cx, cy = c
+    x_new = rotate_x.(x, y, θ, cx, cy)
+    y_new = rotate_y.(x, y, θ, cx, cy)
+    Shape(x_new, y_new)
 end

 # -----------------------------------------------------------------------
@@ -285,7 +288,7 @@ function font(args...;kw...)

  for symbol in keys(kw)
    if symbol == :family
-      family = kw[:family]
+      family = string(kw[:family])
    elseif symbol == :pointsize
      pointsize = kw[:pointsize]
    elseif symbol == :halign
@@ -572,11 +575,21 @@ annotations(sa::SeriesAnnotations) = sa

 # 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 = font())
+function process_annotation(sp::Subplot, xs, ys, labs, font = nothing)
    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
@@ -585,14 +598,24 @@ function process_annotation(sp::Subplot, xs, ys, labs, font = font())
            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...) : text(lab, font)))
+            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 = font())
+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)
@@ -600,7 +623,7 @@ function process_annotation(sp::Subplot, positions::Union{AVec{Symbol},Symbol},
            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...) : text(lab, font)))
+            push!(anns, (pos, isa(lab, PlotText) ? lab : isa(lab, Tuple) ? text(lab[1], font, lab[2:end]...) : text(lab, font)))
        end
    end
    anns
@@ -7,7 +7,7 @@ mutable struct PlotExample
    exprs::Vector{Expr}
 end

-# the _examples we'll run for each
+# the _examples we'll run for each backend
 const _examples = PlotExample[
    PlotExample( # 1
        "Lines",
@@ -241,14 +241,15 @@ const _examples = PlotExample[
                        m -> m in Plots.supported_markers(),
                        Plots._shape_keys,
                    )
-                    markers = reshape(markers, 1, length(markers))
+                    markers = permutedims(markers)
                    n = length(markers)
                    x = range(0, stop = 10, length = n + 2)[2:(end - 1)]
                    y = repeat(reshape(reverse(x), 1, :), n, 1)
                    scatter(
                        x,
                        y,
-                        m = (8, :auto),
+                        m = markers,
+                        markersize = 8,
                        lab = map(string, markers),
                        bg = :linen,
                        xlim = (0, 10),
@@ -1170,7 +1171,7 @@ _backend_skips = Dict(
    :gr => [25, 30, 47],
    :pyplot => [2, 25, 30, 31, 47, 49],
    :plotlyjs => [2, 21, 24, 25, 30, 31, 49, 51],
-    :plotly => [2, 21, 24, 25, 30, 31, 49, 51],
+    :plotly => [2, 21, 24, 25, 30, 31, 49, 50, 51],
    :pgfplotsx => [
        2, # animation
        6, # images
@@ -1428,9 +1428,9 @@ end
    coords(shape)
 end

-@recipe function f(shapes::AVec{Shape})
+@recipe function f(shapes::AVec{<:Shape})
    seriestype --> :shape
-    # For backwards compatibility, column vectors of segmenting attributes are 
+    # For backwards compatibility, column vectors of segmenting attributes are
    # interpreted as having one element per shape
    for attr in union(_segmenting_array_attributes, _segmenting_vector_attributes)
        v = get(plotattributes, attr, nothing)
@@ -1443,7 +1443,7 @@ end
    coords(shapes)
 end

-@recipe function f(shapes::AMat{Shape})
+@recipe function f(shapes::AMat{<:Shape})
    seriestype --> :shape
    for j in axes(shapes, 2)
        @series coords(vec(shapes[:, j]))
@@ -57,7 +57,7 @@ struct SeriesSegment
    # indexes of this segement in series data vectors
    range::UnitRange
    # index into vector-valued attributes corresponding to this segment
-    attr_index::Int 
+    attr_index::Int
 end

 # -----------------------------------------------------
@@ -82,20 +82,26 @@ function series_segments(series::Series, seriestype::Symbol = :path)
    args = RecipesPipeline.is3d(series) ? (x, y, z) : (x, y)
    nan_segments = collect(iter_segments(args...))

-    result = if has_attribute_segments(series)
+    segments = if has_attribute_segments(series)
        Iterators.flatten(map(nan_segments) do r
            if seriestype in (:scatter, :scatter3d)
                (SeriesSegment(i:i, i) for i in r)
            else
                (SeriesSegment(i:i+1, i) for i in first(r):last(r)-1)
-            end 
+            end
        end)
    else
        (SeriesSegment(r, 1) for r in nan_segments)
-    end 
+    end

-    seg_range = UnitRange(minimum(first(seg.range) for seg in result),
-                                maximum(last(seg.range) for seg in result))
+    warn_on_attr_dim_mismatch(series, x, y, z, segments)
+    return segments
+end
+
+function warn_on_attr_dim_mismatch(series, x, y, z, segments)
+    isempty(segments) && return
+    seg_range = UnitRange(minimum(first(seg.range) for seg in segments),
+                          maximum(last(seg.range) for seg in segments))
    for attr in _segmenting_vector_attributes
        v = get(series, attr, nothing)
        if v isa AVec && eachindex(v) != seg_range
@@ -103,7 +109,7 @@ function series_segments(series::Series, seriestype::Symbol = :path)
            if any(v -> !isnothing(v) && any(isnan, v), (x,y,z))
                @info """Data contains NaNs or missing values, and indices of `$attr` vector do not match data indices.
                    If you intend elements of `$attr` to apply to individual NaN-separated segements in the data,
-                    pass each segment in a separate vector instead, and use a row vector for `$attr`. Legend entries 
+                    pass each segment in a separate vector instead, and use a row vector for `$attr`. Legend entries
                    may be suppressed by passing an empty label.
                    For example,
                        plot([1:2,1:3], [[4,5],[3,4,5]], label=["y" ""], $attr=[1 2])
@@ -111,8 +117,6 @@ function series_segments(series::Series, seriestype::Symbol = :path)
            end
        end
    end
-
-    return result
 end

 # helpers to figure out if there are NaN values in a list of array types
@@ -266,7 +270,7 @@ function heatmap_edges(x::AVec, xscale::Symbol, y::AVec, yscale::Symbol, z_size:
                or `size(z) == (length(y)+1, length(x)+1))` (x & y define edges).""")
    end
    x, y = heatmap_edges(x, xscale, isedges),
-           heatmap_edges(y, yscale, isedges, ispolar) # special handle for `r` in polar plots 
+           heatmap_edges(y, yscale, isedges, ispolar) # special handle for `r` in polar plots
    return x, y
 end

@@ -935,67 +939,67 @@ ignorenan_extrema(plt::Plot) = (xmin(plt), xmax(plt))
 # ---------------------------------------------------------------
 # get fonts from objects:

-plottitlefont(p::Plot) = font(
-    p[:plot_titlefontfamily],
-    p[:plot_titlefontsize],
-    p[:plot_titlefontvalign],
-    p[:plot_titlefonthalign],
-    p[:plot_titlefontrotation],
-    p[:plot_titlefontcolor],
+plottitlefont(p::Plot) = font(;
+    family = p[:plot_titlefontfamily],
+    pointsize = p[:plot_titlefontsize],
+    valign = p[:plot_titlefontvalign],
+    halign = p[:plot_titlefonthalign],
+    rotation = p[:plot_titlefontrotation],
+    color = p[:plot_titlefontcolor],
 )

-colorbartitlefont(sp::Subplot) = font(
-    sp[:colorbar_titlefontfamily],
-    sp[:colorbar_titlefontsize],
-    sp[:colorbar_titlefontvalign],
-    sp[:colorbar_titlefonthalign],
-    sp[:colorbar_titlefontrotation],
-    sp[:colorbar_titlefontcolor],
+colorbartitlefont(sp::Subplot) = font(;
+    family = sp[:colorbar_titlefontfamily],
+    pointsize = sp[:colorbar_titlefontsize],
+    valign = sp[:colorbar_titlefontvalign],
+    halign = sp[:colorbar_titlefonthalign],
+    rotation = sp[:colorbar_titlefontrotation],
+    color = sp[:colorbar_titlefontcolor],
 )

-titlefont(sp::Subplot) = font(
-    sp[:titlefontfamily],
-    sp[:titlefontsize],
-    sp[:titlefontvalign],
-    sp[:titlefonthalign],
-    sp[:titlefontrotation],
-    sp[:titlefontcolor],
+titlefont(sp::Subplot) = font(;
+    family = sp[:titlefontfamily],
+    pointsize = sp[:titlefontsize],
+    valign = sp[:titlefontvalign],
+    halign = sp[:titlefonthalign],
+    rotation = sp[:titlefontrotation],
+    color = sp[:titlefontcolor],
 )

-legendfont(sp::Subplot) = font(
-    sp[:legendfontfamily],
-    sp[:legendfontsize],
-    sp[:legendfontvalign],
-    sp[:legendfonthalign],
-    sp[:legendfontrotation],
-    sp[:legendfontcolor],
+legendfont(sp::Subplot) = font(;
+    family = sp[:legendfontfamily],
+    pointsize = sp[:legendfontsize],
+    valign = sp[:legendfontvalign],
+    halign = sp[:legendfonthalign],
+    rotation = sp[:legendfontrotation],
+    color = sp[:legendfontcolor],
 )

-legendtitlefont(sp::Subplot) = font(
-    sp[:legendtitlefontfamily],
-    sp[:legendtitlefontsize],
-    sp[:legendtitlefontvalign],
-    sp[:legendtitlefonthalign],
-    sp[:legendtitlefontrotation],
-    sp[:legendtitlefontcolor],
+legendtitlefont(sp::Subplot) = font(;
+    family = sp[:legendtitlefontfamily],
+    pointsize = sp[:legendtitlefontsize],
+    valign = sp[:legendtitlefontvalign],
+    halign = sp[:legendtitlefonthalign],
+    rotation = sp[:legendtitlefontrotation],
+    color = sp[:legendtitlefontcolor],
 )

-tickfont(ax::Axis) = font(
-    ax[:tickfontfamily],
-    ax[:tickfontsize],
-    ax[:tickfontvalign],
-    ax[:tickfonthalign],
-    ax[:tickfontrotation],
-    ax[:tickfontcolor],
+tickfont(ax::Axis) = font(;
+    family = ax[:tickfontfamily],
+    pointsize = ax[:tickfontsize],
+    valign = ax[:tickfontvalign],
+    halign = ax[:tickfonthalign],
+    rotation = ax[:tickfontrotation],
+    color = ax[:tickfontcolor],
 )

-guidefont(ax::Axis) = font(
-    ax[:guidefontfamily],
-    ax[:guidefontsize],
-    ax[:guidefontvalign],
-    ax[:guidefonthalign],
-    ax[:guidefontrotation],
-    ax[:guidefontcolor],
+guidefont(ax::Axis) = font(;
+    family = ax[:guidefontfamily],
+    pointsize = ax[:guidefontsize],
+    valign = ax[:guidefontvalign],
+    halign = ax[:guidefonthalign],
+    rotation = ax[:guidefontrotation],
+    color = ax[:guidefontcolor],
 )

 # ---------------------------------------------------------------
@@ -1,3 +1,4 @@
+using Plots: guidefont
 import ImageMagick
 using VisualRegressionTests
 using Plots
@@ -172,6 +173,8 @@ end
    @testset "Plot" begin
        plots = [histogram([1, 0, 0, 0, 0, 0]),
                 plot([missing]),
+                 plot([missing, missing]),
+                 plot(fill(missing, 10)),
                 plot([missing; 1:4]),
                 plot([fill(missing, 10); 1:4]),
                 plot([1 1; 1 missing]),
@@ -31,3 +31,8 @@ end
    @test xticks(p) == yticks(p) == zticks(p) == [ticks1, ticks2]
    @test xticks(p[1]) == yticks(p[1]) == zticks(p[1]) == ticks1
 end
+
+@testset "Axis limits" begin
+    pl = plot(1:5, xlims=:symmetric, widen = false)
+    @test Plots.xlims(pl) == (-5, 5)
+end
@@ -1,6 +1,12 @@
 using Plots, Test

@testset "Shapes" begin
+    @testset "Type" begin
+        square = Shape([(0,0.0),(1,0.0),(1,1.0),(0,1.0)])
+        @test isa(square, Shape{Int64, Float64})
+        @test coords(square) isa Tuple{Vector{S}, Vector{T}} where {T,S}
+    end
+
    @testset "Copy" begin
        square = Shape([(0,0),(1,0),(1,1),(0,1)])
        square2 = Shape(square)
@@ -42,6 +48,16 @@ using Plots, Test
        @test square2.x ≈ coords[1,:]
        @test square2.y ≈ coords[2,:]
    end
+
+    @testset "Plot" begin
+        ang = range(0, 2π, length = 60)
+        ellipse(x, y, w, h) = Shape(w*sin.(ang).+x, h*cos.(ang).+y)
+        myshapes = [ellipse(x,rand(),rand(),rand()) for x = 1:4]
+        @test coords(myshapes) isa Tuple{Vector{Vector{S}}, Vector{Vector{T}}} where {T,S}
+        local p
+        @test_nowarn p = plot(myshapes)
+        @test p[1][1][:seriestype] == :shape
+    end
 end

@testset "Brush" begin
@@ -1,10 +1,12 @@
 using Plots, Test

-const PLOTS_DEFAULTS = Dict(:theme => :wong2)
+const PLOTS_DEFAULTS = Dict(:theme => :wong2, :fontfamily => :palantino)
 Plots.__init__()

@testset "Loading theme" begin
-    @test plot(1:5)[1][1][:seriescolor] == RGBA(colorant"black")
+    pl = plot(1:5)
+    @test pl[1][1][:seriescolor] == RGBA(colorant"black")
+    @test guidefont(pl[1][:xaxis]).family == "palantino"
 end

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

@testset "Extra kwargs" begin
Author	SHA1	Message	Date
Simon Christ	4723c513be	1.16.1 [skip ci]	2021-06-04 15:39:51 +02:00
Simon Christ	d1373d8b89	fix fontfamily (#3542 ) * fix fontfamily * Update test_defaults.jl	2021-06-04 15:36:40 +02:00
Simon Christ	9f51b96269	1.16.0 [skip ci]	2021-06-03 19:00:39 +02:00
t-bltg	601df0c9a9	GR: allow explicit guidefontrotation (#3529 ) Co-authored-by: t-bltg <t-bltg@users.noreply.github.com>	2021-06-03 19:00:06 +02:00
github-actions[bot]	700b5782ec	Update precompile_*.jl file (#3536 ) Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>	2021-06-03 17:36:51 +02:00
Simon Christ	6a62d96751	axis limits = :symmetric (#2600 ) * allow axis-lims = :symmetric * remove show * add test	2021-06-03 17:35:42 +02:00
Simon Christ	25b57cfb55	Run tests of GraphRecipes and StatsPlots (#3519 ) * run tests of StatsPlots and GraphRecipes * one environment each * correct paths	2021-06-03 11:08:37 +02:00
github-actions[bot]	fb390d1872	Update precompile_*.jl file (#3535 ) Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>	2021-06-03 10:58:38 +02:00
Simon Christ	5fafddb995	fix fontrotation being interpreted as fontsize (#3533 ) * fix convenience font functions * correct size argument	2021-06-02 22:12:30 +02:00
Simon Christ	697e5a87cf	1.15.3 [skip ci]	2021-06-02 16:29:59 +02:00
github-actions[bot]	77ba81de19	Update precompile_*.jl file (#3530 ) [skip ci] Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>	2021-06-02 16:14:02 +02:00
Simon Christ	e43f3ee373	Drop compat for older GR versions (#3526 )	2021-06-02 08:24:42 +02:00
Simon Christ	8f055fef3d	1.15.2 [skip ci]	2021-05-20 20:43:29 +02:00
Simon Christ	ce530ef518	fix vector of shapes (#3517 )	2021-05-20 20:42:31 +02:00
BerndR	827462dc21	NaN checking in backends/gr.jl (#3514 ) * Updated .zenodo.json infos * resolved NaN-checking	2021-05-19 20:33:33 +02:00
github-actions[bot]	1ecec912a1	Update precompile_*.jl file (#3508 ) [skip ci] Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>	2021-05-19 08:53:17 +02:00
Simon Christ	ca8e775b83	1.15.1[skip ci]	2021-05-19 08:29:08 +02:00
Fons van der Plas	c0e50588d3	Minor cleanup plotlyjs (#3510 )	2021-05-19 08:28:03 +02:00
Simon Christ	de7717b85f	Fix too many legend entries (#3511 ) * add test * fix legend entries	2021-05-19 08:27:41 +02:00
Simon Christ	a1311e5c60	all the names [skip ci]	2021-05-18 18:21:45 +02:00
Simon Christ	4069b73563	Update .zenodo.json	2021-05-17 17:58:12 +02:00
Simon Christ	a7d6e93af3	1.15.0 [skip ci]	2021-05-17 09:57:18 +02:00
Simon Christ	058983165e	change DOI [skip ci]	2021-05-17 09:55:47 +02:00
Simon Christ	97036e689e	Create .zenodo.json (#3482 ) * Create .zenodo.json * Update .zenodo.json Co-authored-by: Daniel Schwabeneder <daschw@disroot.org> * add members, classify contributors * Apply suggestions from code review Co-authored-by: Daniel Schwabeneder <daschw@disroot.org> * add all names Co-authored-by: Daniel Schwabeneder <daschw@disroot.org>	2021-05-17 09:43:23 +02:00
github-actions[bot]	d3589db840	Update precompile_*.jl file (#3484 ) Co-authored-by: daschw <daschw@users.noreply.github.com>	2021-05-14 22:03:29 +02:00
Simon Christ	15bd9c537d	Create docs on pushing to master (#3494 ) * Create docs.yml * Update docs.yml * Update docs.yml * Create docs.yml * Update docs.yml * [skip ci] * [skip ci] * [skip ci] * [skip ci] * Update docs.yml * Update docs.yml * Update docs.yml * Update docs.yml * fix pgfplotsx * fix pyplot * remove push workflow (should work without) * conditionally fix pyplot * change env-vars * fix * fix ref * clean up and cache artifacts * add Documenter_key to environment * fix parentheses * "one last fix" * dev => add * fix marker example * exclude 50 for plotly * install ms fonts * only trigger on master * remove REF pretending	2021-05-14 22:00:09 +02:00
Daniel Schwabeneder	27764bbc67	Merge pull request #3497 from giordano/mg/animate-while Allow `while`-block in at-animate macro	2021-05-14 19:19:05 +02:00
Mosè Giordano	788e28d18a	Allow `while`-block in at-animate macro	2021-05-13 10:14:03 +01:00
Asim H Dar	d544647b1b	Update plotly.jl (#3491 ) Tiny typo	2021-05-12 18:36:14 +02:00
Simon Christ	3cb81d6d04	fix alpha for surface (#3489 )	2021-05-12 18:35:19 +02:00
Yuval	61f2d825b6	Merge pull request #3468 from yha/several-nans-fix Fix for plotting a vector of (at least two) NaNs	2021-05-11 17:56:33 +03:00
Daniel Schwabeneder	5df64bd45b	Merge pull request #3463 from gustaphe/fontdefaults Add annotation font defaults/settings	2021-05-11 01:03:09 +02:00
Simon Christ	7e997da6bd	1.14.0 [skip ci]	2021-05-10 19:53:10 +02:00
Simon Christ	35658bf4fe	fix tests	2021-05-07 08:14:37 +02:00
Simon Christ	f355ff9904	clean up pgfx-legends duplications	2021-05-06 21:27:24 +02:00
github-actions[bot]	8893782b13	[AUTO] Update precompiles (#3471 ) * add legend stylings * fix center and default case * Update precompile_*.jl file Co-authored-by: Simon Christ <simonchrist@gmx.de> Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>	2021-05-04 20:54:43 +02:00
Simon Christ	78f7db138f	add legend stylings (#3470 ) * add legend stylings * fix center and default case	2021-05-04 20:54:11 +02:00
yha	23567964e7	undo accidental change	2021-05-03 19:45:48 +03:00
yha	0c7f7ba011	Fix for plotting a vector of (at least two) NaNs	2021-05-03 19:44:11 +03:00
David Gustavsson	4731477920	Add annotation font defaults	2021-05-01 20:39:55 +02:00
Daniel Schwabeneder	57ba6aa5a9	Merge pull request #3458 from daschw/tickmarks add `tick_direction=:none` option to hide tick marks	2021-04-29 10:54:54 +02:00
Simon Christ	3c472f24b5	add DOI badge	2021-04-28 22:20:34 +02:00
Daniel Schwabeneder	5a4651a0ec	clean changes in recipes.jl	2021-04-28 20:35:00 +02:00
Daniel Schwabeneder	7bb2132b18	add `tick_direction=:none` option to hide tick labels	2021-04-28 20:27:50 +02:00
Daniel Schwabeneder	fd50469e20	Merge pull request #3430 from ma-laforge/idr_layout Update plot areas for the given font sizes.	2021-04-28 18:42:14 +02:00
Daniel Schwabeneder	e3d13aa17a	Merge pull request #3436 from gustaphe/master Generalize Shape	2021-04-28 18:40:57 +02:00
Simon Christ	476de3d2a2	1.13.2 [skip ci]	2021-04-28 09:52:54 +02:00
Yuval	c986bfa1e6	Merge pull request #3443 from yha/plotly-shapes-fix Fix shapes series on plotly	2021-04-27 13:05:32 +03:00
github-actions[bot]	dfd8fada9d	[AUTO] Update precompiles (#3455 ) * incorporate colorbar ticks and ticklabel styles * fix colorbar showing * Update precompile_*.jl file Co-authored-by: Simon Christ <SimonChrist@gmx.de> Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>	2021-04-27 10:35:28 +02:00
Simon Christ	d4298bf1cc	1.13.1 [skip ci]	2021-04-27 10:35:12 +02:00
Simon Christ	02437562a7	colorbar improvements for pgfplotsx (#3441 ) * incorporate colorbar ticks and ticklabel styles * fix colorbar showing	2021-04-27 09:50:49 +02:00
yha	e449d3221c	Fix shapes series on plotly	2021-04-18 13:41:10 +03:00
David Gustavsson	a359f21325	Generalize Shape	2021-04-14 09:34:06 +02:00
MA Laforge	9da550ba3b	Update plot areas for the given font sizes. Also: Layout changes are made to defaults instead of user-overwrites.	2021-04-10 14:57:39 -04:00