a bunch of refactors

use === nothing

.gitignore

@@ -1,3 +1,10 @@
 *.jl.cov
 *.jl.*.cov
 *.jl.mem
+.DS_Store
+examples/.ipynb_checkpoints/*
+examples/meetup/.ipynb_checkpoints/*
+deps/plotly-latest.min.js
+deps/build.log
+deps/deps.jl
+Manifest.toml

.travis.yml

@@ -2,12 +2,19 @@
 language: julia
 os:
   - linux
-  - osx
+  # - osx
 julia:
-  - 0.4
+  - 1.1
+  - nightly
+  
+matrix:
+  allow_failures:
+    - julia: nightly
+
+sudo: required
+before_install:
+  - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then pwd ; fi
+  - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then ./test/install_wkhtmltoimage.sh ; fi
+
 notifications:
-  email: false
-# uncomment the following lines to override the default test script
-script:
- - if [[ -a .git/shallow ]]; then git fetch --unshallow; fi
- - julia -e 'Pkg.clone(pwd()); Pkg.build("Plots"); Pkg.add("Gadfly"); Pkg.test("Plots"; coverage=true)'
+  email: true

NEWS.md

@@ -0,0 +1,815 @@
+
+# Plots.jl NEWS
+
+#### notes on release changes, ongoing development, and future planned work
+
+- Minor version 0.17 is the last one to support Julia 0.6!!
+- Minor version 0.11 is the last one to support Julia 0.5!!
+	- Critical bugfixes only
+    - `backports` branch is for Julia 0.5
+
+---
+## (current master)
+
+## 0.26.2
+- improve empty animation build error
+- fix GR axis flip for heatmaps and images
+- fix ribbons specified as tuples
+- add Char recipe
+- fix Plotly plots with single-element series
+- rewrite PlotlyJS backend
+
+## 0.26.1
+- handle `Char`s as input data
+- fix html saving for Plotly
+- expand ~ in paths on UNIX systems
+- convertToAnyVector clean-up
+- fix color_palette grouping issue
+
+## 0.26.0
+- use FFMPEG.jl
+- add missing method for convertToAnyVector
+
+## 0.25.3
+- add areaplot
+- allow missing in z_color arguments
+- more general tuple recipe
+- stephist logscale improvements
+
+## 0.25.2
+- improvements to handle missings
+- pyplot: allow setting the color gradient for z values
+- document :colorbar_entry
+- limit number of automatic bins
+- fix ENV['PLOTS_DEFAULT_BACKEND']
+- don't let aspect_ratio impact subplot size
+- implement arrowstyle for GR
+- fix bug in plotly_convert_to_datetime
+- improve missing support
+- gr: polar heatmaps
+- make sure show returns nothing
+
+## 0.25.1
+- fix gr_display
+
+## 0.25.0
+- Replace StaticArrays with GeometryTypes
+- Contour fixes for GR
+
+## 0.24.0
+- Update to the new PyCall and PyPlot API
+- fix drawing of ticks
+- fix y label position with GR
+
+## 0.23.2
+- pyplot fixes
+- Add option :tex_output_standalone to set the 'include_preamble' argument in the PGFPlots backend.
+- fix ticks
+- support plotly json mime
+- fix image axis limits
+- default to radius 0 at center for polar plots
+
+## 0.23.1
+- slightly faster load time
+- fixed errant MethodError
+- fix bar plots with unicodeplots
+- better colorbars for contour
+- add volume seriestype for GR
+- fix passing a tuple to custom ticks
+- add vline to pgfplots
+- add tex output for pyplot
+- better 3d axis labels for GR
+
+## 0.23.0
+- compatible with StatPlots -> StatsPlots name shift
+- fix histograms for vectors with NaN and Inf
+- change gif behaviour (remove cache-busting)
+- improved docstrings for shorthands functions
+- fix font rotation for pyplot
+- fix greyscale images for pyplot
+- clamp greyscale images with values outside 0,1
+- support keyword argument for font options
+- allow vector of markers for pyplot scatter
+
+## 0.22.5
+- improve behaviour of plotlyjs backend
+
+## 0.22.4
+- Add support for discrete contourf plots with GR
+
+## 0.22.3
+- Fix the `showtheme` function
+
+## 0.22.2
+- Allow annotations to accept a Tuple instead of the result of a text call (making it possible to specify font characteristics in recipes). E.g. `annotations = (2, 4, ("test", :right, 8, :red))` is the same as `annotations = (2, 4, text("test", :right, 8, :red))`
+
+## 0.22.1
+- push PlotsDisplay just after REPLDisplay
+
+## 0.22.0
+- deprecate GLVisualize
+- allow 1-row and 1-column heatmaps
+- add portfoliodecomposition recipe from PlotRecipes
+- solve Shape bug
+- simplify PyPlot backend installation
+- fix wireframe bug in PyPlot
+- fix color bug in PyPlot
+- minor bug fixes in gr and pyplot
+
+## 0.21.0
+- Compatibility with StaticArrays 0.9.0
+- Up GR min version to 0.35
+- fix :mirror
+
+## 0.20.6
+- fixes for PlotDocs.jl
+- fix gr axis color argument
+- Shapes for inspectdr
+- don't load plotly js file by default
+
+## 0.20.5
+- fix precompilation issue when depending on Plots
+
+## 0.20.4
+- honour `html_output_format` in Juno
+
+## 0.20.3
+- implement guide position in gr, pyplot and pgfplots
+- inspectdr fixes
+- default appveyor
+- rudimentary missings support
+- deprecation fixes for PGFPlots
+
+## 0.20.0
+Many updates, min julia 1.0
+- change display type to use PlotsDisplay (fixes Juno integration)
+- change all internal uses of `d` to `plotattributes` (no user change)
+- change spy implementation to use `scatter` not `heatmap`
+- sort x axes when passing a vector of strings as x
+- improve performance of marker_z
+- update CI to 1.0
+- minor depwarn ifixes
+- only draw one colorbar with GR
+- add colorbar_title to GR and pgfplots
+- fix savefig with latexstrings for PyPlot
+- fix NamedTuple integration
+- don't export `P2` and `P3`
+- make it possible to use 2-argument function as argument to marker_z
+- make `plotattr` work again
+
+## 0.19.3
+- fix some julia 0.7 deprecations
+- fix 32-bit OS functionality
+
+## 0.19.2
+- several small fixes for 1.0 compatibility
+
+## 0.19.1
+- don't broadcast plot_color
+
+## 0.19.0
+- Refactor conditional loading to use Requires
+- Many fixes for 1.0 compatibility
+
+## 0.18.0
+- update minor version to 0.7
+
+## 0.17.4
+- fix thickness_scaling for pyplot
+
+## 0.17.3
+- Log-scale heatmap edge computation
+- Fix size and dpi for GR and PyPlot
+- Fix fillrange with line segments on PyPlot and Plotly
+- fix flip for heatmap and image on GR
+- New attributes for PGFPlots
+- Widen axes for most series types and log scales
+- Plotly: fix log scale with no ticks
+- Fix axis flip on Plotly
+- Fix hover and zcolor interaction in Plotly
+- WebIO integration for PlotlyJS backend
+
+## 0.17.2
+- fix single subplot in plotly
+- implement `(xyz)lims = :round`
+- PyPlot: fix bg_legend = invisible()
+- set fallback tick specification for axes with discrete values
+- restructure of show methods
+
+## 0.17.1
+- Fix contour for PGFPlots
+- 32Bit fix: Int64 -> Int
+- Make series of shapes and segments toggle together in Plotly(JS)
+- Fix marker arguments
+- Fix processing order of series recipes
+- Fix Plotly(JS) ribbon
+- Contour plots with x,y in grid form on PyPlot
+
+## 0.17.0
+- Add GR dependency to make it the default backend
+- Improve histogram2d bin estimation
+- Allow vector arguments for certain series attributes and support line_z and fill_z on GR, PyPlot, Plotly(JS) and PGFPlots
+- Automatic scientific notation for tick labels
+- Allow to set the theme in PLOTS_DEFAULTS
+- Implement plots_heatmap seriestype providing a Plots recipe for heatmaps
+
+## 0.16.0
+- fix 3D plotting in PyPlot
+- Infinite objects
+
+## 0.15.1
+
+- fix scientific notation for labels in GR
+- fix labels with logscale
+- fix image cropping with GR
+- fix grouping of annotations
+- fix annotations in Plotly
+- allow saving notebook with plots as pdf from IJulia
+- fix fillrange and ribbon for step recipes
+- implement native ticks that respond to zoom
+- fix bar plot with one bar
+- contour labels and colorbar fixes
+- interactive linked axis for PyPlot
+- add `NamedTuple` syntax to group with named legend
+- use bar recipe in Plotly
+- implement categorical ticks
+
+## 0.15.0
+
+- improve resolution of png output of GR with savefig()
+- add check for ticks=nothing
+- allow transparency in heatmaps
+- fix line_z for GR
+- fix legendcolor for pyplot
+- fix pyplot ignoring alpha values of images
+- don't let `abline!` change subplot limits
+- update showtheme recipe
+
+## 0.14.2
+
+- fix plotly bar lines bug
+- allow passing multiple series to `ribbon`
+- add a new example for `line_z`
+
+## 0.14.1
+
+- Add linestyle argument to the legend
+- Plotly: bar_width and stroke_width support for bar plots
+- abline! does not change axis limits
+- Fix default log scale ticks in GR backend
+- Use the :fontsize keys so the scalefontsizes command works
+- Prepare support for new PlotTheme type in PlotThemes
+
+## 0.14.0
+
+- remove use of imagemagick; saving gifs now requires ffmpeg
+- improvements to ffmpeg gif quality and speed
+- overhaul of fonts, allows setting fonts in recipes and with magic arguments
+- added `camera` attribute to control camera position for 3d plots
+- added `showaxis` attribute to control which axes to display
+- improvements of polar plots axes, and better backend consistency
+- changed the 'spy' recipe back to using heatmap
+- added `scatterpath` seriestype
+- allow plotlyjs to save svg
+- add `reset_defaults()` function to reset plot defaults
+- update syntax to 0.6
+- make `fill = true` fill to 0 rather than to 1
+- use new `@df` syntax in StatsPlots examples
+- allow changing the color of legend box
+- implement `title_location` for gr
+- add `hline` marker to pgfplots - fixes errorbars
+- pyplot legends now show marker types
+- pyplot colorbars take font style from y axis
+- pyplot tickmarks color the same as axis color
+- allow setting linewidth for contour in gr
+- allow legend to be outside plot area for pgfplots
+- expand axis extrema for heatmap
+- extendg grid lines to axis limits
+- fix `line_z` for pyplot and gr
+- fixed colorbar problem for flipped axes with gr
+- fix marker_z for 3d plots in gr
+- fix `weights` functionality for histograms
+- fix gr annotations with colorbar
+- fix aspect ratio in gr
+- fix "hidden window" problem after savefig in gr
+- fix pgfplots logscale ticks error
+- fix pgfplots legends symbols
+- fix axis linking for plotlyjs
+- fix plotting of grayscale images
+
+## 0.13.1
+
+- fix a bug when passing a vector of functions with no bounds (e.g. `plot([sin, cos])`)
+- export `pct` and `px` from Plots.PlotMeasures
+
+## 0.13.0
+
+- support `plotattributes` rather than `d` in recipes
+- no longer export `w`, `h` and names from Measures.jl; use `using Plots.PlotMeasures` to get these names back
+- `bar_width` now depends on the minimum distance between bars, not the mean
+- better automatic x axis limits for plotting Functions
+- `tick_direction` attribute now allows ticks to be on the inside of the plot border
+- removed a bug where `p1 = plot(randn(10)); plot(p1, p2)` made `display(p1)` impossible
+- allow `plot([])` to generate an empty plot
+- add `origin` framestyle
+- ensure finite bin number on histograms with only one unique value
+- better automatic histogram bins for 2d histograms
+- more informative error message on passing unsupported seriestype in a recipe
+- allow grouping in user recipes
+- GR now has `line_z` and `fill_z` attributes for determining the color of shapes and lines
+- change GR default view angle for 3D plots to match that of PyPlot
+- fix `clims` on GR
+- fix `marker_z` for plotly backend
+- implement `framestyle` for plotly
+- fix logscale bug error for values < 1e-16 on pyplot
+- fix an issue on pyplot where >1 colorbar would be shown if there was >1 series
+- fix `writemime` for eps
+
+## 0.12.4
+
+- added a new `framestyle` argument with choices: :box, :semi, :axes, :grid and :none
+- changed the default bar width to 0.8
+- added working ribbon to plotly backend
+- ensure that automatic ticks always generate 4 to 8 ticks
+- group now groups keyword arguments of the same length as the input
+- allow passing DateTime objects as ticks
+- allow specifying the number of ticks as an integre
+- fix bug on errorbars in gr
+- fixed some but not all world age issues
+- better margin with room for text
+- added a `match` option for linecolor
+- better error message un unsupported series types
+- add a 'stride' keyword for the pyplot backend
+
+## 0.12.3
+
+- new grid line style defaults
+- `grid` is now an axis attribute and a magic argument: it is now possible to modify the grid line style, alpha and line width
+- Enforce plot order in user recipes
+- import `plot!` from RecipesBase
+- GR no longer automatically handles _ and ^ in texts
+- fix GR colorbar for scatter plots
+
+#### 0.12.2
+
+- fix an issue with Juno/PlotlyJS compatibility on new installations
+- fix markers not showing up in seriesrecipes using :scatter
+- don't use pywrap in the pyplot backend
+- improve the bottom margin for the gr backend
+
+#### 0.12.1
+
+- fix deprecation warnings
+- switch from FixedSizeArrays to StaticArrays.FixedSizeArrays
+- drop FactCheck in tests
+- remove julia 0.5 compliant uses of transpose operator
+- fix GR heatmap bugs
+- fix GR guide padding
+- improve legend markers in GR
+- add surface alpha for Plotly(JS)
+- add fillrange to Plotly(JS)
+- allow usage of Matplotlib 1.5 with PyPlot
+- fix GLVisualize for julia 0.6
+- conform to changes in InspectDR
+
+#### 0.12.0
+
+- 0.6 only
+
+#### 0.11.3
+
+- add HDF5 backend
+- GR replaces PyPlot as first-choice backend
+- support for legend position in GR
+- smaller markers in GR
+- better viewport size in GR
+- fix glvisualize support
+- remove bug with three-argument method of `text`
+- `legendtitle` attribute added
+- add test for `spy`
+
+#### 0.11.0
+
+- julia 0.6 compatibility
+- matplotlib 2.0 compatibility
+- add inspectdr backend
+- improved histogram functionality:
+- added a `:stephist` and `:scatterhist` series type as well as ``:barhist` (the default)
+- support for log scale axes with histograms
+- support for plotting `StatsBase.Histogram`
+- allowing bins to be specified as `:sturges`, `:rice`, `:scott` or :fd
+- allow `normalization` to be specified as :density (for unequal bins) or :pdf (sum to 1)
+- add a `plotattr` function to access documentation for Plots attribute
+- add `fill_z` attribute for pyplot
+- add colorbar_title to plotlyjs
+- enable standalone window for plotlyjs
+- improved support for pgfplots, ticks rotation, clims, series_annotations
+- restore colorbars for GR
+- better axis labels for heatmap in GR
+- better marker sizes in GR
+- fix color representation in GR
+- update GR legend
+- fix image bug on GR
+- fix glvisualize dependencies
+- set dotted grid lines for pyplot
+- several improvements to inspectdr
+- improved tick positions for TimeType x axes
+- support for improved color gradient capability in PlotUtils
+- add a showlibrary recipe to display color libraries
+- add a showgradient recipe to display color gradients
+- add `vectorfield` as an alias for `quiver`
+- use `PlotUtils.adaptedgrid` for functions
+
+
+#### 0.9.5
+
+- added dependency on PlotThemes
+- set_theme --> theme
+- remove Compat from REQUIRE
+- warning for DataFrames without StatsPlots
+- closeall exported and implemented for gr/pyplot
+- fix DateTime recipe
+- reset theme with theme(:none)
+- fix link_axes! for nested subplots
+- fix plotly lims for log scale
+
+#### 0.9.4
+
+- optimizations surrounding Subplot.series_list
+- better Atom support, support plotlyjs
+- gr:
+    - gks_wstype defaults and gr_set_output
+    - heatmap uses GR.drawimage
+- histogram2d puts NaN for zeros
+- improved support of NaN in heatmaps
+- rebuilt spy recipes to output scatters with marker_z set
+- deprecate png support in plotly... point to plotlyjs
+- fixes:
+    - axis widen with lims set
+    - reset_extrema, setxyz
+    - bar plot widen
+    - better tick padding
+    - consistent tick rotation
+    - consistent aspect_ratio
+    - pyplot dpi
+    - plotly horizontal bars
+    - handle series attributes when combining subplots
+    - gr images transposed
+    - converted Date/DateTime to new type recipe approach for arrays
+- issues closed include: #505 #513 #479 #523 #526 #529
+
+#### 0.9.3
+
+- support pdf and eps in plotlyjs backend
+- allow curly after grid: `@layout [a b; grid(4,4){0.8h}]`
+- add_backend redesign
+
+#### 0.9.2
+
+- glvisualize backend (@SimonDanisch)
+    - too much to list! ready for alpha testing
+- Volume and volume seriestype
+- Atom: support for PlotPane and proper gui display
+- gr:
+    - clims
+    - aspect ratio
+- pgfplots:
+    - fixes for ticks, axes, and more
+- pyplot:
+    - font families
+    - colorbar guide
+    - pixel marker
+- unicodeplots
+    - basic support for shapes
+- improved add_backend
+- refactor of is_supported methods
+- element-wise type recipes (see https://github.com/tbreloff/Plots.jl/issues/460#issuecomment-248428908)
+- several other fixes/improvements
+
+#### 0.9.1
+
+- Pkg.dir --> dirname (@tkelman)
+- `axis = nothing` magic
+- fixes:
+    - clim for line_z
+    - sticks default range for log scale
+    - rotate method
+    - pyplot heatmap
+    - spurious scale warnings
+    - gr image/alpha
+    - plotly.js path
+    - orientation extrema
+    - bar, reset orientation
+- switch transpose_z to use permutedims
+- skinny x/+ markers
+- ticks in pgfplots
+- eps in savefig (@anriseth)
+- add_backend convenience
+- type recipes for Date/DateTime (@maximsch2)
+- mirror attribute and twinx convenience
+- Axis.sp --> Axis.sps
+- recipe postprocessing for allowing aliases and magic args in recipe bodies
+
+
+
+#### 0.9.0
+
+- fixes to cycle
+- add back single function recipe: `plot!(cos)`
+- new axis formatter attribute... accepts functions to convert numbers to strings
+- fix for inset plots
+- GR:
+	- fillrange fix
+	- annotations fix
+	- force double buffering in display
+
+---
+
+## 0.8
+
+#### 0.8.2 (backported bug fixes for julia 0.4)
+
+- plotly ticks fix
+- unicodeplots size fix
+- remove mkdir call in tests
+
+#### 0.8.1
+
+- manual drawing of axes/ticks/labels
+- get_ticks uses optimize_ticks and Showoff
+- changed PLOTS_DEFAULTS to be a global variable, not ENV key
+- parameterized Segments for pushing tuples
+- fix to axis extrema for Bool/nothing
+- GR:
+	- manually draw 2D axes... fixes several issues and missing features
+	- fontsize fix
+- PGFPlots: pass axis syle
+
+#### 0.8.0
+
+- added dependency on PlotUtils
+- BREAKING: removed DataFrames support (now in StatsPlots.jl)
+- BREAKING: removed boxplot/violin/density recipes (now in StatsPlots.jl)
+- GR:
+    - inline iterm2 support
+    - trisurface support
+    - heatmap fix
+- PyPlot:
+    - ijulia display fix
+- GLVisualize:
+    - first try with shapes
+- iter_segments improvements
+- bar_width support
+- horizontal bars
+- improve tick display
+- better shape handling in pyplot, plotly
+- improved padding calcs
+- internal reorg of _plots method, add pipeline.jl
+
+---
+
+## 0.7
+
+#### 0.7.5
+
+- GR: LaTeX support
+- Changed docs url to juliaplots.github.io
+- added `contourf` seriestype
+- allow `plt[1]` to return first Subplot
+- allow `sp[1]` to return the first Series of the Subplot
+- `series[k]` now passes through to `series.d[k]`
+- allow calling `plot!(sp, ...)` to update a target Subplot
+- PyPlot: zorder fix
+- new DataFrames logic/recipe: more flexible/robust and allow Symbols for:
+	- `(:fillrange, :line_z, :marker_z, :markersize, :ribbon, :weights, :xerror, :yerror)`
+- new `display_type` and `extra_kwargs` plot attributes
+- surface fix
+
+#### 0.7.4
+
+- added snooped precompiles, but left commented out
+- GR fixes: markersize, shapes, legends
+- fixes to recipes
+- turned on Appveyor
+
+#### 0.7.3
+
+- rebuild violin and boxplot recipes
+- "plot recipes"
+- `cgrad` method for easy color gradient creation
+- improvements to inset subplots
+- Segments and iter_segments for NaN-separated vectors
+- `bar` recipe now creates a `shape` series
+- writemime fix for Interact.jl
+- `link = :square` option
+- !!! set `shape` attributes with line/fill, NOT marker/markerstroke !!!
+- basic DPI support
+- moved chorddiagram to PlotRecipes
+- GR:
+	- use temp files for img output
+	- basic support for marker strokes and other marker fixes
+- PyPlot:
+	- Switch to recipes for bar, histogram, histogram2d
+- GLVisualize
+	- subplots
+	- path/scatter and path3d/scatter3d
+	- initial drawing of axes
+- many smaller fixes and improvements
+
+#### 0.7.2
+
+- line_z arg for multicolored line segments
+- pyplot
+	- line_z (2d and 3d)
+	- pushed all fig updates into display pipeline
+	- remove native sticks/hline/vline in favor of recipes
+- unicodeplots cleanup, ijulia fixes, ascii canvas
+- `curves` series type
+- `iter_segments` iterator
+- moved arcdiagram out and into PlotRecipes (thanks @diegozea)
+- several other fixes/checks
+
+#### 0.7.1
+
+- inset (floating) subplots
+- change: when setting subplot/axis args from user recipes, they should apply only to their own subplot
+- trim for violin/boxplot
+- scatter3d recipe
+- removed plotly.js in favor of build.jl download
+- improvements/fixes to pgfplots backend
+- improvements/fixes to plotly/plotlyjs backends
+	- titles are annotations and properly placed with title_position
+	- hover attribute
+	- shapes (almost)
+	- scattergl
+- minimum perimeter logic in layout calc... fixed misaligned subplots
+- new clims attribute
+- more options for test_examples
+- GR refactor
+	- added transparency
+	- moved axis/grid logic out of series loop
+	- generalized 3d and polar projections
+- renamed get_mod to Base.cycle
+- pyplot log scale fixes
+- PLOTS_DEFAULTS environment var processing
+- rename :ellipse to :circle, :ellipse is now an alias
+- supported args/types cleanup
+- seriestype dependency methods and `@deps` macro
+- bbox `h_anchor`/`v_anchor`
+- new axis arg: `:link` is a list of subplots to link axes with
+- cleanup/simplification of glvisualize backend
+
+
+#### 0.7.0
+
+- Check out [the summary](http://juliaplots.github.io/plots_v0.7/)
+- Revamped and simplified internals
+- [Recipes, recipes, recipes](https://github.com/JuliaPlots/RecipesBase.jl/issues/6)
+- [Layouts and Subplots](https://github.com/tbreloff/Plots.jl/issues/60)
+- DataFrames is loaded automatically when installed
+- Overhaul to GroupBy mechanic (now offloads to a recipe)
+- Replaced much of the argument processing with recipes
+- Added series recipes, and began to strip down un-needed backend code.  Some recipes:
+	- line, step, sticks, bar, histogram, histogram2d, boxplot, violin, quiver, errorbars, density, ohlc
+- Added `@shorthands` and `@userplot` macros for recipe convenience
+- Better handling of errorbars and ribbons
+- New Axis type
+	- Tracks extrema and discrete values
+	- New `link_axes` functionality
+- `linetype` has been renamed `seriestype` (the alias is reversed)
+- Many fixes and huge cleanup in GR
+- Brand new subplot layout mechanics:
+	- `@layout` macro
+	- AbstractLayout, Subplot, GridLayout, and everything related
+	- Added dependency on Measures.jl
+	- Computations of axis/guide sizes and precise positioning
+- Refactored and compartmentalized default dictionaries for attributes
+- Deprecated Gadfly and Immerse backends
+- Added `series_annotations` attribute (previously that functionality was merged with `annotations`, which are not series-specific)
+- Removed `axis` attribute... currently not supporting twin (right) y axes
+- Check for `ENV["PLOTS_USE_ATOM_PLOTPANE"]` and default to false
+- Improved backend interface to reduce redundant code.  Template updated.
+- Added `html_output_format`, primarily for choosing between png and svg output in IJulia.
+- Partial support of Julia v0.5
+- Switched testing to dump reference images to JuliaPlots/PlotReferenceImages.jl
+- Moved docs-specific code to new JuliaPlots/PlotDocs.jl
+- Moved example list from ExamplePlots into Plots.
+- Added several examples and improved others.
+- Many other smaller changes and bug fixes.
+
+
+---
+
+## Version 0.6
+
+#### 0.6.2
+
+- `linewidth` fixes
+- `markershape` fix
+- converted center calc to centroid for shapes
+- new dependency on [RecipesBase](https://github.com/JuliaPlots/RecipesBase.jl)
+- REQUIRE upper limit for RecipesBase: 0.0.1
+- GR fixes/improvements (@jheinen)
+  - support `zlims`, `bins`
+  - allow Plots colormaps
+  - other bug fixes
+  - native image support
+- PGFPlots fixes/improvements (@pkofod)
+- DataFrames are handled by recipes
+- Plotly: zaxis, tick rotation, 3d axis fix
+- Improvements in handling discrete data
+- Support for image display
+- `arrow` keyword and support for adding arrows to paths
+- changed quiver recipe to use arrows
+- Bug fixes for boxplots, heatmaps, and more
+
+#### 0.6.1
+
+- `rotation` keyword
+- improved supported graphs
+- subplot bug fix
+
+#### 0.6.0
+
+- `apply_series_recipe` framework for built-in recipes
+- [boxplot/violin recipes](https://github.com/tbreloff/ExamplePlots.jl/blob/master/notebooks/boxplot.ipynb)
+- [errorbar/ribbon recipes](https://github.com/tbreloff/ExamplePlots.jl/blob/master/notebooks/errorbars.ipynb)
+- [quiver recipe](https://github.com/tbreloff/ExamplePlots.jl/blob/master/notebooks/quiver.ipynb)
+- `polar` coordinates
+- better support for shapes and custom polygons (see [batman](https://github.com/tbreloff/ExamplePlots.jl/blob/master/notebooks/batman.ipynb))
+- z-axis keywords
+- 3D indexing overhaul: `push!`, `append!` support
+- matplotlib colormap constants (`:inferno` is the new default colormap for Plots)
+- `const KW = Dict{Symbol,Any}` used in place of splatting in many places
+- png generation for plotly backend using wkhtmltoimage
+- `normalize` and `weights` keywords
+- background/foreground subcategories for fine-tuning of looks
+- `add_theme`/`set_theme` and ggplot2 theme (see [this issue](https://github.com/tbreloff/Plots.jl/issues/201))
+- `PLOTS_DEFAULT_BACKEND` environment variable
+- `barh` linetype
+- support for non-gridded surfaces with pyplot's trisurface
+- pyplot surface zcolor
+- internal refactor of supported.jl
+- `wrap` method to bypass input processing
+- `translate`, `scale` and `rotate` methods for coordinates and shapes
+- and many more minor fixes and improvements
+
+---
+
+## Version 0.5
+
+#### 0.5.4
+
+- old heatmaps have been renamed to hist2d, and true heatmaps implemented (see https://github.com/tbreloff/Plots.jl/issues/147)
+- lots of reorganization and redesign of the internals
+- lots of renaming to keep to conventions: AbstractPlot, AbstractBackend, etc
+- initial redesign of layouts
+- integration with Atom PlotPane
+- arc diagram and chord diagram (thanks to @diegozea: see https://github.com/tbreloff/Plots.jl/issues/163)
+- work on GR, GLVisualize, and PGFPlots backends (thanks @jheinen @dlfivefifty @pkofod)
+- improvements to Plotly setup (thanks @spencerlyon2)
+- overhaul to series creation logic and groupby mechanic
+- replace Dict with `typealias KW Dict{Symbol,Any}` in many places, also replacing keyword arg splatting
+- new `shape` linetype for plotting polygons in plot-coordinates (see https://github.com/tbreloff/ExamplePlots.jl/blob/master/notebooks/batman.ipynb)
+- many other fixes
+
+#### 0.5.3
+
+- `@gif` macro with `every`/`when` syntax
+- bezier curves and other graph drawing helpers
+- added FixedSizeArrays dependency with relevant functionality
+- merged lots of improvements to GR (thanks @jheinen)
+- `overwrite_figure`/`reuse` arg for reusing the same figure window
+- deprecated Qwt, Winston, and Bokeh backends
+- improved handling of 3D inputs (call `z=rand(10,10); surface(z)` for example)
+- fix IJulia display issue
+- lots of progress on PlotlyJS backend
+- and many other changes and fixes...
+
+#### 0.5.2
+
+- Added [GR.jl](https://github.com/jheinen/GR.jl) as a backend (unfinished but functional) All credit to @jheinen
+- Set defaults within backend calls (i.e. `gadfly(legend=false)`)
+- `abline!`; also extrema allows plotting functions without giving x (i.e. `plot(cos, 0, 10); plot!(sin)`) @pkofod @joshday
+- Integration with [PlotlyJS.jl](https://github.com/spencerlyon2/PlotlyJS.jl) for using Plotly inside a Blink window @spencerlyon2
+- The Plotly backend has been split into my built-in version (`plotly()`) and @spencerlyon2's backend (`plotlyjs()`)
+- Revamped backend setup code for easily adding new backends
+- New docs (WIP) at http://juliaplots.github.io/
+- Overhaul to `:legend` keyword (see https://github.com/tbreloff/Plots.jl/issues/135)
+- New dependency on Requires, allows auto-loading of DataFrames support
+- Support for plotting lists of Tuples and FixedSizeArrays
+- new `@animate` macro for super simple animations (see https://github.com/tbreloff/Plots.jl/issues/111#issuecomment-181515616)
+- allow Function for `:fillrange` and `zcolor` arguments (for example: `scatter(sin, 0:10, marker=15, fill=(cos,0.4), zcolor=sin)`)
+- allow vectors of PlotText without x/y coords (for example: `scatter(rand(10), m=20, ann=map(text, 1:10))`)
+- Lots and lots of fixes
+
+#### 0.5.1
+
+#### 0.5.0
+
+- `with` function for temporary defaults
+- contours
+- basic 3D plotting
+- preliminary support for Bokeh
+- `stroke` and `brush` for more fine-tuned control over visuals
+- smarter "magic" arguments: `line`, `marker`

Project.toml

@@ -0,0 +1,57 @@
+name = "Plots"
+uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
+author = ["Tom Breloff (@tbreloff)"]
+version = "0.26.2"
+
+[deps]
+Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
+Contour = "d38c429a-6771-53c6-b99e-75d170b6e991"
+Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
+FFMPEG = "c87230d0-a227-11e9-1b43-d7ebe4e7570a"
+FixedPointNumbers = "53c48c17-4a7d-5ca2-90c5-79b7896eea93"
+GR = "28b8d3ca-fb5f-59d9-8090-bfdbd6d07a71"
+GeometryTypes = "4d00f742-c7ba-57c2-abde-4428a4b178cb"
+JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
+LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+Measures = "442fdcdd-2543-5da2-b0f3-8c86c306513e"
+NaNMath = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3"
+Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
+PlotThemes = "ccf2f8ad-2431-5c83-bf29-c5338b663b6a"
+PlotUtils = "995b91a9-d308-5afd-9ec6-746e21dbc043"
+Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
+REPL = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb"
+Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
+RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01"
+Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
+Requires = "ae029012-a4dd-5104-9daa-d747884805df"
+Showoff = "992d4aef-0814-514b-bc4d-f2e9a6c4116f"
+SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
+Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
+StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
+UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
+
+[compat]
+FixedPointNumbers = "≥ 0.3.0"
+GR = "≥ 0.31.0"
+PlotThemes = "≥ 0.1.3"
+PlotUtils = "≥ 0.4.1"
+RecipesBase = "≥ 0.6.0"
+StatsBase = "≥ 0.14.0"
+julia = "≥ 1.0.0"
+
+[extras]
+FileIO = "5789e2e9-d7fb-5bc7-8068-2c6fae9b9549"
+ImageMagick = "6218d12a-5da1-5696-b52f-db25d2ecc6d1"
+Images = "916415d5-f1e6-5110-898d-aaa5f9f070e0"
+LaTeXStrings = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f"
+Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
+RDatasets = "ce6b1742-4840-55fa-b093-852dadbb1d8b"
+Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
+StatsPlots = "f3b207a7-027a-5e70-b257-86293d7955fd"
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+UnicodePlots = "b8865327-cd53-5732-bb35-84acbb429228"
+VisualRegressionTests = "34922c18-7c2a-561c-bac1-01e79b2c4c92"
+BinaryProvider = "b99e7846-7c00-51b0-8f62-c81ae34c0232"
+
+[targets]
+test = ["BinaryProvider", "Pkg", "Test", "Random", "StatsPlots", "VisualRegressionTests", "LaTeXStrings", "Images", "ImageMagick", "RDatasets", "FileIO", "UnicodePlots"]

README.md

@@ -1,224 +1,24 @@
 # Plots
 
-[![Build Status](https://travis-ci.org/tbreloff/Plots.jl.svg?branch=master)](https://travis-ci.org/tbreloff/Plots.jl)
+[![Build Status](https://travis-ci.org/JuliaPlots/Plots.jl.svg?branch=master)](https://travis-ci.org/JuliaPlots/Plots.jl)
+[![Build status](https://ci.appveyor.com/api/projects/status/github/juliaplots/plots.jl?branch=master&svg=true)](https://ci.appveyor.com/project/mkborregaard/plots-jl)
+[![Join the chat at https://gitter.im/tbreloff/Plots.jl](https://badges.gitter.im/tbreloff/Plots.jl.svg)](https://gitter.im/tbreloff/Plots.jl?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+<a href="http://docs.juliaplots.org/latest/" target="_blank"><img src="https://img.shields.io/badge/docs-latest-blue.svg" alt="Latest documentation"></a>
+<!-- [![Plots](http://pkg.julialang.org/badges/Plots_0.3.svg)](http://pkg.julialang.org/?pkg=Plots&ver=0.3) -->
+<!-- [![Plots](http://pkg.julialang.org/badges/Plots_0.4.svg)](http://pkg.julialang.org/?pkg=Plots&ver=0.4) -->
+<!-- [![Coverage Status](https://coveralls.io/repos/tbreloff/Plots.jl/badge.svg?branch=master)](https://coveralls.io/r/tbreloff/Plots.jl?branch=master) -->
+<!-- [![codecov.io](http://codecov.io/github/tbreloff/Plots.jl/coverage.svg?branch=master)](http://codecov.io/github/tbreloff/Plots.jl?branch=master) -->
 
-Plotting interface and wrapper for several plotting packages.
+#### Created by Tom Breloff (@tbreloff)
 
-Please add wishlist items, bugs, or any other comments/questions to the issues list.
+#### Maintained by the [JuliaPlots members](https://github.com/orgs/JuliaPlots/people)
 
-## Examples
-
-- [Qwt.jl](docs/qwt_examples.md)
-- [Gadfly.jl](docs/gadfly_examples.md)
-
-## Installation
-
-First, clone the package, and get any plotting packages you need:
-
-```
-Pkg.clone("https://github.com/tbreloff/Plots.jl.git")
-Pkg.add("Gadfly")                                     # [optional]
-Pkg.clone("https://github.com/tbreloff/Qwt.jl.git")   # [optional] requires pyqt and pyqwt
-```
-
-## Use
-
-Load it in.  The underlying plotting backends are not imported until `plotter()` is called (which happens
-on your first call to `plot`).  This means that you don't need any backends to be installed when you call `using Plots`.
-For now, the default backend is Gadfly.
-
-```
-using Plots
-```
-
-Do a plot in Gadfly, then save a png:
-
-```
-plot(rand(10,2); marker = :rect)
-savepng(Plots.IMG_DIR * "gadfly1.png")
-```
-
-which saves:
-
-![gadfly_plt](img/gadfly1.png)
-
-
-Do a plot in Qwt, then save a png:
-
-```
-plotter!(:qwt)  # switches the backend to Qwt
-plot(rand(10,2); marker = :rect)
-savepng(Plots.IMG_DIR * "qwt1.png")
-```
-
-which saves:
-
-![qwt_plt](img/qwt1.png)
-
-
-
-## plot and plotter! interface (WIP)
-
-The main plot command.  Call `plotter!(:module)` to set the current plotting backend.
-Commands are converted into the relevant plotting commands for that package:
-
-```
-  plotter!(:gadfly)
-  plot(1:10)    # this effectively calls `y = 1:10; Gadfly.plot(x=1:length(y), y=y)`
-  plotter!(:qwt)
-  plot(1:10)    # this effectively calls `Qwt.plot(1:10)`
-```
-
-Use `plot` to create a new plot object, and `plot!` to add to an existing one:
-
-```
-  plot(args...; kw...)                  # creates a new plot window, and sets it to be the `currentPlot`
-  plot!(args...; kw...)                 # adds to the `currentPlot`
-  plot!(plotobj, args...; kw...)        # adds to the plot `plotobj`
-```
-
-Now that you know which plot object you're updating (new, current, or other), I'll leave it off for simplicity.
-Here are some various args to supply, and the implicit mapping (AVec == AbstractVector and AMat == AbstractMatrix):
-
-```
-  plot(y::AVec; kw...)                       # one line... x = 1:length(y)
-  plot(x::AVec, y::AVec; kw...)              # one line (will assert length(x) == length(y))
-  plot(y::AMat; kw...)                       # multiple lines (one per column of x), all sharing x = 1:size(y,1)
-  plot(x::AVec, y::AMat; kw...)              # multiple lines (one per column of x), all sharing x (will assert length(x) == size(y,1))
-  plot(x::AMat, y::AMat; kw...)              # multiple lines (one per column of x/y... will assert size(x) == size(y))
-  plot(x::AVec, f::Function; kw...)          # one line, y = f(x)
-  plot(x::AMat, f::Function; kw...)          # multiple lines, yᵢⱼ = f(xᵢⱼ)
-  plot(x::AVec, fs::AVec{Function}; kw...)   # multiple lines, yᵢⱼ = fⱼ(xᵢ)
-  plot(y::AVec{AVec}; kw...)                 # multiple lines, each with x = 1:length(y[i])
-  plot(x::AVec, y::AVec{AVec}; kw...)        # multiple lines, will assert length(x) == length(y[i])
-  plot(x::AVec{AVec}, y::AVec{AVec}; kw...)  # multiple lines, will assert length(x[i]) == length(y[i])
-  plot(n::Integer; kw...)                    # n lines, all empty (for updating plots)
-
-  # TODO: how do we handle NA values in dataframes?
-  plot(df::DataFrame; kw...)                 # one line per DataFrame column, labels == names(df)
-  plot(df::DataFrame, columns; kw...)        # one line per column, but on a subset of column names
-```
-
-[TODO] You can swap out `plot` for `subplot`.  Each line will go into a separate plot.  Use the layout keyword:
-
-```
-  y = rand(100,3)
-  subplot(y; layout=(2,2), kw...)           # creates 3 lines going into 3 separate plots, laid out on a 2x2 grid (last row is filled with plot #3)
-  subplot(y; layout=(1,3), kw...)           # again 3 plots, all in the same row
-  subplot(y; layout=[1,[2,3]])              # pass a nested Array to fully specify the layout.  here the first plot will take up the first row, 
-                                            # and the others will share the second row
-```
-
-Shorthands:
-
-```
-  scatter(args...; kw...)    = plot(args...; kw...,  linetype = :none, marker = :hexagon)
-  scatter!(args...; kw...)   = plot!(args...; kw..., linetype = :none, marker = :hexagon)
-  bar(args...; kw...)        = plot(args...; kw...,  linetype = :bar)
-  bar!(args...; kw...)       = plot!(args...; kw..., linetype = :bar)
-  histogram(args...; kw...)  = plot(args...; kw...,  linetype = :hist)
-  histogram!(args...; kw...) = plot!(args...; kw..., linetype = :hist)
-  heatmap(args...; kw...)    = plot(args...; kw...,  linetype = :heatmap)
-  heatmap!(args...; kw...)   = plot!(args...; kw..., linetype = :heatmap)
-```
-
-Some keyword arguments you can set:
-
-```
-  axis            # :left or :right
-  color           # can be a string ("red") or a symbol (:red) or a ColorsTypes.jl Colorant (RGB(1,0,0)) or :auto (which lets the package pick)
-  label           # string or symbol, applies to that line, may go in a legend
-  width           # width of a line
-  linetype        # :line, :step, :stepinverted, :sticks, :dots, :none, :heatmap, :hexbin, :hist, :bar
-  linestyle       # :solid, :dash, :dot, :dashdot, :dashdotdot
-  marker          # :none, :ellipse, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star1, :star2, :hexagon
-  markercolor     # same choices as `color`, or :match will set the color to be the same as `color`
-  markersize      # size of the marker
-  nbins           # number of bins for heatmap/hexbin and histograms
-  heatmap_c       # color cutoffs for Qwt heatmaps
-  fillto          # fillto value for area plots
-  title           # string or symbol, title of the plot
-  xlabel          # string or symbol, label on the bottom (x) axis
-  ylabel          # string or symbol, label on the left (y) axis
-  yrightlabel     # string or symbol, label on the right (y) axis
-  reg             # true or false, add a regression line for each line
-  size            # (Int,Int), resize the enclosing window
-  pos             # (Int,Int), move the enclosing window to this position
-  windowtitle     # string or symbol, set the title of the enclosing windowtitle
-  screen          # Integer, move enclosing window to this screen number (for multiscreen desktops)
-  show            # true or false, show the plot (in case you don't want the window to pop up right away)
-```
-
-If you don't include a keyword argument, these are the defaults:
-  
-```
-  axis = :left
-  color = :auto
-  label = automatically generated (y1, y2, ...., or y1 (R), y2 (R) for the right axis)
-  width = 1
-  linetype = :line
-  linestype = :solid
-  marker = :none
-  markercolor = :match
-  markersize = 3
-  nbins = 100
-  heatmap_c = (0.15, 0.5)
-  fillto = nothing
-  title = ""
-  xlabel = ""
-  ylabel = ""
-  yrightlabel = ""
-  reg = false
-  size = (800,600)
-  pos = (0,0)
-  windowtitle = ""
-  screen = 1
-  show = true
-```
-
-When plotting multiple lines, you can give every line the same trait by using the singular, or add an "s" to pluralize.
-  (yes I know it's not gramatically correct, but it's easy to use and implement)
-
-```
-  plot(rand(100,2); colors = [:red, RGB(.5,.5,0)], axiss = [:left, :right], width = 5)  # note the width=5 is applied to both lines
-```
-
-# TODO
-
-- [x] Plot vectors/matrices/functions
-- [ ] Plot DataFrames
-- [ ] Subplots
-- [ ] Histograms
-- [ ] 3D plotting
-- [ ] Scenes/Drawing
-- [ ] Graphs
-- [ ] Interactivity (GUIs)
-- [x] Gadfly.jl
-- [ ] PyPlot.jl
-- [ ] Winston.jl
-- [ ] Gaston.jl
-- [ ] GLPlot.jl
-- [x] Qwt.jl
-- [ ] Bokeh.jl
-- [ ] Plotly.jl
-- [ ] GoogleCharts.jl
-- [ ] Vega.jl
-- [ ] PLplot.jl
-- [ ] TextPlots.jl
-- [ ] ASCIIPlots.jl
-- [ ] Sparklines.jl
-- [ ] UnicodePlots.jl
-- [ ] Hinton.jl
-- [ ] ImageTerm.jl
-- [ ] GraphViz.jl
-- [ ] TikzGraphs.jl
-- [ ] GraphLayout.jl
-
-# Backends
-
-See the wiki at: https://github.com/JuliaPlot/juliaplot_docs/wiki
-
-# Author
-
-Thomas Breloff (@tbreloff)
+Plots is a plotting API and toolset.  My goals with the package are:
 
+- **Powerful**.  Do more with less.  Complex visualizations become easy.
+- **Intuitive**.  Stop reading so much documentation.  Commands should "just work".
+- **Concise**.  Less code means fewer mistakes and more efficient development/analysis.
+- **Flexible**.  Produce your favorite plots from your favorite package, but quicker and simpler.
+- **Consistent**.  Don't commit to one graphics package, use the same code everywhere.
+- **Lightweight**.  Very few dependencies.
+- **Smart**. Attempts to figure out what you **want** it to do... not just what you **tell** it.

REQUIRE

@@ -1,4 +0,0 @@
-julia 0.4-
-
-Colors
-FactCheck

appveyor.yml

@@ -1,9 +1,18 @@
 environment:
   matrix:
-  - JULIAVERSION: "julialang/bin/winnt/x86/0.3/julia-0.3-latest-win32.exe"
-  - JULIAVERSION: "julialang/bin/winnt/x64/0.3/julia-0.3-latest-win64.exe"
-  - JULIAVERSION: "julianightlies/bin/winnt/x86/julia-latest-win32.exe"
-  - JULIAVERSION: "julianightlies/bin/winnt/x64/julia-latest-win64.exe"
+  # - julia_version: 0.7
+  - julia_version: 1
+  - julia_version: nightly
+
+platform:
+  - x86 # 32-bit
+  - x64 # 64-bit
+
+# # Uncomment the following lines to allow failures on nightly julia
+# # (tests will run but not make your overall status red)
+matrix:
+  allow_failures:
+  - julia_version: nightly
 
 branches:
   only:
@@ -17,18 +26,18 @@ notifications:
     on_build_status_changed: false
 
 install:
-# Download most recent Julia Windows binary
-  - ps: (new-object net.webclient).DownloadFile(
-        $("http://s3.amazonaws.com/"+$env:JULIAVERSION),
-        "C:\projects\julia-binary.exe")
-# Run installer silently, output to C:\projects\julia
-  - C:\projects\julia-binary.exe /S /D=C:\projects\julia
+  - ps: iex ((new-object net.webclient).DownloadString("https://raw.githubusercontent.com/JuliaCI/Appveyor.jl/version-1/bin/install.ps1"))
 
 build_script:
-# Need to convert from shallow to complete for Pkg.clone to work
-  - IF EXIST .git\shallow (git fetch --unshallow)
-  - C:\projects\julia\bin\julia -e "versioninfo();
-      Pkg.clone(pwd(), \"Plots\"); Pkg.build(\"Plots\")"
+  - echo "%JL_BUILD_SCRIPT%"
+  - C:\julia\bin\julia -e "%JL_BUILD_SCRIPT%"
 
 test_script:
-  - C:\projects\julia\bin\julia --check-bounds=yes -e "Pkg.test(\"Plots\")"
+  - echo "%JL_TEST_SCRIPT%"
+  - C:\julia\bin\julia -e "%JL_TEST_SCRIPT%"
+
+# # Uncomment to support code coverage upload. Should only be enabled for packages
+# # which would have coverage gaps without running on Windows
+# on_success:
+#   - echo "%JL_CODECOV_SCRIPT%"
+#   - C:\julia\bin\julia -e "%JL_CODECOV_SCRIPT%"

deps/build.jl

@@ -0,0 +1,18 @@
+
+#TODO: download https://cdn.plot.ly/plotly-latest.min.js to deps/ if it doesn't exist
+file_path = ""
+if get(ENV, "PLOTS_HOST_DEPENDENCY_LOCAL", "false") == "true"
+    global file_path
+    local_fn = joinpath(dirname(@__FILE__), "plotly-latest.min.js")
+    if !isfile(local_fn)
+        @info("Cannot find deps/plotly-latest.min.js... downloading latest version.")
+        download("https://cdn.plot.ly/plotly-latest.min.js", local_fn)
+        isfile(local_fn) && (file_path = local_fn)
+    else
+        file_path = local_fn
+    end
+end
+
+open("deps.jl", "w") do io
+    println(io, "const plotly_local_file_path = $(repr(file_path))")
+end

docs/example_generation.jl

@@ -1,118 +0,0 @@
-
-module PlotExamples
-
-using Plots
-using Colors
-
-const DOCDIR = Pkg.dir("Plots") * "/docs"
-const IMGDIR = Pkg.dir("Plots") * "/img"
-
-doc"""
-Holds all data needed for a documentation example... header, description, and plotting expression (Expr)
-"""
-type PlotExample
-  header::String
-  desc::String
-  exprs::Vector{Expr}
-end
-
-
-# the examples we'll run for each
-const examples = PlotExample[
-  PlotExample("Lines",
-              "A simple line plot of the 3 columns.",
-              [:(plot(rand(100,3)))]),
-  PlotExample("Functions",
-              "Plot multiple functions",
-              [:(plot(0:0.01:4π, [sin,cos]))]),
-  PlotExample("Global",
-              "Change the guides/background without a separate call.",
-              [:(plot(rand(10); title="TITLE", xlabel="XLABEL", ylabel="YLABEL", background_color = RGB(0.5,0.5,0.5)))]),
-  PlotExample("Two-axis",
-              "Use the `axis` or `axiss` arguments.\n\nNote: This is only supported with Qwt right now",
-              [:(plot(Vector[randn(100), randn(100)*100]; axiss = [:left,:right]))]),
-  PlotExample("Vectors w/ pluralized args",
-              "Plot multiple series with different numbers of points.  Mix arguments that apply to all series (singular... see `marker`) with arguments unique to each series (pluralized... see `colors`).",
-              [:(plot(Vector[rand(10), rand(20)]; marker=:ellipse, markersize=8, colors=[:red,:blue]))]),
-  PlotExample("Build plot in pieces",
-              "Start with a base plot...",
-              [:(plot(rand(100)/3; reg=true, fillto=0))]),
-  PlotExample("",
-              "and add to it later.",
-              [:(scatter!(rand(100); markersize=6, color=:blue))]),
-  PlotExample("Heatmaps",
-              "",
-              [:(heatmap(randn(10000),randn(10000); nbins=200))]),
-  PlotExample("Lots of line types",
-              "Options: (:line, :step, :stepinverted, :sticks, :dots, :none, :heatmap, :hexbin, :hist, :bar)  \nNote: some may not work with all backends",
-              [:(plot(rand(20,4); linetypes=[:line, :step, :sticks, :dots]))]),
-  PlotExample("Bar",
-              "x is the midpoint of the bar. (todo: allow passing of edges instead of midpoints)",
-              [:(bar(randn(1000)))]),
-  PlotExample("Histogram",
-              "note: fillto isn't supported on all backends",
-              [:(histogram(randn(1000); nbins=50, fillto=20))]),
-  PlotExample("Subplots",
-              """
-                subplot and subplot! are distinct commands which create many plots and add series to them in a circular fashion.
-                You can define the layout with keyword params... either set the number of plots `n` (and optionally number of rows `nr` or 
-                number of columns `nc`), or you can set the layout directly with `layout`.  
-
-                Note: Gadfly is not very friendly here, and although you can create a plot and save a PNG, I haven't been able to actually display it.
-              """,
-              [:(subplot(randn(100,5); layout=[1,1,3], linetypes=[:line,:hist,:dots,:step,:bar], nbins=10, legend=false))]),
-  PlotExample("Adding to subplots",
-              "Note here the automatic grid layout, as well as the order in which new series are added to the plots.",
-              [:(subplot(randn(100,5); n=4))]),
-  PlotExample("",
-              "",
-              [:(subplot!(randn(100,3)))]),
-
-  
-]
-
-
-function generate_markdown(pkgname::Symbol)
-
-  # set up the plotter, and don't show the plots by default
-  plotter!(pkgname)
-  plotDefault!(:show, false)
-
-  # open the markdown file
-  md = open("$DOCDIR/$(pkgname)_examples.md", "w")
-
-  for (i,example) in enumerate(examples)
-
-    try
-
-      # run the code
-      map(eval, example.exprs)
-
-      # save the png
-      imgname = "$(pkgname)_example_$i.png"
-      savepng("$IMGDIR/$imgname")
-
-      # write out the header, description, code block, and image link
-      write(md, "### $(example.header)\n\n")
-      write(md, "$(example.desc)\n\n")
-      write(md, "```julia\n$(join(map(string, example.exprs), "\n"))\n```\n\n")
-      write(md, "![](../img/$imgname)\n\n")
-
-    catch ex
-      # TODO: put error info into markdown?
-      warn("Example $pkgname:$i failed with: $ex")
-    end
-
-    #
-  end
-
-  close(md)
-
-end
-
-# run it!
-map(generate_markdown, (:qwt, :gadfly))
-
-
-end # module
-

docs/gadfly_examples.md

@@ -1,148 +0,0 @@
-### Lines
-
-A simple line plot of the 3 columns.
-
-```julia
-plot(rand(100,3))
-```
-
-![](../img/gadfly_example_1.png)
-
-### Functions
-
-Plot multiple functions
-
-```julia
-plot(0:0.01:4π,[sin,cos])
-```
-
-![](../img/gadfly_example_2.png)
-
-### Global
-
-Change the guides/background without a separate call.
-
-```julia
-plot(rand(10); title="TITLE",xlabel="XLABEL",ylabel="YLABEL",background_color=RGB(0.5,0.5,0.5))
-```
-
-![](../img/gadfly_example_3.png)
-
-### Two-axis
-
-Use the `axis` or `axiss` arguments.
-
-Note: This is only supported with Qwt right now
-
-```julia
-plot(Vector[randn(100),randn(100) * 100]; axiss=[:left,:right])
-```
-
-![](../img/gadfly_example_4.png)
-
-### Vectors w/ pluralized args
-
-Plot multiple series with different numbers of points.  Mix arguments that apply to all series (singular... see `marker`) with arguments unique to each series (pluralized... see `colors`).
-
-```julia
-plot(Vector[rand(10),rand(20)]; marker=:ellipse,markersize=8,colors=[:red,:blue])
-```
-
-![](../img/gadfly_example_5.png)
-
-### Build plot in pieces
-
-Start with a base plot...
-
-```julia
-plot(rand(100) / 3; reg=true,fillto=0)
-```
-
-![](../img/gadfly_example_6.png)
-
-### 
-
-and add to it later.
-
-```julia
-scatter!(rand(100); markersize=6,color=:blue)
-```
-
-![](../img/gadfly_example_7.png)
-
-### Heatmaps
-
-
-
-```julia
-heatmap(randn(10000),randn(10000); nbins=200)
-```
-
-![](../img/gadfly_example_8.png)
-
-### Lots of line types
-
-Options: (:line, :step, :stepinverted, :sticks, :dots, :none, :heatmap, :hexbin, :hist, :bar)  
-Note: some may not work with all backends
-
-```julia
-plot(rand(20,4); linetypes=[:line,:step,:sticks,:dots])
-```
-
-![](../img/gadfly_example_9.png)
-
-### Bar
-
-x is the midpoint of the bar. (todo: allow passing of edges instead of midpoints)
-
-```julia
-bar(randn(1000))
-```
-
-![](../img/gadfly_example_10.png)
-
-### Histogram
-
-note: fillto isn't supported on all backends
-
-```julia
-histogram(randn(1000); nbins=50,fillto=20)
-```
-
-![](../img/gadfly_example_11.png)
-
-### Subplots
-
-  subplot and subplot! are distinct commands which create many plots and add series to them in a circular fashion.
-  You can define the layout with keyword params... either set the number of plots `n` (and optionally number of rows `nr` or 
-  number of columns `nc`), or you can set the layout directly with `layout`.  
-
-  Note: Gadfly is not very friendly here, and although you can create a plot and save a PNG, I haven't been able to actually display it.
-
-
-```julia
-subplot(randn(100,5); layout=[1,1,3],linetypes=[:line,:hist,:dots,:step,:bar],nbins=10,legend=false)
-```
-
-![](../img/gadfly_example_12.png)
-
-### Adding to subplots
-
-Note here the automatic grid layout, as well as the order in which new series are added to the plots.
-
-```julia
-subplot(randn(100,5); n=4)
-```
-
-![](../img/gadfly_example_13.png)
-
-### 
-
-
-
-```julia
-subplot!(randn(100,3))
-```
-
-![](../img/gadfly_example_14.png)
-

docs/qwt_examples.md

@@ -1,148 +0,0 @@
-### Lines
-
-A simple line plot of the 3 columns.
-
-```julia
-plot(rand(100,3))
-```
-
-![](../img/qwt_example_1.png)
-
-### Functions
-
-Plot multiple functions
-
-```julia
-plot(0:0.01:4π,[sin,cos])
-```
-
-![](../img/qwt_example_2.png)
-
-### Global
-
-Change the guides/background without a separate call.
-
-```julia
-plot(rand(10); title="TITLE",xlabel="XLABEL",ylabel="YLABEL",background_color=RGB(0.5,0.5,0.5))
-```
-
-![](../img/qwt_example_3.png)
-
-### Two-axis
-
-Use the `axis` or `axiss` arguments.
-
-Note: This is only supported with Qwt right now
-
-```julia
-plot(Vector[randn(100),randn(100) * 100]; axiss=[:left,:right])
-```
-
-![](../img/qwt_example_4.png)
-
-### Vectors w/ pluralized args
-
-Plot multiple series with different numbers of points.  Mix arguments that apply to all series (singular... see `marker`) with arguments unique to each series (pluralized... see `colors`).
-
-```julia
-plot(Vector[rand(10),rand(20)]; marker=:ellipse,markersize=8,colors=[:red,:blue])
-```
-
-![](../img/qwt_example_5.png)
-
-### Build plot in pieces
-
-Start with a base plot...
-
-```julia
-plot(rand(100) / 3; reg=true,fillto=0)
-```
-
-![](../img/qwt_example_6.png)
-
-### 
-
-and add to it later.
-
-```julia
-scatter!(rand(100); markersize=6,color=:blue)
-```
-
-![](../img/qwt_example_7.png)
-
-### Heatmaps
-
-
-
-```julia
-heatmap(randn(10000),randn(10000); nbins=200)
-```
-
-![](../img/qwt_example_8.png)
-
-### Lots of line types
-
-Options: (:line, :step, :stepinverted, :sticks, :dots, :none, :heatmap, :hexbin, :hist, :bar)  
-Note: some may not work with all backends
-
-```julia
-plot(rand(20,4); linetypes=[:line,:step,:sticks,:dots])
-```
-
-![](../img/qwt_example_9.png)
-
-### Bar
-
-x is the midpoint of the bar. (todo: allow passing of edges instead of midpoints)
-
-```julia
-bar(randn(1000))
-```
-
-![](../img/qwt_example_10.png)
-
-### Histogram
-
-note: fillto isn't supported on all backends
-
-```julia
-histogram(randn(1000); nbins=50,fillto=20)
-```
-
-![](../img/qwt_example_11.png)
-
-### Subplots
-
-  subplot and subplot! are distinct commands which create many plots and add series to them in a circular fashion.
-  You can define the layout with keyword params... either set the number of plots `n` (and optionally number of rows `nr` or 
-  number of columns `nc`), or you can set the layout directly with `layout`.  
-
-  Note: Gadfly is not very friendly here, and although you can create a plot and save a PNG, I haven't been able to actually display it.
-
-
-```julia
-subplot(randn(100,5); layout=[1,1,3],linetypes=[:line,:hist,:dots,:step,:bar],nbins=10,legend=false)
-```
-
-![](../img/qwt_example_12.png)
-
-### Adding to subplots
-
-Note here the automatic grid layout, as well as the order in which new series are added to the plots.
-
-```julia
-subplot(randn(100,5); n=4)
-```
-
-![](../img/qwt_example_13.png)
-
-### 
-
-
-
-```julia
-subplot!(randn(100,3))
-```
-
-![](../img/qwt_example_14.png)
-

pushtomaster.sh

@@ -0,0 +1,4 @@
+git checkout master
+git merge --ff-only dev
+git push origin master
+git checkout dev

src/Plots.jl

@@ -1,77 +1,226 @@
-__precompile__()
-
 module Plots
 
-using Colors
+_current_plots_version = v"0.26.1"
+
+using Reexport
+
+import GeometryTypes
+using Dates, Printf, Statistics, Base64, LinearAlgebra, Random
+import SparseArrays: findnz
+
+using FFMPEG
+
+@reexport using RecipesBase
+import RecipesBase: plot, plot!, animate
+using Base.Meta
+@reexport using PlotUtils
+@reexport using PlotThemes
+import Showoff
+import StatsBase
+import JSON
+
+using Requires
+
+if isfile(joinpath(@__DIR__, "..", "deps", "deps.jl"))
+    include(joinpath(@__DIR__, "..", "deps", "deps.jl"))
+else
+    # This is a bit dirty, but I don't really see why anyone should be forced
+    # to build Plots, while it will just include exactly the below line
+    # as long as `ENV["PLOTS_HOST_DEPENDENCY_LOCAL"] = "true"` is not set.
+    # If the above env is set + `plotly_local_file_path == ""``,
+    # it will warn in the __init__ function to run build
+    const plotly_local_file_path = ""
+end
 
 export
-  plotter,
-  plot,
-  subplot,
+    grid,
+    bbox,
+    plotarea,
+    @layout,
+    KW,
 
-  plotter!,
-  plot!,
-  subplot!,
+    wrap,
+    theme,
 
-  currentPlot,
-  plotDefault,
-  scatter,
-  bar,
-  histogram,
-  heatmap,
+    plot,
+    plot!,
+    attr!,
 
-  currentPlot!,
-  plotDefault!,
-  scatter!,
-  bar!,
-  histogram!,
-  heatmap!,
+    current,
+    default,
+    with,
+    twinx,
 
-  savepng
+    pie,
+    pie!,
+    plot3d,
+    plot3d!,
+
+    title!,
+    xlabel!,
+    ylabel!,
+    xlims!,
+    ylims!,
+    zlims!,
+    xticks!,
+    yticks!,
+    annotate!,
+    xflip!,
+    yflip!,
+    xaxis!,
+    yaxis!,
+    xgrid!,
+    ygrid!,
+
+    xlims,
+    ylims,
+    zlims,
+
+    savefig,
+    png,
+    gui,
+    inline,
+    closeall,
+
+    backend,
+    backends,
+    backend_name,
+    backend_object,
+    aliases,
+
+    Shape,
+    text,
+    font,
+    stroke,
+    brush,
+    Surface,
+    OHLC,
+    arrow,
+    Segments,
+    Formatted,
+
+    Animation,
+    frame,
+    gif,
+    mov,
+    mp4,
+    animate,
+    @animate,
+    @gif,
+
+    test_examples,
+    iter_segments,
+    coords,
+
+    translate,
+    translate!,
+    rotate,
+    rotate!,
+    center,
+    BezierCurve,
+
+    plotattr
 
 # ---------------------------------------------------------
 
+import NaNMath # define functions that ignores NaNs. To overcome the destructive effects of https://github.com/JuliaLang/julia/pull/12563
+ignorenan_minimum(x::AbstractArray{F}) where {F<:AbstractFloat} = NaNMath.minimum(x)
+ignorenan_minimum(x) = Base.minimum(x)
+ignorenan_maximum(x::AbstractArray{F}) where {F<:AbstractFloat} = NaNMath.maximum(x)
+ignorenan_maximum(x) = Base.maximum(x)
+ignorenan_mean(x::AbstractArray{F}) where {F<:AbstractFloat} = NaNMath.mean(x)
+ignorenan_mean(x) = Statistics.mean(x)
+ignorenan_extrema(x::AbstractArray{F}) where {F<:AbstractFloat} = NaNMath.extrema(x)
+ignorenan_extrema(x) = Base.extrema(x)
 
-const IMG_DIR = Pkg.dir("Plots") * "/img/"
+# ---------------------------------------------------------
+
+# to cater for block matrices, Base.transpose is recursive.
+# This makes it impossible to create row vectors of String and Symbol with the transpose operator.
+# This solves this issue, internally in Plots at least.
 
 
+# commented out on the insistence of the METADATA maintainers
+
+#Base.transpose(x::Symbol) = x
+#Base.transpose(x::String) = x
+
+# ---------------------------------------------------------
+
+import Measures
+module PlotMeasures
+import Measures
+import Measures: Length, AbsoluteLength, Measure, BoundingBox, mm, cm, inch, pt, width, height, w, h
+const BBox = Measures.Absolute2DBox
+
+# allow pixels and percentages
+const px = AbsoluteLength(0.254)
+const pct = Length{:pct, Float64}(1.0)
+export BBox, BoundingBox, mm, cm, inch, px, pct, pt, w, h
+end
+
+using .PlotMeasures
+import .PlotMeasures: Length, AbsoluteLength, Measure, width, height
 # ---------------------------------------------------------
 
 include("types.jl")
 include("utils.jl")
-
-# ---------------------------------------------------------
-
-include("qwt.jl")
-include("gadfly.jl")
-include("plotter.jl")
-
-# ---------------------------------------------------------
-
+include("components.jl")
+include("axes.jl")
 include("args.jl")
+include("themes.jl")
 include("plot.jl")
-include("subplot.jl")
+include("pipeline.jl")
+include("series.jl")
+include("layouts.jl")
+include("subplots.jl")
+include("recipes.jl")
+include("animation.jl")
+include("examples.jl")
+include("arg_desc.jl")
+include("plotattr.jl")
+include("backends.jl")
+include("output.jl")
+include("ijulia.jl")
+include("fileio.jl")
+include("init.jl")
+
+include("backends/plotly.jl")
+include("backends/gr.jl")
+include("backends/web.jl")
+
+include("shorthands.jl")
+
+let PlotOrSubplot = Union{Plot, Subplot}
+    global title!(plt::PlotOrSubplot, s::AbstractString; kw...)                  = plot!(plt; title = s, kw...)
+    global xlabel!(plt::PlotOrSubplot, s::AbstractString; kw...)                 = plot!(plt; xlabel = s, kw...)
+    global ylabel!(plt::PlotOrSubplot, s::AbstractString; kw...)                 = plot!(plt; ylabel = s, kw...)
+    global xlims!(plt::PlotOrSubplot, lims::Tuple{T,S}; kw...) where {T<:Real,S<:Real}  = plot!(plt; xlims = lims, kw...)
+    global ylims!(plt::PlotOrSubplot, lims::Tuple{T,S}; kw...) where {T<:Real,S<:Real}  = plot!(plt; ylims = lims, kw...)
+    global zlims!(plt::PlotOrSubplot, lims::Tuple{T,S}; kw...) where {T<:Real,S<:Real}  = plot!(plt; zlims = lims, kw...)
+    global xlims!(plt::PlotOrSubplot, xmin::Real, xmax::Real; kw...)             = plot!(plt; xlims = (xmin,xmax), kw...)
+    global ylims!(plt::PlotOrSubplot, ymin::Real, ymax::Real; kw...)             = plot!(plt; ylims = (ymin,ymax), kw...)
+    global zlims!(plt::PlotOrSubplot, zmin::Real, zmax::Real; kw...)             = plot!(plt; zlims = (zmin,zmax), kw...)
+    global xticks!(plt::PlotOrSubplot, ticks::TicksArgs; kw...) where {T<:Real}           = plot!(plt; xticks = ticks, kw...)
+    global yticks!(plt::PlotOrSubplot, ticks::TicksArgs; kw...) where {T<:Real}           = plot!(plt; yticks = ticks, kw...)
+    global xticks!(plt::PlotOrSubplot,
+   ticks::AVec{T}, labels::AVec{S}; kw...) where {T<:Real,S<:AbstractString}     = plot!(plt; xticks = (ticks,labels), kw...)
+    global yticks!(plt::PlotOrSubplot,
+   ticks::AVec{T}, labels::AVec{S}; kw...) where {T<:Real,S<:AbstractString}     = plot!(plt; yticks = (ticks,labels), kw...)
+    global xgrid!(plt::PlotOrSubplot, args...; kw...)                  = plot!(plt; xgrid = args, kw...)
+    global ygrid!(plt::PlotOrSubplot, args...; kw...)                  = plot!(plt; ygrid = args, kw...)
+    global annotate!(plt::PlotOrSubplot, anns...; kw...)                         = plot!(plt; annotation = anns, kw...)
+    global annotate!(plt::PlotOrSubplot, anns::AVec{T}; kw...) where {T<:Tuple}         = plot!(plt; annotation = anns, kw...)
+    global xflip!(plt::PlotOrSubplot, flip::Bool = true; kw...)                  = plot!(plt; xflip = flip, kw...)
+    global yflip!(plt::PlotOrSubplot, flip::Bool = true; kw...)                  = plot!(plt; yflip = flip, kw...)
+    global xaxis!(plt::PlotOrSubplot, args...; kw...)                            = plot!(plt; xaxis = args, kw...)
+    global yaxis!(plt::PlotOrSubplot, args...; kw...)                            = plot!(plt; yaxis = args, kw...)
+end
 
 
 # ---------------------------------------------------------
 
-scatter(args...; kw...)    = plot(args...; kw...,  linetype = :none, marker = :hexagon)
-scatter!(args...; kw...)   = plot!(args...; kw..., linetype = :none, marker = :hexagon)
-bar(args...; kw...)        = plot(args...; kw...,  linetype = :bar)
-bar!(args...; kw...)       = plot!(args...; kw..., linetype = :bar)
-histogram(args...; kw...)  = plot(args...; kw...,  linetype = :hist)
-histogram!(args...; kw...) = plot!(args...; kw..., linetype = :hist)
-heatmap(args...; kw...)    = plot(args...; kw...,  linetype = :heatmap)
-heatmap!(args...; kw...)   = plot!(args...; kw..., linetype = :heatmap)
-
-
-# ---------------------------------------------------------
-
-
-savepng(args...; kw...) = savepng(currentPlot(), args...; kw...)
-savepng(plt::PlottingObject, args...; kw...) = savepng(plt.plotter, plt, args...; kw...)
-
-
-# ---------------------------------------------------------
+const CURRENT_BACKEND = Plots.CurrentBackend(:gr)
+gr()
 
 end # module

src/animation.jl

@@ -0,0 +1,205 @@
+"Represents an animation object"
+struct Animation
+    dir::String
+    frames::Vector{String}
+end
+
+function Animation()
+    tmpdir = convert(String, mktempdir())
+    Animation(tmpdir, String[])
+end
+
+"""
+    frame(animation[, plot])
+
+Add a plot (the current plot if not specified) to an existing animation
+"""
+function frame(anim::Animation, plt::P=current()) where P<:AbstractPlot
+    i = length(anim.frames) + 1
+    filename = @sprintf("%06d.png", i)
+    png(plt, joinpath(anim.dir, filename))
+    push!(anim.frames, filename)
+end
+
+giffn() = (isijulia() ? "tmp.gif" : tempname()*".gif")
+movfn() = (isijulia() ? "tmp.mov" : tempname()*".mov")
+mp4fn() = (isijulia() ? "tmp.mp4" : tempname()*".mp4")
+
+mutable struct FrameIterator
+    itr
+    every::Int
+    kw
+end
+FrameIterator(itr; every=1, kw...) = FrameIterator(itr, every, kw)
+
+"""
+Animate from an iterator which returns the plot args each iteration.
+"""
+function animate(fitr::FrameIterator, fn = giffn(); kw...)
+    anim = Animation()
+    for (i, plotargs) in enumerate(fitr.itr)
+        if mod1(i, fitr.every) == 1
+            plot(wraptuple(plotargs)...; fitr.kw...)
+            frame(anim)
+        end
+    end
+    gif(anim, fn; kw...)
+end
+
+# most things will implement this
+function animate(obj, fn = giffn(); every=1, fps=20, loop=0, kw...)
+    animate(FrameIterator(obj, every, kw), fn; fps=fps, loop=loop)
+end
+
+# -----------------------------------------------
+
+"Wraps the location of an animated gif so that it can be displayed"
+struct AnimatedGif
+    filename::String
+end
+
+file_extension(fn) = Base.Filesystem.splitext(fn)[2][2:end]
+
+gif(anim::Animation, fn = giffn(); kw...) = buildanimation(anim, fn; kw...)
+mov(anim::Animation, fn = movfn(); kw...) = buildanimation(anim, fn, false; kw...)
+mp4(anim::Animation, fn = mp4fn(); kw...) = buildanimation(anim, fn, false; kw...)
+
+
+function buildanimation(anim::Animation, fn::AbstractString,
+                        is_animated_gif::Bool=true;
+                        fps::Integer = 20, loop::Integer = 0,
+                        variable_palette::Bool=false,
+                        show_msg::Bool=true)
+    if length(anim.frames) == 0
+        throw(ArgumentError("Cannot build empty animations"))
+    end
+
+    fn = abspath(expanduser(fn))
+    animdir = anim.dir
+
+    if is_animated_gif
+        if variable_palette
+            # generate a colorpalette for each frame for highest quality, but larger filesize
+            palette="palettegen=stats_mode=single[pal],[0:v][pal]paletteuse=new=1"
+            ffmpeg_exe(`-v 0 -framerate $fps -loop $loop -i $(animdir)/%06d.png -lavfi "$palette" -y $fn`)
+        else
+            # generate a colorpalette first so ffmpeg does not have to guess it
+            ffmpeg_exe(`-v 0 -i $(animdir)/%06d.png -vf "palettegen=stats_mode=diff" -y "$(animdir)/palette.bmp"`)
+            # then apply the palette to get better results
+            ffmpeg_exe(` -v 0 -framerate $fps -loop $loop -i $(animdir)/%06d.png -i "$(animdir)/palette.bmp" -lavfi "paletteuse=dither=sierra2_4a" -y $fn`)
+        end
+    else
+        ffmpeg_exe(`-v 0 -framerate $fps -loop $loop -i $(animdir)/%06d.png -pix_fmt yuv420p -y $fn`)
+    end
+
+    show_msg && @info("Saved animation to ", fn)
+    AnimatedGif(fn)
+end
+
+
+
+# write out html to view the gif
+function Base.show(io::IO, ::MIME"text/html", agif::AnimatedGif)
+    ext = file_extension(agif.filename)
+    write(io, if ext == "gif"
+        "<img src=\"$(relpath(agif.filename))\" />"
+    elseif ext in ("mov", "mp4")
+        "<video controls><source src=\"$(relpath(agif.filename)) type=\"video/$ext\"></video>"
+    else
+        error("Cannot show animation with extension $ext: $agif")
+    end)
+    return nothing
+end
+
+
+# Only gifs can be shown via image/gif
+Base.showable(::MIME"image/gif", agif::AnimatedGif) = file_extension(agif.filename) == "gif"
+
+function Base.show(io::IO, ::MIME"image/gif", agif::AnimatedGif)
+    open(fio-> write(io, fio), agif.filename)
+end
+
+
+# -----------------------------------------------
+
+function _animate(forloop::Expr, args...; callgif = false)
+  if forloop.head != :for
+    error("@animate macro expects a for-block. got: $(forloop.head)")
+  end
+
+  # add the call to frame to the end of each iteration
+  animsym = gensym("anim")
+  countersym = gensym("counter")
+  freqassert = :()
+  block = forloop.args[2]
+
+  # create filter
+  n = length(args)
+  filterexpr = if n == 0
+    # no filter... every iteration gets a frame
+    true
+
+  elseif args[1] == :every
+    # filter every `freq` frames (starting with the first frame)
+    @assert n == 2
+    freq = args[2]
+    freqassert = :(@assert isa($freq, Integer) && $freq > 0)
+    :(mod1($countersym, $freq) == 1)
+
+  elseif args[1] == :when
+    # filter on custom expression
+    @assert n == 2
+    args[2]
+
+  else
+    error("Unsupported animate filter: $args")
+  end
+
+  push!(block.args, :(if $filterexpr; frame($animsym); end))
+  push!(block.args, :(global $countersym += 1))
+
+  # add a final call to `gif(anim)`?
+  retval = callgif ? :(gif($animsym)) : animsym
+
+  # full expression:
+  esc(quote
+    $freqassert             # if filtering, check frequency is an Integer > 0
+    $animsym = Animation()  # init animation object
+    global $countersym = 1         # init iteration counter
+    $forloop                # for loop, saving a frame after each iteration
+    $retval                 # return the animation object, or the gif
+  end)
+end
+
+"""
+Builds an `Animation` using one frame per loop iteration, then create an animated GIF.
+
+Example:
+
+```
+  p = plot(1)
+  @gif for x=0:0.1:5
+    push!(p, 1, sin(x))
+  end
+```
+"""
+macro gif(forloop::Expr, args...)
+    _animate(forloop, args...; callgif = true)
+end
+
+"""
+Collect one frame per for-block iteration and return an `Animation` object.
+
+Example:
+
+```
+p = plot(1)
+anim = @animate for x=0:0.1:5
+    push!(p, 1, sin(x))
+end
+gif(anim)
+```
+"""
+macro animate(forloop::Expr, args...)
+    _animate(forloop, args...)
+end

src/arg_desc.jl

@@ -0,0 +1,155 @@
+
+const _arg_desc = Dict{Symbol,String}(
+
+# series args
+:label 			=> "String type. The label for a series, which appears in a legend.  If empty, no legend entry is added.",
+:seriescolor 		=> "Color Type. The base color for this series.  `:auto` (the default) will select a color from the subplot's `color_palette`, based on the order it was added to the subplot",
+:seriesalpha 		=> "Number in [0,1]. The alpha/opacity override for the series.  `nothing` (the default) means it will take the alpha value of the color.",
+:seriestype 		=> "Symbol. This is the identifier of the type of visualization for this series. Choose from $(_allTypes) or any series recipes which are defined.",
+:linestyle 			=> "Symbol. Style of the line (for path and bar stroke).  Choose from $(_allStyles)",
+:linewidth         	=> "Number. Width of the line (in pixels)",
+:linecolor         	=> "Color Type. Color of the line (for path and bar stroke).  `:match` will take the value from `:seriescolor`, (though histogram/bar types use `:black` as a default).",
+:linealpha         	=> "Number in [0,1]. The alpha/opacity override for the line.  `nothing` (the default) means it will take the alpha value of linecolor.",
+:fillrange         	=> "Number or AbstractVector.  Fills area between fillrange and y for line-types, sets the base for bar/stick types, and similar for other types.",
+:fillcolor         	=> "Color Type. Color of the filled area of path or bar types.  `:match` will take the value from `:seriescolor`.",
+:fillalpha         	=> "Number in [0,1]. The alpha/opacity override for the fill area.  `nothing` (the default) means it will take the alpha value of fillcolor.",
+:markershape       	=> "Symbol, Shape, or AbstractVector. Choose from $(_allMarkers).",
+:markercolor       	=> "Color Type. Color of the interior of the marker or shape. `:match` will take the value from `:seriescolor`.",
+:markeralpha       	=> "Number in [0,1]. The alpha/opacity override for the marker interior.  `nothing` (the default) means it will take the alpha value of markercolor.",
+:markersize        	=> "Number or AbstractVector. Size (radius pixels) of the markers.",
+:markerstrokestyle 	=> "Symbol. Style of the marker stroke (border).  Choose from $(_allStyles)",
+:markerstrokewidth 	=> "Number. Width of the marker stroke (border. in pixels)",
+:markerstrokecolor 	=> "Color Type. Color of the marker stroke (border).  `:match` will take the value from `:foreground_color_subplot`.",
+:markerstrokealpha 	=> "Number in [0,1]. The alpha/opacity override for the marker stroke (border).  `nothing` (the default) means it will take the alpha value of markerstrokecolor.",
+:bins              	=> "Integer, NTuple{2,Integer}, AbstractVector or Symbol. Default is :auto (the Freedman-Diaconis rule). For histogram-types, defines the approximate number of bins to aim for, or the auto-binning algorithm to use (:sturges, :sqrt, :rice, :scott or :fd). For fine-grained control pass a Vector of break values, e.g. `range(minimum(x), stop = maximum(x), length = 25)`",
+:smooth            	=> "Bool.  Add a regression line?",
+:group             	=> "AbstractVector. Data is split into a separate series, one for each unique value in `group`.",
+:x                 	=> "Various. Input data. First Dimension",
+:y                 	=> "Various. Input data. Second Dimension",
+:z                 	=> "Various. Input data. Third Dimension. May be wrapped by a `Surface` for surface and heatmap types.",
+:marker_z          	=> "AbstractVector, Function `f(x,y,z) -> z_value`, or Function `f(x,y) -> z_value`, or nothing. z-values for each series data point, which correspond to the color to be used from a markercolor gradient.",
+:line_z          	=> "AbstractVector, Function `f(x,y,z) -> z_value`, or Function `f(x,y) -> z_value`, or nothing. z-values for each series line segment, which correspond to the color to be used from a linecolor gradient.  Note that for N points, only the first N-1 values are used (one per line-segment).",
+:fill_z                 => "Matrix{Float64} of the same size as z matrix, which specifies the color of the 3D surface; the default value is `nothing`.",
+:levels            	=> "Integer, NTuple{2,Integer}, or AbstractVector. Levels or number of levels (or x-levels/y-levels) for a contour type.",
+:orientation       	=> "Symbol.  Horizontal or vertical orientation for bar types.  Values `:h`, `:hor`, `:horizontal` correspond to horizontal (sideways, anchored to y-axis), and `:v`, `:vert`, and `:vertical` correspond to vertical (the default).",
+:bar_position      	=> "Symbol.  Choose from `:overlay` (default), `:stack`.  (warning: May not be implemented fully)",
+:bar_width              => "nothing or Number. Width of bars in data coordinates. When nothing, chooses based on x (or y when `orientation = :h`).",
+:bar_edges              => "Bool.  Align bars to edges (true), or centers (the default)?",
+:xerror                 => "AbstractVector or 2-Tuple of Vectors. x (horizontal) error relative to x-value.  If 2-tuple of vectors, the first vector corresponds to the left error (and the second to the right)",
+:yerror            	=> "AbstractVector or 2-Tuple of Vectors. y (vertical) error relative to y-value.  If 2-tuple of vectors, the first vector corresponds to the bottom error (and the second to the top)",
+:ribbon            	=> "Number or AbstractVector.  Creates a fillrange around the data points.",
+:quiver            	=> "AbstractVector or 2-Tuple of vectors.  The directional vectors U,V which specify velocity/gradient vectors for a quiver plot.",
+:arrow             	=> "nothing (no arrows), Bool (if true, default arrows), Arrow object, or arg(s) that could be style or head length/widths.  Defines arrowheads that should be displayed at the end of path line segments (just before a NaN and the last non-NaN point).  Used in quiverplot, streamplot, or similar.",
+:normalize         	=> "Bool or Symbol. Histogram normalization mode. Possible values are: false/:none (no normalization, default), true/:pdf (normalize to a discrete Probability Density Function, where the total area of the bins is 1), :probability (bin heights sum to 1) and :density (the area of each bin, rather than the height, is equal to the counts - useful for uneven bin sizes).",
+:weights           	=> "AbstractVector. Used in histogram types for weighted counts.",
+:contours          	=> "Bool. Add contours to the side-grids of 3D plots?  Used in surface/wireframe.",
+:contour_labels         => "Bool. Show labels at the contour lines?",
+:match_dimensions  	=> "Bool. For heatmap types... should the first dimension of a matrix (rows) correspond to the first dimension of the plot (x-axis)?  The default is false, which matches the behavior of Matplotlib, Plotly, and others.  Note: when passing a function for z, the function should still map `(x,y) -> z`.",
+:subplot           	=> "Integer (subplot index) or Subplot object.  The subplot that this series belongs to.",
+:series_annotations     => "AbstractVector of String or PlotText.  These are annotations which are mapped to data points/positions.",
+:primary                => "Bool.  Does this count as a 'real series'?  For example, you could have a path (primary), and a scatter (secondary) as 2 separate series, maybe with different data (see sticks recipe for an example).  The secondary series will get the same color, etc as the primary.",
+:hover 	        	=> "nothing or vector of strings. Text to display when hovering over each data point.",
+:colorbar_entry   => "Bool.  Include this series in the color bar?  Set to `false` to exclude.",
+
+# plot args
+:plot_title               => "String. Title for the whole plot (not the subplots) (Note: Not currently implemented)",
+:background_color         => "Color Type.  Base color for all backgrounds.",
+:background_color_outside => "Color Type or `:match` (matches `:background_color`).  Color outside the plot area(s)",
+:foreground_color         => "Color Type.  Base color for all foregrounds.",
+:size                     => "NTuple{2,Int}. (width_px, height_px) of the whole Plot",
+:pos                      => "NTuple{2,Int}. (left_px, top_px) position of the GUI window (note: currently unimplemented)",
+:window_title             => "String. Title of the window.",
+:show                     => "Bool.  Should this command open/refresh a GUI/display?  This allows displaying in scripts or functions without explicitly calling `display`",
+:layout                   => "Integer (number of subplots), NTuple{2,Integer} (grid dimensions), AbstractLayout (for example `grid(2,2)`), or the return from the `@layout` macro.  This builds the layout of subplots.",
+:link                     => "Symbol.  How/whether to link axis limits between subplots. Values: `:none`, `:x` (x axes are linked by columns), `:y` (y axes are linked by rows), `:both` (x and y are linked), `:all` (every subplot is linked together regardless of layout position).",
+:overwrite_figure         => "Bool.  Should we reuse the same GUI window/figure when plotting (true) or open a new one (false).",
+:html_output_format       => "Symbol.  When writing html output, what is the format?  `:png` and `:svg` are currently supported.",
+:tex_output_standalone    => "Bool. When writing tex output, should the source include a preamble for a standalone document class.",
+:inset_subplots           => "nothing or vector of 2-tuple (parent,bbox).  optionally pass a vector of (parent,bbox) tuples which are the parent layout and the relative bounding box of inset subplots",
+:dpi 			  => "Number.  Dots Per Inch of output figures",
+:thickness_scaling        => "Number. Scale for the thickness of all line elements like lines, borders, axes, grid lines, ... defaults to 1.",
+:display_type             => "Symbol (`:auto`, `:gui`, or `:inline`).  When supported, `display` will either open a GUI window or plot inline.",
+:extra_kwargs 	          => "KW (Dict{Symbol,Any}).  Pass a map of extra keyword args which may be specific to a backend.",
+:fontfamily               => "String or Symbol.  Default font family for title, legend entries, tick labels and guides",
+
+# subplot args
+:title                    => "String. Subplot title.",
+:title_location           => "Symbol. Position of subplot title. Values: `:left`, `:center`, `:right`",
+:titlefontfamily          => "String or Symbol. Font family of subplot title.",
+:titlefontsize            => "Integer. Font pointsize of subplot title.",
+:titlefonthalign          => "Symbol. Font horizontal alignment of subplot title: :hcenter, :left, :right or :center",
+:titlefontvalign          => "Symbol. Font vertical alignment of subplot title: :vcenter, :top, :bottom or :center",
+:titlefontrotation        => "Real. Font rotation of subplot title",
+:titlefontcolor           => "Color Type. Font color of subplot title",
+:background_color_subplot => "Color Type or `:match` (matches `:background_color`).  Base background color of the subplot.",
+:background_color_legend  => "Color Type or `:match` (matches `:background_color_subplot`).  Background color of the legend.",
+:background_color_inside  => "Color Type or `:match` (matches `:background_color_subplot`).  Background color inside the plot area (under the grid).",
+:foreground_color_subplot => "Color Type or `:match` (matches `:foreground_color`).  Base foreground color of the subplot.",
+:foreground_color_legend  => "Color Type or `:match` (matches `:foreground_color_subplot`).  Foreground color of the legend.",
+:foreground_color_title   => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of subplot title.",
+:color_palette            => "Vector of colors (cycle through) or color gradient (generate list from gradient) or `:auto` (generate a color list using `Colors.distiguishable_colors` and custom seed colors chosen to contrast with the background).  The color palette is a color list from which series colors are automatically chosen.",
+:legend                   => "Bool (show the legend?) or Symbol (legend position).  Symbol values: `:none`, `:best`, `:right`, `:left`, `:top`, `:bottom`, `:inside`, `:legend`, `:topright`, `:topleft`, `:bottomleft`, `:bottomright` (note: only some may be supported in each backend)",
+:legendfontfamily         => "String or Symbol. Font family of legend entries.",
+:legendfontsize           => "Integer. Font pointsize of legend entries.",
+:legendfonthalign         => "Symbol. Font horizontal alignment of legend entries: :hcenter, :left, :right or :center",
+:legendfontvalign         => "Symbol. Font vertical alignment of legend entries: :vcenter, :top, :bottom or :center",
+:legendfontrotation       => "Real. Font rotation of legend entries",
+:legendfontcolor          => "Color Type. Font color of legend entries",
+:colorbar                 => "Bool (show the colorbar?) or Symbol (colorbar position).  Symbol values: `:none`, `:best`, `:right`, `:left`, `:top`, `:bottom`, `:legend` (matches legend value) (note: only some may be supported in each backend)",
+:clims 					  => "`:auto` or NTuple{2,Number}.  Fixes the limits of the colorbar.",
+:legendfont               => "Font. Font of legend items.",
+: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.",
+:projection               => "Symbol or String.  '3d' or 'polar'",
+:aspect_ratio             => "Symbol (:equal) or Number. Plot area is resized so that 1 y-unit is the same size as `aspect_ratio` x-units.",
+:margin                   => "Measure (multiply by `mm`, `px`, etc). Base for individual margins... not directly used.  Specifies the extra padding around subplots.",
+:left_margin              => "Measure (multiply by `mm`, `px`, etc) or `:match` (matches `:margin`).  Specifies the extra padding to the left of the subplot.",
+:top_margin               => "Measure (multiply by `mm`, `px`, etc) or `:match` (matches `:margin`).  Specifies the extra padding on the top of the subplot.",
+:right_margin             => "Measure (multiply by `mm`, `px`, etc) or `:match` (matches `:margin`).  Specifies the extra padding to the right of the subplot.",
+:bottom_margin            => "Measure (multiply by `mm`, `px`, etc) or `:match` (matches `:margin`).  Specifies the extra padding on the bottom of the subplot.",
+:subplot_index            => "Integer.  Internal (not set by user).  Specifies the index of this subplot in the Plot's `plt.subplot` list.",
+:colorbar_title           => "String.  Title of colorbar.",
+:framestyle               => "Symbol.  Style of the axes frame. Choose from $(_allFramestyles)",
+:camera                   => "NTuple{2, Real}. Sets the view angle (azimuthal, elevation) for 3D plots",
+
+# axis args
+:guide     		  => "String. Axis guide (label).",
+:guide_position		  => "Symbol. Position of axis guides: :top, :bottom, :left or :right",
+:lims      		  => "NTuple{2,Number} or Symbol. Force axis limits.  Only finite values are used (you can set only the right limit with `xlims = (-Inf, 2)` for example). `:round` widens the limit to the nearest round number ie. [0.1,3.6]=>[0.0,4.0]",
+:ticks     		  => "Vector of numbers (set the tick values), Tuple of (tickvalues, ticklabels), or `:auto`",
+:scale     		  => "Symbol. Scale of the axis: `:none`, `:ln`, `:log2`, `:log10`",
+:rotation  		  => "Number. Degrees rotation of tick labels.",
+:flip      		  => "Bool.  Should we flip (reverse) the axis?",
+:formatter                => "Function, :scientific, :plain or :auto. A method which converts a number to a string for tick labeling.",
+:tickfontfamily           => "String or Symbol. Font family of tick labels.",
+:tickfontsize             => "Integer. Font pointsize of tick labels.",
+:tickfonthalign           => "Symbol. Font horizontal alignment of tick labels: :hcenter, :left, :right or :center",
+:tickfontvalign           => "Symbol. Font vertical alignment of tick labels: :vcenter, :top, :bottom or :center",
+:tickfontrotation         => "Real. Font rotation of tick labels",
+:tickfontcolor            => "Color Type. Font color of tick labels",
+:guidefontfamily          => "String or Symbol. Font family of axes guides.",
+:guidefontsize            => "Integer. Font pointsize of axes guides.",
+:guidefonthalign          => "Symbol. Font horizontal alignment of axes guides: :hcenter, :left, :right or :center",
+:guidefontvalign          => "Symbol. Font vertical alignment of axes guides: :vcenter, :top, :bottom or :center",
+:guidefontrotation        => "Real. Font rotation of axes guides",
+:guidefontcolor           => "Color Type. Font color of axes guides",
+:foreground_color_axis    => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of axis ticks.",
+:foreground_color_border  => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of plot area border (spines).",
+:foreground_color_text    => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of tick labels.",
+:foreground_color_guide   => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of axis guides (axis labels).",
+:mirror                   => "Bool.  Switch the side of the tick labels (right or top).",
+:grid                     => "Bool, Symbol, String or `nothing`. Show the grid lines? `true`, `false`, `:show`, `:hide`, `:yes`, `:no`, `:x`, `:y`, `:z`, `:xy`, ..., `:all`, `:none`, `:off`",
+:foreground_color_grid    => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of grid lines.",
+:gridalpha                => "Number in [0,1]. The alpha/opacity override for the grid lines.",
+:gridstyle                => "Symbol. Style of the grid lines. Choose from $(_allStyles)",
+:gridlinewidth            => "Number. Width of the grid lines (in pixels)",
+:foreground_color_minor_grid => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of minor grid lines.",
+:minorgrid                => "Bool. Adds minor grid lines and ticks to the plot. Set minorticks to change number of gridlines",
+:minorticks               => "Integer. Intervals to divide the gap between major ticks into",
+: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`",
+:showaxis                 => "Bool, Symbol or String.  Show the axis. `true`, `false`, `:show`, `:hide`, `:yes`, `:no`, `:x`, `:y`, `:z`, `:xy`, ..., `:all`, `:off`",
+:widen                    => "Bool. Widen the axis limits by a small factor to avoid cut-off markers and lines at the borders. Defaults to `true`.",
+:draw_arrow               => "Bool. Draw arrow at the end of the axis.",
+)

src/axes.jl

@@ -0,0 +1,758 @@
+
+
+# xaxis(args...; kw...) = Axis(:x, args...; kw...)
+# yaxis(args...; kw...) = Axis(:y, args...; kw...)
+# zaxis(args...; kw...) = Axis(:z, args...; kw...)
+
+# -------------------------------------------------------------------------
+
+function Axis(sp::Subplot, letter::Symbol, args...; kw...)
+    # init with values from _plot_defaults
+    plotattributes = KW(
+        :letter => letter,
+        # :extrema => (Inf, -Inf),
+        :extrema => Extrema(),
+        :discrete_map => Dict(),   # map discrete values to discrete indices
+        :continuous_values => zeros(0),
+        :use_minor => false,
+        :show => true,  # show or hide the axis? (useful for linked subplots)
+    )
+
+    # get defaults from letter version, unless match
+    for (k,v) in _axis_defaults
+        lk = Symbol(letter, k)
+        lv = _axis_defaults_byletter[lk]
+        plotattributes[k] = (lv == :match ? v : lv)
+    end
+
+    # merge!(plotattributes, _axis_defaults)
+    plotattributes[:discrete_values] = []
+
+    # update the defaults
+    attr!(Axis([sp], plotattributes), args...; kw...)
+end
+
+function get_axis(sp::Subplot, letter::Symbol)
+    axissym = Symbol(letter, :axis)
+    if haskey(sp.attr, axissym)
+        sp.attr[axissym]
+    else
+        sp.attr[axissym] = Axis(sp, letter)
+    end::Axis
+end
+
+function process_axis_arg!(plotattributes::KW, arg, letter = "")
+    T = typeof(arg)
+    arg = get(_scaleAliases, arg, arg)
+
+    if typeof(arg) <: Font
+        plotattributes[Symbol(letter,:tickfont)] = arg
+        plotattributes[Symbol(letter,:guidefont)] = arg
+
+    elseif arg in _allScales
+        plotattributes[Symbol(letter,:scale)] = arg
+
+    elseif arg in (:flip, :invert, :inverted)
+        plotattributes[Symbol(letter,:flip)] = true
+
+    elseif T <: AbstractString
+        plotattributes[Symbol(letter,:guide)] = arg
+
+    # xlims/ylims
+    elseif (T <: Tuple || T <: AVec) && length(arg) == 2
+        sym = typeof(arg[1]) <: Number ? :lims : :ticks
+        plotattributes[Symbol(letter,sym)] = arg
+
+    # xticks/yticks
+    elseif T <: AVec
+        plotattributes[Symbol(letter,:ticks)] = arg
+
+    elseif arg === nothing
+        plotattributes[Symbol(letter,:ticks)] = []
+
+    elseif T <: Bool || arg in _allShowaxisArgs
+        plotattributes[Symbol(letter,:showaxis)] = showaxis(arg, letter)
+
+    elseif typeof(arg) <: Number
+        plotattributes[Symbol(letter,:rotation)] = arg
+
+    elseif typeof(arg) <: Function
+        plotattributes[Symbol(letter,:formatter)] = arg
+
+    elseif !handleColors!(plotattributes, arg, Symbol(letter, :foreground_color_axis))
+        @warn("Skipped $(letter)axis arg $arg")
+
+    end
+end
+
+# update an Axis object with magic args and keywords
+function attr!(axis::Axis, args...; kw...)
+    # first process args
+    plotattributes = axis.plotattributes
+    for arg in args
+        process_axis_arg!(plotattributes, arg)
+    end
+
+    # then override for any keywords... only those keywords that already exists in plotattributes
+    for (k,v) in kw
+        if haskey(plotattributes, k)
+            if k == :discrete_values
+                # add these discrete values to the axis
+                for vi in v
+                    discrete_value!(axis, vi)
+                end
+            else
+                plotattributes[k] = v
+            end
+        end
+    end
+
+    # replace scale aliases
+    if haskey(_scaleAliases, plotattributes[:scale])
+        plotattributes[:scale] = _scaleAliases[plotattributes[:scale]]
+    end
+
+    axis
+end
+
+# -------------------------------------------------------------------------
+
+Base.show(io::IO, axis::Axis) = dumpdict(io, axis.plotattributes, "Axis", true)
+# Base.getindex(axis::Axis, k::Symbol) = getindex(axis.plotattributes, k)
+Base.setindex!(axis::Axis, v, ks::Symbol...) = setindex!(axis.plotattributes, v, ks...)
+Base.haskey(axis::Axis, k::Symbol) = haskey(axis.plotattributes, k)
+ignorenan_extrema(axis::Axis) = (ex = axis[:extrema]; (ex.emin, ex.emax))
+
+
+const _scale_funcs = Dict{Symbol,Function}(
+    :log10 => log10,
+    :log2 => log2,
+    :ln => log,
+)
+const _inv_scale_funcs = Dict{Symbol,Function}(
+    :log10 => exp10,
+    :log2 => exp2,
+    :ln => exp,
+)
+
+# const _label_func = Dict{Symbol,Function}(
+#     :log10 => x -> "10^$x",
+#     :log2 => x -> "2^$x",
+#     :ln => x -> "e^$x",
+# )
+
+const _label_func = Dict{Symbol,Function}(
+    :log10 => x -> "10^$x",
+    :log2 => x -> "2^$x",
+    :ln => x -> "e^$x",
+)
+
+
+scalefunc(scale::Symbol) = x -> get(_scale_funcs, scale, identity)(Float64(x))
+invscalefunc(scale::Symbol) = x -> get(_inv_scale_funcs, scale, identity)(Float64(x))
+labelfunc(scale::Symbol, backend::AbstractBackend) = get(_label_func, scale, string)
+
+function optimal_ticks_and_labels(sp::Subplot, axis::Axis, ticks = nothing)
+    amin, amax = axis_limits(sp, axis[:letter])
+
+    # scale the limits
+    scale = axis[:scale]
+    sf = scalefunc(scale)
+
+    # If the axis input was a Date or DateTime use a special logic to find
+    # "round" Date(Time)s as ticks
+    # This bypasses the rest of optimal_ticks_and_labels, because
+    # optimize_datetime_ticks returns ticks AND labels: the label format (Date
+    # or DateTime) is chosen based on the time span between amin and amax
+    # rather than on the input format
+    # TODO: maybe: non-trivial scale (:ln, :log2, :log10) for date/datetime
+    if ticks === nothing && scale == :identity
+        if axis[:formatter] == dateformatter
+            # optimize_datetime_ticks returns ticks and labels(!) based on
+            # integers/floats corresponding to the DateTime type. Thus, the axes
+            # limits, which resulted from converting the Date type to integers,
+            # are converted to 'DateTime integers' (actually floats) before
+            # being passed to optimize_datetime_ticks.
+            # (convert(Int, convert(DateTime, convert(Date, i))) == 87600000*i)
+            ticks, labels = optimize_datetime_ticks(864e5 * amin, 864e5 * amax;
+                k_min = 2, k_max = 4)
+            # Now the ticks are converted back to floats corresponding to Dates.
+            return ticks / 864e5, labels
+        elseif axis[:formatter] == datetimeformatter
+            return optimize_datetime_ticks(amin, amax; k_min = 2, k_max = 4)
+        end
+    end
+
+    # get a list of well-laid-out ticks
+    if ticks === nothing
+        scaled_ticks = optimize_ticks(
+            sf(amin),
+            sf(amax);
+            k_min = 4, # minimum number of ticks
+            k_max = 8, # maximum number of ticks
+        )[1]
+    elseif typeof(ticks) <: Int
+        scaled_ticks, viewmin, viewmax = optimize_ticks(
+            sf(amin),
+            sf(amax);
+            k_min = ticks, # minimum number of ticks
+            k_max = ticks, # maximum number of ticks
+            k_ideal = ticks,
+            # `strict_span = false` rewards cases where the span of the
+            # chosen  ticks is not too much bigger than amin - amax:
+            strict_span = false,
+        )
+        axis[:lims] = map(invscalefunc(scale), (viewmin, viewmax))
+    else
+        scaled_ticks = map(sf, (filter(t -> amin <= t <= amax, ticks)))
+    end
+    unscaled_ticks = map(invscalefunc(scale), scaled_ticks)
+
+    labels = if any(isfinite, unscaled_ticks)
+        formatter = axis[:formatter]
+        if formatter == :auto
+            # the default behavior is to make strings of the scaled values and then apply the labelfunc
+            map(labelfunc(scale, backend()), Showoff.showoff(scaled_ticks, :auto))
+        elseif formatter == :plain
+            # Leave the numbers in plain format
+            map(labelfunc(scale, backend()), Showoff.showoff(scaled_ticks, :plain))
+        elseif formatter == :scientific
+            Showoff.showoff(unscaled_ticks, :scientific)
+        else
+            # there was an override for the formatter... use that on the unscaled ticks
+            map(formatter, unscaled_ticks)
+            # if the formatter left us with numbers, still apply the default formatter
+            # However it leave us with the problem of unicode number decoding by the backend
+            # if eltype(unscaled_ticks) <: Number
+            #     Showoff.showoff(unscaled_ticks, :auto)
+            # end
+        end
+    else
+        # no finite ticks to show...
+        String[]
+    end
+
+    # @show unscaled_ticks labels
+    # labels = Showoff.showoff(unscaled_ticks, scale == :log10 ? :scientific : :auto)
+    unscaled_ticks, labels
+end
+
+# return (continuous_values, discrete_values) for the ticks on this axis
+function get_ticks(sp::Subplot, axis::Axis)
+    ticks = _transform_ticks(axis[:ticks])
+    ticks in (:none, nothing, false) && return nothing
+
+    # treat :native ticks as :auto
+    ticks = ticks == :native ? :auto : ticks
+
+    dvals = axis[:discrete_values]
+    cv, dv = if typeof(ticks) <: Symbol
+        if !isempty(dvals)
+            # discrete ticks...
+            n = length(dvals)
+            rng = if ticks == :auto
+                Int[round(Int,i) for i in range(1, stop=n, length=min(n,15))]
+            else # if ticks == :all
+                1:n
+            end
+            axis[:continuous_values][rng], dvals[rng]
+        elseif ispolar(axis.sps[1]) && axis[:letter] == :x
+            #force theta axis to be full circle
+            (collect(0:pi/4:7pi/4), string.(0:45:315))
+        else
+            # compute optimal ticks and labels
+            optimal_ticks_and_labels(sp, axis)
+        end
+    elseif typeof(ticks) <: Union{AVec, Int}
+        if !isempty(dvals) && typeof(ticks) <: Int
+            rng = Int[round(Int,i) for i in range(1, stop=length(dvals), length=ticks)]
+            axis[:continuous_values][rng], dvals[rng]
+        else
+            # override ticks, but get the labels
+            optimal_ticks_and_labels(sp, axis, ticks)
+        end
+    elseif typeof(ticks) <: NTuple{2, Any}
+        # assuming we're passed (ticks, labels)
+        ticks
+    else
+        error("Unknown ticks type in get_ticks: $(typeof(ticks))")
+    end
+    # @show ticks dvals cv dv
+
+    return cv, dv
+end
+
+_transform_ticks(ticks) = ticks
+_transform_ticks(ticks::AbstractArray{T}) where T <: Dates.TimeType = Dates.value.(ticks)
+_transform_ticks(ticks::NTuple{2, Any}) = (_transform_ticks(ticks[1]), ticks[2])
+
+function get_minor_ticks(sp, axis, ticks)
+    axis[:minorticks] in (:none, nothing, false) && !axis[:minorgrid] && return nothing
+    ticks = ticks[1]
+    length(ticks) < 2 && return nothing
+
+    amin, amax = axis_limits(sp, axis[:letter])
+    #Add one phantom tick either side of the ticks to ensure minor ticks extend to the axis limits
+    if length(ticks) > 2
+        ratio = (ticks[3] - ticks[2])/(ticks[2] - ticks[1])
+    elseif axis[:scale] == :none
+        ratio = 1
+    else
+        return nothing
+    end
+    first_step = ticks[2] - ticks[1]
+    last_step = ticks[end] - ticks[end-1]
+    ticks =  [ticks[1] - first_step/ratio; ticks; ticks[end] + last_step*ratio]
+
+    #Default to 5 intervals between major ticks
+    n = typeof(axis[:minorticks]) <: Integer && axis[:minorticks] > 1 ? axis[:minorticks] : 5
+    minorticks = typeof(ticks[1])[]
+    for (i,hi) in enumerate(ticks[2:end])
+        lo = ticks[i]
+        append!(minorticks,collect(lo + (hi-lo)/n :(hi-lo)/n: hi - (hi-lo)/2n))
+    end
+    minorticks[amin .<= minorticks .<= amax]
+end
+
+# -------------------------------------------------------------------------
+
+
+function reset_extrema!(sp::Subplot)
+    for asym in (:x,:y,:z)
+        sp[Symbol(asym,:axis)][:extrema] = Extrema()
+    end
+    for series in sp.series_list
+        expand_extrema!(sp, series.plotattributes)
+    end
+end
+
+
+function expand_extrema!(ex::Extrema, v::Number)
+    ex.emin = isfinite(v) ? min(v, ex.emin) : ex.emin
+    ex.emax = isfinite(v) ? max(v, ex.emax) : ex.emax
+    ex
+end
+
+function expand_extrema!(axis::Axis, v::Number)
+    expand_extrema!(axis[:extrema], v)
+end
+
+# these shouldn't impact the extrema
+expand_extrema!(axis::Axis, ::Nothing) = axis[:extrema]
+expand_extrema!(axis::Axis, ::Bool) = axis[:extrema]
+
+
+function expand_extrema!(axis::Axis, v::Tuple{MIN,MAX}) where {MIN<:Number,MAX<:Number}
+    ex = axis[:extrema]
+    ex.emin = isfinite(v[1]) ? min(v[1], ex.emin) : ex.emin
+    ex.emax = isfinite(v[2]) ? max(v[2], ex.emax) : ex.emax
+    ex
+end
+function expand_extrema!(axis::Axis, v::AVec{N}) where N<:Number
+    ex = axis[:extrema]
+    for vi in v
+        expand_extrema!(ex, vi)
+    end
+    ex
+end
+
+
+function expand_extrema!(sp::Subplot, plotattributes::KW)
+    vert = isvertical(plotattributes)
+
+    # first expand for the data
+    for letter in (:x, :y, :z)
+        data = plotattributes[if vert
+            letter
+        else
+            letter == :x ? :y : letter == :y ? :x : :z
+        end]
+        if letter != :z && plotattributes[:seriestype] == :straightline && any(series[:seriestype] != :straightline for series in series_list(sp)) && data[1] != data[2]
+            data = [NaN]
+        end
+        axis = sp[Symbol(letter, "axis")]
+
+        if isa(data, Volume)
+            expand_extrema!(sp[:xaxis], data.x_extents)
+            expand_extrema!(sp[:yaxis], data.y_extents)
+            expand_extrema!(sp[:zaxis], data.z_extents)
+        elseif eltype(data) <: Number || (isa(data, Surface) && all(di -> isa(di, Number), data.surf))
+            if !(eltype(data) <: Number)
+                # huh... must have been a mis-typed surface? lets swap it out
+                data = plotattributes[letter] = Surface(Matrix{Float64}(data.surf))
+            end
+            expand_extrema!(axis, data)
+        elseif data !== nothing
+            # TODO: need more here... gotta track the discrete reference value
+            #       as well as any coord offset (think of boxplot shape coords... they all
+            #       correspond to the same x-value)
+            plotattributes[letter], plotattributes[Symbol(letter,"_discrete_indices")] = discrete_value!(axis, data)
+            expand_extrema!(axis, plotattributes[letter])
+        end
+    end
+
+    # # expand for fillrange/bar_width
+    # fillaxis, baraxis = sp.attr[:yaxis], sp.attr[:xaxis]
+    # if isvertical(plotattributes)
+    #     fillaxis, baraxis = baraxis, fillaxis
+    # end
+
+    # expand for fillrange
+    fr = plotattributes[:fillrange]
+    if fr === nothing && plotattributes[:seriestype] == :bar
+        fr = 0.0
+    end
+    if fr !== nothing && !all3D(plotattributes)
+        axis = sp.attr[vert ? :yaxis : :xaxis]
+        if typeof(fr) <: Tuple
+            for fri in fr
+                expand_extrema!(axis, fri)
+            end
+        else
+            expand_extrema!(axis, fr)
+        end
+    end
+
+    # expand for bar_width
+    if plotattributes[:seriestype] == :bar
+        dsym = vert ? :x : :y
+        data = plotattributes[dsym]
+
+        bw = plotattributes[:bar_width]
+        if bw === nothing
+            bw = plotattributes[:bar_width] = _bar_width * ignorenan_minimum(filter(x->x>0,diff(sort(data))))
+        end
+        axis = sp.attr[Symbol(dsym, :axis)]
+        expand_extrema!(axis, ignorenan_maximum(data) + 0.5maximum(bw))
+        expand_extrema!(axis, ignorenan_minimum(data) - 0.5minimum(bw))
+    end
+
+    # expand for heatmaps
+    if plotattributes[:seriestype] == :heatmap
+        for letter in (:x, :y)
+            data = plotattributes[letter]
+            axis = sp[Symbol(letter, "axis")]
+            scale = get(plotattributes, Symbol(letter, "scale"), :identity)
+            expand_extrema!(axis, heatmap_edges(data, scale))
+        end
+    end
+end
+
+function expand_extrema!(sp::Subplot, xmin, xmax, ymin, ymax)
+    expand_extrema!(sp[:xaxis], (xmin, xmax))
+    expand_extrema!(sp[:yaxis], (ymin, ymax))
+end
+
+# -------------------------------------------------------------------------
+
+# push the limits out slightly
+function widen(lmin, lmax, scale = :identity)
+    f, invf = scalefunc(scale), invscalefunc(scale)
+    span = f(lmax) - f(lmin)
+    # eps = NaNMath.max(1e-16, min(1e-2span, 1e-10))
+    eps = NaNMath.max(1e-16, 0.03span)
+    invf(f(lmin)-eps), invf(f(lmax)+eps)
+end
+
+# figure out if widening is a good idea.
+const _widen_seriestypes = (:line, :path, :steppre, :steppost, :sticks, :scatter, :barbins, :barhist, :histogram, :scatterbins, :scatterhist, :stepbins, :stephist, :bins2d, :histogram2d, :bar, :shape, :path3d, :scatter3d)
+
+function default_should_widen(axis::Axis)
+    should_widen = false
+    if !(is_2tuple(axis[:lims]) || axis[:lims] == :round)
+        for sp in axis.sps
+            for series in series_list(sp)
+                if series.plotattributes[:seriestype] in _widen_seriestypes
+                    should_widen = true
+                end
+            end
+        end
+    end
+    should_widen
+end
+
+function round_limits(amin,amax)
+    scale = 10^(1-round(log10(amax - amin)))
+    amin = floor(amin*scale)/scale
+    amax = ceil(amax*scale)/scale
+    amin, amax
+end
+
+# using the axis extrema and limit overrides, return the min/max value for this axis
+function axis_limits(sp, letter, should_widen = default_should_widen(sp[Symbol(letter, :axis)]), consider_aspect = true)
+    axis = sp[Symbol(letter, :axis)]
+    ex = axis[:extrema]
+    amin, amax = ex.emin, ex.emax
+    lims = axis[:lims]
+    has_user_lims = (isa(lims, Tuple) || isa(lims, AVec)) && length(lims) == 2
+    if has_user_lims
+        if isfinite(lims[1])
+            amin = lims[1]
+        end
+        if isfinite(lims[2])
+            amax = lims[2]
+        end
+    end
+    if amax <= amin && isfinite(amin)
+        amax = amin + 1.0
+    end
+    if !isfinite(amin) && !isfinite(amax)
+        amin, amax = 0.0, 1.0
+    end
+    amin, amax = if ispolar(axis.sps[1])
+        if axis[:letter] == :x
+            amin, amax = 0, 2pi
+        elseif lims == :auto
+            #widen max radius so ticks dont overlap with theta axis
+            0, amax + 0.1 * abs(amax - amin)
+        else
+            amin, amax
+        end
+    elseif should_widen && axis[:widen]
+        widen(amin, amax, axis[:scale])
+    elseif lims == :round
+        round_limits(amin,amax)
+    else
+        amin, amax
+    end
+
+    if !has_user_lims && consider_aspect && letter in (:x, :y) && !(sp[:aspect_ratio] in (:none, :auto) || is3d(:sp))
+        aspect_ratio = isa(sp[:aspect_ratio], Number) ? sp[:aspect_ratio] : 1
+        plot_ratio = height(plotarea(sp)) / width(plotarea(sp))
+        dist = amax - amin
+
+        if letter == :x
+            yamin, yamax = axis_limits(sp, :y, default_should_widen(sp[:yaxis]), false)
+            ydist = yamax - yamin
+            axis_ratio = aspect_ratio * ydist / dist
+            factor = axis_ratio / plot_ratio
+        else
+            xamin, xamax = axis_limits(sp, :x, default_should_widen(sp[:xaxis]), false)
+            xdist = xamax - xamin
+            axis_ratio = aspect_ratio * dist / xdist
+            factor = plot_ratio / axis_ratio
+        end
+
+        if factor > 1
+            center = (amin + amax) / 2
+            amin = center + factor * (amin - center)
+            amax = center + factor * (amax - center)
+        end
+    end
+
+    return amin, amax
+end
+
+# -------------------------------------------------------------------------
+
+# these methods track the discrete (categorical) values which correspond to axis continuous values (cv)
+# whenever we have discrete values, we automatically set the ticks to match.
+# we return (continuous_value, discrete_index)
+function discrete_value!(axis::Axis, dv)
+    cv_idx = get(axis[:discrete_map], dv, -1)
+    # @show axis[:discrete_map], axis[:discrete_values], dv
+    if cv_idx == -1
+        ex = axis[:extrema]
+        cv = NaNMath.max(0.5, ex.emax + 1.0)
+        expand_extrema!(axis, cv)
+        push!(axis[:discrete_values], dv)
+        push!(axis[:continuous_values], cv)
+        cv_idx = length(axis[:discrete_values])
+        axis[:discrete_map][dv] = cv_idx
+        cv, cv_idx
+    else
+        cv = axis[:continuous_values][cv_idx]
+        cv, cv_idx
+    end
+end
+
+# continuous value... just pass back with axis negative index
+function discrete_value!(axis::Axis, cv::Number)
+    cv, -1
+end
+
+# add the discrete value for each item.  return the continuous values and the indices
+function discrete_value!(axis::Axis, v::AVec)
+    n = length(v)
+    cvec = zeros(n)
+    discrete_indices = zeros(Int, n)
+    for i=1:n
+        cvec[i], discrete_indices[i] = discrete_value!(axis, v[i])
+    end
+    cvec, discrete_indices
+end
+
+# add the discrete value for each item.  return the continuous values and the indices
+function discrete_value!(axis::Axis, v::AMat)
+    n,m = size(v)
+    cmat = zeros(n,m)
+    discrete_indices = zeros(Int, n, m)
+    for i=1:n, j=1:m
+        cmat[i,j], discrete_indices[i,j] = discrete_value!(axis, v[i,j])
+    end
+    cmat, discrete_indices
+end
+
+function discrete_value!(axis::Axis, v::Surface)
+    map(Surface, discrete_value!(axis, v.surf))
+end
+
+# -------------------------------------------------------------------------
+
+function pie_labels(sp::Subplot, series::Series)
+    plotattributes = series.plotattributes
+    if haskey(plotattributes,:x_discrete_indices)
+        dvals = sp.attr[:xaxis].plotattributes[:discrete_values]
+        [dvals[idx] for idx in plotattributes[:x_discrete_indices]]
+    else
+        plotattributes[:x]
+    end
+end
+
+# -------------------------------------------------------------------------
+
+# compute the line segments which should be drawn for this axis
+function axis_drawing_info(sp::Subplot)
+    xaxis, yaxis = sp[:xaxis], sp[:yaxis]
+    xmin, xmax = axis_limits(sp, :x)
+    ymin, ymax = axis_limits(sp, :y)
+    xticks = get_ticks(sp, xaxis)
+    yticks = get_ticks(sp, yaxis)
+    xminorticks = get_minor_ticks(sp, xaxis, xticks)
+    yminorticks = get_minor_ticks(sp, yaxis, yticks)
+    xaxis_segs = Segments(2)
+    yaxis_segs = Segments(2)
+    xtick_segs = Segments(2)
+    ytick_segs = Segments(2)
+    xgrid_segs = Segments(2)
+    ygrid_segs = Segments(2)
+    xminorgrid_segs = Segments(2)
+    yminorgrid_segs = Segments(2)
+    xborder_segs = Segments(2)
+    yborder_segs = Segments(2)
+
+    if sp[:framestyle] != :none
+        # xaxis
+        if xaxis[:showaxis]
+            if sp[:framestyle] != :grid
+                y1, y2 = if sp[:framestyle] in (:origin, :zerolines)
+                    0.0, 0.0
+                else
+                    xor(xaxis[:mirror], yaxis[:flip]) ? (ymax, ymin) : (ymin, ymax)
+                end
+                push!(xaxis_segs, (xmin, y1), (xmax, y1))
+                # don't show the 0 tick label for the origin framestyle
+                if sp[:framestyle] == :origin && !(xticks in (:none, nothing, false)) && length(xticks) > 1
+                    showticks = xticks[1] .!= 0
+                    xticks = (xticks[1][showticks], xticks[2][showticks])
+                end
+            end
+            sp[:framestyle] in (:semi, :box) && push!(xborder_segs, (xmin, y2), (xmax, y2)) # top spine
+        end
+        if !(xaxis[:ticks] in (:none, nothing, false))
+            f = scalefunc(yaxis[:scale])
+            invf = invscalefunc(yaxis[:scale])
+            ticks_in = xaxis[:tick_direction] == :out ? -1 : 1
+            t1 = invf(f(ymin) + 0.015 * (f(ymax) - f(ymin)) * ticks_in)
+            t2 = invf(f(ymax) - 0.015 * (f(ymax) - f(ymin)) * ticks_in)
+            t3 = invf(f(0) + 0.015 * (f(ymax) - f(ymin)) * ticks_in)
+
+            for xtick in xticks[1]
+                if xaxis[:showaxis]
+                    tick_start, tick_stop = if sp[:framestyle] == :origin
+                        (0, t3)
+                    else
+                        xor(xaxis[:mirror], yaxis[:flip]) ? (ymax, t2) : (ymin, t1)
+                    end
+                    push!(xtick_segs, (xtick, tick_start), (xtick, tick_stop)) # bottom tick
+                end
+                # sp[:draw_axes_border] && push!(xaxis_segs, (xtick, ymax), (xtick, t2)) # top tick
+                xaxis[:grid] && push!(xgrid_segs, (xtick, ymin), (xtick, ymax)) # vertical grid
+            end
+        end
+        if !(xaxis[:minorticks] in (:none, nothing, false)) || xaxis[:minorgrid]
+            f = scalefunc(yaxis[:scale])
+            invf = invscalefunc(yaxis[:scale])
+            ticks_in = xaxis[:tick_direction] == :out ? -1 : 1
+            t1 = invf(f(ymin) + 0.01 * (f(ymax) - f(ymin)) * ticks_in)
+            t2 = invf(f(ymax) - 0.01 * (f(ymax) - f(ymin)) * ticks_in)
+            t3 = invf(f(0) + 0.01 * (f(ymax) - f(ymin)) * ticks_in)
+
+            for xminortick in xminorticks
+                if xaxis[:showaxis]
+                    tick_start, tick_stop = if sp[:framestyle] == :origin
+                        (0, t3)
+                    else
+                        xor(xaxis[:mirror], yaxis[:flip]) ? (ymax, t2) : (ymin, t1)
+                    end
+                    push!(xtick_segs, (xminortick, tick_start), (xminortick, tick_stop)) # bottom tick
+                end
+                # sp[:draw_axes_border] && push!(xaxis_segs, (xtick, ymax), (xtick, t2)) # top tick
+                xaxis[:minorgrid] && push!(xminorgrid_segs, (xminortick, ymin), (xminortick, ymax)) # vertical grid
+            end
+        end
+
+
+        # yaxis
+        if yaxis[:showaxis]
+            if sp[:framestyle] != :grid
+                x1, x2 = if sp[:framestyle] in (:origin, :zerolines)
+                    0.0, 0.0
+                else
+                    xor(yaxis[:mirror], xaxis[:flip]) ? (xmax, xmin) : (xmin, xmax)
+                end
+                push!(yaxis_segs, (x1, ymin), (x1, ymax))
+                # don't show the 0 tick label for the origin framestyle
+                if sp[:framestyle] == :origin && !(yticks in (:none, nothing,false)) && length(yticks) > 1
+                    showticks = yticks[1] .!= 0
+                    yticks = (yticks[1][showticks], yticks[2][showticks])
+                end
+            end
+            sp[:framestyle] in (:semi, :box) && push!(yborder_segs, (x2, ymin), (x2, ymax)) # right spine
+        end
+        if !(yaxis[:ticks] in (:none, nothing, false))
+            f = scalefunc(xaxis[:scale])
+            invf = invscalefunc(xaxis[:scale])
+            ticks_in = yaxis[:tick_direction] == :out ? -1 : 1
+            t1 = invf(f(xmin) + 0.015 * (f(xmax) - f(xmin)) * ticks_in)
+            t2 = invf(f(xmax) - 0.015 * (f(xmax) - f(xmin)) * ticks_in)
+            t3 = invf(f(0) + 0.015 * (f(xmax) - f(xmin)) * ticks_in)
+
+            for ytick in yticks[1]
+                if yaxis[:showaxis]
+                    tick_start, tick_stop = if sp[:framestyle] == :origin
+                        (0, t3)
+                    else
+                        xor(yaxis[:mirror], xaxis[:flip]) ? (xmax, t2) : (xmin, t1)
+                    end
+                    push!(ytick_segs, (tick_start, ytick), (tick_stop, ytick)) # left tick
+                end
+                # sp[:draw_axes_border] && push!(yaxis_segs, (xmax, ytick), (t2, ytick)) # right tick
+                yaxis[:grid] && push!(ygrid_segs, (xmin, ytick), (xmax, ytick)) # horizontal grid
+            end
+        end
+        if !(yaxis[:minorticks] in (:none, nothing, false)) || yaxis[:minorgrid]
+            f = scalefunc(xaxis[:scale])
+            invf = invscalefunc(xaxis[:scale])
+            ticks_in = yaxis[:tick_direction] == :out ? -1 : 1
+            t1 = invf(f(xmin) + 0.01 * (f(xmax) - f(xmin)) * ticks_in)
+            t2 = invf(f(xmax) - 0.01 * (f(xmax) - f(xmin)) * ticks_in)
+            t3 = invf(f(0) + 0.01 * (f(xmax) - f(xmin)) * ticks_in)
+
+            for ytick in yminorticks
+                if yaxis[:showaxis]
+                    tick_start, tick_stop = if sp[:framestyle] == :origin
+                        (0, t3)
+                    else
+                        xor(yaxis[:mirror], xaxis[:flip]) ? (xmax, t2) : (xmin, t1)
+                    end
+                    push!(ytick_segs, (tick_start, ytick), (tick_stop, ytick)) # left tick
+                end
+                # sp[:draw_axes_border] && push!(yaxis_segs, (xmax, ytick), (t2, ytick)) # right tick
+                yaxis[:minorgrid] && push!(yminorgrid_segs, (xmin, ytick), (xmax, ytick)) # horizontal grid
+            end
+        end
+    end
+
+    Any[xticks, yticks, xaxis_segs, yaxis_segs, xtick_segs, ytick_segs, xgrid_segs, ygrid_segs, xminorgrid_segs, yminorgrid_segs, xborder_segs, yborder_segs]
+end

src/backends.jl

@@ -0,0 +1,673 @@
+using Pkg
+
+struct NoBackend <: AbstractBackend end
+
+const _backendType = Dict{Symbol, DataType}(:none => NoBackend)
+const _backendSymbol = Dict{DataType, Symbol}(NoBackend => :none)
+const _backends = Symbol[]
+const _initialized_backends = Set{Symbol}()
+const _default_backends = (:none, :gr, :plotly)
+
+const _backend_packages = Dict{Symbol, Symbol}()
+
+"Returns a list of supported backends"
+backends() = _backends
+
+"Returns the name of the current backend"
+backend_name() = CURRENT_BACKEND.sym
+
+function _backend_instance(sym::Symbol)::AbstractBackend
+    haskey(_backendType, sym) ? _backendType[sym]() : error("Unsupported backend $sym")
+end
+
+backend_package_name(sym::Symbol) = _backend_packages[sym]
+
+macro init_backend(s)
+    package_str = string(s)
+    str = lowercase(package_str)
+    sym = Symbol(str)
+    T = Symbol(string(s) * "Backend")
+    esc(quote
+        struct $T <: AbstractBackend end
+        export $sym
+        $sym(; kw...) = (default(; kw...); backend($T()))
+        backend_name(::$T) = Symbol($str)
+        backend_package_name(pkg::$T) = backend_package_name(Symbol($str))
+        push!(_backends, Symbol($str))
+        _backendType[Symbol($str)] = $T
+        _backendSymbol[$T] = Symbol($str)
+        _backend_packages[Symbol($str)] = Symbol($package_str)
+        # include("backends/" * $str * ".jl")
+    end)
+end
+
+# include("backends/web.jl")
+# include("backends/supported.jl")
+
+# ---------------------------------------------------------
+
+# don't do anything as a default
+@noinline _create_backend_figure(plt::Plot) = nothing
+@noinline _prepare_plot_object(plt::Plot) = nothing
+@noinline _initialize_subplot(plt::Plot, sp::Subplot) = nothing
+
+@noinline _series_added(plt::Plot, series::Series) = nothing
+@noinline _series_updated(plt::Plot, series::Series) = nothing
+
+@noinline _before_layout_calcs(plt::Plot) = nothing
+
+@noinline title_padding(sp::Subplot) = sp[:title] == "" ? 0mm : sp[:titlefontsize] * pt
+@noinline guide_padding(axis::Axis) = axis[:guide] == "" ? 0mm : axis[:guidefontsize] * pt
+
+"Returns the (width,height) of a text label."
+function text_size(lablen::Int, sz::Number, rot::Number = 0)
+    # we need to compute the size of the ticks generically
+    # this means computing the bounding box and then getting the width/height
+    # note:
+    ptsz = sz * pt
+    width = 0.8lablen * ptsz
+
+    # now compute the generalized "height" after rotation as the "opposite+adjacent" of 2 triangles
+    height = abs(sind(rot)) * width + abs(cosd(rot)) * ptsz
+    width = abs(sind(rot+90)) * width + abs(cosd(rot+90)) * ptsz
+    width, height
+end
+text_size(lab::AbstractString, sz::Number, rot::Number = 0) = text_size(length(lab), sz, rot)
+
+# account for the size/length/rotation of tick labels
+function tick_padding(sp::Subplot, axis::Axis)
+    ticks = get_ticks(sp, axis)
+    if ticks === nothing
+        0mm
+    else
+        vals, labs = ticks
+        isempty(labs) && return 0mm
+        # ptsz = axis[:tickfont].pointsize * pt
+        longest_label = maximum(length(lab) for lab in labs)
+
+        # generalize by "rotating" y labels
+        rot = axis[:rotation] + (axis[:letter] == :y ? 90 : 0)
+
+        # # we need to compute the size of the ticks generically
+        # # this means computing the bounding box and then getting the width/height
+        # labelwidth = 0.8longest_label * ptsz
+        #
+        #
+        # # now compute the generalized "height" after rotation as the "opposite+adjacent" of 2 triangles
+        # hgt = abs(sind(rot)) * labelwidth + abs(cosd(rot)) * ptsz + 1mm
+        # hgt
+
+        # get the height of the rotated label
+        text_size(longest_label, axis[:tickfontsize], rot)[2]
+    end
+end
+
+# Set the (left, top, right, bottom) minimum padding around the plot area
+# to fit ticks, tick labels, guides, colorbars, etc.
+function _update_min_padding!(sp::Subplot)
+    # TODO: something different when `is3d(sp) == true`
+    leftpad   = tick_padding(sp, sp[:yaxis]) + sp[:left_margin]   + guide_padding(sp[:yaxis])
+    toppad    = sp[:top_margin]    + title_padding(sp)
+    rightpad  = sp[:right_margin]
+    bottompad = tick_padding(sp, sp[:xaxis]) + sp[:bottom_margin] + guide_padding(sp[:xaxis])
+
+    # switch them?
+    if sp[:xaxis][:mirror]
+        bottompad, toppad = toppad, bottompad
+    end
+    if sp[:yaxis][:mirror]
+        leftpad, rightpad = rightpad, leftpad
+    end
+
+    # @show (leftpad, toppad, rightpad, bottompad)
+    sp.minpad = (leftpad, toppad, rightpad, bottompad)
+end
+
+@noinline _update_plot_object(plt::Plot) = nothing
+
+# ---------------------------------------------------------
+
+
+mutable struct CurrentBackend{sym,T}
+  pkg::T
+end
+function CurrentBackend(sym::Symbol)
+    bkend = _backend_instance(sym)
+    CurrentBackend{sym,typeof(bkend)}(bkend)
+end
+
+function Base.getproperty(bkend::CurrentBackend{sym,T},x::Symbol) where {sym,T}
+    if x === :sym
+        return sym
+    elseif x === :pkg
+        return getfield(bkend,:pkg)
+    else
+        error("Must be sym or pkg")
+    end
+end
+
+# ---------------------------------------------------------
+
+@noinline _fallback_default_backend() = backend(GRBackend())
+
+function _pick_default_backend()
+    env_default = get(ENV, "PLOTS_DEFAULT_BACKEND", "")
+    if env_default != ""
+        sym = Symbol(lowercase(env_default))
+        if sym in _backends
+            backend(sym)
+        else
+            @warn("You have set PLOTS_DEFAULT_BACKEND=$env_default but it is not a valid backend package.  Choose from:\n\t" *
+                 join(sort(_backends), "\n\t"))
+            _fallback_default_backend()
+        end
+    else
+        _fallback_default_backend()
+    end
+end
+
+
+# ---------------------------------------------------------
+
+"""
+Returns the current plotting package name.  Initializes package on first call.
+"""
+function backend()
+    if CURRENT_BACKEND.sym == :none
+        _pick_default_backend()
+    end
+
+    CURRENT_BACKEND.pkg
+end
+
+"""
+Set the plot backend.
+"""
+function backend(pkg::AbstractBackend)
+    sym = backend_name(pkg)
+    if !(sym in _initialized_backends)
+        _initialize_backend(pkg)
+        push!(_initialized_backends, sym)
+    end
+    CURRENT_BACKEND = Plots.CurrentBackend(sym)
+    pkg
+end
+
+function backend(sym::Symbol)
+    if sym in _backends
+        backend(_backend_instance(sym))
+    else
+        @warn("`:$sym` is not a supported backend.")
+        backend()
+    end
+end
+
+const _deprecated_backends = [:qwt, :winston, :bokeh, :gadfly, :immerse, :glvisualize]
+
+function warn_on_deprecated_backend(bsym::Symbol)
+    if bsym in _deprecated_backends
+        @warn("Backend $bsym has been deprecated.")
+    end
+end
+
+
+
+# ---------------------------------------------------------
+
+# these are args which every backend supports because they're not used in the backend code
+const _base_supported_args = [
+    :color_palette,
+    :background_color, :background_color_subplot,
+    :foreground_color, :foreground_color_subplot,
+    :group,
+    :seriestype,
+    :seriescolor, :seriesalpha,
+    :smooth,
+    :xerror, :yerror,
+    :subplot,
+    :x, :y, :z,
+    :show, :size,
+    :margin,
+    :left_margin,
+    :right_margin,
+    :top_margin,
+    :bottom_margin,
+    :html_output_format,
+    :layout,
+    :link,
+    :primary,
+    :series_annotations,
+    :subplot_index,
+    :discrete_values,
+    :projection,
+
+]
+
+function merge_with_base_supported(v::AVec)
+    v = vcat(v, _base_supported_args)
+    for vi in v
+        if haskey(_axis_defaults, vi)
+            for letter in (:x,:y,:z)
+                push!(v, Symbol(letter,vi))
+            end
+        end
+    end
+    Set(v)
+end
+
+
+
+@init_backend PyPlot
+@init_backend UnicodePlots
+@init_backend Plotly
+@init_backend PlotlyJS
+@init_backend GR
+@init_backend PGFPlots
+@init_backend InspectDR
+@init_backend HDF5
+
+# ---------------------------------------------------------
+
+# create the various `is_xxx_supported` and `supported_xxxs` methods
+# by default they pass through to checking membership in `_gr_xxx`
+for s in (:attr, :seriestype, :marker, :style, :scale)
+    f = Symbol("is_", s, "_supported")
+    f2 = Symbol("supported_", s, "s")
+    @eval begin
+        $f(::AbstractBackend, $s) = false
+        $f(bend::AbstractBackend, $s::AbstractVector) = all(v -> $f(bend, v), $s)
+        $f($s) = $f(backend(), $s)
+        $f2() = $f2(backend())
+    end
+
+    for bend in backends()
+        bend_type = typeof(_backend_instance(bend))
+        v = Symbol("_", bend, "_", s)
+        @eval begin
+            $f(::$bend_type, $s::Symbol) = $s in $v
+            $f2(::$bend_type) = $v
+        end
+    end
+end
+
+# is_subplot_supported(::AbstractBackend) = false
+# is_subplot_supported() = is_subplot_supported(backend())
+
+
+################################################################################
+# initialize the backends
+
+function _initialize_backend(pkg::AbstractBackend)
+    sym = backend_package_name(pkg)
+    @eval Main begin
+        import $sym
+        export $sym
+    end
+end
+
+@noinline _initialize_backend(pkg::GRBackend) = nothing
+@noinline _initialize_backend(pkg::PlotlyBackend) = nothing
+
+
+# ------------------------------------------------------------------------------
+# gr
+
+const _gr_attr = merge_with_base_supported([
+    :annotations,
+    :background_color_legend, :background_color_inside, :background_color_outside,
+    :foreground_color_legend, :foreground_color_grid, :foreground_color_axis,
+    :foreground_color_text, :foreground_color_border,
+    :label,
+    :seriescolor, :seriesalpha,
+    :linecolor, :linestyle, :linewidth, :linealpha,
+    :markershape, :markercolor, :markersize, :markeralpha,
+    :markerstrokewidth, :markerstrokecolor, :markerstrokealpha,
+    :fillrange, :fillcolor, :fillalpha,
+    :bins,
+    :layout,
+    :title, :window_title,
+    :guide, :lims, :ticks, :scale, :flip,
+    :match_dimensions,
+    :titlefontfamily, :titlefontsize, :titlefonthalign, :titlefontvalign,
+    :titlefontrotation, :titlefontcolor,
+    :legendfontfamily, :legendfontsize, :legendfonthalign, :legendfontvalign,
+    :legendfontrotation, :legendfontcolor,
+    :tickfontfamily, :tickfontsize, :tickfonthalign, :tickfontvalign,
+    :tickfontrotation, :tickfontcolor,
+    :guidefontfamily, :guidefontsize, :guidefonthalign, :guidefontvalign,
+    :guidefontrotation, :guidefontcolor,
+    :grid, :gridalpha, :gridstyle, :gridlinewidth,
+    :legend, :legendtitle, :colorbar, :colorbar_title, :colorbar_entry,
+    :fill_z, :line_z, :marker_z, :levels,
+    :ribbon, :quiver,
+    :orientation,
+    :overwrite_figure,
+    :polar,
+    :aspect_ratio,
+    :normalize, :weights,
+    :inset_subplots,
+    :bar_width,
+    :arrow,
+    :framestyle,
+    :tick_direction,
+    :camera,
+    :contour_labels,
+])
+const _gr_seriestype = [
+    :path, :scatter, :straightline,
+    :heatmap, :pie, :image,
+    :contour, :path3d, :scatter3d, :surface, :wireframe, :volume,
+    :shape
+]
+const _gr_style = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
+const _gr_marker = _allMarkers
+const _gr_scale = [:identity, :log10]
+is_marker_supported(::GRBackend, shape::Shape) = true
+
+# ------------------------------------------------------------------------------
+# plotly
+
+const _plotly_attr = merge_with_base_supported([
+    :annotations,
+    :background_color_legend, :background_color_inside, :background_color_outside,
+    :foreground_color_legend, :foreground_color_guide,
+    :foreground_color_grid, :foreground_color_axis,
+    :foreground_color_text, :foreground_color_border,
+    :foreground_color_title,
+    :label,
+    :seriescolor, :seriesalpha,
+    :linecolor, :linestyle, :linewidth, :linealpha,
+    :markershape, :markercolor, :markersize, :markeralpha,
+    :markerstrokewidth, :markerstrokecolor, :markerstrokealpha, :markerstrokestyle,
+    :fillrange, :fillcolor, :fillalpha,
+    :bins,
+    :title, :title_location,
+    :titlefontfamily, :titlefontsize, :titlefonthalign, :titlefontvalign,
+    :titlefontcolor,
+    :legendfontfamily, :legendfontsize, :legendfontcolor,
+    :tickfontfamily, :tickfontsize, :tickfontcolor,
+    :guidefontfamily, :guidefontsize, :guidefontcolor,
+    :window_title,
+    :guide, :lims, :ticks, :scale, :flip, :rotation,
+    :tickfont, :guidefont, :legendfont,
+    :grid, :gridalpha, :gridlinewidth,
+    :legend, :colorbar, :colorbar_title, :colorbar_entry,
+    :marker_z, :fill_z, :line_z, :levels,
+    :ribbon, :quiver,
+    :orientation,
+    # :overwrite_figure,
+    :polar,
+    :normalize, :weights,
+    # :contours,
+    :aspect_ratio,
+    :hover,
+    :inset_subplots,
+    :bar_width,
+    :clims,
+    :framestyle,
+    :tick_direction,
+    :camera,
+    :contour_labels,
+  ])
+
+const _plotly_seriestype = [
+    :path, :scatter, :pie, :heatmap,
+    :contour, :surface, :wireframe, :path3d, :scatter3d, :shape, :scattergl,
+    :straightline
+]
+const _plotly_style = [:auto, :solid, :dash, :dot, :dashdot]
+const _plotly_marker = [
+    :none, :auto, :circle, :rect, :diamond, :utriangle, :dtriangle,
+    :cross, :xcross, :pentagon, :hexagon, :octagon, :vline, :hline
+]
+const _plotly_scale = [:identity, :log10]
+
+defaultOutputFormat(plt::Plot{Plots.PlotlyBackend}) = "html"
+
+# ------------------------------------------------------------------------------
+# pgfplots
+
+const _pgfplots_attr = merge_with_base_supported([
+    :annotations,
+    :background_color_legend,
+    :background_color_inside,
+    # :background_color_outside,
+    # :foreground_color_legend,
+    :foreground_color_grid, :foreground_color_axis,
+    :foreground_color_text, :foreground_color_border,
+    :label,
+    :seriescolor, :seriesalpha,
+    :linecolor, :linestyle, :linewidth, :linealpha,
+    :markershape, :markercolor, :markersize, :markeralpha,
+    :markerstrokewidth, :markerstrokecolor, :markerstrokealpha, :markerstrokestyle,
+    :fillrange, :fillcolor, :fillalpha,
+    :bins,
+    # :bar_width, :bar_edges,
+    :title,
+    # :window_title,
+    :guide, :guide_position, :lims, :ticks, :scale, :flip, :rotation,
+    :tickfont, :guidefont, :legendfont,
+    :grid, :legend,
+    :colorbar, :colorbar_title,
+    :fill_z, :line_z, :marker_z, :levels,
+    # :ribbon, :quiver, :arrow,
+    # :orientation,
+    # :overwrite_figure,
+    :polar,
+    # :normalize, :weights, :contours,
+    :aspect_ratio,
+    # :match_dimensions,
+    :tick_direction,
+    :framestyle,
+    :camera,
+    :contour_labels,
+])
+const _pgfplots_seriestype = [:path, :path3d, :scatter, :steppre, :stepmid, :steppost, :histogram2d, :ysticks, :xsticks, :contour, :shape, :straightline,]
+const _pgfplots_style = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
+const _pgfplots_marker = [:none, :auto, :circle, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5, :pentagon, :hline, :vline] #vcat(_allMarkers, Shape)
+const _pgfplots_scale = [:identity, :ln, :log2, :log10]
+
+# ------------------------------------------------------------------------------
+# plotlyjs
+
+function _initialize_backend(pkg::PlotlyJSBackend)
+    @eval Main begin
+        import PlotlyJS, ORCA
+        export PlotlyJS
+    end
+end
+
+const _plotlyjs_attr        = _plotly_attr
+const _plotlyjs_seriestype  = _plotly_seriestype
+const _plotlyjs_style       = _plotly_style
+const _plotlyjs_marker      = _plotly_marker
+const _plotlyjs_scale       = _plotly_scale
+
+# ------------------------------------------------------------------------------
+# pyplot
+
+function _initialize_backend(::PyPlotBackend)
+    @eval Main begin
+        import PyPlot
+
+        export PyPlot
+
+        # we don't want every command to update the figure
+        PyPlot.ioff()
+    end
+end
+
+const _pyplot_attr = merge_with_base_supported([
+    :annotations,
+    :background_color_legend, :background_color_inside, :background_color_outside,
+    :foreground_color_grid, :foreground_color_legend, :foreground_color_title,
+    :foreground_color_axis, :foreground_color_border, :foreground_color_guide, :foreground_color_text,
+    :label,
+    :linecolor, :linestyle, :linewidth, :linealpha,
+    :markershape, :markercolor, :markersize, :markeralpha,
+    :markerstrokewidth, :markerstrokecolor, :markerstrokealpha,
+    :fillrange, :fillcolor, :fillalpha,
+    :bins, :bar_width, :bar_edges, :bar_position,
+    :title, :title_location, :titlefont,
+    :window_title,
+    :guide, :guide_position, :lims, :ticks, :scale, :flip, :rotation,
+    :titlefontfamily, :titlefontsize, :titlefontcolor,
+    :legendfontfamily, :legendfontsize, :legendfontcolor,
+    :tickfontfamily, :tickfontsize, :tickfontcolor,
+    :guidefontfamily, :guidefontsize, :guidefontcolor,
+    :grid, :gridalpha, :gridstyle, :gridlinewidth,
+    :legend, :legendtitle, :colorbar, :colorbar_title, :colorbar_entry,
+    :marker_z, :line_z, :fill_z,
+    :levels,
+    :ribbon, :quiver, :arrow,
+    :orientation,
+    :overwrite_figure,
+    :polar,
+    :normalize, :weights,
+    :contours, :aspect_ratio,
+    :match_dimensions,
+    :clims,
+    :inset_subplots,
+    :dpi,
+    :stride,
+    :framestyle,
+    :tick_direction,
+    :camera,
+    :contour_labels,
+  ])
+const _pyplot_seriestype = [
+        :path, :steppre, :steppost, :shape, :straightline,
+        :scatter, :hexbin, #:histogram2d, :histogram,
+        # :bar,
+        :heatmap, :pie, :image,
+        :contour, :contour3d, :path3d, :scatter3d, :surface, :wireframe
+    ]
+const _pyplot_style = [:auto, :solid, :dash, :dot, :dashdot]
+const _pyplot_marker = vcat(_allMarkers, :pixel)
+const _pyplot_scale = [:identity, :ln, :log2, :log10]
+
+# ------------------------------------------------------------------------------
+# unicodeplots
+
+const _unicodeplots_attr = merge_with_base_supported([
+    :label,
+    :legend,
+    :seriescolor,
+    :seriesalpha,
+    :linestyle,
+    :markershape,
+    :bins,
+    :title,
+    :guide, :lims,
+  ])
+const _unicodeplots_seriestype = [
+    :path, :scatter, :straightline,
+    # :bar,
+    :shape,
+    :histogram2d,
+    :spy
+]
+const _unicodeplots_style = [:auto, :solid]
+const _unicodeplots_marker = [:none, :auto, :circle]
+const _unicodeplots_scale = [:identity]
+
+# ------------------------------------------------------------------------------
+# hdf5
+
+const _hdf5_attr = merge_with_base_supported([
+    :annotations,
+    :background_color_legend, :background_color_inside, :background_color_outside,
+    :foreground_color_grid, :foreground_color_legend, :foreground_color_title,
+    :foreground_color_axis, :foreground_color_border, :foreground_color_guide, :foreground_color_text,
+    :label,
+    :linecolor, :linestyle, :linewidth, :linealpha,
+    :markershape, :markercolor, :markersize, :markeralpha,
+    :markerstrokewidth, :markerstrokecolor, :markerstrokealpha,
+    :fillrange, :fillcolor, :fillalpha,
+    :bins, :bar_width, :bar_edges, :bar_position,
+    :title, :title_location, :titlefont,
+    :window_title,
+    :guide, :lims, :ticks, :scale, :flip, :rotation,
+    :tickfont, :guidefont, :legendfont,
+    :grid, :legend, :colorbar,
+    :marker_z, :line_z, :fill_z,
+    :levels,
+    :ribbon, :quiver, :arrow,
+    :orientation,
+    :overwrite_figure,
+    :polar,
+    :normalize, :weights,
+    :contours, :aspect_ratio,
+    :match_dimensions,
+    :clims,
+    :inset_subplots,
+    :dpi,
+    :colorbar_title,
+  ])
+const _hdf5_seriestype = [
+        :path, :steppre, :steppost, :shape, :straightline,
+        :scatter, :hexbin, #:histogram2d, :histogram,
+        # :bar,
+        :heatmap, :pie, :image,
+        :contour, :contour3d, :path3d, :scatter3d, :surface, :wireframe
+    ]
+const _hdf5_style = [:auto, :solid, :dash, :dot, :dashdot]
+const _hdf5_marker = vcat(_allMarkers, :pixel)
+const _hdf5_scale = [:identity, :ln, :log2, :log10]
+
+# ------------------------------------------------------------------------------
+# inspectdr
+
+const _inspectdr_attr = merge_with_base_supported([
+    :annotations,
+    :background_color_legend, :background_color_inside, :background_color_outside,
+    # :foreground_color_grid,
+    :foreground_color_legend, :foreground_color_title,
+    :foreground_color_axis, :foreground_color_border, :foreground_color_guide, :foreground_color_text,
+    :label,
+    :seriescolor, :seriesalpha,
+    :linecolor, :linestyle, :linewidth, :linealpha,
+    :markershape, :markercolor, :markersize, :markeralpha,
+    :markerstrokewidth, :markerstrokecolor, :markerstrokealpha,
+    :markerstrokestyle, #Causes warning not to have it... what is this?
+    :fillcolor, :fillalpha, #:fillrange,
+#    :bins, :bar_width, :bar_edges, :bar_position,
+    :title, :title_location,
+    :window_title,
+    :guide, :lims, :scale, #:ticks, :flip, :rotation,
+    :titlefontfamily, :titlefontsize, :titlefontcolor,
+    :legendfontfamily, :legendfontsize, :legendfontcolor,
+    :tickfontfamily, :tickfontsize, :tickfontcolor,
+    :guidefontfamily, :guidefontsize, :guidefontcolor,
+    :grid, :legend, #:colorbar,
+#    :marker_z,
+#    :line_z,
+#    :levels,
+ #   :ribbon, :quiver, :arrow,
+#    :orientation,
+    :overwrite_figure,
+    :polar,
+#    :normalize, :weights,
+#    :contours, :aspect_ratio,
+    :match_dimensions,
+#    :clims,
+#    :inset_subplots,
+    :dpi,
+#    :colorbar_title,
+  ])
+const _inspectdr_style = [:auto, :solid, :dash, :dot, :dashdot]
+const _inspectdr_seriestype = [
+        :path, :scatter, :shape, :straightline, #, :steppre, :steppost
+    ]
+#see: _allMarkers, _shape_keys
+const _inspectdr_marker = Symbol[
+    :none, :auto,
+    :circle, :rect, :diamond,
+    :cross, :xcross,
+    :utriangle, :dtriangle, :rtriangle, :ltriangle,
+    :pentagon, :hexagon, :heptagon, :octagon,
+    :star4, :star5, :star6, :star7, :star8,
+    :vline, :hline, :+, :x,
+]
+
+const _inspectdr_scale = [:identity, :ln, :log2, :log10]

src/backends/hdf5.jl

@@ -0,0 +1,637 @@
+#HDF5 Plots: Save/replay plots to/from HDF5
+#-------------------------------------------------------------------------------
+
+#==Usage
+===============================================================================
+Write to .hdf5 file using:
+    p = plot(...)
+   Plots.hdf5plot_write(p, "plotsave.hdf5")
+
+Read from .hdf5 file using:
+    pyplot() #Must first select backend
+    pread = Plots.hdf5plot_read("plotsave.hdf5")
+    display(pread)
+==#
+
+
+#==TODO
+===============================================================================
+ 1. Support more features.
+    - GridLayout known not to be working.
+ 2. Improve error handling.
+    - Will likely crash if file format is off.
+ 3. Save data in a folder parallel to "plot".
+    - Will make it easier for users to locate data.
+    - Use HDF5 reference to link data?
+ 4. Develop an actual versioned file format.
+    - Should have some form of backward compatibility.
+    - Should be reliable for archival purposes.
+ 5. Fix construction of plot object with hdf5plot_read.
+    - Not building object correctly when backends do not natively support
+      a certain feature (ex: :steppre)
+==#
+
+import FixedPointNumbers: N0f8 #In core Julia
+
+#Dispatch types:
+struct HDF5PlotNative; end #Indentifies a data element that can natively be handled by HDF5
+struct HDF5CTuple; end #Identifies a "complex" tuple structure
+
+mutable struct HDF5Plot_PlotRef
+	ref::Union{Plot, Nothing}
+end
+
+
+#==Useful constants
+===============================================================================#
+const _hdf5_nullable{T} = Union{T, Nothing}
+const _hdf5_plotroot = "plot"
+const _hdf5_dataroot = "data" #TODO: Eventually move data to different root (easier to locate)?
+const _hdf5plot_datatypeid = "TYPE" #Attribute identifying type
+const _hdf5plot_countid = "COUNT" #Attribute for storing count
+
+#Dict has problems using "Types" as keys.  Initialize in "_initialize_backend":
+const HDF5PLOT_MAP_STR2TELEM = Dict{String, Type}()
+const HDF5PLOT_MAP_TELEM2STR = Dict{Type, String}()
+
+#Don't really like this global variable... Very hacky
+const HDF5PLOT_PLOTREF = HDF5Plot_PlotRef(nothing)
+
+#Simple sub-structures that can just be written out using _hdf5plot_gwritefields:
+const HDF5PLOT_SIMPLESUBSTRUCT = Union{Font, BoundingBox,
+	GridLayout, RootLayout, ColorGradient, SeriesAnnotations, PlotText,
+	Shape,
+}
+
+
+#==
+===============================================================================#
+is_marker_supported(::HDF5Backend, shape::Shape) = true
+
+if length(HDF5PLOT_MAP_TELEM2STR) < 1
+    #Possible element types of high-level data types:
+    telem2str = Dict{String, Type}(
+        "NATIVE" => HDF5PlotNative,
+        "VOID" => Nothing,
+        "BOOL" => Bool,
+        "SYMBOL" => Symbol,
+        "TUPLE" => Tuple,
+        "CTUPLE" => HDF5CTuple, #Tuple of complex structures
+        "RGBA" => ARGB{N0f8},
+        "EXTREMA" => Extrema,
+        "LENGTH" => Length,
+        "ARRAY" => Array, #Dict won't allow Array to be key in HDF5PLOT_MAP_TELEM2STR
+
+        #Sub-structure types:
+        "FONT" => Font,
+        "BOUNDINGBOX" => BoundingBox,
+        "GRIDLAYOUT" => GridLayout,
+        "ROOTLAYOUT" => RootLayout,
+        "SERIESANNOTATIONS" => SeriesAnnotations,
+        "PLOTTEXT" => PlotText,
+        "SHAPE" => Shape,
+        "COLORGRADIENT" => ColorGradient,
+        "AXIS" => Axis,
+        "SURFACE" => Surface,
+        "SUBPLOT" => Subplot,
+        "NULLABLE" => _hdf5_nullable,
+    )
+    merge!(HDF5PLOT_MAP_STR2TELEM, telem2str)
+    merge!(HDF5PLOT_MAP_TELEM2STR, Dict{Type, String}(v=>k for (k,v) in HDF5PLOT_MAP_STR2TELEM))
+end
+
+
+#==Helper functions
+===============================================================================#
+
+_hdf5_plotelempath(subpath::String) = "$_hdf5_plotroot/$subpath"
+_hdf5_datapath(subpath::String) = "$_hdf5_dataroot/$subpath"
+_hdf5_map_str2telem(k::String) = HDF5PLOT_MAP_STR2TELEM[k]
+_hdf5_map_str2telem(v::Vector) = HDF5PLOT_MAP_STR2TELEM[v[1]]
+
+function _hdf5_merge!(dest::Dict, src::Dict)
+    for (k, v) in src
+        if isa(v, Axis)
+            _hdf5_merge!(dest[k].plotattributes, v.plotattributes)
+        else
+            dest[k] = v
+        end
+    end
+    return
+end
+
+
+#==
+===============================================================================#
+
+
+# Create the window/figure for this backend.
+function _create_backend_figure(plt::Plot{HDF5Backend})
+    #Do nothing
+end
+
+# ---------------------------------------------------------------------------
+
+# # this is called early in the pipeline, use it to make the plot current or something
+# function _prepare_plot_object(plt::Plot{HDF5Backend})
+# end
+
+# ---------------------------------------------------------------------------
+
+# Set up the subplot within the backend object.
+function _initialize_subplot(plt::Plot{HDF5Backend}, sp::Subplot{HDF5Backend})
+    #Do nothing
+end
+
+# ---------------------------------------------------------------------------
+
+# Add one series to the underlying backend object.
+# Called once per series
+# NOTE: Seems to be called when user calls plot()... even if backend
+#       plot, sp.o has not yet been constructed...
+function _series_added(plt::Plot{HDF5Backend}, series::Series)
+    #Do nothing
+end
+
+# ---------------------------------------------------------------------------
+
+# When series data is added/changed, this callback can do dynamic updates to the backend object.
+# note: if the backend rebuilds the plot from scratch on display, then you might not do anything here.
+function _series_updated(plt::Plot{HDF5Backend}, series::Series)
+    #Do nothing
+end
+
+# ---------------------------------------------------------------------------
+
+# called just before updating layout bounding boxes... in case you need to prep
+# for the calcs
+function _before_layout_calcs(plt::Plot{HDF5Backend})
+    #Do nothing
+end
+
+# ----------------------------------------------------------------
+
+# Set the (left, top, right, bottom) minimum padding around the plot area
+# to fit ticks, tick labels, guides, colorbars, etc.
+function _update_min_padding!(sp::Subplot{HDF5Backend})
+    #Do nothing
+end
+
+# ----------------------------------------------------------------
+
+# Override this to update plot items (title, xlabel, etc), and add annotations (plotattributes[:annotations])
+function _update_plot_object(plt::Plot{HDF5Backend})
+    #Do nothing
+end
+
+# ----------------------------------------------------------------
+
+# Display/show the plot (open a GUI window, or browser page, for example).
+function _display(plt::Plot{HDF5Backend})
+    msg = "HDF5 interface does not support `display()` function."
+    msg *= "\nUse `Plots.hdf5plot_write(::String)` method to write to .HDF5 \"plot\" file instead."
+    @warn(msg)
+    return
+end
+
+
+#==HDF5 write functions
+===============================================================================#
+
+function _hdf5plot_writetype(grp, k::String, tstr::Array{String})
+    d = HDF5.d_open(grp, k)
+    HDF5.a_write(d, _hdf5plot_datatypeid, tstr)
+end
+function _hdf5plot_writetype(grp, k::String, T::Type)
+    tstr = HDF5PLOT_MAP_TELEM2STR[T]
+    d = HDF5.d_open(grp, k)
+    HDF5.a_write(d, _hdf5plot_datatypeid, tstr)
+end
+function _hdf5plot_overwritetype(grp, k::String, T::Type)
+    tstr = HDF5PLOT_MAP_TELEM2STR[T]
+    d = HDF5.d_open(grp, k)
+    HDF5.a_delete(d, _hdf5plot_datatypeid)
+    HDF5.a_write(d, _hdf5plot_datatypeid, tstr)
+end
+function _hdf5plot_writetype(grp, T::Type) #Write directly to group
+    tstr = HDF5PLOT_MAP_TELEM2STR[T]
+    HDF5.a_write(grp, _hdf5plot_datatypeid, tstr)
+end
+function _hdf5plot_overwritetype(grp, T::Type) #Write directly to group
+    tstr = HDF5PLOT_MAP_TELEM2STR[T]
+    HDF5.a_delete(grp, _hdf5plot_datatypeid)
+    HDF5.a_write(grp, _hdf5plot_datatypeid, tstr)
+end
+function _hdf5plot_writetype(grp, ::Type{Array{T}}) where T<:Any
+    tstr = HDF5PLOT_MAP_TELEM2STR[Array] #ANY
+    HDF5.a_write(grp, _hdf5plot_datatypeid, tstr)
+end
+function _hdf5plot_writetype(grp, ::Type{T}) where T<:BoundingBox
+    tstr = HDF5PLOT_MAP_TELEM2STR[BoundingBox]
+    HDF5.a_write(grp, _hdf5plot_datatypeid, tstr)
+end
+function _hdf5plot_writecount(grp, n::Int) #Write directly to group
+    HDF5.a_write(grp, _hdf5plot_countid, n)
+end
+function _hdf5plot_gwritefields(grp, k::String, v)
+    grp = HDF5.g_create(grp, k)
+    for _k in fieldnames(typeof(v))
+        _v = getfield(v, _k)
+        kstr = string(_k)
+        _hdf5plot_gwrite(grp, kstr, _v)
+    end
+    _hdf5plot_writetype(grp, typeof(v))
+    return
+end
+
+# Write data
+# ----------------------------------------------------------------
+
+function _hdf5plot_gwrite(grp, k::String, v) #Default
+    T = typeof(v)
+    if !(T <: Number || T <: String)
+        tstr = string(T)
+        path = HDF5.name(grp) * "/" * k
+        @info("Type not supported: $tstr\npath: $path")
+#        @show v
+        return
+    end
+    grp[k] = v
+    _hdf5plot_writetype(grp, k, HDF5PlotNative)
+end
+function _hdf5plot_gwrite(grp, k::String, v::Array{T}) where T<:Number #Default for arrays
+    grp[k] = v
+    _hdf5plot_writetype(grp, k, HDF5PlotNative)
+end
+#=
+function _hdf5plot_gwrite(grp, k::String, v::Array{Any})
+#    @show grp, k
+    @warn("Cannot write Array: $k=$v")
+end
+=#
+function _hdf5plot_gwrite(grp, k::String, v::Nothing)
+    grp[k] = 0
+    _hdf5plot_writetype(grp, k, Nothing)
+end
+function _hdf5plot_gwrite(grp, k::String, v::Bool)
+    grp[k] = Int(v)
+    _hdf5plot_writetype(grp, k, Bool)
+end
+function _hdf5plot_gwrite(grp, k::String, v::Symbol)
+    grp[k] = string(v)
+    _hdf5plot_writetype(grp, k, Symbol)
+end
+function _hdf5plot_gwrite(grp, k::String, v::Tuple)
+    varr = [v...]
+    elt = eltype(varr)
+#    if isleaftype(elt)
+
+    _hdf5plot_gwrite(grp, k, varr)
+    if elt <: Number
+        #We just wrote a simple dataset
+        _hdf5plot_overwritetype(grp, k, Tuple)
+    else #Used a more complex scheme (using subgroups):
+        _hdf5plot_overwritetype(grp[k], HDF5CTuple)
+    end
+    #NOTE: _hdf5plot_overwritetype overwrites "Array" type with "Tuple".
+end
+function _hdf5plot_gwrite(grp, k::String, plotattributes::Dict)
+#    @warn("Cannot write dict: $k=$plotattributes")
+end
+function _hdf5plot_gwrite(grp, k::String, v::AbstractRange)
+    _hdf5plot_gwrite(grp, k, collect(v)) #For now
+end
+function _hdf5plot_gwrite(grp, k::String, v::ARGB{N0f8})
+    grp[k] = [v.r.i, v.g.i, v.b.i, v.alpha.i]
+    _hdf5plot_writetype(grp, k, ARGB{N0f8})
+end
+function _hdf5plot_gwrite(grp, k::String, v::Colorant)
+    _hdf5plot_gwrite(grp, k, ARGB{N0f8}(v))
+end
+#Custom vector (when not using simple numeric type):
+function _hdf5plot_gwritearray(grp, k::String, v::Array{T}) where T
+    vgrp = HDF5.g_create(grp, k)
+    _hdf5plot_writetype(vgrp, Array) #ANY
+    sz = size(v)
+    lidx = LinearIndices(sz)
+
+    for iter in eachindex(v)
+        coord = lidx[iter]
+        elem = v[iter]
+        idxstr = join(coord, "_")
+        _hdf5plot_gwrite(vgrp, "v$idxstr", elem)
+    end
+
+    _hdf5plot_gwrite(vgrp, "dim", [sz...])
+    return
+end
+_hdf5plot_gwrite(grp, k::String, v::Array) =
+	_hdf5plot_gwritearray(grp, k, v)
+function _hdf5plot_gwrite(grp, k::String, v::Extrema)
+    grp[k] = [v.emin, v.emax]
+    _hdf5plot_writetype(grp, k, Extrema)
+end
+function _hdf5plot_gwrite(grp, k::String, v::Length{T}) where T
+    grp[k] = v.value
+    _hdf5plot_writetype(grp, k, [HDF5PLOT_MAP_TELEM2STR[Length], string(T)])
+end
+
+# Write more complex structures:
+# ----------------------------------------------------------------
+
+function _hdf5plot_gwrite(grp, k::String, v::Plot)
+    #Don't write plot references
+end
+function _hdf5plot_gwrite(grp, k::String, v::HDF5PLOT_SIMPLESUBSTRUCT)
+    _hdf5plot_gwritefields(grp, k, v)
+    return
+end
+function _hdf5plot_gwrite(grp, k::String, v::Axis)
+    grp = HDF5.g_create(grp, k)
+    for (_k, _v) in v.plotattributes
+        kstr = string(_k)
+        _hdf5plot_gwrite(grp, kstr, _v)
+    end
+    _hdf5plot_writetype(grp, Axis)
+    return
+end
+function _hdf5plot_gwrite(grp, k::String, v::Surface)
+	grp = HDF5.g_create(grp, k)
+	_hdf5plot_gwrite(grp, "data2d", v.surf)
+	_hdf5plot_writetype(grp, Surface)
+end
+# #TODO: "Properly" support Nullable using _hdf5plot_writetype?
+# function _hdf5plot_gwrite(grp, k::String, v::_hdf5_nullable)
+#     if isnull(v)
+#         _hdf5plot_gwrite(grp, k, nothing)
+#     else
+#         _hdf5plot_gwrite(grp, k, v.value)
+#     end
+#     return
+# end
+
+function _hdf5plot_gwrite(grp, k::String, v::Subplot)
+    grp = HDF5.g_create(grp, k)
+    _hdf5plot_gwrite(grp, "index", v[:subplot_index])
+    _hdf5plot_writetype(grp, Subplot)
+    return
+end
+function _hdf5plot_write(grp, plotattributes::Dict)
+    for (k, v) in plotattributes
+        kstr = string(k)
+        _hdf5plot_gwrite(grp, kstr, v)
+    end
+    return
+end
+
+# Write main plot structures:
+# ----------------------------------------------------------------
+
+function _hdf5plot_write(sp::Subplot{HDF5Backend}, subpath::String, f)
+    f = f::HDF5.HDF5File #Assert
+    grp = HDF5.g_create(f, _hdf5_plotelempath("$subpath/attr"))
+    _hdf5plot_write(grp, sp.attr)
+    grp = HDF5.g_create(f, _hdf5_plotelempath("$subpath/series_list"))
+    _hdf5plot_writecount(grp, length(sp.series_list))
+    for (i, series) in enumerate(sp.series_list)
+        grp = HDF5.g_create(f, _hdf5_plotelempath("$subpath/series_list/series$i"))
+        _hdf5plot_write(grp, series.plotattributes)
+    end
+
+    return
+end
+
+function _hdf5plot_write(plt::Plot{HDF5Backend}, f)
+    f = f::HDF5.HDF5File #Assert
+
+    grp = HDF5.g_create(f, _hdf5_plotelempath("attr"))
+    _hdf5plot_write(grp, plt.attr)
+
+    grp = HDF5.g_create(f, _hdf5_plotelempath("subplots"))
+    _hdf5plot_writecount(grp, length(plt.subplots))
+
+    for (i, sp) in enumerate(plt.subplots)
+        _hdf5plot_write(sp, "subplots/subplot$i", f)
+    end
+
+    return
+end
+function hdf5plot_write(plt::Plot{HDF5Backend}, path::AbstractString)
+    HDF5.h5open(path, "w") do file
+        _hdf5plot_write(plt, file)
+    end
+end
+hdf5plot_write(path::AbstractString) = hdf5plot_write(current(), path)
+
+
+#==HDF5 playback (read) functions
+===============================================================================#
+
+function _hdf5plot_readcount(grp) #Read directly from group
+    return HDF5.a_read(grp, _hdf5plot_countid)
+end
+
+_hdf5plot_convert(T::Type{HDF5PlotNative}, v) = v
+_hdf5plot_convert(T::Type{Nothing}, v) = nothing
+_hdf5plot_convert(T::Type{Bool}, v) = (v!=0)
+_hdf5plot_convert(T::Type{Symbol}, v) = Symbol(v)
+_hdf5plot_convert(T::Type{Tuple}, v) = tuple(v...) #With Vector{T<:Number}
+function _hdf5plot_convert(T::Type{ARGB{N0f8}}, v)
+    r, g, b, a = reinterpret(N0f8, v)
+    return Colors.ARGB{N0f8}(r, g, b, a)
+end
+_hdf5plot_convert(T::Type{Extrema}, v) = Extrema(v[1], v[2])
+
+# Read data structures:
+# ----------------------------------------------------------------
+
+function _hdf5plot_read(grp, k::String, T::Type, dtid)
+    v = HDF5.d_read(grp, k)
+    return _hdf5plot_convert(T, v)
+end
+function _hdf5plot_read(grp, k::String, T::Type{Length}, dtid::Vector)
+    v = HDF5.d_read(grp, k)
+    TU = Symbol(dtid[2])
+    T = typeof(v)
+    return Length{TU,T}(v)
+end
+
+# Read more complex data structures:
+# ----------------------------------------------------------------
+function _hdf5plot_read(grp, k::String, T::Type{Font}, dtid)
+    grp = HDF5.g_open(grp, k)
+
+    family = _hdf5plot_read(grp, "family")
+    pointsize = _hdf5plot_read(grp, "pointsize")
+    halign = _hdf5plot_read(grp, "halign")
+    valign = _hdf5plot_read(grp, "valign")
+    rotation = _hdf5plot_read(grp, "rotation")
+    color = _hdf5plot_read(grp, "color")
+    return Font(family, pointsize, halign, valign, rotation, color)
+end
+function _hdf5plot_read(grp, k::String, T::Type{Array}, dtid) #ANY
+    grp = HDF5.g_open(grp, k)
+    sz = _hdf5plot_read(grp, "dim")
+    if [0] == sz; return []; end
+    sz = tuple(sz...)
+    result = Array{Any}(undef, sz)
+    lidx = LinearIndices(sz)
+
+    for iter in eachindex(result)
+        coord = lidx[iter]
+        idxstr = join(coord, "_")
+        result[iter] = _hdf5plot_read(grp, "v$idxstr")
+    end
+
+    #Hack: Implicitly make Julia detect element type.
+    #      (Should probably write it explicitly to file)
+    result = [result[iter] for iter in eachindex(result)] #Potentially make more specific
+    return reshape(result, sz)
+end
+function _hdf5plot_read(grp, k::String, T::Type{HDF5CTuple}, dtid)
+    v = _hdf5plot_read(grp, k, Array, dtid)
+    return tuple(v...)
+end
+function _hdf5plot_read(grp, k::String, T::Type{PlotText}, dtid)
+    grp = HDF5.g_open(grp, k)
+
+    str = _hdf5plot_read(grp, "str")
+    font = _hdf5plot_read(grp, "font")
+    return PlotText(str, font)
+end
+function _hdf5plot_read(grp, k::String, T::Type{SeriesAnnotations}, dtid)
+    grp = HDF5.g_open(grp, k)
+
+    strs = _hdf5plot_read(grp, "strs")
+    font = _hdf5plot_read(grp, "font")
+    baseshape = _hdf5plot_read(grp, "baseshape")
+    scalefactor = _hdf5plot_read(grp, "scalefactor")
+    return SeriesAnnotations(strs, font, baseshape, scalefactor)
+end
+function _hdf5plot_read(grp, k::String, T::Type{Shape}, dtid)
+    grp = HDF5.g_open(grp, k)
+
+    x = _hdf5plot_read(grp, "x")
+    y = _hdf5plot_read(grp, "y")
+    return Shape(x, y)
+end
+function _hdf5plot_read(grp, k::String, T::Type{ColorGradient}, dtid)
+    grp = HDF5.g_open(grp, k)
+
+    colors = _hdf5plot_read(grp, "colors")
+    values = _hdf5plot_read(grp, "values")
+    return ColorGradient(colors, values)
+end
+function _hdf5plot_read(grp, k::String, T::Type{BoundingBox}, dtid)
+    grp = HDF5.g_open(grp, k)
+
+    x0 = _hdf5plot_read(grp, "x0")
+    a = _hdf5plot_read(grp, "a")
+    return BoundingBox(x0, a)
+end
+_hdf5plot_read(grp, k::String, T::Type{RootLayout}, dtid) = RootLayout()
+function _hdf5plot_read(grp, k::String, T::Type{GridLayout}, dtid)
+    grp = HDF5.g_open(grp, k)
+
+#    parent = _hdf5plot_read(grp, "parent")
+parent = RootLayout()
+    minpad = _hdf5plot_read(grp, "minpad")
+    bbox = _hdf5plot_read(grp, "bbox")
+    grid = _hdf5plot_read(grp, "grid")
+    widths = _hdf5plot_read(grp, "widths")
+    heights = _hdf5plot_read(grp, "heights")
+    attr = KW() #TODO support attr: _hdf5plot_read(grp, "attr")
+
+    return GridLayout(parent, minpad, bbox, grid, widths, heights, attr)
+end
+function _hdf5plot_read(grp, k::String, T::Type{Axis}, dtid)
+    grp = HDF5.g_open(grp, k)
+    kwlist = KW()
+    _hdf5plot_read(grp, kwlist)
+    return Axis([], kwlist)
+end
+function _hdf5plot_read(grp, k::String, T::Type{Surface}, dtid)
+    grp = HDF5.g_open(grp, k)
+    data2d = _hdf5plot_read(grp, "data2d")
+    return Surface(data2d)
+end
+function _hdf5plot_read(grp, k::String, T::Type{Subplot}, dtid)
+    grp = HDF5.g_open(grp, k)
+    idx = _hdf5plot_read(grp, "index")
+    return HDF5PLOT_PLOTREF.ref.subplots[idx]
+end
+function _hdf5plot_read(grp, k::String)
+    dtid = HDF5.a_read(grp[k], _hdf5plot_datatypeid)
+    T = _hdf5_map_str2telem(dtid) #expect exception
+    return _hdf5plot_read(grp, k, T, dtid)
+end
+
+#Read in values in group to populate plotattributes:
+function _hdf5plot_read(grp, plotattributes::Dict)
+    gnames = names(grp)
+    for k in gnames
+        try
+            v = _hdf5plot_read(grp, k)
+            plotattributes[Symbol(k)] = v
+        catch e
+            @show e
+            @show grp
+            @warn("Could not read field $k")
+        end
+    end
+    return
+end
+
+# Read main plot structures:
+# ----------------------------------------------------------------
+
+function _hdf5plot_read(sp::Subplot, subpath::String, f)
+    f = f::HDF5.HDF5File #Assert
+
+    grp = HDF5.g_open(f, _hdf5_plotelempath("$subpath/series_list"))
+    nseries = _hdf5plot_readcount(grp)
+
+    for i in 1:nseries
+        grp = HDF5.g_open(f, _hdf5_plotelempath("$subpath/series_list/series$i"))
+        kwlist = KW()
+        _hdf5plot_read(grp, kwlist)
+        plot!(sp, kwlist[:x], kwlist[:y]) #Add data & create data structures
+        _hdf5_merge!(sp.series_list[end].plotattributes, kwlist)
+    end
+
+    #Perform after adding series... otherwise values get overwritten:
+    grp = HDF5.g_open(f, _hdf5_plotelempath("$subpath/attr"))
+    kwlist = KW()
+    _hdf5plot_read(grp, kwlist)
+    _hdf5_merge!(sp.attr, kwlist)
+
+    return
+end
+
+function _hdf5plot_read(plt::Plot, f)
+    f = f::HDF5.HDF5File #Assert
+    #Assumpltion: subplots are already allocated (plt.subplots)
+
+    HDF5PLOT_PLOTREF.ref = plt #Used when reading "layout"
+    grp = HDF5.g_open(f, _hdf5_plotelempath("attr"))
+    _hdf5plot_read(grp, plt.attr)
+
+    for (i, sp) in enumerate(plt.subplots)
+        _hdf5plot_read(sp, "subplots/subplot$i", f)
+    end
+
+    return
+end
+
+function hdf5plot_read(path::AbstractString)
+    plt = nothing
+    HDF5.h5open(path, "r") do file
+        grp = HDF5.g_open(file, _hdf5_plotelempath("subplots"))
+        n = _hdf5plot_readcount(grp)
+        plt = plot(layout=n) #Get reference to a new plot
+        _hdf5plot_read(plt, file)
+    end
+    return plt
+end
+
+#Last line

src/backends/inspectdr.jl

@@ -0,0 +1,476 @@
+
+# https://github.com/ma-laforge/InspectDR.jl
+
+#=TODO:
+    Tweak scale factor for width & other sizes
+
+Not supported by InspectDR:
+    :foreground_color_grid
+    :foreground_color_border
+    :polar,
+
+Add in functionality to Plots.jl:
+    :aspect_ratio,
+=#
+
+# ---------------------------------------------------------------------------
+
+is_marker_supported(::InspectDRBackend, shape::Shape) = true
+
+_inspectdr_to_pixels(bb::BoundingBox) =
+    InspectDR.BoundingBox(to_pixels(left(bb)), to_pixels(right(bb)), to_pixels(top(bb)), to_pixels(bottom(bb)))
+
+#Do we avoid Map to avoid possible pre-comile issues?
+function _inspectdr_mapglyph(s::Symbol)
+    s == :rect && return :square
+    return s
+end
+
+function _inspectdr_mapglyph(s::Shape)
+    x, y = coords(s)
+    return InspectDR.GlyphPolyline(x, y)
+end
+
+# py_marker(markers::AVec) = map(py_marker, markers)
+function _inspectdr_mapglyph(markers::AVec)
+    @warn("Vectors of markers are currently unsupported in InspectDR.")
+    _inspectdr_mapglyph(markers[1])
+end
+
+_inspectdr_mapglyphsize(v::Real) = v
+function _inspectdr_mapglyphsize(v::Vector)
+    @warn("Vectors of marker sizes are currently unsupported in InspectDR.")
+    _inspectdr_mapglyphsize(v[1])
+end
+
+_inspectdr_mapcolor(v::Colorant) = v
+function _inspectdr_mapcolor(g::PlotUtils.ColorGradient)
+    @warn("Color gradients are currently unsupported in InspectDR.")
+    #Pick middle color:
+    _inspectdr_mapcolor(g.colors[div(1+end,2)])
+end
+function _inspectdr_mapcolor(v::AVec)
+    @warn("Vectors of colors are currently unsupported in InspectDR.")
+    #Pick middle color:
+    _inspectdr_mapcolor(v[div(1+end,2)])
+end
+
+#Hack: suggested point size does not seem adequate relative to plot size, for some reason.
+_inspectdr_mapptsize(v) = 1.5*v
+
+function _inspectdr_add_annotations(plot, x, y, val)
+    #What kind of annotation is this?
+end
+
+#plot::InspectDR.Plot2D
+function _inspectdr_add_annotations(plot, x, y, val::PlotText)
+    vmap = Dict{Symbol, Symbol}(:top=>:t, :bottom=>:b) #:vcenter
+    hmap = Dict{Symbol, Symbol}(:left=>:l, :right=>:r) #:hcenter
+    align = Symbol(get(vmap, val.font.valign, :c), get(hmap, val.font.halign, :c))
+    fnt = InspectDR.Font(val.font.family, val.font.pointsize,
+        color =_inspectdr_mapcolor(val.font.color)
+    )
+    ann = InspectDR.atext(val.str, x=x, y=y,
+        font=fnt, angle=val.font.rotation, align=align
+    )
+    InspectDR.add(plot, ann)
+    return
+end
+
+# ---------------------------------------------------------------------------
+
+function _inspectdr_getscale(s::Symbol, yaxis::Bool)
+#TODO: Support :asinh, :sqrt
+    kwargs = yaxis ? (:tgtmajor=>8, :tgtminor=>2) : () #More grid lines on y-axis
+    if :log2 == s
+        return InspectDR.AxisScale(:log2; kwargs...)
+    elseif :log10 == s
+        return InspectDR.AxisScale(:log10; kwargs...)
+    elseif :ln == s
+        return InspectDR.AxisScale(:ln; kwargs...)
+    else #identity
+        return InspectDR.AxisScale(:lin; kwargs...)
+    end
+end
+
+# ---------------------------------------------------------------------------
+
+#Glyph used when plotting "Shape"s:
+INSPECTDR_GLYPH_SHAPE = InspectDR.GlyphPolyline(
+    2*InspectDR.GLYPH_SQUARE.x, InspectDR.GLYPH_SQUARE.y
+)
+
+mutable struct InspecDRPlotRef
+    mplot::Union{Nothing, InspectDR.Multiplot}
+    gui::Union{Nothing, InspectDR.GtkPlot}
+end
+
+_inspectdr_getmplot(::Any) = nothing
+_inspectdr_getmplot(r::InspecDRPlotRef) = r.mplot
+
+_inspectdr_getgui(::Any) = nothing
+_inspectdr_getgui(gplot::InspectDR.GtkPlot) = (gplot.destroyed ? nothing : gplot)
+_inspectdr_getgui(r::InspecDRPlotRef) = _inspectdr_getgui(r.gui)
+push!(_initialized_backends, :inspectdr)
+
+# ---------------------------------------------------------------------------
+
+# Create the window/figure for this backend.
+function _create_backend_figure(plt::Plot{InspectDRBackend})
+    mplot = _inspectdr_getmplot(plt.o)
+    gplot = _inspectdr_getgui(plt.o)
+
+    #:overwrite_figure: want to reuse current figure
+    if plt[:overwrite_figure] && mplot !== nothing
+        mplot.subplots = [] #Reset
+        if gplot !== nothing #Ensure still references current plot
+            gplot.src = mplot
+        end
+    else #want new one:
+        mplot = InspectDR.Multiplot()
+        gplot = nothing #Will be created later
+    end
+
+    #break link with old subplots
+    for sp in plt.subplots
+        sp.o = nothing
+    end
+
+    return InspecDRPlotRef(mplot, gplot)
+end
+
+# ---------------------------------------------------------------------------
+
+# # this is called early in the pipeline, use it to make the plot current or something
+# function _prepare_plot_object(plt::Plot{InspectDRBackend})
+# end
+
+# ---------------------------------------------------------------------------
+
+# Set up the subplot within the backend object.
+function _initialize_subplot(plt::Plot{InspectDRBackend}, sp::Subplot{InspectDRBackend})
+    plot = sp.o
+    #Don't do anything without a "subplot" object:  Will process later.
+    if nothing == plot; return; end
+    plot.data = []
+    plot.userannot = [] #Clear old markers/text annotation/polyline "annotation"
+    return plot
+end
+
+# ---------------------------------------------------------------------------
+
+# Add one series to the underlying backend object.
+# Called once per series
+# NOTE: Seems to be called when user calls plot()... even if backend
+#       plot, sp.o has not yet been constructed...
+function _series_added(plt::Plot{InspectDRBackend}, series::Series)
+    st = series[:seriestype]
+    sp = series[:subplot]
+    plot = sp.o
+
+    #Don't do anything without a "subplot" object:  Will process later.
+    if nothing == plot; return; end
+
+    _vectorize(v) = isa(v, Vector) ? v : collect(v) #InspectDR only supports vectors
+    x, y = if st == :straightline
+        straightline_data(series)
+    else
+        _vectorize(series[:x]), _vectorize(series[:y])
+    end
+
+    #No support for polar grid... but can still perform polar transformation:
+    if ispolar(sp)
+        Θ = x; r = y
+        x = r.*cos.(Θ); y = r.*sin.(Θ)
+    end
+
+    # doesn't handle mismatched x/y - wrap data (pyplot behaviour):
+    nx = length(x); ny = length(y)
+    if nx < ny
+        series[:x] = Float64[x[mod1(i,nx)] for i=1:ny]
+    elseif ny > nx
+        series[:y] = Float64[y[mod1(i,ny)] for i=1:nx]
+    end
+
+#= TODO: Eventually support
+    series[:fillcolor] #I think this is fill under line
+    zorder = series[:series_plotindex]
+
+For st in :shape:
+    zorder = series[:series_plotindex],
+=#
+
+    if st in (:shape,)
+        x, y = shape_data(series)
+        nmax = 0
+        for (i,rng) in enumerate(iter_segments(x, y))
+            nmax = i
+            if length(rng) > 1
+                linewidth = series[:linewidth]
+                c = plot_color(get_linecolor(series), get_linealpha(series))
+                linecolor = _inspectdr_mapcolor(_cycle(c, i))
+                c = plot_color(get_fillcolor(series), get_fillalpha(series))
+                fillcolor = _inspectdr_mapcolor(_cycle(c, i))
+                line = InspectDR.line(
+                    style=:solid, width=linewidth, color=linecolor
+                )
+                apline = InspectDR.PolylineAnnotation(
+                    x[rng], y[rng], line=line, fillcolor=fillcolor
+                )
+                InspectDR.add(plot, apline)
+            end
+        end
+
+        i = (nmax >= 2 ? div(nmax, 2) : nmax) #Must pick one set of colors for legend
+        if i > 1 #Add dummy waveform for legend entry:
+            linewidth = series[:linewidth]
+            c = plot_color(get_linecolor(series), get_linealpha(series))
+            linecolor = _inspectdr_mapcolor(_cycle(c, i))
+            c = plot_color(get_fillcolor(series), get_fillalpha(series))
+            fillcolor = _inspectdr_mapcolor(_cycle(c, i))
+            wfrm = InspectDR.add(plot, Float64[], Float64[], id=series[:label])
+            wfrm.line = InspectDR.line(
+                style=:none, width=linewidth, #linewidth affects glyph
+            )
+            wfrm.glyph = InspectDR.glyph(
+                shape = INSPECTDR_GLYPH_SHAPE, size = 8,
+                color = linecolor, fillcolor = fillcolor
+            )
+        end
+   elseif st in (:path, :scatter, :straightline) #, :steppre, :steppost)
+        #NOTE: In Plots.jl, :scatter plots have 0-linewidths (I think).
+        linewidth = series[:linewidth]
+        #More efficient & allows some support for markerstrokewidth:
+        _style = (0==linewidth ? :none : series[:linestyle])
+        wfrm = InspectDR.add(plot, x, y, id=series[:label])
+        wfrm.line = InspectDR.line(
+            style = _style,
+            width = series[:linewidth],
+            color = plot_color(get_linecolor(series), get_linealpha(series)),
+        )
+        #InspectDR does not control markerstrokewidth independently.
+        if :none == _style
+            #Use this property only if no line is displayed:
+            wfrm.line.width = series[:markerstrokewidth]
+        end
+        wfrm.glyph = InspectDR.glyph(
+            shape = _inspectdr_mapglyph(series[:markershape]),
+            size = _inspectdr_mapglyphsize(series[:markersize]),
+            color = _inspectdr_mapcolor(plot_color(series[:markerstrokecolor], series[:markerstrokealpha])),
+            fillcolor = _inspectdr_mapcolor(plot_color(series[:markercolor], series[:markeralpha])),
+        )
+    end
+
+    # this is all we need to add the series_annotations text
+    anns = series[:series_annotations]
+    for (xi,yi,str,fnt) in EachAnn(anns, x, y)
+        _inspectdr_add_annotations(plot, xi, yi, PlotText(str, fnt))
+    end
+    return
+end
+
+# ---------------------------------------------------------------------------
+
+# When series data is added/changed, this callback can do dynamic updates to the backend object.
+# note: if the backend rebuilds the plot from scratch on display, then you might not do anything here.
+function _series_updated(plt::Plot{InspectDRBackend}, series::Series)
+    #Nothing to do
+end
+
+# ---------------------------------------------------------------------------
+
+function _inspectdr_setupsubplot(sp::Subplot{InspectDRBackend})
+    plot = sp.o
+    strip = plot.strips[1] #Only 1 strip supported with Plots.jl
+
+    xaxis = sp[:xaxis]; yaxis = sp[:yaxis]
+    xgrid_show = xaxis[:grid]
+    ygrid_show = yaxis[:grid]
+
+    strip.grid = InspectDR.GridRect(
+    	vmajor=xgrid_show, # vminor=xgrid_show,
+    	hmajor=ygrid_show, # hminor=ygrid_show,
+    )
+
+        plot.xscale = _inspectdr_getscale(xaxis[:scale], false)
+        strip.yscale = _inspectdr_getscale(yaxis[:scale], true)
+        xmin, xmax  = axis_limits(sp, :x)
+        ymin, ymax  = axis_limits(sp, :y)
+        if ispolar(sp)
+            #Plots.jl appears to give (xmin,xmax) ≜ (Θmin,Θmax) & (ymin,ymax) ≜ (rmin,rmax)
+            rmax = NaNMath.max(abs(ymin), abs(ymax))
+            xmin, xmax = -rmax, rmax
+            ymin, ymax = -rmax, rmax
+        end
+        plot.xext = InspectDR.PExtents1D() #reset
+        strip.yext = InspectDR.PExtents1D() #reset
+        plot.xext_full = InspectDR.PExtents1D(xmin, xmax)
+        strip.yext_full = InspectDR.PExtents1D(ymin, ymax)
+    a = plot.annotation
+        a.title = sp[:title]
+        a.xlabel = xaxis[:guide]; a.ylabels = [yaxis[:guide]]
+
+    l = plot.layout
+        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],
+            _inspectdr_mapptsize(xaxis[:guidefontsize]),
+            color = _inspectdr_mapcolor(xaxis[:guidefontcolor])
+        )
+        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],
+            _inspectdr_mapptsize(sp[:legendfontsize]),
+            color = _inspectdr_mapcolor(sp[:legendfontcolor])
+        )
+        l[:frame_legend].fillcolor = _inspectdr_mapcolor(sp[:background_color_legend])
+end
+
+# called just before updating layout bounding boxes... in case you need to prep
+# for the calcs
+function _before_layout_calcs(plt::Plot{InspectDRBackend})
+    mplot = _inspectdr_getmplot(plt.o)
+    if nothing == mplot; return; end
+
+    mplot.title = plt[:plot_title]
+    if "" == mplot.title
+        #Don't use window_title... probably not what you want.
+        #mplot.title = plt[:window_title]
+    end
+    mplot.layout[:frame].fillcolor = _inspectdr_mapcolor(plt[:background_color_outside])
+
+    resize!(mplot.subplots, length(plt.subplots))
+    nsubplots = length(plt.subplots)
+    for (i, sp) in enumerate(plt.subplots)
+        if !isassigned(mplot.subplots, i)
+            mplot.subplots[i] = InspectDR.Plot2D()
+        end
+        sp.o = mplot.subplots[i]
+        plot = sp.o
+        _initialize_subplot(plt, sp)
+        _inspectdr_setupsubplot(sp)
+
+        # add the annotations
+        for ann in sp[:annotations]
+            _inspectdr_add_annotations(plot, ann...)
+        end
+    end
+
+    #Do not yet support absolute plot positionning.
+    #Just try to make things look more-or less ok:
+    if nsubplots <= 1
+        mplot.layout[:ncolumns] = 1
+    elseif nsubplots <= 4
+        mplot.layout[:ncolumns] = 2
+    elseif nsubplots <= 6
+        mplot.layout[:ncolumns] = 3
+    elseif nsubplots <= 12
+        mplot.layout[:ncolumns] = 4
+    else
+        mplot.layout[:ncolumns] = 5
+    end
+
+    for series in plt.series_list
+        _series_added(plt, series)
+    end
+    return
+end
+
+# ----------------------------------------------------------------
+
+# Set the (left, top, right, bottom) minimum padding around the plot area
+# to fit ticks, tick labels, guides, colorbars, etc.
+function _update_min_padding!(sp::Subplot{InspectDRBackend})
+    plot = sp.o
+    if !isa(plot, InspectDR.Plot2D); return sp.minpad; end
+    #Computing plotbounds with 0-BoundingBox returns required padding:
+    bb = InspectDR.plotbounds(plot.layout.values, InspectDR.BoundingBox(0,0,0,0))
+    #NOTE: plotbounds always pads for titles, legends, etc. even if not in use.
+    #TODO: possibly zero-out items not in use??
+
+    # add in the user-specified margin to InspectDR padding:
+    leftpad   = abs(bb.xmin)*px + sp[:left_margin]
+    toppad    = abs(bb.ymin)*px + sp[:top_margin]
+    rightpad  = abs(bb.xmax)*px + sp[:right_margin]
+    bottompad = abs(bb.ymax)*px + sp[:bottom_margin]
+    sp.minpad = (leftpad, toppad, rightpad, bottompad)
+end
+
+# ----------------------------------------------------------------
+
+# Override this to update plot items (title, xlabel, etc), and add annotations (plotattributes[:annotations])
+function _update_plot_object(plt::Plot{InspectDRBackend})
+    mplot = _inspectdr_getmplot(plt.o)
+    if nothing == mplot; return; end
+
+    for (i, sp) in enumerate(plt.subplots)
+        graphbb = _inspectdr_to_pixels(plotarea(sp))
+        plot = mplot.subplots[i]
+        plot.plotbb = InspectDR.plotbounds(plot.layout.values, graphbb)
+    end
+
+    gplot = _inspectdr_getgui(plt.o)
+    if nothing == gplot; return; end
+
+    gplot.src = mplot #Ensure still references current plot
+    InspectDR.refresh(gplot)
+    return
+end
+
+# ----------------------------------------------------------------
+
+const _inspectdr_mimeformats_dpi = Dict(
+    "image/png"               => "png"
+)
+const _inspectdr_mimeformats_nodpi = Dict(
+    "image/svg+xml"           => "svg",
+    "application/eps"         => "eps",
+    "image/eps"               => "eps",
+#    "application/postscript"  => "ps", #TODO: support once Cairo supports PSSurface
+    "application/pdf"         => "pdf"
+)
+_inspectdr_show(io::IO, mime::MIME, ::Nothing, w, h) =
+    throw(ErrorException("Cannot show(::IO, ...) plot - not yet generated"))
+function _inspectdr_show(io::IO, mime::MIME, mplot, w, h)
+    InspectDR._show(io, mime, mplot, Float64(w), Float64(h))
+end
+
+for (mime, fmt) in _inspectdr_mimeformats_dpi
+    @eval function _show(io::IO, mime::MIME{Symbol($mime)}, plt::Plot{InspectDRBackend})
+        dpi = plt[:dpi]#TODO: support
+        _inspectdr_show(io, mime, _inspectdr_getmplot(plt.o), plt[:size]...)
+    end
+end
+for (mime, fmt) in _inspectdr_mimeformats_nodpi
+    @eval function _show(io::IO, mime::MIME{Symbol($mime)}, plt::Plot{InspectDRBackend})
+        _inspectdr_show(io, mime, _inspectdr_getmplot(plt.o), plt[:size]...)
+    end
+end
+
+# ----------------------------------------------------------------
+
+# Display/show the plot (open a GUI window, or browser page, for example).
+function _display(plt::Plot{InspectDRBackend})
+    mplot = _inspectdr_getmplot(plt.o)
+    if nothing == mplot; return; end
+    gplot = _inspectdr_getgui(plt.o)
+
+    if nothing == gplot
+        gplot = display(InspectDR.GtkDisplay(), mplot)
+    else
+        #redundant... Plots.jl will call _update_plot_object:
+        #InspectDR.refresh(gplot)
+    end
+    plt.o = InspecDRPlotRef(mplot, gplot)
+    return gplot
+end

src/backends/pgfplots.jl

@@ -0,0 +1,588 @@
+# https://github.com/sisl/PGFPlots.jl
+
+# significant contributions by: @pkofod
+
+# --------------------------------------------------------------------------------------
+
+const _pgfplots_linestyles = KW(
+    :solid => "solid",
+    :dash => "dashed",
+    :dot => "dotted",
+    :dashdot => "dashdotted",
+    :dashdotdot => "dashdotdotted",
+)
+
+const _pgfplots_markers = KW(
+    :none => "none",
+    :cross => "+",
+    :xcross => "x",
+    :+ => "+",
+    :x => "x",
+    :utriangle => "triangle*",
+    :dtriangle => "triangle*",
+    :circle => "*",
+    :rect => "square*",
+    :star5 => "star",
+    :star6 => "asterisk",
+    :diamond => "diamond*",
+    :pentagon => "pentagon*",
+    :hline => "-",
+    :vline => "|"
+)
+
+const _pgfplots_legend_pos = KW(
+    :bottomleft => "south west",
+    :bottomright => "south east",
+    :topright => "north east",
+    :topleft => "north west",
+    :outertopright => "outer north east",
+)
+
+
+const _pgf_series_extrastyle = KW(
+    :steppre => "const plot mark right",
+    :stepmid => "const plot mark mid",
+    :steppost => "const plot",
+    :sticks => "ycomb",
+    :ysticks => "ycomb",
+    :xsticks => "xcomb",
+)
+
+# PGFPlots uses the anchors to define orientations for example to align left
+# one needs to use the right edge as anchor
+const _pgf_annotation_halign = KW(
+    :center => "",
+    :left => "right",
+    :right => "left"
+)
+
+const _pgf_framestyles = [:box, :axes, :origin, :zerolines, :grid, :none]
+const _pgf_framestyle_defaults = Dict(:semi => :box)
+function pgf_framestyle(style::Symbol)
+    if style in _pgf_framestyles
+        return style
+    else
+        default_style = get(_pgf_framestyle_defaults, style, :axes)
+        @warn("Framestyle :$style is not (yet) supported by the PGFPlots backend. :$default_style was cosen instead.")
+        default_style
+    end
+end
+
+# --------------------------------------------------------------------------------------
+
+# takes in color,alpha, and returns color and alpha appropriate for pgf style
+function pgf_color(c::Colorant)
+    cstr = @sprintf("{rgb,1:red,%.8f;green,%.8f;blue,%.8f}", red(c), green(c), blue(c))
+    cstr, alpha(c)
+end
+
+function pgf_color(grad::ColorGradient)
+    # Can't handle ColorGradient here, fallback to defaults.
+    cstr = @sprintf("{rgb,1:red,%.8f;green,%.8f;blue,%.8f}", 0.0, 0.60560316,0.97868012)
+    cstr, 1
+end
+
+# Generates a colormap for pgfplots based on a ColorGradient
+function pgf_colormap(grad::ColorGradient)
+    join(map(grad.colors) do c
+        @sprintf("rgb=(%.8f,%.8f,%.8f)", red(c), green(c),blue(c))
+    end,", ")
+end
+
+pgf_thickness_scaling(plt::Plot) = plt[:thickness_scaling]
+pgf_thickness_scaling(sp::Subplot) = pgf_thickness_scaling(sp.plt)
+pgf_thickness_scaling(series) = pgf_thickness_scaling(series[:subplot])
+
+function pgf_fillstyle(plotattributes, i = 1)
+    cstr,a = pgf_color(get_fillcolor(plotattributes, i))
+    fa = get_fillalpha(plotattributes, i)
+    if fa !== nothing
+        a = fa
+    end
+    "fill = $cstr, fill opacity=$a"
+end
+
+function pgf_linestyle(linewidth::Real, color, α = 1, linestyle = "solid")
+    cstr, a = pgf_color(plot_color(color, α))
+    """
+    color = $cstr,
+    draw opacity = $a,
+    line width = $linewidth,
+    $(get(_pgfplots_linestyles, linestyle, "solid"))"""
+end
+
+function pgf_linestyle(plotattributes, i = 1)
+    lw = pgf_thickness_scaling(plotattributes) * get_linewidth(plotattributes, i)
+    lc = get_linecolor(plotattributes, i)
+    la = get_linealpha(plotattributes, i)
+    ls = get_linestyle(plotattributes, i)
+    return pgf_linestyle(lw, lc, la, ls)
+end
+
+function pgf_font(fontsize, thickness_scaling = 1, font = "\\selectfont")
+    fs = fontsize * thickness_scaling
+    return string("{\\fontsize{", fs, " pt}{", 1.3fs, " pt}", font, "}")
+end
+
+function pgf_marker(plotattributes, i = 1)
+    shape = _cycle(plotattributes[:markershape], i)
+    cstr, a = pgf_color(plot_color(get_markercolor(plotattributes, i), get_markeralpha(plotattributes, i)))
+    cstr_stroke, a_stroke = pgf_color(plot_color(get_markerstrokecolor(plotattributes, i), get_markerstrokealpha(plotattributes, i)))
+    """
+    mark = $(get(_pgfplots_markers, shape, "*")),
+    mark size = $(pgf_thickness_scaling(plotattributes) * 0.5 * _cycle(plotattributes[:markersize], i)),
+    mark options = {
+        color = $cstr_stroke, draw opacity = $a_stroke,
+        fill = $cstr, fill opacity = $a,
+        line width = $(pgf_thickness_scaling(plotattributes) * _cycle(plotattributes[:markerstrokewidth], i)),
+        rotate = $(shape == :dtriangle ? 180 : 0),
+        $(get(_pgfplots_linestyles, _cycle(plotattributes[:markerstrokestyle], i), "solid"))
+    }"""
+end
+
+function pgf_add_annotation!(o, x, y, val, thickness_scaling = 1)
+    # Construct the style string.
+    # Currently supports color and orientation
+    cstr,a = pgf_color(val.font.color)
+    push!(o, PGFPlots.Plots.Node(val.str, # Annotation Text
+        x, y,
+        style="""
+        $(get(_pgf_annotation_halign,val.font.halign,"")),
+        color=$cstr, draw opacity=$(convert(Float16,a)),
+        rotate=$(val.font.rotation),
+        font=$(pgf_font(val.font.pointsize, thickness_scaling))
+        """))
+end
+
+# --------------------------------------------------------------------------------------
+
+function pgf_series(sp::Subplot, series::Series)
+    plotattributes = series.plotattributes
+    st = plotattributes[:seriestype]
+    series_collection = PGFPlots.Plot[]
+
+    # function args
+    args = if st == :contour
+        plotattributes[:z].surf, plotattributes[:x], plotattributes[:y]
+    elseif is3d(st)
+        plotattributes[:x], plotattributes[:y], plotattributes[:z]
+    elseif st == :straightline
+        straightline_data(series)
+    elseif st == :shape
+        shape_data(series)
+    elseif ispolar(sp)
+        theta, r = plotattributes[:x], plotattributes[:y]
+        rad2deg.(theta), r
+    else
+        plotattributes[:x], plotattributes[:y]
+    end
+
+    # PGFPlots can't handle non-Vector?
+    args = map(a -> if typeof(a) <: AbstractVector && typeof(a) != Vector
+            collect(a)
+        else
+            a
+        end, args)
+
+    if st in (:contour, :histogram2d)
+        style = []
+        kw = KW()
+        push!(style, pgf_linestyle(plotattributes))
+        push!(style, pgf_marker(plotattributes))
+        push!(style, "forget plot")
+
+        kw[:style] = join(style, ',')
+        func = if st == :histogram2d
+            PGFPlots.Histogram2
+        else
+            kw[:labels] = series[:contour_labels]
+            kw[:levels] = series[:levels]
+            PGFPlots.Contour
+        end
+        push!(series_collection, func(args...; kw...))
+
+    else
+        # series segments
+        segments = iter_segments(series)
+        for (i, rng) in enumerate(segments)
+            style = []
+            kw = KW()
+            push!(style, pgf_linestyle(plotattributes, i))
+            push!(style, pgf_marker(plotattributes, i))
+
+            if st == :shape
+                push!(style, pgf_fillstyle(plotattributes, i))
+            end
+
+            # add to legend?
+            if i == 1 && sp[:legend] != :none && should_add_to_legend(series)
+                if plotattributes[:fillrange] !== nothing
+                    push!(style, "forget plot")
+                    push!(series_collection, pgf_fill_legend_hack(plotattributes, args))
+                else
+                    kw[:legendentry] = plotattributes[:label]
+                    if st == :shape # || plotattributes[:fillrange] !== nothing
+                        push!(style, "area legend")
+                    end
+                end
+            else
+                push!(style, "forget plot")
+            end
+
+            seg_args = (arg[rng] for arg in args)
+
+            # include additional style, then add to the kw
+            if haskey(_pgf_series_extrastyle, st)
+                push!(style, _pgf_series_extrastyle[st])
+            end
+            kw[:style] = join(style, ',')
+
+            # add fillrange
+            if series[:fillrange] !== nothing && st != :shape
+                push!(series_collection, pgf_fillrange_series(series, i, _cycle(series[:fillrange], rng), seg_args...))
+            end
+
+            # build/return the series object
+            func = if st == :path3d
+                PGFPlots.Linear3
+            elseif st == :scatter
+                PGFPlots.Scatter
+            else
+                PGFPlots.Linear
+            end
+            push!(series_collection, func(seg_args...; kw...))
+        end
+    end
+    series_collection
+end
+
+function pgf_fillrange_series(series, i, fillrange, args...)
+    st = series[:seriestype]
+    style = []
+    kw = KW()
+    push!(style, "line width = 0")
+    push!(style, "draw opacity = 0")
+    push!(style, pgf_fillstyle(series, i))
+    push!(style, pgf_marker(series, i))
+    push!(style, "forget plot")
+    if haskey(_pgf_series_extrastyle, st)
+        push!(style, _pgf_series_extrastyle[st])
+    end
+    kw[:style] = join(style, ',')
+    func = is3d(series) ? PGFPlots.Linear3 : PGFPlots.Linear
+    return func(pgf_fillrange_args(fillrange, args...)...; kw...)
+end
+
+function pgf_fillrange_args(fillrange, x, y)
+    n = length(x)
+    x_fill = [x; x[n:-1:1]; x[1]]
+    y_fill = [y; _cycle(fillrange, n:-1:1); y[1]]
+    return x_fill, y_fill
+end
+
+function pgf_fillrange_args(fillrange, x, y, z)
+    n = length(x)
+    x_fill = [x; x[n:-1:1]; x[1]]
+    y_fill = [y; y[n:-1:1]; x[1]]
+    z_fill = [z; _cycle(fillrange, n:-1:1); z[1]]
+    return x_fill, y_fill, z_fill
+end
+
+function pgf_fill_legend_hack(plotattributes, args)
+    style = []
+    kw = KW()
+    push!(style, pgf_linestyle(plotattributes, 1))
+    push!(style, pgf_marker(plotattributes, 1))
+    push!(style, pgf_fillstyle(plotattributes, 1))
+    push!(style, "area legend")
+    kw[:legendentry] = plotattributes[:label]
+    kw[:style] = join(style, ',')
+    st = plotattributes[:seriestype]
+    func = if st == :path3d
+        PGFPlots.Linear3
+    elseif st == :scatter
+        PGFPlots.Scatter
+    else
+        PGFPlots.Linear
+    end
+    return func(([arg[1]] for arg in args)...; kw...)
+end
+
+# ----------------------------------------------------------------
+
+function pgf_axis(sp::Subplot, letter)
+    axis = sp[Symbol(letter,:axis)]
+    style = []
+    kw = KW()
+
+    # turn off scaled ticks
+    push!(style, "scaled $(letter) ticks = false")
+
+    # set to supported framestyle
+    framestyle = pgf_framestyle(sp[:framestyle])
+
+    # axis guide
+    kw[Symbol(letter,:label)] = axis[:guide]
+
+    # axis label position
+    labelpos = ""
+    if letter == :x && axis[:guide_position] == :top
+        labelpos = "at={(0.5,1)},above,"
+    elseif letter == :y && axis[:guide_position] == :right
+        labelpos = "at={(1,0.5)},below,"
+    end
+
+    # Add label font
+    cstr, α = pgf_color(plot_color(axis[:guidefontcolor]))
+    push!(style, string(letter, "label style = {", labelpos ,"font = ", pgf_font(axis[:guidefontsize], pgf_thickness_scaling(sp)), ", color = ", cstr, ", draw opacity = ", α, ", rotate = ", axis[:guidefontrotation], "}"))
+
+    # flip/reverse?
+    axis[:flip] && push!(style, "$letter dir=reverse")
+
+    # scale
+    scale = axis[:scale]
+    if scale in (:log2, :ln, :log10)
+        kw[Symbol(letter,:mode)] = "log"
+        scale == :ln || push!(style, "log basis $letter=$(scale == :log2 ? 2 : 10)")
+    end
+
+    # ticks on or off
+    if axis[:ticks] in (nothing, false, :none) || framestyle == :none
+        push!(style, "$(letter)majorticks=false")
+    end
+
+    # grid on or off
+    if axis[:grid] && framestyle != :none
+        push!(style, "$(letter)majorgrids = true")
+    else
+        push!(style, "$(letter)majorgrids = false")
+    end
+
+    # limits
+    # TODO: support zlims
+    if letter != :z
+        lims = ispolar(sp) && letter == :x ? rad2deg.(axis_limits(sp, :x)) : axis_limits(sp, letter)
+        kw[Symbol(letter,:min)] = lims[1]
+        kw[Symbol(letter,:max)] = lims[2]
+    end
+
+    if !(axis[:ticks] in (nothing, false, :none, :native)) && framestyle != :none
+        ticks = get_ticks(sp, axis)
+        #pgf plot ignores ticks with angle below 90 when xmin = 90 so shift values
+        tick_values = ispolar(sp) && letter == :x ? [rad2deg.(ticks[1])[3:end]..., 360, 405] : ticks[1]
+        push!(style, string(letter, "tick = {", join(tick_values,","), "}"))
+        if axis[:showaxis] && axis[:scale] in (:ln, :log2, :log10) && axis[:ticks] == :auto
+            # wrap the power part of label with }
+            tick_labels = Vector{String}(undef, length(ticks[2]))
+            for (i, label) in enumerate(ticks[2])
+                base, power = split(label, "^")
+                power = string("{", power, "}")
+                tick_labels[i] = string(base, "^", power)
+            end
+            push!(style, string(letter, "ticklabels = {\$", join(tick_labels,"\$,\$"), "\$}"))
+        elseif axis[:showaxis]
+            tick_labels = ispolar(sp) && letter == :x ? [ticks[2][3:end]..., "0", "45"] : ticks[2]
+            if axis[:formatter] in (:scientific, :auto)
+                tick_labels = string.("\$", convert_sci_unicode.(tick_labels), "\$")
+                tick_labels = replace.(tick_labels, Ref("×" => "\\times"))
+            end
+            push!(style, string(letter, "ticklabels = {", join(tick_labels,","), "}"))
+        else
+            push!(style, string(letter, "ticklabels = {}"))
+        end
+        push!(style, string(letter, "tick align = ", (axis[:tick_direction] == :out ? "outside" : "inside")))
+        cstr, α = pgf_color(plot_color(axis[:tickfontcolor]))
+        push!(style, string(letter, "ticklabel style = {font = ", pgf_font(axis[:tickfontsize], pgf_thickness_scaling(sp)), ", color = ", cstr, ", draw opacity = ", α, ", rotate = ", axis[:tickfontrotation], "}"))
+        push!(style, string(letter, " grid style = {", pgf_linestyle(pgf_thickness_scaling(sp) * axis[:gridlinewidth], axis[:foreground_color_grid], axis[:gridalpha], axis[:gridstyle]), "}"))
+    end
+
+    # framestyle
+    if framestyle in (:axes, :origin)
+        axispos = framestyle == :axes ? "left" : "middle"
+        if axis[:draw_arrow]
+            push!(style, string("axis ", letter, " line = ", axispos))
+        else
+            # the * after line disables the arrow at the axis
+            push!(style, string("axis ", letter, " line* = ", axispos))
+        end
+    end
+
+    if framestyle == :zerolines
+        push!(style, string("extra ", letter, " ticks = 0"))
+        push!(style, string("extra ", letter, " tick labels = "))
+        push!(style, string("extra ", letter, " tick style = {grid = major, major grid style = {", pgf_linestyle(pgf_thickness_scaling(sp), axis[:foreground_color_border], 1.0), "}}"))
+    end
+
+    if !axis[:showaxis]
+        push!(style, "separate axis lines")
+    end
+    if !axis[:showaxis] || framestyle in (:zerolines, :grid, :none)
+        push!(style, string(letter, " axis line style = {draw opacity = 0}"))
+    else
+        push!(style, string(letter, " axis line style = {", pgf_linestyle(pgf_thickness_scaling(sp), axis[:foreground_color_border], 1.0), "}"))
+    end
+
+    # return the style list and KW args
+    style, kw
+end
+
+# ----------------------------------------------------------------
+
+
+function _update_plot_object(plt::Plot{PGFPlotsBackend})
+    plt.o = PGFPlots.Axis[]
+    # Obtain the total height of the plot by extracting the maximal bottom
+    # coordinate from the bounding box.
+    total_height = bottom(bbox(plt.layout))
+
+    for sp in plt.subplots
+       # first build the PGFPlots.Axis object
+        style = ["unbounded coords=jump"]
+        kw = KW()
+
+        # add to style/kw for each axis
+        for letter in (:x, :y, :z)
+            if letter != :z || is3d(sp)
+                axisstyle, axiskw = pgf_axis(sp, letter)
+                append!(style, axisstyle)
+                merge!(kw, axiskw)
+            end
+        end
+
+        # bounding box values are in mm
+        # note: bb origin is top-left, pgf is bottom-left
+        # A round on 2 decimal places should be enough precision for 300 dpi
+        # plots.
+        bb = bbox(sp)
+        push!(style, """
+            xshift = $(left(bb).value)mm,
+            yshift = $(round((total_height - (bottom(bb))).value, digits=2))mm,
+            axis background/.style={fill=$(pgf_color(sp[:background_color_inside])[1])}
+        """)
+        kw[:width] = "$(width(bb).value)mm"
+        kw[:height] = "$(height(bb).value)mm"
+
+        if sp[:title] != ""
+            kw[:title] = "$(sp[:title])"
+            cstr, α = pgf_color(plot_color(sp[:titlefontcolor]))
+            push!(style, string("title style = {font = ", pgf_font(sp[:titlefontsize], pgf_thickness_scaling(sp)), ", color = ", cstr, ", draw opacity = ", α, ", rotate = ", sp[:titlefontrotation], "}"))
+        end
+
+        if sp[:aspect_ratio] in (1, :equal)
+            kw[:axisEqual] = "true"
+        end
+
+        legpos = sp[:legend]
+        if haskey(_pgfplots_legend_pos, legpos)
+            kw[:legendPos] = _pgfplots_legend_pos[legpos]
+        end
+        cstr, a = pgf_color(plot_color(sp[:background_color_legend]))
+        push!(style, string("legend style = {", pgf_linestyle(pgf_thickness_scaling(sp), sp[:foreground_color_legend], 1.0, "solid"), ",", "fill = $cstr,", "font = ", pgf_font(sp[:legendfontsize], pgf_thickness_scaling(sp)), "}"))
+
+        if any(s[:seriestype] == :contour for s in series_list(sp))
+            kw[:view] = "{0}{90}"
+            kw[:colorbar] = !(sp[:colorbar] in (:none, :off, :hide, false))
+        elseif is3d(sp)
+            azim, elev = sp[:camera]
+            kw[:view] = "{$(azim)}{$(elev)}"
+        end
+
+        axisf = PGFPlots.Axis
+        if sp[:projection] == :polar
+            axisf = PGFPlots.PolarAxis
+            #make radial axis vertical
+            kw[:xmin] = 90
+            kw[:xmax] = 450
+        end
+
+        # Search series for any gradient. In case one series uses a gradient set
+        # the colorbar and colomap.
+        # The reasoning behind doing this on the axis level is that pgfplots
+        # colorbar seems to only works on axis level and needs the proper colormap for
+        # correctly displaying it.
+        # It's also possible to assign the colormap to the series itself but
+        # then the colormap needs to be added twice, once for the axis and once for the
+        # series.
+        # As it is likely that all series within the same axis use the same
+        # colormap this should not cause any problem.
+        for series in series_list(sp)
+            for col in (:markercolor, :fillcolor, :linecolor)
+                if typeof(series.plotattributes[col]) == ColorGradient
+                    push!(style,"colormap={plots}{$(pgf_colormap(series.plotattributes[col]))}")
+
+                    if sp[:colorbar] == :none
+                        kw[:colorbar] = "false"
+                    else
+                        kw[:colorbar] = "true"
+                    end
+                    # goto is needed to break out of col and series for
+                    @goto colorbar_end
+                end
+            end
+        end
+        @label colorbar_end
+
+        push!(style, "colorbar style={title=$(sp[:colorbar_title])}")
+        o = axisf(; style = join(style, ","), kw...)
+
+        # add the series object to the PGFPlots.Axis
+        for series in series_list(sp)
+            push!.(Ref(o), pgf_series(sp, series))
+
+            # add series annotations
+            anns = series[:series_annotations]
+            for (xi,yi,str,fnt) in EachAnn(anns, series[:x], series[:y])
+                pgf_add_annotation!(o, xi, yi, PlotText(str, fnt), pgf_thickness_scaling(series))
+            end
+        end
+
+        # add the annotations
+        for ann in sp[:annotations]
+            pgf_add_annotation!(o, locate_annotation(sp, ann...)..., pgf_thickness_scaling(sp))
+        end
+
+
+        # add the PGFPlots.Axis to the list
+        push!(plt.o, o)
+    end
+end
+
+function _show(io::IO, mime::MIME"image/svg+xml", plt::Plot{PGFPlotsBackend})
+    show(io, mime, plt.o)
+end
+
+function _show(io::IO, mime::MIME"application/pdf", plt::Plot{PGFPlotsBackend})
+    # prepare the object
+    pgfplt = PGFPlots.plot(plt.o)
+
+    # save a pdf
+    fn = tempname()*".pdf"
+    PGFPlots.save(PGFPlots.PDF(fn), pgfplt)
+
+    # read it into io
+    write(io, read(open(fn), String))
+
+    # cleanup
+    PGFPlots.cleanup(plt.o)
+end
+
+function _show(io::IO, mime::MIME"application/x-tex", plt::Plot{PGFPlotsBackend})
+    fn = tempname()*".tex"
+    PGFPlots.save(fn, backend_object(plt), include_preamble=plt.attr[:tex_output_standalone])
+    write(io, read(open(fn), String))
+end
+
+function _display(plt::Plot{PGFPlotsBackend})
+    # prepare the object
+    pgfplt = PGFPlots.plot(plt.o)
+
+    # save an svg
+    fn = string(tempname(), ".svg")
+    PGFPlots.save(PGFPlots.SVG(fn), pgfplt)
+
+    # show it
+    open_browser_window(fn)
+
+    # cleanup
+    PGFPlots.cleanup(plt.o)
+end

src/backends/plotly.jl

@@ -0,0 +1,875 @@
+
+# https://plot.ly/javascript/getting-started
+
+is_subplot_supported(::PlotlyBackend) = true
+# is_string_supported(::PlotlyBackend) = true
+const _plotly_framestyles = [:box, :axes, :zerolines, :grid, :none]
+const _plotly_framestyle_defaults = Dict(:semi => :box, :origin => :zerolines)
+function _plotly_framestyle(style::Symbol)
+    if style in _plotly_framestyles
+        return style
+    else
+        default_style = get(_plotly_framestyle_defaults, style, :axes)
+        @warn("Framestyle :$style is not supported by Plotly and PlotlyJS. :$default_style was cosen instead.")
+        default_style
+    end
+end
+
+
+# --------------------------------------------------------------------------------------
+const plotly_remote_file_path = "https://cdn.plot.ly/plotly-latest.min.js"
+
+
+# if isatom()
+#     import Atom
+#     Atom.@msg evaljs(_js_code)
+# end
+using UUIDs
+
+push!(_initialized_backends, :plotly)
+# ----------------------------------------------------------------
+
+const _plotly_legend_pos = KW(
+    :right => [1., 0.5],
+    :left => [0., 0.5],
+    :top => [0.5, 1.],
+    :bottom => [0.5, 0.],
+    :bottomleft => [0., 0.],
+    :bottomright => [1., 0.],
+    :topright => [1., 1.],
+    :topleft => [0., 1.]
+)
+
+plotly_legend_pos(pos::Symbol) = get(_plotly_legend_pos, pos, [1.,1.])
+plotly_legend_pos(v::Tuple{S,T}) where {S<:Real, T<:Real} = v
+
+function plotly_font(font::Font, color = font.color)
+    KW(
+        :family => font.family,
+        :size   => round(Int, font.pointsize*1.4),
+        :color  => rgba_string(color),
+    )
+end
+
+
+function plotly_annotation_dict(x, y, val; xref="paper", yref="paper")
+    KW(
+        :text => val,
+        :xref => xref,
+        :x => x,
+        :yref => yref,
+        :y => y,
+        :showarrow => false,
+    )
+end
+
+function plotly_annotation_dict(x, y, ptxt::PlotText; xref="paper", yref="paper")
+    merge(plotly_annotation_dict(x, y, ptxt.str; xref=xref, yref=yref), KW(
+        :font => plotly_font(ptxt.font),
+        :xanchor => ptxt.font.halign == :hcenter ? :center : ptxt.font.halign,
+        :yanchor => ptxt.font.valign == :vcenter ? :middle : ptxt.font.valign,
+        :rotation => -ptxt.font.rotation,
+    ))
+end
+
+# function get_annotation_dict_for_arrow(plotattributes::KW, xyprev::Tuple, xy::Tuple, a::Arrow)
+#     xdiff = xyprev[1] - xy[1]
+#     ydiff = xyprev[2] - xy[2]
+#     dist = sqrt(xdiff^2 + ydiff^2)
+#     KW(
+#         :showarrow => true,
+#         :x => xy[1],
+#         :y => xy[2],
+#         # :ax => xyprev[1] - xy[1],
+#         # :ay => xy[2] - xyprev[2],
+#         # :ax => 0,
+#         # :ay => -40,
+#         :ax => 10xdiff / dist,
+#         :ay => -10ydiff / dist,
+#         :arrowcolor => rgba_string(plotattributes[:linecolor]),
+#         :xref => "x",
+#         :yref => "y",
+#         :arrowsize => 10a.headwidth,
+#         # :arrowwidth => a.headlength,
+#         :arrowwidth => 0.1,
+#     )
+# end
+
+function plotly_scale(scale::Symbol)
+    if scale == :log10
+        "log"
+    else
+        "-"
+    end
+end
+
+function shrink_by(lo, sz, ratio)
+    amt = 0.5 * (1.0 - ratio) * sz
+    lo + amt, sz - 2amt
+end
+
+function plotly_apply_aspect_ratio(sp::Subplot, plotarea, pcts)
+    aspect_ratio = sp[:aspect_ratio]
+    if aspect_ratio != :none
+        if aspect_ratio == :equal
+            aspect_ratio = 1.0
+        end
+        xmin,xmax = axis_limits(sp, :x)
+        ymin,ymax = axis_limits(sp, :y)
+        want_ratio = ((xmax-xmin) / (ymax-ymin)) / aspect_ratio
+        parea_ratio = width(plotarea) / height(plotarea)
+        if want_ratio > parea_ratio
+            # need to shrink y
+            ratio = parea_ratio / want_ratio
+            pcts[2], pcts[4] = shrink_by(pcts[2], pcts[4], ratio)
+        elseif want_ratio < parea_ratio
+            # need to shrink x
+            ratio = want_ratio / parea_ratio
+            pcts[1], pcts[3] = shrink_by(pcts[1], pcts[3], ratio)
+        end
+        pcts
+    end
+    pcts
+end
+
+
+# this method gets the start/end in percentage of the canvas for this axis direction
+function plotly_domain(sp::Subplot, letter)
+    figw, figh = sp.plt[:size]
+    pcts = bbox_to_pcts(sp.plotarea, figw*px, figh*px)
+    pcts = plotly_apply_aspect_ratio(sp, sp.plotarea, pcts)
+    i1,i2 = (letter == :x ? (1,3) : (2,4))
+    [pcts[i1], pcts[i1]+pcts[i2]]
+end
+
+
+function plotly_axis(plt::Plot, axis::Axis, sp::Subplot)
+    letter = axis[:letter]
+    framestyle = sp[:framestyle]
+    ax = KW(
+        :visible    => framestyle != :none,
+        :title      => axis[:guide],
+        :showgrid   => axis[:grid],
+        :gridcolor  => rgba_string(plot_color(axis[:foreground_color_grid], axis[:gridalpha])),
+        :gridwidth  => axis[:gridlinewidth],
+        :zeroline   => framestyle == :zerolines,
+        :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",
+        :mirror     => framestyle == :box,
+        :showticklabels => axis[:showaxis],
+    )
+
+    if letter in (:x,:y)
+        ax[:domain] = plotly_domain(sp, letter)
+        if is3d(sp)
+            # don't link 3d axes for synchronized interactivity
+            x_idx = y_idx = sp[:subplot_index]
+        else
+            x_idx, y_idx = plotly_link_indicies(plt, sp)
+        end
+        ax[:anchor] = "$(letter==:x ? "y$(y_idx)" : "x$(x_idx)")"
+    end
+
+    ax[:tickangle] = -axis[:rotation]
+    ax[:type] = plotly_scale(axis[:scale])
+    lims = axis_limits(sp, letter)
+
+    if axis[:ticks] != :native || axis[:lims] != :auto
+        ax[:range] = map(scalefunc(axis[:scale]), lims)
+    end
+
+    if !(axis[:ticks] in (nothing, :none, false))
+        ax[:titlefont] = plotly_font(guidefont(axis))
+        ax[:tickfont] = plotly_font(tickfont(axis))
+        ax[:tickcolor] = framestyle in (:zerolines, :grid) || !axis[:showaxis] ? rgba_string(invisible()) : rgb_string(axis[:foreground_color_axis])
+        ax[:linecolor] = rgba_string(axis[:foreground_color_axis])
+
+        # ticks
+        if axis[:ticks] != :native
+            ticks = get_ticks(sp, axis)
+            ttype = ticksType(ticks)
+            if ttype == :ticks
+                ax[:tickmode] = "array"
+                ax[:tickvals] = ticks
+            elseif ttype == :ticks_and_labels
+                ax[:tickmode] = "array"
+                ax[:tickvals], ax[:ticktext] = ticks
+            end
+        end
+    else
+        ax[:showticklabels] = false
+        ax[:showgrid] = false
+    end
+
+    # flip
+    if axis[:flip]
+        ax[:range] = reverse(ax[:range])
+    end
+
+    ax
+end
+
+function plotly_polaraxis(sp::Subplot, axis::Axis)
+    ax = KW(
+        :visible => axis[:showaxis],
+        :showline => axis[:grid],
+    )
+
+    if axis[:letter] == :x
+        ax[:range] = rad2deg.(axis_limits(sp, :x))
+    else
+        ax[:range] = axis_limits(sp, :y)
+        ax[:orientation] = -90
+    end
+
+    ax
+end
+
+function plotly_layout(plt::Plot)
+    plotattributes_out = KW()
+
+    w, h = plt[:size]
+    plotattributes_out[:width], plotattributes_out[:height] = w, h
+    plotattributes_out[:paper_bgcolor] = rgba_string(plt[:background_color_outside])
+    plotattributes_out[:margin] = KW(:l=>0, :b=>20, :r=>0, :t=>20)
+
+    plotattributes_out[:annotations] = KW[]
+
+    multiple_subplots = length(plt.subplots) > 1
+
+    for sp in plt.subplots
+        spidx = multiple_subplots ? sp[:subplot_index] : ""
+        x_idx, y_idx = multiple_subplots ? plotly_link_indicies(plt, sp) : ("", "")
+        # add an annotation for the title... positioned horizontally relative to plotarea,
+        # but vertically just below the top of the subplot bounding box
+        if sp[:title] != ""
+            bb = plotarea(sp)
+            tpos = sp[:title_location]
+            xmm = if tpos == :left
+                left(bb)
+            elseif tpos == :right
+                right(bb)
+            else
+                0.5 * (left(bb) + right(bb))
+            end
+            titlex, titley = xy_mm_to_pcts(xmm, top(bbox(sp)), w*px, h*px)
+            title_font = font(titlefont(sp), :top)
+            push!(plotattributes_out[:annotations], plotly_annotation_dict(titlex, titley, text(sp[:title], title_font)))
+        end
+
+        plotattributes_out[:plot_bgcolor] = rgba_string(sp[:background_color_inside])
+
+        # set to supported framestyle
+        sp[:framestyle] = _plotly_framestyle(sp[:framestyle])
+
+        # if any(is3d, seriesargs)
+        if is3d(sp)
+            azim = sp[:camera][1] - 90 #convert azimuthal to match GR behaviour
+            theta = 90 - sp[:camera][2] #spherical coordinate angle from z axis
+            plotattributes_out[:scene] = KW(
+                Symbol("xaxis$(spidx)") => plotly_axis(plt, sp[:xaxis], sp),
+                Symbol("yaxis$(spidx)") => plotly_axis(plt, sp[:yaxis], sp),
+                Symbol("zaxis$(spidx)") => plotly_axis(plt, sp[:zaxis], sp),
+
+                #2.6 multiplier set camera eye such that whole plot can be seen
+                :camera => KW(
+                    :eye => KW(
+                        :x => cosd(azim)*sind(theta)*2.6,
+                        :y => sind(azim)*sind(theta)*2.6,
+                        :z => cosd(theta)*2.6,
+                    ),
+                ),
+            )
+        elseif ispolar(sp)
+            plotattributes_out[Symbol("angularaxis$(spidx)")] = plotly_polaraxis(sp, sp[:xaxis])
+            plotattributes_out[Symbol("radialaxis$(spidx)")] = plotly_polaraxis(sp, sp[:yaxis])
+        else
+            plotattributes_out[Symbol("xaxis$(x_idx)")] = plotly_axis(plt, sp[:xaxis], sp)
+            # don't allow yaxis to be reupdated/reanchored in a linked subplot
+            spidx == y_idx ? plotattributes_out[Symbol("yaxis$(y_idx)")] = plotly_axis(plt, sp[:yaxis], sp) : nothing
+        end
+
+        # legend
+        plotattributes_out[:showlegend] = sp[:legend] != :none
+        xpos,ypos = plotly_legend_pos(sp[:legend])
+        if sp[:legend] != :none
+            plotattributes_out[:legend] = KW(
+                :bgcolor  => rgba_string(sp[:background_color_legend]),
+                :bordercolor => rgba_string(sp[:foreground_color_legend]),
+                :font     => plotly_font(legendfont(sp)),
+                :tracegroupgap => 0,
+                :x => xpos,
+                :y => ypos
+            )
+        end
+
+        # annotations
+        for ann in sp[:annotations]
+            append!(plotattributes_out[:annotations], KW[plotly_annotation_dict(locate_annotation(sp, ann...)...; xref = "x$(x_idx)", yref = "y$(y_idx)")])
+        end
+        # series_annotations
+        for series in series_list(sp)
+            anns = series[:series_annotations]
+            for (xi,yi,str,fnt) in EachAnn(anns, series[:x], series[:y])
+                push!(plotattributes_out[:annotations], plotly_annotation_dict(
+                    xi,
+                    yi,
+                    PlotText(str,fnt); xref = "x$(x_idx)", yref = "y$(y_idx)")
+                )
+            end
+        end
+
+        # # arrows
+        # for sargs in seriesargs
+        #     a = sargs[:arrow]
+        #     if sargs[:seriestype] in (:path, :line) && typeof(a) <: Arrow
+        #         add_arrows(sargs[:x], sargs[:y]) do xyprev, xy
+        #             push!(plotattributes_out[:annotations], get_annotation_dict_for_arrow(sargs, xyprev, xy, a))
+        #         end
+        #     end
+        # end
+
+        if ispolar(sp)
+            plotattributes_out[:direction] = "counterclockwise"
+        end
+
+        plotattributes_out
+    end
+
+    # turn off hover if nothing's using it
+    if all(series -> series.plotattributes[:hover] in (false,:none), plt.series_list)
+        plotattributes_out[:hovermode] = "none"
+    end
+
+    plotattributes_out
+end
+
+function plotly_layout_json(plt::Plot)
+    JSON.json(plotly_layout(plt), 4)
+end
+
+
+function plotly_colorscale(grad::ColorGradient, α)
+    [[grad.values[i], rgba_string(plot_color(grad.colors[i], α))] for i in 1:length(grad.colors)]
+end
+plotly_colorscale(c::Colorant,α) = plotly_colorscale(_as_gradient(c),α)
+function plotly_colorscale(c::AbstractVector{<:RGBA}, α)
+    if length(c) == 1
+        return [[0.0, rgba_string(plot_color(c[1], α))], [1.0, rgba_string(plot_color(c[1], α))]]
+    else
+        vals = range(0.0, stop=1.0, length=length(c))
+        return [[vals[i], rgba_string(plot_color(c[i], α))] for i in eachindex(c)]
+    end
+end
+# plotly_colorscale(c, alpha = nothing) = plotly_colorscale(cgrad(), alpha)
+
+
+const _plotly_markers = KW(
+    :rect       => "square",
+    :xcross     => "x",
+    :x          => "x",
+    :utriangle  => "triangle-up",
+    :dtriangle  => "triangle-down",
+    :star5      => "star-triangle-up",
+    :vline      => "line-ns",
+    :hline      => "line-ew",
+)
+
+# find indicies of axes to which the supblot links to
+function plotly_link_indicies(plt::Plot, sp::Subplot)
+    if plt[:link] in (:x, :y, :both)
+        x_idx = sp[:xaxis].sps[1][:subplot_index]
+        y_idx = sp[:yaxis].sps[1][:subplot_index]
+    else
+        x_idx = y_idx = sp[:subplot_index]
+    end
+    x_idx, y_idx
+end
+
+
+# the Shape contructor will automatically close the shape. since we need it closed,
+# we split by NaNs and then construct/destruct the shapes to get the closed coords
+function plotly_close_shapes(x, y)
+    xs, ys = nansplit(x), nansplit(y)
+    for i=1:length(xs)
+        shape = Shape(xs[i], ys[i])
+        xs[i], ys[i] = coords(shape)
+    end
+    nanvcat(xs), nanvcat(ys)
+end
+
+function plotly_data(series::Series, letter::Symbol, data)
+    axis = series[:subplot][Symbol(letter, :axis)]
+
+    data = if axis[:ticks] == :native && data !== nothing
+        plotly_native_data(axis, data)
+    else
+       data
+    end
+
+    if series[:seriestype] in (:heatmap, :contour, :surface, :wireframe)
+        plotly_surface_data(series, data)
+    else
+        plotly_data(data)
+    end
+end
+plotly_data(v) = v !== nothing ? collect(v) : v
+plotly_data(surf::Surface) = surf.surf
+plotly_data(v::AbstractArray{R}) where {R<:Rational} = float(v)
+
+plotly_surface_data(series::Series, a::AbstractVector) = a
+plotly_surface_data(series::Series, a::AbstractMatrix) = transpose_z(series, a, false)
+plotly_surface_data(series::Series, a::Surface) = plotly_surface_data(series, a.surf)
+
+function plotly_native_data(axis::Axis, data::AbstractArray)
+    if !isempty(axis[:discrete_values])
+        construct_categorical_data(data, axis)
+    elseif axis[:formatter] in (datetimeformatter, dateformatter, timeformatter)
+        plotly_convert_to_datetime(data, axis[:formatter])
+    else
+        data
+    end
+end
+plotly_native_data(axis::Axis, a::Surface) = Surface(plotly_native_data(axis, a.surf))
+
+function plotly_convert_to_datetime(x::AbstractArray, formatter::Function)
+    if formatter == datetimeformatter
+        map(xi -> replace(formatter(xi), "T" => " "), x)
+    elseif formatter == dateformatter
+        map(xi -> string(formatter(xi), " 00:00:00"), x)
+    elseif formatter == timeformatter
+        map(xi -> string(Dates.Date(Dates.now()), " ", formatter(xi)), x)
+    else
+        error("Invalid DateTime formatter. Expected Plots.datetime/date/time formatter but got $formatter")
+    end
+end
+#ensures that a gradient is called if a single color is supplied where a gradient is needed (e.g. if a series recipe defines marker_z)
+as_gradient(grad::ColorGradient, α) = grad
+as_gradient(grad, α) = cgrad(alpha = α)
+
+# get a dictionary representing the series params (plotattributes is the Plots-dict, plotattributes_out is the Plotly-dict)
+function plotly_series(plt::Plot, series::Series)
+    st = series[:seriestype]
+
+    sp = series[:subplot]
+    clims = get_clims(sp)
+
+    if st == :shape
+        return plotly_series_shapes(plt, series, clims)
+    end
+
+    plotattributes_out = KW()
+
+    # these are the axes that the series should be mapped to
+    x_idx, y_idx = plotly_link_indicies(plt, sp)
+    plotattributes_out[:xaxis] = "x$(x_idx)"
+    plotattributes_out[:yaxis] = "y$(y_idx)"
+    plotattributes_out[:showlegend] = should_add_to_legend(series)
+
+    if st == :straightline
+        x, y = straightline_data(series)
+        z = series[:z]
+    else
+        x, y, z  = series[:x], series[:y], series[:z]
+    end
+
+    x, y, z = (plotly_data(series, letter, data)
+        for (letter, data) in zip((:x, :y, :z), (x, y, z))
+    )
+
+    plotattributes_out[:name] = series[:label]
+
+    isscatter = st in (:scatter, :scatter3d, :scattergl)
+    hasmarker = isscatter || series[:markershape] != :none
+    hasline = st in (:path, :path3d, :straightline)
+    hasfillrange = st in (:path, :scatter, :scattergl, :straightline) &&
+        (isa(series[:fillrange], AbstractVector) || isa(series[:fillrange], Tuple))
+
+    plotattributes_out[:colorbar] = KW(:title => sp[:colorbar_title])
+
+    if is_2tuple(clims)
+        plotattributes_out[:zmin], plotattributes_out[:zmax] = clims
+    end
+
+    # set the "type"
+    if st in (:path, :scatter, :scattergl, :straightline, :path3d, :scatter3d)
+        return plotly_series_segments(series, plotattributes_out, x, y, z, clims)
+
+    elseif st == :heatmap
+        x = heatmap_edges(x, sp[:xaxis][:scale])
+        y = heatmap_edges(y, sp[:yaxis][:scale])
+        plotattributes_out[:type] = "heatmap"
+        plotattributes_out[:x], plotattributes_out[:y], plotattributes_out[:z] = x, y, z
+        plotattributes_out[:colorscale] = plotly_colorscale(series[:fillcolor], series[:fillalpha])
+        plotattributes_out[:showscale] = hascolorbar(sp)
+
+    elseif st == :contour
+        filled = isfilledcontour(series)
+        plotattributes_out[:type] = "contour"
+        plotattributes_out[:x], plotattributes_out[:y], plotattributes_out[:z] = x, y, z
+        plotattributes_out[:ncontours] = series[:levels] + 2
+        plotattributes_out[:contours] = KW(:coloring => filled ? "fill" : "lines", :showlabels => series[:contour_labels] == true)
+        plotattributes_out[:colorscale] = plotly_colorscale(series[:linecolor], series[:linealpha])
+        plotattributes_out[:showscale] = hascolorbar(sp) && hascolorbar(series)
+
+    elseif st in (:surface, :wireframe)
+        plotattributes_out[:type] = "surface"
+        plotattributes_out[:x], plotattributes_out[:y], plotattributes_out[:z] = x, y, z
+        if st == :wireframe
+            plotattributes_out[:hidesurface] = true
+            wirelines = KW(
+                :show => true,
+                :color => rgba_string(plot_color(series[:linecolor], series[:linealpha])),
+                :highlightwidth => series[:linewidth],
+            )
+            plotattributes_out[:contours] = KW(:x => wirelines, :y => wirelines, :z => wirelines)
+            plotattributes_out[:showscale] = false
+        else
+            plotattributes_out[:colorscale] = plotly_colorscale(series[:fillcolor], series[:fillalpha])
+            plotattributes_out[:opacity] = series[:fillalpha]
+            if series[:fill_z] !== nothing
+                plotattributes_out[:surfacecolor] = plotly_surface_data(series, series[:fill_z])
+            end
+            plotattributes_out[:showscale] = hascolorbar(sp)
+        end
+
+    elseif st == :pie
+        plotattributes_out[:type] = "pie"
+        plotattributes_out[:labels] = pie_labels(sp, series)
+        plotattributes_out[:values] = y
+        plotattributes_out[:hoverinfo] = "label+percent+name"
+
+    else
+        @warn("Plotly: seriestype $st isn't supported.")
+        return KW()
+    end
+
+    # add "marker"
+    if hasmarker
+        inds = eachindex(x)
+        plotattributes_out[:marker] = KW(
+            :symbol => get(_plotly_markers, series[:markershape], string(series[:markershape])),
+            # :opacity => series[:markeralpha],
+            :size => 2 * _cycle(series[:markersize], inds),
+            :color => rgba_string.(plot_color.(get_markercolor.(series, inds), get_markeralpha.(series, inds))),
+            :line => KW(
+                :color => rgba_string.(plot_color.(get_markerstrokecolor.(series, inds), get_markerstrokealpha.(series, inds))),
+                :width => _cycle(series[:markerstrokewidth], inds),
+            ),
+        )
+    end
+
+    plotly_polar!(plotattributes_out, series)
+    plotly_hover!(plotattributes_out, series[:hover])
+
+    return [plotattributes_out]
+end
+
+function plotly_series_shapes(plt::Plot, series::Series, clims)
+    segments = iter_segments(series)
+    plotattributes_outs = Vector{KW}(undef, length(segments))
+
+    # TODO: create a plotattributes_out for each polygon
+    # x, y = series[:x], series[:y]
+
+    # these are the axes that the series should be mapped to
+    x_idx, y_idx = plotly_link_indicies(plt, series[:subplot])
+    plotattributes_base = KW(
+        :xaxis => "x$(x_idx)",
+        :yaxis => "y$(y_idx)",
+        :name => series[:label],
+        :legendgroup => series[:label],
+    )
+
+    x, y = (plotly_data(series, letter, data)
+        for (letter, data) in zip((:x, :y), shape_data(series))
+    )
+
+    for (i,rng) in enumerate(segments)
+        length(rng) < 2 && continue
+
+        # to draw polygons, we actually draw lines with fill
+        plotattributes_out = merge(plotattributes_base, KW(
+            :type => "scatter",
+            :mode => "lines",
+            :x => vcat(x[rng], x[rng[1]]),
+            :y => vcat(y[rng], y[rng[1]]),
+            :fill => "tozeroy",
+            :fillcolor => rgba_string(plot_color(get_fillcolor(series, clims, i), get_fillalpha(series, i))),
+        ))
+        if series[:markerstrokewidth] > 0
+            plotattributes_out[:line] = KW(
+                :color => rgba_string(plot_color(get_linecolor(series, clims, i), get_linealpha(series, i))),
+                :width => get_linewidth(series, i),
+                :dash => string(get_linestyle(series, i)),
+            )
+        end
+        plotattributes_out[:showlegend] = i==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
+    end
+    if series[:fill_z] !== nothing
+        push!(plotattributes_outs, plotly_colorbar_hack(series, plotattributes_base, :fill))
+    elseif series[:line_z] !== nothing
+        push!(plotattributes_outs, plotly_colorbar_hack(series, plotattributes_base, :line))
+    elseif series[:marker_z] !== nothing
+        push!(plotattributes_outs, plotly_colorbar_hack(series, plotattributes_base, :marker))
+    end
+    plotattributes_outs
+end
+
+function plotly_series_segments(series::Series, plotattributes_base::KW, x, y, z, clims)
+    st = series[:seriestype]
+    sp = series[:subplot]
+    isscatter = st in (:scatter, :scatter3d, :scattergl)
+    hasmarker = isscatter || series[:markershape] != :none
+    hasline = st in (:path, :path3d, :straightline)
+    hasfillrange = st in (:path, :scatter, :scattergl, :straightline) &&
+        (isa(series[:fillrange], AbstractVector) || isa(series[:fillrange], Tuple))
+
+    segments = iter_segments(series)
+    plotattributes_outs = fill(KW(), (hasfillrange ? 2 : 1 ) * length(segments))
+
+    for (i,rng) in enumerate(segments)
+        plotattributes_out = deepcopy(plotattributes_base)
+        plotattributes_out[:showlegend] = i==1 ? should_add_to_legend(series) : false
+        plotattributes_out[:legendgroup] = series[:label]
+
+        # set the type
+        if st in (:path, :scatter, :scattergl, :straightline)
+            plotattributes_out[:type] = st==:scattergl ? "scattergl" : "scatter"
+            plotattributes_out[:mode] = if hasmarker
+                hasline ? "lines+markers" : "markers"
+            else
+                hasline ? "lines" : "none"
+            end
+            if series[:fillrange] == true || series[:fillrange] == 0 || isa(series[:fillrange], Tuple)
+                plotattributes_out[:fill] = "tozeroy"
+                plotattributes_out[:fillcolor] = rgba_string(plot_color(get_fillcolor(series, clims, i), get_fillalpha(series, i)))
+            elseif typeof(series[:fillrange]) <: Union{AbstractVector{<:Real}, Real}
+                plotattributes_out[:fill] = "tonexty"
+                plotattributes_out[:fillcolor] = rgba_string(plot_color(get_fillcolor(series, clims, i), get_fillalpha(series, i)))
+            elseif !(series[:fillrange] in (false, nothing))
+                @warn("fillrange ignored... plotly only supports filling to zero and to a vector of values. fillrange: $(series[:fillrange])")
+            end
+            plotattributes_out[:x], plotattributes_out[:y] = x[rng], y[rng]
+
+        elseif st in (:path3d, :scatter3d)
+            plotattributes_out[:type] = "scatter3d"
+            plotattributes_out[:mode] = if hasmarker
+                hasline ? "lines+markers" : "markers"
+            else
+                hasline ? "lines" : "none"
+            end
+            plotattributes_out[:x], plotattributes_out[:y], plotattributes_out[:z] = x[rng], y[rng], z[rng]
+        end
+
+        # add "marker"
+        if hasmarker
+            plotattributes_out[:marker] = KW(
+                :symbol => get(_plotly_markers, _cycle(series[:markershape], i), string(_cycle(series[:markershape], i))),
+                # :opacity => series[:markeralpha],
+                :size => 2 * _cycle(series[:markersize], i),
+                :color => rgba_string(plot_color(get_markercolor(series, clims, i), get_markeralpha(series, i))),
+                :line => KW(
+                    :color => rgba_string(plot_color(get_markerstrokecolor(series, i), get_markerstrokealpha(series, i))),
+                    :width => _cycle(series[:markerstrokewidth], i),
+                ),
+            )
+        end
+
+        # add "line"
+        if hasline
+            plotattributes_out[:line] = KW(
+                :color => rgba_string(plot_color(get_linecolor(series, clims, i), get_linealpha(series, i))),
+                :width => get_linewidth(series, i),
+                :shape => if st == :steppre
+                    "vh"
+                elseif st == :steppost
+                    "hv"
+                else
+                    "linear"
+                end,
+                :dash => string(get_linestyle(series, i)),
+            )
+        end
+
+        plotly_polar!(plotattributes_out, series)
+        plotly_hover!(plotattributes_out, _cycle(series[:hover], rng))
+
+        if hasfillrange
+            # if hasfillrange is true, return two dictionaries (one for original
+            # series, one for series being filled to) instead of one
+            plotattributes_out_fillrange = deepcopy(plotattributes_out)
+            plotattributes_out_fillrange[:showlegend] = false
+            # if fillrange is provided as real or tuple of real, expand to array
+            if typeof(series[:fillrange]) <: Real
+                series[:fillrange] = fill(series[:fillrange], length(rng))
+            elseif typeof(series[:fillrange]) <: Tuple
+                f1 = typeof(series[:fillrange][1]) <: Real ? fill(series[:fillrange][1], length(rng)) : series[:fillrange][1][rng]
+                f2 = typeof(series[:fillrange][2]) <: Real ? fill(series[:fillrange][2], length(rng)) : series[:fillrange][2][rng]
+                series[:fillrange] = (f1, f2)
+            end
+            if isa(series[:fillrange], AbstractVector)
+                plotattributes_out_fillrange[:y] = series[:fillrange][rng]
+                delete!(plotattributes_out_fillrange, :fill)
+                delete!(plotattributes_out_fillrange, :fillcolor)
+            else
+                # if fillrange is a tuple with upper and lower limit, plotattributes_out_fillrange
+                # is the series that will do the filling
+                fillrng = Tuple(series[:fillrange][i][rng] for i in 1:2)
+                plotattributes_out_fillrange[:x], plotattributes_out_fillrange[:y] = concatenate_fillrange(x[rng], fillrng)
+                plotattributes_out_fillrange[:line][:width] = 0
+                delete!(plotattributes_out, :fill)
+                delete!(plotattributes_out, :fillcolor)
+            end
+
+            plotattributes_outs[(2 * i - 1):(2 * i)] = [plotattributes_out_fillrange, plotattributes_out]
+        else
+            plotattributes_outs[i] = plotattributes_out
+        end
+    end
+
+    if series[:line_z] !== nothing
+        push!(plotattributes_outs, plotly_colorbar_hack(series, plotattributes_base, :line))
+    elseif series[:fill_z] !== nothing
+        push!(plotattributes_outs, plotly_colorbar_hack(series, plotattributes_base, :fill))
+    elseif series[:marker_z] !== nothing
+        push!(plotattributes_outs, plotly_colorbar_hack(series, plotattributes_base, :marker))
+    end
+
+    plotattributes_outs
+end
+
+function plotly_colorbar_hack(series::Series, plotattributes_base::KW, sym::Symbol)
+    plotattributes_out = deepcopy(plotattributes_base)
+    cmin, cmax = get_clims(series[:subplot])
+    plotattributes_out[:showlegend] = false
+    plotattributes_out[:type] = is3d(series) ? :scatter3d : :scatter
+    plotattributes_out[:hoverinfo] = :none
+    plotattributes_out[:mode] = :markers
+    plotattributes_out[:x], plotattributes_out[:y] = [series[:x][1]], [series[:y][1]]
+    if is3d(series)
+        plotattributes_out[:z] = [series[:z][1]]
+    end
+    # zrange = zmax == zmin ? 1 : zmax - zmin # if all marker_z values are the same, plot all markers same color (avoids division by zero in next line)
+    plotattributes_out[:marker] = KW(
+        :size => 0,
+        :opacity => 0,
+        :color => [0.5],
+        :cmin => cmin,
+        :cmax => cmax,
+        :colorscale => plotly_colorscale(series[Symbol("$(sym)color")], 1),
+        :showscale => hascolorbar(series[:subplot]),
+    )
+    return plotattributes_out
+end
+
+
+function plotly_polar!(plotattributes_out::KW, series::Series)
+    # convert polar plots x/y to theta/radius
+    if ispolar(series[:subplot])
+        theta, r = pop!(plotattributes_out, :x), pop!(plotattributes_out, :y)
+        plotattributes_out[:t] = rad2deg.(theta)
+        plotattributes_out[:r] = r
+    end
+end
+
+function plotly_hover!(plotattributes_out::KW, hover)
+    # hover text
+    if hover in (:none, false)
+        plotattributes_out[:hoverinfo] = "none"
+    elseif hover !== nothing
+        plotattributes_out[:hoverinfo] = "text"
+        plotattributes_out[:text] = hover
+    end
+end
+
+# get a list of dictionaries, each representing the series params
+function plotly_series(plt::Plot)
+    slist = []
+    for series in plt.series_list
+        append!(slist, plotly_series(plt, series))
+    end
+    slist
+end
+
+# get json string for a list of dictionaries, each representing the series params
+plotly_series_json(plt::Plot) = JSON.json(plotly_series(plt), 4)
+
+# ----------------------------------------------------------------
+
+html_head(plt::Plot{PlotlyBackend}) = plotly_html_head(plt)
+html_body(plt::Plot{PlotlyBackend}) = plotly_html_body(plt)
+
+const ijulia_initialized = Ref(false)
+
+function plotly_html_head(plt::Plot)
+    local_file = ("file://" * plotly_local_file_path)
+    plotly = use_local_dependencies[] ? local_file : plotly_remote_file_path
+    if isijulia() && !ijulia_initialized[]
+        # using requirejs seems to be key to load a js depency in IJulia!
+        # https://requirejs.org/docs/start.html
+        # https://github.com/JuliaLang/IJulia.jl/issues/345
+        display("text/html", """
+            <script type="text/javascript">
+                requirejs([$(repr(plotly))], function(p) {
+                    window.Plotly = p
+                });
+            </script>
+        """)
+        ijulia_initialized[] = true
+    end
+    return "<script src=$(repr(plotly))></script>"
+end
+
+function plotly_html_body(plt, style = nothing)
+    if style === nothing
+        w, h = plt[:size]
+        style = "width:$(w)px;height:$(h)px;"
+    end
+    uuid = UUIDs.uuid4()
+    html = """
+        <div id=\"$(uuid)\" style=\"$(style)\"></div>
+        <script>
+        PLOT = document.getElementById('$(uuid)');
+        Plotly.plot(PLOT, $(plotly_series_json(plt)), $(plotly_layout_json(plt)));
+        </script>
+    """
+    html
+end
+
+function js_body(plt::Plot, uuid)
+    js = """
+        PLOT = document.getElementById('$(uuid)');
+        Plotly.plot(PLOT, $(plotly_series_json(plt)), $(plotly_layout_json(plt)));
+    """
+end
+
+function plotly_show_js(io::IO, plot::Plot)
+    data = []
+    for series in plot.series_list
+        append!(data, plotly_series(plot, series))
+    end
+    layout = plotly_layout(plot)
+    JSON.print(io, Dict(:data => data, :layout => layout))
+end
+
+# ----------------------------------------------------------------
+
+function _show(io::IO, ::MIME"application/vnd.plotly.v1+json", plot::Plot{PlotlyBackend})
+    plotly_show_js(io, plot)
+end
+
+
+function _show(io::IO, ::MIME"text/html", plt::Plot{PlotlyBackend})
+    write(io, standalone_html(plt))
+end
+
+
+function _display(plt::Plot{PlotlyBackend})
+    standalone_html_window(plt)
+end

src/backends/plotlyjs.jl

@@ -0,0 +1,54 @@
+# https://github.com/sglyon/PlotlyJS.jl
+
+# ------------------------------------------------------------------------------
+
+function plotlyjs_syncplot(plt::Plot{PlotlyJSBackend})
+    plt[:overwrite_figure] && closeall()
+    plt.o = PlotlyJS.plot()
+    traces = PlotlyJS.GenericTrace[]
+    for series_dict in plotly_series(plt)
+        plotly_type = pop!(series_dict, :type)
+        push!(traces, PlotlyJS.GenericTrace(plotly_type; series_dict...))
+    end
+    PlotlyJS.addtraces!(plt.o, traces...)
+    layout = plotly_layout(plt)
+    w, h = plt[:size]
+    PlotlyJS.relayout!(plt.o, layout, width = w, height = h)
+    return plt.o
+end
+
+# ------------------------------------------------------------------------------
+
+const _plotlyjs_mimeformats = Dict(
+    "application/pdf" => "pdf",
+    "image/png"       => "png",
+    "image/svg+xml"   => "svg",
+    "image/eps"       => "eps",
+)
+
+for (mime, fmt) in _plotlyjs_mimeformats
+    @eval _show(io::IO, ::MIME{Symbol($mime)}, plt::Plot{PlotlyJSBackend}) = PlotlyJS.savefig(io, plotlyjs_syncplot(plt), format = $fmt)
+end
+
+# Use the Plotly implementation for json and html:
+_show(io::IO, mime::MIME"application/vnd.plotly.v1+json", plt::Plot{PlotlyJSBackend}) = plotly_show_js(io, plt)
+
+html_head(plt::Plot{PlotlyJSBackend}) = plotly_html_head(plt)
+html_body(plt::Plot{PlotlyJSBackend}) = plotly_html_body(plt)
+
+_show(io::IO, ::MIME"text/html", plt::Plot{PlotlyJSBackend}) = write(io, standalone_html(plt))
+
+_display(plt::Plot{PlotlyJSBackend}) = display(plotlyjs_syncplot(plt))
+
+@require WebIO = "0f1e0344-ec1d-5b48-a673-e5cf874b6c29" begin
+    function WebIO.render(plt::Plot{PlotlyJSBackend})
+        prepare_output(plt)
+        WebIO.render(plt.o)
+    end
+end
+
+function closeall(::PlotlyJSBackend)
+    if !isplotnull() && isa(current().o, PlotlyJS.SyncPlot)
+        close(current().o)
+    end
+end

src/backends/template.jl

@@ -0,0 +1,70 @@
+
+# TODO: find/replace all [PkgName] with CamelCase
+
+# [ADD BACKEND WEBSITE]
+
+import [PkgName]
+export [PkgName]
+push!(_initialized_backends, [pgkname]::Symbol)
+
+# ---------------------------------------------------------------------------
+
+# Create the window/figure for this backend.
+function _create_backend_figure(plt::Plot{[PkgName]Backend})
+    nothing
+end
+
+# # this is called early in the pipeline, use it to make the plot current or something
+# function _prepare_plot_object(plt::Plot{[PkgName]Backend})
+# end
+
+# Set up the subplot within the backend object.
+function _initialize_subplot(plt::Plot{[PkgName]Backend}, sp::Subplot{[PkgName]Backend})
+end
+
+# ---------------------------------------------------------------------------
+
+# Add one series to the underlying backend object.
+function _series_added(plt::Plot{[PkgName]Backend}, series::Series)
+end
+
+# When series data is added/changed, this callback can do dynamic updates to the backend object.
+# note: if the backend rebuilds the plot from scratch on display, then you might not do anything here.
+function _series_updated(plt::Plot{[PkgName]Backend}, series::Series)
+end
+
+# ---------------------------------------------------------------------------
+
+# called just before updating layout bounding boxes... in case you need to prep
+# for the calcs
+function _before_layout_calcs(plt::Plot{[PkgName]Backend})
+end
+
+# Set the (left, top, right, bottom) minimum padding around the plot area
+# to fit ticks, tick labels, guides, colorbars, etc.
+function _update_min_padding!(sp::Subplot{[PkgName]Backend})
+    sp.minpad = (20mm, 5mm, 2mm, 10mm)
+end
+
+
+# ----------------------------------------------------------------
+
+# Override this to update plot items (title, xlabel, etc), and add annotations (plotattributes[:annotations])
+function _update_plot_object(plt::Plot{[PkgName]Backend})
+end
+
+# ----------------------------------------------------------------
+
+# Write a png to io.  You could define methods for:
+    # "application/eps"         => "eps",
+    # "image/eps"               => "eps",
+    # "application/pdf"         => "pdf",
+    # "image/png"               => "png",
+    # "application/postscript"  => "ps",
+    # "image/svg+xml"           => "svg"
+function _show(io::IO, ::MIME"image/png", plt::Plot{[PkgName]Backend})
+end
+
+# Display/show the plot (open a GUI window, or browser page, for example).
+function _display(plt::Plot{[PkgName]Backend})
+end

src/backends/unicodeplots.jl

@@ -0,0 +1,182 @@
+
+# https://github.com/Evizero/UnicodePlots.jl
+
+
+# don't warn on unsupported... there's just too many warnings!!
+warnOnUnsupported_args(::UnicodePlotsBackend, plotattributes::KW) = nothing
+
+# --------------------------------------------------------------------------------------
+
+const _canvas_type = Ref(:auto)
+
+function _canvas_map()
+    KW(
+        :braille => UnicodePlots.BrailleCanvas,
+        :ascii => UnicodePlots.AsciiCanvas,
+        :block => UnicodePlots.BlockCanvas,
+        :dot => UnicodePlots.DotCanvas,
+        :density => UnicodePlots.DensityCanvas,
+    )
+end
+
+
+# do all the magic here... build it all at once, since we need to know about all the series at the very beginning
+function rebuildUnicodePlot!(plt::Plot, width, height)
+    plt.o = []
+
+    for sp in plt.subplots
+        xaxis = sp[:xaxis]
+        yaxis = sp[:yaxis]
+        xlim =  axis_limits(sp, :x)
+        ylim =  axis_limits(sp, :y)
+
+        # make vectors
+        xlim = [xlim[1], xlim[2]]
+        ylim = [ylim[1], ylim[2]]
+
+        # we set x/y to have a single point, since we need to create the plot with some data.
+        # since this point is at the bottom left corner of the plot, it shouldn't actually be shown
+        x = Float64[xlim[1]]
+        y = Float64[ylim[1]]
+
+        # create a plot window with xlim/ylim set, but the X/Y vectors are outside the bounds
+        ct = _canvas_type[]
+        canvas_type = if ct == :auto
+            isijulia() ? UnicodePlots.AsciiCanvas : UnicodePlots.BrailleCanvas
+        else
+            _canvas_map()[ct]
+        end
+
+        # special handling for spy
+        if length(sp.series_list) == 1
+            series = sp.series_list[1]
+            if series[:seriestype] == :spy
+                push!(plt.o, UnicodePlots.spy(
+                    series[:z].surf,
+                    width = width,
+                    height = height,
+                    title = sp[:title],
+                    canvas = canvas_type
+                ))
+                continue
+            end
+        end
+
+        # # make it a bar canvas if plotting bar
+        # if any(series -> series[:seriestype] == :bar, series_list(sp))
+        #     canvas_type = UnicodePlots.BarplotGraphics
+        # end
+
+        o = UnicodePlots.Plot(x, y, canvas_type;
+            width = width,
+            height = height,
+            title = sp[:title],
+            xlim = xlim,
+            ylim = ylim,
+            border = isijulia() ? :ascii : :solid
+        )
+
+        # set the axis labels
+        UnicodePlots.xlabel!(o, xaxis[:guide])
+        UnicodePlots.ylabel!(o, yaxis[:guide])
+
+        # now use the ! functions to add to the plot
+        for series in series_list(sp)
+            addUnicodeSeries!(o, series.plotattributes, sp[:legend] != :none, xlim, ylim)
+        end
+
+        # save the object
+        push!(plt.o, o)
+    end
+end
+
+
+# add a single series
+function addUnicodeSeries!(o, plotattributes::KW, addlegend::Bool, xlim, ylim)
+    # get the function, or special handling for step/bar/hist
+    st = plotattributes[:seriestype]
+    if st == :histogram2d
+        UnicodePlots.densityplot!(o, plotattributes[:x], plotattributes[:y])
+        return
+    end
+
+    if st in (:path, :straightline)
+        func = UnicodePlots.lineplot!
+    elseif st == :scatter || plotattributes[:markershape] != :none
+        func = UnicodePlots.scatterplot!
+    # elseif st == :bar
+    #     func = UnicodePlots.barplot!
+    elseif st == :shape
+        func = UnicodePlots.lineplot!
+    else
+        error("Linestyle $st not supported by UnicodePlots")
+    end
+
+    # get the series data and label
+    x, y = if st == :straightline
+        straightline_data(plotattributes)
+    elseif st == :shape
+        shape_data(plotattributes)
+    else
+        [collect(float(plotattributes[s])) for s in (:x, :y)]
+    end
+    label = addlegend ? plotattributes[:label] : ""
+
+    # if we happen to pass in allowed color symbols, great... otherwise let UnicodePlots decide
+    color = plotattributes[:linecolor] in UnicodePlots.color_cycle ? plotattributes[:linecolor] : :auto
+
+    # add the series
+    x, y = Plots.unzip(collect(Base.Iterators.filter(xy->isfinite(xy[1])&&isfinite(xy[2]), zip(x,y))))
+    func(o, x, y; color = color, name = label)
+end
+
+# -------------------------------
+
+# since this is such a hack, it's only callable using `png`... should error during normal `show`
+function png(plt::AbstractPlot{UnicodePlotsBackend}, fn::AbstractString)
+    fn = addExtension(fn, "png")
+
+    # make some whitespace and show the plot
+    println("\n\n\n\n\n\n")
+    gui(plt)
+
+    # @osx_only begin
+    @static if Sys.isapple()
+        # BEGIN HACK
+
+        # wait while the plot gets drawn
+        sleep(0.5)
+
+        # use osx screen capture when my terminal is maximized and cursor starts at the bottom (I know, right?)
+        # TODO: compute size of plot to adjust these numbers (or maybe implement something good??)
+        run(`screencapture -R50,600,700,420 $fn`)
+
+        # END HACK (phew)
+        return
+    end
+
+    error("Can only savepng on osx with UnicodePlots (though even then I wouldn't do it)")
+end
+
+# -------------------------------
+
+# we don't do very much for subplots... just stack them vertically
+
+function unicodeplots_rebuild(plt::Plot{UnicodePlotsBackend})
+    w, h = plt[:size]
+    plt.attr[:color_palette] = [RGB(0,0,0)]
+    rebuildUnicodePlot!(plt, div(w, 10), div(h, 20))
+end
+
+function _show(io::IO, ::MIME"text/plain", plt::Plot{UnicodePlotsBackend})
+    unicodeplots_rebuild(plt)
+    foreach(x -> show(io, x), plt.o)
+    nothing
+end
+
+
+function _display(plt::Plot{UnicodePlotsBackend})
+    unicodeplots_rebuild(plt)
+    map(show, plt.o)
+    nothing
+end

src/backends/web.jl

@@ -0,0 +1,72 @@
+
+# NOTE:  backend should implement `html_body` and `html_head`
+
+# CREDIT: parts of this implementation were inspired by @joshday's PlotlyLocal.jl
+
+function standalone_html(plt::AbstractPlot; title::AbstractString = get(plt.attr, :window_title, "Plots.jl"))
+    """
+    <!DOCTYPE html>
+    <html>
+        <head>
+            <title>$title</title>
+            <meta http-equiv="content-type" content="text/html; charset=UTF-8">
+            $(html_head(plt))
+        </head>
+        <body>
+            $(html_body(plt))
+        </body>
+    </html>
+    """
+end
+
+function open_browser_window(filename::AbstractString)
+    @static if Sys.isapple()
+        return run(`open $(filename)`)
+    end
+    @static if Sys.islinux() || Sys.isbsd()    # Sys.isbsd() addition is as yet untested, but based on suggestion in https://github.com/JuliaPlots/Plots.jl/issues/681
+        return run(`xdg-open $(filename)`)
+    end
+    @static if Sys.iswindows()
+        return run(`$(ENV["COMSPEC"]) /c start "" "$(filename)"`)
+    end
+    @warn("Unknown OS... cannot open browser window.")
+end
+
+function write_temp_html(plt::AbstractPlot)
+    html = standalone_html(plt; title = plt.attr[:window_title])
+    filename = string(tempname(), ".html")
+    output = open(filename, "w")
+    write(output, html)
+    close(output)
+    filename
+end
+
+function standalone_html_window(plt::AbstractPlot)
+    old = use_local_dependencies[] # save state to restore afterwards
+    # if we open a browser ourself, we can host local files, so
+    # when we have a local plotly downloaded this is the way to go!
+    use_local_dependencies[] = isfile(plotly_local_file_path)
+    filename = write_temp_html(plt)
+    open_browser_window(filename)
+    # restore for other backends
+    use_local_dependencies[] = old
+end
+
+# uses wkhtmltopdf/wkhtmltoimage: http://wkhtmltopdf.org/downloads.html
+function html_to_png(html_fn, png_fn, w, h)
+    run(`wkhtmltoimage -f png -q --width $w --height $h --disable-smart-width $html_fn $png_fn`)
+end
+
+function show_png_from_html(io::IO, plt::AbstractPlot)
+    # write html to a temporary file
+    html_fn = write_temp_html(plt)
+
+    # convert that html file to a temporary png file using wkhtmltoimage
+    png_fn = tempname() * ".png"
+    w, h = plt.attr[:size]
+    html_to_png(html_fn, png_fn, w, h)
+
+    # now read that file data into io
+    pngdata = readall(png_fn)
+    write(io, pngdata)
+end

src/components.jl

@@ -0,0 +1,810 @@
+
+
+const P2 = GeometryTypes.Point2{Float64}
+const P3 = GeometryTypes.Point3{Float64}
+
+nanpush!(a::AbstractVector{P2}, b) = (push!(a, P2(NaN,NaN)); push!(a, b))
+nanappend!(a::AbstractVector{P2}, b) = (push!(a, P2(NaN,NaN)); append!(a, b))
+nanpush!(a::AbstractVector{P3}, b) = (push!(a, P3(NaN,NaN,NaN)); push!(a, b))
+nanappend!(a::AbstractVector{P3}, b) = (push!(a, P3(NaN,NaN,NaN)); append!(a, b))
+compute_angle(v::P2) = (angle = atan(v[2], v[1]); angle < 0 ? 2π - angle : angle)
+
+# -------------------------------------------------------------
+
+struct Shape
+    x::Vector{Float64}
+    y::Vector{Float64}
+    # function Shape(x::AVec, y::AVec)
+    #     # if x[1] != x[end] || y[1] != y[end]
+    #     #     new(vcat(x, x[1]), vcat(y, y[1]))
+    #     # else
+    #         new(x, y)
+    #     end
+    # end
+end
+
+"""
+    Shape(x, y)
+    Shape(vertices)
+
+Construct a polygon to be plotted
+"""
+Shape(verts::AVec) = Shape(unzip(verts)...)
+Shape(s::Shape) = deepcopy(s)
+
+get_xs(shape::Shape) = shape.x
+get_ys(shape::Shape) = shape.y
+vertices(shape::Shape) = collect(zip(shape.x, shape.y))
+
+#deprecated
+@deprecate shape_coords coords
+
+"return the vertex points from a Shape or Segments object"
+function coords(shape::Shape)
+    shape.x, shape.y
+end
+
+function coords(shapes::AVec{Shape})
+    length(shapes) == 0 && return zeros(0), zeros(0)
+    xs = map(get_xs, shapes)
+    ys = map(get_ys, shapes)
+    x, y = map(copy, coords(shapes[1]))
+    for shape in shapes[2:end]
+        nanappend!(x, shape.x)
+        nanappend!(y, shape.y)
+    end
+    x, y
+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)]
+end
+
+"interleave 2 vectors into each other (like a zipper's teeth)"
+function weave(x,y; ordering = Vector[x,y])
+  ret = eltype(x)[]
+  done = false
+  while !done
+    for o in ordering
+      try
+          push!(ret, popfirst!(o))
+      catch
+      end
+    end
+    done = isempty(x) && isempty(y)
+  end
+  ret
+end
+
+
+"create a star by weaving together points from an outer and inner circle.  `n` is the number of arms"
+function makestar(n; offset = -0.5, radius = 1.0)
+    z1 = offset * π
+    z2 = z1 + π / (n)
+    outercircle = partialcircle(z1, z1 + 2π, n+1, radius)
+    innercircle = partialcircle(z2, z2 + 2π, n+1, 0.4radius)
+    Shape(weave(outercircle, innercircle))
+end
+
+"create a shape by picking points around the unit circle.  `n` is the number of point/sides, `offset` is the starting angle"
+function makeshape(n; offset = -0.5, radius = 1.0)
+    z = offset * π
+    Shape(partialcircle(z, z + 2π, n+1, radius))
+end
+
+
+function makecross(; offset = -0.5, radius = 1.0)
+    z2 = offset * π
+    z1 = z2 - π/8
+    outercircle = partialcircle(z1, z1 + 2π, 9, radius)
+    innercircle = partialcircle(z2, z2 + 2π, 5, 0.5radius)
+    Shape(weave(outercircle, innercircle,
+                ordering=Vector[outercircle,innercircle,outercircle]))
+end
+
+
+from_polar(angle, dist) = P2(dist*cos(angle), dist*sin(angle))
+
+function makearrowhead(angle; h = 2.0, w = 0.4)
+    tip = from_polar(angle, h)
+    Shape(P2[(0,0), from_polar(angle - 0.5π, w) - tip,
+        from_polar(angle + 0.5π, w) - tip, (0,0)])
+end
+
+const _shape_keys = Symbol[
+  :circle,
+  :rect,
+  :star5,
+  :diamond,
+  :hexagon,
+  :cross,
+  :xcross,
+  :utriangle,
+  :dtriangle,
+  :rtriangle,
+  :ltriangle,
+  :pentagon,
+  :heptagon,
+  :octagon,
+  :star4,
+  :star6,
+  :star7,
+  :star8,
+  :vline,
+  :hline,
+  :+,
+  :x,
+]
+
+const _shapes = Dict{Symbol,Shape}(
+    :circle    => makeshape(20),
+    :rect       => makeshape(4, offset=-0.25),
+    :diamond    => makeshape(4),
+    :utriangle  => makeshape(3, offset=0.5),
+    :dtriangle  => makeshape(3, offset=-0.5),
+    :rtriangle  => makeshape(3, offset=0.0),
+    :ltriangle  => makeshape(3, offset=1.0),
+    :pentagon   => makeshape(5),
+    :hexagon    => makeshape(6),
+    :heptagon   => makeshape(7),
+    :octagon    => makeshape(8),
+    :cross      => makecross(offset=-0.25),
+    :xcross     => makecross(),
+    :vline      => Shape([(0,1),(0,-1)]),
+    :hline      => Shape([(1,0),(-1,0)]),
+  )
+
+for n in [4,5,6,7,8]
+  _shapes[Symbol("star$n")] = makestar(n)
+end
+
+Shape(k::Symbol) = deepcopy(_shapes[k])
+
+# -----------------------------------------------------------------------
+
+
+# uses the centroid calculation from https://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
+"return the centroid of a Shape"
+function center(shape::Shape)
+    x, y = coords(shape)
+    n = length(x)
+    A, Cx, Cy = 0.0, 0.0, 0.0
+    for i=1:n
+        ip1 = i==n ? 1 : i+1
+        A += x[i] * y[ip1] - x[ip1] * y[i]
+    end
+    A *= 0.5
+    for i=1:n
+        ip1 = i==n ? 1 : i+1
+        m = (x[i] * y[ip1] - x[ip1] * y[i])
+        Cx += (x[i] + x[ip1]) * m
+        Cy += (y[i] + y[ip1]) * m
+    end
+    Cx / 6A, Cy / 6A
+end
+
+function scale!(shape::Shape, x::Real, y::Real = x, c = center(shape))
+    sx, sy = coords(shape)
+    cx, cy = c
+    for i=1:length(sx)
+        sx[i] = (sx[i] - cx) * x + cx
+        sy[i] = (sy[i] - cy) * y + cy
+    end
+    shape
+end
+
+function scale(shape::Shape, x::Real, y::Real = x, c = center(shape))
+    shapecopy = deepcopy(shape)
+    scale!(shapecopy, x, y, c)
+end
+
+"translate a Shape in space"
+function translate!(shape::Shape, x::Real, y::Real = x)
+    sx, sy = coords(shape)
+    for i=1:length(sx)
+        sx[i] += x
+        sy[i] += y
+    end
+    shape
+end
+
+function translate(shape::Shape, x::Real, y::Real = x)
+    shapecopy = deepcopy(shape)
+    translate!(shapecopy, x, y)
+end
+
+function rotate_x(x::Real, y::Real, Θ::Real, centerx::Real, centery::Real)
+    (x - centerx) * cos(Θ) - (y - centery) * sin(Θ) + centerx
+end
+
+function rotate_y(x::Real, y::Real, Θ::Real, centerx::Real, centery::Real)
+    (y - centery) * cos(Θ) + (x - centerx) * sin(Θ) + centery
+end
+
+function rotate(x::Real, y::Real, θ::Real, c = center(shape))
+    cx, cy = c
+    rotate_x(x, y, Θ, cx, cy), rotate_y(x, y, Θ, cx, cy)
+end
+
+function rotate!(shape::Shape, Θ::Real, c = center(shape))
+    x, y = coords(shape)
+    cx, cy = c
+    for i=1:length(x)
+        xi = rotate_x(x[i], y[i], Θ, cx, cy)
+        yi = rotate_y(x[i], y[i], Θ, cx, cy)
+        x[i], y[i] = xi, yi
+    end
+    shape
+end
+
+"rotate an object in space"
+function rotate(shape::Shape, Θ::Real, c = center(shape))
+    shapecopy = deepcopy(shape)
+    rotate!(shapecopy, Θ, c)
+end
+
+# -----------------------------------------------------------------------
+
+
+mutable struct Font
+  family::AbstractString
+  pointsize::Int
+  halign::Symbol
+  valign::Symbol
+  rotation::Float64
+  color::Colorant
+end
+
+"""
+    font(args...)
+Create a Font from a list of features. Values may be specified either as
+arguments (which are distinguished by type/value) or as keyword arguments.
+# Arguments
+- `family`: AbstractString. "serif" or "sans-serif" or "monospace"
+- `pointsize`: Integer. Size of font in points
+- `halign`: Symbol. Horizontal alignment (:hcenter, :left, or :right)
+- `valign`: Symbol. Vertical aligment (:vcenter, :top, or :bottom)
+- `rotation`: Real. Angle of rotation for text in degrees (use a non-integer type)
+- `color`: Colorant or Symbol
+# Examples
+```julia-repl
+julia> font(8)
+julia> font(family="serif",halign=:center,rotation=45.0)
+```
+"""
+function font(args...;kw...)
+
+  # defaults
+  family = "sans-serif"
+  pointsize = 14
+  halign = :hcenter
+  valign = :vcenter
+  rotation = 0.0
+  color = colorant"black"
+
+  for arg in args
+    T = typeof(arg)
+
+    if T == Font
+      family = arg.family
+      pointsize = arg.pointsize
+      halign = arg.halign
+      valign = arg.valign
+      rotation = arg.rotation
+      color = arg.color
+    elseif arg == :center
+      halign = :hcenter
+      valign = :vcenter
+    elseif arg in (:hcenter, :left, :right)
+      halign = arg
+    elseif arg in (:vcenter, :top, :bottom)
+      valign = arg
+    elseif T <: Colorant
+      color = arg
+    elseif T <: Symbol || T <: AbstractString
+      try
+        color = parse(Colorant, string(arg))
+      catch
+        family = string(arg)
+      end
+    elseif typeof(arg) <: Integer
+      pointsize = arg
+    elseif typeof(arg) <: Real
+      rotation = convert(Float64, arg)
+    else
+      @warn("Unused font arg: $arg ($(typeof(arg)))")
+    end
+  end
+
+  for symbol in keys(kw)
+    if symbol == :family
+      family = kw[:family]
+    elseif symbol == :pointsize
+      pointsize = kw[:pointsize]
+    elseif symbol == :halign
+      halign = kw[:halign]
+      if halign == :center
+        halign = :hcenter
+      end
+      @assert halign in (:hcenter, :left, :right)
+    elseif symbol == :valign
+      valign = kw[:valign]
+      if valign == :center
+        valign = :vcenter
+      end
+      @assert valign in (:vcenter, :top, :bottom)
+    elseif symbol == :rotation
+      rotation = kw[:rotation]
+    elseif symbol == :color
+      color = parse(Colorant, kw[:color])
+    else
+      @warn("Unused font kwarg: $symbol")
+    end
+  end
+
+  Font(family, pointsize, halign, valign, rotation, color)
+end
+
+function scalefontsize(k::Symbol, factor::Number)
+    f = default(k)
+    f = round(Int, factor * f)
+    default(k, f)
+end
+
+"""
+    scalefontsizes(factor::Number)
+
+Scales all **current** font sizes by `factor`. For example `scalefontsizes(1.1)` increases all current font sizes by 10%. To reset to initial sizes, use `scalefontsizes()`
+"""
+function scalefontsizes(factor::Number)
+    for k in (:titlefontsize, :guidefontsize, :tickfontsize, :legendfontsize)
+        scalefontsize(k, factor)
+    end
+end
+
+"""
+    scalefontsizes()
+
+Resets font sizes to initial default values.
+"""
+function scalefontsizes()
+  for k in (:titlefontsize, :guidefontsize, :tickfontsize, :legendfontsize)
+      f = default(k)
+      if k in keys(_initial_fontsizes)
+        factor = f / _initial_fontsizes[k]
+        scalefontsize(k, 1.0/factor)
+      end
+  end
+end
+
+"Wrap a string with font info"
+struct PlotText
+  str::AbstractString
+  font::Font
+end
+PlotText(str) = PlotText(string(str), font())
+
+"""
+    text(string, args...; kw...)
+
+Create a PlotText object wrapping a string with font info, for plot annotations.
+`args` and `kw` are passed to `font`.
+"""
+text(t::PlotText) = t
+text(t::PlotText, font::Font) = PlotText(t.str, font)
+text(str::AbstractString, f::Font) = PlotText(str, f)
+function text(str, args...;kw...)
+  PlotText(string(str), font(args...;kw...))
+end
+
+Base.length(t::PlotText) = length(t.str)
+
+# -----------------------------------------------------------------------
+
+# -----------------------------------------------------------------------
+
+struct Stroke
+  width
+  color
+  alpha
+  style
+end
+
+"""
+    stroke(args...; alpha = nothing)
+
+Define the properties of the stroke used in plotting lines
+"""
+function stroke(args...; alpha = nothing)
+  width = 1
+  color = :black
+  style = :solid
+
+  for arg in args
+    T = typeof(arg)
+
+    # if arg in _allStyles
+    if allStyles(arg)
+      style = arg
+    elseif T <: Colorant
+      color = arg
+    elseif T <: Symbol || T <: AbstractString
+      try
+        color = parse(Colorant, string(arg))
+      catch
+      end
+    elseif allAlphas(arg)
+      alpha = arg
+    elseif allReals(arg)
+      width = arg
+    else
+      @warn("Unused stroke arg: $arg ($(typeof(arg)))")
+    end
+  end
+
+  Stroke(width, color, alpha, style)
+end
+
+
+struct Brush
+  size  # fillrange, markersize, or any other sizey attribute
+  color
+  alpha
+end
+
+function brush(args...; alpha = nothing)
+  size = 1
+  color = :black
+
+  for arg in args
+    T = typeof(arg)
+
+    if T <: Colorant
+      color = arg
+    elseif T <: Symbol || T <: AbstractString
+      try
+        color = parse(Colorant, string(arg))
+      catch
+      end
+    elseif allAlphas(arg)
+      alpha = arg
+    elseif allReals(arg)
+      size = arg
+    else
+      @warn("Unused brush arg: $arg ($(typeof(arg)))")
+    end
+  end
+
+  Brush(size, color, alpha)
+end
+
+# -----------------------------------------------------------------------
+
+mutable struct SeriesAnnotations
+    strs::AbstractVector  # the labels/names
+    font::Font
+    baseshape::Union{Shape, AbstractVector{Shape}, Nothing}
+    scalefactor::Tuple
+end
+function series_annotations(strs::AbstractVector, args...)
+    fnt = font()
+    shp = nothing
+    scalefactor = (1,1)
+    for arg in args
+        if isa(arg, Shape) || (isa(arg, AbstractVector) && eltype(arg) == Shape)
+            shp = arg
+        elseif isa(arg, Font)
+            fnt = arg
+        elseif isa(arg, Symbol) && haskey(_shapes, arg)
+            shp = _shapes[arg]
+        elseif isa(arg, Number)
+            scalefactor = (arg,arg)
+        elseif is_2tuple(arg)
+            scalefactor = arg
+        else
+            @warn("Unused SeriesAnnotations arg: $arg ($(typeof(arg)))")
+        end
+    end
+    # if scalefactor != 1
+    #     for s in get(shp)
+    #         scale!(s, scalefactor, scalefactor, (0,0))
+    #     end
+    # end
+    SeriesAnnotations(strs, fnt, shp, scalefactor)
+end
+series_annotations(anns::SeriesAnnotations) = anns
+series_annotations(::Nothing) = nothing
+
+function series_annotations_shapes!(series::Series, scaletype::Symbol = :pixels)
+    anns = series[:series_annotations]
+    # msw,msh = anns.scalefactor
+    # ms = series[:markersize]
+    # msw,msh = if isa(ms, AbstractVector)
+    #     1,1
+    # elseif is_2tuple(ms)
+    #     ms
+    # else
+    #     ms,ms
+    # end
+
+    # @show msw msh
+    if anns !== nothing && anns.baseshape !== nothing
+        # we use baseshape to overwrite the markershape attribute
+        # with a list of custom shapes for each
+        msw,msh = anns.scalefactor
+        msize = Float64[]
+        shapes = Vector{Shape}(undef, length(anns.strs))
+        for i in eachindex(anns.strs)
+            str = _cycle(anns.strs,i)
+
+            # get the width and height of the string (in mm)
+            sw, sh = text_size(str, anns.font.pointsize)
+
+            # how much to scale the base shape?
+            # note: it's a rough assumption that the shape fills the unit box [-1,-1,1,1],
+            #       so we scale the length-2 shape by 1/2 the total length
+            scalar = (backend() == PyPlotBackend() ? 1.7 : 1.0)
+            xscale = 0.5to_pixels(sw) * scalar
+            yscale = 0.5to_pixels(sh) * scalar
+
+            # we save the size of the larger direction to the markersize list,
+            # and then re-scale a copy of baseshape to match the w/h ratio
+            maxscale = max(xscale, yscale)
+            push!(msize, maxscale)
+            baseshape = _cycle(anns.baseshape, i)
+            shapes[i] = scale(baseshape, msw*xscale/maxscale, msh*yscale/maxscale, (0,0))
+        end
+        series[:markershape] = shapes
+        series[:markersize] = msize
+    end
+    return
+end
+
+mutable struct EachAnn
+    anns
+    x
+    y
+end
+
+function Base.iterate(ea::EachAnn, i = 1)
+    if ea.anns === nothing || isempty(ea.anns.strs) || i > length(ea.y)
+        return nothing
+    end
+
+    tmp = _cycle(ea.anns.strs,i)
+    str,fnt = if isa(tmp, PlotText)
+        tmp.str, tmp.font
+    else
+        tmp, ea.anns.font
+    end
+    ((_cycle(ea.x,i), _cycle(ea.y,i), str, fnt), i+1)
+end
+
+annotations(::Nothing) = []
+annotations(anns::AVec) = anns
+annotations(anns) = Any[anns]
+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())
+    anns = []
+    labs = makevec(labs)
+    for i in 1:max(length(xs), length(ys), length(labs))
+        x, y, lab = _cycle(xs, i), _cycle(ys, i), _cycle(labs, i)
+        if lab == :auto
+            alphabet = "abcdefghijklmnopqrstuvwxyz"
+            push!(anns, (x, y, text(string("(", alphabet[sp[:subplot_index]], ")"), font)))
+        else
+            push!(anns, (x, y, isa(lab, PlotText) ? lab : isa(lab, Tuple) ? text(lab...) : text(lab, font)))
+        end
+    end
+    anns
+end
+function process_annotation(sp::Subplot, positions::Union{AVec{Symbol},Symbol}, labs, font = font())
+    anns = []
+    positions, labs = makevec(positions), makevec(labs)
+    for i in 1:max(length(positions), length(labs))
+        pos, lab = _cycle(positions, i), _cycle(labs, i)
+        pos = get(_positionAliases, pos, pos)
+        if lab == :auto
+            alphabet = "abcdefghijklmnopqrstuvwxyz"
+            push!(anns, (pos, text(string("(", alphabet[sp[:subplot_index]], ")"), font)))
+        else
+            push!(anns, (pos, isa(lab, PlotText) ? lab : isa(lab, Tuple) ? text(lab...) : text(lab, font)))
+        end
+    end
+    anns
+end
+
+# Give each annotation coordinates based on specified position
+function locate_annotation(sp::Subplot, pos::Symbol, lab::PlotText)
+    position_multiplier = Dict{Symbol, Tuple{Float64,Float64}}(
+        :topleft       => (0.1, 0.9),
+        :topcenter     => (0.5, 0.9),
+        :topright      => (0.9, 0.9),
+        :bottomleft    => (0.1, 0.1),
+        :bottomcenter  => (0.5, 0.1),
+        :bottomright   => (0.9, 0.1),
+    )
+    xmin, xmax = ignorenan_extrema(sp[:xaxis])
+    ymin, ymax = ignorenan_extrema(sp[:yaxis])
+    x, y = (xmin, ymin).+ position_multiplier[pos].* (xmax - xmin, ymax - ymin)
+    (x, y, lab)
+end
+locate_annotation(sp::Subplot, x, y, label::PlotText) = (x, y, label)
+# -----------------------------------------------------------------------
+
+"type which represents z-values for colors and sizes (and anything else that might come up)"
+struct ZValues
+  values::Vector{Float64}
+  zrange::Tuple{Float64,Float64}
+end
+
+function zvalues(values::AVec{T}, zrange::Tuple{T,T} = (ignorenan_minimum(values), ignorenan_maximum(values))) where T<:Real
+  ZValues(collect(float(values)), map(Float64, zrange))
+end
+
+# -----------------------------------------------------------------------
+
+abstract type AbstractSurface end
+
+"represents a contour or surface mesh"
+struct Surface{M<:AMat} <: AbstractSurface
+  surf::M
+end
+
+Surface(f::Function, x, y) = Surface(Float64[f(xi,yi) for yi in y, xi in x])
+
+Base.Array(surf::Surface) = surf.surf
+
+for f in (:length, :size)
+  @eval Base.$f(surf::Surface, args...) = $f(surf.surf, args...)
+end
+Base.copy(surf::Surface) = Surface(copy(surf.surf))
+Base.eltype(surf::Surface{T}) where {T} = eltype(T)
+
+function expand_extrema!(a::Axis, surf::Surface)
+    ex = a[:extrema]
+    for vi in surf.surf
+        expand_extrema!(ex, vi)
+    end
+    ex
+end
+
+"For the case of representing a surface as a function of x/y... can possibly avoid allocations."
+struct SurfaceFunction <: AbstractSurface
+    f::Function
+end
+
+
+# -----------------------------------------------------------------------
+
+# # I don't want to clash with ValidatedNumerics, but this would be nice:
+# ..(a::T, b::T) = (a,b)
+
+struct Volume{T}
+    v::Array{T,3}
+    x_extents::Tuple{T,T}
+    y_extents::Tuple{T,T}
+    z_extents::Tuple{T,T}
+end
+
+default_extents(::Type{T}) where {T} = (zero(T), one(T))
+
+function Volume(v::Array{T,3},
+                x_extents = default_extents(T),
+                y_extents = default_extents(T),
+                z_extents = default_extents(T)) where T
+    Volume(v, x_extents, y_extents, z_extents)
+end
+
+Base.Array(vol::Volume) = vol.v
+for f in (:length, :size)
+  @eval Base.$f(vol::Volume, args...) = $f(vol.v, args...)
+end
+Base.copy(vol::Volume{T}) where {T} = Volume{T}(copy(vol.v), vol.x_extents, vol.y_extents, vol.z_extents)
+Base.eltype(vol::Volume{T}) where {T} = T
+
+# -----------------------------------------------------------------------
+
+# style is :open or :closed (for now)
+struct Arrow
+    style::Symbol
+    side::Symbol  # :head (default), :tail, or :both
+    headlength::Float64
+    headwidth::Float64
+end
+
+"""
+    arrow(args...)
+
+Define arrowheads to apply to lines - args are `style` (`:open` or `:closed`),
+`side` (`:head`, `:tail` or `:both`), `headlength` and `headwidth`
+"""
+function arrow(args...)
+    style = :simple
+    side = :head
+    headlength = 0.3
+    headwidth = 0.3
+    setlength = false
+    for arg in args
+        T = typeof(arg)
+        if T == Symbol
+            if arg in (:head, :tail, :both)
+                side = arg
+            else
+                style = arg
+            end
+        elseif T <: Number
+            # first we apply to both, but if there's more, then only change width after the first number
+            headwidth = Float64(arg)
+            if !setlength
+                headlength = headwidth
+            end
+            setlength = true
+        elseif T <: Tuple && length(arg) == 2
+            headlength, headwidth = Float64(arg[1]), Float64(arg[2])
+        else
+            @warn("Skipped arrow arg $arg")
+        end
+    end
+    Arrow(style, side, headlength, headwidth)
+end
+
+
+# allow for do-block notation which gets called on every valid start/end pair which
+# we need to draw an arrow
+function add_arrows(func::Function, x::AVec, y::AVec)
+    for i=2:length(x)
+        xyprev = (x[i-1], y[i-1])
+        xy = (x[i], y[i])
+        if ok(xyprev) && ok(xy)
+            if i==length(x) || !ok(x[i+1], y[i+1])
+                # add the arrow from xyprev to xy
+                func(xyprev, xy)
+            end
+        end
+    end
+end
+
+# -----------------------------------------------------------------------
+
+"Represents data values with formatting that should apply to the tick labels."
+struct Formatted{T}
+    data::T
+    formatter::Function
+end
+
+# -----------------------------------------------------------------------
+"create a BezierCurve for plotting"
+mutable struct BezierCurve{T <: GeometryTypes.Point}
+    control_points::Vector{T}
+end
+
+function (bc::BezierCurve)(t::Real)
+    p = zero(P2)
+    n = length(bc.control_points)-1
+    for i in 0:n
+        p += bc.control_points[i+1] * binomial(n, i) * (1-t)^(n-i) * t^i
+    end
+    p
+end
+
+@deprecate curve_points coords
+
+coords(curve::BezierCurve, n::Integer = 30; range = [0,1]) = map(curve, range(range..., stop=n, length=50))
+
+# build a BezierCurve which leaves point p vertically upwards and arrives point q vertically upwards.
+# may create a loop if necessary.  Assumes the view is [0,1]
+function directed_curve(args...; kw...)
+    error("directed_curve has been moved to PlotRecipes")
+end
+
+function extrema_plus_buffer(v, buffmult = 0.2)
+    vmin,vmax = ignorenan_extrema(v)
+    vdiff = vmax-vmin
+    buffer = vdiff * buffmult
+    vmin - buffer, vmax + buffer
+end

src/examples.jl

@@ -0,0 +1,513 @@
+"""
+Holds all data needed for a documentation example... header, description, and plotting expression (Expr)
+"""
+mutable struct PlotExample
+  header::AbstractString
+  desc::AbstractString
+  exprs::Vector{Expr}
+end
+
+# the _examples we'll run for each
+const _examples = PlotExample[
+
+PlotExample("Lines",
+    "A simple line plot of the columns.",
+    [:(begin
+        plot(Plots.fakedata(50,5), w=3)
+    end)]
+),
+
+PlotExample("Functions, adding data, and animations",
+"""
+Plot multiple functions.  You can also put the function first, or use the form `plot(f,
+xmin, xmax)` where f is a Function or AbstractVector{Function}.\n\nGet series data:
+`x, y = plt[i]`.  Set series data: `plt[i] = (x,y)`. Add to the series with
+`push!`/`append!`.\n\nEasily build animations.  (`convert` or `ffmpeg` must be available
+to generate the animation.)  Use command `gif(anim, filename, fps=15)` to save the
+animation.
+""",
+    [:(begin
+        p = plot([sin,cos], zeros(0), leg=false)
+        anim = Animation()
+        for x in range(0, stop=10π, length=100)
+            push!(p, x, Float64[sin(x), cos(x)])
+            frame(anim)
+        end
+    end)]
+),
+
+PlotExample("Parametric plots",
+    "Plot function pair (x(u), y(u)).",
+    [:(begin
+        plot(sin, x->sin(2x), 0, 2π, line=4, leg=false, fill=(0,:orange))
+    end)]
+),
+
+PlotExample("Colors",
+"""
+Access predefined palettes (or build your own with the `colorscheme` method).
+Line/marker colors are auto-generated from the plot's palette, unless overridden.  Set
+the `z` argument to turn on series gradients.
+""",
+    [:(begin
+y = rand(100)
+plot(0:10:100,rand(11,4),lab="lines",w=3,palette=:grays,fill=0, α=0.6)
+scatter!(y, zcolor=abs.(y.-0.5), m=(:heat,0.8,Plots.stroke(1,:green)), ms=10*abs.(y.-0.5).+4,
+         lab="grad")
+    end)]
+),
+
+PlotExample("Global",
+"""
+Change the guides/background/limits/ticks.  Convenience args `xaxis` and `yaxis` allow
+you to pass a tuple or value which will be mapped to the relevant args automatically.
+The `xaxis` below will be replaced with `xlabel` and `xlims` args automatically during
+the preprocessing step. You can also use shorthand functions: `title!`, `xaxis!`,
+`yaxis!`, `xlabel!`, `ylabel!`, `xlims!`, `ylims!`, `xticks!`, `yticks!`
+""",
+    [:(begin
+using Statistics
+y = rand(20,3)
+plot(y, xaxis=("XLABEL",(-5,30),0:2:20,:flip), background_color = RGB(0.2,0.2,0.2),
+     leg=false)
+hline!(mean(y, dims = 1)+rand(1,3), line=(4,:dash,0.6,[:lightgreen :green :darkgreen]))
+vline!([5,10])
+title!("TITLE")
+yaxis!("YLABEL", :log10)
+    end)]
+),
+
+# PlotExample("Two-axis",
+#             "Use the `axis` arguments.",
+#             [
+#               :(plot(Vector[randn(100), randn(100)*100], axis = [:l :r], ylabel="LEFT", yrightlabel="RIGHT", xlabel="X", title="TITLE"))
+#             ]),
+
+PlotExample("Images",
+    "Plot an image.  y-axis is set to flipped",
+    [:(begin
+    import FileIO
+    path = download("http://juliaplots.org/PlotReferenceImages.jl/Plots/pyplot/0.7.0/ref1.png")
+    img = FileIO.load(path)
+        plot(img)
+    end)]
+),
+
+PlotExample("Arguments",
+"""
+Plot multiple series with different numbers of points.  Mix arguments that apply to all
+series (marker/markersize) with arguments unique to each series (colors).  Special
+arguments `line`, `marker`, and `fill` will automatically figure out what arguments to
+set (for example, we are setting the `linestyle`, `linewidth`, and `color` arguments with
+`line`.)  Note that we pass a matrix of colors, and this applies the colors to each
+series.
+""",
+    [:(begin
+        ys = Vector[rand(10), rand(20)]
+        plot(ys, color=[:black :orange], line=(:dot,4), marker=([:hex :d],12,0.8,Plots.stroke(3,:gray)))
+    end)]
+),
+
+PlotExample("Build plot in pieces",
+    "Start with a base plot...",
+    [:(begin
+        plot(rand(100)/3, reg=true, fill=(0,:green))
+    end)]
+),
+
+PlotExample("",
+    "and add to it later.",
+    [:(begin
+        scatter!(rand(100), markersize=6, c=:orange)
+    end)]
+),
+
+PlotExample("Histogram2D",
+    "",
+    [:(begin
+        histogram2d(randn(10000), randn(10000), nbins=20)
+    end)]
+),
+
+PlotExample("Line types",
+    "",
+    [:(begin
+        linetypes = [:path :steppre :steppost :sticks :scatter]
+        n = length(linetypes)
+        x = Vector[sort(rand(20)) for i in 1:n]
+        y = rand(20,n)
+        plot(x, y, line=(linetypes,3), lab=map(string,linetypes), ms=15)
+    end)]
+),
+
+PlotExample("Line styles",
+    "",
+    [:(begin
+styles = filter(s -> s in Plots.supported_styles(),
+                [:solid, :dash, :dot, :dashdot, :dashdotdot])
+styles = reshape(styles, 1, length(styles)) # Julia 0.6 unfortunately gives an error when transposing symbol vectors
+n = length(styles)
+y = cumsum(randn(20,n), dims = 1)
+plot(y, line = (5, styles), label = map(string,styles), legendtitle = "linestyle")
+             end)]
+),
+
+PlotExample("Marker types",
+    "",
+    [:(begin
+        markers = filter(m -> m in Plots.supported_markers(), Plots._shape_keys)
+        markers = reshape(markers, 1, length(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), lab=map(string,markers), bg=:linen, xlim=(0,10), ylim=(0,10))
+    end)]
+),
+
+PlotExample("Bar",
+    "x is the midpoint of the bar. (todo: allow passing of edges instead of midpoints)",
+    [:(begin
+        bar(randn(99))
+    end)]
+),
+
+PlotExample("Histogram",
+    "",
+    [:(begin
+        histogram(randn(1000), bins = :scott, weights = repeat(1:5, outer = 200))
+    end)]
+),
+
+PlotExample("Subplots",
+"""
+Use the `layout` keyword, and optionally the convenient `@layout` macro to generate
+arbitrarily complex subplot layouts.
+""",
+    [:(begin
+l = @layout([a{0.1h}; b [c;d e]])
+plot(randn(100,5), layout=l, t=[:line :histogram :scatter :steppre :bar], leg=false,
+     ticks=nothing, border=:none)
+    end)]
+),
+
+PlotExample("Adding to subplots",
+"""
+Note here the automatic grid layout, as well as the order in which new series are added
+to the plots.
+""",
+    [:(begin
+plot(Plots.fakedata(100,10), layout=4, palette=[:grays :blues :heat :lightrainbow],
+     bg_inside=[:orange :pink :darkblue :black])
+    end)]
+),
+
+PlotExample("",
+    "",
+    [:(begin
+        using Random
+        Random.seed!(111)
+        plot!(Plots.fakedata(100,10))
+    end)]
+),
+
+PlotExample("Open/High/Low/Close",
+"""
+Create an OHLC chart.  Pass in a list of (open,high,low,close) tuples as your `y`
+argument.  This uses recipes to first convert the tuples to OHLC objects, and
+subsequently create a :path series with the appropriate line segments.
+""",
+    [:(begin
+n=20
+hgt=rand(n).+1
+bot=randn(n)
+openpct=rand(n)
+closepct=rand(n)
+y = OHLC[(openpct[i]*hgt[i]+bot[i], bot[i]+hgt[i], bot[i],
+          closepct[i]*hgt[i]+bot[i]) for i in 1:n]
+ohlc(y)
+    end)]
+),
+
+PlotExample("Annotations",
+"""
+The `annotations` keyword is used for text annotations in data-coordinates.  Pass in a
+tuple (x,y,text) or a vector of annotations.  `annotate!(ann)` is shorthand for `plot!(;
+annotation=ann)`.  Series annotations are used for annotating individual data points.
+They require only the annotation... x/y values are computed.  A `PlotText` object can be
+build with the method `text(string, attr...)`, which wraps font and color attributes.
+""",
+    [:(begin
+y = rand(10)
+plot(y, annotations = (3,y[3],text("this is #3",:left)), leg=false)
+annotate!([(5, y[5], text("this is #5",16,:red,:center)),
+          (10, y[10], text("this is #10",:right,20,"courier"))])
+scatter!(range(2, stop=8, length=6), rand(6), marker=(50,0.2,:orange),
+         series_annotations = ["series","annotations","map","to","series",
+                               text("data",:green)])
+    end)]
+),
+
+PlotExample("Custom Markers",
+"""A `Plots.Shape` is a light wrapper around vertices of a polygon.  For supported
+backends, pass arbitrary polygons as the marker shapes.  Note: The center is (0,0) and
+the size is expected to be rougly the area of the unit circle.
+""",
+    [:(begin
+verts = [(-1.0,1.0),(-1.28,0.6),(-0.2,-1.4),(0.2,-1.4),(1.28,0.6),(1.0,1.0),
+         (-1.0,1.0),(-0.2,-0.6),(0.0,-0.2),(-0.4,0.6),(1.28,0.6),(0.2,-1.4),
+         (-0.2,-1.4),(0.6,0.2),(-0.2,0.2),(0.0,-0.2),(0.2,0.2),(-0.2,-0.6)]
+x = 0.1:0.2:0.9
+y = 0.7rand(5).+0.15
+plot(x, y, line = (3,:dash,:lightblue), marker = (Shape(verts),30,RGBA(0,0,0,0.2)),
+     bg=:pink, fg=:darkblue, xlim = (0,1), ylim=(0,1), leg=false)
+    end)]
+),
+
+PlotExample("Contours",
+"""
+Any value for fill works here.  We first build a filled contour from a function, then an
+unfilled contour from a matrix.
+""",
+    [:(begin
+        x = 1:0.5:20
+        y = 1:0.5:10
+        f(x,y) = (3x+y^2)*abs(sin(x)+cos(y))
+        X = repeat(reshape(x,1,:), length(y), 1)
+        Y = repeat(y, 1, length(x))
+        Z = map(f, X, Y)
+        p1 = contour(x, y, f, fill=true)
+        p2 = contour(x, y, Z)
+        plot(p1, p2)
+    end)]
+),
+
+PlotExample("Pie",
+    "",
+    [:(begin
+        x = ["Nerds", "Hackers", "Scientists"]
+        y = [0.4, 0.35, 0.25]
+        pie(x, y, title="The Julia Community", l=0.5)
+    end)]
+),
+
+PlotExample("3D",
+    "",
+    [:(begin
+        n = 100
+        ts = range(0, stop=8π, length=n)
+        x = ts .* map(cos,ts)
+        y = 0.1ts .* map(sin,ts)
+        z = 1:n
+        plot(x, y, z, zcolor=reverse(z), m=(10,0.8,:blues,Plots.stroke(0)), leg=false, cbar=true, w=5)
+        plot!(zeros(n),zeros(n),1:n, w=10)
+    end)]
+),
+
+PlotExample("DataFrames",
+    "Plot using DataFrame column symbols.",
+    [:(begin
+        import RDatasets
+        iris = RDatasets.dataset("datasets", "iris")
+        @df iris scatter(:SepalLength, :SepalWidth, group=:Species,
+            title = "My awesome plot", xlabel = "Length", ylabel = "Width",
+            marker = (0.5, [:cross :hex :star7], 12), bg=RGB(.2,.2,.2))
+    end)]
+),
+
+PlotExample("Groups and Subplots",
+    "",
+    [:(begin
+        group = rand(map(i->"group $i",1:4),100)
+        plot(rand(100), layout=@layout([a b;c]), group=group,
+            linetype=[:bar :scatter :steppre], linecolor = :match)
+    end)]
+),
+
+PlotExample("Polar Plots",
+    "",
+    [:(begin
+        Θ = range(0, stop=1.5π, length=100)
+        r = abs.(0.1randn(100)+sin.(3Θ))
+        plot(Θ, r, proj=:polar, m=2)
+    end)]
+),
+
+PlotExample("Heatmap, categorical axes, and aspect_ratio",
+    "",
+    [:(begin
+        xs = [string("x",i) for i=1:10]
+        ys = [string("y",i) for i=1:4]
+        z = float((1:4)*reshape(1:10,1,:))
+        heatmap(xs, ys, z, aspect_ratio=1)
+    end)]
+),
+
+PlotExample("Layouts, margins, label rotation, title location",
+    "",
+    [:(begin
+        using Plots.PlotMeasures # for Measures, e.g. mm and px
+        plot(rand(100,6),layout=@layout([a b; c]),title=["A" "B" "C"],
+                        title_location=:left, left_margin=[20mm 0mm],
+                        bottom_margin=10px, xrotation=60)
+    end)]
+),
+
+PlotExample("Boxplot and Violin series recipes",
+    "",
+    [:(begin
+        import RDatasets
+        singers = RDatasets.dataset("lattice", "singer")
+        @df singers violin(:VoicePart, :Height, line = 0, fill = (0.2, :blue))
+        @df singers boxplot!(:VoicePart, :Height, line = (2,:black), fill = (0.3, :orange))
+    end)]
+),
+
+PlotExample("Animation with subplots",
+    "The `layout` macro can be used to create an animation with subplots.",
+    [:(begin
+        l = @layout([[a; b] c])
+        p = plot(plot([sin,cos],1,leg=false),
+        scatter([atan,cos],1,leg=false),
+        plot(log,1,xlims=(1,10π),ylims=(0,5),leg=false),layout=l)
+
+        anim = Animation()
+        for x = range(1, stop=10π, length=100)
+          plot(push!(p,x,Float64[sin(x),cos(x),atan(x),cos(x),log(x)]))
+          frame(anim)
+        end
+    end)]
+),
+
+PlotExample("Spy",
+"""
+For a matrix `mat` with unique nonzeros `spy(mat)` returns a colorless plot. If `mat` has
+various different nonzero values, a colorbar is added. The colorbar can be disabled with
+`legend = nothing`.
+""",
+    [:(begin
+    using SparseArrays
+    a = spdiagm(0 => ones(50), 1 => ones(49), -1 => ones(49), 10 => ones(40), -10 => ones(40))
+    b = spdiagm(0 => 1:50, 1 => 1:49, -1 => 1:49, 10 => 1:40, -10 => 1:40)
+    plot(spy(a), spy(b), title = ["Unique nonzeros" "Different nonzeros"])
+    end)]
+),
+
+PlotExample("Magic grid argument",
+"""
+The grid lines can be modified individually for each axis with the magic `grid` argument.
+""",
+    [:(begin
+    x = rand(10)
+    p1 = plot(x, title = "Default looks")
+    p2 = plot(x, grid = (:y, :olivedrab, :dot, 1, 0.9), title = "Modified y grid")
+    p3 = plot(deepcopy(p2), title = "Add x grid")
+    xgrid!(p3, :on, :cadetblue, 2, :dashdot, 0.4)
+    plot(p1, p2, p3, layout = (1, 3), label = "", fillrange = 0, fillalpha = 0.3)
+    end)]
+),
+
+PlotExample("Framestyle",
+"""
+The style of the frame/axes of a (sub)plot can be changed with the `framestyle`
+attribute. The default framestyle is `:axes`.
+""",
+    [:(begin
+    scatter(fill(randn(10), 6), fill(randn(10), 6),
+        framestyle = [:box :semi :origin :zerolines :grid :none],
+        title = [":box" ":semi" ":origin" ":zerolines" ":grid" ":none"],
+        color = permutedims(1:6), layout = 6, label = "", markerstrokewidth = 0,
+        ticks = -2:2)
+    end)]
+),
+
+PlotExample("Lines and markers with varying colors",
+"""
+You can use the `line_z` and `marker_z` properties to associate a color with
+each line segment or marker in the plot.
+""",
+    [:(begin
+        t = range(0, stop=1, length=100)
+        θ = 6π .* t
+        x = t .* cos.(θ)
+        y = t .* sin.(θ)
+        p1 = plot(x, y, line_z=t, linewidth=3, legend=false)
+        p2 = scatter(x, y, marker_z=(x,y)->x+y, color=:bluesreds, legend=false)
+        plot(p1, p2)
+    end)]
+),
+
+PlotExample("Portfolio Composition maps",
+"""
+see: http://stackoverflow.com/a/37732384/5075246
+""",
+    [:(begin
+    using Random
+    Random.seed!(111)
+    tickers = ["IBM", "Google", "Apple", "Intel"]
+    N = 10
+    D = length(tickers)
+    weights = rand(N,D)
+    weights ./= sum(weights, dims = 2)
+    returns = sort!((1:N) + D*randn(N))
+
+    portfoliocomposition(weights, returns, labels = permutedims(tickers))
+    end)]
+),
+
+]
+
+# Some constants for PlotDocs and PlotReferenceImages
+_animation_examples = [2, 30]
+_backend_skips = Dict(
+    :gr => [25, 30],
+    :pyplot => [25, 30],
+    :plotlyjs => [2, 21, 25, 30, 31],
+    :pgfplots => [2, 5, 6, 10, 16, 20, 22, 23, 25, 28, 30],
+)
+
+
+
+# ---------------------------------------------------------------------------------
+
+# make and display one plot
+function test_examples(pkgname::Symbol, idx::Int; debug = false, disp = true)
+  Plots._debugMode.on = debug
+  @info("Testing plot: $pkgname:$idx:$(_examples[idx].header)")
+  backend(pkgname)
+  backend()
+  map(eval, _examples[idx].exprs)
+  plt = current()
+  if disp
+    gui(plt)
+  end
+  plt
+end
+
+# generate all plots and create a dict mapping idx --> plt
+"""
+test_examples(pkgname[, idx]; debug = false, disp = true, sleep = nothing,
+                                        skip = [], only = nothing
+
+Run the `idx` test example for a given backend, or all examples if `idx`
+is not specified.
+"""
+function test_examples(pkgname::Symbol; debug = false, disp = true, sleep = nothing,
+                                        skip = [], only = nothing)
+  Plots._debugMode.on = debug
+  plts = Dict()
+  for i in 1:length(_examples)
+    only !== nothing && !(i in only) && continue
+    i in skip && continue
+    try
+      plt = test_examples(pkgname, i, debug=debug, disp=disp)
+      plts[i] = plt
+    catch ex
+      # TODO: put error info into markdown?
+      @warn("Example $pkgname:$i:$(_examples[i].header) failed with: $ex")
+    end
+    if sleep !== nothing
+        Base.sleep(sleep)
+    end
+  end
+  plts
+end

src/fileio.jl

@@ -0,0 +1,24 @@
+# ---------------------------------------------------------
+# A backup, if no PNG generation is defined, is to try to make a PDF and use FileIO to convert
+
+_fileio_load(@nospecialize(filename::AbstractString)) = FileIO.load(filename::AbstractString)
+_fileio_save(@nospecialize(filename::AbstractString), @nospecialize(x)) = FileIO.save(filename::AbstractString, x)
+
+function _show_pdfbackends(io::IO, ::MIME"image/png", plt::Plot)
+    fn = tempname()
+
+    # first save a pdf file
+    pdf(plt, fn)
+
+    # load that pdf into a FileIO Stream
+    s = _fileio_load(fn * ".pdf")
+
+    # save a png
+    pngfn = fn * ".png"
+    _fileio_save(pngfn, s)
+
+    # now write from the file
+    write(io, read(open(pngfn), String))
+end
+
+const PDFBackends = Union{PGFPlotsBackend,PlotlyJSBackend,PyPlotBackend,InspectDRBackend,GRBackend}

src/gadfly.jl

@@ -1,134 +0,0 @@
-
-# https://github.com/dcjones/Gadfly.jl
-
-immutable GadflyPackage <: PlottingPackage end
-
-
-# create a blank Gadfly.Plot object
-function plot(pkg::GadflyPackage; kw...)
-  @eval import DataFrames
-
-  plt = Gadfly.Plot()
-  plt.mapping = Dict()
-  plt.data_source = DataFrames.DataFrame()
-  plt.layers = plt.layers[1:0]
-  
-  # add the title, axis labels, and theme
-  d = Dict(kw)
-
-  plt.guides = Gadfly.GuideElement[Gadfly.Guide.xlabel(d[:xlabel]),
-                                   Gadfly.Guide.ylabel(d[:ylabel]),
-                                   Gadfly.Guide.title(d[:title])]
-
-  # add the legend?
-  if d[:legend]
-    unshift!(plt.guides, Gadfly.Guide.manual_color_key("", AbstractString[], Color[]))
-  end
-
-  plt.theme = Gadfly.Theme(background_color = (haskey(d, :background_color) ? d[:background_color] : colorant"white"))
-  
-  Plot(plt, pkg, 0)
-end
-
-function getGeomFromLineType(linetype::Symbol, nbins::Int)
-  linetype == :line && return Gadfly.Geom.line
-  linetype == :dots && return Gadfly.Geom.point
-  linetype == :bar && return Gadfly.Geom.bar
-  linetype == :step && return Gadfly.Geom.step
-  linetype == :hist && return Gadfly.Geom.histogram(bincount=nbins)
-  linetype == :none && return Gadfly.Geom.point  # change this? are we usually pairing no line with scatterplots?
-  linetype == :sticks && return Gadfly.Geom.bar
-  error("linetype $linetype not currently supported with Gadfly")
-end
-
-function getGeoms(linetype::Symbol, marker::Symbol, nbins::Int)
-  geoms = []
-
-  # handle heatmaps (hexbins) specially
-  if linetype in (:heatmap,:hexbin)
-    push!(geoms, Gadfly.Geom.hexbin(xbincount=nbins, ybincount=nbins))
-  else
-
-    # for other linetypes, get the correct Geom
-    push!(geoms, getGeomFromLineType(linetype, nbins))
-
-    # for any marker, add Geom.point
-    if marker != :none
-      push!(geoms, Gadfly.Geom.point)
-    end
-  end
-
-  geoms
-end
-
-
-# plot one data series
-function plot!(::GadflyPackage, plt::Plot; kw...)
-  d = Dict(kw)
-
-  gfargs = []
-
-  # add the Geoms
-  append!(gfargs, getGeoms(d[:linetype], d[:marker], d[:nbins]))
-
-  # set color, line width, and point size
-  theme = Gadfly.Theme(default_color = d[:color],
-                       line_width = d[:width] * Gadfly.px,
-                       default_point_size = d[:markersize] * Gadfly.px)
-  push!(gfargs, theme)
-
-  # add a regression line?
-  if d[:reg]
-    push!(gfargs, Gadfly.Geom.smooth(method=:lm))
-  end
-
-  # for histograms, set x=y
-  x = d[d[:linetype] == :hist ? :y : :x]
-
-  # add to the legend
-  if length(plt.o.guides) > 0 && isa(plt.o.guides[1], Gadfly.Guide.ManualColorKey)
-    push!(plt.o.guides[1].labels, d[:label])
-    push!(plt.o.guides[1].colors, d[:color])
-  end
-
-  if d[:axis] != :left
-    warn("Gadly only supports one y axis")
-  end
-
-  # add the layer to the Gadfly.Plot
-  prepend!(plt.o.layers, Gadfly.layer(unique(gfargs)...; x = x, y = d[:y]))
-  plt
-end
-
-function Base.display(::GadflyPackage, plt::Plot)
-  display(plt.o)
-end
-
-# -------------------------------
-
-function savepng(::GadflyPackage, plt::PlottingObject, fn::String;
-                                    w = 6 * Gadfly.inch,
-                                    h = 4 * Gadfly.inch)
-  Gadfly.draw(Gadfly.PNG(fn, w, h), plt.o)
-end
-
-
-# -------------------------------
-
-# # create the underlying object (each backend will do this differently)
-# o = buildSubplotObject(plts, pkg, layout)
-
-function buildSubplotObject!(::GadflyPackage, subplt::Subplot)
-  i = 0
-  rows = []
-  for rowcnt in subplt.layout.rowcounts
-    push!(rows, Gadfly.hstack([plt.o for plt in subplt.plts[(1:rowcnt) + i]]...))
-    i += rowcnt
-  end
-  subplt.o = Gadfly.vstack(rows...)
-end
-
-
-function Base.display(::GadflyPackage, subplt::Subplot)
-  display(subplt.o)
-end

src/ijulia.jl

@@ -0,0 +1,62 @@
+const use_local_dependencies = Ref(false)
+const use_local_plotlyjs = Ref(false)
+
+
+function _init_ijulia_plotting()
+    # IJulia is more stable with local file
+    use_local_plotlyjs[] = isfile(plotly_local_file_path)
+
+    ENV["MPLBACKEND"] = "Agg"
+end
+
+
+"""
+Add extra jupyter mimetypes to display_dict based on the plot backed.
+
+The default is nothing, except for plotly based backends, where it
+adds data for `application/vnd.plotly.v1+json` that is used in
+frontends like jupyterlab and nteract.
+"""
+_ijulia__extra_mime_info!(plt::Plot, out::Dict) = out
+
+function _ijulia__extra_mime_info!(plt::Plot{PlotlyJSBackend}, out::Dict)
+    out["application/vnd.plotly.v1+json"] = Dict(
+        :data => plotly_series(plt),
+        :layout => plotly_layout(plt)
+    )
+    out
+end
+
+function _ijulia__extra_mime_info!(plt::Plot{PlotlyBackend}, out::Dict)
+    out["application/vnd.plotly.v1+json"] = Dict(
+        :data => plotly_series(plt),
+        :layout => plotly_layout(plt)
+    )
+    out
+end
+
+
+function _ijulia_display_dict(plt::Plot)
+    output_type = Symbol(plt.attr[:html_output_format])
+    if output_type == :auto
+        output_type = get(_best_html_output_type, backend_name(plt.backend), :svg)
+    end
+    out = Dict()
+    if output_type == :txt
+        mime = "text/plain"
+        out[mime] = sprint(show, MIME(mime), plt)
+    elseif output_type == :png
+        mime = "image/png"
+        out[mime] = base64encode(show, MIME(mime), plt)
+    elseif output_type == :svg
+        mime = "image/svg+xml"
+        out[mime] = sprint(show, MIME(mime), plt)
+    elseif output_type == :html
+        mime = "text/html"
+        out[mime] = sprint(show, MIME(mime), plt)
+    else
+        error("Unsupported output type $output_type")
+    end
+    _ijulia__extra_mime_info!(plt, out)
+    out
+end

src/init.jl

@@ -0,0 +1,60 @@
+using REPL
+
+
+function _plots_defaults()
+    if isdefined(Main, :PLOTS_DEFAULTS)
+        Dict{Symbol,Any}(Main.PLOTS_DEFAULTS)
+    else
+        Dict{Symbol,Any}()
+    end
+end
+
+
+function __init__()
+    user_defaults = _plots_defaults()
+    if haskey(user_defaults, :theme)
+        theme(user_defaults[:theme])
+    end
+    for (k,v) in user_defaults
+        k == :theme || default(k, v)
+    end
+
+    insert!(Base.Multimedia.displays, findlast(x -> x isa Base.TextDisplay || x isa REPL.REPLDisplay, Base.Multimedia.displays) + 1, PlotsDisplay())
+
+    atreplinit(i -> begin
+        while PlotsDisplay() in Base.Multimedia.displays
+            popdisplay(PlotsDisplay())
+        end
+        insert!(Base.Multimedia.displays, findlast(x -> x isa REPL.REPLDisplay, Base.Multimedia.displays) + 1, PlotsDisplay())
+    end)
+
+    @require HDF5 = "f67ccb44-e63f-5c2f-98bd-6dc0ccc4ba2f" include(joinpath(@__DIR__, "backends", "hdf5.jl"))
+    @require InspectDR = "d0351b0e-4b05-5898-87b3-e2a8edfddd1d" include(joinpath(@__DIR__, "backends", "inspectdr.jl"))
+    @require PGFPlots = "3b7a836e-365b-5785-a47d-02c71176b4aa" include(joinpath(@__DIR__, "backends", "pgfplots.jl"))
+    @require PlotlyJS = "f0f68f2c-4968-5e81-91da-67840de0976a" include(joinpath(@__DIR__, "backends", "plotlyjs.jl"))
+    @require PyPlot = "d330b81b-6aea-500a-939a-2ce795aea3ee" include(joinpath(@__DIR__, "backends", "pyplot.jl"))
+    @require UnicodePlots = "b8865327-cd53-5732-bb35-84acbb429228" include(joinpath(@__DIR__, "backends", "unicodeplots.jl"))
+
+    @require IJulia = "7073ff75-c697-5162-941a-fcdaad2a7d2a" begin
+        if IJulia.inited
+            _init_ijulia_plotting()
+
+            IJulia.display_dict(plt::Plot) = _ijulia_display_dict(plt)
+        end
+    end
+
+    if haskey(ENV, "PLOTS_HOST_DEPENDENCY_LOCAL")
+        use_local_plotlyjs[] = ENV["PLOTS_HOST_DEPENDENCY_LOCAL"] == "true"
+        use_local_dependencies[] = isfile(plotly_local_file_path) && use_local_plotlyjs[]
+        if use_local_plotlyjs[] && !isfile(plotly_local_file_path)
+            @warn("PLOTS_HOST_DEPENDENCY_LOCAL is set to true, but no local plotly file found. run Pkg.build(\"Plots\") and make sure PLOTS_HOST_DEPENDENCY_LOCAL is set to true")
+        end
+    else
+        use_local_dependencies[] = use_local_plotlyjs[]
+    end
+
+
+    @require FileIO = "5789e2e9-d7fb-5bc7-8068-2c6fae9b9549" begin
+        _show(io::IO, mime::MIME"image/png", plt::Plot{<:PDFBackends}) = _show_pdfbackends(io, mime, plt)
+    end
+end

src/layouts.jl

@@ -0,0 +1,800 @@
+
+# NOTE: (0,0) is the top-left !!!
+
+to_pixels(m::AbsoluteLength) = m.value / 0.254
+
+const _cbar_width = 5mm
+
+#Base.broadcast(::typeof(Base.:.*), m::Measure, n::Number) = m * n
+#Base.broadcast(::typeof(Base.:.*), m::Number, n::Measure) = m * n
+Base.:-(m::Measure, a::AbstractArray) = map(ai -> m - ai, a)
+Base.:-(a::AbstractArray, m::Measure) = map(ai -> ai - m, a)
+Base.zero(::Type{typeof(mm)}) = 0mm
+Base.one(::Type{typeof(mm)}) = 1mm
+Base.typemin(::typeof(mm)) = -Inf*mm
+Base.typemax(::typeof(mm)) = Inf*mm
+Base.convert(::Type{F}, l::AbsoluteLength) where {F<:AbstractFloat} = convert(F, l.value)
+
+# TODO: these are unintuitive and may cause tricky bugs
+# Base.:+(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value * (1 + m2.value))
+# Base.:+(m1::Length{:pct}, m2::AbsoluteLength) = AbsoluteLength(m2.value * (1 + m1.value))
+# Base.:-(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value * (1 - m2.value))
+# Base.:-(m1::Length{:pct}, m2::AbsoluteLength) = AbsoluteLength(m2.value * (m1.value - 1))
+
+Base.:*(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value * m2.value)
+Base.:*(m1::Length{:pct}, m2::AbsoluteLength) = AbsoluteLength(m2.value * m1.value)
+Base.:/(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value / m2.value)
+Base.:/(m1::Length{:pct}, m2::AbsoluteLength) = AbsoluteLength(m2.value / m1.value)
+
+
+Base.zero(::Type{typeof(pct)}) = 0pct
+Base.one(::Type{typeof(pct)}) = 1pct
+Base.typemin(::typeof(pct)) = 0pct
+Base.typemax(::typeof(pct)) = 1pct
+
+const defaultbox = BoundingBox(0mm, 0mm, 0mm, 0mm)
+
+left(bbox::BoundingBox) = bbox.x0[1]
+top(bbox::BoundingBox) = bbox.x0[2]
+right(bbox::BoundingBox) = left(bbox) + width(bbox)
+bottom(bbox::BoundingBox) = top(bbox) + height(bbox)
+Base.size(bbox::BoundingBox) = (width(bbox), height(bbox))
+
+# Base.:*{T,N}(m1::Length{T,N}, m2::Length{T,N}) = Length{T,N}(m1.value * m2.value)
+ispositive(m::Measure) = m.value > 0
+
+# union together bounding boxes
+function Base.:+(bb1::BoundingBox, bb2::BoundingBox)
+    # empty boxes don't change the union
+    ispositive(width(bb1))  || return bb2
+    ispositive(height(bb1)) || return bb2
+    ispositive(width(bb2))  || return bb1
+    ispositive(height(bb2)) || return bb1
+
+    l = min(left(bb1), left(bb2))
+    t = min(top(bb1), top(bb2))
+    r = max(right(bb1), right(bb2))
+    b = max(bottom(bb1), bottom(bb2))
+    BoundingBox(l, t, r-l, b-t)
+end
+
+# this creates a bounding box in the parent's scope, where the child bounding box
+# is relative to the parent
+function crop(parent::BoundingBox, child::BoundingBox)
+    l = left(parent) + left(child)
+    t = top(parent) + top(child)
+    w = width(child)
+    h = height(child)
+    BoundingBox(l, t, w, h)
+end
+
+# convert x,y coordinates from absolute coords to percentages...
+# returns x_pct, y_pct
+function xy_mm_to_pcts(x::AbsoluteLength, y::AbsoluteLength, figw, figh, flipy = true)
+    xmm, ymm = x.value, y.value
+    if flipy
+        ymm = figh.value - ymm  # flip y when origin in bottom-left
+    end
+    xmm / figw.value, ymm / figh.value
+end
+
+# convert a bounding box from absolute coords to percentages...
+# returns an array of percentages of figure size: [left, bottom, width, height]
+function bbox_to_pcts(bb::BoundingBox, figw, figh, flipy = true)
+    mms = Float64[f(bb).value for f in (left,bottom,width,height)]
+    if flipy
+        mms[2] = figh.value - mms[2]  # flip y when origin in bottom-left
+    end
+    mms ./ Float64[figw.value, figh.value, figw.value, figh.value]
+end
+
+function Base.show(io::IO, bbox::BoundingBox)
+    print(io, "BBox{l,t,r,b,w,h = $(left(bbox)),$(top(bbox)), $(right(bbox)),$(bottom(bbox)), $(width(bbox)),$(height(bbox))}")
+end
+
+# -----------------------------------------------------------
+
+# points combined by x/y, pct, and length
+mutable struct MixedMeasures
+    xy::Float64
+    pct::Float64
+    len::AbsoluteLength
+end
+
+function resolve_mixed(mix::MixedMeasures, sp::Subplot, letter::Symbol)
+    xy = mix.xy
+    pct = mix.pct
+    if mix.len != 0mm
+        f = (letter == :x ? width : height)
+        totlen = f(plotarea(sp))
+        @show totlen
+        pct += mix.len / totlen
+    end
+    if pct != 0
+        amin, amax = axis_limits(sp, letter)
+        xy += pct * (amax-amin)
+    end
+    xy
+end
+
+
+# -----------------------------------------------------------
+# AbstractLayout
+
+Base.show(io::IO, layout::AbstractLayout) = print(io, "$(typeof(layout))$(size(layout))")
+
+make_measure_hor(n::Number) = n * w
+make_measure_hor(m::Measure) = m
+
+make_measure_vert(n::Number) = n * h
+make_measure_vert(m::Measure) = m
+
+"""
+    bbox(x, y, w, h [,originargs...])
+    bbox(layout)
+
+Create a bounding box for plotting
+"""
+function bbox(x, y, w, h, oarg1::Symbol, originargs::Symbol...)
+    oargs = vcat(oarg1, originargs...)
+    orighor = :left
+    origver = :top
+    for oarg in oargs
+        if oarg == :center
+            orighor = origver = oarg
+        elseif oarg in (:left, :right, :hcenter)
+            orighor = oarg
+        elseif oarg in (:top, :bottom, :vcenter)
+            origver = oarg
+        else
+            @warn("Unused origin arg in bbox construction: $oarg")
+        end
+    end
+    bbox(x, y, w, h; h_anchor = orighor, v_anchor = origver)
+end
+
+# create a new bbox
+function bbox(x, y, width, height; h_anchor = :left, v_anchor = :top)
+    x = make_measure_hor(x)
+    y = make_measure_vert(y)
+    width = make_measure_hor(width)
+    height = make_measure_vert(height)
+    left = if h_anchor == :left
+        x
+    elseif h_anchor in (:center, :hcenter)
+        0.5w - 0.5width + x
+    else
+        1w - x - width
+    end
+    top = if v_anchor == :top
+        y
+    elseif v_anchor in (:center, :vcenter)
+        0.5h - 0.5height + y
+    else
+        1h - y - height
+    end
+    BoundingBox(left, top, width, height)
+end
+
+# this is the available area for drawing everything in this layout... as percentages of total canvas
+bbox(layout::AbstractLayout) = layout.bbox
+bbox!(layout::AbstractLayout, bb::BoundingBox) = (layout.bbox = bb)
+
+# layouts are recursive, tree-like structures, and most will have a parent field
+Base.parent(layout::AbstractLayout) = layout.parent
+parent_bbox(layout::AbstractLayout) = bbox(parent(layout))
+
+# padding_w(layout::AbstractLayout) = left_padding(layout) + right_padding(layout)
+# padding_h(layout::AbstractLayout) = bottom_padding(layout) + top_padding(layout)
+# padding(layout::AbstractLayout) = (padding_w(layout), padding_h(layout))
+
+@noinline update_position!(layout::AbstractLayout) = nothing
+@noinline update_child_bboxes!(layout::AbstractLayout, minimum_perimeter = [0mm,0mm,0mm,0mm]) = nothing
+
+@noinline left(layout::AbstractLayout) = left(bbox(layout))
+@noinline top(layout::AbstractLayout) = top(bbox(layout))
+@noinline right(layout::AbstractLayout) = right(bbox(layout))
+@noinline bottom(layout::AbstractLayout) = bottom(bbox(layout))
+@noinline width(layout::AbstractLayout) = width(bbox(layout))
+@noinline height(layout::AbstractLayout) = height(bbox(layout))
+
+# pass these through to the bbox methods if there's no plotarea
+@noinline plotarea(layout::AbstractLayout) = bbox(layout)
+@noinline plotarea!(layout::AbstractLayout, bb::BoundingBox) = bbox!(layout, bb)
+
+@noinline attr(layout::AbstractLayout, k::Symbol) = layout.attr[k]
+@noinline attr(layout::AbstractLayout, k::Symbol, v) = get(layout.attr, k, v)
+@noinline attr!(layout::AbstractLayout, v, k::Symbol) = (layout.attr[k] = v)
+@noinline hasattr(layout::AbstractLayout, k::Symbol) = haskey(layout.attr, k)
+
+@noinline leftpad(layout::AbstractLayout)   = 0mm
+@noinline toppad(layout::AbstractLayout)    = 0mm
+@noinline rightpad(layout::AbstractLayout)  = 0mm
+@noinline bottompad(layout::AbstractLayout) = 0mm
+
+# -----------------------------------------------------------
+# RootLayout
+
+# this is the parent of the top-level layout
+struct RootLayout <: AbstractLayout end
+
+Base.parent(::RootLayout) = nothing
+parent_bbox(::RootLayout) = defaultbox
+bbox(::RootLayout) = defaultbox
+
+# -----------------------------------------------------------
+# EmptyLayout
+
+# contains blank space
+mutable struct EmptyLayout <: AbstractLayout
+    parent
+    bbox#::BoundingBox
+    attr::KW  # store label, width, and height for initialization
+    # label  # this is the label that the subplot will take (since we create a layout before initialization)
+end
+EmptyLayout(parent = RootLayout(); kw...) = EmptyLayout(parent, defaultbox, KW(kw))
+
+Base.size(layout::EmptyLayout) = (0,0)
+Base.length(layout::EmptyLayout) = 0
+Base.getindex(layout::EmptyLayout, r::Int, c::Int) = nothing
+
+_update_min_padding!(layout::EmptyLayout) = nothing
+
+# -----------------------------------------------------------
+# GridLayout
+
+# nested, gridded layout with optional size percentages
+mutable struct GridLayout <: AbstractLayout
+    parent
+    minpad::Tuple{AbsoluteLength,AbsoluteLength,AbsoluteLength,AbsoluteLength} # leftpad, toppad, rightpad, bottompad
+    bbox#::BoundingBox
+    grid::Matrix{Any} # Nested layouts. Each position is a AbstractLayout, which allows for arbitrary recursion
+    widths::Vector{Any}
+    heights::Vector{Any}
+    attr::KW
+end
+
+"""
+    grid(args...; kw...)
+
+Create a grid layout for subplots. `args` specify the dimensions, e.g.
+`grid(3,2, widths = (0.6,04))` creates a grid with three rows and two
+columns of different width.
+"""
+grid(args...; kw...) = GridLayout(args...; kw...)
+
+function GridLayout(dims...;
+                    parent = RootLayout(),
+                    widths = zeros(dims[2]),
+                    heights = zeros(dims[1]),
+                    kw...)
+    grid = Matrix{Any}(undef, dims...)
+    layout = GridLayout(
+        parent,
+        (20mm, 5mm, 2mm, 10mm),
+        defaultbox,
+        grid,
+        Any[w*pct for w in widths],
+        Any[h*pct for h in heights],
+        # convert(Vector{Float64}, widths),
+        # convert(Vector{Float64}, heights),
+        KW(kw))
+    for i in eachindex(grid)
+        grid[i] = EmptyLayout(layout)
+    end
+    layout
+end
+
+Base.size(layout::GridLayout) = size(layout.grid)
+Base.length(layout::GridLayout) = length(layout.grid)
+Base.getindex(layout::GridLayout, r::Int, c::Int) = layout.grid[r,c]
+function Base.setindex!(layout::GridLayout, v, r::Int, c::Int)
+    layout.grid[r,c] = v
+end
+
+leftpad(layout::GridLayout)   = layout.minpad[1]
+toppad(layout::GridLayout)    = layout.minpad[2]
+rightpad(layout::GridLayout)  = layout.minpad[3]
+bottompad(layout::GridLayout) = layout.minpad[4]
+
+
+# here's how this works... first we recursively "update the minimum padding" (which
+# means to calculate the minimum size needed from the edge of the subplot to plot area)
+# for the whole layout tree.  then we can compute the "padding borders" of this
+# layout as the biggest padding of the children on the perimeter.  then we need to
+# recursively pass those borders back down the tree, one side at a time, but ONLY
+# to those perimeter children.
+
+# leftpad, toppad, rightpad, bottompad
+function _update_min_padding!(layout::GridLayout)
+    map(_update_min_padding!, layout.grid)
+    layout.minpad = (
+        maximum(map(leftpad,   layout.grid[:,1])),
+        maximum(map(toppad,    layout.grid[1,:])),
+        maximum(map(rightpad,  layout.grid[:,end])),
+        maximum(map(bottompad, layout.grid[end,:]))
+    )
+end
+
+
+function update_position!(layout::GridLayout)
+    map(update_position!, layout.grid)
+end
+
+# some lengths are fixed... we have to split up the free space among the list v
+function recompute_lengths(v)
+    # dump(v)
+    tot = 0pct
+    cnt = 0
+    for vi in v
+        if vi == 0pct
+            cnt += 1
+        else
+            tot += vi
+        end
+    end
+    leftover = 1.0pct - tot
+    if cnt > 1 && leftover.value <= 0
+        error("Not enough length left over in layout!  v = $v, cnt = $cnt, leftover = $leftover")
+    end
+
+    # now fill in the blanks
+    Measure[(vi == 0pct ? leftover / cnt : vi) for vi in v]
+end
+
+# recursively compute the bounding boxes for the layout and plotarea (relative to canvas!)
+function update_child_bboxes!(layout::GridLayout, minimum_perimeter = [0mm,0mm,0mm,0mm])
+    nr, nc = size(layout)
+
+    # # create a matrix for each minimum padding direction
+    # _update_min_padding!(layout)
+
+    minpad_left::Matrix{AbsoluteLength}   = map(leftpad,   layout.grid)
+    minpad_top::Matrix{AbsoluteLength}    = map(toppad,    layout.grid)
+    minpad_right::Matrix{AbsoluteLength}  = map(rightpad,  layout.grid)
+    minpad_bottom::Matrix{AbsoluteLength} = map(bottompad, layout.grid)
+
+    # get the max horizontal (left and right) padding over columns,
+    # and max vertical (bottom and top) padding over rows
+    # TODO: add extra padding here
+    pad_left::Matrix{AbsoluteLength}   = maximum(minpad_left,   dims = 1)
+    pad_top::Matrix{AbsoluteLength}    = maximum(minpad_top,    dims = 2)
+    pad_right::Matrix{AbsoluteLength}  = maximum(minpad_right,  dims = 1)
+    pad_bottom::Matrix{AbsoluteLength} = maximum(minpad_bottom, dims = 2)
+
+    # make sure the perimeter match the parent
+    pad_left[1]     = max(pad_left[1], minimum_perimeter[1])
+    pad_top[1]      = max(pad_top[1], minimum_perimeter[2])
+    pad_right[end]  = max(pad_right[end], minimum_perimeter[3])
+    pad_bottom[end] = max(pad_bottom[end], minimum_perimeter[4])
+
+    # scale this up to the total padding in each direction
+    total_pad_horizontal = sum(pad_left + pad_right)
+    total_pad_vertical   = sum(pad_top + pad_bottom)
+
+    # now we can compute the total plot area in each direction
+    total_plotarea_horizontal = width(layout)  - total_pad_horizontal
+    total_plotarea_vertical   = height(layout) - total_pad_vertical
+
+    # recompute widths/heights
+    layout.widths = recompute_lengths(layout.widths)
+    layout.heights = recompute_lengths(layout.heights)
+
+    # normalize widths/heights so they sum to 1
+    # denom_w = sum(layout.widths)
+    # denom_h = sum(layout.heights)
+
+    # we have all the data we need... lets compute the plot areas and set the bounding boxes
+    for r=1:nr, c=1:nc
+        child = layout[r,c]
+
+        # get the top-left corner of this child... the first one is top-left of the parent (i.e. layout)
+        child_left::AbsoluteLength  = (c == 1 ? left(layout.bbox) : right(layout[r, c-1].bbox))
+        child_top::AbsoluteLength   = (r == 1 ? top(layout.bbox) : bottom(layout[r-1, c].bbox))
+
+        # compute plot area
+        plotarea_left::AbsoluteLength    = child_left + pad_left[c]
+        plotarea_top::AbsoluteLength     = child_top + pad_top[r]
+        plotarea_width::AbsoluteLength   = total_plotarea_horizontal * layout.widths[c]
+        plotarea_height::AbsoluteLength  = total_plotarea_vertical * layout.heights[r]
+        plotarea!(child, BoundingBox(plotarea_left, plotarea_top, plotarea_width, plotarea_height))
+
+        # compute child bbox
+        child_width  = pad_left[c] + plotarea_width + pad_right[c]
+        child_height = pad_top[r] + plotarea_height + pad_bottom[r]
+        bbox!(child, BoundingBox(child_left, child_top, child_width, child_height))
+
+        # this is the minimum perimeter as decided by this child's parent, so that
+        # all children on this border have the same value
+        min_child_perimeter = [
+            c == 1  ? layout.minpad[1] : 0mm,
+            r == 1  ? layout.minpad[2] : 0mm,
+            c == nc ? layout.minpad[3] : 0mm,
+            r == nr ? layout.minpad[4] : 0mm
+        ]
+
+        # recursively update the child's children
+        update_child_bboxes!(child, min_child_perimeter)
+    end
+end
+
+# for each inset (floating) subplot, resolve the relative position
+# to absolute canvas coordinates, relative to the parent's plotarea
+function update_inset_bboxes!(plt::Plot)
+    for sp in plt.inset_subplots
+        p_area = Measures.resolve(plotarea(sp.parent), sp[:relative_bbox])
+        plotarea!(sp, p_area)
+
+        bbox!(sp, bbox(
+            left(p_area) - leftpad(sp),
+            top(p_area) - toppad(sp),
+            width(p_area) + leftpad(sp) + rightpad(sp),
+            height(p_area) + toppad(sp) + bottompad(sp)
+        ))
+    end
+end
+
+# ----------------------------------------------------------------------
+
+calc_num_subplots(layout::AbstractLayout) = 1
+function calc_num_subplots(layout::GridLayout)
+    tot = 0
+    for l in layout.grid
+        tot += calc_num_subplots(l)
+    end
+    tot
+end
+
+function compute_gridsize(numplts::Int, nr::Int, nc::Int)
+    # figure out how many rows/columns we need
+    if nr < 1
+        if nc < 1
+            nr = round(Int, sqrt(numplts))
+            nc = ceil(Int, numplts / nr)
+        else
+            nr = ceil(Int, numplts / nc)
+        end
+    else
+        nc = ceil(Int, numplts / nr)
+    end
+    nr, nc
+end
+
+# ----------------------------------------------------------------------
+# constructors
+
+# pass the layout arg through
+function layout_args(plotattributes::KW)
+    layout_args(get(plotattributes, :layout, default(:layout)))
+end
+
+function layout_args(plotattributes::KW, n_override::Integer)
+    layout, n = layout_args(get(plotattributes, :layout, n_override))
+    if n != n_override
+        error("When doing layout, n ($n) != n_override ($(n_override)).  You're probably trying to force existing plots into a layout that doesn't fit them.")
+    end
+    layout, n
+end
+
+function layout_args(n::Integer)
+    nr, nc = compute_gridsize(n, -1, -1)
+    GridLayout(nr, nc), n
+end
+
+function layout_args(sztup::NTuple{2,I}) where I<:Integer
+    nr, nc = sztup
+    GridLayout(nr, nc), nr*nc
+end
+
+function layout_args(sztup::NTuple{3,I}) where I<:Integer
+    n, nr, nc = sztup
+    nr, nc = compute_gridsize(n, nr, nc)
+    GridLayout(nr, nc), n
+end
+
+# compute number of subplots
+function layout_args(layout::GridLayout)
+    # recursively get the size of the grid
+    n = calc_num_subplots(layout)
+    layout, n
+end
+
+layout_args(huh) = error("unhandled layout type $(typeof(huh)): $huh")
+
+
+# ----------------------------------------------------------------------
+
+
+function build_layout(args...)
+    layout, n = layout_args(args...)
+    build_layout(layout, n)
+end
+
+# # just a single subplot
+# function build_layout(sp::Subplot, n::Integer)
+#     sp, Subplot[sp], KW(gensym() => sp)
+# end
+
+# n is the number of subplots... build a grid and initialize the inner subplots recursively
+function build_layout(layout::GridLayout, n::Integer)
+    nr, nc = size(layout)
+    subplots = Any[]
+    spmap = KW()
+    i = 0
+    for r=1:nr, c=1:nc
+        l = layout[r,c]
+        if isa(l, EmptyLayout) && !get(l.attr, :blank, false)
+            sp = Subplot(backend(), parent=layout)
+            layout[r,c] = sp
+            push!(subplots, sp)
+            spmap[attr(l,:label,gensym())] = sp
+            if get(l.attr, :width, :auto) != :auto
+                layout.widths[c] = attr(l,:width)
+            end
+            if get(l.attr, :height, :auto) != :auto
+                layout.heights[r] = attr(l,:height)
+            end
+            i += 1
+        elseif isa(l, GridLayout)
+            # sub-grid
+            if get(l.attr, :width, :auto) != :auto
+                layout.widths[c] = attr(l,:width)
+            end
+            if get(l.attr, :height, :auto) != :auto
+                layout.heights[r] = attr(l,:height)
+            end
+            l, sps, m = build_layout(l, n-i)
+            append!(subplots, sps)
+            merge!(spmap, m)
+            i += length(sps)
+        elseif isa(l, Subplot)
+            error("Subplot exists. Cannot re-use existing layout.  Please make a new one.")
+        end
+        i >= n && break  # only add n subplots
+    end
+
+    layout, subplots, spmap
+end
+
+# build a layout from a list of existing Plot objects
+# TODO... much of the logic overlaps with the method above... can we merge?
+function build_layout(layout::GridLayout, numsp::Integer, plts::AVec{Plot})
+    nr, nc = size(layout)
+    subplots = Any[]
+    spmap = KW()
+    i = 0
+    for r=1:nr, c=1:nc
+        l = layout[r,c]
+        if isa(l, EmptyLayout) && !get(l.attr, :blank, false)
+            plt = popfirst!(plts)  # grab the first plot out of the list
+            layout[r,c] = plt.layout
+            append!(subplots, plt.subplots)
+            merge!(spmap, plt.spmap)
+            if get(l.attr, :width, :auto) != :auto
+                layout.widths[c] = attr(l,:width)
+            end
+            if get(l.attr, :height, :auto) != :auto
+                layout.heights[r] = attr(l,:height)
+            end
+            i += length(plt.subplots)
+        elseif isa(l, GridLayout)
+            # sub-grid
+            if get(l.attr, :width, :auto) != :auto
+                layout.widths[c] = attr(l,:width)
+            end
+            if get(l.attr, :height, :auto) != :auto
+                layout.heights[r] = attr(l,:height)
+            end
+            l, sps, m = build_layout(l, numsp-i, plts)
+            append!(subplots, sps)
+            merge!(spmap, m)
+            i += length(sps)
+        end
+        i >= numsp && break  # only add n subplots
+    end
+    layout, subplots, spmap
+end
+
+
+# ----------------------------------------------------------------------
+# @layout macro
+
+function add_layout_pct!(kw::KW, v::Expr, idx::Integer, nidx::Integer)
+    # dump(v)
+    # something like {0.2w}?
+    if v.head == :call && v.args[1] == :*
+        num = v.args[2]
+        if length(v.args) == 3 && isa(num, Number)
+            units = v.args[3]
+            if units == :h
+                return kw[:h] = num*pct
+            elseif units == :w
+                return kw[:w] = num*pct
+            elseif units in (:pct, :px, :mm, :cm, :inch)
+                idx == 1 && (kw[:w] = v)
+                (idx == 2 || nidx == 1) && (kw[:h] = v)
+                # return kw[idx == 1 ? :w : :h] = v
+            end
+        end
+    end
+    error("Couldn't match layout curly (idx=$idx): $v")
+end
+
+function add_layout_pct!(kw::KW, v::Number, idx::Integer)
+    # kw[idx == 1 ? :w : :h] = v*pct
+    idx == 1 && (kw[:w] = v*pct)
+    (idx == 2 || nidx == 1) && (kw[:h] = v*pct)
+end
+
+isrow(v) = isa(v, Expr) && v.head in (:hcat,:row)
+iscol(v) = isa(v, Expr) && v.head == :vcat
+rowsize(v) = isrow(v) ? length(v.args) : 1
+
+
+function create_grid(expr::Expr)
+    if iscol(expr)
+        create_grid_vcat(expr)
+    elseif isrow(expr)
+        :(let cell = GridLayout(1, $(length(expr.args)))
+            $([:(cell[1,$i] = $(create_grid(v))) for (i,v) in enumerate(expr.args)]...)
+            cell
+        end)
+
+    elseif expr.head == :curly
+        create_grid_curly(expr)
+    else
+        # if it's something else, just return that (might be an existing layout?)
+        esc(expr)
+    end
+end
+
+function create_grid_vcat(expr::Expr)
+    rowsizes = map(rowsize, expr.args)
+    rmin, rmax = extrema(rowsizes)
+    if rmin > 0 && rmin == rmax
+        # we have a grid... build the whole thing
+        # note: rmin is the number of columns
+        nr = length(expr.args)
+        nc = rmin
+        body = Expr(:block)
+        for r=1:nr
+            arg = expr.args[r]
+            if isrow(arg)
+                for (c,item) in enumerate(arg.args)
+                    push!(body.args, :(cell[$r,$c] = $(create_grid(item))))
+                end
+            else
+                push!(body.args, :(cell[$r,1] = $(create_grid(arg))))
+            end
+        end
+        :(let cell = GridLayout($nr, $nc)
+            $body
+            cell
+        end)
+    else
+        # otherwise just build one row at a time
+        :(let cell = GridLayout($(length(expr.args)), 1)
+            $([:(cell[$i,1] = $(create_grid(v))) for (i,v) in enumerate(expr.args)]...)
+            cell
+        end)
+    end
+end
+
+function create_grid_curly(expr::Expr)
+    kw = KW()
+    for (i,arg) in enumerate(expr.args[2:end])
+        add_layout_pct!(kw, arg, i, length(expr.args)-1)
+    end
+    s = expr.args[1]
+    if isa(s, Expr) && s.head == :call && s.args[1] == :grid
+        create_grid(:(grid($(s.args[2:end]...), width = $(get(kw, :w, QuoteNode(:auto))), height = $(get(kw, :h, QuoteNode(:auto))))))
+    elseif isa(s, Symbol)
+        :(EmptyLayout(label = $(QuoteNode(s)), width = $(get(kw, :w, QuoteNode(:auto))), height = $(get(kw, :h, QuoteNode(:auto)))))
+    else
+        error("Unknown use of curly brackets: $expr")
+    end
+end
+
+function create_grid(s::Symbol)
+    :(EmptyLayout(label = $(QuoteNode(s)), blank = $(s == :_)))
+end
+
+macro layout(mat::Expr)
+    create_grid(mat)
+end
+
+
+# -------------------------------------------------------------------------
+
+# make all reference the same axis extrema/values.
+# merge subplot lists.
+function link_axes!(axes::Axis...)
+    a1 = axes[1]
+    for i=2:length(axes)
+        a2 = axes[i]
+        expand_extrema!(a1, ignorenan_extrema(a2))
+        for k in (:extrema, :discrete_values, :continuous_values, :discrete_map)
+            a2[k] = a1[k]
+        end
+
+        # make a2's subplot list refer to a1's and add any missing values
+        sps2 = a2.sps
+        for sp in sps2
+            sp in a1.sps || push!(a1.sps, sp)
+        end
+        a2.sps = a1.sps
+    end
+end
+
+# figure out which subplots to link
+function link_subplots(a::AbstractArray{AbstractLayout}, axissym::Symbol)
+    subplots = []
+    for l in a
+        if isa(l, Subplot)
+            push!(subplots, l)
+        elseif isa(l, GridLayout) && size(l) == (1,1)
+            push!(subplots, l[1,1])
+        end
+    end
+    subplots
+end
+
+# for some vector or matrix of layouts, filter only the Subplots and link those axes
+function link_axes!(a::AbstractArray{AbstractLayout}, axissym::Symbol)
+    subplots = link_subplots(a, axissym)
+    axes = [sp.attr[axissym] for sp in subplots]
+    if length(axes) > 0
+        link_axes!(axes...)
+    end
+end
+
+# don't do anything for most layout types
+function link_axes!(l::AbstractLayout, link::Symbol)
+end
+
+# process a GridLayout, recursively linking axes according to the link symbol
+function link_axes!(layout::GridLayout, link::Symbol)
+    nr, nc = size(layout)
+    if link in (:x, :both)
+        for c=1:nc
+            link_axes!(layout.grid[:,c], :xaxis)
+        end
+    end
+    if link in (:y, :both)
+        for r=1:nr
+            link_axes!(layout.grid[r,:], :yaxis)
+        end
+    end
+    if link == :square
+        sps = filter(l -> isa(l, Subplot), layout.grid)
+        if !isempty(sps)
+            base_axis = sps[1][:xaxis]
+            for sp in sps
+                link_axes!(base_axis, sp[:xaxis])
+                link_axes!(base_axis, sp[:yaxis])
+            end
+        end
+    end
+    if link == :all
+        link_axes!(layout.grid, :xaxis)
+        link_axes!(layout.grid, :yaxis)
+    end
+    for l in layout.grid
+        link_axes!(l, link)
+    end
+end
+
+# -------------------------------------------------------------------------
+
+"Adds a new, empty subplot overlayed on top of `sp`, with a mirrored y-axis and linked x-axis."
+function twinx(sp::Subplot)
+    sp[:right_margin] = max(sp[:right_margin], 30px)
+    plot!(sp.plt, inset = (sp[:subplot_index], bbox(0,0,1,1)))
+    twinsp = sp.plt.subplots[end]
+    twinsp[:yaxis][:mirror] = true
+    twinsp[:background_color_inside] = RGBA{Float64}(0,0,0,0)
+    link_axes!(sp[:xaxis], twinsp[:xaxis])
+    twinsp
+end
+
+twinx(plt::Plot = current()) = twinx(plt[1])

src/output.jl

@@ -0,0 +1,261 @@
+
+
+defaultOutputFormat(plt::Plot) = "png"
+
+function png(plt::Plot, fn::AbstractString)
+  fn = addExtension(fn, "png")
+  io = open(fn, "w")
+  show(io, MIME("image/png"), plt)
+  close(io)
+end
+png(fn::AbstractString) = png(current(), fn)
+
+function svg(plt::Plot, fn::AbstractString)
+  fn = addExtension(fn, "svg")
+  io = open(fn, "w")
+  show(io, MIME("image/svg+xml"), plt)
+  close(io)
+end
+svg(fn::AbstractString) = svg(current(), fn)
+
+
+function pdf(plt::Plot, fn::AbstractString)
+  fn = addExtension(fn, "pdf")
+  io = open(fn, "w")
+  show(io, MIME("application/pdf"), plt)
+  close(io)
+end
+pdf(fn::AbstractString) = pdf(current(), fn)
+
+
+function ps(plt::Plot, fn::AbstractString)
+  fn = addExtension(fn, "ps")
+  io = open(fn, "w")
+  show(io, MIME("application/postscript"), plt)
+  close(io)
+end
+ps(fn::AbstractString) = ps(current(), fn)
+
+function eps(plt::Plot, fn::AbstractString)
+  fn = addExtension(fn, "eps")
+  io = open(fn, "w")
+  show(io, MIME("image/eps"), plt)
+  close(io)
+end
+eps(fn::AbstractString) = eps(current(), fn)
+
+function tex(plt::Plot, fn::AbstractString)
+  fn = addExtension(fn, "tex")
+  io = open(fn, "w")
+  show(io, MIME("application/x-tex"), plt)
+  close(io)
+end
+tex(fn::AbstractString) = tex(current(), fn)
+
+function html(plt::Plot, fn::AbstractString)
+    fn = addExtension(fn, "html")
+    io = open(fn, "w")
+    show(io, MIME("text/html"), plt)
+    close(io)
+end
+html(fn::AbstractString) = html(current(), fn)
+
+
+# ----------------------------------------------------------------
+
+
+const _savemap = Dict(
+    "png" => png,
+    "svg" => svg,
+    "pdf" => pdf,
+    "ps"  => ps,
+    "eps" => eps,
+    "tex" => tex,
+    "html" => html,
+  )
+
+function getExtension(fn::AbstractString)
+  pieces = split(fn, ".")
+  length(pieces) > 1 || error("Can't extract file extension: ", fn)
+  ext = pieces[end]
+  haskey(_savemap, ext) || error("Invalid file extension: ", fn)
+  ext
+end
+
+function addExtension(fn::AbstractString, ext::AbstractString)
+  try
+    oldext = getExtension(fn)
+    if oldext == ext
+      return fn
+    else
+      return "$fn.$ext"
+    end
+  catch
+    return "$fn.$ext"
+  end
+end
+
+"""
+    savefig([plot,] filename)
+
+Save a Plot (the current plot if `plot` is not passed) to file. The file
+type is inferred from the file extension. All backends support png and pdf
+file types, some also support svg, ps, eps, html and tex.
+"""
+function savefig(plt::Plot, fn::AbstractString)
+  fn = abspath(expanduser(fn))
+  # get the extension
+  local ext
+  try
+    ext = getExtension(fn)
+  catch
+    # if we couldn't extract the extension, add the default
+    ext = defaultOutputFormat(plt)
+    fn = addExtension(fn, ext)
+  end
+
+  # save it
+  func = get(_savemap, ext) do
+    error("Unsupported extension $ext with filename ", fn)
+  end
+  func(plt, fn)
+end
+savefig(fn::AbstractString) = savefig(current(), fn)
+
+
+# ---------------------------------------------------------
+"""
+    gui([plot])
+
+Display a plot using the backends' gui window
+"""
+@noinline gui(plt::Plot = current()) = display(PlotsDisplay(), plt)
+
+# IJulia only... inline display
+@noinline function inline(plt::Plot = current())
+    isijulia() || error("inline() is IJulia-only")
+    Main.IJulia.clear_output(true)
+    display(Main.IJulia.InlineDisplay(), plt)
+end
+
+@noinline function Base.display(::PlotsDisplay, plt::Plot)
+    prepare_output(plt)
+    _display(plt)
+end
+
+@noinline _do_plot_show(plt, showval::Bool) = showval && gui(plt)
+@noinline function _do_plot_show(plt, showval::Symbol)
+    showval == :gui && gui(plt)
+    showval in (:inline,:ijulia) && inline(plt)
+end
+
+# ---------------------------------------------------------
+
+const _best_html_output_type = Dict{Symbol,Symbol}(
+    :pyplot => :png,
+    :unicodeplots => :txt,
+    :plotlyjs => :html,
+    :plotly => :html
+)
+
+# a backup for html... passes to svg or png depending on the html_output_format arg
+@noinline function _show(io::IO, ::MIME"text/html", plt::Plot)
+    output_type = Symbol(plt.attr[:html_output_format])
+    if output_type == :auto
+        output_type = get(_best_html_output_type, backend_name(plt.backend), :svg)
+    end
+    if output_type == :png
+        # @info("writing png to html output")
+        print(io, "<img src=\"data:image/png;base64,", base64encode(show, MIME("image/png"), plt), "\" />")
+    elseif output_type == :svg
+        # @info("writing svg to html output")
+        show(io, MIME("image/svg+xml"), plt)
+    elseif output_type == :txt
+        show(io, MIME("text/plain"), plt)
+    else
+        error("only png or svg allowed. got: $(repr(output_type))")
+    end
+end
+
+# delegate showable to _show instead
+@noinline function Base.showable(m::M, plt::P) where {M<:MIME, P<:Plot}
+    return hasmethod(_show, Tuple{IO, M, P})
+end
+
+@noinline function _display(plt::Plot)
+    @warn("_display is not defined for this backend.")
+end
+
+# for writing to io streams... first prepare, then callback
+for mime in ("text/plain", "text/html", "image/png", "image/eps", "image/svg+xml",
+             "application/eps", "application/pdf", "application/postscript",
+             "application/x-tex", "application/vnd.plotly.v1+json")
+    @eval function Base.show(io::IO, m::MIME{Symbol($mime)}, plt::Plot)
+        if haskey(io, :juno_plotsize)
+          showjuno(io, m, plt)
+        else
+          prepare_output(plt)
+          _show(io, m, plt)
+        end
+        return nothing
+    end
+end
+
+# default text/plain for all backends
+@noinline _show(io::IO, ::MIME{Symbol("text/plain")}, plt::Plot) = show(io, plt)
+
+"Close all open gui windows of the current backend"
+closeall() = closeall(backend())
+
+
+# function html_output_format(fmt)
+#     if fmt == "png"
+#         @eval function Base.show(io::IO, ::MIME"text/html", plt::Plot)
+#             print(io, "<img src=\"data:image/png;base64,", base64(show, MIME("image/png"), plt), "\" />")
+#         end
+#     elseif fmt == "svg"
+#         @eval function Base.show(io::IO, ::MIME"text/html", plt::Plot)
+#             show(io, MIME("image/svg+xml"), plt)
+#         end
+#     else
+#         error("only png or svg allowed. got: $fmt")
+#     end
+# end
+#
+# html_output_format("svg")
+
+
+# ---------------------------------------------------------
+# Atom PlotPane
+# ---------------------------------------------------------
+@noinline function showjuno(io::IO, m, plt)
+    sz = plt[:size]
+    dpi = plt[:dpi]
+    thickness_scaling = plt[:thickness_scaling]
+
+    jsize = get(io, :juno_plotsize, [400, 500])
+
+    scale = minimum(jsize[i] / sz[i] for i in 1:2)
+    plt[:size] = (s * scale for s in sz)
+    plt[:dpi] = Plots.DPI
+    plt[:thickness_scaling] *= scale
+
+    prepare_output(plt)
+    try
+      _showjuno(io, m, plt)
+    finally
+      plt[:size] = sz
+      plt[:dpi] = dpi
+      plt[:thickness_scaling] = thickness_scaling
+    end
+end
+
+@noinline function _showjuno(io::IO, m::MIME"image/svg+xml", plt)
+  if Symbol(plt.attr[:html_output_format]) ≠ :svg
+    throw(MethodError(show, (typeof(m), typeof(plt))))
+  else
+    _show(io, m, plt)
+  end
+end
+
+@noinline _showjuno(io::IO, m, plt) = _show(io, m, plt)

src/pipeline.jl

@@ -0,0 +1,424 @@
+
+
+# ------------------------------------------------------------------
+# preprocessing
+
+@noinline function command_idx(kw_list::AVec{KW}, kw::KW)
+    Int(kw[:series_plotindex]) - Int(kw_list[1][:series_plotindex]) + 1
+end
+
+@noinline function _expand_seriestype_array(plotattributes::KW, args)
+    sts = get(plotattributes, :seriestype, :path)
+    if typeof(sts) <: AbstractArray
+        delete!(plotattributes, :seriestype)
+        rd = Vector{RecipeData}(undef, size(sts, 1))
+        for r in 1:size(sts, 1)
+            dc = copy(plotattributes)
+            dc[:seriestype] = sts[r:r,:]
+            rd[r] = RecipeData(dc, args)
+        end
+        rd
+    else
+        RecipeData[RecipeData(copy(plotattributes), args)]
+    end
+end
+
+@noinline function _preprocess_args(plotattributes::KW, args, still_to_process::Vector{RecipeData})
+    # the grouping mechanism is a recipe on a GroupBy object
+    # we simply add the GroupBy object to the front of the args list to allow
+    # the recipe to be applied
+    if haskey(plotattributes, :group)
+        args = (extractGroupArgs(plotattributes[:group], args...), args...)
+    end
+
+    # if we were passed a vector/matrix of seriestypes and there's more than one row,
+    # we want to duplicate the inputs, once for each seriestype row.
+    if !isempty(args)
+        append!(still_to_process, _expand_seriestype_array(plotattributes, args))
+    end
+
+    # remove subplot and axis args from plotattributes... they will be passed through in the kw_list
+    if !isempty(args)
+        for (k,v) in plotattributes
+            for defdict in (_subplot_defaults,
+                            _axis_defaults,
+                            _axis_defaults_byletter)
+                if haskey(defdict, k)
+                    delete!(plotattributes, k)
+                end
+            end
+        end
+    end
+
+    args
+end
+
+# ------------------------------------------------------------------
+# user recipes
+
+
+@noinline function _process_userrecipes(plt::Plot, plotattributes::KW, args)
+    still_to_process = RecipeData[]
+    args = _preprocess_args(plotattributes, args, still_to_process)
+
+    # for plotting recipes, swap out the args and update the parameter dictionary
+    # we are keeping a stack of series that still need to be processed.
+    # each pass through the loop, we pop one off and apply the recipe.
+    # the recipe will return a list a Series objects... the ones that are
+    # finished (no more args) get added to the kw_list, the ones that are not
+    # are placed on top of the stack and are then processed further.
+    kw_list = KW[]
+    while !isempty(still_to_process)
+        # grab the first in line to be processed and either add it to the kw_list or
+        # pass it through apply_recipe to generate a list of RecipeData objects (data + attributes)
+        # for further processing.
+        next_series = popfirst!(still_to_process)
+        # recipedata should be of type RecipeData.  if it's not then the inputs must not have been fully processed by recipes
+        if !(typeof(next_series) <: RecipeData)
+            error("Inputs couldn't be processed... expected RecipeData but got: $next_series")
+        end
+        if isempty(next_series.args)
+            _process_userrecipe(plt, kw_list, next_series)
+        else
+            rd_list = RecipesBase.apply_recipe(next_series.plotattributes, next_series.args...)
+            prepend!(still_to_process,rd_list)
+        end
+    end
+
+    # don't allow something else to handle it
+    plotattributes[:smooth] = false
+    kw_list
+end
+
+@noinline function _process_userrecipe(plt::Plot, kw_list::Vector{KW}, recipedata::RecipeData)
+    # when the arg tuple is empty, that means there's nothing left to recursively
+    # process... finish up and add to the kw_list
+    kw = recipedata.plotattributes
+    preprocessArgs!(kw)
+    _preprocess_userrecipe(kw)
+    warnOnUnsupported_scales(plt.backend, kw)
+
+    # add the plot index
+    plt.n += 1
+    kw[:series_plotindex] = plt.n
+
+    push!(kw_list, kw)
+    _add_errorbar_kw(kw_list, kw)
+    _add_smooth_kw(kw_list, kw)
+    return
+end
+
+@noinline function _preprocess_userrecipe(kw::KW)
+    _add_markershape(kw)
+
+    # if there was a grouping, filter the data here
+    _filter_input_data!(kw)
+
+    # map marker_z if it's a Function
+    if isa(get(kw, :marker_z, nothing), Function)
+        # TODO: should this take y and/or z as arguments?
+        kw[:marker_z] = isa(kw[:z], Nothing) ? map(kw[:marker_z], kw[:x], kw[:y]) : map(kw[:marker_z], kw[:x], kw[:y], kw[:z])
+    end
+
+    # map line_z if it's a Function
+    if isa(get(kw, :line_z, nothing), Function)
+        kw[:line_z] = isa(kw[:z], Nothing) ? map(kw[:line_z], kw[:x], kw[:y]) : map(kw[:line_z], kw[:x], kw[:y], kw[:z])
+    end
+
+    # convert a ribbon into a fillrange
+    if get(kw, :ribbon, nothing) !== nothing
+        make_fillrange_from_ribbon(kw)
+    end
+    return
+end
+
+@noinline function _add_errorbar_kw(kw_list::Vector{KW}, kw::KW)
+    # handle error bars by creating new recipedata data... these will have
+    # the same recipedata index as the recipedata they are copied from
+    for esym in (:xerror, :yerror)
+        if get(kw, esym, nothing) !== nothing
+            # we make a copy of the KW and apply an errorbar recipe
+            errkw = copy(kw)
+            errkw[:seriestype] = esym
+            errkw[:label] = ""
+            errkw[:primary] = false
+            push!(kw_list, errkw)
+        end
+    end
+end
+
+@noinline function _add_smooth_kw(kw_list::Vector{KW}, kw::KW)
+    # handle smoothing by adding a new series
+    if get(kw, :smooth, false)
+        x, y = kw[:x], kw[:y]
+        β, α = convert(Matrix{Float64}, [x ones(length(x))]) \ convert(Vector{Float64}, y)
+        sx = [ignorenan_minimum(x), ignorenan_maximum(x)]
+        sy = β .* sx .+ α
+        push!(kw_list, merge(copy(kw), KW(
+            :seriestype => :path,
+            :x => sx,
+            :y => sy,
+            :fillrange => nothing,
+            :label => "",
+            :primary => false,
+        )))
+    end
+end
+
+# ------------------------------------------------------------------
+# plot recipes
+
+# Grab the first in line to be processed and pass it through apply_recipe
+# to generate a list of RecipeData objects (data + attributes).
+# If we applied a "plot recipe" without error, then add the returned datalist's KWs,
+# otherwise we just add the original KW.
+function _process_plotrecipe(plt::Plot, kw::KW, kw_list::Vector{KW}, still_to_process::Vector{KW})
+    if !isa(get(kw, :seriestype, nothing), Symbol)
+        # seriestype was never set, or it's not a Symbol, so it can't be a plot recipe
+        push!(kw_list, kw)
+        return
+    end
+    try
+        st = kw[:seriestype]
+        st = kw[:seriestype] = get(_typeAliases, st, st)
+        datalist = RecipesBase.apply_recipe(kw, Val{st}, plt)
+        for data in datalist
+            preprocessArgs!(data.plotattributes)
+            if data.plotattributes[:seriestype] == st
+                error("Plot recipe $st returned the same seriestype: $(data.plotattributes)")
+            end
+            push!(still_to_process, data.plotattributes)
+        end
+    catch err
+        if isa(err, MethodError)
+            push!(kw_list, kw)
+        else
+            rethrow()
+        end
+    end
+    return
+end
+
+
+# ------------------------------------------------------------------
+# setup plot and subplot
+
+function _plot_setup(plt::Plot{T}, plotattributes::KW, kw_list::Vector{KW}) where {T}
+    # merge in anything meant for the Plot
+    for kw in kw_list, (k,v) in kw
+        haskey(_plot_defaults, k) && (plotattributes[k] = pop!(kw, k))
+    end
+
+    # TODO: init subplots here
+    _update_plot_args(plt, plotattributes)
+    if !plt.init
+        plt.o = Base.invokelatest(_create_backend_figure, plt)
+
+        # create the layout and subplots from the inputs
+        plt.layout, plt.subplots, plt.spmap = build_layout(plt.attr)
+        for (idx,sp) in enumerate(plt.subplots)
+            sp.plt = plt
+            sp.attr[:subplot_index] = idx
+        end
+
+        plt.init = true
+    end
+
+
+    # handle inset subplots
+    insets = plt[:inset_subplots]
+    if insets !== nothing
+        if !(typeof(insets) <: AVec)
+            insets = [insets]
+        end
+        for inset in insets
+            parent, bb = is_2tuple(inset) ? inset : (nothing, inset)
+            P = typeof(parent)
+            if P <: Integer
+                parent = plt.subplots[parent]
+            elseif P == Symbol
+                parent = plt.spmap[parent]
+            else
+                parent = plt.layout
+            end
+            sp = Subplot(backend(), parent=parent)
+            sp.plt = plt
+            push!(plt.subplots, sp)
+            push!(plt.inset_subplots, sp)
+            sp.attr[:relative_bbox] = bb
+            sp.attr[:subplot_index] = length(plt.subplots)
+        end
+    end
+    plt[:inset_subplots] = nothing
+end
+
+function _subplot_setup(plt::Plot{T}, plotattributes::KW, kw_list::Vector{KW}) where T
+    # we'll keep a map of subplot to an attribute override dict.
+    # Subplot/Axis attributes set by a user/series recipe apply only to the
+    # Subplot object which they belong to.
+    # TODO: allow matrices to still apply to all subplots
+    sp_attrs = Dict{Any,Any}()
+    for kw in kw_list
+        # get the Subplot object to which the series belongs.
+        sps = get(kw, :subplot, :auto)
+        sp = get_subplot(plt, _cycle(sps == :auto ? plt.subplots : plt.subplots[sps], command_idx(kw_list,kw)))
+        kw[:subplot] = sp
+        # extract subplot/axis attributes from kw and add to sp_attr
+        attr = KW()
+        for (k,v) in collect(kw)
+            if haskey(_subplot_defaults, k) || haskey(_axis_defaults_byletter, k)
+                attr[k] = pop!(kw, k)
+            end
+            if haskey(_axis_defaults, k)
+                v = pop!(kw, k)
+                for letter in (:x,:y,:z)
+                    attr[Symbol(letter,k)] = v
+                end
+            end
+            for k in (:scale,), letter in (:x,:y,:z)
+                # Series recipes may need access to this information
+                lk = Symbol(letter,k)
+                if haskey(attr, lk)
+                    kw[lk] = attr[lk]
+                end
+            end
+        end
+        sp_attrs[sp] = attr
+    end
+
+    # override subplot/axis args.  `sp_attrs` take precendence
+    for (idx,sp) in enumerate(plt.subplots)
+        attr = if !haskey(plotattributes, :subplot) || plotattributes[:subplot] == idx
+            merge(plotattributes, get(sp_attrs, sp, KW()))
+        else
+            get(sp_attrs, sp, KW())
+        end
+        _update_subplot_args(plt, sp, attr, idx, false)
+    end
+
+    # do we need to link any axes together?
+    link_axes!(plt.layout, plt[:link])
+end
+
+# getting ready to add the series... last update to subplot from anything
+# that might have been added during series recipes
+@noinline function _prepare_subplot(plt::Plot{T}, plotattributes::KW) where T
+    st::Symbol = plotattributes[:seriestype]
+    sp::Subplot{T} = plotattributes[:subplot]
+    sp_idx = get_subplot_index(plt, sp)
+    _update_subplot_args(plt, sp, plotattributes, sp_idx, true)
+
+    st = _override_seriestype_check(plotattributes, st)
+
+    # change to a 3d projection for this subplot?
+    if is3d(st)
+        sp.attr[:projection] = "3d"
+    end
+
+    # initialize now that we know the first series type
+    if !haskey(sp.attr, :init)
+        _initialize_subplot(plt, sp)
+        sp.attr[:init] = true
+    end
+    sp
+end
+
+# ------------------------------------------------------------------
+# series types
+
+@noinline function _override_seriestype_check(plotattributes::KW, st::Symbol)
+    # do we want to override the series type?
+    if !is3d(st) && !(st in (:contour,:contour3d))
+        z = plotattributes[:z]
+        if !isa(z, Nothing) && (size(plotattributes[:x]) == size(plotattributes[:y]) == size(z))
+            st = (st == :scatter ? :scatter3d : :path3d)
+            plotattributes[:seriestype] = st
+        end
+    end
+    st
+end
+
+@noinline function _prepare_annotations(sp::Subplot, plotattributes::KW)
+    # strip out series annotations (those which are based on series x/y coords)
+    # and add them to the subplot attr
+    sp_anns = annotations(sp[:annotations])
+    # series_anns = annotations(pop!(plotattributes, :series_annotations, []))
+    # if isa(series_anns, SeriesAnnotations)
+    #     series_anns.x = plotattributes[:x]
+    #     series_anns.y = plotattributes[:y]
+    # elseif length(series_anns) > 0
+    #     x, y = plotattributes[:x], plotattributes[:y]
+    #     nx, ny, na = map(length, (x,y,series_anns))
+    #     n = max(nx, ny, na)
+    #     series_anns = [(x[mod1(i,nx)], y[mod1(i,ny)], text(series_anns[mod1(i,na)])) for i=1:n]
+    # end
+    # sp.attr[:annotations] = vcat(sp_anns, series_anns)
+end
+
+function _expand_subplot_extrema(sp::Subplot, plotattributes::KW, st::Symbol)
+    # adjust extrema and discrete info
+    if st == :image
+        xmin, xmax = ignorenan_extrema(plotattributes[:x]); ymin, ymax = ignorenan_extrema(plotattributes[:y])
+        expand_extrema!(sp[:xaxis], (xmin, xmax))
+        expand_extrema!(sp[:yaxis], (ymin, ymax))
+    elseif !(st in (:pie, :histogram, :bins2d, :histogram2d))
+        expand_extrema!(sp, plotattributes)
+    end
+    # expand for zerolines (axes through origin)
+    if sp[:framestyle] in (:origin, :zerolines)
+        expand_extrema!(sp[:xaxis], 0.0)
+        expand_extrema!(sp[:yaxis], 0.0)
+    end
+end
+
+@noinline function _add_the_series(plt, sp, plotattributes)
+    warnOnUnsupported_args(plt.backend, plotattributes)
+    warnOnUnsupported(plt.backend, plotattributes)
+    series = Series(plotattributes)
+    push!(plt.series_list, series)
+    push!(sp.series_list, series)
+    _series_added(plt, series)
+end
+
+# -------------------------------------------------------------------------------
+
+# this method recursively applies series recipes when the seriestype is not supported
+# natively by the backend
+function _process_seriesrecipe(plt::Plot, plotattributes::KW)
+    # replace seriestype aliases
+    st = Symbol(plotattributes[:seriestype])
+    st = plotattributes[:seriestype] = get(_typeAliases, st, st)
+
+    # shapes shouldn't have fillrange set
+    if plotattributes[:seriestype] == :shape
+        plotattributes[:fillrange] = nothing
+    end
+
+    # if it's natively supported, finalize processing and pass along to the backend, otherwise recurse
+    if is_seriestype_supported(st)
+        sp = _prepare_subplot(plt, plotattributes)
+        _prepare_annotations(sp, plotattributes)
+        _expand_subplot_extrema(sp, plotattributes, st)
+        _update_series_attributes!(plotattributes, plt, sp)
+        _add_the_series(plt, sp, plotattributes)
+
+    else
+        # get a sub list of series for this seriestype
+        datalist = RecipesBase.apply_recipe(plotattributes, Val{st}, plotattributes[:x], plotattributes[:y], plotattributes[:z])
+
+        # assuming there was no error, recursively apply the series recipes
+        for data in datalist
+            if isa(data, RecipeData)
+                preprocessArgs!(data.plotattributes)
+                if data.plotattributes[:seriestype] == st
+                    error("The seriestype didn't change in series recipe $st.  This will cause a StackOverflow.")
+                end
+                _process_seriesrecipe(plt, data.plotattributes)
+            else
+                @warn("Unhandled recipe: $(data)")
+                break
+            end
+        end
+    end
+    nothing
+end

src/plot.jl

@@ -1,414 +1,300 @@
 
-type CurrentPlot
-  nullableplot::Nullable{PlottingObject}
+mutable struct CurrentPlot
+    nullableplot::Union{AbstractPlot, Nothing}
 end
-const CURRENT_PLOT = CurrentPlot(Nullable{PlottingObject}())
+const CURRENT_PLOT = CurrentPlot(nothing)
 
-isplotnull() = isnull(CURRENT_PLOT.nullableplot)
+@noinline isplotnull() = CURRENT_PLOT.nullableplot === nothing
 
-function currentPlot()
-  if isplotnull()
-    error("No current plot/subplot")
-  end
-  get(CURRENT_PLOT.nullableplot)
+"""
+    current()
+Returns the Plot object for the current plot
+"""
+@noinline function current()
+    if isplotnull()
+        error("No current plot/subplot")
+    end
+    CURRENT_PLOT.nullableplot
 end
-currentPlot!(plot::PlottingObject) = (CURRENT_PLOT.nullableplot = Nullable(plot))
+@noinline current(plot::AbstractPlot) = (CURRENT_PLOT.nullableplot = plot)
 
 # ---------------------------------------------------------
 
 
-Base.string(plt::Plot) = "Plot{$(plt.plotter) n=$(plt.n)}"
+Base.string(plt::Plot) = "Plot{$(plt.backend) n=$(plt.n)}"
 Base.print(io::IO, plt::Plot) = print(io, string(plt))
 Base.show(io::IO, plt::Plot) = print(io, string(plt))
 
-getplot(plt::Plot) = plt
+@noinline getplot(plt::Plot) = plt
+@noinline getattr(plt::Plot, idx::Int = 1) = plt.attr
+@noinline convertSeriesIndex(plt::Plot, n::Int) = n
 
+# ---------------------------------------------------------
 
-doc"""
-The main plot command.  Call `plotter!(:module)` to set the current plotting backend.
-Commands are converted into the relevant plotting commands for that package:
-
-```
-  plotter!(:gadfly)
-  plot(1:10)    # this effectively calls `y = 1:10; Gadfly.plot(x=1:length(y), y=y)`
-  plotter!(:qwt)
-  plot(1:10)    # this effectively calls `Qwt.plot(1:10)`
-```
-
-Use `plot` to create a new plot object, and `plot!` to add to an existing one:
-
-```
-  plot(args...; kw...)                  # creates a new plot window, and sets it to be the currentPlot
-  plot!(args...; kw...)                 # adds to the `currentPlot`
-  plot!(plotobj, args...; kw...)        # adds to the plot `plotobj`
-```
-
-There are lots of ways to pass in data... just try it and it will likely work as expected.
-When you pass in matrices, it splits by columns.  See the documentation for more info.
-
-Some keyword arguments you can set:
-
-```
-  axis            # :left or :right
-  color           # can be a string ("red") or a symbol (:red) or a ColorsTypes.jl Colorant (RGB(1,0,0)) or :auto (which lets the package pick)
-  label           # string or symbol, applies to that line, may go in a legend
-  width           # width of a line
-  linetype        # :line, :step, :stepinverted, :sticks, :dots, :none, :heatmap
-  linestyle       # :solid, :dash, :dot, :dashdot, :dashdotdot
-  marker          # :none, :ellipse, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star1, :star2, :hexagon
-  markercolor     # same choices as `color`
-  markersize      # size of the marker
-  nbins           # number of bins for heatmap/hexbin and histograms
-  heatmap_c       # color cutoffs for Qwt heatmaps
-  fillto          # fillto value for area plots
-  title           # string or symbol, title of the plot
-  xlabel          # string or symbol, label on the bottom (x) axis
-  ylabel          # string or symbol, label on the left (y) axis
-  yrightlabel     # string or symbol, label on the right (y) axis
-  reg             # true or false, add a regression line for each line
-  size            # (Int,Int), resize the enclosing window
-  pos             # (Int,Int), move the enclosing window to this position
-  windowtitle     # string or symbol, set the title of the enclosing windowtitle
-  screen          # Integer, move enclosing window to this screen number (for multiscreen desktops)
-  show            # true or false, show the plot (in case you don't want the window to pop up right away)
-```
-
-When plotting multiple lines, you can give every line the same trait by using the singular, or add an "s" to pluralize.
-  (yes I know it's not gramatically correct, but it's easy to use and implement)
-
-```
-  plot(rand(100,2); colors = [:red, RGB(.5,.5,0)], axiss = [:left, :right], width = 5)  # note the width=5 is applied to both lines
-```
 
 """
+The main plot command. Use `plot` to create a new plot object, and `plot!` to add to an existing one:
 
+```
+    plot(args...; kw...)                  # creates a new plot window, and sets it to be the current
+    plot!(args...; kw...)                 # adds to the `current`
+    plot!(plotobj, args...; kw...)        # adds to the plot `plotobj`
+```
 
-# -------------------------
-
-# this creates a new plot with args/kw and sets it to be the current plot
+There are lots of ways to pass in data, and lots of keyword arguments... just try it and it will likely work as expected.
+When you pass in matrices, it splits by columns. To see the list of available attributes, use the `plotattr([attr])`
+function, where `attr` is the symbol `:Series:`, `:Subplot:`, `:Plot` or `:Axis`. Pass any attribute to `plotattr`
+as a String to look up its docstring; e.g. `plotattr("seriestype")`.
+"""
 function plot(args...; kw...)
-  plt = plot(plotter(); getPlotKeywordArgs(kw, 1, 0)...)  # create a new, blank plot
-  plot!(plt, args...; kw...)  # add to it
+    # this creates a new plot with args/kw and sets it to be the current plot
+    plotattributes = KW(kw)
+    preprocessArgs!(plotattributes)
+    # create an empty Plot then process
+    plt = Plot()
+    # plt.user_attr = plotattributes
+    _plot!(plt, plotattributes, Any[args...])
 end
 
-# this adds to the current plot
+# build a new plot from existing plots
+# note: we split into plt1 and plts_tail so we can dispatch correctly
+function plot(plt1::Plot, plts_tail::Plot...; kw...)
+    plotattributes = KW(kw)
+    preprocessArgs!(plotattributes)
+
+    # build our plot vector from the args
+    n = length(plts_tail) + 1
+    plts = Array{Plot}(undef, n)
+    plts[1] = plt1
+    for (i,plt) in enumerate(plts_tail)
+        plts[i+1] = plt
+    end
+
+    # compute the layout
+    layout = layout_args(plotattributes, n)[1]
+    num_sp = sum([length(p.subplots) for p in plts])
+
+    # create a new plot object, with subplot list/map made of existing subplots.
+    # note: we create a new backend figure for this new plot object
+    # note: all subplots and series "belong" to this new plot...
+    plt = Plot()
+
+    # TODO: build the user_attr dict by creating "Any matrices" for the args of each subplot
+
+    # TODO: replace this with proper processing from a merged user_attr KW
+    # update plot args, first with existing plots, then override with plotattributes
+    for p in plts
+        _update_plot_args(plt, copy(p.attr))
+        plt.n += p.n
+    end
+    _update_plot_args(plt, plotattributes)
+
+    # pass new plot to the backend
+    plt.o = _create_backend_figure(plt)
+    plt.init = true
+
+    series_attr = KW()
+    for (k,v) in plotattributes
+        if haskey(_series_defaults, k)
+            series_attr[k] = pop!(plotattributes,k)
+        end
+    end
+
+    # create the layout
+    plt.layout, plt.subplots, plt.spmap = build_layout(layout, num_sp, copy(plts))
+
+    # do we need to link any axes together?
+    link_axes!(plt.layout, plt[:link])
+
+    # initialize the subplots
+    cmdidx = 1
+    for (idx, sp) in enumerate(plt.subplots)
+        _initialize_subplot(plt, sp)
+        serieslist = series_list(sp)
+        if sp in sp.plt.inset_subplots
+            push!(plt.inset_subplots, sp)
+        end
+        sp.plt = plt
+        sp.attr[:subplot_index] = idx
+        for series in serieslist
+            merge!(series.plotattributes, series_attr)
+            _add_defaults!(series.plotattributes, plt, sp, cmdidx)
+            push!(plt.series_list, series)
+            _series_added(plt, series)
+            cmdidx += 1
+        end
+    end
+
+    # first apply any args for the subplots
+    for (idx,sp) in enumerate(plt.subplots)
+        _update_subplot_args(plt, sp, plotattributes, idx, false)
+    end
+
+    # finish up
+    current(plt)
+    _do_plot_show(plt, get(plotattributes, :show, default(:show)))
+    plt
+end
+
+
+
+# this adds to the current plot, or creates a new plot if none are current
 function  plot!(args...; kw...)
-  plot!(currentPlot(), args...; kw...)
-end
-
-# not allowed:
-function plot!(subplt::Subplot, args...; kw...)
-  error("Can't call plot! on a Subplot!")
+    local plt
+    try
+        plt = current()
+    catch
+        return plot(args...; kw...)
+    end
+    plot!(current(), args...; kw...)
 end
 
 # this adds to a specific plot... most plot commands will flow through here
 function plot!(plt::Plot, args...; kw...)
-
-  # # increment n if we're going directly to the package's plot method
-  # if length(args) == 0
-  #   plt.n += 1
-  # end
-
-  # plot!(plt.plotter, plt, args...; kw...)
-
-
-  kwList = createKWargsList(plt, args...; kw...)
-  for (i,d) in enumerate(kwList)
-    plt.n += 1
-    plot!(plt.plotter, plt; d...)
-  end
-
-  currentPlot!(plt)
-
-  # do we want to show it?
-  d = Dict(kw)
-  if haskey(d, :show) && d[:show]
-    display(plt)
-  end
-
-  plt
+    plotattributes = KW(kw)
+    preprocessArgs!(plotattributes)
+    # merge!(plt.user_attr, plotattributes)
+    _plot!(plt, plotattributes, Any[args...])
 end
 
-# show/update the plot
-function Base.display(plt::PlottingObject)
-  display(plt.plotter, plt)
+# -------------------------------------------------------------------------------
+
+# this is the core plotting function.  recursively apply recipes to build
+# a list of series KW dicts.
+# note: at entry, we only have those preprocessed args which were passed in... no default values yet
+function _plot!(plt::Plot{T}, plotattributes::KW, args::Vector{Any}) where {T}
+    plotattributes[:plot_object] = plt
+
+
+    if !isempty(args) && !isdefined(Main, :StatsPlots) &&
+            first(split(string(typeof(args[1])), ".")) == "DataFrames"
+        @warn("You're trying to plot a DataFrame, but this functionality is provided by StatsPlots")
+    end
+
+    # --------------------------------
+    # "USER RECIPES"
+    # --------------------------------
+
+    # 1 second
+    kw_list = _process_userrecipes(plt, plotattributes, args)
+
+    # @info(1)
+    # map(DD, kw_list)
+
+
+    # --------------------------------
+    # "PLOT RECIPES"
+    # --------------------------------
+
+    # "plot recipe", which acts like a series type, and is processed before
+    # the plot layout is created, which allows for setting layouts and other plot-wide attributes.
+    # we get inputs which have been fully processed by "user recipes" and "type recipes",
+    # so we can expect standard vectors, surfaces, etc.  No defaults have been set yet.
+
+    still_to_process = kw_list
+    kw_list = KW[]
+    while !isempty(still_to_process)
+        next_kw = popfirst!(still_to_process)
+        _process_plotrecipe(plt, next_kw, kw_list, still_to_process)
+    end
+
+    # @info(2)
+    # map(DD, kw_list)
+
+    # --------------------------------
+    # Plot/Subplot/Layout setup
+    # --------------------------------
+
+    # 2.5 seconds
+    _plot_setup(plt, plotattributes, kw_list)
+
+    # 6 seconds
+    _subplot_setup(plt, plotattributes, kw_list)
+
+    # !!! note: At this point, kw_list is fully decomposed into individual series... one KW per series.          !!!
+    # !!!       The next step is to recursively apply series recipes until the backend supports that series type !!!
+
+    # --------------------------------
+    # "SERIES RECIPES"
+    # --------------------------------
+
+    # @info(3)
+    # map(DD, kw_list)
+
+    for kw in kw_list
+        sp::Subplot{T} = kw[:subplot]
+        # idx = get_subplot_index(plt, sp)
+
+        # # we update subplot args in case something like the color palatte is part of the recipe
+        # _update_subplot_args(plt, sp, kw, idx, true)
+
+        # set default values, select from attribute cycles, and generally set the final attributes
+        _add_defaults!(kw, plt, sp, command_idx(kw_list,kw))
+
+        # now we have a fully specified series, with colors chosen.   we must recursively handle
+        # series recipes, which dispatch on seriestype.  If a backend does not natively support a seriestype,
+        # we check for a recipe that will convert that series type into one made up of lower-level components.
+        # For example, a histogram is just a bar plot with binned data, a bar plot is really a filled step plot,
+        # and a step plot is really just a path.  So any backend that supports drawing a path will implicitly
+        # be able to support step, bar, and histogram plots (and any recipes that use those components).
+        _process_seriesrecipe(plt, kw)
+    end
+    # --------------------------------
+
+    # 7 seconds
+    current(plt)
+
+    # do we want to force display?
+    # if plt[:show]
+    #     gui(plt)
+    # end
+    _do_plot_show(plt, plt[:show])
+    plt
 end
 
-# -------------------------
 
+# we're getting ready to display/output.  prep for layout calcs, then update
+# the plot object after
+@noinline function prepare_output(plt::Plot)
 
+    _before_layout_calcs(plt)
 
-doc"Build a vector of dictionaries which hold the keyword arguments for a call to plot!"
+    w, h = plt.attr[:size]
+    plt.layout.bbox = BoundingBox(0mm, 0mm, w*px, h*px)
+
+    # One pass down and back up the tree to compute the minimum padding
+    # of the children on the perimeter.  This is an backend callback.
+    _update_min_padding!(plt.layout)
+    for sp in plt.inset_subplots
+        _update_min_padding!(sp)
+    end
+
+    # now another pass down, to update the bounding boxes
+    update_child_bboxes!(plt.layout)
+
+    # update those bounding boxes of inset subplots
+    update_inset_bboxes!(plt)
+
+    # the backend callback, to reposition subplots, etc
+    _update_plot_object(plt)
 
-# no args... 1 series
-function createKWargsList(plt::PlottingObject; kw...)
-  d = Dict(kw)
-  @assert haskey(d, :y)
-  if !haskey(d, :x)
-    d[:x] = 1:length(d[:y])
-  end
-  [getPlotKeywordArgs(d, 1, plt.n + 1)]
 end
 
-# create one series where y is vectors of numbers
-function createKWargsList{T<:Real}(plt::PlottingObject, y::AVec{T}; kw...)
-  d = getPlotKeywordArgs(kw, 1, plt.n + 1)
-  d[:x] = 1:length(y)
-  d[:y] = y
-  [d]
+@noinline function backend_object(plt::Plot)
+    prepare_output(plt)
+    plt.o
 end
 
-# create one series where x/y are vectors of numbers
-function createKWargsList{T<:Real,S<:Real}(plt::PlottingObject, x::AVec{T}, y::AVec{S}; kw...)
-  @assert length(x) == length(y)
-  d = getPlotKeywordArgs(kw, 1, plt.n + 1)
-  d[:x] = x
-  d[:y] = y
-  [d]
+# --------------------------------------------------------------------
+# plot to a Subplot
+
+function plot(sp::Subplot, args...; kw...)
+    plt = sp.plt
+    plot(plt, args...; kw..., subplot = findfirst(isequal(sp), plt.subplots))
+end
+function plot!(sp::Subplot, args...; kw...)
+    plt = sp.plt
+    plot!(plt, args...; kw..., subplot = findfirst(isequal(sp), plt.subplots))
 end
 
-# create m series, 1 for each column of y
-function createKWargsList(plt::PlottingObject, y::AMat; kw...)
-  n,m = size(y)
-  ret = []
-  for i in 1:m
-    d = getPlotKeywordArgs(kw, i, plt.n + i)
-    d[:x] = 1:n
-    d[:y] = y[:,i]
-    push!(ret, d)
-  end
-  ret
-end
-
-# create m series, 1 for each column of y
-function createKWargsList(plt::PlottingObject, x::AVec, y::AMat; kw...)
-  n,m = size(y)
-  @assert length(x) == n
-  ret = []
-  for i in 1:m
-    d = getPlotKeywordArgs(kw, i, plt.n + i)
-    d[:x] = x
-    d[:y] = y[:,i]
-    push!(ret, d)
-  end
-  ret
-end
-
-# create m series, 1 for each column of y
-function createKWargsList(plt::PlottingObject, x::AMat, y::AMat; kw...)
-  @assert size(x) == size(y)
-  n,m = size(y)
-  ret = []
-  for i in 1:m
-    d = getPlotKeywordArgs(kw, i, plt.n + i)
-    d[:x] = x[:,i]
-    d[:y] = y[:,i]
-    push!(ret, d)
-  end
-  ret
-end
-
-# create 1 series, y = f(x)
-function createKWargsList(plt::PlottingObject, x::AVec, f::Function; kw...)
-  d = getPlotKeywordArgs(kw, 1, plt.n + 1)
-  d[:x] = x
-  d[:y] = map(f, x)
-  [d]
-end
-
-# create m series, y = f(x), 1 for each column of x
-function createKWargsList(plt::PlottingObject, x::AMat, f::Function; kw...)
-  n,m = size(x)
-  ret = []
-  for i in 1:m
-    d = getPlotKeywordArgs(kw, i, plt.n + i)
-    d[:x] = x[:,i]
-    d[:y] = map(f, d[:x])
-    push!(ret, d)
-  end
-  ret
-end
-
-# create m series, 1 for each item in y (assumes vectors of something other than numbers... functions? vectors?)
-function createKWargsList(plt::PlottingObject, y::AVec; kw...)
-  m = length(y)
-  ret = []
-  for i in 1:m
-    d = getPlotKeywordArgs(kw, i, plt.n + i)
-    d[:x] = 1:length(y[i])
-    d[:y] = y[i]
-    push!(ret, d)
-  end
-  ret
-end
-
-function getyvec(x::AVec, y::AVec)
-  @assert length(x) == length(y)
-  y
-end
-getyvec(x::AVec, f::Function) = map(f, x)
-getyvec(x, y) = error("Couldn't create yvec from types: x ($(typeof(x))), y ($(typeof(y)))")
-
-# same, but given an x to use for all series
-function createKWargsList{T<:Real}(plt::PlottingObject, x::AVec{T}, y::AVec; kw...)
-  m = length(y)
-  ret = []
-  for i in 1:m
-    d = getPlotKeywordArgs(kw, i, plt.n + i)
-    d[:x] = x
-    d[:y] = getyvec(x, y[i])
-    push!(ret, d)
-  end
-  ret
-end
-
-# same, but m series of (x[i],y[i])
-function createKWargsList(plt::PlottingObject, x::AVec, y::AVec; kw...)
-  @assert length(x) == length(y)
-  m = length(y)
-  ret = []
-  for i in 1:m
-    d = getPlotKeywordArgs(kw, i, plt.n + i)
-    d[:x] = x[i]
-    d[:y] = getyvec(x[i], y[i])
-    push!(ret, d)
-  end
-  ret
-end
-
-# n empty series
-function createKWargsList(plt::PlottingObject, n::Integer; kw...)
-  ret = []
-  for i in 1:n
-    d = getPlotKeywordArgs(kw, i, plt.n + i)
-    d[:x] = zeros(0)
-    d[:y] = zeros(0)
-    push!(ret, d)
-  end
-  ret
-end
-
-# TODO: handle DataFrames (might have NAs!)
-
-# -------------------------
-
-# # most calls should flow through here now... we create a Dict with the keyword args for each series, and plot them
-# function plot!(pkg::PlottingPackage, plt::Plot, args...; kw...)
-#   kwList = createKWargsList(plt, args...; kw...)
-#   for (i,d) in enumerate(kwList)
-#     plt.n += 1
-#     plot!(pkg, plt; d...)
-#   end
-#   plt
-# end
-
-# -------------------------
-
-# # These methods are various ways to add to an existing plot
-
-# function plot!{T<:Real}(pkg::PlottingPackage, plt::Plot, y::AVec{T}; kw...)
-#   plt.n += 1
-#   # plot!(pkg, plt; x = 1:length(y), y = y, getPlotKeywordArgs(kw, 1, plt)...)
-# end
-
-# function plot!{T<:Real,S<:Real}(pkg::PlottingPackage, plt::Plot, x::AVec{T}, y::AVec{S}; kw...)              # one line (will assert length(x) == length(y))
-#   @assert length(x) == length(y)
-#   plt.n += 1
-#   plot!(pkg, plt; x=x, y=y, getPlotKeywordArgs(kw, 1, plt)...)
-# end
-
-# function plot!(pkg::PlottingPackage, plt::Plot, y::AMat; kw...)                       # multiple lines (one per column of x), all sharing x = 1:size(y,1)
-#   n,m = size(y)
-#   for i in 1:m
-#     plt.n += 1
-#     plot!(pkg, plt; x = 1:n, y = y[:,i], getPlotKeywordArgs(kw, i, plt)...)
-#   end
-#   plt
-# end
-
-# function plot!(pkg::PlottingPackage, plt::Plot, x::AVec, y::AMat; kw...)              # multiple lines (one per column of x), all sharing x (will assert length(x) == size(y,1))
-#   n,m = size(y)
-#   for i in 1:m
-#     @assert length(x) == n
-#     plt.n += 1
-#     plot!(pkg, plt; x = x, y = y[:,i], getPlotKeywordArgs(kw, i, plt)...)
-#   end
-#   plt
-# end
-
-# function plot!(pkg::PlottingPackage, plt::Plot, x::AMat, y::AMat; kw...)              # multiple lines (one per column of x/y... will assert size(x) == size(y))
-#   @assert size(x) == size(y)
-#   for i in 1:size(x,2)
-#     plt.n += 1
-#     plot!(pkg, plt; x = x[:,i], y = y[:,i], getPlotKeywordArgs(kw, i, plt)...)
-#   end
-#   plt
-# end
-
-# function plot!(pkg::PlottingPackage, plt::Plot, x::AVec, f::Function; kw...)          # one line, y = f(x)
-#   plt.n += 1
-#   plot!(pkg, plt; x = x, y = map(f,x), getPlotKeywordArgs(kw, 1, plt)...)
-# end
-
-# function plot!(pkg::PlottingPackage, plt::Plot, x::AMat, f::Function; kw...)          # multiple lines, yᵢⱼ = f(xᵢⱼ)
-#   for i in 1:size(x,2)
-#     xi = x[:,i]
-#     plt.n += 1
-#     plot!(pkg, plt; x = xi, y = map(f, xi), getPlotKeywordArgs(kw, i, plt)...)
-#   end
-#   plt
-# end
-
-# # function plot!(pkg::PlottingPackage, plt::Plot, x::AVec, fs::AVec{Function}; kw...)   # multiple lines, yᵢⱼ = fⱼ(xᵢ)
-# #   for i in 1:length(fs)
-# #     plt.n += 1
-# #     plot!(pkg, plt; x = x, y = map(fs[i], x), getPlotKeywordArgs(kw, i, plt)...)
-# #   end
-# #   plt
-# # end
-
-# function plot!(pkg::PlottingPackage, plt::Plot, y::AVec; kw...)                 # multiple lines, each with x = 1:length(y[i])
-#   for i in 1:length(y)
-#     plt.n += 1
-#     plot!(pkg, plt; x = 1:length(y[i]), y = y[i], getPlotKeywordArgs(kw, i, plt)...)
-#   end
-#   plt
-# end
-
-# function plot!{T<:Real}(pkg::PlottingPackage, plt::Plot, x::AVec{T}, y::AVec; kw...)        # multiple lines, will assert length(x) == length(y[i])
-#   for i in 1:length(y)
-#     if typeof(y[i]) <: AbstractVector
-#       @assert length(x) == length(y[i])
-#       plt.n += 1
-#       plot!(pkg, plt; x = x, y = y[i], getPlotKeywordArgs(kw, i, plt)...)
-#     elseif typeof(y[i]) == Function
-#       plt.n += 1
-#       plot!(pkg, plt; x = x, y = map(y[i], x), getPlotKeywordArgs(kw, 1, plt)...)
-#     end
-#   end
-#   plt
-# end
-
-# function plot!(pkg::PlottingPackage, plt::Plot, x::AVec, y::AVec; kw...)  # multiple lines, will assert length(x[i]) == length(y[i])
-#   @assert length(x) == length(y)
-#   for i in 1:length(x)
-#     @assert length(x[i]) == length(y[i])
-#     plt.n += 1
-#     plot!(pkg, plt; x = x[i], y = y[i], getPlotKeywordArgs(kw, i, plt)...)
-#   end
-#   plt
-# end
-
-# function plot!(pkg::PlottingPackage, plt::Plot, n::Integer; kw...)                    # n lines, all empty (for updating plots)
-#   for i in 1:n
-#     plt.n += 1
-#     plot(pkg, plt, x = zeros(0), y = zeros(0), getPlotKeywordArgs(kw, i, plt)...)
-#   end
-# end
-
-# -------------------------
-
-# # this is the core method... add to a plot object using kwargs, with args already converted into kwargs
-# function plot!(pkg::PlottingPackage, plt::Plot; kw...)
-#   plot!(pl, plt; kw...)
-# end
+# --------------------------------------------------------------------

src/plotattr.jl

@@ -0,0 +1,70 @@
+
+const _attribute_defaults =  Dict(:Series => _series_defaults,
+                        :Subplot => _subplot_defaults,
+                        :Plot => _plot_defaults,
+                        :Axis => _axis_defaults)
+
+attrtypes() = join(keys(_attribute_defaults), ", ")
+attributes(attrtype::Symbol) = sort(collect(keys(_attribute_defaults[attrtype])))
+
+function lookup_aliases(attrtype, attribute)
+    attribute = Symbol(attribute)
+    attribute = in(attribute, keys(_keyAliases)) ? _keyAliases[attribute] : attribute
+    in(attribute, keys(_attribute_defaults[attrtype])) && return attribute
+    error("There is no attribute named $attribute in $attrtype")
+end
+
+"""
+    plotattr([attr])
+
+Look up the properties of a Plots attribute, or specify an attribute type. Call `plotattr()` for options.
+The information is the same as that given on https://docs.juliaplots.org/latest/attributes/.
+"""
+function plotattr()
+    println("Specify an attribute type to get a list of supported attributes. Options are $(attrtypes())")
+end
+
+function plotattr(attrtype::Symbol)
+    in(attrtype, keys(_attribute_defaults)) || error("Viable options are $(attrtypes())")
+    println("Defined $attrtype attributes are:\n$(join(attributes(attrtype), ", "))")
+end
+
+function plotattr(attribute::AbstractString)
+    attribute = Symbol(attribute)
+    attribute = in(attribute, keys(_keyAliases)) ? _keyAliases[attribute] : attribute
+    for (k, v) in _attribute_defaults
+        if in(attribute, keys(v))
+            return plotattr(k, "$attribute")
+        end
+    end
+    error("There is no attribute named $attribute")
+end
+
+printnothing(x) = x
+printnothing(x::Nothing) = "nothing"
+
+function plotattr(attrtype::Symbol, attribute::AbstractString)
+    in(attrtype, keys(_attribute_defaults)) || ArgumentError("`attrtype` must match one of $(attrtypes())")
+
+    attribute = Symbol(lookup_aliases(attrtype, attribute))
+
+    desc = get(_arg_desc, attribute, "")
+    first_period_idx = findfirst(isequal('.'), desc)
+    if isnothing(first_period_idx) 
+        typedesc = ""
+        desc = strip(desc)
+    else
+        typedesc = desc[1:first_period_idx-1]
+        desc = strip(desc[first_period_idx+1:end])
+    end
+    als = keys(filter(x->x[2]==attribute, _keyAliases)) |> collect |> sort
+    als = join(map(string,als), ", ")
+    def = _attribute_defaults[attrtype][attribute]
+
+
+    # Looks up the different elements and plots them
+    println("$(printnothing(attribute)) ", typedesc == "" ? "" : "{$(printnothing(typedesc))}", "\n",
+        als == "" ? "" : "$(printnothing(als))\n",
+        "\n$(printnothing(desc))\n",
+        "$(printnothing(attrtype)) attribute, ", def == "" ? "" : " default: $(printnothing(def))")
+end

src/plotter.jl

@@ -1,64 +0,0 @@
-
-
-plot(pkg::PlottingPackage; kw...) = error("plot($pkg; kw...) is not implemented")
-plot!(pkg::PlottingPackage, plt::Plot; kw...) = error("plot!($pkg, plt; kw...) is not implemented")
-Base.display(pkg::PlottingPackage, plt::Plot) = error("display($pkg, plt) is not implemented")
-
-# ---------------------------------------------------------
-
-
-const AVAILABLE_PACKAGES = [:qwt, :gadfly]
-const INITIALIZED_PACKAGES = Set{Symbol}()
-
-type CurrentPackage
-  sym::Symbol
-  pkg::PlottingPackage
-end
-# const CURRENT_PACKAGE = CurrentPackage(:qwt, QwtPackage())
-const CURRENT_PACKAGE = CurrentPackage(:gadfly, GadflyPackage())
-
-
-doc"""
-Returns the current plotting package name.  Initializes package on first call.
-"""
-function plotter()
-
-  currentPackageSymbol = CURRENT_PACKAGE.sym
-  if !(currentPackageSymbol in INITIALIZED_PACKAGES)
-
-    # initialize
-    print("[Plots.jl] Initializing package: $CURRENT_PACKAGE... ")
-    if currentPackageSymbol == :qwt
-      @eval import Qwt
-    elseif currentPackageSymbol == :gadfly
-      @eval import Gadfly
-    else
-      error("Unknown plotter $currentPackageSymbol.  Choose from: $AVAILABLE_PACKAGES")
-    end
-    push!(INITIALIZED_PACKAGES, currentPackageSymbol)
-    println("done.")
-
-  end
-  CURRENT_PACKAGE.pkg
-end
-
-doc"""
-Set the plot backend.  Choose from:  :qwt, :gadfly
-"""
-function plotter!(modname)
-  
-  # set the PlottingPackage
-  if modname == :qwt
-    CURRENT_PACKAGE.pkg = QwtPackage()
-  elseif modname == :gadfly
-    CURRENT_PACKAGE.pkg = GadflyPackage()
-  else
-    error("Unknown plotter $modname.  Choose from: $AVAILABLE_PACKAGES")
-  end
-
-  # update the symbol
-  CURRENT_PACKAGE.sym = modname
-
-  # return the package
-  CURRENT_PACKAGE.pkg
-end

src/precompile.jl

@@ -0,0 +1,3 @@
+function _precompile_()
+    ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
+end

src/qwt.jl

@@ -1,67 +0,0 @@
-
-# https://github.com/tbreloff/Qwt.jl
-
-immutable QwtPackage <: PlottingPackage end
-
-# -------------------------------
-
-function adjustQwtKeywords(iscreating::Bool; kw...)
-  d = Dict(kw)
-  d[:heatmap_n] = d[:nbins]
-
-  if d[:linetype] == :hexbin
-    d[:linetype] = :heatmap
-  elseif d[:linetype] == :dots
-    d[:linetype] = :none
-    d[:marker] = :hexagon
-  elseif !iscreating && d[:linetype] == :bar
-    return barHack(; kw...)
-  elseif !iscreating && d[:linetype] == :hist
-    return barHack(; histogramHack(; kw...)...)
-  end
-  d
-end
-
-function plot(pkg::QwtPackage; kw...)
-  kw = adjustQwtKeywords(true; kw...)
-  plt = Plot(Qwt.plot(zeros(0,0); kw..., show=false), pkg, 0)
-  plt
-end
-
-function plot!(::QwtPackage, plt::Plot; kw...)
-  kw = adjustQwtKeywords(false; kw...)
-  Qwt.oplot(plt.o; kw...)
-end
-
-function Base.display(::QwtPackage, plt::Plot)
-  Qwt.refresh(plt.o)
-  Qwt.showwidget(plt.o)
-end
-
-# -------------------------------
-
-savepng(::QwtPackage, plt::PlottingObject, fn::String, args...) = Qwt.savepng(plt.o, fn)
-
-# -------------------------------
-
-# # create the underlying object (each backend will do this differently)
-# o = buildSubplotObject(plts, pkg, layout)
-
-function buildSubplotObject!(::QwtPackage, subplt::Subplot)
-  i = 0
-  rows = []
-  for rowcnt in subplt.layout.rowcounts
-    push!(rows, Qwt.hsplitter([plt.o for plt in subplt.plts[(1:rowcnt) + i]]...))
-    i += rowcnt
-  end
-  subplt.o = Qwt.vsplitter(rows...)
-end
-
-
-function Base.display(::QwtPackage, subplt::Subplot)
-  for plt in subplt.plts
-    Qwt.refresh(plt.o)
-  end
-  Qwt.showwidget(subplt.o)
-end
-

src/series.jl

@@ -0,0 +1,625 @@
+
+
+# create a new "build_series_args" which converts all inputs into xs = Any[xitems], ys = Any[yitems].
+# Special handling for: no args, xmin/xmax, parametric, dataframes
+# Then once inputs have been converted, build the series args, map functions, etc.
+# This should cut down on boilerplate code and allow more focused dispatch on type
+# note: returns meta information... mainly for use with automatic labeling from DataFrames for now
+
+const FuncOrFuncs{F} = Union{F, Vector{F}, Matrix{F}}
+const DataPoint = Union{Number, AbstractString, Missing}
+const SeriesData = Union{AVec{<:DataPoint}, Function, Surface, Volume}
+
+prepareSeriesData(x) = error("Cannot convert $(typeof(x)) to series data for plotting")
+prepareSeriesData(::Nothing) = nothing
+prepareSeriesData(s::SeriesData) = handlemissings(s)
+
+handlemissings(v) = v
+handlemissings(v::AbstractArray{Union{T,Missing}}) where T <: Number = replace(v, missing => NaN)
+handlemissings(v::AbstractArray{Union{T,Missing}}) where T <: AbstractString = replace(v, missing => "")
+handlemissings(s::Surface) = Surface(handlemissings(s.surf))
+handlemissings(v::Volume) = Volume(handlemissings(v.v), v.x_extents, v.y_extents, v.z_extents)
+
+# default: assume x represents a single series
+convertToAnyVector(x) = Any[prepareSeriesData(x)]
+
+# fixed number of blank series
+convertToAnyVector(n::Integer) = Any[zeros(0) for i in 1:n]
+
+# vector of data points is a single series
+convertToAnyVector(v::AVec{<:DataPoint}) = Any[prepareSeriesData(v)]
+
+# list of things (maybe other vectors, functions, or something else)
+convertToAnyVector(v::AVec) = vcat((convertToAnyVector(vi) for vi in v)...)
+
+# Matrix is split into columns
+convertToAnyVector(v::AMat{<:DataPoint}) = Any[prepareSeriesData(v[:,i]) for i in 1:size(v,2)]
+
+# --------------------------------------------------------------------
+# Fillranges & ribbons
+
+
+process_fillrange(range::Number) = [range]
+process_fillrange(range) = convertToAnyVector(range)
+
+process_ribbon(ribbon::Number) = [ribbon]
+process_ribbon(ribbon) = convertToAnyVector(ribbon)
+# ribbon as a tuple: (lower_ribbons, upper_ribbons)
+process_ribbon(ribbon::Tuple{Any,Any}) = collect(zip(convertToAnyVector(ribbon[1]),
+                                                     convertToAnyVector(ribbon[2])))
+
+
+# --------------------------------------------------------------------
+
+# TODO: can we avoid the copy here?  one error that crops up is that mapping functions over the same array
+#       result in that array being shared.  push!, etc will add too many items to that array
+
+compute_x(x::Nothing, y::Nothing, z)      = 1:size(z,1)
+compute_x(x::Nothing, y, z)            = 1:size(y,1)
+compute_x(x::Function, y, z)        = map(x, y)
+compute_x(x, y, z)                  = copy(x)
+
+# compute_y(x::Void, y::Function, z)  = error()
+compute_y(x::Nothing, y::Nothing, z)      = 1:size(z,2)
+compute_y(x, y::Function, z)        = map(y, x)
+compute_y(x, y, z)                  = copy(y)
+
+compute_z(x, y, z::Function)        = map(z, x, y)
+compute_z(x, y, z::AbstractMatrix)  = Surface(z)
+compute_z(x, y, z::Nothing)            = nothing
+compute_z(x, y, z)                  = copy(z)
+
+nobigs(v::AVec{BigFloat}) = map(Float64, v)
+nobigs(v::AVec{BigInt}) = map(Int64, v)
+nobigs(v) = v
+
+@noinline function compute_xyz(x, y, z)
+    x = compute_x(x,y,z)
+    y = compute_y(x,y,z)
+    z = compute_z(x,y,z)
+    nobigs(x), nobigs(y), nobigs(z)
+end
+
+# not allowed
+compute_xyz(x::Nothing, y::FuncOrFuncs{F}, z) where {F<:Function}       = error("If you want to plot the function `$y`, you need to define the x values!")
+compute_xyz(x::Nothing, y::Nothing, z::FuncOrFuncs{F}) where {F<:Function} = error("If you want to plot the function `$z`, you need to define x and y values!")
+compute_xyz(x::Nothing, y::Nothing, z::Nothing)        = error("x/y/z are all nothing!")
+
+# --------------------------------------------------------------------
+
+
+# we are going to build recipes to do the processing and splitting of the args
+
+# ensure we dispatch to the slicer
+struct SliceIt end
+
+# the catch-all recipes
+@recipe function f(::Type{SliceIt}, x, y, z)
+
+    # handle data with formatting attached
+    if typeof(x) <: Formatted
+        xformatter := x.formatter
+        x = x.data
+    end
+    if typeof(y) <: Formatted
+        yformatter := y.formatter
+        y = y.data
+    end
+    if typeof(z) <: Formatted
+        zformatter := z.formatter
+        z = z.data
+    end
+
+    xs = convertToAnyVector(x)
+    ys = convertToAnyVector(y)
+    zs = convertToAnyVector(z)
+
+
+    fr = pop!(plotattributes, :fillrange, nothing)
+    fillranges = process_fillrange(fr)
+    mf = length(fillranges)
+
+    rib = pop!(plotattributes, :ribbon, nothing)
+    ribbons = process_ribbon(rib)
+    mr = length(ribbons)
+
+    # @show zs
+
+    mx = length(xs)
+    my = length(ys)
+    mz = length(zs)
+    if mx > 0 && my > 0 && mz > 0
+        for i in 1:max(mx, my, mz)
+            # add a new series
+            di = copy(plotattributes)
+            xi, yi, zi = xs[mod1(i,mx)], ys[mod1(i,my)], zs[mod1(i,mz)]
+            di[:x], di[:y], di[:z] = compute_xyz(xi, yi, zi)
+
+            # handle fillrange
+            fr = fillranges[mod1(i,mf)]
+            di[:fillrange] = isa(fr, Function) ? map(fr, di[:x]) : fr
+
+            # handle ribbons
+            rib = ribbons[mod1(i,mr)]
+            di[:ribbon] = isa(rib, Function) ? map(rib, di[:x]) : rib
+
+            push!(series_list, RecipeData(di, Any[]))
+        end
+    end
+    nothing  # don't add a series for the main block
+end
+
+# this is the default "type recipe"... just pass the object through
+@recipe f(::Type{T}, v::T) where {T<:Any} = v
+
+# this should catch unhandled "series recipes" and error with a nice message
+@recipe f(::Type{V}, x, y, z) where {V<:Val} = error("The backend must not support the series type $V, and there isn't a series recipe defined.")
+
+_apply_type_recipe(plotattributes, v) = RecipesBase.apply_recipe(plotattributes, typeof(v), v)[1].args[1]
+
+# Handle type recipes when the recipe is defined on the elements.
+# This sort of recipe should return a pair of functions... one to convert to number,
+# and one to format tick values.
+function _apply_type_recipe(plotattributes, v::AbstractArray)
+    isempty(skipmissing(v)) && return Float64[]
+    x = first(skipmissing(v))
+    args = RecipesBase.apply_recipe(plotattributes, typeof(x), x)[1].args
+    if length(args) == 2 && typeof(args[1]) <: Function && typeof(args[2]) <: Function
+        numfunc, formatter = args
+        Formatted(map(numfunc, v), formatter)
+    else
+        v
+    end
+end
+
+# # special handling for Surface... need to properly unwrap and re-wrap
+# function _apply_type_recipe(plotattributes, v::Surface)
+#     T = eltype(v.surf)
+#     @show T
+#     if T <: Integer || T <: AbstractFloat
+#         v
+#     else
+#         ret = _apply_type_recipe(plotattributes, v.surf)
+#         if typeof(ret) <: Formatted
+#             Formatted(Surface(ret.data), ret.formatter)
+#         else
+#             v
+#         end
+#     end
+# end
+
+# don't do anything for ints or floats
+_apply_type_recipe(plotattributes, v::AbstractArray{T}) where {T<:Union{Integer,AbstractFloat}} = v
+
+# handle "type recipes" by converting inputs, and then either re-calling or slicing
+@recipe function f(x, y, z)
+    did_replace = false
+    newx = _apply_type_recipe(plotattributes, x)
+    x === newx || (did_replace = true)
+    newy = _apply_type_recipe(plotattributes, y)
+    y === newy || (did_replace = true)
+    newz = _apply_type_recipe(plotattributes, z)
+    z === newz || (did_replace = true)
+    if did_replace
+        newx, newy, newz
+    else
+        SliceIt, x, y, z
+    end
+end
+@recipe function f(x, y)
+    did_replace = false
+    newx = _apply_type_recipe(plotattributes, x)
+    x === newx || (did_replace = true)
+    newy = _apply_type_recipe(plotattributes, y)
+    y === newy || (did_replace = true)
+    if did_replace
+        newx, newy
+    else
+        SliceIt, x, y, nothing
+    end
+end
+@recipe function f(y)
+    newy = _apply_type_recipe(plotattributes, y)
+    if y !== newy
+        newy
+    else
+        SliceIt, nothing, y, nothing
+    end
+end
+
+# if there's more than 3 inputs, it can't be passed directly to SliceIt
+# so we'll apply_type_recipe to all of them
+@recipe function f(v1, v2, v3, v4, vrest...)
+    did_replace = false
+    newargs = map(v -> begin
+        newv = _apply_type_recipe(plotattributes, v)
+        if newv !== v
+            did_replace = true
+        end
+        newv
+    end, (v1, v2, v3, v4, vrest...))
+    if !did_replace
+        error("Couldn't process recipe args: $(map(typeof, (v1, v2, v3, v4, vrest...)))")
+    end
+    newargs
+end
+
+
+# # --------------------------------------------------------------------
+# # 1 argument
+# # --------------------------------------------------------------------
+
+# helper function to ensure relevant attributes are wrapped by Surface
+function wrap_surfaces(plotattributes::KW)
+    if haskey(plotattributes, :fill_z)
+        v = plotattributes[:fill_z]
+        if !isa(v, Surface)
+            plotattributes[:fill_z] = Surface(v)
+        end
+    end
+end
+
+@recipe f(n::Integer) = is3d(get(plotattributes,:seriestype,:path)) ? (SliceIt, n, n, n) : (SliceIt, n, n, nothing)
+
+all3D(plotattributes::KW) = trueOrAllTrue(st -> st in (:contour, :contourf, :heatmap, :surface, :wireframe, :contour3d, :image, :plots_heatmap), get(plotattributes, :seriestype, :none))
+
+# return a surface if this is a 3d plot, otherwise let it be sliced up
+@recipe function f(mat::AMat{T}) where T<:Union{Integer,AbstractFloat,Missing}
+    if all3D(plotattributes)
+        n,m = size(mat)
+        wrap_surfaces(plotattributes)
+        SliceIt, 1:m, 1:n, Surface(mat)
+    else
+        SliceIt, nothing, mat, nothing
+    end
+end
+
+# if a matrix is wrapped by Formatted, do similar logic, but wrap data with Surface
+@recipe function f(fmt::Formatted{T}) where T<:AbstractMatrix
+    if all3D(plotattributes)
+        mat = fmt.data
+        n,m = size(mat)
+        wrap_surfaces(plotattributes)
+        SliceIt, 1:m, 1:n, Formatted(Surface(mat), fmt.formatter)
+    else
+        SliceIt, nothing, fmt, nothing
+    end
+end
+
+# assume this is a Volume, so construct one
+@recipe function f(vol::AbstractArray{T,3}, args...) where T<:Union{Number,Missing}
+    seriestype := :volume
+    SliceIt, nothing, Volume(vol, args...), nothing
+end
+
+
+# # images - grays
+function clamp_greys!(mat::AMat{T}) where T<:Gray
+    for i in eachindex(mat)
+        mat[i].val < 0 && (mat[i] = Gray(0))
+        mat[i].val > 1 && (mat[i] = Gray(1))
+    end
+    mat
+end
+
+@recipe function f(mat::AMat{T}) where T<:Gray
+    n, m = size(mat)
+    if is_seriestype_supported(:image)
+        seriestype := :image
+        yflip --> true
+        SliceIt, 1:m, 1:n, Surface(clamp_greys!(mat))
+    else
+        seriestype := :heatmap
+        yflip --> true
+        cbar --> false
+        fillcolor --> ColorGradient([:black, :white])
+        SliceIt, 1:m, 1:n, Surface(clamp!(convert(Matrix{Float64}, mat), 0., 1.))
+    end
+end
+
+# # images - colors
+
+@recipe function f(mat::AMat{T}) where T<:Colorant
+	n, m = size(mat)
+
+    if is_seriestype_supported(:image)
+        seriestype := :image
+        yflip --> true
+        SliceIt, 1:m, 1:n, Surface(mat)
+    else
+        seriestype := :heatmap
+        yflip --> true
+        cbar --> false
+        z, plotattributes[:fillcolor] = replace_image_with_heatmap(mat)
+        SliceIt, 1:m, 1:n, Surface(z)
+    end
+end
+
+#
+# # plotting arbitrary shapes/polygons
+
+@recipe function f(shape::Shape)
+    seriestype --> :shape
+    coords(shape)
+end
+
+@recipe function f(shapes::AVec{Shape})
+    seriestype --> :shape
+    coords(shapes)
+end
+
+@recipe function f(shapes::AMat{Shape})
+    seriestype --> :shape
+    for j in 1:size(shapes,2)
+        @series coords(vec(shapes[:,j]))
+    end
+end
+
+# Dicts: each entry is a data point (x,y)=(key,value)
+
+@recipe f(d::AbstractDict) = collect(keys(d)), collect(values(d))
+
+# function without range... use the current range of the x-axis
+
+@recipe function f(f::FuncOrFuncs{F}) where F<:Function
+    plt = plotattributes[:plot_object]
+    xmin, xmax = try
+        axis_limits(plt[1], :x)
+    catch
+        xinv = invscalefunc(get(plotattributes, :xscale, :identity))
+        xm = tryrange(f, xinv.([-5,-1,0,0.01]))
+        xm, tryrange(f, filter(x->x>xm, xinv.([5,1,0.99, 0, -0.01])))
+    end
+
+    f, xmin, xmax
+end
+
+# try some intervals over which the function may be defined
+function tryrange(F::AbstractArray, vec)
+    rets = [tryrange(f, vec) for f in F] # get the preferred for each
+    maxind = maximum(indexin(rets, vec)) # get the last attempt that succeeded (most likely to fit all)
+    rets .= [tryrange(f, vec[maxind:maxind]) for f in F] # ensure that all functions compute there
+    rets[1]
+end
+
+function tryrange(F, vec)
+    for v in vec
+        try
+            tmp = F(v)
+            return v
+        catch
+        end
+    end
+    error("$F is not a Function, or is not defined at any of the values $vec")
+end
+#
+# # --------------------------------------------------------------------
+# # 2 arguments
+# # --------------------------------------------------------------------
+#
+#
+# # if functions come first, just swap the order (not to be confused with parametric functions...
+# # as there would be more than one function passed in)
+
+@recipe function f(f::FuncOrFuncs{F}, x) where F<:Function
+    F2 = typeof(x)
+    @assert !(F2 <: Function || (F2 <: AbstractArray && F2.parameters[1] <: Function))  # otherwise we'd hit infinite recursion here
+    x, f
+end
+
+#
+# # --------------------------------------------------------------------
+# # 3 arguments
+# # --------------------------------------------------------------------
+#
+#
+# # 3d line or scatter
+
+@recipe function f(x::AVec, y::AVec, z::AVec)
+    # st = get(plotattributes, :seriestype, :none)
+    # if st == :scatter
+    #     plotattributes[:seriestype] = :scatter3d
+    # elseif !is3d(st)
+    #     plotattributes[:seriestype] = :path3d
+    # end
+    SliceIt, x, y, z
+end
+
+@recipe function f(x::AMat, y::AMat, z::AMat)
+    # st = get(plotattributes, :seriestype, :none)
+    # if size(x) == size(y) == size(z)
+    #     if !is3d(st)
+    #         seriestype := :path3d
+    #     end
+    # end
+    wrap_surfaces(plotattributes)
+    SliceIt, x, y, z
+end
+
+#
+# # surface-like... function
+
+@recipe function f(x::AVec, y::AVec, zf::Function)
+    # x = X <: Number ? sort(x) : x
+    # y = Y <: Number ? sort(y) : y
+    wrap_surfaces(plotattributes)
+    SliceIt, x, y, Surface(zf, x, y)  # TODO: replace with SurfaceFunction when supported
+end
+
+#
+# # surface-like... matrix grid
+
+@recipe function f(x::AVec, y::AVec, z::AMat)
+    if !like_surface(get(plotattributes, :seriestype, :none))
+        plotattributes[:seriestype] = :contour
+    end
+    wrap_surfaces(plotattributes)
+    SliceIt, x, y, Surface(z)
+end
+
+# # images - grays
+
+@recipe function f(x::AVec, y::AVec, mat::AMat{T}) where T<:Gray
+    if is_seriestype_supported(:image)
+        seriestype := :image
+        yflip --> true
+        SliceIt, x, y, Surface(mat)
+    else
+        seriestype := :heatmap
+        yflip --> true
+        cbar --> false
+        fillcolor --> ColorGradient([:black, :white])
+        SliceIt, x, y, Surface(convert(Matrix{Float64}, mat))
+    end
+end
+
+# # images - colors
+
+@recipe function f(x::AVec, y::AVec, mat::AMat{T}) where T<:Colorant
+    if is_seriestype_supported(:image)
+        seriestype := :image
+        yflip --> true
+        SliceIt, x, y, Surface(mat)
+    else
+        seriestype := :heatmap
+        yflip --> true
+        cbar --> false
+        z, plotattributes[:fillcolor] = replace_image_with_heatmap(mat)
+        SliceIt, x, y, Surface(z)
+    end
+end
+
+#
+#
+# # --------------------------------------------------------------------
+# # Parametric functions
+# # --------------------------------------------------------------------
+
+#
+# # special handling... xmin/xmax with parametric function(s)
+@recipe function f(f::Function, xmin::Number, xmax::Number)
+    xscale, yscale = [get(plotattributes, sym, :identity) for sym=(:xscale,:yscale)]
+    xs = _scaled_adapted_grid(f, xscale, yscale, xmin, xmax)
+    xs, f
+end
+@recipe function f(fs::AbstractArray{F}, xmin::Number, xmax::Number) where F<:Function
+    xscale, yscale = [get(plotattributes, sym, :identity) for sym=(:xscale,:yscale)]
+    xs = Any[_scaled_adapted_grid(f, xscale, yscale, xmin, xmax) for f in fs]
+    xs, fs
+end
+@recipe f(fx::FuncOrFuncs{F}, fy::FuncOrFuncs{G}, u::AVec) where {F<:Function,G<:Function}  = mapFuncOrFuncs(fx, u), mapFuncOrFuncs(fy, u)
+@recipe f(fx::FuncOrFuncs{F}, fy::FuncOrFuncs{G}, umin::Number, umax::Number, n = 200) where {F<:Function,G<:Function} = fx, fy, range(umin, stop = umax, length = n)
+
+function _scaled_adapted_grid(f, xscale, yscale, xmin, xmax)
+    (xf, xinv), (yf, yinv) =  ((scalefunc(s),invscalefunc(s)) for s in (xscale,yscale))
+    xinv.(adapted_grid(yf∘f∘xinv, xf.((xmin, xmax))))
+end
+
+#
+# # special handling... 3D parametric function(s)
+@recipe function f(fx::FuncOrFuncs{F}, fy::FuncOrFuncs{G}, fz::FuncOrFuncs{H}, u::AVec) where {F<:Function,G<:Function,H<:Function}
+    mapFuncOrFuncs(fx, u), mapFuncOrFuncs(fy, u), mapFuncOrFuncs(fz, u)
+end
+@recipe function f(fx::FuncOrFuncs{F}, fy::FuncOrFuncs{G}, fz::FuncOrFuncs{H}, umin::Number, umax::Number, numPoints = 200) where {F<:Function,G<:Function,H<:Function}
+    fx, fy, fz, range(umin, stop = umax, length = numPoints)
+end
+
+#
+#
+# # --------------------------------------------------------------------
+# # Lists of tuples and GeometryTypes.Points
+# # --------------------------------------------------------------------
+#
+
+@recipe f(v::AVec{<:Tuple})               = unzip(v)
+@recipe f(v::AVec{<:GeometryTypes.Point}) = unzip(v)
+@recipe f(tup::Tuple)             = [tup]
+@recipe f(p::GeometryTypes.Point) = [p]
+
+# Special case for 4-tuples in :ohlc series
+@recipe f(xyuv::AVec{<:Tuple{R1,R2,R3,R4}}) where {R1,R2,R3,R4} = get(plotattributes,:seriestype,:path)==:ohlc ? OHLC[OHLC(t...) for t in xyuv] : unzip(xyuv)
+
+#
+# # --------------------------------------------------------------------
+# # handle grouping
+# # --------------------------------------------------------------------
+
+# @recipe function f(groupby::GroupBy, args...)
+#     for (i,glab) in enumerate(groupby.groupLabels)
+#         # create a new series, with the label of the group, and an idxfilter (to be applied in slice_and_dice)
+#         # TODO: use @series instead
+#         @show i, glab, groupby.groupIds[i]
+#         di = copy(plotattributes)
+#         get!(di, :label, string(glab))
+#         get!(di, :idxfilter, groupby.groupIds[i])
+#         push!(series_list, RecipeData(di, args))
+#     end
+#     nothing
+# end
+
+splittable_kw(key, val, lengthGroup) = false
+splittable_kw(key, val::AbstractArray, lengthGroup) = !(key in (:group, :color_palette)) && size(val,1) == lengthGroup
+splittable_kw(key, val::Tuple, lengthGroup) = all(splittable_kw.(key, val, lengthGroup))
+splittable_kw(key, val::SeriesAnnotations, lengthGroup) = splittable_kw(key, val.strs, lengthGroup)
+
+split_kw(key, val::AbstractArray, indices) = val[indices, fill(Colon(), ndims(val)-1)...]
+split_kw(key, val::Tuple, indices) = Tuple(split_kw(key, v, indices) for v in val)
+function split_kw(key, val::SeriesAnnotations, indices)
+    split_strs = split_kw(key, val.strs, indices)
+    return SeriesAnnotations(split_strs, val.font, val.baseshape, val.scalefactor)
+end
+
+function groupedvec2mat(x_ind, x, y::AbstractArray, groupby, def_val = y[1])
+    y_mat = Array{promote_type(eltype(y), typeof(def_val))}(undef, length(keys(x_ind)), length(groupby.groupLabels))
+    fill!(y_mat, def_val)
+    for i in 1:length(groupby.groupLabels)
+        xi = x[groupby.groupIds[i]]
+        yi = y[groupby.groupIds[i]]
+        y_mat[getindex.(Ref(x_ind), xi), i] = yi
+    end
+    return y_mat
+end
+
+groupedvec2mat(x_ind, x, y::Tuple, groupby) = Tuple(groupedvec2mat(x_ind, x, v, groupby) for v in y)
+
+group_as_matrix(t) = false
+
+# split the group into 1 series per group, and set the label and idxfilter for each
+@recipe function f(groupby::GroupBy, args...)
+    lengthGroup = maximum(union(groupby.groupIds...))
+    if !(group_as_matrix(args[1]))
+        for (i,glab) in enumerate(groupby.groupLabels)
+            @series begin
+                label     --> string(glab)
+                idxfilter --> groupby.groupIds[i]
+                for (key,val) in plotattributes
+                    if splittable_kw(key, val, lengthGroup)
+                        :($key) := split_kw(key, val, groupby.groupIds[i])
+                    end
+                end
+                args
+            end
+        end
+    else
+        g = args[1]
+        if length(g.args) == 1
+            x = zeros(Int, lengthGroup)
+            for indexes in groupby.groupIds
+                x[indexes] = 1:length(indexes)
+            end
+            last_args = g.args
+        else
+            x = g.args[1]
+            last_args = g.args[2:end]
+        end
+        x_u = unique(sort(x))
+        x_ind = Dict(zip(x_u, 1:length(x_u)))
+        for (key,val) in plotattributes
+            if splittable_kw(key, val, lengthGroup)
+                :($key) := groupedvec2mat(x_ind, x, val, groupby)
+            end
+        end
+        label --> reshape(groupby.groupLabels, 1, :)
+        typeof(g)((x_u, (groupedvec2mat(x_ind, x, arg, groupby, NaN) for arg in last_args)...))
+    end
+end

src/shorthands.jl

@@ -0,0 +1,455 @@
+"""
+    scatter(x,y)
+    scatter!(x,y)
+
+Make a scatter plot of y vs x.
+
+# Examples
+```julia-repl
+julia> scatter([1,2,3],[4,5,6],markersize=[3,4,5],markercolor=[:red,:green,:blue])
+julia> scatter([(1,4),(2,5),(3,6)])
+```
+"""
+@shorthands scatter
+
+"""
+    bar(x,y)
+    bar!(x,y)
+
+Make a bar plot of y vs x.
+
+# Arguments
+
+- $(_document_argument("bar_position"))
+- $(_document_argument("bar_width"))
+- $(_document_argument("bar_edges"))
+- $(_document_argument("orientation"))
+
+# Examples
+```julia-repl
+julia> bar([1,2,3],[4,5,6],fillcolor=[:red,:green,:blue],fillalpha=[0.2,0.4,0.6])
+julia> bar([(1,4),(2,5),(3,6)])
+```
+"""
+@shorthands bar
+
+@shorthands barh
+
+"""
+    histogram(x)
+    histogram!(x)
+
+Plot a histogram.
+
+# Arguments
+
+- `x`: AbstractVector of values to be binned
+- $(_document_argument("bins"))
+- `weights`: Vector of weights for the values in `x`, for weighted bin counts
+- $(_document_argument("normalize"))
+- $(_document_argument("bar_position"))
+- $(_document_argument("bar_width"))
+- $(_document_argument("bar_edges"))
+- $(_document_argument("orientation"))
+
+# Example
+```julia-repl
+julia> histogram([1,2,1,1,4,3,8],bins=0:8)
+```
+"""
+@shorthands histogram
+
+"""
+    barhist(x)
+    barhist!(x)
+
+Make a histogram bar plot. See `histogram`.
+"""
+@shorthands barhist
+
+"""
+    stephist(x)
+    stephist(x)
+
+Make a histogram step plot (bin counts are represented using horizontal lines
+instead of bars). See `histogram`.
+"""
+@shorthands stephist
+
+"""
+    scatterhist(x)
+    scatterhist!(x)
+
+Make a histogram scatter plot (bin counts are represented using points
+instead of bars). See `histogram`.
+"""
+@shorthands scatterhist
+
+"""
+    histogram2d(x,y)
+    histogram2d!(x,y)
+
+Plot a two-dimensional histogram.
+
+# Arguments
+
+- `bins`: Number of bins (if an `Integer`) or bin edges (if an `AbtractVector`)
+- `weights`: Vector of weights for the values in `x`. Each entry of x contributes
+             its weight to the height of its bin.
+
+# Example
+```julia-repl
+julia> histogram2d(randn(10_000),randn(10_000))
+```
+"""
+@shorthands histogram2d
+
+"""
+    density(x)
+    density!(x)
+
+Make a line plot of a kernel density estimate of x.
+
+# Arguments
+
+- `x`: AbstractVector of samples for probability density estimation
+
+# Example
+```julia-repl
+julia> using StatsPlots
+julia> density(randn(100_000))
+```
+"""
+@shorthands density
+
+"""
+    heatmap(x,y,z)
+    heatmap!(x,y,z)
+
+Plot a heatmap of the rectangular array `z`.
+
+# Example
+```julia-repl
+julia> heatmap(randn(10,10))
+```
+"""
+@shorthands heatmap
+@shorthands plots_heatmap
+
+"""
+    hexbin(x,y)
+    hexbin!(x,y)
+
+Make a hexagonal binning plot (a histogram of the observations `(x[i],y[i])`
+with hexagonal bins)
+
+# Example
+```julia-repl
+julia> hexbin(randn(10_000), randn(10_000))
+```
+"""
+@shorthands hexbin
+
+"""
+    sticks(x,y)
+    sticks!(x,y)
+
+Draw a stick plot of y vs x.
+
+# Example
+```julia-repl
+julia> sticks(1:10)
+```
+"""
+@shorthands sticks
+
+"""
+    hline(y)
+    hline!(y)
+
+Draw horizontal lines at positions specified by the values in
+the AbstractVector `y`
+
+# Example
+```julia-repl
+julia> hline([-1,0,2])
+```
+"""
+@shorthands hline
+
+"""
+    vline(x)
+    vline!(x)
+
+Draw vertical lines at positions specified by the values in
+the AbstractVector `x`
+
+# Example
+```julia-repl
+julia> vline([-1,0,2])
+```
+"""
+@shorthands vline
+
+"""
+    hspan(y)
+
+Draw a rectangle between the horizontal line at position `y[1]`
+and the horizontal line at position `y[2]`. If `length(y) ≥ 4`,
+then further rectangles are drawn between `y[3]` and `y[4]`,
+`y[5]` and `y[6]`, and so on. If `length(y)` is odd, then the
+last entry of `y` is ignored.
+# Example
+```julia-repl
+julia> hspan(1:6)
+```
+"""
+@shorthands hspan
+
+"""
+    vspan(x)
+
+Draw a rectangle between the vertical line at position `x[1]`
+and the vertical line at position `x[2]`. If `length(x) ≥ 4`,
+then further rectangles are drawn between `x[3]` and `x[4]`,
+`x[5]` and `x[6]`, and so on. If `length(x)` is odd, then the
+last entry of `x` is ignored.
+# Example
+```julia-repl
+julia> vspan(1:6)
+```
+"""
+@shorthands vspan
+
+"""
+    ohlc(x,y::Vector{OHLC})
+    ohlc!(x,y::Vector{OHLC})
+
+Make open-high-low-close plot. Each entry of y is represented by a vertical
+segment extending from the low value to the high value, with short horizontal
+segments on the left and right indicating the open and close values, respectively.
+
+# Example
+```julia-repl
+julia> meanprices = cumsum(randn(100))
+julia> y = OHLC[(p+rand(),p+1,p-1,p+rand()) for p in meanprices]
+julia> ohlc(y)
+```
+"""
+@shorthands ohlc
+
+
+"""
+    contour(x,y,z)
+    contour!(x,y,z)
+
+Draw contour lines of the `Surface` z.
+
+# Arguments
+- `levels`: Contour levels (if `AbstractVector`) or number of levels (if `Integer`)
+- `fill`: Bool. Fill area between contours or draw contours only (false by default)
+
+# Example
+```julia-repl
+julia> x = y = range(-20, 20, length = 100)
+julia> contour(x, y, (x, y) -> x^2 + y^2)
+```
+"""
+@shorthands contour
+
+"An alias for `contour` with fill = true."
+@shorthands contourf
+
+
+@shorthands contour3d
+
+"""
+    surface(x,y,z)
+    surface!(x,y,z)
+
+Draw a 3D surface plot.
+
+# Example
+```julia-repl
+julia> x = y = range(-3, 3, length = 100)
+julia> surface(x, y, (x, y) -> sinc(norm([x, y])))
+```
+"""
+@shorthands surface
+
+"""
+    wireframe(x,y,z)
+    wireframe!(x,y,z)
+
+Draw a 3D wireframe plot.
+
+# Example
+```julia-repl
+julia> wireframe(1:10,1:10,randn(10,10))
+```
+"""
+@shorthands wireframe
+
+"""
+    path3d(x,y,z)
+    path3d!(x,y,z)
+
+Plot a 3D path from `(x[1],y[1],z[1])` to `(x[2],y[2],z[2])`,
+..., to `(x[end],y[end],z[end])`.
+
+# Example
+```julia-repl
+julia> path3d([0,1,2,3],[0,1,4,9],[0,1,8,27])
+```
+"""
+@shorthands path3d
+
+"""
+    scatter3d(x,y,z)
+    scatter3d!(x,y,z)
+
+Make a 3D scatter plot.
+
+# Example
+```julia-repl
+julia> scatter3d([0,1,2,3],[0,1,4,9],[0,1,8,27])
+```
+"""
+@shorthands scatter3d
+
+"""
+    boxplot(x, y)
+    boxplot!(x, y)
+
+Make a box and whisker plot.
+
+# Keyword arguments
+- `notch`: Bool. Notch the box plot? (false)
+- `range`: Real. Values more than range*IQR below the first quartile
+           or above the third quartile are shown as outliers (1.5)
+- `outliers`: Bool. Show outliers? (true)
+- `whisker_width`: Real or Symbol. Length of whiskers (:match)
+
+# Example
+```julia-repl
+julia> using StatsPlots
+julia> boxplot(repeat([1,2,3],outer=100),randn(300))
+```
+"""
+@shorthands boxplot
+
+"""
+    violin(x,y,z)
+    violin!(x,y,z)
+
+Make a violin plot.
+
+# Example
+```julia-repl
+julia> violin(repeat([1,2,3],outer=100),randn(300))
+```
+"""
+@shorthands violin
+
+"""
+    quiver(x,y,quiver=(u,v))
+    quiver!(x,y,quiver=(u,v))
+
+Make a quiver (vector field) plot. The `i`th vector extends
+from `(x[i],y[i])` to `(x[i] + u[i], y[i] + v[i])`.
+
+# Example
+```julia-repl
+julia> quiver([1,2,3],[3,2,1],quiver=([1,1,1],[1,2,3]))
+```
+"""
+@shorthands quiver
+
+"""
+    curves(x,y)
+    curves!(x,y)
+
+Draw a Bezier curve from `(x[1],y[1])` to `(x[end],y[end])`
+with control points `(x[2],y[2]), ..., (x[end-1],y[end]-1)`
+
+# Example
+```julia-repl
+julia> curves([1,2,3,4],[1,1,2,4])
+```
+"""
+@shorthands curves
+
+"Plot a pie diagram"
+pie(args...; kw...)        = plot(args...; kw...,  seriestype = :pie, aspect_ratio = :equal, grid=false, xticks=nothing, yticks=nothing)
+pie!(args...; kw...)       = plot!(args...; kw..., seriestype = :pie, aspect_ratio = :equal, grid=false, xticks=nothing, yticks=nothing)
+
+"Plot with seriestype :path3d"
+plot3d(args...; kw...)     = plot(args...; kw...,  seriestype = :path3d)
+plot3d!(args...; kw...)    = plot!(args...; kw..., seriestype = :path3d)
+
+"Add title to an existing plot"
+title!(s::AbstractString; kw...)                 = plot!(; title = s, kw...)
+
+"Add xlabel to an existing plot"
+xlabel!(s::AbstractString; kw...)                = plot!(; xlabel = s, kw...)
+
+"Add ylabel to an existing plot"
+ylabel!(s::AbstractString; kw...)                = plot!(; ylabel = s, kw...)
+
+"Set xlims for an existing plot"
+xlims!(lims::Tuple{T,S}; kw...) where {T<:Real,S<:Real} = plot!(; xlims = lims, kw...)
+
+"Set ylims for an existing plot"
+ylims!(lims::Tuple{T,S}; kw...) where {T<:Real,S<:Real} = plot!(; ylims = lims, kw...)
+
+"Set zlims for an existing plot"
+zlims!(lims::Tuple{T,S}; kw...) where {T<:Real,S<:Real} = plot!(; zlims = lims, kw...)
+
+xlims!(xmin::Real, xmax::Real; kw...)                     = plot!(; xlims = (xmin,xmax), kw...)
+ylims!(ymin::Real, ymax::Real; kw...)                     = plot!(; ylims = (ymin,ymax), kw...)
+zlims!(zmin::Real, zmax::Real; kw...)                     = plot!(; zlims = (zmin,zmax), kw...)
+
+
+"Set xticks for an existing plot"
+xticks!(v::TicksArgs; kw...) where {T<:Real}                       = plot!(; xticks = v, kw...)
+
+"Set yticks for an existing plot"
+yticks!(v::TicksArgs; kw...) where {T<:Real}                       = plot!(; yticks = v, kw...)
+
+xticks!(
+ticks::AVec{T}, labels::AVec{S}; kw...) where {T<:Real,S<:AbstractString}     = plot!(; xticks = (ticks,labels), kw...)
+yticks!(
+ticks::AVec{T}, labels::AVec{S}; kw...) where {T<:Real,S<:AbstractString}     = plot!(; yticks = (ticks,labels), kw...)
+
+"""
+    annotate!(anns...)
+
+Add annotations to an existing plot.
+
+# Arguments
+
+- `anns`: An `AbstractVector` of tuples of the form (x,y,text). The text object
+          can be an String or PlotText
+
+# Example
+```julia-repl
+julia> plot(1:10)
+julia> annotate!([(7,3,"(7,3)"),(3,7,text("hey", 14, :left, :top, :green))])
+```
+"""
+annotate!(anns...; kw...)                                        = plot!(; annotation = anns, kw...)
+annotate!(anns::AVec{T}; kw...) where {T<:Tuple}                 = plot!(; annotation = anns, kw...)
+
+"Flip the current plots' x axis"
+xflip!(flip::Bool = true; kw...)                          = plot!(; xflip = flip, kw...)
+
+"Flip the current plots' y axis"
+yflip!(flip::Bool = true; kw...)                          = plot!(; yflip = flip, kw...)
+
+"Specify x axis attributes for an existing plot"
+xaxis!(args...; kw...)                                    = plot!(; xaxis = args, kw...)
+
+"Specify y axis attributes for an existing plot"
+yaxis!(args...; kw...)                                    = plot!(; yaxis = args, kw...)
+xgrid!(args...; kw...)                                    = plot!(; xgrid = args, kw...)
+ygrid!(args...; kw...)                                    = plot!(; ygrid = args, kw...)

src/subplot.jl

@@ -1,124 +0,0 @@
-
-
-# create a layout directly
-SubplotLayout(rowcounts::AbstractVector{Int}) = SubplotLayout(sum(rowcounts), rowcounts)
-
-# create a layout given counts... nr/nc == -1 implies we figure out a good number automatically
-function SubplotLayout(numplts::Int, nr::Int, nc::Int)
-
-  # figure out how many rows/columns we need
-  if nr == -1
-    if nc == -1
-      nr = round(Int, sqrt(numplts))
-      nc = ceil(Int, numplts / nr)
-    else
-      nr = ceil(Int, numplts / nc)
-    end
-  else
-    nc = ceil(Int, numplts / nr)
-  end
-
-  # create the rowcounts vector
-  i = 0
-  rowcounts = Int[]
-  for r in 1:nr
-    cnt = min(nc, numplts - i)
-    push!(rowcounts, cnt)
-    i += cnt
-  end
-
-  SubplotLayout(numplts, rowcounts)
-end
-
-
-Base.length(layout::SubplotLayout) = layout.numplts
-
-
-# ------------------------------------------------------------
-
-
-Base.string(subplt::Subplot) = "Subplot{$(subplt.plotter) p=$(subplt.p) n=$(subplt.n)}"
-Base.print(io::IO, subplt::Subplot) = print(io, string(subplt))
-Base.show(io::IO, subplt::Subplot) = print(io, string(subplt))
-
-getplot(subplt::Subplot) = subplt.plts[mod1(subplt.n, subplt.p)]
-
-# ------------------------------------------------------------
-
-
-doc"""
-Create a series of plots:
-```
-  y = rand(100,3)
-  subplot(y; n = 3)             # create an automatic grid, and let it figure out the nr/nc... will put plots 1 and 2 on the first row, and plot 3 by itself on the 2nd row
-  subplot(y; n = 3, nr = 1)     # create an automatic grid, but fix the number of rows to 1 (so there are n columns)
-  subplot(y; n = 3, nc = 1)     # create an automatic grid, but fix the number of columns to 1 (so there are n rows)
-  subplot(y; layout = [1, 2])   # explicit layout by row... plot #1 goes by itself in the first row, plots 2 and 3 split the 2nd row (note the n kw is unnecessary)
-```
-"""
-function subplot(args...; kw...)
-  d = Dict(kw)
-
-  # figure out the layout
-  if haskey(d, :layout)
-    layout = SubplotLayout(d[:layout])
-  else
-    if !haskey(d, :n)
-      error("You must specify either layout or n when creating a subplot: ", d)
-    end
-    layout = SubplotLayout(d[:n], get(d, :nr, -1), get(d, :nc, -1))
-  end
-
-  # initialize the individual plots
-  pkg = plotter()
-  kw0 = getPlotKeywordArgs(kw, 1, 0)
-  plts = Plot[plot(pkg; kw0..., show=false) for i in 1:length(layout)]
-
-  # create the object and do the plotting
-  subplt = Subplot(nothing, plts, pkg, length(layout), 0, layout)
-  subplot!(subplt, args...; kw...)
-
-  subplt
-end
-
-doc"""
-Adds to a subplot.
-"""
-
-# current subplot
-function subplot!(args...; kw...)
-  subplot!(currentPlot(), args...; kw...)
-end
-
-
-# not allowed:
-function subplot!(plt::Plot, args...; kw...)
-  error("Can't call subplot! on a Plot!")
-end
-
-
-# # this adds to a specific subplot... most plot commands will flow through here
-function subplot!(subplt::Subplot, args...; kw...)
-  kwList = createKWargsList(subplt, args...; kw...)
-  for (i,d) in enumerate(kwList)
-    subplt.n += 1
-    plt = getplot(subplt)  # get the Plot object where this series will be drawn
-    plot!(plt; d...)
-  end
-
-  # create the underlying object (each backend will do this differently)
-  buildSubplotObject!(subplt.plotter, subplt)
-
-  # set this to be current
-  currentPlot!(subplt)
-
-  # do we want to show it?
-  d = Dict(kw)
-  if haskey(d, :show) && d[:show]
-    draw(subplt)
-  end
-
-  subplt
-end
-
-

src/subplots.jl

@@ -0,0 +1,53 @@
+
+
+function Subplot(::T; parent = RootLayout()) where T<:AbstractBackend
+    Subplot{T}(
+        parent,
+        Series[],
+        (20mm, 5mm, 2mm, 10mm),
+        defaultbox,
+        defaultbox,
+        KW(),
+        nothing,
+        nothing
+    )
+end
+
+"""
+    plotarea(subplot)
+
+Return the bounding box of a subplot
+"""
+plotarea(sp::Subplot) = sp.plotarea
+plotarea!(sp::Subplot, bbox::BoundingBox) = (sp.plotarea = bbox)
+
+
+Base.size(sp::Subplot) = (1,1)
+Base.length(sp::Subplot) = 1
+Base.getindex(sp::Subplot, r::Int, c::Int) = sp
+
+leftpad(sp::Subplot)   = sp.minpad[1]
+toppad(sp::Subplot)    = sp.minpad[2]
+rightpad(sp::Subplot)  = sp.minpad[3]
+bottompad(sp::Subplot) = sp.minpad[4]
+
+get_subplot(plt::Plot, sp::Subplot) = sp
+get_subplot(plt::Plot, i::Integer) = plt.subplots[i]
+get_subplot(plt::Plot, k) = plt.spmap[k]
+get_subplot(series::Series) = series.plotattributes[:subplot]
+
+get_subplot_index(plt::Plot, idx::Integer) = Int(idx)
+get_subplot_index(plt::Plot, sp::Subplot) = findfirst(x -> x === sp, plt.subplots)
+
+series_list(sp::Subplot) = sp.series_list # filter(series -> series.plotattributes[:subplot] === sp, sp.plt.series_list)
+
+function should_add_to_legend(series::Series)
+    series.plotattributes[:primary] && series.plotattributes[:label] != "" &&
+        !(series.plotattributes[:seriestype] in (
+            :hexbin,:bins2d,:histogram2d,:hline,:vline,
+            :contour,:contourf,:contour3d,:surface,:wireframe,
+            :heatmap, :pie, :image
+        ))
+end
+
+# ----------------------------------------------------------------------

src/themes.jl

@@ -0,0 +1,168 @@
+"""
+    theme(s::Symbol)
+
+Specify the colour theme for plots.
+"""
+function theme(s::Symbol; kw...)
+    defaults = _get_defaults(s)
+    _theme(s, defaults; kw...)
+end
+
+function _get_defaults(s::Symbol)
+    thm = PlotThemes._themes[s]
+    if :defaults in fieldnames(typeof(thm))
+        return thm.defaults
+    else # old PlotTheme type
+        defaults = KW(
+            :bg       => thm.bg_secondary,
+            :bginside => thm.bg_primary,
+            :fg       => thm.lines,
+            :fgtext   => thm.text,
+            :fgguide  => thm.text,
+            :fglegend => thm.text,
+            :palette  => thm.palette,
+        )
+        if thm.gradient !== nothing
+            push!(defaults, :gradient => thm.gradient)
+        end
+        return defaults
+    end
+end
+
+function _theme(s::Symbol, defaults::KW; kw...)
+    # Reset to defaults to overwrite active theme
+    reset_defaults()
+
+    # Set the theme's gradient as default
+    if haskey(defaults, :gradient)
+        PlotUtils.clibrary(:misc)
+        PlotUtils.default_cgrad(default = :sequential, sequential = PlotThemes.gradient_name(s))
+    else
+        PlotUtils.clibrary(:Plots)
+        PlotUtils.default_cgrad(default = :sequential, sequential = :inferno)
+    end
+
+    # maybe overwrite the theme's gradient
+    kw = KW(kw)
+    if haskey(kw, :gradient)
+        kwgrad = pop!(kw, :gradient)
+        for clib in clibraries()
+            if kwgrad in cgradients(clib)
+                PlotUtils.clibrary(clib)
+                PlotUtils.default_cgrad(default = :sequential, sequential = kwgrad)
+                break
+            end
+        end
+    end
+
+    # Set the theme's defaults
+    default(; defaults..., kw...)
+    return
+end
+
+@deprecate set_theme(s) theme(s)
+
+@userplot ShowTheme
+
+_color_functions = KW(
+    :protanopic => protanopic,
+    :deuteranopic => deuteranopic,
+    :tritanopic => tritanopic,
+)
+_get_showtheme_args(thm::Symbol) = thm, identity
+_get_showtheme_args(thm::Symbol, func::Symbol) = thm, get(_color_functions, func, identity)
+
+@recipe function showtheme(st::ShowTheme)
+    thm, cfunc = _get_showtheme_args(st.args...)
+    defaults = _get_defaults(thm)
+
+    # get the gradient
+    gradient_colors = get(defaults, :gradient, cgrad(:inferno).colors)
+    gradient = cgrad(cfunc.(RGB.(gradient_colors)))
+
+    # get the palette
+    palette = get(defaults, :palette, get_color_palette(:auto, plot_color(:white), 17))
+    palette = cfunc.(RGB.(palette))
+
+    # apply the theme
+    for k in keys(defaults)
+        k in (:gradient, :palette) && continue
+        def = defaults[k]
+        arg = get(_keyAliases, k, k)
+        plotattributes[arg] = if typeof(def) <: Colorant
+            cfunc(RGB(def))
+        elseif eltype(def) <: Colorant
+            cfunc.(RGB.(def))
+        elseif occursin("color", string(arg))
+            cfunc.(RGB.(plot_color.(def)))
+        else
+            def
+        end
+    end
+
+    Random.seed!(1)
+
+    label := ""
+    colorbar := false
+    layout := (2, 3)
+
+    for j in 1:4
+        @series begin
+            subplot := 1
+            palette := palette
+            seriestype := :path
+            cumsum(randn(50))
+        end
+
+        @series begin
+            subplot := 2
+            seriestype := :scatter
+            palette := palette
+            marker := (:circle, :diamond, :star5, :square)[j]
+            randn(10), randn(10)
+        end
+    end
+
+    @series begin
+        subplot := 3
+        seriestype := :histogram
+        palette := palette
+        randn(1000) .+ (0:2:4)'
+    end
+
+    f(r) = sin(r) / r
+    _norm(x, y) = norm([x, y])
+    x = y = range(-3π, stop = 3π, length = 30)
+    z = f.(_norm.(x, y'))
+    wi = 2:3:30
+
+    @series begin
+        subplot := 4
+        seriestype := :heatmap
+        seriescolor := gradient
+        ticks := -5:5:5
+        x, y, z
+    end
+
+    @series begin
+        subplot := 5
+        seriestype := :surface
+        seriescolor := gradient
+        x, y, z
+    end
+
+    n = 100
+    ts = range(0, stop = 10π, length = n)
+    x = ts .* cos.(ts)
+    y = (0.1ts) .* sin.(ts)
+    z = 1:n
+
+    @series begin
+        subplot := 6
+        seriescolor := gradient
+        linewidth := 3
+        line_z := z
+        x, y, z
+    end
+
+end

src/types.jl

@@ -1,28 +1,100 @@
 
-typealias AVec AbstractVector
-typealias AMat AbstractMatrix
+# TODO: I declare lots of types here because of the lacking ability to do forward declarations in current Julia
+# I should move these to the relevant files when something like "extern" is implemented
 
-abstract PlottingObject
-abstract PlottingPackage
+const AVec = AbstractVector
+const AMat = AbstractMatrix
+const KW = Dict{Symbol,Any}
+const TicksArgs = Union{AVec{T}, Tuple{AVec{T}, AVec{S}}, Symbol} where {T<:Real, S<:AbstractString}
 
-type Plot <: PlottingObject
-  o  # the underlying object
-  plotter::PlottingPackage
-  n::Int # number of series
+struct PlotsDisplay <: AbstractDisplay end
+
+# -----------------------------------------------------------
+
+struct InputWrapper{T}
+    obj::T
+end
+wrap(obj::T) where {T} = InputWrapper{T}(obj)
+Base.isempty(wrapper::InputWrapper) = false
+
+
+# -----------------------------------------------------------
+
+mutable struct Series
+    plotattributes::KW
 end
 
+attr(series::Series, k::Symbol) = series.plotattributes[k]
+attr!(series::Series, v, k::Symbol) = (series.plotattributes[k] = v)
 
-type SubplotLayout
-  numplts::Int
-  rowcounts::AbstractVector{Int}
+# -----------------------------------------------------------
+
+# a single subplot
+mutable struct Subplot{T<:AbstractBackend} <: AbstractLayout
+    parent
+    series_list::Vector{Series}  # arguments for each series
+    minpad::Tuple{AbsoluteLength,AbsoluteLength,AbsoluteLength,AbsoluteLength} # leftpad, toppad, rightpad, bottompad
+    bbox#::BoundingBox  # the canvas area which is available to this subplot
+    plotarea#::BoundingBox  # the part where the data goes
+    attr::KW  # args specific to this subplot
+    o  # can store backend-specific data... like a pyplot ax
+    plt  # the enclosing Plot object (can't give it a type because of no forward declarations)
 end
 
+Base.show(io::IO, sp::Subplot) = print(io, "Subplot{$(sp[:subplot_index])}")
 
-type Subplot <: PlottingObject
-  o                           # the underlying object
-  plts::Vector{Plot}          # the individual plots
-  plotter::PlottingPackage
-  p::Int                      # number of plots
-  n::Int                      # number of series
-  layout::SubplotLayout
-end
+# -----------------------------------------------------------
+
+# simple wrapper around a KW so we can hold all attributes pertaining to the axis in one place
+mutable struct Axis
+    sps::Vector{Subplot}
+    plotattributes::KW
+end
+
+mutable struct Extrema
+    emin::Float64
+    emax::Float64
+end
+Extrema() = Extrema(Inf, -Inf)
+
+# -----------------------------------------------------------
+
+
+mutable struct Plot{T<:AbstractBackend} <: AbstractPlot{T}
+    backend::T                   # the backend type
+    n::Int                       # number of series
+    attr::KW                     # arguments for the whole plot
+    user_attr::KW                # raw arg inputs (after aliases).  these are used as the input dict in `_plot!`
+    series_list::Vector{Series}  # arguments for each series
+    o                            # the backend's plot object
+    subplots::Vector{Subplot{T}}
+    spmap::KW            # provide any label as a map to a subplot
+    layout
+    inset_subplots::Vector{Subplot{T}}  # list of inset subplots
+    init::Bool
+end
+
+function Plot(_backend = CURRENT_BACKEND)
+    Plot(_backend.pkg, 0, KW(), KW(), Series[], nothing,
+         Subplot{typeof(_backend.pkg)}[], KW(), EmptyLayout(),
+         Subplot{typeof(_backend.pkg)}[], false)
+end
+
+# -----------------------------------------------------------------------
+
+Base.getindex(plt::Plot, i::Integer) = plt.subplots[i]
+Base.length(plt::Plot) = length(plt.subplots)
+Base.lastindex(plt::Plot) = length(plt)
+
+Base.getindex(plt::Plot, r::Integer, c::Integer) = plt.layout[r,c]
+Base.size(plt::Plot) = size(plt.layout)
+Base.size(plt::Plot, i::Integer) = size(plt.layout)[i]
+Base.ndims(plt::Plot) = 2
+
+# attr(plt::Plot, k::Symbol) = plt.attr[k]
+# attr!(plt::Plot, v, k::Symbol) = (plt.attr[k] = v)
+
+Base.getindex(sp::Subplot, i::Integer) = series_list(sp)[i]
+Base.lastindex(sp::Subplot) = length(series_list(sp))
+
+# -----------------------------------------------------------------------

test/.gitignore

@@ -0,0 +1 @@
+reference_images

test/imgcomp.jl

@@ -0,0 +1,105 @@
+import Plots._current_plots_version
+
+# Taken from MakieGallery
+"""
+Downloads the reference images from ReferenceImages for a specific version
+"""
+function download_reference(version = v"0.0.1")
+    download_dir = abspath(@__DIR__, "reference_images")
+    isdir(download_dir) || mkpath(download_dir)
+    tarfile = joinpath(download_dir, "reference_images.zip")
+    url = "https://github.com/JuliaPlots/PlotReferenceImages.jl/archive/v$(version).tar.gz"
+    refpath = joinpath(download_dir, "PlotReferenceImages.jl-$(version)")
+    if !isdir(refpath) # if not yet downloaded
+        @info "downloading reference images for version $version"
+        download(url, tarfile)
+        BinaryProvider.unpack(tarfile, download_dir)
+        # check again after download
+        if !isdir(refpath)
+            error("Something went wrong while downloading reference images. Plots can't be compared to references")
+        else
+            rm(tarfile, force = true)
+        end
+    else
+        @info "using reference images for version $version (already downloaded)"
+    end
+    refpath
+end
+
+const ref_image_dir = download_reference()
+
+function image_comparison_tests(pkg::Symbol, idx::Int; debug = false, popup = isinteractive(), sigma = [1,1], tol = 1e-2)
+    Plots._debugMode.on = debug
+    example = Plots._examples[idx]
+    Plots.theme(:default)
+    @info("Testing plot: $pkg:$idx:$(example.header)")
+    backend(pkg)
+    backend()
+    default(size=(500,300))
+    # ensure consistent results
+    Random.seed!(1234)
+
+    # reference image directory setup
+    refdir = joinpath(ref_image_dir, "Plots", string(pkg))
+    fn = "ref$idx.png"
+
+    # firgure out version info
+    vns = filter(x->x[1] != '.', readdir(refdir))
+    versions = sort(VersionNumber.(vns), rev = true)
+    versions = filter(v -> v <= _current_plots_version, versions)
+    # @show refdir fn versions
+
+    newdir = joinpath(refdir, string(_current_plots_version))
+    newfn = joinpath(newdir, fn)
+
+    # figure out which reference file we should compare to, by finding the highest versioned file
+    reffn = nothing
+    for v in versions
+        tmpfn = joinpath(refdir, string(v), fn)
+        if isfile(tmpfn)
+            reffn = tmpfn
+            break
+        end
+    end
+
+    # now we have the fn (if any)... do the comparison
+    # @show reffn
+    if reffn === nothing
+        reffn = newfn
+    end
+    # @show reffn
+    # return
+
+    # test function
+    func = (fn, idx) -> begin
+        expr = Expr(:block)
+        append!(expr.args, example.exprs)
+        eval(expr)
+        png(fn)
+    end
+
+    # try
+    #     run(`mkdir -p $newdir`)
+    # catch err
+    #     display(err)
+    # end
+    # # reffn = joinpath(refdir, "ref$idx.png")
+
+    # the test
+    vtest = VisualTest(func, reffn, idx)
+    test_images(vtest, popup=popup, sigma=sigma, tol=tol, newfn = newfn)
+end
+
+function image_comparison_facts(pkg::Symbol;
+                                skip = [],      # skip these examples (int index)
+                                only = nothing, # limit to these examples (int index)
+                                debug = false,  # print debug information?
+                                sigma = [1,1],  # number of pixels to "blur"
+                                tol = 1e-2)     # acceptable error (percent)
+  for i in 1:length(Plots._examples)
+    i in skip && continue
+    if only === nothing || i in only
+      @test image_comparison_tests(pkg, i, debug=debug, sigma=sigma, tol=tol) |> success == true
+    end
+  end
+end

test/install_wkhtmltoimage.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+set -ex
+
+# sudo add-apt-repository -y ppa:pov/wkhtmltopdf
+sudo apt-get -qq update
+# sudo apt-get install -y wkhtmltopdf
+
+sudo apt-get install -y xfonts-75dpi xfonts-base
+wget https://github.com/wkhtmltopdf/wkhtmltopdf/releases/download/0.12.2.1/wkhtmltox-0.12.2.1_linux-precise-amd64.deb
+sudo dpkg -i wkhtmltox-0.12.2.1_linux-precise-amd64.deb
+# wget http://download.gna.org/wkhtmltopdf/0.12/0.12.2/wkhtmltox-0.12.2_linux-trusty-amd64.deb
+# sudo dpkg -i wkhtmltox-0.12.2_linux-trusty-amd64.deb
+wkhtmltoimage http://www.google.com test.png
+ls
+
+wkhtmltopdf -V
+wkhtmltoimage -V
+
+# echo 'exec xvfb-run -a -s "-screen 0 640x480x16" wkhtmltoimage "$@"' | sudo tee /usr/local/bin/wkhtmltoimage.sh >/dev/null
+# sudo chmod a+x /usr/local/bin/wkhtmltoimage.sh
+
+# export DISPLAY=:99.0
+# sh -e /etc/init.d/xvfb start
+# sleep 3 # give xvfb some time to start

test/runtests.jl

@@ -1,78 +1,102 @@
-module PlotsTests
-
+using VisualRegressionTests
 using Plots
-using FactCheck
+using Random
+using BinaryProvider
+using Test
+using FileIO
+using GeometryTypes
 
+include("imgcomp.jl")
 # don't actually show the plots
-plotDefault!(:show, false)
+Random.seed!(1234)
+default(show=false, reuse=true)
+img_tol = isinteractive() ? 1e-2 : 10e-2
 
+@testset "GR" begin
+    ENV["PLOTS_TEST"] = "true"
+    ENV["GKSwstype"] = "100"
+    @test gr() == Plots.GRBackend()
+    @test backend() == Plots.GRBackend()
 
-# note: we wrap in a try block so that the tests only run if we have the backend installed
-try
-  Pkg.installed("Gadfly")
-  facts("Gadfly") do
-    @fact plotter!(:gadfly) --> Plots.GadflyPackage()
-    @fact plotter() --> Plots.GadflyPackage()
-    @fact typeof(plot(1:10)) --> Plot
-
-
-    # plot(x::AVec, y::AVec; kw...)              # one line (will assert length(x) == length(y))
-    @fact plot(Int[1,2,3], rand(3)) --> not(nothing)
-    @fact_throws plot(1:5, 1:4)
-
-    # plot(x::AVec, y::AMat; kw...)              # multiple lines (one per column of x), all sharing x (will assert length(x) == size(y,1))
-    @fact plot(sort(rand(10)), rand(Int, 10, 3)) --> not(nothing)
-    @fact_throws(plot!(rand(10), rand(9,2)))
-
-    # plot(x::AMat, y::AMat; kw...)              # multiple lines (one per column of x/y... will assert size(x) == size(y))
-    @fact plot!(rand(10,3), rand(10,3)) --> not(nothing)
-    @fact_throws plot!(rand(10,3), rand(10,2))
-
-
-    # plot(x::AVec, y::AVec{AVec}; kw...)        # multiple lines, will assert length(x) == length(y[i])
-
-
-    # plot(x::AVec{AVec}, y::AVec{AVec}; kw...)  # multiple lines, will assert length(x[i]) == length(y[i])
-    # plot(n::Integer; kw...)                    # n lines, all empty (for updating plots)
-  end
-end
-
-# note: we wrap in a try block so that the tests only run if we have the backend installed
-try
-  Pkg.installed("Qwt")
-  facts("Qwt") do
-    @fact plotter!(:qwt) --> Plots.QwtPackage()
-    @fact plotter() --> Plots.QwtPackage()
-    @fact typeof(plot(1:10)) --> Plot
-
-    # plot(y::AVec; kw...)                       # one line... x = 1:length(y)
-    @fact plot(1:10) --> not(nothing)
-    @fact length(currentPlot().o.lines) --> 1
-
-    # plot(x::AVec, f::Function; kw...)          # one line, y = f(x)
-    @fact plot(1:10, sin) --> not(nothing)
-    @fact currentPlot().o.lines[1].y --> sin(collect(1:10))
-
-    # plot(x::AMat, f::Function; kw...)          # multiple lines, yᵢⱼ = f(xᵢⱼ)
-    @fact plot(rand(10,2), sin) --> not(nothing)
-    @fact length(currentPlot().o.lines) --> 2
-
-    # plot(y::AMat; kw...)                       # multiple lines (one per column of x), all sharing x = 1:size(y,1)
-    @fact plot!(rand(10,2)) --> not(nothing)
-    @fact length(currentPlot().o.lines) --> 4
-
-    # plot(x::AVec, fs::AVec{Function}; kw...)   # multiple lines, yᵢⱼ = fⱼ(xᵢ)
-    @fact plot(1:10, Function[sin,cos]) --> not(nothing)
-    @fact currentPlot().o.lines[1].y --> sin(collect(1:10))
-    @fact currentPlot().o.lines[2].y --> cos(collect(1:10))
-
-    # plot(y::AVec{AVec}; kw...)                 # multiple lines, each with x = 1:length(y[i])
-    @fact plot([11:20 ; rand(10)]) --> not(nothing)
-    @fact currentPlot().o.lines[1].x[4] --> 4
-    @fact currentPlot().o.lines[1].y[4] --> 14
-  end
+    @static if Sys.islinux()
+        image_comparison_facts(:gr, tol=img_tol, skip = [25, 30])
+    end
 end
 
 
-FactCheck.exitstatus()
-end # module
+@testset "UnicodePlots" begin
+    @test unicodeplots() == Plots.UnicodePlotsBackend()
+    @test backend() == Plots.UnicodePlotsBackend()
+
+    # lets just make sure it runs without error
+    p = plot(rand(10))
+    @test isa(p, Plots.Plot) == true
+    @test isa(display(p), Nothing) == true
+    p = bar(randn(10))
+    @test isa(p, Plots.Plot) == true
+    @test isa(display(p), Nothing) == true
+end
+
+@testset "Axes" begin
+    p = plot()
+    axis = p.subplots[1][:xaxis]
+    @test typeof(axis) == Plots.Axis
+    @test Plots.discrete_value!(axis, "HI") == (0.5, 1)
+    @test Plots.discrete_value!(axis, :yo) == (1.5, 2)
+    @test Plots.ignorenan_extrema(axis) == (0.5,1.5)
+    @test axis[:discrete_map] == Dict{Any,Any}(:yo  => 2, "HI" => 1)
+
+    Plots.discrete_value!(axis, ["x$i" for i=1:5])
+    Plots.discrete_value!(axis, ["x$i" for i=0:2])
+    @test Plots.ignorenan_extrema(axis) == (0.5, 7.5)
+end
+
+@testset "NoFail" begin
+    plots = [histogram([1, 0, 0, 0, 0, 0]),
+             plot([missing]),
+             plot([missing; 1:4]),
+             plot([fill(missing,10); 1:4]),
+             plot([1 1; 1 missing]),
+             plot(["a" "b"; missing "d"], [1 2; 3 4])]
+    for plt in plots
+        display(plt)
+    end
+end
+
+@testset "EmptyAnim" begin
+    anim = @animate for i in []
+    end
+
+    @test_throws ArgumentError gif(anim)
+end
+
+@testset "Segments" begin
+    function segments(args...)
+        segs = UnitRange{Int}[]
+        for seg in iter_segments(args...)
+            push!(segs,seg)
+        end
+        segs
+    end
+
+    nan10 = fill(NaN,10)
+    @test segments(11:20) == [1:10]
+    @test segments([NaN]) == []
+    @test segments(nan10) == []
+    @test segments([nan10; 1:5]) == [11:15]
+    @test segments([1:5;nan10]) == [1:5]
+    @test segments([nan10; 1:5; nan10; 1:5; nan10]) == [11:15, 26:30]
+    @test segments([NaN; 1], 1:10) == [2:2, 4:4, 6:6, 8:8, 10:10]
+    @test segments([nan10; 1:15], [1:15; nan10]) == [11:15]
+end
+
+@testset "Utils" begin
+    zipped = ([(1,2)], [("a","b")], [(1,"a"),(2,"b")],
+              [(1,2),(3,4)], [(1,2,3),(3,4,5)], [(1,2,3,4),(3,4,5,6)],
+              [(1,2.0),(missing,missing)], [(1,missing),(missing,"a")],
+              [(missing,missing)], [(missing,missing,missing),("a","b","c")])
+    for z in zipped
+        @test isequal(collect(zip(Plots.unzip(z)...)), z)
+        @test isequal(collect(zip(Plots.unzip(Point.(z))...)), z)
+    end
+end

test/test_plottypes.jl

@@ -1,21 +0,0 @@
-
-
-function testplot_line1()
-  plot(rand(100,3))
-end
-
-function testplot_fn1()
-  plot(0:0.01:4π, [sin,cos])
-end
-
-function testplot_guides1()
-  plot(rand(10); title="TITLE", xlabel="XLABEL", ylabel="YLABEL", background_color=:red)
-end
-
-function testplot_points1()
-  plot(Vector[rand(10), rand(20)]; marker=:ellipse, markersize=8)
-end
-
-function testplot_points2()
-  plot(Vector[rand(10), rand(20)]; marker=:ellipse, markersize=8, markercolors=[:red,:blue])
-end