Merge pull request #2090 from daschw/areaplot

add areaplot recipe (close #1423)
up version
2019-07-04 13:45:52 +02:00 · 2019-07-04 12:55:02 +02:00 · 2019-07-04 12:53:01 +02:00 · 2019-07-04 12:48:47 +02:00 · 2019-07-04 11:36:08 +02:00 · 2019-07-04 11:31:00 +02:00
60 changed files with 11452 additions and 8448 deletions
@@ -5,3 +5,6 @@
 examples/.ipynb_checkpoints/*
 examples/meetup/.ipynb_checkpoints/*
 deps/plotly-latest.min.js
+deps/build.log
+deps/deps.jl
+Manifest.toml
@@ -2,59 +2,19 @@
 language: julia
 os:
  - linux
-  - osx
+  # - osx
 julia:
-  - release
+  - 1.1
  - nightly
+  
 matrix:
  allow_failures:
    - julia: nightly

-# # before install:
-# #   - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew update          ; fi
-# #   - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew install wkhtmltopdf; fi
-
-# ref: http://askubuntu.com/a/556672 for the wkhtmltopdf apt repository info
-
 sudo: required
 before_install:
  - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then pwd ; fi
  - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then ./test/install_wkhtmltoimage.sh ; fi
-#   - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then  sudo add-apt-repository -y ppa:pov/wkhtmltopdf  ; fi
-#   - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then  sudo apt-get -qq update                      ; fi
-#   - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then  sudo apt-get install -y wkhtmltopdf          ; fi
-#   - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then  wkhtmltopdf -V                               ; fi
-#   - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then  wkhtmltoimage -V                             ; fi
-#   echo 'exec xvfb-run -a -s "-screen 0 640x480x16" wkhtmltopdf "$@"' | sudo tee /usr/local/bin/wkhtmltopdf.sh >/dev/null
-# sudo chmod a+x /usr/local/bin/wkhtmltopdf.sh
-
-# # borrowed from Blink.jl's travis file
-# matrix:
-#   include:
-#     - os: linux
-#       julia: 0.4
-#       env: TESTCMD="xvfb-run julia"
-#     - os: osx
-#       julia: 0.4
-#       env: TESTCMD="julia"
-
-

 notifications:
  email: true
-# 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")'
- - julia test/travis_commands.jl
- # - julia -e 'Pkg.clone("ImageMagick"); Pkg.build("ImageMagick")'
- # - julia -e 'Pkg.clone("GR"); Pkg.build("GR")'
- # # - julia -e 'Pkg.clone("https://github.com/tbreloff/ImageMagick.jl.git"); Pkg.checkout("ImageMagick","tb_write"); Pkg.build("ImageMagick")'
- # - julia -e 'Pkg.clone("https://github.com/tbreloff/ExamplePlots.jl.git");'
- # # - julia -e 'Pkg.clone("https://github.com/JunoLab/Blink.jl.git"); Pkg.build("Blink"); import Blink; Blink.AtomShell.install()'
- # # - julia -e 'Pkg.clone("https://github.com/spencerlyon2/PlotlyJS.jl.git")'
- # - julia -e 'ENV["PYTHON"] = ""; Pkg.add("PyPlot"); Pkg.build("PyPlot")'
- #
- # # - $TESTCMD -e 'Pkg.test("Plots"; coverage=false)'
- # - julia -e 'Pkg.test("Plots"; coverage=false)'
- # # - julia -e 'cd(Pkg.dir("Plots")); Pkg.add("Coverage"); using Coverage; Coveralls.submit(process_folder()); Codecov.submit(process_folder())'
@@ -3,11 +3,556 @@

 #### notes on release changes, ongoing development, and future planned work

- All new development should target 0.7!
+- 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.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.7 (current master/dev)
+## 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

@@ -79,7 +624,7 @@

 #### 0.7.0

- Check out [the summary](http://plots.readthedocs.io/en/latest/plots_v0.7/)
+- 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)
@@ -157,7 +702,7 @@
 - z-axis keywords
 - 3D indexing overhaul: `push!`, `append!` support
 - matplotlib colormap constants (`:inferno` is the new default colormap for Plots)
- `typealias KW Dict{Symbol,Any}` used in place of splatting in many places
+- `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
@@ -211,7 +756,7 @@
 - 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://plots.readthedocs.org/
+- 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
@@ -0,0 +1,56 @@
+name = "Plots"
+uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
+author = ["Tom Breloff (@tbreloff)"]
+version = "0.25.3"
+
+[deps]
+Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
+Contour = "d38c429a-6771-53c6-b99e-75d170b6e991"
+Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
+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"]
@@ -1,33 +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) -->

-#### Author: Thomas Breloff (@tbreloff)
+#### Created by Tom Breloff (@tbreloff)
+
+#### Maintained by the [JuliaPlot members](https://github.com/orgs/JuliaPlots/people)

 Plots is a plotting API and toolset.  My goals with the package are:

 - **Powerful**.  Do more with less.  Complex visualizations become easy.
- **Intuitive**.  Start generating plots without reading volumes of documentation.  Commands should "just work".
+- **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 and access the strengths of all [backends](http://plots.readthedocs.io/en/latest/backends/).
- **Lightweight**.  Very few dependencies, since backends are loaded and initialized dynamically.
-
-Use the [preprocessing pipeline](http://plots.readthedocs.io/en/latest/pipeline/) in Plots to fully describe your visualization before it calls the backend code.  This maintains modularity and allows for efficient separation of front end code, algorithms, and backend graphics.  New graphical backends can be added with minimal effort.
-
-```julia
-using Plots
-@gif for i in linspace(0,2π,100)
-    X = Y = linspace(-5,5,40)
-    surface(X, Y, (x,y) -> sin(x+10sin(i))+cos(y))
-end
-```
-
-![waves](http://plots.readthedocs.io/en/latest/examples/img/waves.gif)
-
-View the [full documentation](http://plots.readthedocs.io).
+- **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.
@@ -1,8 +0,0 @@
-julia 0.4
-
-RecipesBase
-Colors
-Reexport
-Compat
-FixedSizeArrays
-Measures
@@ -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%"
@@ -1,8 +1,18 @@

 #TODO: download https://cdn.plot.ly/plotly-latest.min.js to deps/ if it doesn't exist
-
-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)
+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
@@ -1,45 +1,53 @@
-
- __precompile__()
-
 module Plots

-using Compat
+_current_plots_version = v"0.25.0"
+
 using Reexport
-@reexport using Colors
-# using Requires
-using FixedSizeArrays
+
+import GeometryTypes
+using Dates, Printf, Statistics, Base64, LinearAlgebra, Random
+import SparseArrays: findnz
+
@reexport using RecipesBase
+import RecipesBase: plot, plot!, animate
 using Base.Meta
-# using PlotUtils
+@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
-    AbstractPlot,
-    Plot,
-    Subplot,
-    AbstractLayout,
-    GridLayout,
    grid,
-    EmptyLayout,
    bbox,
    plotarea,
    @layout,
-    AVec,
-    AMat,
    KW,

    wrap,
-    set_theme,
-    add_theme,
+    theme,

    plot,
    plot!,
+    attr!,

    current,
    default,
    with,
-
-    @userplot,
-    @shorthands,
+    twinx,

    pie,
    pie!,
@@ -59,199 +67,157 @@ export
    yflip!,
    xaxis!,
    yaxis!,
+    xgrid!,
+    ygrid!,
+
+    xlims,
+    ylims,
+    zlims,

    savefig,
    png,
    gui,
+    inline,
+    closeall,

    backend,
    backends,
    backend_name,
+    backend_object,
    aliases,
-    dataframes,

    Shape,
    text,
    font,
-    Axis,
    stroke,
    brush,
    Surface,
    OHLC,
    arrow,
    Segments,
-
-    colorscheme,
-    ColorScheme,
-    ColorGradient,
-    ColorVector,
-    ColorWrapper,
-    ColorFunction,
-    ColorZFunction,
-    getColor,
-    getColorZ,
-
-    debugplots,
-
-    supported_args,
-    supported_types,
-    supported_styles,
-    supported_markers,
-    is_subplot_supported,
+    Formatted,

    Animation,
    frame,
    gif,
+    mov,
+    mp4,
+    animate,
    @animate,
    @gif,

-    spy,
-
    test_examples,
    iter_segments,
+    coords,

    translate,
    translate!,
    rotate,
    rotate!,
    center,
-    P2,
-    P3,
    BezierCurve,
-    curve_points,
-    directed_curve
+
+    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)
+
+# ---------------------------------------------------------
+
+# 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
-typealias BBox Measures.Absolute2DBox
-export BBox, BoundingBox, mm, cm, inch, pt, px, pct, 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("colors.jl")
 include("components.jl")
 include("axes.jl")
-include("backends.jl")
 include("args.jl")
 include("themes.jl")
 include("plot.jl")
-include("series_args.jl")
-include("series_new.jl")
+include("pipeline.jl")
+include("series.jl")
 include("layouts.jl")
 include("subplots.jl")
 include("recipes.jl")
 include("animation.jl")
-include("output.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")

-# define and export shorthand plotting method definitions
-macro shorthands(funcname::Symbol)
-    funcname2 = Symbol(funcname, "!")
-    esc(quote
-        export $funcname, $funcname2
-        $funcname(args...; kw...) = plot(args...; kw..., seriestype = $(quot(funcname)))
-        $funcname2(args...; kw...) = plot!(args...; kw..., seriestype = $(quot(funcname)))
-    end)
+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

-@shorthands scatter
-@shorthands bar
-@shorthands barh
-@shorthands histogram
-@shorthands histogram2d
-@shorthands density
-@shorthands heatmap
-@shorthands hexbin
-@shorthands sticks
-@shorthands hline
-@shorthands vline
-@shorthands ohlc
-@shorthands contour
-@shorthands contour3d
-@shorthands surface
-@shorthands wireframe
-@shorthands path3d
-@shorthands scatter3d
-@shorthands boxplot
-@shorthands violin
-@shorthands quiver
-@shorthands curves
-
-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)
-plot3d(args...; kw...)     = plot(args...; kw...,  seriestype = :path3d)
-plot3d!(args...; kw...)    = plot!(args...; kw..., seriestype = :path3d)
-
-
-title!(s::AbstractString; kw...)                 = plot!(; title = s, kw...)
-xlabel!(s::AbstractString; kw...)                = plot!(; xlabel = s, kw...)
-ylabel!(s::AbstractString; kw...)                = plot!(; ylabel = s, kw...)
-xlims!{T<:Real,S<:Real}(lims::Tuple{T,S}; kw...) = plot!(; xlims = lims, kw...)
-ylims!{T<:Real,S<:Real}(lims::Tuple{T,S}; kw...) = plot!(; ylims = lims, kw...)
-zlims!{T<:Real,S<:Real}(lims::Tuple{T,S}; kw...) = 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...)
-xticks!{T<:Real}(v::AVec{T}; kw...)                       = plot!(; xticks = v, kw...)
-yticks!{T<:Real}(v::AVec{T}; kw...)                       = plot!(; yticks = v, kw...)
-xticks!{T<:Real,S<:AbstractString}(
-              ticks::AVec{T}, labels::AVec{S}; kw...)     = plot!(; xticks = (ticks,labels), kw...)
-yticks!{T<:Real,S<:AbstractString}(
-              ticks::AVec{T}, labels::AVec{S}; kw...)     = plot!(; yticks = (ticks,labels), kw...)
-annotate!(anns...; kw...)                                 = plot!(; annotation = anns, kw...)
-annotate!{T<:Tuple}(anns::AVec{T}; kw...)                 = plot!(; annotation = anns, kw...)
-xflip!(flip::Bool = true; kw...)                          = plot!(; xflip = flip, kw...)
-yflip!(flip::Bool = true; kw...)                          = plot!(; yflip = flip, kw...)
-xaxis!(args...; kw...)                                    = plot!(; xaxis = args, kw...)
-yaxis!(args...; kw...)                                    = plot!(; yaxis = args, kw...)
-
-title!(plt::Plot, s::AbstractString; kw...)                  = plot!(plt; title = s, kw...)
-xlabel!(plt::Plot, s::AbstractString; kw...)                 = plot!(plt; xlabel = s, kw...)
-ylabel!(plt::Plot, s::AbstractString; kw...)                 = plot!(plt; ylabel = s, kw...)
-xlims!{T<:Real,S<:Real}(plt::Plot, lims::Tuple{T,S}; kw...)  = plot!(plt; xlims = lims, kw...)
-ylims!{T<:Real,S<:Real}(plt::Plot, lims::Tuple{T,S}; kw...)  = plot!(plt; ylims = lims, kw...)
-zlims!{T<:Real,S<:Real}(plt::Plot, lims::Tuple{T,S}; kw...)  = plot!(plt; zlims = lims, kw...)
-xlims!(plt::Plot, xmin::Real, xmax::Real; kw...)                      = plot!(plt; xlims = (xmin,xmax), kw...)
-ylims!(plt::Plot, ymin::Real, ymax::Real; kw...)                      = plot!(plt; ylims = (ymin,ymax), kw...)
-zlims!(plt::Plot, zmin::Real, zmax::Real; kw...)                      = plot!(plt; zlims = (zmin,zmax), kw...)
-xticks!{T<:Real}(plt::Plot, ticks::AVec{T}; kw...)                    = plot!(plt; xticks = ticks, kw...)
-yticks!{T<:Real}(plt::Plot, ticks::AVec{T}; kw...)                    = plot!(plt; yticks = ticks, kw...)
-xticks!{T<:Real,S<:AbstractString}(plt::Plot,
-                          ticks::AVec{T}, labels::AVec{S}; kw...)     = plot!(plt; xticks = (ticks,labels), kw...)
-yticks!{T<:Real,S<:AbstractString}(plt::Plot,
-                          ticks::AVec{T}, labels::AVec{S}; kw...)     = plot!(plt; yticks = (ticks,labels), kw...)
-annotate!(plt::Plot, anns...; kw...)                                  = plot!(plt; annotation = anns, kw...)
-annotate!{T<:Tuple}(plt::Plot, anns::AVec{T}; kw...)                  = plot!(plt; annotation = anns, kw...)
-xflip!(plt::Plot, flip::Bool = true; kw...)                           = plot!(plt; xflip = flip, kw...)
-yflip!(plt::Plot, flip::Bool = true; kw...)                           = plot!(plt; yflip = flip, kw...)
-xaxis!(plt::Plot, args...; kw...)                                     = plot!(plt; xaxis = args, kw...)
-yaxis!(plt::Plot, args...; kw...)                                     = plot!(plt; yaxis = args, kw...)
-
-

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

 const CURRENT_BACKEND = CurrentBackend(:none)

-function __init__()
-    setup_ijulia()
-    setup_atom()
-
-    if haskey(ENV, "PLOTS_DEFAULTS")
-        for (k,v) in eval(parse(ENV["PLOTS_DEFAULTS"]))
-            default(k, v)
-        end
-    end
-end
-
-# ---------------------------------------------------------
-
 end # module
@@ -1,62 +1,117 @@
-
-immutable Animation
-  dir::Compat.ASCIIString
-  frames::Vector{Compat.ASCIIString}
+"Represents an animation object"
+struct Animation
+    dir::String
+    frames::Vector{String}
 end

 function Animation()
-  tmpdir = convert(Compat.ASCIIString, mktempdir())
-  Animation(tmpdir, Compat.ASCIIString[])
+    tmpdir = convert(String, mktempdir())
+    Animation(tmpdir, String[])
 end

-function frame{P<:AbstractPlot}(anim::Animation, plt::P=current())
-  i = length(anim.frames) + 1
-  filename = @sprintf("%06d.png", i)
-  png(plt, joinpath(anim.dir, filename))
-  push!(anim.frames, filename)
+"""
+    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"
-immutable AnimatedGif
-  filename::Compat.ASCIIString
+struct AnimatedGif
+    filename::String
 end

-function gif(anim::Animation, fn = (isijulia() ? "tmp.gif" : tempname()*".gif"); fps::Integer = 20)
-  fn = abspath(fn)
+file_extension(fn) = Base.Filesystem.splitext(fn)[2][2:end]

-  try
+gif(anim::Animation, fn = giffn(); kw...) = buildanimation(anim.dir, fn; kw...)
+mov(anim::Animation, fn = movfn(); kw...) = buildanimation(anim.dir, fn, false; kw...)
+mp4(anim::Animation, fn = mp4fn(); kw...) = buildanimation(anim.dir, fn, false; kw...)

-    # high quality
-    speed = round(Int, 100 / fps)
-    file = joinpath(Pkg.dir("ImageMagick"), "deps","deps.jl")
-    if isfile(file) && !haskey(ENV, "MAGICK_CONFIGURE_PATH")
-        include(file)
+
+function buildanimation(animdir::AbstractString, fn::AbstractString,
+                        is_animated_gif::Bool=true;
+                        fps::Integer = 20, loop::Integer = 0,
+                        variable_palette::Bool=false,
+                        show_msg::Bool=true)
+    fn = abspath(fn)
+
+    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"
+            run(`ffmpeg -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
+            run(`ffmpeg -v 0 -i $(animdir)/%06d.png -vf "palettegen=stats_mode=diff" -y "$(animdir)/palette.bmp"`)
+            # then apply the palette to get better results
+            run(`ffmpeg -v 0 -framerate $fps -loop $loop -i $(animdir)/%06d.png -i "$(animdir)/palette.bmp" -lavfi "paletteuse=dither=sierra2_4a" -y $fn`)
+        end
+    else
+        run(`ffmpeg -v 0 -framerate $fps -loop $loop -i $(animdir)/%06d.png -pix_fmt yuv420p -y $fn`)
    end
-    # prefix = get(ENV, "MAGICK_CONFIGURE_PATH", "")
-    run(`convert -delay $speed -loop 0 $(joinpath(anim.dir, "*.png")) -alpha off $fn`)

-  catch err
-    warn("""Tried to create gif using convert (ImageMagick), but got error: $err
-    ImageMagick can be installed by executing `Pkg.add("ImageMagick")`
-    Will try ffmpeg, but it's lower quality...)""")
-
-    # low quality
-    run(`ffmpeg -v 0 -framerate $fps -i $(anim.dir)/%06d.png -y $fn`)
-    # run(`ffmpeg -v warning -i  "fps=$fps,scale=320:-1:flags=lanczos"`)
-  end
-
-  info("Saved animation to ", fn)
-  AnimatedGif(fn)
+    show_msg && @info("Saved animation to ", fn)
+    AnimatedGif(fn)
 end



-# write out html to view the gif... note the rand call which is a hack so the image doesn't get cached
-function Base.writemime(io::IO, ::MIME"text/html", agif::AnimatedGif)
-    write(io, "<img src=\"$(relpath(agif.filename))?$(rand())>\" />")
+# 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


@@ -70,6 +125,7 @@ function _animate(forloop::Expr, args...; callgif = false)
  # add the call to frame to the end of each iteration
  animsym = gensym("anim")
  countersym = gensym("counter")
+  freqassert = :()
  block = forloop.args[2]

  # create filter
@@ -82,7 +138,7 @@ function _animate(forloop::Expr, args...; callgif = false)
    # filter every `freq` frames (starting with the first frame)
    @assert n == 2
    freq = args[2]
-    @assert isa(freq, Integer) && freq > 0
+    freqassert = :(@assert isa($freq, Integer) && $freq > 0)
    :(mod1($countersym, $freq) == 1)

  elseif args[1] == :when
@@ -95,15 +151,16 @@ function _animate(forloop::Expr, args...; callgif = false)
  end

  push!(block.args, :(if $filterexpr; frame($animsym); end))
-  push!(block.args, :($countersym += 1))
+  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
-    $countersym = 1         # init iteration counter
+    global $countersym = 1         # init iteration counter
    $forloop                # for loop, saving a frame after each iteration
    $retval                 # return the animation object, or the gif
  end)
@@ -122,7 +179,7 @@ Example:
 ```
 """
 macro gif(forloop::Expr, args...)
-  _animate(forloop, args...; callgif = true)
+    _animate(forloop, args...; callgif = true)
 end

 """
@@ -131,13 +188,13 @@ Collect one frame per for-block iteration and return an `Animation` object.
 Example:

 ```
-  p = plot(1)
-  anim = @animate for x=0:0.1:5
+p = plot(1)
+anim = @animate for x=0:0.1:5
    push!(p, 1, sin(x))
-  end
-  gif(anim)
+end
+gif(anim)
 ```
 """
 macro animate(forloop::Expr, args...)
-  _animate(forloop, args...)
+    _animate(forloop, args...)
 end
@@ -2,7 +2,7 @@
 const _arg_desc = KW(

 # series args
-:label 				=> "String type. The label for a series, which appears in a legend.  If empty, no legend entry is added.",
+: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.",
@@ -10,7 +10,7 @@ const _arg_desc = KW(
 :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 from this to y for line-types, sets the base for bar/stick types, and similar for other types.",
+: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).",
@@ -19,35 +19,38 @@ const _arg_desc = KW(
 :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 `:seriescolor`.",
+: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. For histogram-types, defines the number of bins, or the edges, of the histogram.",
+: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 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 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).",
-:levels            	=> "Integer, NTuple{2,Integer}. Number of levels (or x-levels/y-levels) for a contour type.",
+: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)",
+: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. Should normalize histogram types?  Trying for area == 1.",
+: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.",
-
+: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.",
@@ -61,48 +64,92 @@ const _arg_desc = KW(
 :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.",
-: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",
+: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`",
-:titlefont                => "Font. Font of subplot title.",
+: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_grid    => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of grid lines.",
 :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.",
-:grid                     => "Bool. Show the grid lines?",
 :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 (width to height ratio of plot area).",
+: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).",
-:lims      				  => "NTuple{2,Number}. Force axis limits.  Only finite values are used (you can set only the right limit with `xlims = (-Inf, 2)` for example).",
-: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?",
-:tickfont  				  => "Font. Font of axis tick labels.",
-:guidefont 				  => "Font. Font of axis guide (label).",
+: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.",
 )
@@ -8,7 +8,7 @@

 function Axis(sp::Subplot, letter::Symbol, args...; kw...)
    # init with values from _plot_defaults
-    d = KW(
+    plotattributes = KW(
        :letter => letter,
        # :extrema => (Inf, -Inf),
        :extrema => Extrema(),
@@ -22,14 +22,14 @@ function Axis(sp::Subplot, letter::Symbol, args...; kw...)
    for (k,v) in _axis_defaults
        lk = Symbol(letter, k)
        lv = _axis_defaults_byletter[lk]
-        d[k] = (lv == :match ? v : lv)
-    end     
+        plotattributes[k] = (lv == :match ? v : lv)
+    end

-    # merge!(d, _axis_defaults)
-    d[:discrete_values] = []
+    # merge!(plotattributes, _axis_defaults)
+    plotattributes[:discrete_values] = []

    # update the defaults
-    update!(Axis(sp, d), args...; kw...)
+    attr!(Axis([sp], plotattributes), args...; kw...)
 end

 function get_axis(sp::Subplot, letter::Symbol)
@@ -38,72 +38,78 @@ function get_axis(sp::Subplot, letter::Symbol)
        sp.attr[axissym]
    else
        sp.attr[axissym] = Axis(sp, letter)
-    end
+    end::Axis
 end

-function process_axis_arg!(d::KW, arg, letter = "")
+function process_axis_arg!(plotattributes::KW, arg, letter = "")
    T = typeof(arg)
    arg = get(_scaleAliases, arg, arg)

    if typeof(arg) <: Font
-        d[Symbol(letter,:tickfont)] = arg
-        d[Symbol(letter,:guidefont)] = arg
+        plotattributes[Symbol(letter,:tickfont)] = arg
+        plotattributes[Symbol(letter,:guidefont)] = arg

    elseif arg in _allScales
-        d[Symbol(letter,:scale)] = arg
+        plotattributes[Symbol(letter,:scale)] = arg

    elseif arg in (:flip, :invert, :inverted)
-        d[Symbol(letter,:flip)] = true
+        plotattributes[Symbol(letter,:flip)] = true

    elseif T <: AbstractString
-        d[Symbol(letter,:guide)] = arg
+        plotattributes[Symbol(letter,:guide)] = arg

    # xlims/ylims
    elseif (T <: Tuple || T <: AVec) && length(arg) == 2
        sym = typeof(arg[1]) <: Number ? :lims : :ticks
-        d[Symbol(letter,sym)] = arg
+        plotattributes[Symbol(letter,sym)] = arg

    # xticks/yticks
    elseif T <: AVec
-        d[Symbol(letter,:ticks)] = arg
+        plotattributes[Symbol(letter,:ticks)] = arg

    elseif arg == nothing
-        d[Symbol(letter,:ticks)] = []
+        plotattributes[Symbol(letter,:ticks)] = []
+
+    elseif T <: Bool || arg in _allShowaxisArgs
+        plotattributes[Symbol(letter,:showaxis)] = showaxis(arg, letter)

    elseif typeof(arg) <: Number
-        d[Symbol(letter,:rotation)] = arg
+        plotattributes[Symbol(letter,:rotation)] = arg

-    else
-        warn("Skipped $(letter)axis arg $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 update!(axis::Axis, args...; kw...)
+function attr!(axis::Axis, args...; kw...)
    # first process args
-    d = axis.d
+    plotattributes = axis.plotattributes
    for arg in args
-        process_axis_arg!(d, arg)
+        process_axis_arg!(plotattributes, arg)
    end

-    # then override for any keywords... only those keywords that already exists in d
+    # then override for any keywords... only those keywords that already exists in plotattributes
    for (k,v) in kw
-        if haskey(d, k)
+        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
-                d[k] = v
+                plotattributes[k] = v
            end
        end
    end

    # replace scale aliases
-    if haskey(_scaleAliases, d[:scale])
-        d[:scale] = _scaleAliases[d[:scale]]
+    if haskey(_scaleAliases, plotattributes[:scale])
+        plotattributes[:scale] = _scaleAliases[plotattributes[:scale]]
    end

    axis
@@ -111,41 +117,238 @@ end

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

-Base.show(io::IO, axis::Axis) = dumpdict(axis.d, "Axis", true)
-# Base.getindex(axis::Axis, k::Symbol) = getindex(axis.d, k)
-Base.setindex!(axis::Axis, v, ks::Symbol...) = setindex!(axis.d, v, ks...)
-Base.haskey(axis::Axis, k::Symbol) = haskey(axis.d, k)
-Base.extrema(axis::Axis) = (ex = axis[:extrema]; (ex.emin, ex.emax))
+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))

-# get discrete ticks, or not
-function get_ticks(axis::Axis)
-    ticks = axis[:ticks]
-    dvals = axis[:discrete_values]
-    if !isempty(dvals) && ticks == :auto
-        axis[:continuous_values], dvals
-    else
-        ticks
+
+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 = min(v, ex.emin)
-    ex.emax = max(v, ex.emax)
+    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
-function expand_extrema!{MIN<:Number,MAX<:Number}(axis::Axis, v::Tuple{MIN,MAX})
+
+# 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 = min(v[1], ex.emin)
-    ex.emax = max(v[2], ex.emax)
+    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!{N<:Number}(axis::Axis, v::AVec{N})
+function expand_extrema!(axis::Axis, v::AVec{N}) where N<:Number
    ex = axis[:extrema]
    for vi in v
        expand_extrema!(ex, vi)
@@ -154,37 +357,52 @@ function expand_extrema!{N<:Number}(axis::Axis, v::AVec{N})
 end


-function expand_extrema!(sp::Subplot, d::KW)
+function expand_extrema!(sp::Subplot, plotattributes::KW)
+    vert = isvertical(plotattributes)
+
    # first expand for the data
    for letter in (:x, :y, :z)
-        data = d[letter]
-        axis = sp.attr[Symbol(letter, "axis")]
-        if eltype(data) <: Number
-            expand_extrema!(axis, data)
-        elseif isa(data, Surface) && eltype(data.surf) <: Number
+        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)
-            # @show letter,eltype(data),typeof(data)
-            d[letter], d[Symbol(letter,"_discrete_indices")] = discrete_value!(axis, data)
+            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(d)
+    # if isvertical(plotattributes)
    #     fillaxis, baraxis = baraxis, fillaxis
    # end

    # expand for fillrange
-    vert = isvertical(d)
-    fr = d[:fillrange]
-    if fr == nothing && d[:seriestype] == :bar
+    fr = plotattributes[:fillrange]
+    if fr == nothing && plotattributes[:seriestype] == :bar
        fr = 0.0
    end
-    if fr != nothing
+    if fr != nothing && !all3D(plotattributes)
        axis = sp.attr[vert ? :yaxis : :xaxis]
        if typeof(fr) <: Tuple
            for fri in fr
@@ -196,21 +414,28 @@ function expand_extrema!(sp::Subplot, d::KW)
    end

    # expand for bar_width
-    if d[:seriestype] == :bar
+    if plotattributes[:seriestype] == :bar
        dsym = vert ? :x : :y
-        data = d[dsym]
+        data = plotattributes[dsym]

-        bw = d[:bar_width]
+        bw = plotattributes[:bar_width]
        if bw == nothing
-            bw = d[:bar_width] = mean(diff(data))
+            bw = plotattributes[:bar_width] = _bar_width * ignorenan_minimum(filter(x->x>0,diff(sort(data))))
        end
-        # @show data bw
-
        axis = sp.attr[Symbol(dsym, :axis)]
-        expand_extrema!(axis, maximum(data) + 0.5maximum(bw))
-        expand_extrema!(axis, minimum(data) - 0.5minimum(bw))
+        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)
@@ -221,33 +446,46 @@ end
 # -------------------------------------------------------------------------

 # push the limits out slightly
-function widen(lmin, lmax)
-    span = lmax - lmin
-    # eps = max(1e-16, min(1e-2span, 1e-10))
-    eps = max(1e-16, 0.03span)
-    lmin-eps, lmax+eps
+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.  if there's a scale set it's too tricky,
-# so lazy out and don't widen
+# 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 axis[:scale] == :identity
-        for series in series_list(axis.sp)
-            if series.d[:seriestype] in (:scatter,) || series.d[:markershape] != :none
-                should_widen = true
+    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(axis::Axis, should_widen::Bool = default_should_widen(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]
-    if (isa(lims, Tuple) || isa(lims, AVec)) && length(lims) == 2
+    has_user_lims = (isa(lims, Tuple) || isa(lims, AVec)) && length(lims) == 2
+    if has_user_lims
        if isfinite(lims[1])
            amin = lims[1]
        end
@@ -258,11 +496,51 @@ function axis_limits(axis::Axis, should_widen::Bool = default_should_widen(axis)
    if amax <= amin && isfinite(amin)
        amax = amin + 1.0
    end
-    if should_widen
-        widen(amin, amax)
+    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

 # -------------------------------------------------------------------------
@@ -275,7 +553,7 @@ function discrete_value!(axis::Axis, dv)
    # @show axis[:discrete_map], axis[:discrete_values], dv
    if cv_idx == -1
        ex = axis[:extrema]
-        cv = max(0.5, ex.emax + 1.0)
+        cv = NaNMath.max(0.5, ex.emax + 1.0)
        expand_extrema!(axis, cv)
        push!(axis[:discrete_values], dv)
        push!(axis[:continuous_values], cv)
@@ -322,11 +600,159 @@ end
 # -------------------------------------------------------------------------

 function pie_labels(sp::Subplot, series::Series)
-    d = series.d
-    if haskey(d,:x_discrete_indices)
-        dvals = sp.attr[:xaxis].d[:discrete_values]
-        [dvals[idx] for idx in d[:x_discrete_indices]]
+    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
-        d[:x]
+        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
+
+    xticks, yticks, xaxis_segs, yaxis_segs, xtick_segs, ytick_segs, xgrid_segs, ygrid_segs, xminorgrid_segs, yminorgrid_segs, xborder_segs, yborder_segs
+end
@@ -1,45 +1,47 @@
+using Pkg

-immutable NoBackend <: AbstractBackend end
+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
-_backend_instance(sym::Symbol) = haskey(_backendType, sym) ? _backendType[sym]() : error("Unsupported 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)
-    str = lowercase(string(s))
+    package_str = string(s)
+    str = lowercase(package_str)
    sym = Symbol(str)
    T = Symbol(string(s) * "Backend")
    esc(quote
-        immutable $T <: AbstractBackend end
+        struct $T <: AbstractBackend end
        export $sym
-        $sym(; kw...) = (default(; kw...); backend(Symbol($str)))
+        $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)
-        include("backends/" * $str * ".jl")
+        _backend_packages[Symbol($str)] = Symbol($package_str)
+        # include("backends/" * $str * ".jl")
    end)
 end

-@init_backend Immerse
-@init_backend Gadfly
-@init_backend PyPlot
-@init_backend Qwt
-@init_backend UnicodePlots
-@init_backend Winston
-@init_backend Bokeh
-@init_backend Plotly
-@init_backend PlotlyJS
-@init_backend GR
-@init_backend GLVisualize
-@init_backend PGFPlots
-
-include("backends/web.jl")
+# include("backends/web.jl")
 # include("backends/supported.jl")

 # ---------------------------------------------------------
@@ -54,16 +56,69 @@ _series_updated(plt::Plot, series::Series) = nothing

 _before_layout_calcs(plt::Plot) = nothing

-title_padding(sp::Subplot) = sp[:title] == "" ? 0mm : sp[:titlefont].pointsize * pt
-guide_padding(axis::Axis) = axis[:guide] == "" ? 0mm : axis[:guidefont].pointsize * pt
+title_padding(sp::Subplot) = sp[:title] == "" ? 0mm : sp[:titlefontsize] * pt
+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)
-    leftpad   = 10mm + sp[:left_margin]   + guide_padding(sp[:yaxis])
-    toppad    =  2mm + sp[:top_margin]    + title_padding(sp)
-    rightpad  =  3mm + sp[:right_margin]
-    bottompad =  5mm + sp[:bottom_margin] + guide_padding(sp[:xaxis])
+    # 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
@@ -73,7 +128,7 @@ _update_plot_object(plt::Plot) = nothing
 # ---------------------------------------------------------


-type CurrentBackend
+mutable struct CurrentBackend
  sym::Symbol
  pkg::AbstractBackend
 end
@@ -81,34 +136,22 @@ CurrentBackend(sym::Symbol) = CurrentBackend(sym, _backend_instance(sym))

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

-function pickDefaultBackend()
+_fallback_default_backend() = backend(GRBackend())
+
+function _pick_default_backend()
    env_default = get(ENV, "PLOTS_DEFAULT_BACKEND", "")
    if env_default != ""
-        try
-            Pkg.installed(env_default)  # this will error if not installed
-            sym = Symbol(lowercase(env_default))
-            if haskey(_backendType, sym)
-                return 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"))
-            end
-        catch
-            warn("You have set PLOTS_DEFAULT_BACKEND=$env_default but it is not installed.")
+        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
-
-    # the ordering/inclusion of this package list is my semi-arbitrary guess at
-    # which one someone will want to use if they have the package installed...accounting for
-    # features, speed, and robustness
-    for pkgstr in ("PyPlot", "GR", "PlotlyJS", "Immerse", "Gadfly", "UnicodePlots")
-        if Pkg.installed(pkgstr) != nothing
-            return backend(Symbol(lowercase(pkgstr)))
-        end
-    end
-
-    # the default if nothing else is installed
-    backend(:plotly)
 end


@@ -118,72 +161,45 @@ end
 Returns the current plotting package name.  Initializes package on first call.
 """
 function backend()
-
-  global CURRENT_BACKEND
-  if CURRENT_BACKEND.sym == :none
-    pickDefaultBackend()
-  end
-
-  sym = CURRENT_BACKEND.sym
-  if !(sym in _initialized_backends)
-
-    # initialize
-    println("[Plots.jl] Initializing backend: ", sym)
-
-    inst = _backend_instance(sym)
-    try
-      _initialize_backend(inst)
-    catch err
-      warn("Couldn't initialize $sym.  (might need to install it?)")
-      rethrow(err)
+    if CURRENT_BACKEND.sym == :none
+        _pick_default_backend()
    end

-    push!(_initialized_backends, sym)
-
-  end
-  CURRENT_BACKEND.pkg
+    CURRENT_BACKEND.pkg
 end

 """
 Set the plot backend.
 """
 function backend(pkg::AbstractBackend)
-    CURRENT_BACKEND.sym = backend_name(pkg)
-    warn_on_deprecated_backend(CURRENT_BACKEND.sym)
+    sym = backend_name(pkg)
+    if !(sym in _initialized_backends)
+        _initialize_backend(pkg)
+        push!(_initialized_backends, sym)
+    end
+    CURRENT_BACKEND.sym = sym
    CURRENT_BACKEND.pkg = pkg
+    pkg
 end

-function backend(modname::Symbol)
-    warn_on_deprecated_backend(modname)
-    CURRENT_BACKEND.sym = modname
-    CURRENT_BACKEND.pkg = _backend_instance(modname)
-end
-
-const _deprecated_backends = [:qwt, :winston, :bokeh, :gadfly, :immerse]
-
-function warn_on_deprecated_backend(bsym::Symbol)
-    if bsym in _deprecated_backends
-        warn("Backend $bsym has been deprecated.  It may not work as originally intended.")
+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

-supported_types(::AbstractBackend) = []
-supported_styles(::AbstractBackend) = [:solid]
-supported_markers(::AbstractBackend) = [:none]
-supported_scales(::AbstractBackend) = [:identity]
-is_subplot_supported(::AbstractBackend) = false
-is_string_supported(::AbstractBackend) = false
-nativeImagesSupported(b::AbstractBackend) = :image in supported_types(b)

-supported_types() = supported_types(backend())
-supported_styles() = supported_styles(backend())
-supported_markers() = supported_markers(backend())
-supported_scales() = supported_scales(backend())
-is_subplot_supported() = is_subplot_supported(backend())
-is_string_supported() = is_string_supported(backend())
-nativeImagesSupported() = nativeImagesSupported(backend())

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

@@ -213,7 +229,7 @@ const _base_supported_args = [
    :subplot_index,
    :discrete_values,
    :projection,
-    
+
 ]

 function merge_with_base_supported(v::AVec)
@@ -225,5 +241,423 @@ function merge_with_base_supported(v::AVec)
            end
        end
    end
-    v
+    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
+
+_initialize_backend(pkg::GRBackend) = nothing
+
+_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]
@@ -1,208 +0,0 @@
-
-# https://github.com/bokeh/Bokeh.jl
-
-
-supported_args(::BokehBackend) = merge_with_base_supported([
-    # :annotations,
-    # :axis,
-    # :background_color,
-    :linecolor,
-    # :color_palette,
-    # :fillrange,
-    # :fillcolor,
-    # :fillalpha,
-    # :foreground_color,
-    :group,
-    # :label,
-    # :layout,
-    # :legend,
-    :seriescolor, :seriesalpha,
-    :linestyle,
-    :seriestype,
-    :linewidth,
-    # :linealpha,
-    :markershape,
-    :markercolor,
-    :markersize,
-    # :markeralpha,
-    # :markerstrokewidth,
-    # :markerstrokecolor,
-    # :markerstrokestyle,
-    # :n,
-    # :bins,
-    # :nc,
-    # :nr,
-    # :pos,
-    # :smooth,
-    # :show,
-    :size,
-    :title,
-    # :window_title,
-    :x,
-    # :xguide,
-    # :xlims,
-    # :xticks,
-    :y,
-    # :yguide,
-    # :ylims,
-    # :yrightlabel,
-    # :yticks,
-    # :xscale,
-    # :yscale,
-    # :xflip,
-    # :yflip,
-    # :z,
-    # :tickfont,
-    # :guidefont,
-    # :legendfont,
-    # :grid,
-    # :surface,
-    # :levels,
-  ])
-supported_types(::BokehBackend) = [:path, :scatter]
-supported_styles(::BokehBackend) = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
-supported_markers(::BokehBackend) = [:none, :auto, :circle, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5]
-supported_scales(::BokehBackend) = [:identity, :ln]
-is_subplot_supported(::BokehBackend) = false
-
-
-# --------------------------------------------------------------------------------------
-
-
-
-function _initialize_backend(::BokehBackend; kw...)
-  @eval begin
-    warn("Bokeh is no longer supported... many features will likely be broken.")
-    import Bokeh
-    export Bokeh
-  end
-end
-
-
-const _glyphtypes = KW(
-    :circle    => :Circle,
-    :rect       => :Square,
-    :diamond    => :Diamond,
-    :utriangle  => :Triangle,
-    :dtriangle  => :InvertedTriangle,
-    # :pentagon   =>
-    # :hexagon    =>
-    # :heptagon   =>
-    # :octagon    =>
-    :cross      => :Cross,
-    :xcross     => :X,
-    :star5      => :Asterisk,
-  )
-
-
-function bokeh_glyph_type(d::KW)
-  st = d[:seriestype]
-  mt = d[:markershape]
-  if st == :scatter && mt == :none
-    mt = :circle
-  end
-
-  # if we have a marker, use that
-  if st == :scatter || mt != :none
-    return _glyphtypes[mt]
-  end
-
-  # otherwise return a line
-  return :Line
-end
-
-function get_stroke_vector(linestyle::Symbol)
-  dash = 12
-  dot = 3
-  gap = 2
-  linestyle == :solid && return Int[]
-  linestyle == :dash && return Int[dash, gap]
-  linestyle == :dot && return Int[dot, gap]
-  linestyle == :dashdot && return Int[dash, gap, dot, gap]
-  linestyle == :dashdotdot && return Int[dash, gap, dot, gap, dot, gap]
-  error("unsupported linestyle: ", linestyle)
-end
-
-# ---------------------------------------------------------------------------
-
-# function _create_plot(pkg::BokehBackend, d::KW)
-function _create_backend_figure(plt::Plot{BokehBackend})
-  # TODO: create the window/canvas/context that is the plot within the backend (call it `o`)
-  # TODO: initialize the plot... title, xlabel, bgcolor, etc
-
-  datacolumns = Bokeh.BokehDataSet[]
-  tools = Bokeh.tools()
-  filename = tempname() * ".html"
-  title = plt.attr[:title]
-  w, h = plt.attr[:size]
-  xaxis_type = plt.attr[:xscale] == :log10 ? :log : :auto
-  yaxis_type = plt.attr[:yscale] == :log10 ? :log : :auto
-  # legend = plt.attr[:legend] ? xxxx : nothing
-  legend = nothing
-  extra_args = KW()  # TODO: we'll put extra settings (xlim, etc) here
-  Bokeh.Plot(datacolumns, tools, filename, title, w, h, xaxis_type, yaxis_type, legend) #, extra_args)
-
-  # Plot(bplt, pkg, 0, d, KW[])
-end
-
-
-# function _series_added(::BokehBackend, plt::Plot, d::KW)
-function _series_added(plt::Plot{BokehBackend}, series::Series)
-  bdata = Dict{Symbol, Vector}(:x => collect(series.d[:x]), :y => collect(series.d[:y]))
-
-  glyph = Bokeh.Bokehjs.Glyph(
-      glyphtype = bokeh_glyph_type(d),
-      linecolor = webcolor(d[:linecolor]),  # shape's stroke or line color
-      linewidth = d[:linewidth],          # shape's stroke width or line width
-      fillcolor = webcolor(d[:markercolor]),
-      size      = ceil(Int, d[:markersize] * 2.5),  # magic number 2.5 to keep in same scale as other backends
-      dash      = get_stroke_vector(d[:linestyle])
-    )
-
-  legend = nothing  # TODO
-  push!(plt.o.datacolumns, Bokeh.BokehDataSet(bdata, glyph, legend))
-
-  # push!(plt.seriesargs, d)
-  # plt
-end
-
-# ----------------------------------------------------------------
-
-# TODO: override this to update plot items (title, xlabel, etc) after creation
-function _update_plot_object(plt::Plot{BokehBackend}, d::KW)
-end
-
-# ----------------------------------------------------------------
-
-# accessors for x/y data
-
-# function getxy(plt::Plot{BokehBackend}, i::Int)
-#   series = plt.o.datacolumns[i].data
-#   series[:x], series[:y]
-# end
-#
-# function setxy!(plt::Plot{BokehBackend}, xy::Tuple{X,Y}, i::Integer)
-#   series = plt.o.datacolumns[i].data
-#   series[:x], series[:y] = xy
-#   plt
-# end
-
-
-
-# ----------------------------------------------------------------
-
-
-# ----------------------------------------------------------------
-
-function Base.writemime(io::IO, ::MIME"image/png", plt::AbstractPlot{BokehBackend})
-  # TODO: write a png to io
-  warn("mime png not implemented")
-end
-
-function Base.display(::PlotsDisplay, plt::Plot{BokehBackend})
-  Bokeh.showplot(plt.o)
-end
-
-# function Base.display(::PlotsDisplay, plt::Subplot{BokehBackend})
-#   # TODO: display/show the subplot
-# end
@@ -1,744 +0,0 @@
-
-# https://github.com/dcjones/Gadfly.jl
-
-
-supported_args(::GadflyBackend) = merge_with_base_supported([
-    :annotations,
-    :background_color, :foreground_color, :color_palette,
-    :group, :label, :seriestype,
-    :seriescolor, :seriesalpha,
-    :linecolor, :linestyle, :linewidth, :linealpha,
-    :markershape, :markercolor, :markersize, :markeralpha,
-    :markerstrokewidth, :markerstrokecolor, :markerstrokealpha,
-    :fillrange, :fillcolor, :fillalpha,
-    :bins, :n, :nc, :nr, :layout, :smooth,
-    :title, :window_title, :show, :size,
-    :x, :xguide, :xlims, :xticks, :xscale, :xflip,
-    :y, :yguide, :ylims, :yticks, :yscale, :yflip,
-    :z,
-    :tickfont, :guidefont, :legendfont,
-    :grid, :legend, :colorbar,
-    :marker_z, :levels,
-    :xerror, :yerror,
-    :ribbon, :quiver,
-    :orientation,
-  ])
-supported_types(::GadflyBackend) = [
-        :path,
-        :scatter, :hexbin,
-        :bar,
-        :contour, :shape
-    ]
-supported_styles(::GadflyBackend) = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
-supported_markers(::GadflyBackend) = vcat(_allMarkers, Shape)
-supported_scales(::GadflyBackend) = [:identity, :ln, :log2, :log10, :asinh, :sqrt]
-is_subplot_supported(::GadflyBackend) = true
-
-
-# --------------------------------------------------------------------------------------
-
-function _initialize_backend(::GadflyBackend; kw...)
-    @eval begin
-        import Gadfly, Compose
-        export Gadfly, Compose
-        include(joinpath(Pkg.dir("Plots"), "src", "backends", "gadfly_shapes.jl"))
-    end
-end
-
-# ---------------------------------------------------------------------------
-
-# immutable MissingVec <: AbstractVector{Float64} end
-# Base.size(v::MissingVec) = (1,)
-# Base.getindex(v::MissingVec, i::Integer) = 0.0
-
-function createGadflyPlotObject(d::KW)
-    gplt = Gadfly.Plot()
-    gplt.mapping = Dict()
-    gplt.data_source = Gadfly.DataFrames.DataFrame()
-    # gplt.layers = gplt.layers[1:0]
-    gplt.layers = [Gadfly.layer(Gadfly.Geom.point(tag=:remove), x=zeros(1), y=zeros(1));] # x=MissingVec(), y=MissingVec());]
-    gplt.guides = Gadfly.GuideElement[Gadfly.Guide.xlabel(d[:xguide]),
-                                   Gadfly.Guide.ylabel(d[:yguide]),
-                                   Gadfly.Guide.title(d[:title])]
-    gplt
-end
-
-# ---------------------------------------------------------------------------
-
-
-function getLineGeom(d::KW)
-    st = d[:seriestype]
-    xbins, ybins = maketuple(d[:bins])
-    if st == :hexb
-        Gadfly.Geom.hexbin(xbincount = xbins, ybincount = ybins)
-    elseif st == :histogram2d
-        Gadfly.Geom.histogram2d(xbincount = xbins, ybincount = ybins)
-    elseif st == :histogram
-        Gadfly.Geom.histogram(bincount = xbins,
-                              orientation = isvertical(d) ? :vertical : :horizontal,
-                              position = d[:bar_position] == :stack ? :stack : :dodge)
-    elseif st == :path
-        Gadfly.Geom.path
-    elseif st in (:bar, :sticks)
-        Gadfly.Geom.bar
-    elseif st == :steppost
-        Gadfly.Geom.step
-    elseif st == :steppre
-        Gadfly.Geom.step(direction = :vh)
-    elseif st == :hline
-        Gadfly.Geom.hline
-    elseif st == :vline
-        Gadfly.Geom.vline
-    elseif st == :contour
-        Gadfly.Geom.contour(levels = d[:levels])
-    # elseif st == :shape
-    #     Gadfly.Geom.polygon(fill = true, preserve_order = true)
-    else
-        nothing
-    end
-end
-
-function get_extra_theme_args(d::KW, k::Symbol)
-    # gracefully handles old Gadfly versions
-    extra_theme_args = KW()
-    try
-        extra_theme_args[:line_style] = Gadfly.get_stroke_vector(d[k])
-    catch err
-        if string(err) == "UndefVarError(:get_stroke_vector)"
-            Base.warn_once("Gadfly.get_stroke_vector failed... do you have an old version of Gadfly?")
-        else
-            rethrow()
-        end
-    end
-    extra_theme_args
-end
-
-function getGadflyLineTheme(d::KW)
-    st = d[:seriestype]
-    lc = convertColor(getColor(d[:linecolor]), d[:linealpha])
-    fc = convertColor(getColor(d[:fillcolor]), d[:fillalpha])
-
-    Gadfly.Theme(;
-        default_color = (st in (:histogram,:histogram2d,:hexbin,:bar,:sticks) ? fc : lc),
-        line_width = (st == :sticks ? 1 : d[:linewidth]) * Gadfly.px,
-        # line_style = Gadfly.get_stroke_vector(d[:linestyle]),
-        lowlight_color = x->RGB(fc),  # fill/ribbon
-        lowlight_opacity = alpha(fc), # fill/ribbon
-        bar_highlight = RGB(lc),      # bars
-        get_extra_theme_args(d, :linestyle)...
-    )
-end
-
-# add a line as a new layer
-function addGadflyLine!(plt::Plot, numlayers::Int, d::KW, geoms...)
-    gplt = getGadflyContext(plt)
-    gfargs = vcat(geoms..., getGadflyLineTheme(d))
-    kwargs = KW()
-    st = d[:seriestype]
-
-    # add a fill?
-    if d[:fillrange] != nothing && st != :contour
-        fillmin, fillmax = map(makevec, maketuple(d[:fillrange]))
-        nmin, nmax = length(fillmin), length(fillmax)
-        kwargs[:ymin] = Float64[min(y, fillmin[mod1(i, nmin)], fillmax[mod1(i, nmax)]) for (i,y) in enumerate(d[:y])]
-        kwargs[:ymax] = Float64[max(y, fillmin[mod1(i, nmin)], fillmax[mod1(i, nmax)]) for (i,y) in enumerate(d[:y])]
-        push!(gfargs, Gadfly.Geom.ribbon)
-    end
-
-    if st in (:hline, :vline)
-        kwargs[st == :hline ? :yintercept : :xintercept] = d[:y]
-
-    else
-        if st == :sticks
-            w = 0.01 * mean(diff(d[:x]))
-            kwargs[:xmin] = d[:x] - w
-            kwargs[:xmax] = d[:x] + w
-        elseif st == :contour
-            kwargs[:z] = d[:z].surf
-            addGadflyContColorScale(plt, d[:linecolor])
-        end
-
-        kwargs[:x] = d[st == :histogram ? :y : :x]
-        kwargs[:y] = d[:y]
-
-    end
-
-    # # add the layer
-    Gadfly.layer(gfargs...; order=numlayers, kwargs...)
-end
-
-
-# ---------------------------------------------------------------------------
-
-get_shape(sym::Symbol) = _shapes[sym]
-get_shape(shape::Shape) = shape
-
-# extract the underlying ShapeGeometry object(s)
-getMarkerGeom(shapes::AVec) = gadflyshape(map(get_shape, shapes))
-getMarkerGeom(other) = gadflyshape(get_shape(other))
-
-# getMarkerGeom(shape::Shape) = gadflyshape(shape)
-# getMarkerGeom(shape::Symbol) = gadflyshape(_shapes[shape])
-# getMarkerGeom(shapes::AVec) = gadflyshape(map(gadflyshape, shapes)) # map(getMarkerGeom, shapes)
-function getMarkerGeom(d::KW)
-    if d[:seriestype] == :shape
-        Gadfly.Geom.polygon(fill = true, preserve_order = true)
-    else
-        getMarkerGeom(d[:markershape])
-    end
-end
-
-function getGadflyMarkerTheme(d::KW, attr::KW)
-    c = getColor(d[:markercolor])
-    α = d[:markeralpha]
-    if α != nothing
-        c = RGBA(RGB(c), α)
-    end
-
-    ms = d[:markersize]
-    ms = if typeof(ms) <: AVec
-        warn("Gadfly doesn't support variable marker sizes... using the average: $(mean(ms))")
-        mean(ms) * Gadfly.px
-    else
-        ms * Gadfly.px
-    end
-
-    Gadfly.Theme(;
-        default_color = c,
-        default_point_size = ms,
-        discrete_highlight_color = c -> RGB(getColor(d[:markerstrokecolor])),
-        highlight_width = d[:markerstrokewidth] * Gadfly.px,
-        line_width = d[:markerstrokewidth] * Gadfly.px,
-        # get_extra_theme_args(d, :markerstrokestyle)...
-    )
-end
-
-function addGadflyContColorScale(plt::Plot{GadflyBackend}, c)
-    plt.attr[:colorbar] == :none && return
-    if !isa(c, ColorGradient)
-        c = default_gradient()
-    end
-    push!(getGadflyContext(plt).scales, Gadfly.Scale.ContinuousColorScale(p -> RGB(getColorZ(c, p))))
-end
-
-function addGadflyMarker!(plt::Plot, numlayers::Int, d::KW, attr::KW, geoms...)
-    gfargs = vcat(geoms..., getGadflyMarkerTheme(d, attr), getMarkerGeom(d))
-    kwargs = KW()
-
-    # handle continuous color scales for the markers
-    zcolor = d[:marker_z]
-    if zcolor != nothing && typeof(zcolor) <: AVec
-        kwargs[:color] = zcolor
-        addGadflyContColorScale(plt, d[:markercolor])
-    end
-
-    Gadfly.layer(gfargs...; x = d[:x], y = d[:y], order=numlayers, kwargs...)
-end
-
-
-# ---------------------------------------------------------------------------
-
-function addToGadflyLegend(plt::Plot, d::KW)
-    if plt.attr[:legend] != :none && d[:label] != ""
-        gplt = getGadflyContext(plt)
-
-        # add the legend if needed
-        if all(g -> !isa(g, Gadfly.Guide.ManualColorKey), gplt.guides)
-            unshift!(gplt.guides, Gadfly.Guide.manual_color_key("", @compat(AbstractString)[], Color[]))
-        end
-
-        # now add the series to the legend
-        for guide in gplt.guides
-            if isa(guide, Gadfly.Guide.ManualColorKey)
-                # TODO: there's a BUG in gadfly if you pass in the same color more than once,
-                # since gadfly will call unique(colors), but doesn't also merge the rows that match
-                # Should ensure from this side that colors which are the same are merged together
-
-                c = getColor(d[d[:markershape] == :none ? :linecolor : :markercolor])
-                foundit = false
-
-                # extend the label if we found this color
-                for i in 1:length(guide.colors)
-                    if RGB(c) == guide.colors[i]
-                        guide.labels[i] *= ", " * d[:label]
-                        foundit = true
-                    end
-                end
-
-                # didn't find the color, so add a new entry into the legend
-                if !foundit
-                    push!(guide.labels, d[:label])
-                    push!(guide.colors, c)
-                end
-            end
-        end
-    end
-end
-
-getGadflySmoothing(smooth::Bool) = smooth ? [Gadfly.Geom.smooth(method=:lm)] : Any[]
-getGadflySmoothing(smooth::Real) = [Gadfly.Geom.smooth(method=:loess, smoothing=float(smooth))]
-
-
-function addGadflySeries!(plt::Plot, d::KW)
-    layers = Gadfly.Layer[]
-    gplt = getGadflyContext(plt)
-
-    # add a regression line?
-    # TODO: make more flexible
-    smooth = getGadflySmoothing(d[:smooth])
-
-    # lines
-    geom = getLineGeom(d)
-    if geom != nothing
-        prepend!(layers, addGadflyLine!(plt, length(gplt.layers), d, geom, smooth...))
-        smooth = Any[] # don't add a regression for markers too
-    end
-
-    # special handling for ohlc and scatter
-    st = d[:seriestype]
-    # if st == :ohlc
-    #     error("Haven't re-implemented after refactoring")
-    if st in (:histogram2d, :hexbin) && (isa(d[:fillcolor], ColorGradient) || isa(d[:fillcolor], ColorFunction))
-        push!(gplt.scales, Gadfly.Scale.ContinuousColorScale(p -> RGB(getColorZ(d[:fillcolor], p))))
-    elseif st == :scatter && d[:markershape] == :none
-        d[:markershape] = :circle
-    end
-
-    # markers
-    if d[:markershape] != :none || st == :shape
-        prepend!(layers, addGadflyMarker!(plt, length(gplt.layers), d, plt.attr, smooth...))
-    end
-
-    st in (:histogram2d, :hexbin, :contour) || addToGadflyLegend(plt, d)
-
-    # now save the layers that apply to this series
-    d[:gadflylayers] = layers
-    prepend!(gplt.layers, layers)
-end
-
-
-# ---------------------------------------------------------------------------
-
-# NOTE: I'm leaving this here and commented out just in case I want to implement again... it was hacky code to create multi-colored line segments
-
-#   # colorgroup
-#   z = d[:z]
-
-#   # handle line segments of different colors
-#   cscheme = d[:linecolor]
-#   if isa(cscheme, ColorVector)
-#     # create a color scale, and set the color group to the index of the color
-#     push!(gplt.scales, Gadfly.Scale.color_discrete_manual(cscheme.v...))
-
-#     # this is super weird, but... oh well... for some reason this creates n separate line segments...
-#     # create a list of vertices that go: [x1,x2,x2,x3,x3, ... ,xi,xi, ... xn,xn] (same for y)
-#     # then the vector passed to the "color" keyword should be a vector: [1,1,2,2,3,3,4,4, ..., i,i, ... , n,n]
-#     csindices = Int[mod1(i,length(cscheme.v)) for i in 1:length(d[:y])]
-#     cs = collect(repmat(csindices', 2, 1))[1:end-1]
-#     grp = collect(repmat((1:length(d[:y]))', 2, 1))[1:end-1]
-#     d[:x], d[:y] = map(createSegments, (d[:x], d[:y]))
-#     colorgroup = [(:linecolor, cs), (:group, grp)]
-
-
-# ---------------------------------------------------------------------------
-
-
-function addGadflyTicksGuide(gplt, ticks, isx::Bool)
-    ticks == :auto && return
-
-    # remove the ticks?
-    if ticks in (:none, false, nothing)
-        return addOrReplace(gplt.guides, isx ? Gadfly.Guide.xticks : Gadfly.Guide.yticks; label=false)
-    end
-
-    ttype = ticksType(ticks)
-
-    # just the values... put ticks here, but use standard labels
-    if ttype == :ticks
-        gtype = isx ? Gadfly.Guide.xticks : Gadfly.Guide.yticks
-        replaceType(gplt.guides, gtype(ticks = collect(ticks)))
-
-    # set the ticks and the labels
-    # Note: this is pretty convoluted, but I think it works.  We set the ticks using Gadfly.Guide,
-    #   and then set the label function (wraps a dict lookup) through a continuous Gadfly.Scale.
-    elseif ttype == :ticks_and_labels
-        gtype = isx ? Gadfly.Guide.xticks : Gadfly.Guide.yticks
-        replaceType(gplt.guides, gtype(ticks = collect(ticks[1])))
-
-        # # TODO add xtick_label function (given tick, return label??)
-        # # Scale.x_discrete(; labels=nothing, levels=nothing, order=nothing)
-        # filterGadflyScale(gplt, isx)
-        # gfunc = isx ? Gadfly.Scale.x_discrete : Gadfly.Scale.y_discrete
-        # labelmap = Dict(zip(ticks...))
-        # labelfunc = val -> labelmap[val]
-        # push!(gplt.scales, gfunc(levels = collect(ticks[1]), labels = labelfunc))
-
-        filterGadflyScale(gplt, isx)
-        gfunc = isx ? Gadfly.Scale.x_continuous : Gadfly.Scale.y_continuous
-        labelmap = Dict(zip(ticks...))
-        labelfunc = val -> labelmap[val]
-        push!(gplt.scales, gfunc(labels = labelfunc))
-
-    else
-        error("Invalid input for $(isx ? "xticks" : "yticks"): ", ticks)
-    end
-end
-
-continuousAndSameAxis(scale, isx::Bool) = isa(scale, Gadfly.Scale.ContinuousScale) && scale.vars[1] == (isx ? :x : :y)
-filterGadflyScale(gplt, isx::Bool) = filter!(scale -> !continuousAndSameAxis(scale, isx), gplt.scales)
-
-
-function getGadflyScaleFunction(d::KW, isx::Bool)
-    scalekey = isx ? :xscale : :yscale
-    hasScaleKey = haskey(d, scalekey)
-    if hasScaleKey
-        scale = d[scalekey]
-        scale == :ln && return isx ? Gadfly.Scale.x_log : Gadfly.Scale.y_log, hasScaleKey, log
-        scale == :log2 && return isx ? Gadfly.Scale.x_log2 : Gadfly.Scale.y_log2, hasScaleKey, log2
-        scale == :log10 && return isx ? Gadfly.Scale.x_log10 : Gadfly.Scale.y_log10, hasScaleKey, log10
-        scale == :asinh && return isx ? Gadfly.Scale.x_asinh : Gadfly.Scale.y_asinh, hasScaleKey, asinh
-        scale == :sqrt && return isx ? Gadfly.Scale.x_sqrt : Gadfly.Scale.y_sqrt, hasScaleKey, sqrt
-    end
-    isx ? Gadfly.Scale.x_continuous : Gadfly.Scale.y_continuous, hasScaleKey, identity
-end
-
-
-function addGadflyLimitsScale(gplt, d::KW, isx::Bool)
-    gfunc, hasScaleKey, func = getGadflyScaleFunction(d, isx)
-
-    # do we want to add min/max limits for the axis?
-    limsym = isx ? :xlims : :ylims
-    limargs = Any[]
-
-    # map :auto to nothing, otherwise add to limargs
-    lims = get(d, limsym, :auto)
-    if lims == :auto
-        lims = nothing
-    else
-        if limsType(lims) == :limits
-            push!(limargs, (:minvalue, min(lims...)))
-            push!(limargs, (:maxvalue, max(lims...)))
-        else
-            error("Invalid input for $(isx ? "xlims" : "ylims"): ", lims)
-        end
-    end
-
-    # replace any current scales with this one
-    if hasScaleKey || !isempty(limargs)
-        filterGadflyScale(gplt, isx)
-        push!(gplt.scales, gfunc(; limargs...))
-    end
-
-    lims, func
-end
-
-function updateGadflyAxisFlips(gplt, d::KW, xlims, ylims, xfunc, yfunc)
-    if isa(gplt.coord, Gadfly.Coord.Cartesian)
-        gplt.coord = Gadfly.Coord.cartesian(
-            gplt.coord.xvars,
-            gplt.coord.yvars;
-            xmin = xlims == nothing ? gplt.coord.xmin : xfunc(minimum(xlims)),
-            xmax = xlims == nothing ? gplt.coord.xmax : xfunc(maximum(xlims)),
-            ymin = ylims == nothing ? gplt.coord.ymin : yfunc(minimum(ylims)),
-            ymax = ylims == nothing ? gplt.coord.ymax : yfunc(maximum(ylims)),
-            xflip = get(d, :xflip, gplt.coord.xflip),
-            yflip = get(d, :yflip, gplt.coord.yflip),
-            fixed = gplt.coord.fixed,
-            aspect_ratio = gplt.coord.aspect_ratio,
-            raster = gplt.coord.raster
-        )
-    else
-        gplt.coord = Gadfly.Coord.Cartesian(
-            xflip = get(d, :xflip, false),
-            yflip = get(d, :yflip, false)
-        )
-    end
-end
-
-
-function findGuideAndSet(gplt, t::DataType, args...; kw...) #s::@compat(AbstractString))
-    for (i,guide) in enumerate(gplt.guides)
-        if isa(guide, t)
-            gplt.guides[i] = t(args...; kw...)
-        end
-    end
-end
-
-function updateGadflyGuides(plt::Plot, d::KW)
-    gplt = getGadflyContext(plt)
-    haskey(d, :title) && findGuideAndSet(gplt, Gadfly.Guide.title, string(d[:title]))
-    haskey(d, :xguide) && findGuideAndSet(gplt, Gadfly.Guide.xlabel, string(d[:xguide]))
-    haskey(d, :yguide) && findGuideAndSet(gplt, Gadfly.Guide.ylabel, string(d[:yguide]))
-
-    xlims, xfunc = addGadflyLimitsScale(gplt, d, true)
-    ylims, yfunc = addGadflyLimitsScale(gplt, d, false)
-
-    ticks = get(d, :xticks, :auto)
-    if ticks == :none
-        _remove_axis(plt, true)
-    else
-        addGadflyTicksGuide(gplt, ticks, true)
-    end
-    ticks = get(d, :yticks, :auto)
-    if ticks == :none
-        _remove_axis(plt, false)
-    else
-        addGadflyTicksGuide(gplt, ticks, false)
-    end
-
-    updateGadflyAxisFlips(gplt, d, xlims, ylims, xfunc, yfunc)
-end
-
-function updateGadflyPlotTheme(plt::Plot, d::KW)
-    kwargs = KW()
-
-    # colors
-    insidecolor, gridcolor, textcolor, guidecolor, legendcolor =
-        map(s -> getColor(d[s]), (
-            :background_color_inside,
-            :foreground_color_grid,
-            :foreground_color_text,
-            :foreground_color_guide,
-            :foreground_color_legend
-        ))
-
-    # # hide the legend?
-    leg = d[d[:legend] == :none ? :colorbar : :legend]
-    if leg != :best
-        kwargs[:key_position] = leg == :inside ? :right : leg
-    end
-
-    if !get(d, :grid, true)
-        kwargs[:grid_color] = gridcolor
-    end
-
-    # fonts
-    tfont, gfont, lfont = d[:tickfont], d[:guidefont], d[:legendfont]
-
-    getGadflyContext(plt).theme = Gadfly.Theme(;
-        background_color = insidecolor,
-        minor_label_color = textcolor,
-        minor_label_font = tfont.family,
-        minor_label_font_size = tfont.pointsize * Gadfly.pt,
-        major_label_color = guidecolor,
-        major_label_font = gfont.family,
-        major_label_font_size = gfont.pointsize * Gadfly.pt,
-        key_title_color = guidecolor,
-        key_title_font = gfont.family,
-        key_title_font_size = gfont.pointsize * Gadfly.pt,
-        key_label_color = legendcolor,
-        key_label_font = lfont.family,
-        key_label_font_size = lfont.pointsize * Gadfly.pt,
-        plot_padding = 1 * Gadfly.mm,
-        kwargs...
-    )
-end
-
-# ----------------------------------------------------------------
-
-
-function createGadflyAnnotationObject(x, y, val::@compat(AbstractString))
-    Gadfly.Guide.annotation(Compose.compose(
-                              Compose.context(),
-                              Compose.text(x, y, val)
-                            ))
-end
-
-function createGadflyAnnotationObject(x, y, txt::PlotText)
-    halign = (txt.font.halign == :hcenter ? Compose.hcenter : (txt.font.halign == :left ? Compose.hleft : Compose.hright))
-    valign = (txt.font.valign == :vcenter ? Compose.vcenter : (txt.font.valign == :top ? Compose.vtop : Compose.vbottom))
-    rotations = (txt.font.rotation == 0.0 ? [] : [Compose.Rotation(txt.font.rotation, Compose.Point(Compose.x_measure(x), Compose.y_measure(y)))])
-    Gadfly.Guide.annotation(Compose.compose(
-                              Compose.context(),
-                              Compose.text(x, y, txt.str, halign, valign, rotations...),
-                              Compose.font(string(txt.font.family)),
-                              Compose.fontsize(txt.font.pointsize * Gadfly.pt),
-                              Compose.stroke(txt.font.color),
-                              Compose.fill(txt.font.color)
-                            ))
-end
-
-function _add_annotations{X,Y,V}(plt::Plot{GadflyBackend}, anns::AVec{@compat(Tuple{X,Y,V})})
-    for ann in anns
-        push!(plt.o.guides, createGadflyAnnotationObject(ann...))
-    end
-end
-
-
-# ---------------------------------------------------------------------------
-
-# create a blank Gadfly.Plot object
-# function _create_plot(pkg::GadflyBackend, d::KW)
-#     gplt = createGadflyPlotObject(d)
-#     Plot(gplt, pkg, 0, d, KW[])
-# end
-function _create_backend_figure(plt::Plot{GadflyBackend})
-    createGadflyPlotObject(plt.attr)
-end
-
-
-# plot one data series
-# function _series_added(::GadflyBackend, plt::Plot, d::KW)
-function _series_added(plt::Plot{GadflyBackend}, series::Series)
-    # first clear out the temporary layer
-    gplt = getGadflyContext(plt)
-    if gplt.layers[1].geom.tag == :remove
-        gplt.layers = gplt.layers[2:end]
-    end
-
-    addGadflySeries!(plt, series.d)
-    # push!(plt.seriesargs, d)
-    # plt
-end
-
-
-
-function _update_plot_object(plt::Plot{GadflyBackend}, d::KW)
-    updateGadflyGuides(plt, d)
-    updateGadflyPlotTheme(plt, d)
-end
-
-
-# ----------------------------------------------------------------
-
-# accessors for x/y data
-
-# TODO: need to save all the layer indices which apply to this series
-function getGadflyMappings(plt::Plot, i::Integer)
-    @assert i > 0 && i <= plt.n
-    mappings = [l.mapping for l in plt.seriesargs[i][:gadflylayers]]
-end
-
-function getxy(plt::Plot{GadflyBackend}, i::Integer)
-    mapping = getGadflyMappings(plt, i)[1]
-    mapping[:x], mapping[:y]
-end
-
-function setxy!{X,Y}(plt::Plot{GadflyBackend}, xy::Tuple{X,Y}, i::Integer)
-    for mapping in getGadflyMappings(plt, i)
-        mapping[:x], mapping[:y] = xy
-    end
-    plt
-end
-
-# ----------------------------------------------------------------
-
-
-# # create the underlying object (each backend will do this differently)
-# function _create_subplot(subplt::Subplot{GadflyBackend}, isbefore::Bool)
-#     isbefore && return false # wait until after plotting to create the subplots
-#     subplt.o = nothing
-#     true
-# end
-
-
-function _remove_axis(plt::Plot{GadflyBackend}, isx::Bool)
-    gplt = getGadflyContext(plt)
-    addOrReplace(gplt.guides, isx ? Gadfly.Guide.xticks : Gadfly.Guide.yticks; label=false)
-    addOrReplace(gplt.guides, isx ? Gadfly.Guide.xlabel : Gadfly.Guide.ylabel, "")
-end
-
-function _expand_limits(lims, plt::Plot{GadflyBackend}, isx::Bool)
-    for l in getGadflyContext(plt).layers
-        _expand_limits(lims, l.mapping[isx ? :x : :y])
-    end
-end
-
-
-# ----------------------------------------------------------------
-
-
-getGadflyContext(plt::Plot{GadflyBackend}) = plt.o
-# getGadflyContext(subplt::Subplot{GadflyBackend}) = buildGadflySubplotContext(subplt)
-
-# # create my Compose.Context grid by hstacking and vstacking the Gadfly.Plot objects
-# function buildGadflySubplotContext(subplt::Subplot)
-#     rows = Any[]
-#     row = Any[]
-#     for (i,(r,c)) in enumerate(subplt.layout)
-#
-#         # add the Plot object to the row
-#         push!(row, getGadflyContext(subplt.plts[i]))
-#
-#         # add the row
-#         if c == ncols(subplt.layout, r)
-#             push!(rows, Gadfly.hstack(row...))
-#             row = Any[]
-#         end
-#     end
-#
-#     # stack the rows
-#     Gadfly.vstack(rows...)
-# end
-
-setGadflyDisplaySize(w,h) = Compose.set_default_graphic_size(w * Compose.px, h * Compose.px)
-setGadflyDisplaySize(plt::Plot) = setGadflyDisplaySize(plt.attr[:size]...)
-# setGadflyDisplaySize(subplt::Subplot) = setGadflyDisplaySize(getattr(subplt, 1)[:size]...)
-# -------------------------------------------------------------------------
-
-
-function dowritemime{P<:Union{GadflyBackend,ImmerseBackend}}(io::IO, func, plt::AbstractPlot{P})
-    gplt = getGadflyContext(plt)
-    setGadflyDisplaySize(plt)
-    Gadfly.draw(func(io, Compose.default_graphic_width, Compose.default_graphic_height), gplt)
-end
-
-getGadflyWriteFunc(::MIME"image/png") = Gadfly.PNG
-getGadflyWriteFunc(::MIME"image/svg+xml") = Gadfly.SVG
-# getGadflyWriteFunc(::MIME"text/html") = Gadfly.SVGJS
-getGadflyWriteFunc(::MIME"application/pdf") = Gadfly.PDF
-getGadflyWriteFunc(::MIME"application/postscript") = Gadfly.PS
-getGadflyWriteFunc(::MIME"application/x-tex") = Gadfly.PGF
-getGadflyWriteFunc(m::MIME) = error("Unsupported in Gadfly/Immerse: ", m)
-
-for mime in (MIME"image/png", MIME"image/svg+xml", MIME"application/pdf", MIME"application/postscript", MIME"application/x-tex")
-    @eval function Base.writemime{P<:Union{GadflyBackend,ImmerseBackend}}(io::IO, ::$mime, plt::AbstractPlot{P})
-        func = getGadflyWriteFunc($mime())
-        dowritemime(io, func, plt)
-    end
-end
-
-
-
-function Base.display(::PlotsDisplay, plt::Plot{GadflyBackend})
-    setGadflyDisplaySize(plt.attr[:size]...)
-    display(plt.o)
-end
-
-
-# function Base.display(::PlotsDisplay, subplt::Subplot{GadflyBackend})
-#     setGadflyDisplaySize(getattr(subplt,1)[:size]...)
-#     ctx = buildGadflySubplotContext(subplt)
-#
-#     # taken from Gadfly since I couldn't figure out how to do it directly
-#
-#     filename = string(Gadfly.tempname(), ".html")
-#     output = open(filename, "w")
-#
-#     plot_output = IOBuffer()
-#     Gadfly.draw(Gadfly.SVGJS(plot_output, Compose.default_graphic_width,
-#              Compose.default_graphic_height, false), ctx)
-#     plotsvg = takebuf_string(plot_output)
-#
-#     write(output,
-#       """
-#       <!DOCTYPE html>
-#       <html>
-#         <head>
-#           <title>Gadfly Plot</title>
-#           <meta charset="utf-8">
-#         </head>
-#           <body>
-#           <script charset="utf-8">
-#               $(readall(Compose.snapsvgjs))
-#           </script>
-#           <script charset="utf-8">
-#               $(readall(Gadfly.gadflyjs))
-#           </script>
-#           $(plotsvg)
-#         </body>
-#       </html>
-#       """)
-#     close(output)
-#     Gadfly.open_file(filename)
-# end
@@ -1,93 +0,0 @@
-
-
-# Geometry which displays arbitrary shapes at given (x, y) positions.
-# note: vertices is a list of shapes
-immutable ShapeGeometry <: Gadfly.GeometryElement
-    vertices::AbstractVector #{Tuple{Float64,Float64}}
-    tag::Symbol
-
-    function ShapeGeometry(shape; tag::Symbol=Gadfly.Geom.empty_tag)
-        new(shape, tag)
-    end
-end
-
-# TODO: add for PR
-# const shape = ShapeGeometry
-
-
-function Gadfly.element_aesthetics(::ShapeGeometry)
-    [:x, :y, :size, :color]
-end
-
-
-# Generate a form for a shape geometry.
-#
-# Args:
-#   geom: shape geometry.
-#   theme: the plot's theme.
-#   aes: aesthetics.
-#
-# Returns:
-#   A compose Form.
-#
-function Gadfly.render(geom::ShapeGeometry, theme::Gadfly.Theme, aes::Gadfly.Aesthetics)
-
-    # TODO: add for PR
-    # Gadfly.assert_aesthetics_defined("Geom.shape", aes, :x, :y)
-    # Gadfly.assert_aesthetics_equal_length("Geom.shape", aes,
-    #                                       element_aesthetics(geom)...)
-
-    default_aes = Gadfly.Aesthetics()
-    default_aes.color = Gadfly.DataFrames.PooledDataArray(RGBA{Float32}[theme.default_color])
-    default_aes.size = Compose.Measure[theme.default_point_size]
-    aes = Gadfly.inherit(aes, default_aes)
-
-    lw_hover_scale = 10
-    lw_ratio = theme.line_width / aes.size[1]
-
-    aes_x, aes_y = Gadfly.concretize(aes.x, aes.y)
-
-    ctx = Compose.compose!(
-        Compose.context(),
-        make_polygon(geom, aes.x, aes.y, aes.size),
-        Compose.fill(aes.color),
-        Compose.linewidth(theme.highlight_width))
-
-    if aes.color_key_continuous != nothing && aes.color_key_continuous
-        Compose.compose!(ctx,
-            Compose.stroke(map(theme.continuous_highlight_color, aes.color)))
-    else
-        Compose.compose!(ctx,
-            Compose.stroke(map(theme.discrete_highlight_color, aes.color)),
-            Compose.svgclass([Gadfly.svg_color_class_from_label(Gadfly.escape_id(aes.color_label([c])[1]))
-                      for c in aes.color]))
-    end
-
-    return Compose.compose!(Compose.context(order=4), Compose.svgclass("geometry"), ctx)
-end
-
-function gadflyshape(sv::Shape)
-  ShapeGeometry(Any[vertices(sv)])
-end
-
-function gadflyshape(sv::AVec{Shape})
-    ShapeGeometry(Any[vertices(s) for s in sv])
-end
-
-
-# create a Compose context given a ShapeGeometry and the xs/ys/sizes
-function make_polygon(geom::ShapeGeometry, xs::AbstractArray, ys::AbstractArray, rs::AbstractArray)
-  n = max(length(xs), length(ys), length(rs))
-  T = Tuple{Compose.Measure, Compose.Measure}
-  polys = Array(Vector{T}, n)
-  for i in 1:n
-    x = Compose.x_measure(xs[mod1(i, length(xs))])
-    y = Compose.y_measure(ys[mod1(i, length(ys))])
-    r = rs[mod1(i, length(rs))]
-    polys[i] = T[(x + r * sx, y + r * sy) for (sx,sy) in cycle(geom.vertices, i)]
-  end
-  Gadfly.polygon(polys, geom.tag)
-end
-
-
-# ---------------------------------------------------------------------------------------------
@@ -1,298 +0,0 @@
-
-
-# [WEBSITE]
-
-supported_args(::GLVisualizeBackend) = 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, :levels,
-    # :ribbon, :quiver, :arrow,
-    # :orientation,
-    # :overwrite_figure,
-    # :polar,
-    # :normalize, :weights,
-    # :contours, :aspect_ratio,
-    # :match_dimensions,
-    # :clims,
-    # :inset_subplots,
-  ])
-supported_types(::GLVisualizeBackend) = [:surface, :scatter, :scatter3d, :path, :path3d]
-supported_styles(::GLVisualizeBackend) = [:auto, :solid]
-supported_markers(::GLVisualizeBackend) = vcat([:none, :auto, :circle], collect(keys(_gl_marker_map)))
-supported_scales(::GLVisualizeBackend) = [:identity]
-is_subplot_supported(::GLVisualizeBackend) = true
-
-# --------------------------------------------------------------------------------------
-
-
-function _initialize_backend(::GLVisualizeBackend; kw...)
-    @eval begin
-        import GLVisualize, GeometryTypes, GLAbstraction, GLWindow
-        import GeometryTypes: Point2f0, Point3f0, Vec2f0, Vec3f0
-        export GLVisualize
-
-        # TODO: remove this when PlotUtils is registered
-        import PlotUtils
-    end
-end
-
-# ---------------------------------------------------------------------------
-
-# initialize the figure/window
-function _create_backend_figure(plt::Plot{GLVisualizeBackend})
-    # init a screen
-    screen = if isdefined(GLVisualize, :ROOT_SCREEN)
-        GLVisualize.ROOT_SCREEN
-    else
-        s = GLVisualize.glscreen()
-        @async GLVisualize.renderloop(s)
-        s
-    end
-    empty!(screen)
-    screen
-end
-
-# ---------------------------------------------------------------------------
-
-# size as a percentage of the window size
-function gl_relative_size(plt::Plot{GLVisualizeBackend}, msize::Number)
-    winsz = min(plt[:size]...)
-    Float32(msize / winsz)
-end
-
-const _gl_marker_map = KW(
-  :rect => '■',
-  :star5 => '★',
-  :diamond => '◆',
-  :hexagon => '⬢',
-  :cross => '✚',
-  :xcross => '❌',
-  :utriangle => '▲',
-  :dtriangle => '▼',
-  :pentagon => '⬟',
-  :octagon => '⯄',
-  :star4 => '✦',
-  :star6 => '✶',
-  :star8 => '✷',
-  :vline => '┃',
-  :hline => '━',
-)
-
-
-# create a marker/shape type
-function gl_marker(shape::Symbol, msize::Number, _3d::Bool)
-    GeometryTypes.HyperSphere((_3d ? Point3f0 : Point2f0)(0), msize)
-end
-
-gl_color(c::RGBA{Float32}) = c
-
-# convert to RGBA
-function gl_color(c, a=nothing)
-    c = convertColor(c, a)
-    RGBA{Float32}(getColor(c))
-end
-
-function gl_viewport(bb, rect)
-    l, b, bw, bh = bb
-    rw, rh = rect.w, rect.h
-    GLVisualize.SimpleRectangle(
-        round(Int, rect.x + rw * l),
-        round(Int, rect.y + rh * b),
-        round(Int, rw * bw),
-        round(Int, rh * bh)
-    )
-end
-
-gl_make_points(x, y) = Point2f0[Point2f0(x[i], y[i]) for i=1:length(x)]
-gl_make_points(x, y, z) = Point3f0[Point3f0(x[i], y[i], z[i]) for i=1:length(x)]
-
-function gl_draw_lines_2d(x, y, color, linewidth, sp_screen)
-    color = gl_color(color)
-    thickness = Float32(linewidth)
-    for rng in iter_segments(x, y)
-        n = length(rng)
-        n < 2 && continue
-        viz = GLVisualize.visualize(
-            gl_make_points(x[rng], y[rng]),
-            n==2 ? :linesegment : :lines,
-            color=color,
-            thickness = Float32(linewidth)
-        )
-        GLVisualize.view(viz, sp_screen, camera=:orthographic_pixel)
-    end
-end
-
-function gl_draw_lines_3d(x, y, z, color, linewidth, sp_screen)
-    color = gl_color(color)
-    thickness = Float32(linewidth)
-    for rng in iter_segments(x, y, z)
-        n = length(rng)
-        n < 2 && continue
-        viz = GLVisualize.visualize(
-            gl_make_points(x[rng], y[rng], z[rng]),
-            n==2 ? :linesegment : :lines,
-            color=color,
-            thickness = Float32(linewidth)
-        )
-        GLVisualize.view(viz, sp_screen, camera=:perspective)
-    end
-end
-
-function gl_annotate(sp::Subplot{GLVisualizeBackend}, x, y, txt::PlotText)
-end
-
-function gl_draw_axes_2d(sp::Subplot{GLVisualizeBackend})
-    sp_screen = sp.o
-    xaxis = sp[:xaxis]
-    xmin, xmax = axis_limits(xaxis)
-    yaxis = sp[:yaxis]
-    ymin, ymax = axis_limits(yaxis)
-
-    # x axis
-    xsegs, ysegs = Segments(), Segments()
-    ticksz = 0.03*(ymax-ymin)
-    push!(xsegs, [xmin,xmax]); push!(ysegs, [ymin,ymin])
-    for tick in PlotUtils.optimize_ticks(xmin, xmax)[1]
-        push!(xsegs, [tick,tick]); push!(ysegs, [ymin,ymin+ticksz])
-        # TODO: add the ticklabel
-    end
-    gl_draw_lines_2d(xsegs.pts, ysegs.pts, xaxis[:foreground_color_border], 1, sp_screen)
-
-    # y axis
-    xsegs, ysegs = Segments(), Segments()
-    push!(xsegs, [xmin,xmin]); push!(ysegs, [ymin,ymax])
-    for tick in PlotUtils.optimize_ticks(xmin, xmax)[1]
-        push!(xsegs, [xmin,xmin+ticksz]); push!(ysegs, [tick,tick])
-        # TODO: add the ticklabel
-    end
-    gl_draw_lines_2d(xsegs.pts, ysegs.pts, yaxis[:foreground_color_border], 1, sp_screen)
-end
-
-# ---------------------------------------------------------------------------
-
-# draw everything
-function gl_display(plt::Plot{GLVisualizeBackend})
-    screen = plt.o
-    sw, sh = plt[:size]
-    sw, sh = sw*px, sh*px
-    for (name, sp) in plt.spmap
-
-        _3d = is3d(sp)
-        camera = _3d ? :perspective : :orthographic_pixel
-        # camera = :perspective
-
-        # initialize the sub-screen for this subplot
-        # note: we create a lift function to update the size on resize
-        rel_bbox = bbox_to_pcts(bbox(sp), sw, sh)
-        f = rect -> gl_viewport(rel_bbox, rect)
-        sp_screen = GLVisualize.Screen(
-            screen,
-            name = name,
-            area = GLVisualize.const_lift(f, screen.area)
-        )
-
-        sp.o = sp_screen
-        if !is3d(sp)
-            gl_draw_axes_2d(sp)
-        end
-
-        # loop over the series and add them to the subplot
-        for series in series_list(sp)
-            d = series.d
-            st = d[:seriestype]
-            x, y = map(Float32, d[:x]), map(Float32, d[:y])
-            msize = gl_relative_size(plt, d[:markersize])
-
-            viz = if st == :surface
-                # TODO: can pass just the ranges and surface
-                ismatrix(x) || (x = repmat(x', length(y), 1))
-                ismatrix(y) || (y = repmat(y, 1, length(x)))
-                z = transpose_z(d, map(Float32, d[:z].surf), false)
-                viz = GLVisualize.visualize((x, y, z), :surface)
-                GLVisualize.view(viz, sp_screen, camera = :perspective)
-
-            else
-                # paths and scatters
-
-                _3d && (z = map(Float32, d[:z]))
-
-                # paths?
-                lw = d[:linewidth]
-                if lw > 0
-                    c = gl_color(d[:linecolor], d[:linealpha])
-                    if _3d
-                        gl_draw_lines_3d(x, y, z, c, lw, sp_screen)
-                    else
-                        gl_draw_lines_2d(x, y, c, lw, sp_screen)
-                    end
-                end
-                
-                # markers?
-                if st in (:scatter, :scatter3d) || d[:markershape] != :none
-                    extrakw = KW()
-                    c = gl_color(d[:markercolor], d[:markeralpha])
-
-                    # get the marker
-                    shape = d[:markershape] 
-                    shape = get(_gl_marker_map, shape, shape)
-                    marker = if isa(shape, Char)
-                        # extrakw[:scale] = Vec2f0(_3d ? 0.6*d[:markersize] : msize)
-                        extrakw[:scale] = Vec2f0(msize)
-                        shape
-                    else
-                        gl_marker(d[:markershape], msize, _3d)
-                    end
-
-                    if !_3d
-                        extrakw[:billboard] = true
-                    end
-
-                    points = _3d ? gl_make_points(x,y,z) : gl_make_points(x,y)
-                    viz = GLVisualize.visualize(
-                        (marker, points);
-                        color = c,
-                        extrakw...
-                    )
-                    GLVisualize.view(viz, sp_screen, camera = camera)
-
-                    # TODO: might need to switch to these forms later?
-                    # GLVisualize.visualize((marker ,(x, y, z)))
-                    #GLVisualize.visualize((marker , map(Point3f0, zip(x, y, z),
-                    # billboard=true
-                    #))
-                end
-            end
-        end
-        GLAbstraction.center!(sp_screen, camera)
-    end
-
-    # TODO: render one frame at a time?  (no renderloop)
-    # GLWindow.render_frame(screen)
-end
-
-
-# ----------------------------------------------------------------
-
-function _update_plot_object(plt::Plot{GLVisualizeBackend})
-    gl_display(plt)
-end
-
-# function _writemime(io::IO, ::MIME"image/png", plt::AbstractPlot{GLVisualizeBackend})
-#     # TODO: write a png to io
-# end
-
-function _display(plt::Plot{GLVisualizeBackend})
-end
@@ -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
@@ -1,186 +0,0 @@
-
-# https://github.com/JuliaGraphics/Immerse.jl
-
-supported_args(::ImmerseBackend) = supported_args(GadflyBackend())
-supported_types(::ImmerseBackend) = supported_types(GadflyBackend())
-supported_styles(::ImmerseBackend) = supported_styles(GadflyBackend())
-supported_markers(::ImmerseBackend) = supported_markers(GadflyBackend())
-supported_scales(::ImmerseBackend) = supported_scales(GadflyBackend())
-is_subplot_supported(::ImmerseBackend) = true
-
-# --------------------------------------------------------------------------------------
-
-function _initialize_backend(::ImmerseBackend; kw...)
-  @eval begin
-    import Immerse, Gadfly, Compose, Gtk
-    export Immerse, Gadfly, Compose, Gtk
-    include(joinpath(Pkg.dir("Plots"), "src", "backends", "gadfly_shapes.jl"))
-  end
-end
-
-function createImmerseFigure(d::KW)
-  w,h = d[:size]
-  figidx = Immerse.figure(; name = d[:window_title], width = w, height = h)
-  Immerse.Figure(figidx)
-end
-
-# ----------------------------------------------------------------
-
-
-# create a blank Gadfly.Plot object
-# function _create_plot(pkg::ImmerseBackend, d::KW)
-#   # create the underlying Gadfly.Plot object
-#   gplt = createGadflyPlotObject(d)
-#
-#   # save both the Immerse.Figure and the Gadfly.Plot
-#   Plot((nothing,gplt), pkg, 0, d, KW[])
-# end
-function _create_backend_figure(plt::Plot{ImmerseBackend})
-    (nothing, createGadflyPlotObject(plt.attr))
-end
-
-
-# # plot one data series
-# function _series_added(::ImmerseBackend, plt::Plot, d::KW)
-#   addGadflySeries!(plt, d)
-#   push!(plt.seriesargs, d)
-#   plt
-# end
-
-function _series_added(plt::Plot{ImmerseBackend}, series::Series)
-    addGadflySeries!(plt, series.d)
-end
-
-
-function _update_plot_object(plt::Plot{ImmerseBackend}, d::KW)
-  updateGadflyGuides(plt, d)
-  updateGadflyPlotTheme(plt, d)
-end
-
-
-
-# ----------------------------------------------------------------
-
-function _add_annotations{X,Y,V}(plt::Plot{ImmerseBackend}, anns::AVec{@compat(Tuple{X,Y,V})})
-  for ann in anns
-    push!(getGadflyContext(plt).guides, createGadflyAnnotationObject(ann...))
-  end
-end
-
-# ----------------------------------------------------------------
-
-# accessors for x/y data
-
-function getxy(plt::Plot{ImmerseBackend}, i::Integer)
-  mapping = getGadflyMappings(plt, i)[1]
-  mapping[:x], mapping[:y]
-end
-
-function setxy!{X,Y}(plt::Plot{ImmerseBackend}, xy::Tuple{X,Y}, i::Integer)
-  for mapping in getGadflyMappings(plt, i)
-    mapping[:x], mapping[:y] = xy
-  end
-  plt
-end
-
-
-# ----------------------------------------------------------------
-
-
-# function _create_subplot(subplt::Subplot{ImmerseBackend}, isbefore::Bool)
-#   return false
-#   # isbefore && return false
-# end
-#
-# function showSubplotObject(subplt::Subplot{ImmerseBackend})
-#   # create the Gtk window with vertical box vsep
-#   d = getattr(subplt,1)
-#   w,h = d[:size]
-#   vsep = Gtk.GtkBoxLeaf(:v)
-#   win = Gtk.GtkWindowLeaf(vsep, d[:window_title], w, h)
-#
-#   figindices = []
-#   row = Gtk.GtkBoxLeaf(:h)
-#   push!(vsep, row)
-#   for (i,(r,c)) in enumerate(subplt.layout)
-#     plt = subplt.plts[i]
-#
-#     # get the components... box is the main plot GtkBox, and canvas is the GtkCanvas where it's plotted
-#     box, toolbar, canvas = Immerse.createPlotGuiComponents()
-#
-#     # add the plot's box to the row
-#     push!(row, box)
-#
-#     # create the figure and store the index returned for destruction later
-#     figidx = Immerse.figure(canvas)
-#     push!(figindices, figidx)
-#
-#     fig = Immerse.figure(figidx)
-#     plt.o = (fig, plt.o[2])
-#
-#     # add the row
-#     if c == ncols(subplt.layout, r)
-#       row = Gtk.GtkBoxLeaf(:h)
-#       push!(vsep, row)
-#     end
-#
-#   end
-#
-#   # destructor... clean up plots
-#   Gtk.on_signal_destroy((x...) -> ([Immerse.dropfig(Immerse._display,i) for i in figindices]; subplt.o = nothing), win)
-#
-#   subplt.o = win
-#   true
-# end
-
-
-function _remove_axis(plt::Plot{ImmerseBackend}, isx::Bool)
-  gplt = getGadflyContext(plt)
-  addOrReplace(gplt.guides, isx ? Gadfly.Guide.xticks : Gadfly.Guide.yticks; label=false)
-  addOrReplace(gplt.guides, isx ? Gadfly.Guide.xlabel : Gadfly.Guide.ylabel, "")
-end
-
-function _expand_limits(lims, plt::Plot{ImmerseBackend}, isx::Bool)
-  for l in getGadflyContext(plt).layers
-    _expand_limits(lims, l.mapping[isx ? :x : :y])
-  end
-end
-
-
-# ----------------------------------------------------------------
-
-getGadflyContext(plt::Plot{ImmerseBackend}) = plt.o[2]
-# getGadflyContext(subplt::Subplot{ImmerseBackend}) = buildGadflySubplotContext(subplt)
-
-
-function Base.display(::PlotsDisplay, plt::Plot{ImmerseBackend})
-
-  fig, gplt = plt.o
-  if fig == nothing
-    fig = createImmerseFigure(plt.attr)
-    Gtk.on_signal_destroy((x...) -> (Immerse.dropfig(Immerse._display, fig.figno); plt.o = (nothing,gplt)), fig.canvas)
-    plt.o = (fig, gplt)
-  end
-
-  Immerse.figure(fig.figno; displayfig = false)
-  display(gplt)
-end
-
-
-# function Base.display(::PlotsDisplay, subplt::Subplot{ImmerseBackend})
-#
-#   # if we haven't created the window yet, do it
-#   if subplt.o == nothing
-#     showSubplotObject(subplt)
-#   end
-#
-#   # display the plots by creating a fresh Immerse.Figure object from the GtkCanvas and Gadfly.Plot
-#   for plt in subplt.plts
-#     fig, gplt = plt.o
-#     Immerse.figure(fig.figno; displayfig = false)
-#     display(gplt)
-#   end
-#
-#   # o is the window... show it
-#   showall(subplt.o)
-# end
@@ -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
@@ -2,54 +2,6 @@

 # significant contributions by: @pkofod

-supported_args(::PGFPlotsBackend) = 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, :lims, :ticks, :scale, :flip, :rotation,
-    :tickfont, :guidefont, :legendfont,
-    :grid, :legend,
-    # :colorbar,
-    # :marker_z, :levels,
-    # :ribbon, :quiver, :arrow,
-    # :orientation,
-    # :overwrite_figure,
-    # :polar,
-    # :normalize, :weights, :contours,
-    :aspect_ratio,
-    # :match_dimensions,
-  ])
-supported_types(::PGFPlotsBackend) = [:path, :path3d, :scatter, :steppre, :stepmid, :steppost, :histogram2d, :ysticks, :xsticks, :contour]
-supported_styles(::PGFPlotsBackend) = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
-supported_markers(::PGFPlotsBackend) = [:none, :auto, :circle, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5, :pentagon] #vcat(_allMarkers, Shape)
-supported_scales(::PGFPlotsBackend) = [:identity, :ln, :log2, :log10]
-is_subplot_supported(::PGFPlotsBackend) = false
-
-
-# --------------------------------------------------------------------------------------
-
-
-function _initialize_backend(::PGFPlotsBackend; kw...)
-    @eval begin
-        import PGFPlots
-        export PGFPlots
-    end
-end
-
-
 # --------------------------------------------------------------------------------------

 const _pgfplots_linestyles = KW(
@@ -64,6 +16,8 @@ const _pgfplots_markers = KW(
    :none => "none",
    :cross => "+",
    :xcross => "x",
+    :+ => "+",
+    :x => "x",
    :utriangle => "triangle*",
    :dtriangle => "triangle*",
    :circle => "*",
@@ -72,6 +26,8 @@ const _pgfplots_markers = KW(
    :star6 => "asterisk",
    :diamond => "diamond*",
    :pentagon => "pentagon*",
+    :hline => "-",
+    :vline => "|"
 )

 const _pgfplots_legend_pos = KW(
@@ -79,6 +35,7 @@ const _pgfplots_legend_pos = KW(
    :bottomright => "south east",
    :topright => "north east",
    :topleft => "north west",
+    :outertopright => "outer north east",
 )


@@ -91,73 +48,133 @@ const _pgf_series_extrastyle = KW(
    :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, a = nothing)
-    c = getColor(c)
+function pgf_color(c::Colorant)
    cstr = @sprintf("{rgb,1:red,%.8f;green,%.8f;blue,%.8f}", red(c), green(c), blue(c))
-    a = float(a == nothing ? alpha(c) : a)
-    cstr, a
+    cstr, alpha(c)
 end

-function pgf_fillstyle(d::KW)
-    cstr,a = pgf_color(d[:fillcolor], d[:fillalpha])
+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(d::KW)
-    cstr,a = pgf_color(d[:linecolor], d[:linealpha])
+function pgf_linestyle(linewidth::Real, color, α = 1, linestyle = "solid")
+    cstr, a = pgf_color(plot_color(color, α))
    """
    color = $cstr,
-    draw opacity=$a,
-    line width=$(d[:linewidth]),
-    $(get(_pgfplots_linestyles, d[:linestyle], "solid"))"""
+    draw opacity = $a,
+    line width = $linewidth,
+    $(get(_pgfplots_linestyles, linestyle, "solid"))"""
 end

-function pgf_marker(d::KW)
-    shape = d[:markershape]
-    cstr, a = pgf_color(d[:markercolor], d[:markeralpha])
-    cstr_stroke, a_stroke = pgf_color(d[:markerstrokecolor], d[:markerstrokealpha])
+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 = $(0.5 * d[:markersize]),
+    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 = $(d[:markerstrokewidth]),
+        line width = $(pgf_thickness_scaling(plotattributes) * _cycle(plotattributes[:markerstrokewidth], i)),
        rotate = $(shape == :dtriangle ? 180 : 0),
-        $(get(_pgfplots_linestyles, d[:markerstrokestyle], "solid"))
+        $(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)
-    d = series.d
-    st = d[:seriestype]
-    style = []
-    kw = KW()
-
-    push!(style, pgf_linestyle(d))
-    push!(style, pgf_marker(d))
-
-    if d[:fillrange] != nothing
-        push!(style, pgf_fillstyle(d))
-    end
-
-    # add to legend?
-    if sp[:legend] != :none && should_add_to_legend(series)
-        kw[:legendentry] = d[:label]
-    end
+    plotattributes = series.plotattributes
+    st = plotattributes[:seriestype]
+    series_collection = PGFPlots.Plot[]

    # function args
-    args = if st  == :contour
-        d[:z].surf, d[:x], d[:y]
+    args = if st == :contour
+        plotattributes[:z].surf, plotattributes[:x], plotattributes[:y]
    elseif is3d(st)
-        d[:x], d[:y], d[:z]
+        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
-        d[:x], d[:y]
+        plotattributes[:x], plotattributes[:y]
    end

    # PGFPlots can't handle non-Vector?
@@ -166,34 +183,131 @@ function pgf_series(sp::Subplot, series::Series)
        else
            a
        end, args)
-    # for (i,a) in enumerate(args)
-    #     if typeof(a) <: AbstractVector && typeof(a) != Vector
-    #         args[i] = collect(a)
-    #     end
-    # end

-    # include additional style, then add to the kw
+    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

-    # build/return the series object
+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
-    elseif st == :histogram2d
-        PGFPlots.Histogram2
-    elseif st == :contour
-        PGFPlots.Contour
    else
        PGFPlots.Linear
    end
-    func(args...; kw...)
+    return func(([arg[1]] for arg in args)...; kw...)
 end

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

 function pgf_axis(sp::Subplot, letter)
@@ -201,9 +315,27 @@ function pgf_axis(sp::Subplot, letter)
    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")

@@ -214,14 +346,82 @@ function pgf_axis(sp::Subplot, letter)
        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 = axis_limits(axis)
+        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
@@ -229,10 +429,14 @@ end
 # ----------------------------------------------------------------


-function _make_pgf_plot!(plt::Plot)
+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
+       # first build the PGFPlots.Axis object
        style = ["unbounded coords=jump"]
        kw = KW()

@@ -240,26 +444,30 @@ function _make_pgf_plot!(plt::Plot)
        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 = $((height(bb) - (bottom(bb))).value)mm,
-            width = $(width(bb).value)mm,
-            height = $(height(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] != ""
-            push!(style, "title = $(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

-        sp[:grid] && push!(style, "grid = major")
        if sp[:aspect_ratio] in (1, :equal)
            kw[:axisEqual] = "true"
        end
@@ -268,28 +476,82 @@ function _make_pgf_plot!(plt::Plot)
        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)), "}"))

-        o = PGFPlots.Axis(; style = style, kw...)
+        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!(o, pgf_series(sp, series))
+            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 _writemime(io::IO, mime::MIME"image/svg+xml", plt::Plot{PGFPlotsBackend})
-    _make_pgf_plot!(plt)
-    writemime(io, mime, plt.o)
+function _show(io::IO, mime::MIME"image/svg+xml", plt::Plot{PGFPlotsBackend})
+    show(io, mime, plt.o)
 end

-function _writemime(io::IO, mime::MIME"application/pdf", plt::Plot{PGFPlotsBackend})
-    _make_pgf_plot!(plt)
-
+function _show(io::IO, mime::MIME"application/pdf", plt::Plot{PGFPlotsBackend})
    # prepare the object
    pgfplt = PGFPlots.plot(plt.o)

@@ -298,15 +560,20 @@ function _writemime(io::IO, mime::MIME"application/pdf", plt::Plot{PGFPlotsBacke
    PGFPlots.save(PGFPlots.PDF(fn), pgfplt)

    # read it into io
-    write(io, readall(open(fn)))
+    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
-    _make_pgf_plot!(plt)
    pgfplt = PGFPlots.plot(plt.o)

    # save an svg
@@ -1,50 +1,38 @@
-
-# https://github.com/spencerlyon2/PlotlyJS.jl
-
-supported_args(::PlotlyJSBackend) = supported_args(PlotlyBackend())
-supported_types(::PlotlyJSBackend) = supported_types(PlotlyBackend())
-supported_styles(::PlotlyJSBackend) = supported_styles(PlotlyBackend())
-supported_markers(::PlotlyJSBackend) = supported_markers(PlotlyBackend())
-supported_scales(::PlotlyJSBackend) = supported_scales(PlotlyBackend())
-is_subplot_supported(::PlotlyJSBackend) = true
-is_string_supported(::PlotlyJSBackend) = true
+# https://github.com/sglyon/PlotlyJS.jl

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

-function _initialize_backend(::PlotlyJSBackend; kw...)
-    @eval begin
-        import PlotlyJS
-        export PlotlyJS
-    end
-
-    # # override IJulia inline display
-    # if isijulia()
-    #     IJulia.display_dict(plt::AbstractPlot{PlotlyJSBackend}) = IJulia.display_dict(plt.o)
-    # end
-end
-
-# ---------------------------------------------------------------------------
-

 function _create_backend_figure(plt::Plot{PlotlyJSBackend})
-    PlotlyJS.plot()
+    if !isplotnull() && plt[:overwrite_figure] && isa(current().o, PlotlyJS.SyncPlot)
+        PlotlyJS.SyncPlot(PlotlyJS.Plot(), options = current().o.options)
+    else
+        PlotlyJS.plot()
+    end
 end


 function _series_added(plt::Plot{PlotlyJSBackend}, series::Series)
    syncplot = plt.o
-    pdict = plotly_series(plt, series)
-    typ = pop!(pdict, :type)
-    gt = PlotlyJS.GenericTrace(typ; pdict...)
-    PlotlyJS.addtraces!(syncplot, gt)
+    pdicts = plotly_series(plt, series)
+    for pdict in pdicts
+        typ = pop!(pdict, :type)
+        gt = PlotlyJS.GenericTrace(typ; pdict...)
+        PlotlyJS.addtraces!(syncplot, gt)
+    end
 end

 function _series_updated(plt::Plot{PlotlyJSBackend}, series::Series)
    xsym, ysym = (ispolar(series) ? (:t,:r) : (:x,:y))
+    kw = KW(xsym => (series.plotattributes[:x],), ysym => (series.plotattributes[:y],))
+    z = series[:z]
+    if z != nothing
+        kw[:z] = (isa(z,Surface) ? transpose_z(series, series[:z].surf, false) : z,)
+    end
    PlotlyJS.restyle!(
        plt.o,
-        findfirst(plt.series_list, series),
-        KW(xsym => (series.d[:x],), ysym => (series.d[:y],))
+        findfirst(isequal(series), plt.series_list),
+        kw
    )
 end

@@ -61,16 +49,40 @@ end

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

-function _writemime(io::IO, ::MIME"image/svg+xml", plt::Plot{PlotlyJSBackend})
-    writemime(io, MIME("text/html"), plt.o)
+_show(io::IO, ::MIME"text/html", plt::Plot{PlotlyJSBackend}) = show(io, MIME("text/html"), plt.o)
+_show(io::IO, ::MIME"image/svg+xml", plt::Plot{PlotlyJSBackend}) = PlotlyJS.savefig(io, plt.o, format="svg")
+_show(io::IO, ::MIME"image/png", plt::Plot{PlotlyJSBackend}) = PlotlyJS.savefig(io, plt.o, format="png")
+_show(io::IO, ::MIME"application/pdf", plt::Plot{PlotlyJSBackend}) = PlotlyJS.savefig(io, plt.o, format="pdf")
+_show(io::IO, ::MIME"image/eps", plt::Plot{PlotlyJSBackend}) = PlotlyJS.savefig(io, plt.o, format="eps")
+
+function _show(io::IO, m::MIME"application/vnd.plotly.v1+json", plt::Plot{PlotlyJSBackend})
+    show(io, m, plt.o)
 end

-function _writemime(io::IO, ::MIME"image/png", plt::Plot{PlotlyJSBackend})
-    tmpfn = tempname() * ".png"
-    PlotlyJS.savefig(plt.o, tmpfn)
-    write(io, read(open(tmpfn)))
+
+function write_temp_html(plt::Plot{PlotlyJSBackend})
+    filename = string(tempname(), ".html")
+    savefig(plt, filename)
+    filename
 end

 function _display(plt::Plot{PlotlyJSBackend})
-    display(plt.o)
+    if get(ENV, "PLOTS_USE_ATOM_PLOTPANE", true) in (true, 1, "1", "true", "yes")
+        display(plt.o)
+    else
+        standalone_html_window(plt)
+    end
+end
+
+@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
@@ -1,310 +0,0 @@
-
-# https://github.com/tbreloff/Qwt.jl
-
-
-supported_args(::QwtBackend) = merge_with_base_supported([
-    :annotations,
-    :linecolor,
-    :fillrange,
-    :fillcolor,
-    :label,
-    :legend,
-    :seriescolor, :seriesalpha,
-    :linestyle,
-    :linewidth,
-    :markershape,
-    :markercolor,
-    :markersize,
-    :bins,
-    :pos,
-    :title,
-    :window_title,
-    :guide, :lims, :ticks, :scale,
-  ])
-supported_types(::QwtBackend) = [:path, :scatter, :hexbin, :bar]
-supported_markers(::QwtBackend) = [:none, :auto, :rect, :circle, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5, :star8, :hexagon]
-supported_scales(::QwtBackend) = [:identity, :log10]
-is_subplot_supported(::QwtBackend) = true
-
-
-# --------------------------------------------------------------------------------------
-
-function _initialize_backend(::QwtBackend; kw...)
-  @eval begin
-    warn("Qwt is no longer supported... many features will likely be broken.")
-    import Qwt
-    export Qwt
-  end
-end
-
-# -------------------------------
-
-@compat const _qwtAliases = KW(
-    :bins => :heatmap_n,
-    :fillrange => :fillto,
-    :linewidth => :width,
-    :markershape => :marker,
-    :hexbin => :heatmap,
-    :path => :line,
-    :steppost => :step,
-    :steppre => :stepinverted,
-    :star5 => :star1,
-    :star8 => :star2,
-  )
-
-function fixcolors(d::KW)
-  for (k,v) in d
-    if typeof(v) <: ColorScheme
-      d[k] = getColor(v)
-    end
-  end
-end
-
-function replaceQwtAliases(d, s)
-  if haskey(_qwtAliases, d[s])
-    d[s] = _qwtAliases[d[s]]
-  end
-end
-
-function adjustQwtKeywords(plt::Plot{QwtBackend}, iscreating::Bool; kw...)
-  d = KW(kw)
-  st = d[:seriestype]
-  if st == :scatter
-    d[:seriestype] = :none
-    if d[:markershape] == :none
-      d[:markershape] = :circle
-    end
-
-  elseif st in (:hline, :vline)
-    addLineMarker(plt, d)
-    d[:seriestype] = :none
-    d[:markershape] = :circle
-    d[:markersize] = 1
-    if st == :vline
-      d[:x], d[:y] = d[:y], d[:x]
-    end
-
-  elseif !iscreating && st == :bar
-    d = barHack(; kw...)
-  elseif !iscreating && st == :histogram
-    d = barHack(; histogramHack(; kw...)...)
-  end
-
-  replaceQwtAliases(d, :seriestype)
-  replaceQwtAliases(d, :markershape)
-
-  for k in keys(d)
-    if haskey(_qwtAliases, k)
-      d[_qwtAliases[k]] = d[k]
-    end
-  end
-
-  d[:x] = collect(d[:x])
-  d[:y] = collect(d[:y])
-
-  d
-end
-
-# function _create_plot(pkg::QwtBackend, d::KW)
-function _create_backend_figure(plt::Plot{QwtBackend})
-  fixcolors(plt.attr)
-  dumpdict(plt.attr,"\n\n!!! plot")
-  o = Qwt.plot(zeros(0,0); plt.attr..., show=false)
-  # plt = Plot(o, pkg, 0, d, KW[])
-  # plt
-end
-
-# function _series_added(::QwtBackend, plt::Plot, d::KW)
-function _series_added(plt::Plot{QwtBackend}, series::Series)
-  d = adjustQwtKeywords(plt, false; series.d...)
-  fixcolors(d)
-  dumpdict(d,"\n\n!!! plot!")
-  Qwt.oplot(plt.o; d...)
-  # push!(plt.seriesargs, d)
-  # plt
-end
-
-
-# ----------------------------------------------------------------
-
-function updateLimsAndTicks(plt::Plot{QwtBackend}, d::KW, isx::Bool)
-  lims = get(d, isx ? :xlims : :ylims, nothing)
-  ticks = get(d, isx ? :xticks : :yticks, nothing)
-  w = plt.o.widget
-  axisid = Qwt.QWT.QwtPlot[isx ? :xBottom : :yLeft]
-
-  if typeof(lims) <: @compat(Union{Tuple,AVec}) && length(lims) == 2
-    if isx
-      plt.o.autoscale_x = false
-    else
-      plt.o.autoscale_y = false
-    end
-    w[:setAxisScale](axisid, lims...)
-  end
-
-  if typeof(ticks) <: Range
-    if isx
-      plt.o.autoscale_x = false
-    else
-      plt.o.autoscale_y = false
-    end
-    w[:setAxisScale](axisid, float(minimum(ticks)), float(maximum(ticks)), float(step(ticks)))
-  elseif !(ticks in (nothing, :none, :auto))
-    warn("Only Range types are supported for Qwt xticks/yticks. typeof(ticks)=$(typeof(ticks))")
-  end
-
-  # change the scale
-  scalesym = isx ? :xscale : :yscale
-  if haskey(d, scalesym)
-    scaletype = d[scalesym]
-    scaletype == :identity  && w[:setAxisScaleEngine](axisid, Qwt.QWT.QwtLinearScaleEngine())
-    # scaletype == :log       && w[:setAxisScaleEngine](axisid, Qwt.QWT.QwtLogScaleEngine(e))
-    # scaletype == :log2      && w[:setAxisScaleEngine](axisid, Qwt.QWT.QwtLogScaleEngine(2))
-    scaletype == :log10     && w[:setAxisScaleEngine](axisid, Qwt.QWT.QwtLog10ScaleEngine())
-    scaletype in supported_scales() || warn("Unsupported scale type: ", scaletype)
-  end
-
-end
-
-
-function _update_plot_object(plt::Plot{QwtBackend}, d::KW)
-  haskey(d, :title) && Qwt.title(plt.o, d[:title])
-  haskey(d, :xguide) && Qwt.xlabel(plt.o, d[:xguide])
-  haskey(d, :yguide) && Qwt.ylabel(plt.o, d[:yguide])
-  updateLimsAndTicks(plt, d, true)
-  updateLimsAndTicks(plt, d, false)
-end
-
-function _update_plot_pos_size(plt::AbstractPlot{QwtBackend}, d::KW)
-  haskey(d, :size) && Qwt.resizewidget(plt.o, d[:size]...)
-  haskey(d, :pos) && Qwt.movewidget(plt.o, d[:pos]...)
-end
-
-
-# ----------------------------------------------------------------
-
-        # curve.setPen(Qt.QPen(Qt.QColor(color), linewidth, self.getLineStyle(linestyle)))
-function addLineMarker(plt::Plot{QwtBackend}, d::KW)
-  for yi in d[:y]
-    marker = Qwt.QWT.QwtPlotMarker()
-    ishorizontal = (d[:seriestype] == :hline)
-    marker[:setLineStyle](ishorizontal ? 1 : 2)
-    marker[ishorizontal ? :setYValue : :setXValue](yi)
-    qcolor = Qwt.convertRGBToQColor(getColor(d[:linecolor]))
-    linestyle = plt.o.widget[:getLineStyle](string(d[:linestyle]))
-    marker[:setLinePen](Qwt.QT.QPen(qcolor, d[:linewidth], linestyle))
-    marker[:attach](plt.o.widget)
-  end
-
-  # marker[:setValue](x, y)
-  # marker[:setLabel](Qwt.QWT.QwtText(val))
-  # marker[:attach](plt.o.widget)
-end
-
-function createQwtAnnotation(plt::Plot, x, y, val::PlotText)
-  marker = Qwt.QWT.QwtPlotMarker()
-  marker[:setValue](x, y)
-  qwttext = Qwt.QWT.QwtText(val.str)
-  qwttext[:setFont](Qwt.QT.QFont(val.font.family, val.font.pointsize))
-  qwttext[:setColor](Qwt.convertRGBToQColor(getColor(val.font.color)))
-  marker[:setLabel](qwttext)
-  marker[:attach](plt.o.widget)
-end
-
-function createQwtAnnotation(plt::Plot, x, y, val::@compat(AbstractString))
-  marker = Qwt.QWT.QwtPlotMarker()
-  marker[:setValue](x, y)
-  marker[:setLabel](Qwt.QWT.QwtText(val))
-  marker[:attach](plt.o.widget)
-end
-
-function _add_annotations{X,Y,V}(plt::Plot{QwtBackend}, anns::AVec{@compat(Tuple{X,Y,V})})
-  for ann in anns
-    createQwtAnnotation(plt, ann...)
-  end
-end
-
-# ----------------------------------------------------------------
-
-# accessors for x/y data
-
-function getxy(plt::Plot{QwtBackend}, i::Int)
-  series = plt.o.lines[i]
-  series.x, series.y
-end
-
-function setxy!{X,Y}(plt::Plot{QwtBackend}, xy::Tuple{X,Y}, i::Integer)
-  series = plt.o.lines[i]
-  series.x, series.y = xy
-  plt
-end
-
-
-# -------------------------------
-
-# savepng(::QwtBackend, plt::AbstractPlot, fn::@compat(AbstractString), args...) = Qwt.savepng(plt.o, fn)
-
-# -------------------------------
-
-# # create the underlying object (each backend will do this differently)
-# function _create_subplot(subplt::Subplot{QwtBackend}, isbefore::Bool)
-#   isbefore && return false
-#   i = 0
-#   rows = Any[]
-#   row = Any[]
-#   for (i,(r,c)) in enumerate(subplt.layout)
-#     push!(row, subplt.plts[i].o)
-#     if c == ncols(subplt.layout, r)
-#       push!(rows, Qwt.hsplitter(row...))
-#       row = Any[]
-#     end
-#   end
-#   # 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...)
-#   # Qwt.resizewidget(subplt.o, getattr(subplt,1)[:size]...)
-#   # Qwt.moveToLastScreen(subplt.o)  # hack so it goes to my center monitor... sorry
-#   true
-# end
-
-function _expand_limits(lims, plt::Plot{QwtBackend}, isx::Bool)
-  for series in plt.o.lines
-    _expand_limits(lims, isx ? series.x : series.y)
-  end
-end
-
-
-function _remove_axis(plt::Plot{QwtBackend}, isx::Bool)
-end
-
-
-# ----------------------------------------------------------------
-
-function Base.writemime(io::IO, ::MIME"image/png", plt::Plot{QwtBackend})
-  Qwt.refresh(plt.o)
-  Qwt.savepng(plt.o, "/tmp/dfskjdhfkh.png")
-  write(io, readall("/tmp/dfskjdhfkh.png"))
-end
-
-# function Base.writemime(io::IO, ::MIME"image/png", subplt::Subplot{QwtBackend})
-#   for plt in subplt.plts
-#     Qwt.refresh(plt.o)
-#   end
-#   Qwt.savepng(subplt.o, "/tmp/dfskjdhfkh.png")
-#   write(io, readall("/tmp/dfskjdhfkh.png"))
-# end
-
-
-function Base.display(::PlotsDisplay, plt::Plot{QwtBackend})
-  Qwt.refresh(plt.o)
-  Qwt.showwidget(plt.o)
-end
-
-# function Base.display(::PlotsDisplay, subplt::Subplot{QwtBackend})
-#   for plt in subplt.plts
-#     Qwt.refresh(plt.o)
-#   end
-#   Qwt.showwidget(subplt.o)
-# end
@@ -3,14 +3,9 @@

 # [ADD BACKEND WEBSITE]

-function _initialize_backend(::[PkgName]Backend; kw...)
-    @eval begin
-        import [PkgName]
-        export [PkgName]
-        # todo: other initialization that needs to be eval-ed
-    end
-    # todo: other initialization
-end
+import [PkgName]
+export [PkgName]
+push!(_initialized_backends, [pgkname]::Symbol)

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

@@ -54,7 +49,7 @@ end

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

-# Override this to update plot items (title, xlabel, etc), and add annotations (d[:annotations])
+# Override this to update plot items (title, xlabel, etc), and add annotations (plotattributes[:annotations])
 function _update_plot_object(plt::Plot{[PkgName]Backend})
 end

@@ -67,7 +62,7 @@ end
    # "image/png"               => "png",
    # "application/postscript"  => "ps",
    # "image/svg+xml"           => "svg"
-function _writemime(io::IO, ::MIME"image/png", plt::Plot{[PkgName]Backend})
+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).
@@ -1,51 +1,34 @@

 # https://github.com/Evizero/UnicodePlots.jl

-supported_args(::UnicodePlotsBackend) = merge_with_base_supported([
-    :label,
-    :legend,
-    :seriescolor,
-    :seriesalpha,
-    :linestyle,
-    :markershape,
-    :bins,
-    :title,
-    :guide, :lims,
-  ])
-supported_types(::UnicodePlotsBackend) = [
-    :path, :scatter,
-    :histogram2d
-]
-supported_styles(::UnicodePlotsBackend) = [:auto, :solid]
-supported_markers(::UnicodePlotsBackend) = [:none, :auto, :circle]
-supported_scales(::UnicodePlotsBackend) = [:identity]
-is_subplot_supported(::UnicodePlotsBackend) = true
-

 # don't warn on unsupported... there's just too many warnings!!
-warnOnUnsupported_args(pkg::UnicodePlotsBackend, d::KW) = nothing
+warnOnUnsupported_args(::UnicodePlotsBackend, plotattributes::KW) = nothing

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

-function _initialize_backend(::UnicodePlotsBackend; kw...)
-    @eval begin
-        import UnicodePlots
-        export UnicodePlots
-    end
-end
+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)
+function rebuildUnicodePlot!(plt::Plot, width, height)
    plt.o = []

    for sp in plt.subplots
        xaxis = sp[:xaxis]
        yaxis = sp[:yaxis]
-        xlim =  axis_limits(xaxis)
-        ylim =  axis_limits(yaxis)
+        xlim =  axis_limits(sp, :x)
+        ylim =  axis_limits(sp, :y)

        # make vectors
        xlim = [xlim[1], xlim[2]]
@@ -57,8 +40,33 @@ function rebuildUnicodePlot!(plt::Plot)
        y = Float64[ylim[1]]

        # create a plot window with xlim/ylim set, but the X/Y vectors are outside the bounds
-        width, height = plt[:size]
-        canvas_type = isijulia() ? UnicodePlots.AsciiCanvas : UnicodePlots.BrailleCanvas
+        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,
@@ -74,7 +82,7 @@ function rebuildUnicodePlot!(plt::Plot)

        # now use the ! functions to add to the plot
        for series in series_list(sp)
-            addUnicodeSeries!(o, series.d, sp[:legend] != :none, xlim, ylim)
+            addUnicodeSeries!(o, series.plotattributes, sp[:legend] != :none, xlim, ylim)
        end

        # save the object
@@ -84,36 +92,47 @@ end


 # add a single series
-function addUnicodeSeries!(o, d::KW, addlegend::Bool, xlim, ylim)
+function addUnicodeSeries!(o, plotattributes::KW, addlegend::Bool, xlim, ylim)
    # get the function, or special handling for step/bar/hist
-    st = d[:seriestype]
+    st = plotattributes[:seriestype]
    if st == :histogram2d
-        UnicodePlots.densityplot!(o, d[:x], d[:y])
+        UnicodePlots.densityplot!(o, plotattributes[:x], plotattributes[:y])
        return
    end

-    if st == :path
+    if st in (:path, :straightline)
        func = UnicodePlots.lineplot!
-    elseif st == :scatter || d[:markershape] != :none
+    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 = [collect(float(d[s])) for s in (:x, :y)]
-    label = addlegend ? d[: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 = d[:linecolor] in UnicodePlots.color_cycle ? d[:linecolor] : :auto
+    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 `writemime`
+# 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")

@@ -122,7 +141,7 @@ function png(plt::AbstractPlot{UnicodePlotsBackend}, fn::AbstractString)
    gui(plt)

    # @osx_only begin
-    @compat @static if is_apple()
+    @static if Sys.isapple()
        # BEGIN HACK

        # wait while the plot gets drawn
@@ -143,21 +162,21 @@ end

 # we don't do very much for subplots... just stack them vertically

-function _update_plot_object(plt::Plot{UnicodePlotsBackend})
-  w, h = plt[:size]
-  plt.attr[:size] = div(w, 10), div(h, 20)
-  plt.attr[:color_palette] = [RGB(0,0,0)]
-  rebuildUnicodePlot!(plt)
+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 _writemime(io::IO, ::MIME"text/plain", plt::Plot{UnicodePlotsBackend})
-  map(show, plt.o)
-  nothing
+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})
-  map(show, plt.o)
-  nothing
+    unicodeplots_rebuild(plt)
+    map(show, plt.o)
+    nothing
 end
-
@@ -3,13 +3,13 @@

 # 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>
@@ -20,16 +20,16 @@ function standalone_html(plt::AbstractPlot; title::AbstractString = get(plt.attr
 end

 function open_browser_window(filename::AbstractString)
-    @compat @static if is_apple()
+    @static if Sys.isapple()
        return run(`open $(filename)`)
    end
-    @compat @static if is_linux()
+    @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
-    @compat @static if is_windows()
-        return run(`$(ENV["COMSPEC"]) /c start $(filename)`)
+    @static if Sys.iswindows()
+        return run(`$(ENV["COMSPEC"]) /c start "" "$(filename)"`)
    end
-    warn("Unknown OS... cannot open browser window.")
+    @warn("Unknown OS... cannot open browser window.")
 end

 function write_temp_html(plt::AbstractPlot)
@@ -42,8 +42,14 @@ function write_temp_html(plt::AbstractPlot)
 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
@@ -51,7 +57,7 @@ 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 writemime_png_from_html(io::IO, plt::AbstractPlot)
+function show_png_from_html(io::IO, plt::AbstractPlot)
    # write html to a temporary file
    html_fn = write_temp_html(plt)

@@ -1,272 +0,0 @@
-
-# https://github.com/nolta/Winston.jl
-
-# credit goes to https://github.com/jverzani for contributing to the first draft of this backend implementation
-
-supported_args(::WinstonBackend) = merge_with_base_supported([
-    :annotations,
-    :linecolor,
-    :fillrange,
-    :fillcolor,
-    :label,
-    :legend,
-    :seriescolor, :seriesalpha,
-    :linestyle,
-    :linewidth,
-    :markershape,
-    :markercolor,
-    :markersize,
-    :bins,
-    :title,
-    :window_title,
-    :guide, :lims, :scale,
-  ])
-supported_types(::WinstonBackend) = [:path, :scatter, :bar]
-supported_styles(::WinstonBackend) = [:auto, :solid, :dash, :dot, :dashdot]
-supported_markers(::WinstonBackend) = [:none, :auto, :rect, :circle, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5]
-supported_scales(::WinstonBackend) = [:identity, :log10]
-is_subplot_supported(::WinstonBackend) = false
-
-
-# --------------------------------------------------------------------------------------
-
-
-function _initialize_backend(::WinstonBackend; kw...)
-  @eval begin
-    # ENV["WINSTON_OUTPUT"] = "gtk"
-    warn("Winston is no longer supported... many features will likely be broken.")
-    import Winston, Gtk
-    export Winston, Gtk
-  end
-end
-
-# ---------------------------------------------------------------------------
-
-
-## dictionaries for conversion of Plots.jl names to Winston ones.
-@compat const winston_linestyle =  KW(:solid=>"solid",
-                                :dash=>"dash",
-                                :dot=>"dotted",
-                                :dashdot=>"dotdashed"
-                               )
-
-@compat const winston_marker = KW(:none=>".",
-                            :rect => "square",
-                            :circle=>"circle",
-                            :diamond=>"diamond",
-                            :utriangle=>"triangle",
-                            :dtriangle=>"down-triangle",
-                            :cross => "plus",
-                            :xcross => "cross",
-                            :star5 => "asterisk"
-                           )
-
-function _before_update(plt::Plot{WinstonBackend})
-  Winston.ghf(plt.o)
-end
-
-# ---------------------------------------------------------------------------
-
-function _create_backend_figure(plt::Plot{WinstonBackend})
-    Winston.FramedPlot(
-        title = plt.attr[:title],
-        xlabel = plt.attr[:xguide],
-        ylabel = plt.attr[:yguide]
-    )
-end
-
-copy_remove(d::KW, s::Symbol) = delete!(copy(d), s)
-
-function addRegressionLineWinston(d::KW, wplt)
-  xs, ys = regressionXY(d[:x], d[:y])
-  Winston.add(wplt, Winston.Curve(xs, ys, kind="dotted"))
-end
-
-function getWinstonItems(plt::Plot)
-  if isa(plt.o, Winston.FramedPlot)
-    wplt = plt.o
-    window, canvas = nothing, nothing
-  else
-    window, canvas, wplt = plt.o
-  end
-  window, canvas, wplt
-end
-
-function _series_added(plt::Plot{WinstonBackend}, series::Series)
-    d = series.d
-  window, canvas, wplt = getWinstonItems(plt)
-
-  # until we call it normally, do the hack
-  if d[:seriestype] == :bar
-    d = barHack(;d...)
-  end
-
-
-  e = KW()
-  e[:color] = getColor(d[:linecolor])
-  e[:linewidth] = d[:linewidth]
-  e[:kind] = winston_linestyle[d[:linestyle]]
-  e[:symbolkind] = winston_marker[d[:markershape]]
-  # markercolor     # same choices as `color`, or :match will set the color to be the same as `color`
-  e[:symbolsize] = d[:markersize] / 5
-
-  # pos             # (Int,Int), move the enclosing window to this position
-  # screen          # Integer, move enclosing window to this screen number (for multiscreen desktops)
-
-
-
-  ## lintype :path, :step, :stepinverted, :sticks, :dots, :none, :histogram2d, :hexbin, :histogram, :bar
-  if d[:seriestype] == :none
-    Winston.add(wplt, Winston.Points(d[:x], d[:y]; copy_remove(e, :kind)..., color=getColor(d[:markercolor])))
-
-  elseif d[:seriestype] == :path
-    x, y = d[:x], d[:y]
-    Winston.add(wplt, Winston.Curve(x, y; e...))
-
-    fillrange = d[:fillrange]
-    if fillrange != nothing
-      if isa(fillrange, AbstractVector)
-        y2 = fillrange
-      else
-        y2 = Float64[fillrange for yi in y]
-      end
-      Winston.add(wplt, Winston.FillBetween(x, y, x, y2, fillcolor=getColor(d[:fillcolor])))
-    end
-
-  elseif d[:seriestype] == :scatter
-    if d[:markershape] == :none
-      d[:markershape] = :circle
-    end
-
-  # elseif d[:seriestype] == :step
-  #     fn = Winston.XXX
-
-  # elseif d[:seriestype] == :stepinverted
-  #     fn = Winston.XXX
-
-  elseif d[:seriestype] == :sticks
-      Winston.add(wplt, Winston.Stems(d[:x], d[:y]; e...))
-
-  # elseif d[:seriestype] == :dots
-  #     fn = Winston.XXX
-
-  # elseif d[:seriestype] == :histogram2d
-  #     fn = Winston.XXX
-
-  # elseif d[:seriestype] == :hexbin
-  #     fn = Winston.XXX
-
-  elseif d[:seriestype] == :histogram
-      hst = hist(d[:y], d[:bins])
-      Winston.add(wplt, Winston.Histogram(hst...; copy_remove(e, :bins)...))
-
-  # elseif d[:seriestype] == :bar
-  #     # fn = Winston.XXX
-
-  else
-    error("seriestype $(d[:seriestype]) not supported by Winston.")
-
-  end
-
-
-  # markershape
-  if d[:markershape] != :none
-    Winston.add(wplt, Winston.Points(d[:x], d[:y]; copy_remove(e, :kind)..., color=getColor(d[:markercolor])))
-  end
-
-
-  # optionally add a regression line
-  d[:smooth] && d[:seriestype] != :histogram && addRegressionLineWinston(d, wplt)
-
-  # push!(plt.seriesargs, d)
-  # plt
-end
-
-
-# ----------------------------------------------------------------
-
-@compat const _winstonNames = KW(
-    :xlims => :xrange,
-    :ylims => :yrange,
-    :xscale => :xlog,
-    :yscale => :ylog,
-  )
-
-function _update_plot_object(plt::Plot{WinstonBackend}, d::KW)
-  window, canvas, wplt = getWinstonItems(plt)
-  for k in (:xguide, :yguide, :title, :xlims, :ylims)
-    if haskey(d, k)
-      Winston.setattr(wplt, string(get(_winstonNames, k, k)), d[k])
-    end
-  end
-
-  for k in (:xscale, :yscale)
-    if haskey(d, k)
-      islogscale = d[k] == :log10
-      Winston.setattr(wplt, (k == :xscale ? :xlog : :ylog), islogscale)
-    end
-  end
-
-end
-
-
-
-# ----------------------------------------------------------------
-
-function createWinstonAnnotationObject(plt::Plot{WinstonBackend}, x, y, val::@compat(AbstractString))
-  Winston.text(x, y, val)
-end
-
-function _add_annotations{X,Y,V}(plt::Plot{WinstonBackend}, anns::AVec{@compat(Tuple{X,Y,V})})
-  for ann in anns
-    createWinstonAnnotationObject(plt, ann...)
-  end
-end
-
-
-# ----------------------------------------------------------------
-
-# function _create_subplot(subplt::Subplot{WinstonBackend}, isbefore::Bool)
-#   # TODO: build the underlying Subplot object.  this is where you might layout the panes within a GUI window, for example
-# end
-
-# ----------------------------------------------------------------
-
-function addWinstonLegend(plt::Plot, wplt)
-  if plt.attr[:legend] != :none
-    Winston.legend(wplt, [sd[:label] for sd in plt.seriesargs])
-  end
-end
-
-function Base.writemime(io::IO, ::MIME"image/png", plt::AbstractPlot{WinstonBackend})
-  window, canvas, wplt = getWinstonItems(plt)
-  addWinstonLegend(plt, wplt)
-  writemime(io, "image/png", wplt)
-end
-
-
-function Base.display(::PlotsDisplay, plt::Plot{WinstonBackend})
-
-  window, canvas, wplt = getWinstonItems(plt)
-
-  if window == nothing
-    if Winston.output_surface != :gtk
-      error("Gtk is the only supported display for Winston in Plots.  Set `output_surface = gtk` in src/Winston.ini")
-    end
-    # initialize window
-    w,h = plt.attr[:size]
-    canvas = Gtk.GtkCanvasLeaf()
-    window = Gtk.GtkWindowLeaf(canvas, plt.attr[:window_title], w, h)
-    plt.o = (window, canvas, wplt)
-  end
-
-  addWinstonLegend(plt, wplt)
-
-  Winston.display(canvas, wplt)
-  Gtk.showall(window)
-end
-
-
-# function Base.display(::PlotsDisplay, subplt::Subplot{WinstonBackend})
-#   # TODO: display/show the Subplot object
-# end
@@ -1,413 +0,0 @@
-
-abstract ColorScheme
-
-Base.getindex(scheme::ColorScheme, i::Integer) = getColor(scheme, i)
-
-export
-    cgrad
-
-cgrad() = default_gradient()
-
-function cgrad(arg, values = nothing; alpha = nothing, scale = :identity)
-    colors = ColorGradient(arg, alpha=alpha).colors
-    values = if values != nothing
-        values
-    elseif scale in (:log, :log10)
-        log10(linspace(1,10,30))
-    elseif scale == :log2
-        log2(linspace(1,2,30))
-    elseif scale == :ln
-        log(linspace(1,pi,30))
-    elseif scale in (:exp, :exp10)
-        (exp10(linspace(0,1,30)) - 1) / 9
-    else
-        linspace(0, 1, length(colors))
-    end
-    ColorGradient(colors, values)
-end
-
-# --------------------------------------------------------------
-
-getColor(scheme::ColorScheme) = getColor(scheme, 1)
-getColorVector(scheme::ColorScheme) = [getColor(scheme)]
-
-colorscheme(scheme::ColorScheme) = scheme
-colorscheme(s::Symbol; kw...) = haskey(_gradients, s) ? ColorGradient(s; kw...) : ColorWrapper(convertColor(s); kw...)
-colorscheme{T<:Real}(s::Symbol, vals::AVec{T}; kw...) = ColorGradient(s, vals; kw...)
-colorscheme(cs::AVec, vs::AVec; kw...) = ColorGradient(cs, vs; kw...)
-colorscheme{T<:Colorant}(cs::AVec{T}; kw...) = ColorGradient(cs; kw...)
-colorscheme(f::Function; kw...) = ColorFunction(f; kw...)
-colorscheme(v::AVec; kw...) = ColorVector(v; kw...)
-colorscheme(m::AMat; kw...) = size(m,1) == 1 ? map(c->colorscheme(c; kw...), m) : [colorscheme(m[:,i]; kw...) for i in 1:size(m,2)]'
-colorscheme(c::Colorant; kw...) = ColorWrapper(c; kw...)
-
-
-# --------------------------------------------------------------
-
-
-convertColor(c::AbstractString) = parse(Colorant, c)
-convertColor(c::Symbol) = parse(Colorant, string(c))
-convertColor(c::Colorant) = c
-convertColor(cvec::AbstractVector) = map(convertColor, cvec)
-convertColor(c::ColorScheme) = c
-convertColor(v::Void) = RGBA(0,0,0,0)
-convertColor(b::Bool) = b ? RGBA(0,0,0,1) : RGBA(0,0,0,0)
-
-function convertColor(c, α::Real)
-  c = convertColor(c)
-  RGBA(RGB(c), α)
-end
-convertColor(cs::AVec, α::Real) = map(c -> convertColor(c, α), cs)
-convertColor(c, α::@compat(Void)) = convertColor(c)
-
-# backup... try to convert
-getColor(c) = convertColor(c)
-
-# --------------------------------------------------------------
-
-function darken(c, v=0.1)
-    rgba = convert(RGBA, c)
-    r = max(0, min(rgba.r - v, 1))
-    g = max(0, min(rgba.g - v, 1))
-    b = max(0, min(rgba.b - v, 1))
-    RGBA(r,g,b,rgba.alpha)
-end
-function lighten(c, v=0.3)
-    darken(c, -v)
-end
-
-# --------------------------------------------------------------
-
-const _rainbowColors = [colorant"blue", colorant"purple", colorant"green", colorant"orange", colorant"red"]
-const _testColors = [colorant"darkblue", colorant"blueviolet",  colorant"darkcyan",colorant"green",
-                     darken(colorant"yellow",0.3), colorant"orange", darken(colorant"red",0.2)]
-
-const _gradients = KW(
-    :blues        => [colorant"lightblue", colorant"darkblue"],
-    :reds         => [colorant"lightpink", colorant"darkred"],
-    :greens       => [colorant"lightgreen", colorant"darkgreen"],
-    :redsblues    => [colorant"darkred", RGB(0.8,0.85,0.8), colorant"darkblue"],
-    :bluesreds    => [colorant"darkblue", RGB(0.8,0.85,0.8), colorant"darkred"],
-    :heat         => [colorant"lightyellow", colorant"orange", colorant"darkred"],
-    :grays        => [RGB(.95,.95,.95),RGB(.05,.05,.05)],
-    :rainbow      => _rainbowColors,
-    :lightrainbow => map(lighten, _rainbowColors),
-    :darkrainbow  => map(darken, _rainbowColors),
-    :darktest     => _testColors,
-    :lighttest    => map(c -> lighten(c, 0.3), _testColors),
-  )
-
-function register_gradient_colors{C<:Colorant}(name::Symbol, colors::AVec{C})
-    _gradients[name] = colors
-end
-
-include("color_gradients.jl")
-
-default_gradient() = ColorGradient(:inferno)
-
-# --------------------------------------------------------------
-
-"Continuous gradient between values.  Wraps a list of bounding colors and the values they represent."
-immutable ColorGradient <: ColorScheme
-  colors::Vector
-  values::Vector
-
-  function ColorGradient{S<:Real}(cs::AVec, vals::AVec{S} = linspace(0, 1, length(cs)); alpha = nothing)
-    if length(cs) == length(vals)
-      return new(convertColor(cs,alpha), collect(vals))
-    end
-
-    # # otherwise interpolate evenly between the minval and maxval
-    # minval, maxval = minimum(vals), maximum(vals)
-    # vs = Float64[interpolate(minval, maxval, w) for w in linspace(0, 1, length(cs))]
-    # new(convertColor(cs,alpha), vs)
-
-    # interpolate the colors for each value
-    vals = merge(linspace(0, 1, length(cs)), vals)
-    grad = ColorGradient(cs)
-    cs = [getColorZ(grad, z) for z in linspace(0, 1, length(vals))]
-    new(convertColor(cs, alpha), vals)
-  end
-end
-
-
-
-Base.getindex(cs::ColorGradient, i::Integer) = getColor(cs, i)
-Base.getindex(cs::ColorGradient, z::Number) = getColorZ(cs, z)
-
-
-# create a gradient from a symbol (blues, reds, etc) and vector of boundary values
-function ColorGradient{T<:Real}(s::Symbol, vals::AVec{T} = 0:0; kw...)
-  haskey(_gradients, s) || error("Invalid gradient symbol.  Choose from: ", sort(collect(keys(_gradients))))
-  cs = _gradients[s]
-  if vals == 0:0
-    vals = linspace(0, 1, length(cs))
-  end
-  ColorGradient(cs, vals; kw...)
-end
-
-# function ColorGradient{T<:Real}(cs::AVec, vals::AVec{T} = linspace(0, 1, length(cs)); kw...)
-#   ColorGradient(map(convertColor, cs), vals; kw...)
-# end
-
-function ColorGradient(grad::ColorGradient; alpha = nothing)
-  ColorGradient(convertColor(grad.colors, alpha), grad.values)
-end
-
-# anything else just gets the default gradient
-function ColorGradient(cw; alpha=nothing)
-    ColorGradient(default_gradient(), alpha=alpha)
-end
-
-getColor(gradient::ColorGradient, idx::Int) = gradient.colors[mod1(idx, length(gradient.colors))]
-
-function getColorZ(gradient::ColorGradient, z::Real)
-  cs = gradient.colors
-  vs = gradient.values
-  n = length(cs)
-  @assert n > 0 && n == length(vs)
-
-  # can we just return the first color?
-  if z <= vs[1] || n == 1
-    return cs[1]
-  end
-
-  # find the bounding colors and interpolate
-  for i in 2:n
-    if z <= vs[i]
-      return interpolate_rgb(cs[i-1], cs[i], (z - vs[i-1]) / (vs[i] - vs[i-1]))
-    end
-  end
-
-  # if we get here, return the last color
-  cs[end]
-end
-
-getColorVector(gradient::ColorGradient) = gradient.colors
-
-# for 0.3
-Colors.RGBA(c::Colorant) = RGBA(red(c), green(c), blue(c), alpha(c))
-Colors.RGB(c::Colorant) = RGB(red(c), green(c), blue(c))
-
-function interpolate_rgb(c1::Colorant, c2::Colorant, w::Real)
-  rgb1 = RGBA(c1)
-  rgb2 = RGBA(c2)
-  r = interpolate(rgb1.r, rgb2.r, w)
-  g = interpolate(rgb1.g, rgb2.g, w)
-  b = interpolate(rgb1.b, rgb2.b, w)
-  a = interpolate(rgb1.alpha, rgb2.alpha, w)
-  RGBA(r, g, b, a)
-end
-
-
-function interpolate(v1::Real, v2::Real, w::Real)
-  (1-w) * v1 + w * v2
-end
-
-# --------------------------------------------------------------
-
-"Wraps a function, taking an index and returning a Colorant"
-immutable ColorFunction <: ColorScheme
-  f::Function
-end
-
-getColor(scheme::ColorFunction, idx::Int) = scheme.f(idx)
-
-# --------------------------------------------------------------
-
-"Wraps a function, taking an z-value and returning a Colorant"
-immutable ColorZFunction <: ColorScheme
-  f::Function
-end
-
-getColorZ(scheme::ColorFunction, z::Real) = scheme.f(z)
-
-# --------------------------------------------------------------
-
-"Wraps a vector of colors... may be vector of Symbol/String/Colorant"
-immutable ColorVector <: ColorScheme
-  v::Vector{Colorant}
-  ColorVector(v::AVec; alpha = nothing) = new(convertColor(v,alpha))
-end
-
-getColor(scheme::ColorVector, idx::Int) = convertColor(scheme.v[mod1(idx, length(scheme.v))])
-getColorVector(scheme::ColorVector) = scheme.v
-
-
-# --------------------------------------------------------------
-
-"Wraps a single color"
-immutable ColorWrapper <: ColorScheme
-  c::RGBA
-  ColorWrapper(c::Colorant; alpha = nothing) = new(convertColor(c, alpha))
-end
-
-ColorWrapper(s::Symbol; alpha = nothing) = ColorWrapper(convertColor(parse(Colorant, s), alpha))
-
-getColor(scheme::ColorWrapper, idx::Int) = scheme.c
-getColorZ(scheme::ColorWrapper, z::Real) = scheme.c
-
-# --------------------------------------------------------------
-
-
-isbackgrounddark(bgcolor::Color) = Lab(bgcolor).l < 0.5
-
-# move closer to lighter/darker depending on background value
-function adjustAway(val, bgval, vmin=0., vmax=100.)
-  if bgval < 0.5 * (vmax+vmin)
-    tmp = max(val, bgval)
-    return 0.5 * (tmp + max(tmp, vmax))
-  else
-    tmp = min(val, bgval)
-    return 0.5 * (tmp + min(tmp, vmin))
-  end
-end
-
-# borrowed from http://stackoverflow.com/a/1855903:
-lightnessLevel(c::Colorant) = 0.299 * red(c) + 0.587 * green(c) + 0.114 * blue(c)
-
-isdark(c::Colorant) = lightnessLevel(c) < 0.5
-islight(c::Colorant) = !isdark(c)
-
-function convertHexToRGB(h::Unsigned)
-  mask = 0x0000FF
-  RGB([(x & mask) / 0xFF for x in  (h >> 16, h >> 8, h)]...)
-end
-
-# note: I found this list of hex values in a comment by Tatarize here: http://stackoverflow.com/a/12224359
-const _masterColorList = [
-    0xFFFFFF, 0x000000, 0x0000FF, 0x00FF00, 0xFF0000, 0x01FFFE, 0xFFA6FE, 0xFFDB66, 0x006401, 0x010067,
-    0x95003A, 0x007DB5, 0xFF00F6, 0xFFEEE8, 0x774D00, 0x90FB92, 0x0076FF, 0xD5FF00, 0xFF937E, 0x6A826C,
-    0xFF029D, 0xFE8900, 0x7A4782, 0x7E2DD2, 0x85A900, 0xFF0056, 0xA42400, 0x00AE7E, 0x683D3B, 0xBDC6FF,
-    0x263400, 0xBDD393, 0x00B917, 0x9E008E, 0x001544, 0xC28C9F, 0xFF74A3, 0x01D0FF, 0x004754, 0xE56FFE,
-    0x788231, 0x0E4CA1, 0x91D0CB, 0xBE9970, 0x968AE8, 0xBB8800, 0x43002C, 0xDEFF74, 0x00FFC6, 0xFFE502,
-    0x620E00, 0x008F9C, 0x98FF52, 0x7544B1, 0xB500FF, 0x00FF78, 0xFF6E41, 0x005F39, 0x6B6882, 0x5FAD4E,
-    0xA75740, 0xA5FFD2, 0xFFB167, 0x009BFF, 0xE85EBE
-  ]
-const _allColors = map(convertHexToRGB, _masterColorList)
-const _darkColors = filter(isdark, _allColors)
-const _lightColors = filter(islight, _allColors)
-const _sortedColorsForDarkBackground = vcat(_lightColors, reverse(_darkColors[2:end]))
-const _sortedColorsForLightBackground = vcat(_darkColors, reverse(_lightColors[2:end]))
-
-const _defaultNumColors = 17
-
-# --------------------------------------------------------------
-
-# Methods to automatically generate gradients for color selection based on
-# background color and a short list of seed colors
-
-# here are some magic constants that could be changed if you really want
-const _lightness_darkbg = [80.0]
-const _lightness_lightbg = [60.0]
-const _lch_c_const = [60]
-
-function adjust_lch(color, l, c)
-    lch = convert(LCHab, color)
-    convert(RGB, LCHab(l, c, lch.h))
-end
-
-function lightness_from_background(bgcolor)
-  bglight = convert(LCHab, bgcolor).l
-  bglight < 50.0 ? _lightness_darkbg[1] : _lightness_lightbg[1]
-end
-
-function gradient_from_list(cs)
-    zvalues = Plots.get_zvalues(length(cs))
-    indices = sortperm(zvalues)
-    sorted_colors = map(RGBA, cs[indices])
-    sorted_zvalues = zvalues[indices]
-    ColorGradient(sorted_colors, sorted_zvalues)
-end
-
-function generate_colorgradient(bgcolor = colorant"white";
-                               color_bases = color_bases=[colorant"steelblue",colorant"orangered"],
-                               lightness = lightness_from_background(bgcolor),
-                               chroma = _lch_c_const[1],
-                               n = _defaultNumColors)
-  seed_colors = vcat(bgcolor, map(c -> adjust_lch(c, lightness, chroma), color_bases))
-  colors = distinguishable_colors(n,
-      seed_colors,
-      lchoices=Float64[lightness],
-      cchoices=Float64[chroma],
-      hchoices=linspace(0, 340, 20)
-    )[2:end]
-  gradient_from_list(colors)
-end
-
-function get_color_palette(palette, bgcolor::Union{Colorant,ColorWrapper}, numcolors::Integer)
-  grad = if palette == :auto
-    generate_colorgradient(bgcolor)
-  else
-    ColorGradient(palette)
-  end
-  zrng = get_zvalues(numcolors)
-  RGBA[getColorZ(grad, z) for z in zrng]
-end
-
-function get_color_palette{C<:Colorant}(palette::Vector{C},
-            bgcolor::Union{Colorant,ColorWrapper}, numcolors::Integer)
-  palette
-end
-
-# ----------------------------------------------------------------------------------
-
-
-function getpctrange(n::Int)
-    n > 0 || error()
-    n == 1 && return zeros(1)
-    zs = [0.0, 1.0]
-    for i in 3:n
-        sorted = sort(zs)
-        diffs = diff(sorted)
-        widestj = 0
-        widest = 0.0
-        for (j,d) in enumerate(diffs)
-            if d > widest
-                widest = d
-                widestj = j
-            end
-        end
-        push!(zs, sorted[widestj] + 0.5 * diffs[widestj])
-    end
-    zs
-end
-
-function get_zvalues(n::Int)
-    offsets = getpctrange(ceil(Int,n/4)+1)/4
-    offsets = vcat(offsets[1], offsets[3:end])
-    zvalues = Float64[]
-    for offset in offsets
-        append!(zvalues, offset + [0.0, 0.5, 0.25, 0.75])
-    end
-    vcat(zvalues[1], 1.0, zvalues[2:n-1])
-end
-
-# ----------------------------------------------------------------------------------
-
-
-make255(x) = round(Int, 255 * x)
-
-function webcolor(c::Color)
-    @sprintf("rgb(%d, %d, %d)", [make255(f(c)) for f in [red,green,blue]]...)
-end
-function webcolor(c::TransparentColor)
-    @sprintf("rgba(%d, %d, %d, %1.3f)", [make255(f(c)) for f in [red,green,blue]]..., alpha(c))
-end
-webcolor(cs::ColorScheme) = webcolor(getColor(cs))
-webcolor(c) = webcolor(convertColor(c))
-webcolor(c, α) = webcolor(convertColor(getColor(c), α))
-
-# ----------------------------------------------------------------------------------
-
-
-# converts a symbol or string into a colorant (Colors.RGB), and assigns a color automatically
-function getSeriesRGBColor(c, sp::Subplot, n::Int)
-
-  if c == :auto
-    c = autopick(sp[:color_palette], n)
-  end
-
-  # c should now be a subtype of ColorScheme
-  colorscheme(c)
-end
@@ -1,43 +1,54 @@


-typealias P2 FixedSizeArrays.Vec{2,Float64}
-typealias P3 FixedSizeArrays.Vec{3,Float64}
+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 = atan2(v[2], v[1]); angle < 0 ? 2π - angle : angle)
+compute_angle(v::P2) = (angle = atan(v[2], v[1]); angle < 0 ? 2π - angle : angle)

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

-immutable Shape
+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
+    # 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

-function shape_coords(shape::Shape)
+"return the vertex points from a Shape or Segments object"
+function coords(shape::Shape)
    shape.x, shape.y
 end

-function shape_coords(shapes::AVec{Shape})
+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, shape_coords(shapes[1]))
+    x, y = map(copy, coords(shapes[1]))
    for shape in shapes[2:end]
        nanappend!(x, shape.x)
        nanappend!(y, shape.y)
@@ -47,7 +58,7 @@ end

 "get an array of tuples of points on a circle with radius `r`"
 function partialcircle(start_θ, end_θ, n = 20, r=1)
-  @compat(Tuple{Float64,Float64})[(r*cos(u),r*sin(u)) for u in linspace(start_θ, end_θ, n)]
+    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)"
@@ -57,7 +68,8 @@ function weave(x,y; ordering = Vector[x,y])
  while !done
    for o in ordering
      try
-          push!(ret, shift!(o))
+          push!(ret, popfirst!(o))
+      catch
      end
    end
    done = isempty(x) && isempty(y)
@@ -72,13 +84,13 @@ function makestar(n; offset = -0.5, radius = 1.0)
    z2 = z1 + π / (n)
    outercircle = partialcircle(z1, z1 + 2π, n+1, radius)
    innercircle = partialcircle(z2, z2 + 2π, n+1, 0.4radius)
-    Shape(weave(outercircle, innercircle)[1:end-2])
+    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)[1:end-1])
+    Shape(partialcircle(z, z + 2π, n+1, radius))
 end


@@ -88,7 +100,7 @@ function makecross(; offset = -0.5, radius = 1.0)
    outercircle = partialcircle(z1, z1 + 2π, 9, radius)
    innercircle = partialcircle(z2, z2 + 2π, 5, 0.5radius)
    Shape(weave(outercircle, innercircle,
-                ordering=Vector[outercircle,innercircle,outercircle])[1:end-2])
+                ordering=Vector[outercircle,innercircle,outercircle]))
 end


@@ -110,6 +122,8 @@ const _shape_keys = Symbol[
  :xcross,
  :utriangle,
  :dtriangle,
+  :rtriangle,
+  :ltriangle,
  :pentagon,
  :heptagon,
  :octagon,
@@ -119,14 +133,18 @@ const _shape_keys = Symbol[
  :star8,
  :vline,
  :hline,
+  :+,
+  :x,
 ]

 const _shapes = KW(
    :circle    => makeshape(20),
    :rect       => makeshape(4, offset=-0.25),
    :diamond    => makeshape(4),
-    :utriangle  => makeshape(3),
-    :dtriangle  => makeshape(3, offset=0.5),
+    :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),
@@ -141,12 +159,15 @@ 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 = shape_coords(shape)
+    x, y = coords(shape)
    n = length(x)
    A, Cx, Cy = 0.0, 0.0, 0.0
    for i=1:n
@@ -163,8 +184,8 @@ function center(shape::Shape)
    Cx / 6A, Cy / 6A
 end

-function Base.scale!(shape::Shape, x::Real, y::Real = x, c = center(shape))
-    sx, sy = shape_coords(shape)
+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
@@ -173,13 +194,14 @@ function Base.scale!(shape::Shape, x::Real, y::Real = x, c = center(shape))
    shape
 end

-function Base.scale(shape::Shape, x::Real, y::Real = x, c = center(shape))
+function scale(shape::Shape, x::Real, y::Real = x, c = center(shape))
    shapecopy = deepcopy(shape)
-    scale!(shape, x, y, c)
+    scale!(shapecopy, x, y, c)
 end

+"translate a Shape in space"
 function translate!(shape::Shape, x::Real, y::Real = x)
-    sx, sy = shape_coords(shape)
+    sx, sy = coords(shape)
    for i=1:length(sx)
        sx[i] += x
        sy[i] += y
@@ -189,7 +211,7 @@ end

 function translate(shape::Shape, x::Real, y::Real = x)
    shapecopy = deepcopy(shape)
-    translate!(shape, x, y)
+    translate!(shapecopy, x, y)
 end

 function rotate_x(x::Real, y::Real, Θ::Real, centerx::Real, centery::Real)
@@ -206,15 +228,17 @@ function rotate(x::Real, y::Real, θ::Real, c = center(shape))
 end

 function rotate!(shape::Shape, Θ::Real, c = center(shape))
-    x, y = shape_coords(shape)
+    x, y = coords(shape)
    cx, cy = c
    for i=1:length(x)
-        x[i] = rotate_x(x[i], y[i], Θ, cx, cy)
-        y[i] = rotate_y(x[i], y[i], Θ, cx, cy)
+        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)
@@ -223,7 +247,7 @@ end
 # -----------------------------------------------------------------------


-immutable Font
+mutable struct Font
  family::AbstractString
  pointsize::Int
  halign::Symbol
@@ -232,11 +256,27 @@ immutable Font
  color::Colorant
 end

-"Create a Font from a list of unordered features"
-function font(args...)
+"""
+    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 = "Helvetica"
+  family = "sans-serif"
  pointsize = 14
  halign = :hcenter
  valign = :vcenter
@@ -273,47 +313,113 @@ function font(args...)
    elseif typeof(arg) <: Real
      rotation = convert(Float64, arg)
    else
-      warn("Unused font arg: $arg ($(typeof(arg)))")
+      @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"
-immutable PlotText
+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...)
-  PlotText(string(str), font(args...))
+function text(str, args...;kw...)
+  PlotText(string(str), font(args...;kw...))
 end

-
-annotations(::Void) = []
-annotations(anns::AVec) = anns
-annotations(anns) = Any[anns]
-
+Base.length(t::PlotText) = length(t.str)

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

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

-immutable Stroke
+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 = nothing
-  color = nothing
-  style = nothing
+  width = 1
+  color = :black
+  style = :solid

  for arg in args
    T = typeof(arg)
@@ -326,13 +432,14 @@ function stroke(args...; alpha = nothing)
    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)))")
+      @warn("Unused stroke arg: $arg ($(typeof(arg)))")
    end
  end

@@ -340,15 +447,15 @@ function stroke(args...; alpha = nothing)
 end


-immutable Brush
+struct Brush
  size  # fillrange, markersize, or any other sizey attribute
  color
  alpha
 end

 function brush(args...; alpha = nothing)
-  size = nothing
-  color = nothing
+  size = 1
+  color = :black

  for arg in args
    T = typeof(arg)
@@ -358,13 +465,14 @@ function brush(args...; alpha = nothing)
    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)))")
+      @warn("Unused brush arg: $arg ($(typeof(arg)))")
    end
  end

@@ -373,22 +481,177 @@ 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)"
-immutable ZValues
+struct ZValues
  values::Vector{Float64}
  zrange::Tuple{Float64,Float64}
 end

-function zvalues{T<:Real}(values::AVec{T}, zrange::Tuple{T,T} = (minimum(values), maximum(values)))
+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 AbstractSurface
+abstract type AbstractSurface end

 "represents a contour or surface mesh"
-immutable Surface{M<:AMat} <: AbstractSurface
+struct Surface{M<:AMat} <: AbstractSurface
  surf::M
 end

@@ -400,7 +663,7 @@ 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) = eltype(surf.surf)
+Base.eltype(surf::Surface{T}) where {T} = eltype(T)

 function expand_extrema!(a::Axis, surf::Surface)
    ex = a[:extrema]
@@ -411,28 +674,69 @@ function expand_extrema!(a::Axis, surf::Surface)
 end

 "For the case of representing a surface as a function of x/y... can possibly avoid allocations."
-immutable SurfaceFunction <: AbstractSurface
+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)
-immutable Arrow
+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
-            style = arg
+            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)
@@ -443,10 +747,10 @@ function arrow(args...)
        elseif T <: Tuple && length(arg) == 2
            headlength, headwidth = Float64(arg[1]), Float64(arg[2])
        else
-            warn("Skipped arrow arg $arg")
+            @warn("Skipped arrow arg $arg")
        end
    end
-    Arrow(style, headlength, headwidth)
+    Arrow(style, side, headlength, headwidth)
 end


@@ -465,58 +769,42 @@ function add_arrows(func::Function, x::AVec, y::AVec)
    end
 end

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

-type BezierCurve{T <: FixedSizeArrays.Vec}
-  control_points::Vector{T}
+"Represents data values with formatting that should apply to the tick labels."
+struct Formatted{T}
+    data::T
+    formatter::Function
 end

-@compat 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
+# -----------------------------------------------------------------------
+"create a BezierCurve for plotting"
+mutable struct BezierCurve{T <: GeometryTypes.Point}
+    control_points::Vector{T}
 end

-Base.mean(x::Real, y::Real) = 0.5*(x+y)
-Base.mean{N,T<:Real}(ps::FixedSizeArrays.Vec{N,T}...) = sum(ps) / length(ps)
+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

-curve_points(curve::BezierCurve, n::Integer = 30; range = [0,1]) = map(curve, linspace(range..., n))
+@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(p::P2, q::P2; xview = 0:1, yview = 0:1)
-mn = mean(p, q)
-diff = q - p
-
-minx, maxx = minimum(xview), maximum(xview)
-miny, maxy = minimum(yview), maximum(yview)
-diffpct = P2(diff[1] / (maxx - minx),
-             diff[2] / (maxy - miny))
-
-# these points give the initial/final "rise"
-# vertical_offset = P2(0, (maxy - miny) * max(0.03, min(abs(0.5diffpct[2]), 1.0)))
-vertical_offset = P2(0, max(0.15, 0.5norm(diff)))
-upper_control = p + vertical_offset
-lower_control = q - vertical_offset
-
-# try to figure out when to loop around vs just connecting straight
-# TODO: choose loop direction based on sign of p[1]??
-# x_close_together = abs(diffpct[1]) <= 0.05
-p_is_higher = diff[2] <= 0
-inside_control_points = if p_is_higher
-  # add curve points which will create a loop
-  sgn = mn[1] < 0.5 * (maxx + minx) ? -1 : 1
-  inside_offset = P2(0.3 * (maxx - minx), 0)
-  additional_offset = P2(sgn * diff[1], 0)  # make it even loopier
-  [upper_control + sgn * (inside_offset + max(0,  additional_offset)),
-   lower_control + sgn * (inside_offset + max(0, -additional_offset))]
-else
-  []
+function directed_curve(args...; kw...)
+    error("directed_curve has been moved to PlotRecipes")
 end

-BezierCurve([p, upper_control, inside_control_points..., lower_control, q])
+function extrema_plus_buffer(v, buffmult = 0.2)
+    vmin,vmax = ignorenan_extrema(v)
+    vdiff = vmax-vmin
+    buffer = vdiff * buffmult
+    vmin - buffer, vmax + buffer
 end
@@ -1,63 +0,0 @@
-
-
-# TODO:
-"""
- load Contours.jl similar to DataFrames
- method to build grid from x/y/z vectors
- method to wrap contours creation
- method to plot contours as custom shapes (TODO: create Stroke and Fill types and add markerstroke/markerfill args)
-
-"""
-
-
-
-# # ----------------------------------------------------------
-# # ----------------------------------------------------------
-
-
-# immutable Vertex
-#   x::Float64
-#   y::Float64
-#   z::Float64
-# end
-
-# immutable Edge
-#   v::Vertex
-#   u::Vertex
-# end
-
-# # ----------------------------------------------------------
-
-# # one rectangle's z-values and the center vertex
-# # z is ordered: topleft, topright, bottomright, bottomleft
-# immutable GridRect
-#   z::Vector{Float64}
-#   center::Vertex
-#   data::Vector{Vertex}
-# end
-
-
-
-# type Grid
-#   xs::Vector{Float64}
-#   ys::Vector{Float64}
-#   rects::Matrix{GridRect}
-# end
-
-# function splitDataEvenly(v::AbstractVector{Float64}, n::Int)
-#   vs = sort(v)
-  
-# end
-
-# # the goal here is to create the vertical and horizontal partitions
-# # which define the grid, so that the data is somewhat evenly split
-# function bucketData(x, y, z)
-
-# end
-
-
-# function buildGrid(x, y, z)
-#   # create 
-# end
-
-
@@ -1,7 +1,7 @@
 """
 Holds all data needed for a documentation example... header, description, and plotting expression (Expr)
 """
-type PlotExample
+mutable struct PlotExample
  header::AbstractString
  desc::AbstractString
  exprs::Vector{Expr}
@@ -18,11 +18,18 @@ PlotExample("Lines",
 ),

 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.",
+"""
+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 linspace(0, 10π, 100)
+        for x in range(0, stop=10π, length=100)
            push!(p, x, Float64[sin(x), cos(x)])
            frame(anim)
        end
@@ -37,23 +44,36 @@ PlotExample("Parametric plots",
 ),

 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.",
+"""
+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,:auto), α=0.6)
-        scatter!(y, zcolor=abs(y-.5), m=(:heat,0.8,stroke(1,:green)), ms=10*abs(y-0.5)+4, lab="grad")
+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!`",
+"""
+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
-        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,1)+rand(1,3), line=(4,:dash,0.6,[:lightgreen :green :darkgreen]))
-        vline!([5,10])
-        title!("TITLE")
-        yaxis!("YLABEL", :log10)
+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)]
 ),

@@ -61,22 +81,30 @@ PlotExample("Global",
 #             "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 Images
-        img = Images.load(Pkg.dir("PlotReferenceImages","Plots","pyplot","0.7.0","ref1.png"))
+    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.",
+"""
+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,stroke(3,:gray)))
+        plot(ys, color=[:black :orange], line=(:dot,4), marker=([:hex :d],12,0.8,Plots.stroke(3,:gray)))
    end)]
 ),

@@ -115,20 +143,23 @@ PlotExample("Line types",
 PlotExample("Line styles",
    "",
    [:(begin
-        styles = filter(s -> s in supported_styles(), [:solid, :dash, :dot, :dashdot, :dashdotdot])'
-        n = length(styles)
-        y = cumsum(randn(20,n),1)
-        plot(y, line = (5, styles), label = map(string,styles))
-    end)]
+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 supported_markers(), Plots._shape_keys)'
+        markers = filter(m -> m in Plots.supported_markers(), Plots._shape_keys)
+        markers = reshape(markers, 1, length(markers))
        n = length(markers)
-        x = linspace(0,10,n+2)[2:end-1]
-        y = repmat(reverse(x)', n, 1)
+        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)]
 ),
@@ -143,90 +174,111 @@ PlotExample("Bar",
 PlotExample("Histogram",
    "",
    [:(begin
-        histogram(randn(1000), nbins=20)
+        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.
-    """,
+"""
+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=false)
+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.",
+"""
+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])
+plot(Plots.fakedata(100,10), layout=4, palette=[:grays :blues :heat :lightrainbow],
+     bg_inside=[:orange :pink :darkblue :black])
    end)]
 ),

 PlotExample("",
    "",
    [:(begin
-        srand(111)
+        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.",
+"""
+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)
+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.",
+"""
+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!(linspace(2,8,6), rand(6), marker=(50,0.2,:orange), series_annotations = ["series","annotations","map","to","series",text("data",:green)])
+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.",
+"""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)
+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.",
+"""
+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 = repmat(x', length(y), 1)
-        Y = repmat(y, 1, length(x))
+        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)]
-    # [:(begin
-    #     x = 1:0.3:20
-    #     y = x
-    #     f(x,y) = sin(x)+cos(y)
-    #     contour(x, y, f, fill=true)
-    # end)]
 ),

 PlotExample("Pie",
@@ -242,11 +294,11 @@ PlotExample("3D",
    "",
    [:(begin
        n = 100
-        ts = linspace(0,8π,n)
+        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,stroke(0)), leg=false, cbar=true, w=5)
+        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)]
 ),
@@ -256,9 +308,9 @@ PlotExample("DataFrames",
    [:(begin
        import RDatasets
        iris = RDatasets.dataset("datasets", "iris")
-        scatter(iris, :SepalLength, :SepalWidth, group=:Species,
+        @df iris scatter(:SepalLength, :SepalWidth, group=:Species,
            title = "My awesome plot", xlabel = "Length", ylabel = "Width",
-            marker = (0.5, [:+ :h :star7], 12), bg=RGB(.2,.2,.2))
+            marker = (0.5, [:cross :hex :star7], 12), bg=RGB(.2,.2,.2))
    end)]
 ),

@@ -266,15 +318,16 @@ 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])
+        plot(rand(100), layout=@layout([a b;c]), group=group,
+            linetype=[:bar :scatter :steppre], linecolor = :match)
    end)]
 ),

 PlotExample("Polar Plots",
    "",
    [:(begin
-        Θ = linspace(0,1.5π,100)
-        r = abs(0.1randn(100)+sin(3Θ))
+        Θ = range(0, stop=1.5π, length=100)
+        r = abs.(0.1randn(100)+sin.(3Θ))
        plot(Θ, r, proj=:polar, m=2)
    end)]
 ),
@@ -284,7 +337,7 @@ 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)*(1:10)')
+        z = float((1:4)*reshape(1:10,1,:))
        heatmap(xs, ys, z, aspect_ratio=1)
    end)]
 ),
@@ -292,9 +345,10 @@ PlotExample("Heatmap, categorical axes, and aspect_ratio",
 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=50px, xrotation=60)
+                        bottom_margin=10px, xrotation=60)
    end)]
 ),

@@ -303,19 +357,122 @@ PlotExample("Boxplot and Violin series recipes",
    [:(begin
        import RDatasets
        singers = RDatasets.dataset("lattice", "singer")
-        violin(singers, :VoicePart, :Height, line = 0, fill = (0.2, :blue))
-        boxplot!(singers, :VoicePart, :Height, line = (2,:black), fill = (0.3, :orange))
+        @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)")
+  @info("Testing plot: $pkgname:$idx:$(_examples[idx].header)")
  backend(pkgname)
  backend()
  map(eval, _examples[idx].exprs)
@@ -327,6 +484,13 @@ function test_examples(pkgname::Symbol, idx::Int; debug = false, disp = true)
 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
@@ -339,7 +503,7 @@ function test_examples(pkgname::Symbol; debug = false, disp = true, sleep = noth
      plts[i] = plt
    catch ex
      # TODO: put error info into markdown?
-      warn("Example $pkgname:$i:$(_examples[i].header) failed with: $ex")
+      @warn("Example $pkgname:$i:$(_examples[i].header) failed with: $ex")
    end
    if sleep != nothing
        Base.sleep(sleep)
@@ -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}
@@ -0,0 +1,59 @@
+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"] = JSON.lower(plt.o)
+    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
@@ -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
@@ -1,34 +1,30 @@

 # NOTE: (0,0) is the top-left !!!

-# allow pixels and percentages
-const px = AbsoluteLength(0.254)
-const pct = Length{:pct, Float64}(1.0)
-
 to_pixels(m::AbsoluteLength) = m.value / 0.254

 const _cbar_width = 5mm

-@compat Base.:.*(m::Measure, n::Number) = m * n
-@compat Base.:.*(n::Number, m::Measure) = m * n
-@compat Base.:-(m::Measure, a::AbstractArray) = map(ai -> m - ai, a)
-@compat Base.:-(a::AbstractArray, m::Measure) = map(ai -> ai - m, a)
+#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{F<:AbstractFloat}(::Type{F}, l::AbsoluteLength) = convert(F, l.value)
+Base.convert(::Type{F}, l::AbsoluteLength) where {F<:AbstractFloat} = convert(F, l.value)

 # TODO: these are unintuitive and may cause tricky bugs
-# @compat Base.:+(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value * (1 + m2.value))
-# @compat Base.:+(m1::Length{:pct}, m2::AbsoluteLength) = AbsoluteLength(m2.value * (1 + m1.value))
-# @compat Base.:-(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value * (1 - m2.value))
-# @compat Base.:-(m1::Length{:pct}, m2::AbsoluteLength) = AbsoluteLength(m2.value * (m1.value - 1))
+# 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))

-@compat Base.:*(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value * m2.value)
-@compat Base.:*(m1::Length{:pct}, m2::AbsoluteLength) = AbsoluteLength(m2.value * m1.value)
-@compat Base.:/(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value / m2.value)
-@compat 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.:/(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
@@ -44,11 +40,11 @@ right(bbox::BoundingBox) = left(bbox) + width(bbox)
 bottom(bbox::BoundingBox) = top(bbox) + height(bbox)
 Base.size(bbox::BoundingBox) = (width(bbox), height(bbox))

-# @compat Base.:*{T,N}(m1::Length{T,N}, m2::Length{T,N}) = Length{T,N}(m1.value * m2.value)
+# 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
-@compat function Base.:+(bb1::BoundingBox, bb2::BoundingBox)
+function Base.:+(bb1::BoundingBox, bb2::BoundingBox)
    # empty boxes don't change the union
    ispositive(width(bb1))  || return bb2
    ispositive(height(bb1)) || return bb2
@@ -96,6 +92,32 @@ 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

@@ -107,18 +129,25 @@ 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 in (:left, :right)
+        if oarg == :center
+            orighor = origver = oarg
+        elseif oarg in (:left, :right, :hcenter)
            orighor = oarg
-        elseif oarg in (:top, :bottom)
+        elseif oarg in (:top, :bottom, :vcenter)
            origver = oarg
        else
-            warn("Unused origin arg in bbox construction: $oarg")
+            @warn("Unused origin arg in bbox construction: $oarg")
        end
    end
    bbox(x, y, w, h; h_anchor = orighor, v_anchor = origver)
@@ -132,13 +161,17 @@ function bbox(x, y, width, height; h_anchor = :left, v_anchor = :top)
    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 
+        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 
+        1h - y - height
    end
    BoundingBox(left, top, width, height)
 end
@@ -183,7 +216,7 @@ bottompad(layout::AbstractLayout) = 0mm
 # RootLayout

 # this is the parent of the top-level layout
-immutable RootLayout <: AbstractLayout end
+struct RootLayout <: AbstractLayout end

 Base.parent(::RootLayout) = nothing
 parent_bbox(::RootLayout) = defaultbox
@@ -193,7 +226,7 @@ bbox(::RootLayout) = defaultbox
 # EmptyLayout

 # contains blank space
-type EmptyLayout <: AbstractLayout
+mutable struct EmptyLayout <: AbstractLayout
    parent::AbstractLayout
    bbox::BoundingBox
    attr::KW  # store label, width, and height for initialization
@@ -211,7 +244,7 @@ _update_min_padding!(layout::EmptyLayout) = nothing
 # GridLayout

 # nested, gridded layout with optional size percentages
-type GridLayout <: AbstractLayout
+mutable struct GridLayout <: AbstractLayout
    parent::AbstractLayout
    minpad::Tuple # leftpad, toppad, rightpad, bottompad
    bbox::BoundingBox
@@ -221,6 +254,13 @@ type GridLayout <: AbstractLayout
    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...;
@@ -228,7 +268,7 @@ function GridLayout(dims...;
                    widths = zeros(dims[2]),
                    heights = zeros(dims[1]),
                    kw...)
-    grid = Matrix{AbstractLayout}(dims...)
+    grid = Matrix{AbstractLayout}(undef, dims...)
    layout = GridLayout(
        parent,
        (20mm, 5mm, 2mm, 10mm),
@@ -239,7 +279,9 @@ function GridLayout(dims...;
        # convert(Vector{Float64}, widths),
        # convert(Vector{Float64}, heights),
        KW(kw))
-    fill!(grid, EmptyLayout(layout))
+    for i in eachindex(grid)
+        grid[i] = EmptyLayout(layout)
+    end
    layout
 end

@@ -256,7 +298,7 @@ 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 
+# 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
@@ -311,16 +353,14 @@ function update_child_bboxes!(layout::GridLayout, minimum_perimeter = [0mm,0mm,0
    minpad_top    = map(toppad,    layout.grid)
    minpad_right  = map(rightpad,  layout.grid)
    minpad_bottom = map(bottompad, layout.grid)
-    # @show minpad_left minpad_top minpad_right minpad_bottom

    # 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   = maximum(minpad_left,   1)
-    pad_top    = maximum(minpad_top,    2)
-    pad_right  = maximum(minpad_right,  1)
-    pad_bottom = maximum(minpad_bottom, 2)
-    # @show pad_left pad_top pad_right pad_bottom
+    pad_left   = maximum(minpad_left,   dims = 1)
+    pad_top    = maximum(minpad_top,    dims = 2)
+    pad_right  = maximum(minpad_right,  dims = 1)
+    pad_bottom = maximum(minpad_bottom, dims = 2)

    # make sure the perimeter match the parent
    pad_left[1]     = max(pad_left[1], minimum_perimeter[1])
@@ -331,22 +371,18 @@ function update_child_bboxes!(layout::GridLayout, minimum_perimeter = [0mm,0mm,0
    # 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)
-    # @show total_pad_horizontal total_pad_vertical

    # 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
-    # @show total_plotarea_horizontal total_plotarea_vertical

    # recompute widths/heights
    layout.widths = recompute_lengths(layout.widths)
    layout.heights = recompute_lengths(layout.heights)
-    # @show layout.widths layout.heights

    # normalize widths/heights so they sum to 1
    # denom_w = sum(layout.widths)
    # denom_h = sum(layout.heights)
-    # @show layout.widths layout.heights denom_w, denom_h

    # we have all the data we need... lets compute the plot areas and set the bounding boxes
    for r=1:nr, c=1:nc
@@ -387,7 +423,6 @@ end
 function update_inset_bboxes!(plt::Plot)
    for sp in plt.inset_subplots
        p_area = Measures.resolve(plotarea(sp.parent), sp[:relative_bbox])
-        # @show bbox(sp.parent) sp[:relative_bbox] p_area
        plotarea!(sp, p_area)

        bbox!(sp, bbox(
@@ -429,14 +464,14 @@ end
 # constructors

 # pass the layout arg through
-function layout_args(d::KW)
-    layout_args(get(d, :layout, default(:layout)))
+function layout_args(plotattributes::KW)
+    layout_args(get(plotattributes, :layout, default(:layout)))
 end

-function layout_args(d::KW, n_override::Integer)
-    layout, n = layout_args(get(d, :layout, n_override))
+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_override.  You're probably trying to force existing plots into a layout that doesn't fit them.")
+        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
@@ -446,12 +481,12 @@ function layout_args(n::Integer)
    GridLayout(nr, nc), n
 end

-function layout_args{I<:Integer}(sztup::NTuple{2,I})
+function layout_args(sztup::NTuple{2,I}) where I<:Integer
    nr, nc = sztup
    GridLayout(nr, nc), nr*nc
 end

-function layout_args{I<:Integer}(sztup::NTuple{3,I})
+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
@@ -502,6 +537,12 @@ function build_layout(layout::GridLayout, n::Integer)
            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)
@@ -525,7 +566,7 @@ function build_layout(layout::GridLayout, numsp::Integer, plts::AVec{Plot})
    for r=1:nr, c=1:nc
        l = layout[r,c]
        if isa(l, EmptyLayout) && !get(l.attr, :blank, false)
-            plt = shift!(plts)  # grab the first plot out of the list
+            plt = popfirst!(plts)  # grab the first plot out of the list
            layout[r,c] = plt.layout
            append!(subplots, plt.subplots)
            merge!(spmap, plt.spmap)
@@ -538,6 +579,12 @@ function build_layout(layout::GridLayout, numsp::Integer, plts::AVec{Plot})
            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)
@@ -597,7 +644,7 @@ function create_grid(expr::Expr)
        create_grid_curly(expr)
    else
        # if it's something else, just return that (might be an existing layout?)
-        expr
+        esc(expr)
    end
 end

@@ -634,13 +681,18 @@ function create_grid_vcat(expr::Expr)
 end

 function create_grid_curly(expr::Expr)
-    s = expr.args[1]
    kw = KW()
    for (i,arg) in enumerate(expr.args[2:end])
        add_layout_pct!(kw, arg, i, length(expr.args)-1)
    end
-    # @show kw
-    :(EmptyLayout(label = $(QuoteNode(s)), width = $(get(kw, :w, QuoteNode(:auto))), height = $(get(kw, :h, QuoteNode(:auto)))))
+    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)
@@ -654,20 +706,42 @@ end

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

-# make all reference the same axis extrema/values
+# 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 = filter(l -> isa(l, Subplot), a)
+    subplots = link_subplots(a, axissym)
    axes = [sp.attr[axissym] for sp in subplots]
    if length(axes) > 0
        link_axes!(axes...)
@@ -709,3 +783,18 @@ function link_axes!(layout::GridLayout, link::Symbol)
        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])
@@ -5,7 +5,7 @@ defaultOutputFormat(plt::Plot) = "png"
 function png(plt::Plot, fn::AbstractString)
  fn = addExtension(fn, "png")
  io = open(fn, "w")
-  writemime(io, MIME("image/png"), plt)
+  show(io, MIME("image/png"), plt)
  close(io)
 end
 png(fn::AbstractString) = png(current(), fn)
@@ -13,7 +13,7 @@ png(fn::AbstractString) = png(current(), fn)
 function svg(plt::Plot, fn::AbstractString)
  fn = addExtension(fn, "svg")
  io = open(fn, "w")
-  writemime(io, MIME("image/svg+xml"), plt)
+  show(io, MIME("image/svg+xml"), plt)
  close(io)
 end
 svg(fn::AbstractString) = svg(current(), fn)
@@ -22,7 +22,7 @@ svg(fn::AbstractString) = svg(current(), fn)
 function pdf(plt::Plot, fn::AbstractString)
  fn = addExtension(fn, "pdf")
  io = open(fn, "w")
-  writemime(io, MIME("application/pdf"), plt)
+  show(io, MIME("application/pdf"), plt)
  close(io)
 end
 pdf(fn::AbstractString) = pdf(current(), fn)
@@ -31,30 +31,47 @@ pdf(fn::AbstractString) = pdf(current(), fn)
 function ps(plt::Plot, fn::AbstractString)
  fn = addExtension(fn, "ps")
  io = open(fn, "w")
-  writemime(io, MIME("application/postscript"), plt)
+  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")
-  writemime(io, MIME("application/x-tex"), plt)
+  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)
+

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


-@compat const _savemap = Dict(
+const _savemap = Dict(
    "png" => png,
    "svg" => svg,
    "pdf" => pdf,
    "ps"  => ps,
+    "eps" => eps,
    "tex" => tex,
+    "html" => html,
  )

 function getExtension(fn::AbstractString)
@@ -78,6 +95,13 @@ function addExtension(fn::AbstractString, ext::AbstractString)
  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)

  # get the extension
@@ -100,105 +124,98 @@ savefig(fn::AbstractString) = savefig(current(), fn)


 # ---------------------------------------------------------
+"""
+    gui([plot])

+Display a plot using the backends' gui window
+"""
 gui(plt::Plot = current()) = display(PlotsDisplay(), plt)

+# IJulia only... inline display
+function inline(plt::Plot = current())
+    isijulia() || error("inline() is IJulia-only")
+    Main.IJulia.clear_output(true)
+    display(Main.IJulia.InlineDisplay(), plt)
+end
+
 function Base.display(::PlotsDisplay, plt::Plot)
    prepare_output(plt)
    _display(plt)
 end

-# override the REPL display to open a gui window
-Base.display(::Base.REPL.REPLDisplay, ::MIME"text/plain", plt::Plot) = gui(plt)
+_do_plot_show(plt, showval::Bool) = showval && gui(plt)
+function _do_plot_show(plt, showval::Symbol)
+    showval == :gui && gui(plt)
+    showval in (:inline,:ijulia) && inline(plt)
+end

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

-const _mimeformats = Dict(
-    "application/eps"         => "eps",
-    "image/eps"               => "eps",
-    "application/pdf"         => "pdf",
-    "image/png"               => "png",
-    "application/postscript"  => "ps",
-    "image/svg+xml"           => "svg",
-    "text/plain"              => "txt",
-)
-
 const _best_html_output_type = KW(
    :pyplot => :png,
    :unicodeplots => :txt,
+    :plotlyjs => :html,
+    :plotly => :html
 )

 # a backup for html... passes to svg or png depending on the html_output_format arg
-function Base.writemime(io::IO, ::MIME"text/html", plt::Plot)
+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(writemime, MIME("image/png"), plt), "\" />")
+        # @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")
-        writemime(io, MIME("image/svg+xml"), plt)
+        # @info("writing svg to html output")
+        show(io, MIME("image/svg+xml"), plt)
    elseif output_type == :txt
-        writemime(io, MIME("text/plain"), plt)
+        show(io, MIME("text/plain"), plt)
    else
-        error("only png or svg allowed. got: $output_type")
+        error("only png or svg allowed. got: $(repr(output_type))")
    end
 end

+# delegate showable to _show instead
+function Base.showable(m::M, plt::P) where {M<:MIME, P<:Plot}
+    return hasmethod(_show, Tuple{IO, M, P})
+end
+
+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 keys(_mimeformats)
-    @eval function _writemime(io::IO, m, plt::Plot)
-        warn("_writemime is not defined for this backend. m=", string(m))
-    end
-    @eval function _display(plt::Plot)
-        warn("_display is not defined for this backend.")
-    end
-    @eval function Base.writemime(io::IO, m::MIME{Symbol($mime)}, plt::Plot)
-        prepare_output(plt)
-        _writemime(io, m, plt)
-    end
-end
-
-
-# ---------------------------------------------------------
-# A backup, if no PNG generation is defined, is to try to make a PDF and use FileIO to convert
-
-if is_installed("FileIO")
-    @eval begin
-        import FileIO
-        function _writemime(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, readall(open(pngfn)))
+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
+_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.writemime(io::IO, ::MIME"text/html", plt::Plot)
-#             print(io, "<img src=\"data:image/png;base64,", base64(writemime, MIME("image/png"), plt), "\" />")
+#         @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.writemime(io::IO, ::MIME"text/html", plt::Plot)
-#             writemime(io, MIME("image/svg+xml"), plt)
+#         @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")
@@ -207,64 +224,38 @@ end
 #
 # html_output_format("svg")

-# ---------------------------------------------------------
-# IJulia
-# ---------------------------------------------------------
-
-const _ijulia_output = Compat.ASCIIString["text/html"]
-
-function setup_ijulia()
-    # override IJulia inline display
-    if isijulia()
-        @eval begin
-            import IJulia
-            export set_ijulia_output
-            function set_ijulia_output(mimestr::AbstractString)
-                # info("Setting IJulia output format to $mimestr")
-                global _ijulia_output
-                _ijulia_output[1] = mimestr
-            end
-            function IJulia.display_dict(plt::Plot)
-                global _ijulia_output
-                Dict{Compat.ASCIIString, ByteString}(_ijulia_output[1] => sprint(writemime, _ijulia_output[1], plt))
-            end
-
-            # default text/plain passes to html... handles Interact issues
-            function Base.writemime(io::IO, m::MIME"text/plain", plt::Plot)
-                writemime(io, MIME("text/html"), plt)
-            end
-        end
-        set_ijulia_output("text/html")
-    end
-end

 # ---------------------------------------------------------
 # Atom PlotPane
 # ---------------------------------------------------------
+function showjuno(io::IO, m, plt)
+    sz = plt[:size]
+    dpi = plt[:dpi]
+    thickness_scaling = plt[:thickness_scaling]

-function setup_atom()
-    # @require Atom begin
-    if isatom() && get(ENV, "PLOTS_USE_ATOM_PLOTPANE", false) in (true, 1, "1", "true", "yes")
-        # @eval import Atom, Media
-        @eval import Atom
+    jsize = get(io, :juno_plotsize, [400, 500])

-        # connects the render function
-        for T in (GadflyBackend,ImmerseBackend,PyPlotBackend,GRBackend)
-            Atom.Media.media(Plot{T}, Atom.Media.Plot)
-        end
-        # Atom.Media.media{T <: Union{GadflyBackend,ImmerseBackend,PyPlotBackend,GRBackend}}(Plot{T}, Atom.Media.Plot)
+    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

-        # Atom.displaysize(::Plot) = (535, 379)
-        # Atom.displaytitle(plt::Plot) = "Plots.jl (backend: $(backend(plt)))"
-
-        # this is like "display"... sends an html div with the plot to the PlotPane
-        function Atom.Media.render(pane::Atom.PlotPane, plt::Plot)
-            Atom.Media.render(pane, Atom.div(Atom.d(), Atom.HTML(stringmime(MIME("text/html"), plt))))
-        end
-
-
-        # function Atom.Media.render(pane::Atom.PlotPane, plt::Plot{PlotlyBackend})
-        #     html = Media.render(pane, Atom.div(Atom.d(), Atom.HTML(stringmime(MIME("text/html"), plt))))
-        # end
+    prepare_output(plt)
+    try
+      _showjuno(io, m, plt)
+    finally
+      plt[:size] = sz
+      plt[:dpi] = dpi
+      plt[:thickness_scaling] = thickness_scaling
    end
 end
+
+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
+
+_showjuno(io::IO, m, plt) = _show(io, m, plt)
@@ -0,0 +1,425 @@
+
+
+# ------------------------------------------------------------------
+# preprocessing
+
+function command_idx(kw_list::AVec{KW}, kw::KW)
+    Int(kw[:series_plotindex]) - Int(kw_list[1][:series_plotindex]) + 1
+end
+
+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
+
+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
+
+
+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
+
+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
+
+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
+
+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
+
+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, plotattributes::KW, kw_list::Vector{KW})
+    # 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, plotattributes::KW, kw_list::Vector{KW})
+    # 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{Subplot,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
+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
+
+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
+
+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
+
+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
@@ -1,18 +1,22 @@

-type CurrentPlot
-    nullableplot::Nullable{AbstractPlot}
+mutable struct CurrentPlot
+    nullableplot::Union{AbstractPlot, Nothing}
 end
-const CURRENT_PLOT = CurrentPlot(Nullable{AbstractPlot}())
+const CURRENT_PLOT = CurrentPlot(nothing)

-isplotnull() = isnull(CURRENT_PLOT.nullableplot)
+isplotnull() = CURRENT_PLOT.nullableplot == nothing

+"""
+    current()
+Returns the Plot object for the current plot
+"""
 function current()
    if isplotnull()
        error("No current plot/subplot")
    end
-    get(CURRENT_PLOT.nullableplot)
+    CURRENT_PLOT.nullableplot
 end
-current(plot::AbstractPlot) = (CURRENT_PLOT.nullableplot = Nullable(plot))
+current(plot::AbstractPlot) = (CURRENT_PLOT.nullableplot = plot)

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

@@ -29,7 +33,7 @@ convertSeriesIndex(plt::Plot, n::Int) = n


 """
-The main plot command.  Use `plot` to create a new plot object, and `plot!` to add to an existing one:
+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
@@ -38,36 +42,37 @@ The main plot command.  Use `plot` to create a new plot object, and `plot!` to a
 ```

 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.  See the documentation for more info.
+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")`.
 """
-
-# this creates a new plot with args/kw and sets it to be the current plot
 function plot(args...; kw...)
-    d = KW(kw)
-    preprocessArgs!(d)
+    # 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 = d
-    _plot!(plt, d, args...)
+    # plt.user_attr = plotattributes
+    _plot!(plt, plotattributes, args)
 end

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

    # build our plot vector from the args
    n = length(plts_tail) + 1
-    plts = Array(Plot, n)
+    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(d, n)[1]
+    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.
@@ -78,19 +83,32 @@ function plot(plt1::Plot, plts_tail::Plot...; kw...)
    # 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 d
+    # update plot args, first with existing plots, then override with plotattributes
    for p in plts
-        _update_plot_args(plt, p.attr)
+        _update_plot_args(plt, copy(p.attr))
        plt.n += p.n
    end
-    _update_plot_args(plt, d)
+    _update_plot_args(plt, plotattributes)

    # pass new plot to the backend
    plt.o = _create_backend_figure(plt)
    plt.init = true

-    # create the layout and initialize the subplots
+    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)
@@ -100,35 +118,22 @@ function plot(plt1::Plot, plts_tail::Plot...; kw...)
        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

-    # # just in case the backend needs to set up the plot (make it current or something)
-    # _prepare_plot_object(plt)
-
    # first apply any args for the subplots
    for (idx,sp) in enumerate(plt.subplots)
-        _update_subplot_args(plt, sp, d, idx, remove_pair = false)
+        _update_subplot_args(plt, sp, plotattributes, idx, false)
    end

-    # # now we can get rid of the axis keys without a letter
-    # for k in keys(_axis_defaults)
-    #     delete!(d, k)
-    #     for letter in (:x,:y,:z)
-    #         delete!(d, Symbol(letter,k))
-    #     end
-    # end
-
-    # do we need to link any axes together?
-    link_axes!(plt.layout, plt[:link])
-
    # finish up
    current(plt)
-    if get(d, :show, default(:show))
-        gui()
-    end
+    _do_plot_show(plt, get(plotattributes, :show, default(:show)))
    plt
 end

@@ -147,246 +152,34 @@ end

 # this adds to a specific plot... most plot commands will flow through here
 function plot!(plt::Plot, args...; kw...)
-    d = KW(kw)
-    preprocessArgs!(d)
-    # merge!(plt.user_attr, d)
-    _plot!(plt, d, args...)
-end
-
-function strip_first_letter(s::Symbol)
-    str = string(s)
-    str[1:1], Symbol(str[2:end])
-end
-
-
-# this method recursively applies series recipes when the seriestype is not supported
-# natively by the backend
-function _apply_series_recipe(plt::Plot, d::KW)
-    # replace seriestype aliases
-    st = d[:seriestype]
-    st = d[:seriestype] = get(_typeAliases, st, st)
-
-    # if it's natively supported, finalize processing and pass along to the backend, otherwise recurse
-    if st in supported_types()
-
-        # getting ready to add the series... last update to subplot from anything
-        # that might have been added during series recipes
-        sp = d[:subplot]
-        sp_idx = get_subplot_index(plt, sp)
-        _update_subplot_args(plt, sp, d, sp_idx)
-
-        # do we want to override the series type?
-        if !is3d(st) && d[:z] != nothing && (size(d[:x]) == size(d[:y]) == size(d[:z]))
-            st = d[:seriestype] = (st == :scatter ? :scatter3d : :path3d)
-        end
-
-        # 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
-
-        # 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])
-        anns = annotations(pop!(d, :series_annotations, []))
-        if length(anns) > 0
-            x, y = d[:x], d[:y]
-            nx, ny, na = map(length, (x,y,anns))
-            n = max(nx, ny, na)
-            anns = [(x[mod1(i,nx)], y[mod1(i,ny)], text(anns[mod1(i,na)])) for i=1:n]
-        end
-        sp.attr[:annotations] = vcat(sp_anns, anns)
-
-        # adjust extrema and discrete info
-        if st == :image
-            w, h = size(d[:z])
-            expand_extrema!(sp[:xaxis], (0,w))
-            expand_extrema!(sp[:yaxis], (0,h))
-            sp[:yaxis].d[:flip] = true
-        elseif !(st in (:pie, :histogram, :histogram2d))
-            expand_extrema!(sp, d)
-        end
-
-
-        # add the series!
-        warnOnUnsupported_args(plt.backend, d)
-        warnOnUnsupported(plt.backend, d)
-        series = Series(d)
-        push!(plt.series_list, series)
-        # @show series
-        
-        _series_added(plt, series)
-
-    else
-        # get a sub list of series for this seriestype
-        datalist = RecipesBase.apply_recipe(d, Val{st}, d[:x], d[:y], d[:z])
-        # datalist = try
-        #     RecipesBase.apply_recipe(d, Val{st}, d[:x], d[:y], d[:z])
-        # catch
-        #     warn("Exception during apply_recipe(Val{$st}, ...) with types ($(typeof(d[:x])), $(typeof(d[:y])), $(typeof(d[:z])))")
-        #     rethrow()
-        # end
-
-        # assuming there was no error, recursively apply the series recipes
-        for data in datalist
-            if isa(data, RecipeData)
-                _apply_series_recipe(plt, data.d)
-            else
-                warn("Unhandled recipe: $(data)")
-                break
-            end
-        end
-    end
-end
-
-function command_idx(kw_list::AVec{KW}, kw::KW)
-    kw[:series_plotindex] - kw_list[1][:series_plotindex] + 1
+    plotattributes = KW(kw)
+    preprocessArgs!(plotattributes)
+    # merge!(plt.user_attr, plotattributes)
+    _plot!(plt, plotattributes, args)
 end

+# -------------------------------------------------------------------------------

 # 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, d::KW, args...)
-    d[:plot_object] = plt
+function _plot!(plt::Plot, plotattributes::KW, args::Tuple)
+    plotattributes[:plot_object] = plt

-    # 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(d, :group)
-        args = (extractGroupArgs(d[: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.
-    kw_list = KW[]
-    still_to_process = if isempty(args)
-        []
-    else
-        sts = get(d, :seriestype, :path)
-        if typeof(sts) <: AbstractArray
-            [begin
-                dc = copy(d)
-                dc[:seriestype] = sts[r,:]
-                RecipeData(dc, args)
-            end for r=1:size(sts,1)]
-        else
-            [RecipeData(copy(d), args)]
-        end
-    end
-
-    # remove subplot and axis args from d... they will be passed through in the kw_list
-    if !isempty(args)
-        for (k,v) in d
-            for defdict in (_subplot_defaults,
-                            _axis_defaults,
-                            _axis_defaults_byletter)
-                if haskey(defdict, k)
-                    delete!(d, k)
-                end
-            end
-        end
+    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"
    # --------------------------------

-    # for plotting recipes, swap out the args and update the parameter dictionary
-    # we are keeping a queue 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, and the rest go into the queue
-    # for processing.
-    while !isempty(still_to_process)
+    kw_list = _process_userrecipes(plt, plotattributes, args)

-        # grab the first in line to be processed and pass it through apply_recipe
-        # to generate a list of RecipeData objects (data + attributes)
-        next_series = shift!(still_to_process)
-        for recipedata in RecipesBase.apply_recipe(next_series.d, next_series.args...)
+    # @info(1)
+    # map(DD, kw_list)

-            # recipedata should be of type RecipeData.  if it's not then the inputs must not have been fully processed by recipes
-            if !(typeof(recipedata) <: RecipeData)
-                error("Inputs couldn't be processed... expected RecipeData but got: $recipedata")
-            end
-
-            if isempty(recipedata.args)
-                # 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.d
-                _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] = 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] = 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
-
-                # add the plot index
-                plt.n += 1
-                kw[:series_plotindex] = plt.n
-
-                # check that the backend will support the command and add it to the list
-                warnOnUnsupported_scales(plt.backend, kw)
-                push!(kw_list, 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(d, 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
-
-                # handle smoothing by adding a new series
-                if get(d, :smooth, false)
-                    x, y = kw[:x], kw[:y]
-                    β, α = convert(Matrix{Float64}, [x ones(length(x))]) \ convert(Vector{Float64}, y)
-                    sx = [minimum(x), maximum(x)]
-                    sy = β * sx + α
-                    push!(kw_list, merge(copy(kw), KW(
-                        :seriestype => :path,
-                        :x => sx,
-                        :y => sy,
-                        :fillrange => nothing,
-                        :label => "",
-                        :primary => false,
-                    )))
-                end
-
-            else
-                # args are non-empty, so there's still processing to do... add it back to the queue
-                push!(still_to_process, recipedata)
-            end
-        end
-    end
-
-    # don't allow something else to handle it
-    d[:smooth] = false

    # --------------------------------
    # "PLOT RECIPES"
@@ -399,117 +192,18 @@ function _plot!(plt::Plot, d::KW, args...)
    still_to_process = kw_list
    kw_list = KW[]
    while !isempty(still_to_process)
-        # 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.
-        next_kw = shift!(still_to_process)
-        if !isa(get(next_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, next_kw)
-            continue
-        end
-        try
-            st = next_kw[:seriestype]
-            st = next_kw[:seriestype] = get(_typeAliases, st, st)
-            datalist = RecipesBase.apply_recipe(next_kw, Val{st}, plt)
-            for data in datalist
-                if data.d[:seriestype] == st
-                    error("Plot recipe $st returned the same seriestype: $(data.d)")
-                end
-                push!(still_to_process, data.d)
-            end
-        catch err
-            if isa(err, MethodError)
-                push!(kw_list, next_kw)
-            else
-                rethrow()
-            end
-        end
+        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
    # --------------------------------
-    
-    # merge in anything meant for the Plot
-    for kw in kw_list, (k,v) in kw
-        haskey(_plot_defaults, k) && (d[k] = pop!(kw, k))
-    end
-
-    # TODO: init subplots here
-    _update_plot_args(plt, d)
-    if !plt.init
-        plt.o = _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
-            sp.attr[:relative_bbox] = bb
-            sp.attr[:subplot_index] = length(plt.subplots)
-            push!(plt.subplots, sp)
-            push!(plt.inset_subplots, sp)
-        end
-    end
-
-    # 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{Subplot,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
-
-        attr = KW()
-        for (k,v) in kw
-            for defdict in (_subplot_defaults,
-                            _axis_defaults,
-                            _axis_defaults_byletter)
-                if haskey(defdict, k)
-                    attr[k] = pop!(kw, k)
-                end
-            end
-        end
-        sp_attrs[sp] = attr
-    end
-
-    # override subplot/axis args.  `sp_attrs` take precendence
-    for (idx,sp) in enumerate(plt.subplots)
-        attr = merge(d, get(sp_attrs, sp, KW()))
-        _update_subplot_args(plt, sp, attr, idx, remove_pair = false)
-    end
-
-    # do we need to link any axes together?
-    link_axes!(plt.layout, plt[:link])
+    _plot_setup(plt, plotattributes, kw_list)
+    _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 !!!
@@ -517,13 +211,16 @@ function _plot!(plt::Plot, d::KW, args...)
    # --------------------------------
    # "SERIES RECIPES"
    # --------------------------------
-    
+
+    # @info(3)
+    # map(DD, kw_list)
+
    for kw in kw_list
-        sp = kw[:subplot]
-        idx = get_subplot_index(plt, sp)
+        sp::Subplot = 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)
+        # _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))
@@ -534,7 +231,7 @@ function _plot!(plt::Plot, d::KW, args...)
        # 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).
-        _apply_series_recipe(plt, kw)
+        _process_seriesrecipe(plt, kw)
    end

    # --------------------------------
@@ -542,21 +239,15 @@ function _plot!(plt::Plot, d::KW, args...)
    current(plt)

    # do we want to force display?
-    if plt[:show]
-        gui()
-    end
+    # if plt[:show]
+    #     gui(plt)
+    # end
+    _do_plot_show(plt, plt[:show])

    plt
 end


-function _replace_linewidth(d::KW)
-    # get a good default linewidth... 0 for surface and heatmaps
-    if get(d, :linewidth, :auto) == :auto
-        d[:linewidth] = (get(d, :seriestype, :path) in (:surface,:heatmap,:image) ? 0 : 1)
-    end
-end
-
 # we're getting ready to display/output.  prep for layout calcs, then update
 # the plot object after
 function prepare_output(plt::Plot)
@@ -582,81 +273,21 @@ function prepare_output(plt::Plot)
    _update_plot_object(plt)
 end

-function prepared_object(plt::Plot)
+function backend_object(plt::Plot)
    prepare_output(plt)
    plt.o
 end

 # --------------------------------------------------------------------
+# plot to a Subplot

-# function get_indices(orig, labels)
-#     Int[findnext(labels, l, 1) for l in orig]
-# end
-
-# # TODO: remove?? this is the old way of handling discrete data... should be
-# # replaced by the Axis type and logic
-# function setTicksFromStringVector(plt::Plot, d::KW, di::KW, letter)
-#     sym = Symbol(letter)
-#     ticksym = Symbol(letter * "ticks")
-#     pargs = plt.attr
-#     v = di[sym]
-#
-#     # do we really want to do this?
-#     typeof(v) <: AbstractArray || return
-#     isempty(v) && return
-#     trueOrAllTrue(_ -> typeof(_) <: AbstractString, v) || return
-#
-#     # compute the ticks and labels
-#     ticks, labels = if ticksType(pargs[ticksym]) == :ticks_and_labels
-#         # extend the existing ticks and labels. only add to labels if they're new!
-#         ticks, labels = pargs[ticksym]
-#         newlabels = filter(_ -> !(_ in labels), unique(v))
-#         newticks = if isempty(ticks)
-#             collect(1:length(newlabels))
-#         else
-#             maximum(ticks) + collect(1:length(newlabels))
-#         end
-#         ticks = vcat(ticks, newticks)
-#         labels = vcat(labels, newlabels)
-#         ticks, labels
-#     else
-#         # create new ticks and labels
-#         newlabels = unique(v)
-#         collect(1:length(newlabels)), newlabels
-#     end
-#
-#     d[ticksym] = ticks, labels
-#     plt.attr[ticksym] = ticks, labels
-#
-#     # add an origsym field so that later on we can re-compute the x vector if ticks change
-#     origsym = Symbol(letter * "orig")
-#     di[origsym] = v
-#     di[sym] = get_indices(v, labels)
-#
-#     # loop through existing plt.seriesargs and adjust indices if there is an origsym key
-#     for sargs in plt.seriesargs
-#         if haskey(sargs, origsym)
-#             # TODO: might need to call the setindex function instead to trigger a plot update for some backends??
-#             sargs[sym] = get_indices(sargs[origsym], labels)
-#         end
-#     end
-# end
-
-
-# --------------------------------------------------------------------
-
-
-
-# --------------------------------------------------------------------
-
-# function Base.copy(plt::Plot)
-#     backend(plt.backend)
-#     plt2 = plot(; plt.attr...)
-#     for sargs in plt.seriesargs
-#         sargs = filter((k,v) -> haskey(_series_defaults,k), sargs)
-#         plot!(plt2; sargs...)
-#     end
-#     plt2
-# end
+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

 # --------------------------------------------------------------------
@@ -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
@@ -0,0 +1,3 @@
+function _precompile_()
+    ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
+end
@@ -0,0 +1,648 @@
+
+
+# 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}}
+
+all3D(plotattributes::KW) = trueOrAllTrue(st -> st in (:contour, :contourf, :heatmap, :surface, :wireframe, :contour3d, :image, :plots_heatmap), get(plotattributes, :seriestype, :none))
+
+# unknown
+convertToAnyVector(x, plotattributes::KW) = error("No user recipe defined for $(typeof(x))")
+
+# missing
+convertToAnyVector(v::Nothing, plotattributes::KW) = Any[nothing], nothing
+
+# fixed number of blank series
+convertToAnyVector(n::Integer, plotattributes::KW) = Any[zeros(0) for i in 1:n], nothing
+
+# numeric/string vector
+convertToAnyVector(v::AVec{T}, plotattributes::KW) where {T<:Union{Number,String,Missing}} = Any[handlemissings(v)], nothing
+
+function convertToAnyVector(v::AMat, plotattributes::KW)
+    v = handlemissings(v)
+    if all3D(plotattributes)
+        Any[Surface(v)]
+    else
+        Any[v[:,i] for i in 1:size(v,2)]
+    end, nothing
+end
+
+handlemissings(v) = v
+handlemissings(v::AbstractArray{Union{T,Missing}}) where T <: Number = replace(v, missing => NaN)
+handlemissings(v::AbstractArray{Union{T,Missing}}) where T <: String = replace(v, missing => "")
+
+# function
+convertToAnyVector(f::Function, plotattributes::KW) = Any[f], nothing
+
+# surface
+convertToAnyVector(s::Surface, plotattributes::KW) = Any[s], nothing
+
+# volume
+convertToAnyVector(v::Volume, plotattributes::KW) = Any[v], nothing
+
+# # vector of OHLC
+# convertToAnyVector(v::AVec{OHLC}, plotattributes::KW) = Any[v], nothing
+
+# # dates
+convertToAnyVector(dts::AVec{D}, plotattributes::KW) where {D<:Union{Date,DateTime}} = Any[dts], nothing
+
+# list of things (maybe other vectors, functions, or something else)
+function convertToAnyVector(v::AVec, plotattributes::KW)
+    if all(x -> typeof(x) <: Number, v)
+        # all real numbers wrap the whole vector as one item
+        Any[convert(Vector{Float64}, v)], nothing
+    else
+        # something else... treat each element as an item
+        vcat(Any[convertToAnyVector(vi, plotattributes)[1] for vi in v]...), nothing
+        # Any[vi for vi in v], nothing
+    end
+end
+
+convertToAnyVector(t::Tuple, plotattributes::KW) = Any[t], nothing
+
+
+function convertToAnyVector(args...)
+    error("In convertToAnyVector, could not handle the argument types: $(map(typeof, args[1:end-1]))")
+end
+
+# --------------------------------------------------------------------
+
+# 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, plotattributes)
+    ys, _ = convertToAnyVector(y, plotattributes)
+    zs, _ = convertToAnyVector(z, plotattributes)
+
+    fr = pop!(plotattributes, :fillrange, nothing)
+    fillranges, _ = if typeof(fr) <: Number
+        ([fr],nothing)
+    else
+        convertToAnyVector(fr, plotattributes)
+    end
+    mf = length(fillranges)
+
+    rib = pop!(plotattributes, :ribbon, nothing)
+    ribbons, _ = if typeof(rib) <: Number
+        ([fr],nothing)
+    else
+        convertToAnyVector(rib, plotattributes)
+    end
+    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, ()))
+        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)
+
+# 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}
+    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<:Number
+    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
+
+
+
+# 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 != :group) && 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
@@ -1,99 +0,0 @@
-
-# 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
-
-typealias FuncOrFuncs @compat(Union{Function, AVec{Function}})
-
-all3D(d::KW) = trueOrAllTrue(st -> st in (:contour, :heatmap, :surface, :wireframe, :contour3d, :image), get(d, :seriestype, :none))
-
-# missing
-convertToAnyVector(v::@compat(Void), d::KW) = Any[nothing], nothing
-
-# fixed number of blank series
-convertToAnyVector(n::Integer, d::KW) = Any[zeros(0) for i in 1:n], nothing
-
-# numeric vector
-convertToAnyVector{T<:Number}(v::AVec{T}, d::KW) = Any[v], nothing
-
-# string vector
-convertToAnyVector{T<:@compat(AbstractString)}(v::AVec{T}, d::KW) = Any[v], nothing
-
-function convertToAnyVector(v::AMat, d::KW)
-    if all3D(d)
-        Any[Surface(v)]
-    else
-        Any[v[:,i] for i in 1:size(v,2)]
-    end, nothing
-end
-
-# function
-convertToAnyVector(f::Function, d::KW) = Any[f], nothing
-
-# surface
-convertToAnyVector(s::Surface, d::KW) = Any[s], nothing
-
-# # vector of OHLC
-# convertToAnyVector(v::AVec{OHLC}, d::KW) = Any[v], nothing
-
-# dates
-convertToAnyVector{D<:Union{Date,DateTime}}(dts::AVec{D}, d::KW) = Any[dts], nothing
-
-# list of things (maybe other vectors, functions, or something else)
-function convertToAnyVector(v::AVec, d::KW)
-    if all(x -> typeof(x) <: Number, v)
-        # all real numbers wrap the whole vector as one item
-        Any[convert(Vector{Float64}, v)], nothing
-    else
-        # something else... treat each element as an item
-        vcat(Any[convertToAnyVector(vi, d)[1] for vi in v]...), nothing
-        # Any[vi for vi in v], nothing
-    end
-end
-
-convertToAnyVector(t::Tuple, d::KW) = Any[t], nothing
-
-
-function convertToAnyVector(args...)
-    error("In convertToAnyVector, could not handle the argument types: $(map(typeof, args[1:end-1]))")
-end
-
-# --------------------------------------------------------------------
-
-# 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::Void, y::Void, z)      = 1:size(z,1)
-compute_x(x::Void, 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::Void, y::Void, 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::Void)            = 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::Void, y::FuncOrFuncs, z)       = error("If you want to plot the function `$y`, you need to define the x values!")
-compute_xyz(x::Void, y::Void, z::FuncOrFuncs) = error("If you want to plot the function `$z`, you need to define x and y values!")
-compute_xyz(x::Void, y::Void, z::Void)        = error("x/y/z are all nothing!")
-
-# --------------------------------------------------------------------
@@ -1,407 +0,0 @@
-
-# we are going to build recipes to do the processing and splitting of the args
-
-
-function _add_defaults!(d::KW, plt::Plot, sp::Subplot, commandIndex::Int)
-    pkg = plt.backend
-    globalIndex = d[:series_plotindex]
-
-    # add default values to our dictionary, being careful not to delete what we just added!
-    for (k,v) in _series_defaults
-        slice_arg!(d, d, k, v, commandIndex, remove_pair = false)
-    end
-
-    # this is how many series belong to this subplot
-    plotIndex = count(series -> series.d[:subplot] === sp && series.d[:primary], plt.series_list)
-    if get(d, :primary, true)
-        plotIndex += 1
-    end
-
-    aliasesAndAutopick(d, :linestyle, _styleAliases, supported_styles(pkg), plotIndex)
-    aliasesAndAutopick(d, :markershape, _markerAliases, supported_markers(pkg), plotIndex)
-
-    # update color
-    d[:seriescolor] = getSeriesRGBColor(d[:seriescolor], sp, plotIndex)
-
-    # update colors
-    for csym in (:linecolor, :markercolor, :fillcolor)
-        d[csym] = if d[csym] == :match
-            if has_black_border_for_default(d[:seriestype]) && csym == :linecolor
-                :black
-            else
-                d[:seriescolor]
-            end
-        else
-            getSeriesRGBColor(d[csym], sp, plotIndex)
-        end
-    end
-
-    # update markerstrokecolor
-    c = d[:markerstrokecolor]
-    c = if c == :match
-        sp[:foreground_color_subplot]
-    else
-        getSeriesRGBColor(c, sp, plotIndex)
-    end
-    d[:markerstrokecolor] = c
-
-    # update alphas
-    for asym in (:linealpha, :markeralpha, :fillalpha)
-        if d[asym] == nothing
-            d[asym] = d[:seriesalpha]
-        end
-    end
-    if d[:markerstrokealpha] == nothing
-        d[:markerstrokealpha] = d[:markeralpha]
-    end
-
-    # scatter plots don't have a line, but must have a shape
-    if d[:seriestype] in (:scatter, :scatter3d)
-        d[:linewidth] = 0
-        if d[:markershape] == :none
-            d[:markershape] = :circle
-        end
-    end
-
-    # set label
-    label = d[:label]
-    label = (label == "AUTO" ? "y$globalIndex" : label)
-    d[:label] = label
-
-    _replace_linewidth(d)
-    d
-end
-
-# -------------------------------------------------------------------
-# -------------------------------------------------------------------
-
-# instead of process_inputs:
-
-# ensure we dispatch to the slicer
-immutable SliceIt end
-
-# the catch-all recipes
-@recipe function f(::Type{SliceIt}, x, y, z)
-    # @show "HERE", typeof((x,y,z))
-    xs, _ = convertToAnyVector(x, d)
-    ys, _ = convertToAnyVector(y, d)
-    zs, _ = convertToAnyVector(z, d)
-
-    fr = pop!(d, :fillrange, nothing)
-    fillranges, _ = if typeof(fr) <: Number
-        ([fr],nothing)
-    else
-        convertToAnyVector(fr, d)
-    end
-    mf = length(fillranges)
-
-    # @show zs
-
-    mx = length(xs)
-    my = length(ys)
-    mz = length(zs)
-    # ret = Any[]
-    for i in 1:max(mx, my, mz)
-        # add a new series
-        di = copy(d)
-        xi, yi, zi = xs[mod1(i,mx)], ys[mod1(i,my)], zs[mod1(i,mz)]
-        # @show i, typeof((xi, yi, zi))
-        di[:x], di[:y], di[:z] = compute_xyz(xi, yi, zi)
-        # @show i, typeof((di[:x], di[:y], di[:z]))
-
-        # handle fillrange
-        fr = fillranges[mod1(i,mf)]
-        di[:fillrange] = isa(fr, Function) ? map(fr, di[:x]) : fr
-
-        # @show i, di[:x], di[:y], di[:z]
-        push!(series_list, RecipeData(di, ()))
-    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{T<:Any}(::Type{T}, v::T) = v
-
-# this should catch unhandled "series recipes" and error with a nice message
-@recipe f{V<:Val}(::Type{V}, x, y, z) = error("The backend must not support the series type $V, and there isn't a series recipe defined.")
-
-_apply_type_recipe(d, v) = RecipesBase.apply_recipe(d, typeof(v), v)[1].args[1]
-
-# 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(d, x)
-    x === newx || (did_replace = true)
-    newy = _apply_type_recipe(d, y)
-    y === newy || (did_replace = true)
-    newz = _apply_type_recipe(d, 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(d, x)
-    x === newx || (did_replace = true)
-    newy = _apply_type_recipe(d, 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(d, 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(d, 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
-# # --------------------------------------------------------------------
-
-@recipe f(n::Integer) = n, n, n
-
-# return a surface if this is a 3d plot, otherwise let it be sliced up
-@recipe function f{T<:Number}(mat::AMat{T})
-    if all3D(d)
-        n,m = size(mat)
-        SliceIt, 1:m, 1:n, Surface(mat)
-    else
-        SliceIt, nothing, mat, nothing
-    end
-end
-
-
-# # images - grays
-
-@recipe function f{T<:Gray}(mat::AMat{T})
-    if nativeImagesSupported()
-        seriestype := :image
-        n, m = size(mat)
-        SliceIt, 1:m, 1:n, Surface(mat)
-    else
-        seriestype := :heatmap
-        yflip --> true
-        fillcolor --> ColorGradient([:black, :white])
-        SliceIt, 1:m, 1:n, Surface(convert(Matrix{Float64}, mat))
-    end
-end
-
-# # images - colors
-
-@recipe function f{T<:Colorant}(mat::AMat{T})
-    if nativeImagesSupported()
-        seriestype := :image
-        n, m = size(mat)
-        SliceIt, 1:m, 1:n, Surface(mat)
-    else
-        seriestype := :heatmap
-        yflip --> true
-        z, d[: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
-    shape_coords(shape)
-end
-
-@recipe function f(shapes::AVec{Shape})
-    seriestype := :shape
-    shape_coords(shapes)
-end
-
-@recipe function f(shapes::AMat{Shape})
-    for j in 1:size(shapes,2)
-        # create one series for each column
-        # @series shape_coords(vec(shapes[:,j]))
-        di = copy(d)
-        push!(series_list, RecipeData(di, shape_coords(vec(shapes[:,j]))))
-    end
-    nothing # don't create a series for the main block
-end
-
-#
-#
-# # function without range... use the current range of the x-axis
-
-@recipe function f(f::FuncOrFuncs)
-    plt = d[:plot_object]
-    f, xmin(plt), xmax(plt)
-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, x)
-    @assert !(typeof(x) <: FuncOrFuncs)  # 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(d, :seriestype, :none)
-    # if st == :scatter
-    #     d[:seriestype] = :scatter3d
-    # elseif !is3d(st)
-    #     d[:seriestype] = :path3d
-    # end
-    SliceIt, x, y, z
-end
-
-@recipe function f(x::AMat, y::AMat, z::AMat)
-    # st = get(d, :seriestype, :none)
-    # if size(x) == size(y) == size(z)
-    #     if !is3d(st)
-    #         seriestype := :path3d
-    #     end
-    # end
-    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
-    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(d, :seriestype, :none))
-        d[:seriestype] = :contour
-    end
-    SliceIt, x, y, Surface(z)
-end
-
-#
-#
-# # --------------------------------------------------------------------
-# # Parametric functions
-# # --------------------------------------------------------------------
-
-#
-# # special handling... xmin/xmax with parametric function(s)
-@recipe f(f::FuncOrFuncs, xmin::Number, xmax::Number) = linspace(xmin, xmax, 100), f
-@recipe f(fx::FuncOrFuncs, fy::FuncOrFuncs, u::AVec)  = mapFuncOrFuncs(fx, u), mapFuncOrFuncs(fy, u)
-@recipe f(fx::FuncOrFuncs, fy::FuncOrFuncs, umin::Number, umax::Number, n = 200) = fx, fy, linspace(umin, umax, n)
-
-#
-# # special handling... 3D parametric function(s)
-@recipe function f(fx::FuncOrFuncs, fy::FuncOrFuncs, fz::FuncOrFuncs, u::AVec)
-    mapFuncOrFuncs(fx, u), mapFuncOrFuncs(fy, u), mapFuncOrFuncs(fz, u)
-end
-@recipe function f(fx::FuncOrFuncs, fy::FuncOrFuncs, fz::FuncOrFuncs, umin::Number, umax::Number, numPoints = 200)
-    fx, fy, fz, linspace(umin, umax, numPoints)
-end
-
-#
-#
-# # --------------------------------------------------------------------
-# # Lists of tuples and FixedSizeArrays
-# # --------------------------------------------------------------------
-#
-# # if we get an unhandled tuple, just splat it in
-@recipe f(tup::Tuple) = tup
-
-#
-# # (x,y) tuples
-@recipe f{R1<:Number,R2<:Number}(xy::AVec{Tuple{R1,R2}}) = unzip(xy)
-@recipe f{R1<:Number,R2<:Number}(xy::Tuple{R1,R2})       = [xy[1]], [xy[2]]
-
-#
-# # (x,y,z) tuples
-@recipe f{R1<:Number,R2<:Number,R3<:Number}(xyz::AVec{Tuple{R1,R2,R3}}) = unzip(xyz)
-@recipe f{R1<:Number,R2<:Number,R3<:Number}(xyz::Tuple{R1,R2,R3})       = [xyz[1]], [xyz[2]], [xyz[3]]
-
-# these might be points+velocity, or OHLC or something else
-@recipe f{R1<:Number,R2<:Number,R3<:Number,R4<:Number}(xyuv::AVec{Tuple{R1,R2,R3,R4}}) = get(d,:seriestype,:path)==:ohlc ? OHLC[OHLC(t...) for t in xyuv] : unzip(xyuv)
-@recipe f{R1<:Number,R2<:Number,R3<:Number,R4<:Number}(xyuv::Tuple{R1,R2,R3,R4})       = [xyuv[1]], [xyuv[2]], [xyuv[3]], [xyuv[4]]
-
-
-#
-# # 2D FixedSizeArrays
-@recipe f{T<:Number}(xy::AVec{FixedSizeArrays.Vec{2,T}}) = unzip(xy)
-@recipe f{T<:Number}(xy::FixedSizeArrays.Vec{2,T})       = [xy[1]], [xy[2]]
-
-#
-# # 3D FixedSizeArrays
-@recipe f{T<:Number}(xyz::AVec{FixedSizeArrays.Vec{3,T}}) = unzip(xyz)
-@recipe f{T<:Number}(xyz::FixedSizeArrays.Vec{3,T})       = [xyz[1]], [xyz[2]], [xyz[3]]
-
-#
-# # --------------------------------------------------------------------
-# # 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(d)
-#         get!(di, :label, string(glab))
-#         get!(di, :idxfilter, groupby.groupIds[i])
-#         push!(series_list, RecipeData(di, args))
-#     end
-#     nothing
-# end
-
-# split the group into 1 series per group, and set the label and idxfilter for each
-@recipe function f(groupby::GroupBy, args...)
-    for (i,glab) in enumerate(groupby.groupLabels)
-        @series begin
-            label     --> string(glab)
-            idxfilter --> groupby.groupIds[i]
-            args
-        end
-    end
-end
-
@@ -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...)
@@ -1,8 +1,9 @@


-function Subplot{T<:AbstractBackend}(::T; parent = RootLayout())
+function Subplot(::T; parent = RootLayout()) where T<:AbstractBackend
    Subplot{T}(
        parent,
+        Series[],
        (20mm, 5mm, 2mm, 10mm),
        defaultbox,
        defaultbox,
@@ -12,6 +13,11 @@ function Subplot{T<:AbstractBackend}(::T; parent = RootLayout())
    )
 end

+"""
+    plotarea(subplot)
+
+Return the bounding box of a subplot
+"""
 plotarea(sp::Subplot) = sp.plotarea
 plotarea!(sp::Subplot, bbox::BoundingBox) = (sp.plotarea = bbox)

@@ -28,18 +34,18 @@ 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.d[:subplot]
+get_subplot(series::Series) = series.plotattributes[:subplot]

-get_subplot_index(plt::Plot, idx::Integer) = idx
-get_subplot_index(plt::Plot, sp::Subplot) = findfirst(_ -> _ === sp, plt.subplots)
+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) = filter(series -> series.d[:subplot] === sp, sp.plt.series_list)
+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.d[:primary] && series.d[:label] != "" &&
-        !(series.d[:seriestype] in (
-            :hexbin,:histogram2d,:hline,:vline,
-            :contour,:contour3d,:surface,:wireframe,
+    series.plotattributes[:primary] && series.plotattributes[:label] != "" &&
+        !(series.plotattributes[:seriestype] in (
+            :hexbin,:bins2d,:histogram2d,:hline,:vline,
+            :contour,:contourf,:contour3d,:surface,:wireframe,
            :heatmap, :pie, :image
        ))
 end
@@ -1,65 +1,168 @@
+"""
+    theme(s::Symbol)

-const _invisible = RGBA(0,0,0,0)
+Specify the colour theme for plots.
+"""
+function theme(s::Symbol; kw...)
+    defaults = _get_defaults(s)
+    _theme(s, defaults; kw...)
+end

-const _themes = KW(
-    :default => KW(
-        :bg         => :white,
-        :bglegend   => :match,
-        :bginside   => :match,
-        :bgoutside  => :match,
-        :fg         => :auto,
-        :fglegend   => :match,
-        :fggrid     => :match,
-        :fgaxis     => :match,
-        :fgtext     => :match,
-        :fgborder   => :match,
-        :fgguide    => :match,
-    )
+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

-function add_theme(sym::Symbol, theme::KW)
-    _themes[sym] = theme
-end
-
-# add a new theme, using an existing theme as the base
-function add_theme(sym::Symbol;
-                   base      = :default,  # start with this theme
-                   bg        = _themes[base][:bg],
-                   bglegend  = _themes[base][:bglegend],
-                   bginside  = _themes[base][:bginside],
-                   bgoutside = _themes[base][:bgoutside],
-                   fg        = _themes[base][:fg],
-                   fglegend  = _themes[base][:fglegend],
-                   fggrid    = _themes[base][:fggrid],
-                   fgaxis    = _themes[base][:fgaxis],
-                   fgtext    = _themes[base][:fgtext],
-                   fgborder  = _themes[base][:fgborder],
-                   fgguide   = _themes[base][:fgguide],
-                   kw...)
-    _themes[sym] = merge(KW(
-        :bg => bg,
-        :bglegend  => bglegend,
-        :bginside  => bginside,
-        :bgoutside => bgoutside,
-        :fg        => fg,
-        :fglegend  => fglegend,
-        :fggrid    => fggrid,
-        :fgaxis    => fgaxis,
-        :fgtext    => fgtext,
-        :fgborder  => fgborder,
-        :fgguide   => fgguide,
-    ), KW(kw))
-end
-
-add_theme(:ggplot2,
-    bglegend = _invisible,
-    bginside = :lightgray,
-    fg       = :white,
-    fglegend = _invisible,
-    fgtext   = :gray,
-    fgguide  = :black
-)
-
-function set_theme(sym::Symbol)
-    default(; _themes[sym]...)
 end
@@ -2,30 +2,37 @@
 # 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

-typealias AVec AbstractVector
-typealias AMat AbstractMatrix
-typealias KW Dict{Symbol,Any}
+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}

-immutable PlotsDisplay <: Display end
-
-abstract AbstractBackend
-abstract AbstractPlot{T<:AbstractBackend}
-abstract AbstractLayout
+struct PlotsDisplay <: AbstractDisplay end

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

-immutable InputWrapper{T}
+struct InputWrapper{T}
    obj::T
 end
-wrap{T}(obj::T) = InputWrapper{T}(obj)
+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)
+
 # -----------------------------------------------------------

 # a single subplot
-type Subplot{T<:AbstractBackend} <: AbstractLayout
+mutable struct Subplot{T<:AbstractBackend} <: AbstractLayout
    parent::AbstractLayout
+    series_list::Vector{Series}  # arguments for each series
    minpad::Tuple # leftpad, toppad, rightpad, bottompad
    bbox::BoundingBox  # the canvas area which is available to this subplot
    plotarea::BoundingBox  # the part where the data goes
@@ -34,15 +41,17 @@ type Subplot{T<:AbstractBackend} <: AbstractLayout
    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])}")
+
 # -----------------------------------------------------------

 # simple wrapper around a KW so we can hold all attributes pertaining to the axis in one place
-type Axis
-    sp::Subplot
-    d::KW
+mutable struct Axis
+    sps::Vector{Subplot}
+    plotattributes::KW
 end

-type Extrema
+mutable struct Extrema
    emin::Float64
    emax::Float64
 end
@@ -50,20 +59,12 @@ Extrema() = Extrema(Inf, -Inf)

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

-typealias SubplotMap Dict{Any, Subplot}
+const SubplotMap = Dict{Any, Subplot}

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

-type Series
-    d::KW
-end

-attr(series::Series, k::Symbol) = series.d[k]
-attr!(series::Series, v, k::Symbol) = (series.d[k] = v)
-
-# -----------------------------------------------------------
-
-type Plot{T<:AbstractBackend} <: AbstractPlot{T}
+mutable struct Plot{T<:AbstractBackend} <: AbstractPlot{T}
    backend::T                   # the backend type
    n::Int                       # number of series
    attr::KW                     # arguments for the whole plot
@@ -83,12 +84,21 @@ function Plot()
         Subplot[], false)
 end

-# TODO: make a decision... should plt[1] return the first subplot or the first series??
-# Base.getindex(plt::Plot, i::Integer) = plt.subplots[i]
-Base.getindex(plt::Plot, s::Symbol) = plt.spmap[s]
-Base.getindex(plt::Plot, r::Integer, c::Integer) = plt.layout[r,c]
-attr(plt::Plot, k::Symbol) = plt.attr[k]
-attr!(plt::Plot, v, k::Symbol) = (plt.attr[k] = v)
+# -----------------------------------------------------------------------

+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))

 # -----------------------------------------------------------------------
@@ -0,0 +1 @@
+reference_images
@@ -1,16 +0,0 @@
-julia 0.4
-
-RecipesBase
-Colors
-Reexport
-Measures
-FactCheck
-Images
-PyPlot
-@osx QuartzImageIO
-GR
-DataFrames
-RDatasets
-VisualRegressionTests
-UnicodePlots
-Glob
@@ -1,50 +1,51 @@
+import Plots._current_plots_version

-using VisualRegressionTests
-# using ExamplePlots
-
-import DataFrames, RDatasets
-
-# don't let pyplot use a gui... it'll crash
-# note: Agg will set gui -> :none in PyPlot
-ENV["MPLBACKEND"] = "Agg"
-try
-  @eval import PyPlot
-  info("Matplotlib version: $(PyPlot.matplotlib[:__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()

-using Plots, FactCheck
-using Glob
-
-default(size=(500,300))
-
-
-# TODO: use julia's Condition type and the wait() and notify() functions to initialize a Window, then wait() on a condition that
-#       is referenced in a button press callback (the button clicked callback will call notify() on that condition)
-
-const _current_plots_version = v"0.7.3"
-
-
-function image_comparison_tests(pkg::Symbol, idx::Int; debug = false, popup = isinteractive(), sigma = [1,1], eps = 1e-2)
+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]
-    info("Testing plot: $pkg:$idx:$(example.header)")
+    Plots.theme(:default)
+    @info("Testing plot: $pkg:$idx:$(example.header)")
    backend(pkg)
    backend()
-
+    default(size=(500,300))
    # ensure consistent results
-    srand(1234)
+    Random.seed!(1234)

    # reference image directory setup
-    # refdir = joinpath(Pkg.dir("ExamplePlots"), "test", "refimg", string(pkg))
-    refdir = Pkg.dir("PlotReferenceImages", "Plots", string(pkg))
+    refdir = joinpath(ref_image_dir, "Plots", string(pkg))
    fn = "ref$idx.png"

    # firgure out version info
-    G = glob(relpath(refdir) * "/*")
-    # @show refdir fn G
-    versions = map(fn -> VersionNumber(split(fn,"/")[end]), G)
-    versions = reverse(sort(versions))
+    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

@@ -71,20 +72,22 @@ function image_comparison_tests(pkg::Symbol, idx::Int; debug = false, popup = is

    # test function
    func = (fn, idx) -> begin
-        map(eval, example.exprs)
+        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")
+    # 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, eps=eps, newfn = newfn)
+    test_images(vtest, popup=popup, sigma=sigma, tol=tol, newfn = newfn)
 end

 function image_comparison_facts(pkg::Symbol;
@@ -92,11 +95,11 @@ function image_comparison_facts(pkg::Symbol;
                                only = nothing, # limit to these examples (int index)
                                debug = false,  # print debug information?
                                sigma = [1,1],  # number of pixels to "blur"
-                                eps = 1e-2)     # acceptable error (percent)
+                                tol = 1e-2)     # acceptable error (percent)
  for i in 1:length(Plots._examples)
    i in skip && continue
    if only == nothing || i in only
-      @fact image_comparison_tests(pkg, i, debug=debug, sigma=sigma, eps=eps) |> success --> true
+      @test image_comparison_tests(pkg, i, debug=debug, sigma=sigma, tol=tol) |> success == true
    end
  end
 end
@@ -5,9 +5,11 @@ set -ex
 sudo apt-get -qq update
 # sudo apt-get install -y wkhtmltopdf

-sudo apt-get install -y xfonts-75dpi
-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
+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

@@ -1,91 +1,95 @@
-module PlotsTests
+using VisualRegressionTests
+using Plots
+using Random
+using BinaryProvider
+using Test
+using FileIO
+using GeometryTypes

 include("imgcomp.jl")
-
 # don't actually show the plots
-srand(1234)
+Random.seed!(1234)
 default(show=false, reuse=true)
-img_eps = 5e-2
+img_tol = isinteractive() ? 1e-2 : 10e-2

-# facts("Gadfly") do
-#     @fact gadfly() --> Plots.GadflyBackend()
-#     @fact backend() --> Plots.GadflyBackend()
-#
-#     @fact typeof(plot(1:10)) --> Plots.Plot{Plots.GadflyBackend}
-#     @fact plot(Int[1,2,3], rand(3)) --> not(nothing)
-#     @fact plot(sort(rand(10)), rand(Int, 10, 3)) --> not(nothing)
-#     @fact plot!(rand(10,3), rand(10,3)) --> not(nothing)
-#
-#     image_comparison_facts(:gadfly, skip=[4,6,23,24,27], eps=img_eps)
-# end
+@testset "GR" begin
+    ENV["PLOTS_TEST"] = "true"
+    ENV["GKSwstype"] = "100"
+    @test gr() == Plots.GRBackend()
+    @test backend() == Plots.GRBackend()

-facts("PyPlot") do
-    @fact pyplot() --> Plots.PyPlotBackend()
-    @fact backend() --> Plots.PyPlotBackend()
-
-    image_comparison_facts(:pyplot, skip=[30], eps=img_eps)
-end
-
-facts("GR") do
-    @fact gr() --> Plots.GRBackend()
-    @fact backend() --> Plots.GRBackend()
-
-    # @linux_only image_comparison_facts(:gr, skip=[], eps=img_eps)
-end
-
-facts("Plotly") do
-    @fact plotly() --> Plots.PlotlyBackend()
-    @fact backend() --> Plots.PlotlyBackend()
-
-    # # until png generation is reliable on OSX, just test on linux
-    # @linux_only image_comparison_facts(:plotly, only=[1,3,4,7,8,9,10,11,12,14,15,20,22,23,27], eps=img_eps)
+    @static if Sys.islinux()
+        image_comparison_facts(:gr, tol=img_tol, skip = [25, 30])
+    end
 end


-# facts("Immerse") do
-#     @fact immerse() --> Plots.ImmerseBackend()
-#     @fact backend() --> Plots.ImmerseBackend()
-#
-#     # as long as we can plot anything without error, it should be the same as Gadfly
-#     image_comparison_facts(:immerse, only=[1], eps=img_eps)
-# end
-
-
-# facts("PlotlyJS") do
-#     @fact plotlyjs() --> Plots.PlotlyJSBackend()
-#     @fact backend() --> Plots.PlotlyJSBackend()
-#
-#     # as long as we can plot anything without error, it should be the same as Plotly
-#     image_comparison_facts(:plotlyjs, only=[1], eps=img_eps)
-# end
-
-
-facts("UnicodePlots") do
-    @fact unicodeplots() --> Plots.UnicodePlotsBackend()
-    @fact backend() --> Plots.UnicodePlotsBackend()
+@testset "UnicodePlots" begin
+    @test unicodeplots() == Plots.UnicodePlotsBackend()
+    @test backend() == Plots.UnicodePlotsBackend()

    # lets just make sure it runs without error
-    @fact isa(plot(rand(10)), Plot) --> true
+    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

-
-
-facts("Axes") do
+@testset "Axes" begin
    p = plot()
    axis = p.subplots[1][:xaxis]
-    @fact typeof(axis) --> Axis
-    @fact Plots.discrete_value!(axis, "HI") --> (0.5, 1)
-    @fact Plots.discrete_value!(axis, :yo) --> (1.5, 2)
-    @fact extrema(axis) --> (0.5,1.5)
-    @fact axis[:discrete_map] --> Dict{Any,Any}(:yo  => 2, "HI" => 1)
+    @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])
-    @fact extrema(axis) --> (0.5, 7.5)
+    @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 "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

-FactCheck.exitstatus()
-end # module
+@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
@@ -1,27 +0,0 @@
-# Pkg.clone(pwd())
-# Pkg.build("Plots")
-
-Pkg.clone("ImageMagick")
-Pkg.build("ImageMagick")
-
-Pkg.clone("GR")
-Pkg.build("GR")
-
-# Pkg.clone("https://github.com/JuliaPlots/RecipesBase.jl.git")
-# Pkg.clone("https://github.com/tbreloff/ExamplePlots.jl.git");
-Pkg.clone("https://github.com/JuliaPlots/PlotReferenceImages.jl.git")
-
-# Pkg.clone("https://github.com/JunoLab/Blink.jl.git")
-# Pkg.build("Blink")
-# import Blink
-# Blink.AtomShell.install()
-# Pkg.clone("https://github.com/spencerlyon2/PlotlyJS.jl.git")
-
-Pkg.checkout("RecipesBase")
-Pkg.clone("VisualRegressionTests")
-
-ENV["PYTHON"] = ""
-Pkg.add("PyPlot")
-Pkg.build("PyPlot")
-
-Pkg.test("Plots"; coverage=false)