change version number for testing

Merge pull request #1070 from JuliaPlots/release-0.12.4
Release 0.12.4
2017-09-04 12:18:10 +02:00 · 2017-09-04 12:05:07 +02:00 · 2017-09-04 12:02:34 +02:00 · 2017-09-04 12:02:19 +02:00 · 2017-09-04 11:50:17 +02:00 · 2017-09-03 17:30:17 +02:00
53 changed files with 8366 additions and 3817 deletions
@@ -2,10 +2,9 @@
 language: julia
 os:
  - linux
-  - osx
+  # - osx
 julia:
-  - release
-  - nightly
+  - 0.6
 matrix:
  allow_failures:
    - julia: nightly
@@ -3,11 +3,280 @@

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

- All new development should target 0.7!
+- All new development should target 0.12!
+- 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.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 0.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 StatPlots
+- 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 StatPlots.jl)
+- BREAKING: removed boxplot/violin/density recipes (now in StatPlots.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 +348,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 +426,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 +480,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
@@ -1,6 +1,7 @@
 # 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/tbreloff/plots.jl?branch=master&svg=true)](https://ci.appveyor.com/project/tbreloff/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)
 <!-- [![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) -->
@@ -12,22 +13,11 @@
 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.
+- **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.

-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).
+View the [full documentation](http://juliaplots.github.io).
@@ -1,8 +1,15 @@
-julia 0.4
+julia 0.6

-RecipesBase
-Colors
+RecipesBase 0.2.0
+PlotUtils 0.4.1
+PlotThemes 0.1.3
 Reexport
-Compat
-FixedSizeArrays
+StaticArrays 0.5
+FixedPointNumbers 0.3
 Measures
+Showoff
+StatsBase 0.14.0
+JSON
+NaNMath
+Requires
+Contour
@@ -1,11 +1,15 @@
 environment:
  matrix:
-# Releases
-  - JULIAVERSION: "stable/win32"
-  - JULIAVERSION: "stable/win64"
-# Nightlies
-  - JULIAVERSION: "download/win32"
-  - JULIAVERSION: "download/win64"
+  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x86/0.6/julia-0.6-latest-win32.exe"
+  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x64/0.6/julia-0.6-latest-win64.exe"
+  - JULIA_URL: "https://julialangnightlies-s3.julialang.org/bin/winnt/x86/julia-latest-win32.exe"
+  - JULIA_URL: "https://julialangnightlies-s3.julialang.org/bin/winnt/x64/julia-latest-win64.exe"
+
+matrix:
+  allow_failures:
+  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x86/0.6/julia-0.6-latest-win32.exe" #check and address
+  - JULIA_URL: "https://julialangnightlies-s3.julialang.org/bin/winnt/x86/julia-latest-win32.exe"
+  - JULIA_URL: "https://julialangnightlies-s3.julialang.org/bin/winnt/x64/julia-latest-win64.exe"

 notifications:
  - provider: Email
@@ -14,8 +18,14 @@ notifications:
    on_build_status_changed: false

 install:
+  - ps: "[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.SecurityProtocolType]::Tls12"
+# If there's a newer build queued for the same PR, cancel this one
+  - ps: if ($env:APPVEYOR_PULL_REQUEST_NUMBER -and $env:APPVEYOR_BUILD_NUMBER -ne ((Invoke-RestMethod `
+        https://ci.appveyor.com/api/projects/$env:APPVEYOR_ACCOUNT_NAME/$env:APPVEYOR_PROJECT_SLUG/history?recordsNumber=50).builds | `
+        Where-Object pullRequestId -eq $env:APPVEYOR_PULL_REQUEST_NUMBER)[0].buildNumber) { `
+        throw "There are newer queued builds for this pull request, failing early." }
 # Download most recent Julia Windows binary
-  - ps: (new-object net.webclient).DownloadFile($("http://status.julialang.org/"+$env:JULIAVERSION), "C:\projects\julia-binary.exe")
+  - ps: (new-object net.webclient).DownloadFile($env:JULIA_URL, "C:\projects\julia-binary.exe")
 # Run installer silently, output to C:\projects\julia
  - C:\projects\julia-binary.exe /S /D=C:\projects\julia

@@ -26,4 +36,4 @@ build_script:

 test_script:
  # - C:\projects\julia\bin\julia -e "Pkg.test(\"Plots\")"
-  - C:\projects\julia\bin\julia -e "include(Pkg.dir(\"Plots\", \"test\", \"travis_commands.jl\"))"
+  - C:\projects\julia\bin\julia -e "include(Pkg.dir(\"Plots\", \"test\", \"travis_commands.jl\"))"
@@ -1,45 +1,38 @@
-
-__precompile__()
+__precompile__(false)

 module Plots

-using Compat
 using Reexport
-@reexport using Colors
-# using Requires
-using FixedSizeArrays
+
+import StaticArrays
+using StaticArrays.FixedSizeArrays
+
@reexport using RecipesBase
+import RecipesBase: plot, plot!, animate
 using Base.Meta
-# using PlotUtils
+@reexport using PlotUtils
+@reexport using PlotThemes
+import Showoff
+import StatsBase

 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,56 +52,49 @@ export
    yflip!,
    xaxis!,
    yaxis!,
+    xgrid!,
+    ygrid!,
+
+    xlims,
+    ylims,
+    zlims,

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

    backend,
    backends,
    backend_name,
+    backend_object,
+    add_backend,
    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!,
@@ -118,54 +104,70 @@ export
    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{F<:AbstractFloat}(x::AbstractArray{F}) = NaNMath.minimum(x)
+ignorenan_minimum(x) = Base.minimum(x)
+ignorenan_maximum{F<:AbstractFloat}(x::AbstractArray{F}) = NaNMath.maximum(x)
+ignorenan_maximum(x) = Base.maximum(x)
+ignorenan_mean{F<:AbstractFloat}(x::AbstractArray{F}) = NaNMath.mean(x)
+ignorenan_mean(x) = Base.mean(x)
+ignorenan_extrema{F<:AbstractFloat}(x::AbstractArray{F}) = 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
 import Measures: Length, AbsoluteLength, Measure, BoundingBox, mm, cm, inch, pt, width, height, w, h
-typealias BBox Measures.Absolute2DBox
+const BBox = Measures.Absolute2DBox
 export BBox, BoundingBox, mm, cm, inch, pt, px, pct, w, h

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

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

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

-# 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)
-end
-
@shorthands scatter
@shorthands bar
@shorthands barh
@shorthands histogram
+@shorthands barhist
+@shorthands stephist
+@shorthands scatterhist
@shorthands histogram2d
@shorthands density
@shorthands heatmap
@@ -175,6 +177,7 @@ end
@shorthands vline
@shorthands ohlc
@shorthands contour
+@shorthands contourf
@shorthands contour3d
@shorthands surface
@shorthands wireframe
@@ -185,68 +188,101 @@ end
@shorthands quiver
@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!{T<:Real,S<:Real}(lims::Tuple{T,S}; kw...) = plot!(; xlims = lims, kw...)
+
+"Set ylims for an existing plot"
 ylims!{T<:Real,S<:Real}(lims::Tuple{T,S}; kw...) = plot!(; ylims = lims, kw...)
+
+"Set zlims for an existing plot"
 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...)
+
+
+"Set xticks for an existing plot"
 xticks!{T<:Real}(v::AVec{T}; kw...)                       = plot!(; xticks = v, kw...)
+
+"Set yticks for an existing plot"
 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...)
+
+"Add annotations to an existing plot"
 annotate!(anns...; kw...)                                 = plot!(; annotation = anns, kw...)
 annotate!{T<:Tuple}(anns::AVec{T}; kw...)                 = 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 x 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...)

-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...)
-
+let PlotOrSubplot = Union{Plot, Subplot}
+    title!(plt::PlotOrSubplot, s::AbstractString; kw...)                  = plot!(plt; title = s, kw...)
+    xlabel!(plt::PlotOrSubplot, s::AbstractString; kw...)                 = plot!(plt; xlabel = s, kw...)
+    ylabel!(plt::PlotOrSubplot, s::AbstractString; kw...)                 = plot!(plt; ylabel = s, kw...)
+    xlims!{T<:Real,S<:Real}(plt::PlotOrSubplot, lims::Tuple{T,S}; kw...)  = plot!(plt; xlims = lims, kw...)
+    ylims!{T<:Real,S<:Real}(plt::PlotOrSubplot, lims::Tuple{T,S}; kw...)  = plot!(plt; ylims = lims, kw...)
+    zlims!{T<:Real,S<:Real}(plt::PlotOrSubplot, lims::Tuple{T,S}; kw...)  = plot!(plt; zlims = lims, kw...)
+    xlims!(plt::PlotOrSubplot, xmin::Real, xmax::Real; kw...)             = plot!(plt; xlims = (xmin,xmax), kw...)
+    ylims!(plt::PlotOrSubplot, ymin::Real, ymax::Real; kw...)             = plot!(plt; ylims = (ymin,ymax), kw...)
+    zlims!(plt::PlotOrSubplot, zmin::Real, zmax::Real; kw...)             = plot!(plt; zlims = (zmin,zmax), kw...)
+    xticks!{T<:Real}(plt::PlotOrSubplot, ticks::AVec{T}; kw...)           = plot!(plt; xticks = ticks, kw...)
+    yticks!{T<:Real}(plt::PlotOrSubplot, ticks::AVec{T}; kw...)           = plot!(plt; yticks = ticks, kw...)
+    xticks!{T<:Real,S<:AbstractString}(plt::PlotOrSubplot,
+                              ticks::AVec{T}, labels::AVec{S}; kw...)     = plot!(plt; xticks = (ticks,labels), kw...)
+    yticks!{T<:Real,S<:AbstractString}(plt::PlotOrSubplot,
+                              ticks::AVec{T}, labels::AVec{S}; kw...)     = plot!(plt; yticks = (ticks,labels), kw...)
+    xgrid!(plt::PlotOrSubplot, args...; kw...)                  = plot!(plt; xgrid = args, kw...)
+    ygrid!(plt::PlotOrSubplot, args...; kw...)                  = plot!(plt; ygrid = args, kw...)
+    annotate!(plt::PlotOrSubplot, anns...; kw...)                         = plot!(plt; annotation = anns, kw...)
+    annotate!{T<:Tuple}(plt::PlotOrSubplot, anns::AVec{T}; kw...)         = plot!(plt; annotation = anns, kw...)
+    xflip!(plt::PlotOrSubplot, flip::Bool = true; kw...)                  = plot!(plt; xflip = flip, kw...)
+    yflip!(plt::PlotOrSubplot, flip::Bool = true; kw...)                  = plot!(plt; yflip = flip, kw...)
+    xaxis!(plt::PlotOrSubplot, args...; kw...)                            = plot!(plt; xaxis = args, kw...)
+    yaxis!(plt::PlotOrSubplot, args...; kw...)                            = plot!(plt; yaxis = args, kw...)
+end


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

 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"]))
+# for compatibility with Requires.jl:
+@init begin
+    if isdefined(Main, :PLOTS_DEFAULTS)
+        for (k,v) in Main.PLOTS_DEFAULTS
            default(k, v)
        end
    end
@@ -254,11 +290,4 @@ end

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

-# if VERSION >= v"0.4.0-dev+5512"
-#     include("precompile.jl")
-#     _precompile_()
-# end
-
-# ---------------------------------------------------------
-
 end # module
@@ -1,62 +1,115 @@
-
+"Represents an animation object"
 immutable Animation
-  dir::Compat.ASCIIString
-  frames::Vector{Compat.ASCIIString}
+    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

+"""
+    frame(animation[, plot])
+
+Add a plot (the current plot if not specified) to an existing animation
+"""
 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)
+    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")
+
+type 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
+    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; kw...)
+mp4(anim::Animation, fn = mp4fn(); kw...) = buildanimation(anim.dir, fn; 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)
+const _imagemagick_initialized = Ref(false)
+
+function buildanimation(animdir::AbstractString, fn::AbstractString;
+                        fps::Integer = 20, loop::Integer = 0)
+    fn = abspath(fn)
+    try
+        if !_imagemagick_initialized[]
+            file = joinpath(Pkg.dir("ImageMagick"), "deps","deps.jl")
+            if isfile(file) && !haskey(ENV, "MAGICK_CONFIGURE_PATH")
+                include(file)
+            end
+            _imagemagick_initialized[] = true
+        end
+
+        # prefix = get(ENV, "MAGICK_CONFIGURE_PATH", "")
+        # high quality
+        speed = round(Int, 100 / fps)
+        run(`convert -delay $speed -loop $loop $(joinpath(animdir, "*.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")`.
+            You may also need to install the imagemagick c++ library through your operating system.
+            Will try ffmpeg, but it's lower quality...)""")
+
+        # low quality
+        run(`ffmpeg -v 0 -framerate $fps -loop $loop -i $(animdir)/%06d.png -y $fn`)
+        # run(`ffmpeg -v warning -i  "fps=$fps,scale=320:-1:flags=lanczos"`)
    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)
+    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())>\" />")
+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))?$(rand())>\" />"
+    elseif ext in ("mov", "mp4")
+        "<video controls><source src=\"$(relpath(agif.filename))?$(rand())>\" type=\"video/$ext\"></video>"
+    else
+        error("Cannot show animation with extension $ext: $agif")
+    end)
 end


@@ -122,7 +175,7 @@ Example:
 ```
 """
 macro gif(forloop::Expr, args...)
-  _animate(forloop, args...; callgif = true)
+    _animate(forloop, args...; callgif = true)
 end

 """
@@ -131,13 +184,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
@@ -19,9 +19,9 @@ 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. `linspace(extrema(x)..., 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",
@@ -29,6 +29,7 @@ const _arg_desc = KW(
 :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).",
+: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}. 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)",
@@ -39,7 +40,7 @@ const _arg_desc = KW(
 :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.",
 :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`.",
@@ -63,6 +64,8 @@ const _arg_desc = KW(
 :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",
+: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.",

 # subplot args
 :title                    => "String. Subplot title.",
@@ -73,23 +76,24 @@ const _arg_desc = KW(
 :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)",
+:legendtitle              => "String or nothing (default). Sets the legend title.",
 :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 `apect_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)",

 # axis args
 :guide     				  => "String. Axis guide (label).",
@@ -98,11 +102,17 @@ const _arg_desc = KW(
 :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, or :auto. A method which converts a number to a string for tick labeling.",
 :tickfont  				  => "Font. Font of axis tick labels.",
 :guidefont 				  => "Font. Font of axis guide (label).",
 :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? `: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)",
 )
@@ -23,13 +23,13 @@ function Axis(sp::Subplot, letter::Symbol, args...; kw...)
        lk = Symbol(letter, k)
        lv = _axis_defaults_byletter[lk]
        d[k] = (lv == :match ? v : lv)
-    end     
+    end

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

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

 function get_axis(sp::Subplot, letter::Symbol)
@@ -38,7 +38,7 @@ 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 = "")
@@ -73,6 +73,9 @@ function process_axis_arg!(d::KW, arg, letter = "")
    elseif typeof(arg) <: Number
        d[Symbol(letter,:rotation)] = arg

+    elseif typeof(arg) <: Function
+        d[Symbol(letter,:formatter)] = arg
+
    else
        warn("Skipped $(letter)axis arg $arg")

@@ -80,7 +83,7 @@ function process_axis_arg!(d::KW, arg, letter = "")
 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
    for arg in args
@@ -115,34 +118,182 @@ 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))
+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
+
+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(axis::Axis, ticks = nothing)
+    amin,amax = axis_limits(axis)
+
+    # 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, :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)
+        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(axis::Axis)
+    ticks = _transform_ticks(axis[:ticks])
+    ticks in (nothing, false) && return nothing
+
+    dvals = axis[:discrete_values]
+    cv, dv = if !isempty(dvals) && ticks == :auto
+        # discrete ticks...
+        axis[:continuous_values], dvals
+    elseif ticks == :auto
+        # compute optimal ticks and labels
+        optimal_ticks_and_labels(axis)
+    elseif typeof(ticks) <: Union{AVec, Int}
+        # override ticks, but get the labels
+        optimal_ticks_and_labels(axis, ticks)
+    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
+
+    # TODO: better/smarter cutoff values for sampling ticks
+    if length(cv) > 30 && ticks == :auto
+        rng = Int[round(Int,i) for i in linspace(1, length(cv), 15)]
+        cv[rng], dv[rng]
+    else
+        cv, dv
    end
 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 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.d)
+    end
+end
+
+
 function expand_extrema!(ex::Extrema, v::Number)
-    ex.emin = min(v, ex.emin)
-    ex.emax = max(v, ex.emax)
+    ex.emin = NaNMath.min(v, ex.emin)
+    ex.emax = NaNMath.max(v, ex.emax)
    ex
 end

 function expand_extrema!(axis::Axis, v::Number)
    expand_extrema!(axis[:extrema], v)
 end
+
+# these shouldn't impact the extrema
+expand_extrema!(axis::Axis, ::Void) = axis[:extrema]
+expand_extrema!(axis::Axis, ::Bool) = axis[:extrema]
+
+
 function expand_extrema!{MIN<:Number,MAX<:Number}(axis::Axis, v::Tuple{MIN,MAX})
    ex = axis[:extrema]
-    ex.emin = min(v[1], ex.emin)
-    ex.emax = max(v[2], ex.emax)
+    ex.emin = NaNMath.min(v[1], ex.emin)
+    ex.emax = NaNMath.max(v[2], ex.emax)
    ex
 end
 function expand_extrema!{N<:Number}(axis::Axis, v::AVec{N})
@@ -155,20 +306,33 @@ end


 function expand_extrema!(sp::Subplot, d::KW)
+    vert = isvertical(d)
+
    # 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 = d[if vert
+            letter
+        else
+            letter == :x ? :y : letter == :y ? :x : :z
+        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 = d[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)
+            expand_extrema!(axis, d[letter])
        end
    end

@@ -179,7 +343,6 @@ function expand_extrema!(sp::Subplot, d::KW)
    # end

    # expand for fillrange
-    vert = isvertical(d)
    fr = d[:fillrange]
    if fr == nothing && d[:seriestype] == :bar
        fr = 0.0
@@ -202,13 +365,11 @@ function expand_extrema!(sp::Subplot, d::KW)

        bw = d[:bar_width]
        if bw == nothing
-            bw = d[:bar_width] = mean(diff(data))
+            bw = d[:bar_width] = _bar_width * ignorenan_mean(diff(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

 end
@@ -223,8 +384,8 @@ 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)
+    # eps = NaNMath.max(1e-16, min(1e-2span, 1e-10))
+    eps = NaNMath.max(1e-16, 0.03span)
    lmin-eps, lmax+eps
 end

@@ -232,10 +393,12 @@ end
 # so lazy out and don't widen
 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 axis[:scale] == :identity && !is_2tuple(axis[:lims])
+        for sp in axis.sps
+            for series in series_list(sp)
+                if series.d[:seriestype] in (:scatter,) || series.d[:markershape] != :none
+                    should_widen = true
+                end
            end
        end
    end
@@ -258,6 +421,9 @@ function axis_limits(axis::Axis, should_widen::Bool = default_should_widen(axis)
    if amax <= amin && isfinite(amin)
        amax = amin + 1.0
    end
+    if !isfinite(amin) && !isfinite(amax)
+        amin, amax = 0.0, 1.0
+    end
    if should_widen
        widen(amin, amax)
    else
@@ -275,7 +441,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)
@@ -330,3 +496,56 @@ function pie_labels(sp::Subplot, series::Series)
        d[: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(xaxis)
+    ymin, ymax = axis_limits(yaxis)
+    xticks = get_ticks(xaxis)
+    yticks = get_ticks(yaxis)
+    xaxis_segs = Segments(2)
+    yaxis_segs = Segments(2)
+    xgrid_segs = Segments(2)
+    ygrid_segs = Segments(2)
+    xborder_segs = Segments(2)
+    yborder_segs = Segments(2)
+
+    if !(sp[:framestyle] == :none)
+        # xaxis
+        sp[:framestyle] == :grid || push!(xaxis_segs, (xmin,ymin), (xmax,ymin)) # bottom spine / xaxis
+        sp[:framestyle] in (:semi, :box) && push!(xborder_segs, (xmin,ymax), (xmax,ymax)) # top spine
+        if !(xaxis[:ticks] in (nothing, false))
+            f = scalefunc(yaxis[:scale])
+            invf = invscalefunc(yaxis[:scale])
+            t1 = invf(f(ymin) + 0.015*(f(ymax)-f(ymin)))
+            t2 = invf(f(ymax) - 0.015*(f(ymax)-f(ymin)))
+
+            for xtick in xticks[1]
+                push!(xaxis_segs, (xtick, ymin), (xtick, t1)) # bottom tick
+                # sp[:draw_axes_border] && push!(xaxis_segs, (xtick, ymax), (xtick, t2)) # top tick
+                xaxis[:grid] && push!(xgrid_segs,  (xtick, t1),   (xtick, t2)) # vertical grid
+            end
+        end
+
+        # yaxis
+        sp[:framestyle] == :grid || push!(yaxis_segs, (xmin,ymin), (xmin,ymax)) # left spine / yaxis
+        sp[:framestyle] in (:semi, :box) && push!(yborder_segs, (xmax,ymin), (xmax,ymax)) # right spine
+        if !(yaxis[:ticks] in (nothing, false))
+            f = scalefunc(xaxis[:scale])
+            invf = invscalefunc(xaxis[:scale])
+            t1 = invf(f(xmin) + 0.015*(f(xmax)-f(xmin)))
+            t2 = invf(f(xmax) - 0.015*(f(xmax)-f(xmin)))
+
+            for ytick in yticks[1]
+                push!(yaxis_segs, (xmin, ytick), (t1, ytick)) # left tick
+                # sp[:draw_axes_border] && push!(yaxis_segs, (xmax, ytick), (t2, ytick)) # right tick
+                yaxis[:grid] && push!(ygrid_segs,  (t1, ytick),   (t2, ytick)) # horizontal grid
+            end
+        end
+    end
+
+    xticks, yticks, xaxis_segs, yaxis_segs, xgrid_segs, ygrid_segs, xborder_segs, yborder_segs
+end
@@ -6,7 +6,10 @@ const _backendSymbol = Dict{DataType, Symbol}(NoBackend => :none)
 const _backends = Symbol[]
 const _initialized_backends = Set{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")

@@ -26,24 +29,18 @@ macro init_backend(s)
    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/supported.jl")

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

+function add_backend(pkg::Symbol)
+    info("To do a standard install of $pkg, copy and run this:\n\n")
+    println(add_backend_string(_backend_instance(pkg)))
+    println()
+end
+add_backend_string(b::AbstractBackend) = warn("No custom install defined for $(backend_name(b))")
+
 # don't do anything as a default
 _create_backend_figure(plt::Plot) = nothing
 _prepare_plot_object(plt::Plot) = nothing
@@ -57,13 +54,66 @@ _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

+"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(axis::Axis)
+    ticks = get_ticks(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[:tickfont].pointsize, 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[:yaxis]) + sp[:left_margin]   + guide_padding(sp[:yaxis])
+    toppad    = sp[:top_margin]    + title_padding(sp)
+    rightpad  = sp[:right_margin]
+    bottompad = tick_padding(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
@@ -101,7 +151,7 @@ function pickDefaultBackend()
    # 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")
+    for pkgstr in ("GR", "PyPlot", "PlotlyJS", "PGFPlots", "UnicodePlots", "InspectDR", "GLVisualize")
        if Pkg.installed(pkgstr) != nothing
            return backend(Symbol(lowercase(pkgstr)))
        end
@@ -127,14 +177,15 @@ function backend()
  sym = CURRENT_BACKEND.sym
  if !(sym in _initialized_backends)

-    # initialize
-    println("[Plots.jl] Initializing backend: ", sym)
+    # # 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?)")
+      add_backend(sym)
      rethrow(err)
    end

@@ -151,12 +202,14 @@ function backend(pkg::AbstractBackend)
    CURRENT_BACKEND.sym = backend_name(pkg)
    warn_on_deprecated_backend(CURRENT_BACKEND.sym)
    CURRENT_BACKEND.pkg = pkg
+    backend()
 end

 function backend(modname::Symbol)
    warn_on_deprecated_backend(modname)
    CURRENT_BACKEND.sym = modname
    CURRENT_BACKEND.pkg = _backend_instance(modname)
+    backend()
 end

 const _deprecated_backends = [:qwt, :winston, :bokeh, :gadfly, :immerse]
@@ -167,23 +220,7 @@ function warn_on_deprecated_backend(bsym::Symbol)
    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 +250,7 @@ const _base_supported_args = [
    :subplot_index,
    :discrete_values,
    :projection,
-    
+
 ]

 function merge_with_base_supported(v::AVec)
@@ -225,5 +262,49 @@ function merge_with_base_supported(v::AVec)
            end
        end
    end
-    v
+    Set(v)
 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
+@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())
@@ -0,0 +1,655 @@
+#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
+    - SeriesAnnotations & GridLayout known to be missing.
+ 3. Improve error handling.
+    - Will likely crash if file format is off.
+ 2. Save data in a folder parallel to "plot".
+    - Will make it easier for users to locate data.
+    - Use HDF5 reference to link data?
+ 3. Develop an actual versioned file format.
+    - Should have some form of backward compatibility.
+    - Should be reliable for archival purposes.
+==#
+
+
+import FixedPointNumbers: N0f8 #In core Julia
+
+#Dispatch types:
+immutable HDF5PlotNative; end #Indentifies a data element that can natively be handled by HDF5
+immutable HDF5CTuple; end #Identifies a "complex" tuple structure
+
+type HDF5Plot_PlotRef
+	ref::Union{Plot, Void}
+end
+
+
+#==Useful constants
+===============================================================================#
+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
+}
+
+
+#==
+===============================================================================#
+
+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,
+        :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]
+is_marker_supported(::HDF5Backend, shape::Shape) = true
+
+function add_backend_string(::HDF5Backend)
+    """
+    if !Plots.is_installed("HDF5")
+        Pkg.add("HDF5")
+    end
+    """
+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].d, v.d)
+        else
+            dest[k] = v
+        end    
+    end
+    return
+end
+
+
+#==
+===============================================================================#
+
+function _initialize_backend(::HDF5Backend)
+    @eval begin
+        import HDF5
+        export HDF5
+        if length(HDF5PLOT_MAP_TELEM2STR) < 1
+            #Possible element types of high-level data types:
+            const telem2str = Dict{String, Type}(
+                "NATIVE" => HDF5PlotNative,
+                "VOID" => Void,
+                "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,
+                "COLORGRADIENT" => ColorGradient,
+                "AXIS" => Axis,
+                "SUBPLOT" => Subplot,
+                "NULLABLE" => Nullable,
+            )
+            merge!(HDF5PLOT_MAP_STR2TELEM, telem2str)
+            merge!(HDF5PLOT_MAP_TELEM2STR, Dict{Type, String}(v=>k for (k,v) in HDF5PLOT_MAP_STR2TELEM))
+        end
+    end
+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 (d[:annotations])
+function _update_plot_object(plt::Plot{HDF5Backend})
+    #Do nothing
+end
+
+# ----------------------------------------------------------------
+
+_show(io::IO, mime::MIME"text/plain", plt::Plot{HDF5Backend}) = nothing #Don't show
+
+# ----------------------------------------------------------------
+
+# 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{T<:Any}(grp, ::Type{Array{T}})
+    tstr = HDF5PLOT_MAP_TELEM2STR[Array] #ANY
+    HDF5.a_write(grp, _hdf5plot_datatypeid, tstr)
+end
+function _hdf5plot_writetype{T<:BoundingBox}(grp, ::Type{T})
+    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(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
+    grp[k] = v
+    _hdf5plot_writetype(grp, k, HDF5PlotNative)
+end
+function _hdf5plot_gwrite{T<:Number}(grp, k::String, v::Array{T}) #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::Void)
+    grp[k] = 0
+    _hdf5plot_writetype(grp, k, Void)
+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, d::Dict)
+#    warn("Cannot write dict: $k=$d")
+end
+function _hdf5plot_gwrite(grp, k::String, v::Range)
+    _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{T}(grp, k::String, v::Array{T})
+    if "annotations" == k;
+        return #Hack.  Does not yet support annotations.
+    end
+
+    vgrp = HDF5.g_create(grp, k)
+    _hdf5plot_writetype(vgrp, Array) #ANY
+    sz = size(v)
+
+    for iter in eachindex(v)
+        coord = ind2sub(sz, iter)
+        elem = v[iter]
+        idxstr = join(coord, "_")
+        _hdf5plot_gwrite(vgrp, "v$idxstr", v[iter])
+    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{T}(grp, k::String, v::Length{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.d
+        kstr = string(_k)
+        _hdf5plot_gwrite(grp, kstr, _v)
+    end
+    _hdf5plot_writetype(grp, Axis)
+    return
+end
+#TODO: "Properly" support Nullable using _hdf5plot_writetype?
+function _hdf5plot_gwrite(grp, k::String, v::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::SeriesAnnotations)
+    #Currently no support for SeriesAnnotations
+    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, d::Dict)
+    for (k, v) in d
+        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.d)
+    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{Void}, 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}(sz)
+
+    for iter in eachindex(result)
+        coord = ind2sub(sz, 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{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{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 d:
+function _hdf5plot_read(grp, d::Dict)
+    gnames = names(grp)
+    for k in gnames
+        try
+            v = _hdf5plot_read(grp, k)
+            d[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/attr"))
+    kwlist = KW()
+    _hdf5plot_read(grp, kwlist)
+    _hdf5_merge!(sp.attr, kwlist)
+
+    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].d, kwlist)
+    end
+
+    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
@@ -0,0 +1,532 @@
+
+# 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,
+=#
+
+# ---------------------------------------------------------------------------
+#TODO: remove features
+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,
+    :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, :titlefont,
+    :window_title,
+    :guide, :lims, :scale, #:ticks, :flip, :rotation,
+    :tickfont, :guidefont, :legendfont,
+    :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 #, :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]
+
+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
+
+# ---------------------------------------------------------------------------
+
+function add_backend_string(::InspectDRBackend)
+    """
+    if !Plots.is_installed("InspectDR")
+        Pkg.add("InspectDR")
+    end
+    """
+end
+
+function _initialize_backend(::InspectDRBackend; kw...)
+    @eval begin
+        import InspectDR
+        export InspectDR
+
+        #Glyph used when plotting "Shape"s:
+        const INSPECTDR_GLYPH_SHAPE = InspectDR.GlyphPolyline(
+            2*InspectDR.GLYPH_SQUARE.x, InspectDR.GLYPH_SQUARE.y
+        )
+
+        type InspecDRPlotRef
+            mplot::Union{Void, InspectDR.Multiplot}
+            gui::Union{Void, 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)
+    end
+end
+
+# ---------------------------------------------------------------------------
+
+# 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 = _vectorize(series[:x]); y = _vectorize(series[:y])
+
+    #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,)
+        nmax = 0
+        for (i,rng) in enumerate(iter_segments(x, y))
+            nmax = i
+            if length(rng) > 1
+                linewidth = series[:linewidth]
+                linecolor = _inspectdr_mapcolor(_cycle(series[:linecolor], i))
+                fillcolor = _inspectdr_mapcolor(_cycle(series[:fillcolor], 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]
+            linecolor = _inspectdr_mapcolor(_cycle(series[:linecolor], i))
+            fillcolor = _inspectdr_mapcolor(_cycle(series[:fillcolor], 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) #, :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 = series[:linecolor],
+        )
+        #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(series[:markerstrokecolor]),
+            fillcolor = _inspectdr_mapcolor(series[:markercolor]),
+        )
+    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})
+    const plot = sp.o
+    const 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(xaxis)
+        ymin, ymax  = axis_limits(yaxis)
+        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[:titlefont].family,
+            _inspectdr_mapptsize(sp[:titlefont].pointsize),
+            color = _inspectdr_mapcolor(sp[:foreground_color_title])
+        )
+        #Cannot independently control fonts of axes with InspectDR:
+        l[:font_axislabel] = InspectDR.Font(xaxis[:guidefont].family,
+            _inspectdr_mapptsize(xaxis[:guidefont].pointsize),
+            color = _inspectdr_mapcolor(xaxis[:foreground_color_guide])
+        )
+        l[:font_ticklabel] = InspectDR.Font(xaxis[:tickfont].family,
+            _inspectdr_mapptsize(xaxis[:tickfont].pointsize),
+            color = _inspectdr_mapcolor(xaxis[:foreground_color_text])
+        )
+        l[:enable_legend] = (sp[:legend] != :none)
+        #l[:halloc_legend] = 150 #TODO: compute???
+        l[:font_legend] = InspectDR.Font(sp[:legendfont].family,
+            _inspectdr_mapptsize(sp[:legendfont].pointsize),
+            color = _inspectdr_mapcolor(sp[:foreground_color_legend])
+        )
+        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})
+    const 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 (d[: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, ::Void, 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
+_show(io::IO, mime::MIME"text/plain", plt::Plot{InspectDRBackend}) = nothing #Don't show
+
+# ----------------------------------------------------------------
+
+# 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,8 +2,8 @@

 # significant contributions by: @pkofod

-supported_args(::PGFPlotsBackend) = merge_with_base_supported([
-    # :annotations,
+const _pgfplots_attr = merge_with_base_supported([
+    :annotations,
    # :background_color_legend,
    :background_color_inside,
    # :background_color_outside,
@@ -22,25 +22,30 @@ supported_args(::PGFPlotsBackend) = merge_with_base_supported([
    :guide, :lims, :ticks, :scale, :flip, :rotation,
    :tickfont, :guidefont, :legendfont,
    :grid, :legend,
-    # :colorbar,
-    # :marker_z, :levels,
+    :colorbar,
+    :marker_z, #:levels,
    # :ribbon, :quiver, :arrow,
    # :orientation,
    # :overwrite_figure,
-    # :polar,
+    :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
+const _pgfplots_seriestype = [:path, :path3d, :scatter, :steppre, :stepmid, :steppost, :histogram2d, :ysticks, :xsticks, :contour, :shape]
+const _pgfplots_style = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
+const _pgfplots_marker = [:none, :auto, :circle, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5, :pentagon] #vcat(_allMarkers, Shape)
+const _pgfplots_scale = [:identity, :ln, :log2, :log10]


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

+function add_backend_string(::PGFPlotsBackend)
+    """
+    Pkg.add("PGFPlots")
+    Pkg.build("PGFPlots")
+    """
+end

 function _initialize_backend(::PGFPlotsBackend; kw...)
    @eval begin
@@ -64,6 +69,8 @@ const _pgfplots_markers = KW(
    :none => "none",
    :cross => "+",
    :xcross => "x",
+    :+ => "+",
+    :x => "x",
    :utriangle => "triangle*",
    :dtriangle => "triangle*",
    :circle => "*",
@@ -91,23 +98,42 @@ 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"
+)
+
 # --------------------------------------------------------------------------------------

 # 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_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

 function pgf_fillstyle(d::KW)
-    cstr,a = pgf_color(d[:fillcolor], d[:fillalpha])
+    cstr,a = pgf_color(d[:fillcolor])
    "fill = $cstr, fill opacity=$a"
 end

 function pgf_linestyle(d::KW)
-    cstr,a = pgf_color(d[:linecolor], d[:linealpha])
+    cstr,a = pgf_color(d[:linecolor])
    """
    color = $cstr,
    draw opacity=$a,
@@ -117,8 +143,8 @@ 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])
+    cstr, a = pgf_color(d[:markercolor])
+    cstr_stroke, a_stroke = pgf_color(d[:markerstrokecolor])
    """
    mark = $(get(_pgfplots_markers, shape, "*")),
    mark size = $(0.5 * d[:markersize]),
@@ -131,6 +157,19 @@ function pgf_marker(d::KW)
    }"""
 end

+function pgf_add_annotation!(o,x,y,val)
+    # 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)
+                                 """))
+end
+
 # --------------------------------------------------------------------------------------

 function pgf_series(sp::Subplot, series::Series)
@@ -138,17 +177,18 @@ function pgf_series(sp::Subplot, series::Series)
    st = d[:seriestype]
    style = []
    kw = KW()
-
    push!(style, pgf_linestyle(d))
    push!(style, pgf_marker(d))

-    if d[:fillrange] != nothing
+    if d[:fillrange] != nothing || st in (:shape,)
        push!(style, pgf_fillstyle(d))
    end

    # add to legend?
    if sp[:legend] != :none && should_add_to_legend(series)
        kw[:legendentry] = d[:label]
+    else
+        push!(style, "forget plot")
    end

    # function args
@@ -156,6 +196,10 @@ function pgf_series(sp::Subplot, series::Series)
        d[:z].surf, d[:x], d[:y]
    elseif is3d(st)
        d[:x], d[:y], d[:z]
+    elseif d[:marker_z] != nothing
+        # If a marker_z is used pass it as third coordinate to a 2D plot.
+        # See "Scatter Plots" in PGFPlots documentation
+        d[:x], d[:y], d[:marker_z]
    else
        d[:x], d[:y]
    end
@@ -204,6 +248,9 @@ function pgf_axis(sp::Subplot, letter)
    # axis guide
    kw[Symbol(letter,:label)] = axis[:guide]

+    # Add ticklabel rotations
+    push!(style, "$(letter)ticklabel style={rotate = $(axis[:rotation])}")
+
    # flip/reverse?
    axis[:flip] && push!(style, "$letter dir=reverse")

@@ -214,6 +261,16 @@ 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)
+        push!(style, "$(letter)majorticks=false")
+    end
+
+    # grid on or off
+    if axis[:grid]
+        push!(style, "$(letter)majorgrids = true")
+    end
+
    # limits
    # TODO: support zlims
    if letter != :z
@@ -222,6 +279,12 @@ function pgf_axis(sp::Subplot, letter)
        kw[Symbol(letter,:max)] = lims[2]
    end

+    if !(axis[:ticks] in (nothing, false, :none, :auto))
+        ticks = get_ticks(axis)
+        push!(style, string(letter, "tick = {", join(ticks[1],","), "}"))
+        push!(style, string(letter, "ticklabels = {", join(ticks[2],","), "}"))
+    end
+
    # return the style list and KW args
    style, kw
 end
@@ -229,10 +292,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 +307,28 @@ 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,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])"
        end

-        sp[:grid] && push!(style, "grid = major")
        if sp[:aspect_ratio] in (1, :equal)
            kw[:axisEqual] = "true"
        end
@@ -269,27 +338,67 @@ function _make_pgf_plot!(plt::Plot)
            kw[:legendPos] = _pgfplots_legend_pos[legpos]
        end

-        o = PGFPlots.Axis(; style = style, kw...)
+        axisf = PGFPlots.Axis
+        if sp[:projection] == :polar
+            axisf = PGFPlots.PolarAxis
+        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)
+                if typeof(series.d[col]) == ColorGradient
+                    push!(style,"colormap={plots}{$(pgf_colormap(series.d[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
+
+        o = axisf(; style = style, kw...)

        # add the series object to the PGFPlots.Axis
        for series in series_list(sp)
            push!(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))
+            end
        end

+        # add the annotations
+        for ann in sp[:annotations]
+            pgf_add_annotation!(o,ann...)
+        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 +407,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, readstring(open(fn)))

    # 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=false)
+    write(io, readstring(open(fn)))
+end
+
 function _display(plt::Plot{PGFPlotsBackend})
    # prepare the object
-    _make_pgf_plot!(plt)
    pgfplt = PGFPlots.plot(plt.o)

    # save an svg
@@ -1,11 +1,11 @@

 # https://plot.ly/javascript/getting-started

-supported_args(::PlotlyBackend) = merge_with_base_supported([
+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_grid, :foreground_color_axis,
    :foreground_color_text, :foreground_color_border,
    :foreground_color_title,
    :label,
@@ -19,41 +19,53 @@ supported_args(::PlotlyBackend) = merge_with_base_supported([
    :window_title,
    :guide, :lims, :ticks, :scale, :flip, :rotation,
    :tickfont, :guidefont, :legendfont,
-    :grid, :legend, :colorbar,
-    :marker_z, :levels,
+    :grid, :gridalpha, :gridlinewidth,
+    :legend, :colorbar, :colorbar_title,
+    :marker_z, :fill_z, :levels,
    :ribbon, :quiver,
    :orientation,
    # :overwrite_figure,
    :polar,
    :normalize, :weights,
-    # :contours, :aspect_ratio,
+    # :contours,
+    :aspect_ratio,
    :hover,
    :inset_subplots,
+    :bar_width,
+    :clims,
  ])

-supported_types(::PlotlyBackend) = [
+const _plotly_seriestype = [
    :path, :scatter, :bar, :pie, :heatmap,
-    :contour, :surface, :path3d, :scatter3d, :shape, :scattergl,
+    :contour, :surface, :wireframe, :path3d, :scatter3d, :shape, :scattergl,
 ]
-supported_styles(::PlotlyBackend) = [:auto, :solid, :dash, :dot, :dashdot]
-supported_markers(::PlotlyBackend) = [
+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
 ]
-supported_scales(::PlotlyBackend) = [:identity, :log10]
+const _plotly_scale = [:identity, :log10]
 is_subplot_supported(::PlotlyBackend) = true
-is_string_supported(::PlotlyBackend) = true
+# is_string_supported(::PlotlyBackend) = true


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

+function add_backend_string(::PlotlyBackend)
+    """
+    Pkg.build("Plots")
+    """
+end
+
+
+const _plotly_js_path = joinpath(dirname(@__FILE__), "..", "..", "deps", "plotly-latest.min.js")
+const _plotly_js_path_remote = "https://cdn.plot.ly/plotly-latest.min.js"
+
 function _initialize_backend(::PlotlyBackend; kw...)
  @eval begin
    import JSON
-    JSON._print(io::IO, state::JSON.State, dt::Union{Date,DateTime}) = print(io, '"', dt, '"')

-    _js_path = Pkg.dir("Plots", "deps", "plotly-latest.min.js")
-    _js_code = open(@compat(readstring), _js_path, "r")
+    _js_code = open(readstring, _plotly_js_path, "r")

    # borrowed from https://github.com/plotly/plotly.py/blob/2594076e29584ede2d09f2aa40a8a195b3f3fc66/plotly/offline/offline.py#L64-L71 c/o @spencerlyon2
    _js_script = """
@@ -84,14 +96,29 @@ end

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

+const _plotly_legend_pos = KW(
+    :right => [1., 0.5],
+    :left => [0., 0.5],
+    :top => [0.5, 1.],
+    :bottom => [0.5, 0.],
+    :bottomleft => [0., 0.],
+    :bottomright => [1., 0.],
+    :topright => [1., 1.],
+    :topleft => [0., 1.]
+    )
+
+plotly_legend_pos(pos::Symbol) = get(_plotly_legend_pos, pos, [1.,1.])
+plotly_legend_pos{S<:Real, T<:Real}(v::Tuple{S,T}) = v
+
 function plotly_font(font::Font, color = font.color)
    KW(
        :family => font.family,
        :size   => round(Int, font.pointsize*1.4),
-        :color  => webcolor(color),
+        :color  => rgba_string(color),
    )
 end

+
 function plotly_annotation_dict(x, y, val; xref="paper", yref="paper")
    KW(
        :text => val,
@@ -108,7 +135,7 @@ function plotly_annotation_dict(x, y, ptxt::PlotText; xref="paper", yref="paper"
        :font => plotly_font(ptxt.font),
        :xanchor => ptxt.font.halign == :hcenter ? :center : ptxt.font.halign,
        :yanchor => ptxt.font.valign == :vcenter ? :middle : ptxt.font.valign,
-        :rotation => ptxt.font.rotation,
+        :rotation => -ptxt.font.rotation,
    ))
 end

@@ -126,7 +153,7 @@ end
 #         # :ay => -40,
 #         :ax => 10xdiff / dist,
 #         :ay => -10ydiff / dist,
-#         :arrowcolor => webcolor(d[:linecolor], d[:linealpha]),
+#         :arrowcolor => rgba_string(d[:linecolor]),
 #         :xref => "x",
 #         :yref => "y",
 #         :arrowsize => 10a.headwidth,
@@ -143,11 +170,41 @@ function plotly_scale(scale::Symbol)
    end
 end

+function shrink_by(lo, sz, ratio)
+    amt = 0.5 * (1.0 - ratio) * sz
+    lo + amt, sz - 2amt
+end
+
+function plotly_apply_aspect_ratio(sp::Subplot, plotarea, pcts)
+    aspect_ratio = sp[:aspect_ratio]
+    if aspect_ratio != :none
+        if aspect_ratio == :equal
+            aspect_ratio = 1.0
+        end
+        xmin,xmax = axis_limits(sp[:xaxis])
+        ymin,ymax = axis_limits(sp[:yaxis])
+        want_ratio = ((xmax-xmin) / (ymax-ymin)) / aspect_ratio
+        parea_ratio = width(plotarea) / height(plotarea)
+        if want_ratio > parea_ratio
+            # need to shrink y
+            ratio = parea_ratio / want_ratio
+            pcts[2], pcts[4] = shrink_by(pcts[2], pcts[4], ratio)
+        elseif want_ratio < parea_ratio
+            # need to shrink x
+            ratio = want_ratio / parea_ratio
+            pcts[1], pcts[3] = shrink_by(pcts[1], pcts[3], ratio)
+        end
+        pcts
+    end
+    pcts
+end
+

 # this method gets the start/end in percentage of the canvas for this axis direction
 function plotly_domain(sp::Subplot, letter)
    figw, figh = sp.plt[:size]
    pcts = bbox_to_pcts(sp.plotarea, figw*px, figh*px)
+    pcts = plotly_apply_aspect_ratio(sp, sp.plotarea, pcts)
    i1,i2 = (letter == :x ? (1,3) : (2,4))
    [pcts[i1], pcts[i1]+pcts[i2]]
 end
@@ -157,8 +214,11 @@ function plotly_axis(axis::Axis, sp::Subplot)
    letter = axis[:letter]
    ax = KW(
        :title      => axis[:guide],
-        :showgrid   => sp[:grid],
+        :showgrid   => axis[:grid],
+        :gridcolor  => rgba_string(plot_color(axis[:foreground_color_grid], axis[:gridalpha])),
+        :gridwidth  => axis[:gridlinewidth],
        :zeroline   => false,
+        :ticks      => "inside",
    )

    if letter in (:x,:y)
@@ -166,22 +226,19 @@ function plotly_axis(axis::Axis, sp::Subplot)
        ax[:anchor] = "$(letter==:x ? :y : :x)$(plotly_subplot_index(sp))"
    end

-    rot = axis[:rotation]
-    if rot != 0
-        ax[:tickangle] = rot
-    end
+    ax[:tickangle] = -axis[:rotation]

    if !(axis[:ticks] in (nothing, :none))
        ax[:titlefont] = plotly_font(axis[:guidefont], axis[:foreground_color_guide])
        ax[:type] = plotly_scale(axis[:scale])
        ax[:tickfont] = plotly_font(axis[:tickfont], axis[:foreground_color_text])
-        ax[:tickcolor] = webcolor(axis[:foreground_color_border])
-        ax[:linecolor] = webcolor(axis[:foreground_color_border])
+        ax[:tickcolor] = rgba_string(axis[:foreground_color_axis])
+        ax[:linecolor] = rgba_string(axis[:foreground_color_axis])

        # lims
        lims = axis[:lims]
        if lims != :auto && limsType(lims) == :limits
-            ax[:range] = lims
+            ax[:range] = map(scalefunc(axis[:scale]), lims)
        end

        # flip
@@ -190,7 +247,7 @@ function plotly_axis(axis::Axis, sp::Subplot)
        end

        # ticks
-        ticks = axis[:ticks]
+        ticks = get_ticks(axis)
        if ticks != :auto
            ttype = ticksType(ticks)
            if ttype == :ticks
@@ -214,14 +271,15 @@ function plotly_layout(plt::Plot)

    w, h = plt[:size]
    d_out[:width], d_out[:height] = w, h
-    d_out[:paper_bgcolor] = webcolor(plt[:background_color_outside])
-    d_out[:margin] = KW(:l=>0, :b=>0, :r=>0, :t=>20)
+    d_out[:paper_bgcolor] = rgba_string(plt[:background_color_outside])
+    d_out[:margin] = KW(:l=>0, :b=>20, :r=>0, :t=>20)

    d_out[:annotations] = KW[]

    for sp in plt.subplots
        spidx = plotly_subplot_index(sp)

+
        # add an annotation for the title... positioned horizontally relative to plotarea,
        # but vertically just below the top of the subplot bounding box
        if sp[:title] != ""
@@ -239,9 +297,7 @@ function plotly_layout(plt::Plot)
            push!(d_out[:annotations], plotly_annotation_dict(titlex, titley, text(sp[:title], titlefont)))
        end

-        d_out[:plot_bgcolor] = webcolor(sp[:background_color_inside])
-
-        # TODO: x/y axis tick values/labels
+        d_out[:plot_bgcolor] = rgba_string(sp[:background_color_inside])

        # if any(is3d, seriesargs)
        if is3d(sp)
@@ -257,17 +313,32 @@ function plotly_layout(plt::Plot)

        # legend
        d_out[:showlegend] = sp[:legend] != :none
+        xpos,ypos = plotly_legend_pos(sp[:legend])
        if sp[:legend] != :none
            d_out[:legend] = KW(
-                :bgcolor  => webcolor(sp[:background_color_legend]),
-                :bordercolor => webcolor(sp[:foreground_color_legend]),
+                :bgcolor  => rgba_string(sp[:background_color_legend]),
+                :bordercolor => rgba_string(sp[:foreground_color_legend]),
                :font     => plotly_font(sp[:legendfont], sp[:foreground_color_legend]),
+                :x => xpos,
+                :y => ypos
            )
        end

        # annotations
        append!(d_out[:annotations], KW[plotly_annotation_dict(ann...; xref = "x$spidx", yref = "y$spidx") for ann in sp[:annotations]])

+        # series_annotations
+        for series in series_list(sp)
+            anns = series[:series_annotations]
+            for (xi,yi,str,fnt) in EachAnn(anns, series[:x], series[:y])
+                push!(d_out[:annotations], plotly_annotation_dict(
+                    xi,
+                    yi,
+                    PlotText(str,fnt); xref = "x$spidx", yref = "y$spidx")
+                )
+            end
+        end
+
        # # arrows
        # for sargs in seriesargs
        #     a = sargs[:arrow]
@@ -298,14 +369,17 @@ function plotly_layout_json(plt::Plot)
 end


-function plotly_colorscale(grad::ColorGradient, alpha = nothing)
-    [[grad.values[i], webcolor(grad.colors[i], alpha)] for i in 1:length(grad.colors)]
+function plotly_colorscale(grad::ColorGradient, α)
+    [[grad.values[i], rgb_string(grad.colors[i])] for i in 1:length(grad.colors)]
 end
-plotly_colorscale(c, alpha = nothing) = plotly_colorscale(default_gradient(), alpha)
+plotly_colorscale(c, α) = plotly_colorscale(cgrad(alpha=α), α)
+# plotly_colorscale(c, alpha = nothing) = plotly_colorscale(cgrad(), alpha)
+

 const _plotly_markers = KW(
    :rect       => "square",
    :xcross     => "x",
+    :x          => "x",
    :utriangle  => "triangle-up",
    :dtriangle  => "triangle-down",
    :star5      => "star-triangle-up",
@@ -325,15 +399,31 @@ function plotly_close_shapes(x, y)
    xs, ys = nansplit(x), nansplit(y)
    for i=1:length(xs)
        shape = Shape(xs[i], ys[i])
-        xs[i], ys[i] = shape_coords(shape)
+        xs[i], ys[i] = coords(shape)
    end
    nanvcat(xs), nanvcat(ys)
 end

+plotly_data(v) = collect(v)
+plotly_data(surf::Surface) = surf.surf
+plotly_data{R<:Rational}(v::AbstractArray{R}) = float(v)
+
+plotly_surface_data(series::Series, a::AbstractVector) = a
+plotly_surface_data(series::Series, a::AbstractMatrix) = transpose_z(series, a, false)
+plotly_surface_data(series::Series, a::Surface) = plotly_surface_data(series, a.surf)
+
+#ensures that a gradient is called if a single color is supplied where a gradient is needed (e.g. if a series recipe defines marker_z)
+as_gradient(grad::ColorGradient, α) = grad
+as_gradient(grad, α) = cgrad(alpha = α)
+
 # get a dictionary representing the series params (d is the Plots-dict, d_out is the Plotly-dict)
 function plotly_series(plt::Plot, series::Series)
-    d = series.d
-    sp = d[:subplot]
+    st = series[:seriestype]
+    if st == :shape
+        return plotly_series_shapes(plt, series)
+    end
+
+    sp = series[:subplot]
    d_out = KW()

    # these are the axes that the series should be mapped to
@@ -342,13 +432,28 @@ function plotly_series(plt::Plot, series::Series)
    d_out[:yaxis] = "y$spidx"
    d_out[:showlegend] = should_add_to_legend(series)

-    x, y = collect(d[:x]), collect(d[:y])
-    d_out[:name] = d[:label]
-    st = d[:seriestype]
+    x, y = plotly_data(series[:x]), plotly_data(series[:y])
+    d_out[:name] = series[:label]
+
    isscatter = st in (:scatter, :scatter3d, :scattergl)
-    hasmarker = isscatter || d[:markershape] != :none
-    # hasline = !isscatter
+    hasmarker = isscatter || series[:markershape] != :none
    hasline = st in (:path, :path3d)
+    hasfillrange = st in (:path, :scatter, :scattergl) &&
+        (isa(series[:fillrange], AbstractVector) || isa(series[:fillrange], Tuple))
+
+    # for surface types, set the data
+    if st in (:heatmap, :contour, :surface, :wireframe)
+        for letter in [:x,:y,:z]
+            d_out[letter] = plotly_surface_data(series, series[letter])
+        end
+    end
+
+    d_out[:colorbar] = KW(:title => sp[:colorbar_title])
+
+    clims = sp[:clims]
+    if is_2tuple(clims)
+        d_out[:zmin], d_out[:zmax] = clims
+    end

    # set the "type"
    if st in (:path, :scatter, :scattergl)
@@ -358,76 +463,61 @@ function plotly_series(plt::Plot, series::Series)
        else
            hasline ? "lines" : "none"
        end
-        if d[:fillrange] == true || d[:fillrange] == 0
+        if series[:fillrange] == true || series[:fillrange] == 0 || isa(series[:fillrange], Tuple)
            d_out[:fill] = "tozeroy"
-            d_out[:fillcolor] = webcolor(d[:fillcolor], d[:fillalpha])
-        elseif !(d[:fillrange] in (false, nothing))
-            warn("fillrange ignored... plotly only supports filling to zero. fillrange: $(d[:fillrange])")
+            d_out[:fillcolor] = rgba_string(series[:fillcolor])
+        elseif isa(series[:fillrange], AbstractVector)
+            d_out[:fill] = "tonexty"
+            d_out[:fillcolor] = rgba_string(series[:fillcolor])
+        elseif !(series[:fillrange] in (false, nothing))
+            warn("fillrange ignored... plotly only supports filling to zero and to a vector of values. fillrange: $(series[:fillrange])")
        end
        d_out[:x], d_out[:y] = x, y

-    elseif st == :shape
-        # to draw polygons, we actually draw lines with fill
-        d_out[:type] = "scatter"
-        d_out[:mode] = "lines"
-        d_out[:x], d_out[:y] = plotly_close_shapes(x, y)
-        # @show map(length, (x,y,d_out[:x],d_out[:y]))
-        # @show d_out[:x] d_out[:y]
-        d_out[:fill] = "tozeroy"
-        d_out[:fillcolor] = webcolor(d[:fillcolor], d[:fillalpha])
-        if d[:markerstrokewidth] > 0
-            d_out[:line] = KW(
-                :color => webcolor(d[:linecolor], d[:linealpha]),
-                :width => d[:linewidth],
-                :dash => string(d[:linestyle]),
-            )
-        end
-
-
-
    elseif st == :bar
        d_out[:type] = "bar"
-        d_out[:x], d_out[:y] = x, y
-        d_out[:orientation] = isvertical(d) ? "v" : "h"
-
-    # elseif st == :histogram2d
-    #     d_out[:type] = "histogram2d"
-    #     d_out[:x], d_out[:y] = x, y
-    #     if isa(d[:bins], Tuple)
-    #         xbins, ybins = d[:bins]
-    #     else
-    #         xbins = ybins = d[:bins]
-    #     end
-    #     d_out[:nbinsx] = xbins
-    #     d_out[:nbinsy] = ybins
-    #     d_out[:colorscale] = plotly_colorscale(d[:fillcolor], d[:fillalpha])
-
-    # elseif st in (:histogram, :density)
-    #     d_out[:type] = "histogram"
-    #     isvert = isvertical(d)
-    #     d_out[isvert ? :x : :y] = y
-    #     d_out[isvert ? :nbinsx : :nbinsy] = d[:bins]
-    #     if st == :density
-    #         d_out[:histogramnorm] = "probability density"
-    #     end
+        d_out[:x], d_out[:y], d_out[:orientation] = if isvertical(series)
+            x, y, "v"
+        else
+            y, x, "h"
+        end
+        d_out[:marker] = KW(:color => rgba_string(series[:fillcolor]))

    elseif st == :heatmap
        d_out[:type] = "heatmap"
-        d_out[:x], d_out[:y], d_out[:z] = d[:x], d[:y], transpose_z(d, d[:z].surf, false)
-        d_out[:colorscale] = plotly_colorscale(d[:fillcolor], d[:fillalpha])
+        # d_out[:x], d_out[:y], d_out[:z] = series[:x], series[:y], transpose_z(series, series[:z].surf, false)
+        d_out[:colorscale] = plotly_colorscale(series[:fillcolor], series[:fillalpha])
+        d_out[:showscale] = sp[:legend] != :none

    elseif st == :contour
        d_out[:type] = "contour"
-        d_out[:x], d_out[:y], d_out[:z] = d[:x], d[:y], transpose_z(d, d[:z].surf, false)
-        # d_out[:showscale] = d[:colorbar] != :none
-        d_out[:ncontours] = d[:levels]
-        d_out[:contours] = KW(:coloring => d[:fillrange] != nothing ? "fill" : "lines")
-        d_out[:colorscale] = plotly_colorscale(d[:linecolor], d[:linealpha])
+        # d_out[:x], d_out[:y], d_out[:z] = series[:x], series[:y], transpose_z(series, series[:z].surf, false)
+        # d_out[:showscale] = series[:colorbar] != :none
+        d_out[:ncontours] = series[:levels]
+        d_out[:contours] = KW(:coloring => series[:fillrange] != nothing ? "fill" : "lines")
+        d_out[:colorscale] = plotly_colorscale(series[:linecolor], series[:linealpha])
+        d_out[:showscale] = sp[:legend] != :none

    elseif st in (:surface, :wireframe)
        d_out[:type] = "surface"
-        d_out[:x], d_out[:y], d_out[:z] = d[:x], d[:y], transpose_z(d, d[:z].surf, false)
-        d_out[:colorscale] = plotly_colorscale(d[:fillcolor], d[:fillalpha])
+        # d_out[:x], d_out[:y], d_out[:z] = series[:x], series[:y], transpose_z(series, series[:z].surf, false)
+        if st == :wireframe
+            d_out[:hidesurface] = true
+            wirelines = KW(
+                :show => true,
+                :color => rgba_string(series[:linecolor]),
+                :highlightwidth => series[:linewidth],
+            )
+            d_out[:contours] = KW(:x => wirelines, :y => wirelines, :z => wirelines)
+            d_out[:showscale] = false
+        else
+            d_out[:colorscale] = plotly_colorscale(series[:fillcolor], series[:fillalpha])
+            d_out[:opacity] = series[:fillalpha]
+            if series[:fill_z] != nothing
+                d_out[:surfacecolor] = plotly_surface_data(series, series[:fill_z])
+            end
+            d_out[:showscale] = sp[:legend] != :none
+        end

    elseif st == :pie
        d_out[:type] = "pie"
@@ -443,7 +533,7 @@ function plotly_series(plt::Plot, series::Series)
            hasline ? "lines" : "none"
        end
        d_out[:x], d_out[:y] = x, y
-        d_out[:z] = collect(d[:z])
+        d_out[:z] = plotly_data(series[:z])

    else
        warn("Plotly: seriestype $st isn't supported.")
@@ -453,32 +543,33 @@ function plotly_series(plt::Plot, series::Series)
    # add "marker"
    if hasmarker
        d_out[:marker] = KW(
-            :symbol => get(_plotly_markers, d[:markershape], string(d[:markershape])),
-            :opacity => d[:markeralpha],
-            :size => 2 * d[:markersize],
-            :color => webcolor(d[:markercolor], d[:markeralpha]),
+            :symbol => get(_plotly_markers, series[:markershape], string(series[:markershape])),
+            # :opacity => series[:markeralpha],
+            :size => 2 * series[:markersize],
+            # :color => rgba_string(series[:markercolor]),
            :line => KW(
-                :color => webcolor(d[:markerstrokecolor], d[:markerstrokealpha]),
-                :width => d[:markerstrokewidth],
+                :color => rgba_string(series[:markerstrokecolor]),
+                :width => series[:markerstrokewidth],
            ),
        )

        # gotta hack this (for now?) since plotly can't handle rgba values inside the gradient
-        if d[:marker_z] != nothing
-            # d_out[:marker][:color] = d[:marker_z]
-            # d_out[:marker][:colorscale] = plotly_colorscale(d[:markercolor], d[:markeralpha])
-            # d_out[:showscale] = true
-            grad = ColorGradient(d[:markercolor], alpha=d[:markeralpha])
-            zmin, zmax = extrema(d[:marker_z])
-            d_out[:marker][:color] = [webcolor(getColorZ(grad, (zi - zmin) / (zmax - zmin))) for zi in d[:marker_z]]
+        d_out[:marker][:color] = if series[:marker_z] == nothing
+            rgba_string(series[:markercolor])
+        else
+            # grad = ColorGradient(series[:markercolor], alpha=series[:markeralpha])
+            grad = as_gradient(series[:markercolor], series[:markeralpha])
+            zmin, zmax = ignorenan_extrema(series[:marker_z])
+            zrange = zmax == zmin ? 1 : zmax - zmin # if all marker_z values are the same, plot all markers same color (avoids division by zero in next line)
+            [rgba_string(grad[(zi - zmin) / zrange]) for zi in series[:marker_z]]
        end
    end

    # add "line"
    if hasline
        d_out[:line] = KW(
-            :color => webcolor(d[:linecolor], d[:linealpha]),
-            :width => d[:linewidth],
+            :color => rgba_string(series[:linecolor]),
+            :width => series[:linewidth],
            :shape => if st == :steppre
                "vh"
            elseif st == :steppost
@@ -486,38 +577,117 @@ function plotly_series(plt::Plot, series::Series)
            else
                "linear"
            end,
-            :dash => string(d[:linestyle]),
+            :dash => string(series[:linestyle]),
            # :dash => "solid",
        )
    end

+    plotly_polar!(d_out, series)
+    plotly_hover!(d_out, series[:hover])
+
+    if hasfillrange
+        # if hasfillrange is true, return two dictionaries (one for original
+        # series, one for series being filled to) instead of one
+        d_out_fillrange = deepcopy(d_out)
+        d_out_fillrange[:showlegend] = false
+        if isa(series[:fillrange], AbstractVector)
+            d_out_fillrange[:y] = series[:fillrange]
+            delete!(d_out_fillrange, :fill)
+            delete!(d_out_fillrange, :fillcolor)
+        else
+            # if fillrange is a tuple with upper and lower limit, d_out_fillrange
+            # is the series that will do the filling
+            d_out_fillrange[:x], d_out_fillrange[:y] =
+                concatenate_fillrange(series[:x], series[:fillrange])
+            d_out_fillrange[:line][:width] = 0
+            delete!(d_out, :fill)
+            delete!(d_out, :fillcolor)
+        end
+
+        return [d_out_fillrange, d_out]
+    else
+        return [d_out]
+    end
+end
+
+function plotly_series_shapes(plt::Plot, series::Series)
+    d_outs = []
+
+    # TODO: create a d_out for each polygon
+    # x, y = series[:x], series[:y]
+
+    # these are the axes that the series should be mapped to
+    spidx = plotly_subplot_index(series[:subplot])
+    base_d = KW()
+    base_d[:xaxis] = "x$spidx"
+    base_d[:yaxis] = "y$spidx"
+    base_d[:name] = series[:label]
+    # base_d[:legendgroup] = series[:label]
+
+    x, y = plotly_data(series[:x]), plotly_data(series[:y])
+    for (i,rng) in enumerate(iter_segments(x,y))
+        length(rng) < 2 && continue
+
+        # to draw polygons, we actually draw lines with fill
+        d_out = merge(base_d, KW(
+            :type => "scatter",
+            :mode => "lines",
+            :x => vcat(x[rng], x[rng[1]]),
+            :y => vcat(y[rng], y[rng[1]]),
+            :fill => "tozeroy",
+            :fillcolor => rgba_string(_cycle(series[:fillcolor], i)),
+        ))
+        if series[:markerstrokewidth] > 0
+            d_out[:line] = KW(
+                :color => rgba_string(_cycle(series[:linecolor], i)),
+                :width => series[:linewidth],
+                :dash => string(series[:linestyle]),
+            )
+        end
+        d_out[:showlegend] = i==1 ? should_add_to_legend(series) : false
+        plotly_polar!(d_out, series)
+        plotly_hover!(d_out, _cycle(series[:hover], i))
+        push!(d_outs, d_out)
+    end
+    d_outs
+end
+
+function plotly_polar!(d_out::KW, series::Series)
    # convert polar plots x/y to theta/radius
-    if ispolar(d[:subplot])
+    if ispolar(series[:subplot])
        d_out[:t] = rad2deg(pop!(d_out, :x))
        d_out[:r] = pop!(d_out, :y)
    end
+end

+function plotly_hover!(d_out::KW, hover)
    # hover text
-    hover = d[:hover]
    if hover in (:none, false)
        d_out[:hoverinfo] = "none"
    elseif hover != nothing
        d_out[:hoverinfo] = "text"
        d_out[:text] = hover
    end
-
-    d_out
 end

 # get a list of dictionaries, each representing the series params
 function plotly_series_json(plt::Plot)
-    JSON.json(map(series -> plotly_series(plt, series), plt.series_list))
+    slist = []
+    for series in plt.series_list
+        append!(slist, plotly_series(plt, series))
+    end
+    JSON.json(slist)
+    # JSON.json(map(series -> plotly_series(plt, series), plt.series_list))
 end

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

+const _use_remote = Ref(false)
+
 function html_head(plt::Plot{PlotlyBackend})
-    "<script src=\"$(Pkg.dir("Plots","deps","plotly-latest.min.js"))\"></script>"
+    jsfilename = _use_remote[] ? _plotly_js_path_remote : _plotly_js_path
+    # "<script src=\"$(joinpath(dirname(@__FILE__),"..","..","deps","plotly-latest.min.js"))\"></script>"
+    "<script src=\"$jsfilename\"></script>"
 end

 function html_body(plt::Plot{PlotlyBackend}, style = nothing)
@@ -547,11 +717,12 @@ end
 # ----------------------------------------------------------------


-function _writemime(io::IO, ::MIME"image/png", plt::Plot{PlotlyBackend})
-    writemime_png_from_html(io, plt)
+function _show(io::IO, ::MIME"image/png", plt::Plot{PlotlyBackend})
+    # show_png_from_html(io, plt)
+    error("png output from the plotly backend is not supported.  Please use plotlyjs instead.")
 end

-function _writemime(io::IO, ::MIME"image/svg+xml", plt::Plot{PlotlyBackend})
+function _show(io::IO, ::MIME"image/svg+xml", plt::Plot{PlotlyBackend})
    write(io, html_head(plt) * html_body(plt))
 end

@@ -1,16 +1,29 @@

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

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

+
+function add_backend_string(::PlotlyJSBackend)
+    """
+    if !Plots.is_installed("PlotlyJS")
+        Pkg.add("PlotlyJS")
+    end
+    if !Plots.is_installed("Rsvg")
+        Pkg.add("Rsvg")
+    end
+    import Blink
+    Blink.AtomShell.install()
+    """
+end
+
+
 function _initialize_backend(::PlotlyJSBackend; kw...)
    @eval begin
        import PlotlyJS
@@ -27,24 +40,35 @@ end


 function _create_backend_figure(plt::Plot{PlotlyJSBackend})
-    PlotlyJS.plot()
+    if !isplotnull() && plt[:overwrite_figure] && isa(current().o, PlotlyJS.SyncPlot)
+        PlotlyJS.SyncPlot(PlotlyJS.Plot(), current().o.view)
+    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.d[:x],), ysym => (series.d[: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],))
+        kw
    )
 end

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

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

-function _writemime(io::IO, ::MIME"image/svg+xml", plt::Plot{PlotlyJSBackend})
-    writemime(io, MIME("text/html"), plt.o)
+function _show(io::IO, ::MIME"image/svg+xml", plt::Plot{PlotlyJSBackend})
+    if isijulia() && !_use_remote[]
+        write(io, PlotlyJS.html_body(PlotlyJS.JupyterPlot(plt.o)))
+    else
+        show(io, MIME("text/html"), plt.o)
+    end
 end

-function _writemime(io::IO, ::MIME"image/png", plt::Plot{PlotlyJSBackend})
-    tmpfn = tempname() * ".png"
+function plotlyjs_save_hack(io::IO, plt::Plot{PlotlyJSBackend}, ext::String)
+    tmpfn = tempname() * "." * ext
    PlotlyJS.savefig(plt.o, tmpfn)
    write(io, read(open(tmpfn)))
 end
+_show(io::IO, ::MIME"image/png", plt::Plot{PlotlyJSBackend}) = plotlyjs_save_hack(io, plt, "png")
+_show(io::IO, ::MIME"application/pdf", plt::Plot{PlotlyJSBackend}) = plotlyjs_save_hack(io, plt, "pdf")
+_show(io::IO, ::MIME"image/eps", plt::Plot{PlotlyJSBackend}) = plotlyjs_save_hack(io, plt, "eps")
+
+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
+
+
+function closeall(::PlotlyJSBackend)
+    if !isplotnull() && isa(current().o, PlotlyJS.SyncPlot)
+        close(current().o)
+    end
 end
@@ -67,7 +67,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,7 +1,7 @@

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

-supported_args(::UnicodePlotsBackend) = merge_with_base_supported([
+const _unicodeplots_attr = merge_with_base_supported([
    :label,
    :legend,
    :seriescolor,
@@ -12,21 +12,30 @@ supported_args(::UnicodePlotsBackend) = merge_with_base_supported([
    :title,
    :guide, :lims,
  ])
-supported_types(::UnicodePlotsBackend) = [
+const _unicodeplots_seriestype = [
    :path, :scatter,
-    :histogram2d
+    # :bar,
+    :shape,
+    :histogram2d,
+    :spy
 ]
-supported_styles(::UnicodePlotsBackend) = [:auto, :solid]
-supported_markers(::UnicodePlotsBackend) = [:none, :auto, :circle]
-supported_scales(::UnicodePlotsBackend) = [:identity]
-is_subplot_supported(::UnicodePlotsBackend) = true
+const _unicodeplots_style = [:auto, :solid]
+const _unicodeplots_marker = [:none, :auto, :circle]
+const _unicodeplots_scale = [:identity]


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

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

+function add_backend_string(::UnicodePlotsBackend)
+    """
+    Pkg.add("UnicodePlots")
+    Pkg.build("UnicodePlots")
+    """
+end
+
 function _initialize_backend(::UnicodePlotsBackend; kw...)
    @eval begin
        import UnicodePlots
@@ -36,9 +45,21 @@ 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
@@ -57,8 +78,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,
@@ -96,6 +142,10 @@ function addUnicodeSeries!(o, d::KW, addlegend::Bool, xlim, ylim)
        func = UnicodePlots.lineplot!
    elseif st == :scatter || d[: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
@@ -108,12 +158,13 @@ function addUnicodeSeries!(o, d::KW, addlegend::Bool, xlim, ylim)
    color = d[:linecolor] in UnicodePlots.color_cycle ? d[:linecolor] : :auto

    # add the series
+    x, y = Plots.unzip(collect(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 +173,7 @@ function png(plt::AbstractPlot{UnicodePlotsBackend}, fn::AbstractString)
    gui(plt)

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

        # wait while the plot gets drawn
@@ -143,21 +194,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)
+    map(show, plt.o)
+    nothing
 end


 function _display(plt::Plot{UnicodePlotsBackend})
-  map(show, plt.o)
-  nothing
+    unicodeplots_rebuild(plt)
+    map(show, plt.o)
+    nothing
 end
-
@@ -20,14 +20,14 @@ function standalone_html(plt::AbstractPlot; title::AbstractString = get(plt.attr
 end

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


-typealias P2 FixedSizeArrays.Vec{2,Float64}
-typealias P3 FixedSizeArrays.Vec{3,Float64}
+const P2 = FixedSizeArrays.Vec{2,Float64}
+const P3 = FixedSizeArrays.Vec{3,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))
@@ -14,30 +14,41 @@ compute_angle(v::P2) = (angle = atan2(v[2], v[1]); angle < 0 ? 2π - angle : ang
 immutable 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 linspace(start_θ, end_θ, n)]
 end

 "interleave 2 vectors into each other (like a zipper's teeth)"
@@ -72,13 +83,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 +99,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 +121,8 @@ const _shape_keys = Symbol[
  :xcross,
  :utriangle,
  :dtriangle,
+  :rtriangle,
+  :ltriangle,
  :pentagon,
  :heptagon,
  :octagon,
@@ -119,14 +132,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 +158,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 +183,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 +193,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 +210,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 +227,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 +246,7 @@ end
 # -----------------------------------------------------------------------


-immutable Font
+type Font
  family::AbstractString
  pointsize::Int
  halign::Symbol
@@ -236,7 +259,7 @@ end
 function font(args...)

  # defaults
-  family = "Helvetica"
+  family = "sans-serif"
  pointsize = 14
  halign = :hcenter
  valign = :vcenter
@@ -280,6 +303,38 @@ function font(args...)
  Font(family, pointsize, halign, valign, rotation, color)
 end

+function scalefontsize(k::Symbol, factor::Number)
+    f = default(k)
+    f.pointsize = round(Int, factor * f.pointsize)
+    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 (:titlefont, :guidefont, :tickfont, :legendfont)
+        scalefontsize(k, factor)
+    end
+end
+
+"""
+    scalefontsizes()
+
+Resets font sizes to initial default values.
+"""
+function scalefontsizes()
+  for k in (:titlefont, :guidefont, :tickfont, :legendfont)
+      f = default(k)
+      if k in keys(_initial_fontsizes)
+        factor = f.pointsize / _initial_fontsizes[k]
+        scalefontsize(k, 1.0/factor)
+      end
+  end
+end
+
 "Wrap a string with font info"
 immutable PlotText
  str::AbstractString
@@ -287,17 +342,18 @@ immutable PlotText
 end
 PlotText(str) = PlotText(string(str), font())

+"""
+    text(string, args...)
+
+Create a PlotText object wrapping a string with font info, for plot annotations
+"""
 text(t::PlotText) = t
 text(str::AbstractString, f::Font) = PlotText(str, f)
 function text(str, args...)
  PlotText(string(str), font(args...))
 end

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

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

@@ -310,10 +366,15 @@ immutable Stroke
  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)
@@ -347,8 +408,8 @@ immutable Brush
 end

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

  for arg in args
    T = typeof(arg)
@@ -373,19 +434,122 @@ end

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

+type SeriesAnnotations
+    strs::AbstractVector  # the labels/names
+    font::Font
+    baseshape::Nullable
+    scalefactor::Tuple
+end
+function series_annotations(strs::AbstractVector, args...)
+    fnt = font()
+    shp = Nullable{Any}()
+    scalefactor = (1,1)
+    for arg in args
+        if isa(arg, Shape) || (isa(arg, AbstractVector) && eltype(arg) == Shape)
+            shp = Nullable(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(::Void) = 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 && !isnull(anns.baseshape)
+        # we use baseshape to overwrite the markershape attribute
+        # with a list of custom shapes for each
+        msw,msh = anns.scalefactor
+        msize = Float64[]
+        shapes = Shape[begin
+            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(get(anns.baseshape),i)
+            shape = scale(baseshape, msw*xscale/maxscale, msh*yscale/maxscale, (0,0))
+        end for i=1:length(anns.strs)]
+        series[:markershape] = shapes
+        series[:markersize] = msize
+    end
+    return
+end
+
+type EachAnn
+    anns
+    x
+    y
+end
+Base.start(ea::EachAnn) = 1
+Base.done(ea::EachAnn, i) = ea.anns == nothing || isempty(ea.anns.strs) || i > length(ea.y)
+function Base.next(ea::EachAnn, i)
+    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(::Void) = []
+annotations(anns::AVec) = anns
+annotations(anns) = Any[anns]
+annotations(sa::SeriesAnnotations) = sa
+
+# -----------------------------------------------------------------------
+
 "type which represents z-values for colors and sizes (and anything else that might come up)"
 immutable 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{T<:Real}(values::AVec{T}, zrange::Tuple{T,T} = (ignorenan_minimum(values), ignorenan_maximum(values)))
  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
@@ -400,7 +564,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{T}(surf::Surface{T}) = eltype(T)

 function expand_extrema!(a::Axis, surf::Surface)
    ex = a[:extrema]
@@ -415,24 +579,65 @@ immutable SurfaceFunction <: AbstractSurface
    f::Function
 end

+
+# -----------------------------------------------------------------------
+
+# # I don't want to clash with ValidatedNumerics, but this would be nice:
+# ..(a::T, b::T) = (a,b)
+
+immutable Volume{T}
+    v::Array{T,3}
+    x_extents::Tuple{T,T}
+    y_extents::Tuple{T,T}
+    z_extents::Tuple{T,T}
+end
+
+default_extents{T}(::Type{T}) = (zero(T), one(T))
+
+function Volume{T}(v::Array{T,3},
+                   x_extents = default_extents(T),
+                   y_extents = default_extents(T),
+                   z_extents = default_extents(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{T}(vol::Volume{T}) = Volume{T}(copy(vol.v), vol.x_extents, vol.y_extents, vol.z_extents)
+Base.eltype{T}(vol::Volume{T}) = T
+
 # -----------------------------------------------------------------------

 # style is :open or :closed (for now)
 immutable 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)
@@ -446,7 +651,7 @@ function arrow(args...)
            warn("Skipped arrow arg $arg")
        end
    end
-    Arrow(style, headlength, headwidth)
+    Arrow(style, side, headlength, headwidth)
 end


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

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

+"Represents data values with formatting that should apply to the tick labels."
+immutable Formatted{T}
+    data::T
+    formatter::Function
+end
+
+# -----------------------------------------------------------------------
+"create a BezierCurve for plotting"
 type BezierCurve{T <: FixedSizeArrays.Vec}
-  control_points::Vector{T}
+    control_points::Vector{T}
 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
+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

-Base.mean(x::Real, y::Real) = 0.5*(x+y)
-Base.mean{N,T<:Real}(ps::FixedSizeArrays.Vec{N,T}...) = sum(ps) / length(ps)
+# mean(x::Real, y::Real) = 0.5*(x+y) #commented out as I cannot see this used anywhere and it overwrites a Base method with different functionality
+# mean{N,T<:Real}(ps::FixedSizeArrays.Vec{N,T}...) = sum(ps) / length(ps) # I also could not see this used anywhere, and it's type piracy - implementing a NaNMath version for this would just involve converting to a standard array

-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, linspace(range..., n))

 # 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
@@ -2,7 +2,7 @@
 # https://github.com/bokeh/Bokeh.jl


-supported_args(::BokehBackend) = merge_with_base_supported([
+supported_attrs(::BokehBackend) = merge_with_base_supported([
    # :annotations,
    # :axis,
    # :background_color,
@@ -194,7 +194,7 @@ end

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

-function Base.writemime(io::IO, ::MIME"image/png", plt::AbstractPlot{BokehBackend})
+function Base.show(io::IO, ::MIME"image/png", plt::AbstractPlot{BokehBackend})
  # TODO: write a png to io
  warn("mime png not implemented")
 end
@@ -2,7 +2,7 @@
 # https://github.com/dcjones/Gadfly.jl


-supported_args(::GadflyBackend) = merge_with_base_supported([
+supported_attrs(::GadflyBackend) = merge_with_base_supported([
    :annotations,
    :background_color, :foreground_color, :color_palette,
    :group, :label, :seriestype,
@@ -41,7 +41,7 @@ function _initialize_backend(::GadflyBackend; kw...)
    @eval begin
        import Gadfly, Compose
        export Gadfly, Compose
-        include(joinpath(Pkg.dir("Plots"), "src", "backends", "gadfly_shapes.jl"))
+        include(joinpath(dirname(@__FILE__), "gadfly_shapes.jl"))
    end
 end

@@ -244,7 +244,7 @@ function addToGadflyLegend(plt::Plot, d::KW)

        # 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[]))
+            unshift!(gplt.guides, Gadfly.Guide.manual_color_key("", AbstractString[], Color[]))
        end

        # now add the series to the legend
@@ -456,7 +456,7 @@ function updateGadflyAxisFlips(gplt, d::KW, xlims, ylims, xfunc, yfunc)
 end


-function findGuideAndSet(gplt, t::DataType, args...; kw...) #s::@compat(AbstractString))
+function findGuideAndSet(gplt, t::DataType, args...; kw...)
    for (i,guide) in enumerate(gplt.guides)
        if isa(guide, t)
            gplt.guides[i] = t(args...; kw...)
@@ -537,7 +537,7 @@ end
 # ----------------------------------------------------------------


-function createGadflyAnnotationObject(x, y, val::@compat(AbstractString))
+function createGadflyAnnotationObject(x, y, val::AbstractString)
    Gadfly.Guide.annotation(Compose.compose(
                              Compose.context(),
                              Compose.text(x, y, val)
@@ -558,7 +558,7 @@ function createGadflyAnnotationObject(x, y, txt::PlotText)
                            ))
 end

-function _add_annotations{X,Y,V}(plt::Plot{GadflyBackend}, anns::AVec{@compat(Tuple{X,Y,V})})
+function _add_annotations{X,Y,V}(plt::Plot{GadflyBackend}, anns::AVec{Tuple{X,Y,V}})
    for ann in anns
        push!(plt.o.guides, createGadflyAnnotationObject(ann...))
    end
@@ -677,7 +677,7 @@ setGadflyDisplaySize(plt::Plot) = setGadflyDisplaySize(plt.attr[:size]...)
 # -------------------------------------------------------------------------


-function dowritemime{P<:Union{GadflyBackend,ImmerseBackend}}(io::IO, func, plt::AbstractPlot{P})
+function doshow{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)
@@ -692,9 +692,9 @@ 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})
+    @eval function Base.show{P<:Union{GadflyBackend,ImmerseBackend}}(io::IO, ::$mime, plt::AbstractPlot{P})
        func = getGadflyWriteFunc($mime())
-        dowritemime(io, func, plt)
+        doshow(io, func, plt)
    end
 end

@@ -84,7 +84,7 @@ function make_polygon(geom::ShapeGeometry, xs::AbstractArray, ys::AbstractArray,
    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)]
+    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,7 +1,7 @@

 # https://github.com/JuliaGraphics/Immerse.jl

-supported_args(::ImmerseBackend) = supported_args(GadflyBackend())
+supported_attrs(::ImmerseBackend) = supported_attrs(GadflyBackend())
 supported_types(::ImmerseBackend) = supported_types(GadflyBackend())
 supported_styles(::ImmerseBackend) = supported_styles(GadflyBackend())
 supported_markers(::ImmerseBackend) = supported_markers(GadflyBackend())
@@ -14,7 +14,7 @@ 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"))
+    include(joinpath(dirname(@__FILE__), "gadfly_shapes.jl"))
  end
 end

@@ -61,7 +61,7 @@ end

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

-function _add_annotations{X,Y,V}(plt::Plot{ImmerseBackend}, anns::AVec{@compat(Tuple{X,Y,V})})
+function _add_annotations{X,Y,V}(plt::Plot{ImmerseBackend}, anns::AVec{Tuple{X,Y,V}})
  for ann in anns
    push!(getGadflyContext(plt).guides, createGadflyAnnotationObject(ann...))
  end
@@ -2,7 +2,7 @@
 # https://github.com/tbreloff/Qwt.jl


-supported_args(::QwtBackend) = merge_with_base_supported([
+supported_attrs(::QwtBackend) = merge_with_base_supported([
    :annotations,
    :linecolor,
    :fillrange,
@@ -39,7 +39,7 @@ end

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

-@compat const _qwtAliases = KW(
+const _qwtAliases = KW(
    :bins => :heatmap_n,
    :fillrange => :fillto,
    :linewidth => :width,
@@ -133,7 +133,7 @@ function updateLimsAndTicks(plt::Plot{QwtBackend}, d::KW, isx::Bool)
  w = plt.o.widget
  axisid = Qwt.QWT.QwtPlot[isx ? :xBottom : :yLeft]

-  if typeof(lims) <: @compat(Union{Tuple,AVec}) && length(lims) == 2
+  if typeof(lims) <: Union{Tuple,AVec} && length(lims) == 2
    if isx
      plt.o.autoscale_x = false
    else
@@ -211,14 +211,14 @@ function createQwtAnnotation(plt::Plot, x, y, val::PlotText)
  marker[:attach](plt.o.widget)
 end

-function createQwtAnnotation(plt::Plot, x, y, val::@compat(AbstractString))
+function createQwtAnnotation(plt::Plot, x, y, val::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})})
+function _add_annotations{X,Y,V}(plt::Plot{QwtBackend}, anns::AVec{Tuple{X,Y,V}})
  for ann in anns
    createQwtAnnotation(plt, ann...)
  end
@@ -242,8 +242,6 @@ end

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

-# savepng(::QwtBackend, plt::AbstractPlot, fn::@compat(AbstractString), args...) = Qwt.savepng(plt.o, fn)
-
 # -------------------------------

 # # create the underlying object (each backend will do this differently)
@@ -282,13 +280,13 @@ end

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

-function Base.writemime(io::IO, ::MIME"image/png", plt::Plot{QwtBackend})
+function Base.show(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})
+# function Base.show(io::IO, ::MIME"image/png", subplt::Subplot{QwtBackend})
 #   for plt in subplt.plts
 #     Qwt.refresh(plt.o)
 #   end
@@ -3,7 +3,7 @@

 # credit goes to https://github.com/jverzani for contributing to the first draft of this backend implementation

-supported_args(::WinstonBackend) = merge_with_base_supported([
+supported_attrs(::WinstonBackend) = merge_with_base_supported([
    :annotations,
    :linecolor,
    :fillrange,
@@ -44,13 +44,13 @@ end


 ## dictionaries for conversion of Plots.jl names to Winston ones.
-@compat const winston_linestyle =  KW(:solid=>"solid",
+const winston_linestyle =  KW(:solid=>"solid",
                                :dash=>"dash",
                                :dot=>"dotted",
                                :dashdot=>"dotdashed"
                               )

-@compat const winston_marker = KW(:none=>".",
+const winston_marker = KW(:none=>".",
                            :rect => "square",
                            :circle=>"circle",
                            :diamond=>"diamond",
@@ -185,7 +185,7 @@ end

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

-@compat const _winstonNames = KW(
+const _winstonNames = KW(
    :xlims => :xrange,
    :ylims => :yrange,
    :xscale => :xlog,
@@ -213,11 +213,11 @@ end

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

-function createWinstonAnnotationObject(plt::Plot{WinstonBackend}, x, y, val::@compat(AbstractString))
+function createWinstonAnnotationObject(plt::Plot{WinstonBackend}, x, y, val::AbstractString)
  Winston.text(x, y, val)
 end

-function _add_annotations{X,Y,V}(plt::Plot{WinstonBackend}, anns::AVec{@compat(Tuple{X,Y,V})})
+function _add_annotations{X,Y,V}(plt::Plot{WinstonBackend}, anns::AVec{Tuple{X,Y,V}})
  for ann in anns
    createWinstonAnnotationObject(plt, ann...)
  end
@@ -238,10 +238,10 @@ function addWinstonLegend(plt::Plot, wplt)
  end
 end

-function Base.writemime(io::IO, ::MIME"image/png", plt::AbstractPlot{WinstonBackend})
+function Base.show(io::IO, ::MIME"image/png", plt::AbstractPlot{WinstonBackend})
  window, canvas, wplt = getWinstonItems(plt)
  addWinstonLegend(plt, wplt)
-  writemime(io, "image/png", wplt)
+  show(io, "image/png", wplt)
 end


@@ -1,5 +1,5 @@

-abstract ColorScheme
+abstract type ColorScheme end

 Base.getindex(scheme::ColorScheme, i::Integer) = getColor(scheme, i)

@@ -32,6 +32,7 @@ getColor(scheme::ColorScheme) = getColor(scheme, 1)
 getColorVector(scheme::ColorScheme) = [getColor(scheme)]

 colorscheme(scheme::ColorScheme) = scheme
+colorscheme(s::AbstractString; kw...) = colorscheme(Symbol(s); kw...)
 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...)
@@ -55,10 +56,10 @@ convertColor(b::Bool) = b ? RGBA(0,0,0,1) : RGBA(0,0,0,0)

 function convertColor(c, α::Real)
  c = convertColor(c)
-  RGBA(RGB(c), α)
+  RGBA(RGB(getColor(c)), α)
 end
 convertColor(cs::AVec, α::Real) = map(c -> convertColor(c, α), cs)
-convertColor(c, α::@compat(Void)) = convertColor(c)
+convertColor(c, α::Void) = convertColor(c)

 # backup... try to convert
 getColor(c) = convertColor(c)
@@ -78,7 +79,7 @@ end

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

-const _rainbowColors = [colorant"blue", colorant"purple", colorant"green", colorant"orange", colorant"red"]
+const _rainbowColors = [colorant"purple", colorant"blue", 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)]

@@ -220,7 +221,7 @@ immutable ColorZFunction <: ColorScheme
  f::Function
 end

-getColorZ(scheme::ColorFunction, z::Real) = scheme.f(z)
+getColorZ(scheme::ColorZFunction, z::Real) = scheme.f(z)

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

@@ -246,6 +247,7 @@ ColorWrapper(s::Symbol; alpha = nothing) = ColorWrapper(convertColor(parse(Color

 getColor(scheme::ColorWrapper, idx::Int) = scheme.c
 getColorZ(scheme::ColorWrapper, z::Real) = scheme.c
+convertColor(c::ColorWrapper, α::Void) = c.c

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

@@ -5,9 +5,9 @@
 # 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}})
+const FuncOrFuncs = @compat(Union{Function, AVec{Function}})

-all3D(d::KW) = trueOrAllTrue(st -> st in (:contour, :heatmap, :surface, :wireframe, :contour3d, :image), get(d, :seriestype, :none))
+all3D(d::KW) = trueOrAllTrue(st -> st in (:contour, :contourf, :heatmap, :surface, :wireframe, :contour3d, :image), get(d, :seriestype, :none))

 # missing
 convertToAnyVector(v::@compat(Void), d::KW) = Any[nothing], nothing
@@ -40,8 +40,8 @@ PlotExample("Colors",
    "Access predefined palettes (or build your own with the `colorscheme` method).  Line/marker colors are auto-generated from the plot's palette, unless overridden.  Set the `z` argument to turn on series gradients.",
    [:(begin
        y = rand(100)
-        plot(0:10:100,rand(11,4),lab="lines",w=3,palette=:grays,fill=(0,: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")
+        plot(0:10:100,rand(11,4),lab="lines",w=3,palette=:grays,fill=0, α=0.6)
+        scatter!(y, zcolor=abs.(y-.5), m=(:heat,0.8,stroke(1,:green)), ms=10*abs.(y-0.5)+4, lab="grad")
    end)]
 ),

@@ -61,13 +61,13 @@ 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
+        img = FileIO.load(Pkg.dir("PlotReferenceImages","Plots","pyplot","0.7.0","ref1.png"))
        plot(img)
    end)]
 ),
@@ -115,20 +115,22 @@ PlotExample("Line types",
 PlotExample("Line styles",
    "",
    [:(begin
-        styles = filter(s -> s in supported_styles(), [:solid, :dash, :dot, :dashdot, :dashdotdot])'
+        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),1)
-        plot(y, line = (5, styles), label = map(string,styles))
+        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)
+        y = repmat(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)]
 ),
@@ -153,7 +155,7 @@ PlotExample("Subplots",
    """,
    [:(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)
+        plot(randn(100,5), layout=l, t=[:line :histogram :scatter :steppre :bar], leg=false, ticks=nothing, border=:none)
    end)]
 ),

@@ -214,19 +216,13 @@ PlotExample("Contours",
        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)
+        X = repmat(reshape(x,1,:), length(y), 1)
        Y = repmat(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",
@@ -258,7 +254,7 @@ PlotExample("DataFrames",
        iris = RDatasets.dataset("datasets", "iris")
        scatter(iris, :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)]
 ),

@@ -274,7 +270,7 @@ PlotExample("Polar Plots",
    "",
    [:(begin
        Θ = linspace(0,1.5π,100)
-        r = abs(0.1randn(100)+sin(3Θ))
+        r = abs.(0.1randn(100)+sin.(3Θ))
        plot(Θ, r, proj=:polar, m=2)
    end)]
 ),
@@ -284,7 +280,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)]
 ),
@@ -294,7 +290,7 @@ PlotExample("Layouts, margins, label rotation, title location",
    [:(begin
        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)]
 ),

@@ -306,7 +302,52 @@ PlotExample("Boxplot and Violin series recipes",
        violin(singers, :VoicePart, :Height, line = 0, fill = (0.2, :blue))
        boxplot!(singers, :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 = linspace(1,10π,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`. As always, the marker shape and size can be changed with `spy(mat, markersize = 3, markershape = :star)`.",
+    [:(begin
+    a = spdiagm((ones(50), ones(49), ones(49), ones(40), ones(40)),(0, 1, -1, 10, -10))
+    b = spdiagm((1:50, 1:49, 1:49, 1:40, 1:40),(0, 1, -1, 10, -10))
+    plot(spy(a, markershape = :dtriangle), spy(b), markersize = 3, 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
+    histogram(fill(randn(1000), 5), framestyle = [:box :semi :axes :grid :none],
+        title = [":box" ":semi" ":axes" ":grid" ":none"], color = RowVector(1:5), layout = 5, label = "")
+    end)]
+),

 ]

@@ -327,6 +368,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
@@ -9,10 +9,10 @@ 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
@@ -20,15 +20,15 @@ Base.typemax(::typeof(mm)) = Inf*mm
 Base.convert{F<:AbstractFloat}(::Type{F}, l::AbsoluteLength) = 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 +44,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 +96,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
+type 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[Symbol(letter,:axis)])
+        xy += pct * (amax-amin)
+    end
+    xy
+end
+
+
 # -----------------------------------------------------------
 # AbstractLayout

@@ -107,15 +133,22 @@ 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")
@@ -132,13 +165,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
@@ -221,6 +258,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...;
@@ -239,7 +283,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 +302,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,7 +357,6 @@ 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
@@ -320,7 +365,6 @@ function update_child_bboxes!(layout::GridLayout, minimum_perimeter = [0mm,0mm,0
    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

    # make sure the perimeter match the parent
    pad_left[1]     = max(pad_left[1], minimum_perimeter[1])
@@ -331,22 +375,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 +427,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(
@@ -436,7 +475,7 @@ end
 function layout_args(d::KW, n_override::Integer)
    layout, n = layout_args(get(d, :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
@@ -502,6 +541,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)
@@ -538,6 +583,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 +648,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 +685,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 +710,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 +787,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,49 @@ 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")
+  writemime(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")
+    _use_remote[] = true
+    show(io, MIME("text/html"), plt)
+    _use_remote[] = false
+    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 +97,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,9 +126,20 @@ 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)
@@ -111,6 +148,13 @@ 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(
@@ -121,84 +165,85 @@ const _mimeformats = Dict(
    "application/postscript"  => "ps",
    "image/svg+xml"           => "svg",
    "text/plain"              => "txt",
+    "application/x-tex"       => "tex",
 )

 const _best_html_output_type = KW(
    :pyplot => :png,
    :unicodeplots => :txt,
+    :glvisualize => :png
 )

 # 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 Base.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), "\" />")
+        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)
+        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")
    end
 end

+function _show{B}(io::IO, m, plt::Plot{B})
+    # Base.show_backtrace(STDOUT, backtrace())
+    warn("_show is not defined for this backend. m=", string(m))
+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)
+    @eval function Base.show{B}(io::IO, m::MIME{Symbol($mime)}, plt::Plot{B})
        prepare_output(plt)
-        _writemime(io, m, plt)
+        _show(io, m, plt)
    end
 end

+"Close all open gui windows of the current backend"
+closeall() = closeall(backend())
+

 # ---------------------------------------------------------
 # 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()
+    @eval import FileIO
+    function _show(io::IO, ::MIME"image/png", plt::Plot)
+        fn = tempname()

-            # first save a pdf file
-            pdf(plt, fn)
+        # first save a pdf file
+        pdf(plt, fn)

-            # load that pdf into a FileIO Stream
-            s = FileIO.load(fn * ".pdf")
+        # load that pdf into a FileIO Stream
+        s = FileIO.load(fn * ".pdf")

-            # save a png
-            pngfn = fn * ".png"
-            FileIO.save(pngfn, s)
+        # save a png
+        pngfn = fn * ".png"
+        FileIO.save(pngfn, s)

-            # now write from the file
-            write(io, readall(open(pngfn)))
-        end
+        # now write from the file
+        write(io, readstring(open(pngfn)))
    end
 end

-
-
-
-
 # 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")
@@ -211,29 +256,29 @@ end
 # IJulia
 # ---------------------------------------------------------

-const _ijulia_output = Compat.ASCIIString["text/html"]
+const _ijulia_output = String["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
+using Requires
+@require IJulia begin
+    if IJulia.inited
+        export set_ijulia_output

-            # 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
+        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{String, String}(_ijulia_output[1] => sprint(show, _ijulia_output[1], plt))
+        end
+
+        # default text/plain passes to html... handles Interact issues
+        function Base.show(io::IO, m::MIME"text/plain", plt::Plot)
+            show(io, MIME("text/html"), plt)
+        end
+
+        ENV["MPLBACKEND"] = "Agg"
        set_ijulia_output("text/html")
    end
 end
@@ -241,30 +286,48 @@ end
 # ---------------------------------------------------------
 # Atom PlotPane
 # ---------------------------------------------------------
+@require Juno begin
+    import Hiccup, Media

-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
+    if Juno.isactive()
+        Media.media(Plot, Media.Plot)

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

-        # Atom.displaysize(::Plot) = (535, 379)
-        # Atom.displaytitle(plt::Plot) = "Plots.jl (backend: $(backend(plt)))"
+        _show{B}(io::IO, m::MIME"text/plain", plt::Plot{B}) = print(io, "Plot{$B}()")

-        # 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))))
+        function Juno.render(e::Juno.Editor, plt::Plot)
+            Juno.render(e, nothing)
        end

+        if get(ENV, "PLOTS_USE_ATOM_PLOTPANE", true) in (true, 1, "1", "true", "yes")
+            function Juno.render(pane::Juno.PlotPane, plt::Plot)
+                # temporarily overwrite size to be Atom.plotsize
+                sz = plt[:size]
+                jsize = Juno.plotsize()
+                jsize[1] == 0 && (jsize[1] = 400)
+                jsize[2] == 0 && (jsize[2] = 500)

-        # 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
+                plt[:size] = jsize
+                Juno.render(pane, HTML(stringmime(MIME("text/html"), plt)))
+                plt[:size] = sz
+            end
+            # special handling for PlotlyJS
+            function Juno.render(pane::Juno.PlotPane, plt::Plot{PlotlyJSBackend})
+                display(Plots.PlotsDisplay(), plt)
+            end
+        else
+            function Juno.render(pane::Juno.PlotPane, plt::Plot)
+                display(Plots.PlotsDisplay(), plt)
+                s = "PlotPane turned off.  Unset ENV[\"PLOTS_USE_ATOM_PLOTPANE\"] and restart Julia to enable it."
+                Juno.render(pane, HTML(s))
+            end
+        end
+
+        # special handling for plotly... use PlotsDisplay
+        function Juno.render(pane::Juno.PlotPane, plt::Plot{PlotlyBackend})
+            display(Plots.PlotsDisplay(), plt)
+            s = "PlotPane turned off.  The plotly backend cannot render in the PlotPane due to javascript issues. Plotlyjs is similar to plotly and is compatible with the plot pane."
+            Juno.render(pane, HTML(s))
+        end
    end
 end
@@ -0,0 +1,418 @@
+
+
+# ------------------------------------------------------------------
+# 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(d::KW, args)
+    sts = get(d, :seriestype, :path)
+    if typeof(sts) <: AbstractArray
+        delete!(d, :seriestype)
+        RecipeData[begin
+            dc = copy(d)
+            dc[:seriestype] = sts[r:r,:]
+            RecipeData(dc, args)
+        end for r=1:size(sts,1)]
+    else
+        RecipeData[RecipeData(copy(d), args)]
+    end
+end
+
+function _preprocess_args(d::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(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.
+    if !isempty(args)
+        append!(still_to_process, _expand_seriestype_array(d, args))
+    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
+    end
+
+    args
+end
+
+# ------------------------------------------------------------------
+# user recipes
+
+
+function _process_userrecipes(plt::Plot, d::KW, args)
+    still_to_process = RecipeData[]
+    args = _preprocess_args(d, 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 = shift!(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.d, next_series.args...)
+            prepend!(still_to_process,rd_list)
+        end
+    end
+
+    # don't allow something else to handle it
+    d[: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.d
+    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] = 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
+    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.d)
+            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, kw)
+        else
+            rethrow()
+        end
+    end
+    return
+end
+
+
+# ------------------------------------------------------------------
+# setup plot and subplot
+
+function _plot_setup(plt::Plot, d::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) && (d[k] = pop!(kw, k))
+    end
+
+    # TODO: init subplots here
+    _update_plot_args(plt, d)
+    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, d::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 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(d, :subplot) || d[:subplot] == idx
+            merge(d, 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{T}(plt::Plot{T}, d::KW)
+    st::Symbol = d[:seriestype]
+    sp::Subplot{T} = d[:subplot]
+    sp_idx = get_subplot_index(plt, sp)
+    _update_subplot_args(plt, sp, d, sp_idx, true)
+
+    st = _override_seriestype_check(d, 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(d::KW, st::Symbol)
+    # do we want to override the series type?
+    if !is3d(st)
+        z = d[:z]
+        if !isa(z, Void) && (size(d[:x]) == size(d[:y]) == size(z))
+            st = (st == :scatter ? :scatter3d : :path3d)
+            d[:seriestype] = st
+        end
+    end
+    st
+end
+
+function _prepare_annotations(sp::Subplot, d::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!(d, :series_annotations, []))
+    # if isa(series_anns, SeriesAnnotations)
+    #     series_anns.x = d[:x]
+    #     series_anns.y = d[:y]
+    # elseif length(series_anns) > 0
+    #     x, y = d[:x], d[: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, d::KW, st::Symbol)
+    # 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, :bins2d, :histogram2d))
+        expand_extrema!(sp, d)
+    end
+end
+
+function _add_the_series(plt, sp, d)
+    warnOnUnsupported_args(plt.backend, d)
+    warnOnUnsupported(plt.backend, d)
+    series = Series(d)
+    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, d::KW)
+    # replace seriestype aliases
+    st = Symbol(d[:seriestype])
+    st = d[:seriestype] = get(_typeAliases, st, st)
+
+    # shapes shouldn't have fillrange set
+    if d[:seriestype] == :shape
+        d[: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, d)
+        _prepare_annotations(sp, d)
+        _expand_subplot_extrema(sp, d, st)
+        _add_the_series(plt, sp, d)
+
+    else
+        # get a sub list of series for this seriestype
+        datalist = RecipesBase.apply_recipe(d, Val{st}, d[:x], d[:y], d[:z])
+
+        # assuming there was no error, recursively apply the series recipes
+        for data in datalist
+            if isa(data, RecipeData)
+                preprocessArgs!(data.d)
+                if data.d[:seriestype] == st
+                    error("The seriestype didn't change in series recipe $st.  This will cause a StackOverflow.")
+                end
+                _process_seriesrecipe(plt, data.d)
+            else
+                warn("Unhandled recipe: $(data)")
+                break
+            end
+        end
+    end
+    nothing
+end
@@ -6,6 +6,10 @@ const CURRENT_PLOT = CurrentPlot(Nullable{AbstractPlot}())

 isplotnull() = isnull(CURRENT_PLOT.nullableplot)

+"""
+    current()
+Returns the Plot object for the current plot
+"""
 function current()
    if isplotnull()
        error("No current plot/subplot")
@@ -49,7 +53,7 @@ function plot(args...; kw...)
    # create an empty Plot then process
    plt = Plot()
    # plt.user_attr = d
-    _plot!(plt, d, args...)
+    _plot!(plt, d, args)
 end

 # build a new plot from existing plots
@@ -60,7 +64,7 @@ function plot(plt1::Plot, plts_tail::Plot...; kw...)

    # build our plot vector from the args
    n = length(plts_tail) + 1
-    plts = Array(Plot, n)
+    plts = Array{Plot}(n)
    plts[1] = plt1
    for (i,plt) in enumerate(plts_tail)
        plts[i+1] = plt
@@ -89,8 +93,16 @@ function plot(plt1::Plot, plts_tail::Plot...; kw...)
    plt.o = _create_backend_figure(plt)
    plt.init = true

+    series_attr = KW()
+    for (k,v) in d
+        if haskey(_series_defaults, k)
+            series_attr[k] = pop!(d,k)
+        end
+    end
+
    # create the layout and initialize the subplots
    plt.layout, plt.subplots, plt.spmap = build_layout(layout, num_sp, copy(plts))
+    cmdidx = 1
    for (idx, sp) in enumerate(plt.subplots)
        _initialize_subplot(plt, sp)
        serieslist = series_list(sp)
@@ -100,35 +112,25 @@ function plot(plt1::Plot, plts_tail::Plot...; kw...)
        sp.plt = plt
        sp.attr[:subplot_index] = idx
        for series in serieslist
+            merge!(series.d, series_attr)
+            _add_defaults!(series.d, 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, d, 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(d, :show, default(:show)))
    plt
 end

@@ -150,243 +152,31 @@ 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
+    _plot!(plt, d, 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...)
+function _plot!(plt::Plot, d::KW, args::Tuple)
    d[: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, :StatPlots) &&
+            first(split(string(typeof(args[1])), ".")) == "DataFrames"
+        warn("You're trying to plot a DataFrame, but this functionality is provided by StatPlots")
    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, d, 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 +189,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
+        _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, d, kw_list)
+    _subplot_setup(plt, d, 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 +208,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 +228,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 +236,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 +270,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(plt.subplots, sp))
+end
+function plot!(sp::Subplot, args...; kw...)
+    plt = sp.plt
+    plot!(plt, args...; kw..., subplot = findfirst(plt.subplots, sp))
+end

 # --------------------------------------------------------------------
@@ -0,0 +1,62 @@
+
+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://juliaplots.github.io/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
+
+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(desc, '.')
+    typedesc = desc[1:first_period_idx-1]
+    desc = strip(desc[first_period_idx+1:end])
+    als = keys(filter((_,v)->v==attribute, _keyAliases)) |> collect |> sort
+    als = join(map(string,als), ", ")
+    def = _attribute_defaults[attrtype][attribute]
+
+
+    # Looks up the different elements and plots them
+    println("$attribute ", typedesc == "" ? "" : "{$typedesc}", "\n",
+        als == "" ? "" : "$als\n",
+        "\n$desc\n",
+        "$(attrtype) attribute, ", def == "" ? "" : " default: $def")
+end
@@ -1,468 +1,3 @@
 function _precompile_()
    ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
-    precompile(Plots.py_add_series, (Plots.Plot{Plots.PyPlotBackend}, Plots.Series,))
-    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Array{Float64, 1},))
-    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Base.StepRange{Int64, Int64},))
-    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Function,))
-    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Array{Plots.OHLC, 1},))
-    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Array{Float64, 1},))
-    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Base.LinSpace{Float64},))
-    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, DataFrames.DataFrame,))
-    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Array{Int64, 1},))
-    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Array{Union{UTF8String, ASCIIString}, 1},))
-    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Array{Function, 1},))
-    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Array{ASCIIString, 1},))
-    precompile(Plots._plot!, (Plots.Plot{Plots.UnicodePlotsBackend}, Base.Dict{Symbol, Any},))
-    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Base.FloatRange{Float64},))
-    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any},))
-    precompile(Plots._plot!, (Plots.Plot{Plots.UnicodePlotsBackend}, Base.Dict{Symbol, Any}, Array{Float64, 1},))
-    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Array{Float64, 2},))
-    precompile(Plots._add_defaults!, (Base.Dict{Symbol, Any}, Plots.Plot{Plots.UnicodePlotsBackend}, Plots.Subplot{Plots.UnicodePlotsBackend}, Int64,))
-    precompile(Plots._before_layout_calcs, (Plots.Plot{Plots.PyPlotBackend},))
-    precompile(Plots._apply_series_recipe, (Plots.Plot{Plots.UnicodePlotsBackend}, Base.Dict{Symbol, Any},))
-    precompile(Plots._add_defaults!, (Base.Dict{Symbol, Any}, Plots.Plot{Plots.PyPlotBackend}, Plots.Subplot{Plots.PyPlotBackend}, Int64,))
-    precompile(Plots._apply_series_recipe, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any},))
-    precompile(Plots.setup_ijulia, ())
-    precompile(Plots.call, (Type{Plots.Plot{Plots.UnicodePlotsBackend}}, Plots.UnicodePlotsBackend, Int64, Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Array{Plots.Series, 1}, Void, Array{Plots.Subplot, 1}, Base.Dict{Any, Plots.Subplot}, Plots.EmptyLayout, Array{Plots.Subplot, 1}, Bool,))
-    precompile(Plots.expand_extrema!, (Plots.Subplot{Plots.UnicodePlotsBackend}, Base.Dict{Symbol, Any},))
-    precompile(Plots.create_grid_vcat, (Expr,))
-    precompile(Plots.expand_extrema!, (Plots.Subplot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any},))
-    precompile(Plots.update_child_bboxes!, (Plots.GridLayout, Array{Measures.Length{:mm, Float64}, 1},))
-    precompile(Plots.preprocessArgs!, (Base.Dict{Symbol, Any},))
-    precompile(Plots.call, (Type{Plots.Plot{Plots.PyPlotBackend}}, Plots.PyPlotBackend, Int64, Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Array{Plots.Series, 1}, Void, Array{Plots.Subplot, 1}, Base.Dict{Any, Plots.Subplot}, Plots.EmptyLayout, Array{Plots.Subplot, 1}, Bool,))
-    precompile(Plots.fix_xy_lengths!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any},))
-    precompile(Plots._update_min_padding!, (Plots.Subplot{Plots.PyPlotBackend},))
-    precompile(Plots.warnOnUnsupported_args, (Plots.PyPlotBackend, Base.Dict{Symbol, Any},))
-    precompile(Plots.build_layout, (Plots.GridLayout, Int64,))
-    precompile(Plots.build_layout, (Plots.GridLayout, Int64, Array{Plots.Plot, 1},))
-    precompile(Plots.warnOnUnsupported, (Plots.UnicodePlotsBackend, Base.Dict{Symbol, Any},))
-    precompile(Plots.link_axes!, (Plots.GridLayout, Symbol,))
-    precompile(Plots.warnOnUnsupported, (Plots.PyPlotBackend, Base.Dict{Symbol, Any},))
-    precompile(Plots._update_plot_args, (Plots.Plot{Plots.UnicodePlotsBackend}, Base.Dict{Symbol, Any},))
-    precompile(Plots.font, (Int64,))
-    precompile(Plots.recompute_lengths, (Array{Measures.Measure, 1},))
-    precompile(Plots._update_plot_object, (Plots.Plot{Plots.PyPlotBackend},))
-    precompile(Plots.font, (Symbol,))
-    precompile(Plots.create_grid, (Expr,))
-    precompile(Plots.slice_arg!, (Array{Any, 1}, Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Symbol, Void, Int64,))
-    precompile(Plots.pickDefaultBackend, ())
-    precompile(Plots.default_should_widen, (Plots.Axis,))
-    precompile(Plots.setup_atom, ())
-    precompile(Plots.slice_arg!, (Array{Any, 1}, Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Symbol, Symbol, Int64,))
-    precompile(Plots.my_hist_2d, (Array{Any, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64,))
-    precompile(Plots.slice_arg!, (Array{Any, 1}, Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Symbol, ASCIIString, Int64,))
-    precompile(Plots.create_grid_curly, (Expr,))
-    precompile(Plots.slice_arg!, (Array{Any, 1}, Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Symbol, Bool, Int64,))
-    precompile(Plots.slice_arg!, (Array{Any, 1}, Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Symbol, Int64, Int64,))
-    precompile(Plots.my_hist, (Array{Any, 1}, Array{Float64, 1}, Int64,))
-    precompile(Plots.getpctrange, (Int64,))
-    precompile(Plots.call, (Type{Plots.ColorGradient}, Array{Symbol, 1},))
-    precompile(Plots.default, (Symbol,))
-    precompile(Plots.process_axis_arg!, (Base.Dict{Symbol, Any}, Symbol, Symbol,))
-    precompile(Plots.pie_labels, (Plots.Subplot{Plots.PyPlotBackend}, Plots.Series,))
-    precompile(Plots.slice_arg!, (Array{Any, 1}, Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Symbol, Measures.Length{:mm, Float64}, Int64,))
-    precompile(Plots.py_path, (Array{Float64, 1}, Array{Float64, 1},))
-    precompile(Plots._update_min_padding!, (Plots.GridLayout,))
-    precompile(Plots.warnOnUnsupported_scales, (Plots.UnicodePlotsBackend, Base.Dict{Symbol, Any},))
-    precompile(Plots.slice_arg!, (Array{Any, 1}, Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Symbol, Plots.Font, Int64,))
-    precompile(Plots.process_axis_arg!, (Base.Dict{Symbol, Any}, Tuple{Int64, Int64}, Symbol,))
-    precompile(Plots.slice_arg!, (Array{Any, 1}, Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Symbol, Array{Any, 1}, Int64,))
-    precompile(Plots.default, (Symbol, Tuple{Int64, Int64},))
-    precompile(Plots.warnOnUnsupported_scales, (Plots.PyPlotBackend, Base.Dict{Symbol, Any},))
-    precompile(Plots.axis_limits, (Plots.Axis, Bool,))
-    precompile(Plots.default, (Symbol, Bool,))
-    precompile(Plots.getColorZ, (Plots.ColorGradient, Float64,))
-    precompile(Plots._update_plot_args, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any},))
-    precompile(Plots.call, (Type{Plots.Surface}, Function, Base.FloatRange{Float64}, Base.FloatRange{Float64},))
-    precompile(Plots.font, (Symbol,))
-    precompile(Plots.process_axis_arg!, (Base.Dict{Symbol, Any}, Base.StepRange{Int64, Int64}, Symbol,))
-    precompile(Plots.call, (Array{Any, 1}, Type{Plots.Subplot}, Plots.UnicodePlotsBackend,))
-    precompile(Plots.extractGroupArgs, (Array{ASCIIString, 1}, Array{Float64, 1},))
-    precompile(Plots._update_subplot_args, (Array{Any, 1}, Plots.Plot{Plots.UnicodePlotsBackend}, Plots.Subplot{Plots.UnicodePlotsBackend}, Base.Dict{Symbol, Any}, Int64,))
-    precompile(Plots.call, (Array{Any, 1}, Type{Plots.Subplot}, Plots.PyPlotBackend,))
-    precompile(Plots._update_subplot_args, (Array{Any, 1}, Plots.Plot{Plots.PyPlotBackend}, Plots.Subplot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Int64,))
-    precompile(Plots.extractGroupArgs, (Array{Union{UTF8String, ASCIIString}, 1},))
-    precompile(Plots.bbox_to_pcts, (Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}, Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}, Bool,))
-    precompile(Plots.plot, (Array{Any, 1}, Array{Float64, 1},))
-    precompile(Plots.py_marker, (Plots.Shape,))
-    precompile(Plots.getindex, (Plots.Subplot{Plots.UnicodePlotsBackend}, Symbol,))
-    precompile(Plots.getindex, (Plots.Subplot{Plots.PyPlotBackend}, Symbol,))
-    precompile(Plots.discrete_value!, (Plots.Axis, Array{Union{UTF8String, ASCIIString}, 1},))
-    precompile(Plots.prepare_output, (Plots.Plot{Plots.PyPlotBackend},))
-    precompile(Plots.update_inset_bboxes!, (Plots.Plot{Plots.PyPlotBackend},))
-    precompile(Plots.add_layout_pct!, (Base.Dict{Symbol, Any}, Expr, Int64, Int64,))
-    precompile(Plots.process_axis_arg!, (Base.Dict{Symbol, Any}, ASCIIString, Symbol,))
-    precompile(Plots.call, (Type{Plots.Shape}, Array{Float64, 1}, Array{Float64, 1},))
-    precompile(Plots.plot, (Array{Any, 1}, Base.LinSpace{Float64}, Array{Float64, 2},))
-    precompile(Plots.call, (Array{Any, 1}, Type{Plots.EmptyLayout}, Plots.RootLayout,))
-    precompile(Plots.plot, (Array{Any, 1}, Function, Function,))
-    precompile(Plots.should_add_to_legend, (Plots.Series,))
-    precompile(Plots.plot, (Array{Any, 1}, DataFrames.DataFrame, Symbol,))
-    precompile(Plots.plot, (Array{Any, 1}, Array{Plots.OHLC, 1},))
-    precompile(Plots.convertToAnyVector, (Array{Float64, 2}, Base.Dict{Symbol, Any},))
-    precompile(Plots.plot, (Array{Any, 1}, Array{Float64, 1}, Array{Float64, 1},))
-    precompile(Plots.plot, (Array{Any, 1}, Array{ASCIIString, 1}, Array{Float64, 1},))
-    precompile(Plots.plot!, (Array{Any, 1}, Plots.Plot{Plots.PyPlotBackend}, Array{Float64, 1},))
-    precompile(Plots.processLineArg, (Base.Dict{Symbol, Any}, Symbol,))
-    precompile(Plots.aliasesAndAutopick, (Base.Dict{Symbol, Any}, Symbol, Base.Dict{Symbol, Any}, Array{Symbol, 1}, Int64,))
-    precompile(Plots.plot!, (Array{Any, 1}, Plots.Plot{Plots.PyPlotBackend}, Array{Int64, 1},))
-    precompile(Plots.pie, (Array{Any, 1}, Array{ASCIIString, 1},))
-    precompile(Plots.aliasesAndAutopick, (Base.Dict{Symbol, Any}, Symbol, Base.Dict{Symbol, Any}, Array{Any, 1}, Int64,))
-    precompile(Plots.merge_with_base_supported, (Array{Symbol, 1},))
-    precompile(Plots.histogram2d, (Array{Any, 1}, Array{Float64, 1},))
-    precompile(Plots.plot, (Array{Any, 1}, Base.StepRange{Int64, Int64}, Array{Float64, 2},))
-    precompile(Plots.plot, (Array{Any, 1}, Base.LinSpace{Float64}, Array{Float64, 1},))
-    precompile(Plots.plot, (Array{Any, 1}, Array{Float64, 1}, Array{Float64, 1},))
-    precompile(Plots.font, ())
-    precompile(Plots.plot, (Array{Any, 1}, Base.FloatRange{Float64}, Array{Float64, 1},))
-    precompile(Plots.plot, (Array{Any, 1}, Base.FloatRange{Float64}, Base.FloatRange{Float64},))
-    precompile(Plots.plot, (Array{Any, 1}, Array{Function, 1}, Array{Float64, 1},))
-    precompile(Plots.scatter, (Array{Any, 1}, Base.LinSpace{Float64},))
-    precompile(Plots.plot!, (Array{Any, 1}, Plots.Plot{Plots.PyPlotBackend}, Base.LinSpace{Float64},))
-    precompile(Plots.plot!, (Array{Any, 1}, Base.LinSpace{Float64}, Array{Float64, 1},))
-    precompile(Plots.get_zvalues, (Int64,))
-    precompile(Plots.plot, (Array{Any, 1}, Array{Union{UTF8String, ASCIIString}, 1}, Array{Union{UTF8String, ASCIIString}, 1},))
-    precompile(Plots.histogram, (Array{Any, 1}, Array{Float64, 1},))
-    precompile(Plots.hline!, (Array{Any, 1}, Array{Float64, 2},))
-    precompile(Plots.layout_args, (Base.Dict{Symbol, Any}, Int64,))
-    precompile(Plots.heatmap, (Array{Any, 1}, Array{Union{UTF8String, ASCIIString}, 1},))
-    precompile(Plots._replace_linewidth, (Base.Dict{Symbol, Any},))
-    precompile(Plots.plot!, (Array{Any, 1}, Array{Float64, 1}, Array{Float64, 1},))
-    precompile(Plots.plot!, (Array{Any, 1}, Plots.Plot{Plots.PyPlotBackend}, Array{Float64, 2},))
-    precompile(Plots.py_markercolor, (Base.Dict{Symbol, Any},))
-    precompile(Plots.unzip, (Array{Tuple{Float64, Float64}, 1},))
-    precompile(Plots.link_axes!, (Array{Plots.AbstractLayout, 2}, Symbol,))
-    precompile(Plots.plot!, (Array{Any, 1}, Plots.Plot{Plots.PyPlotBackend}, Array{Float64, 1},))
-    precompile(Plots.contour, (Array{Any, 1}, Base.FloatRange{Float64},))
-    precompile(Plots.scatter, (Array{Any, 1}, DataFrames.DataFrame,))
-    precompile(Plots.scatter!, (Array{Any, 1}, Base.LinSpace{Float64},))
-    precompile(Plots.scatter!, (Array{Any, 1}, Array{Float64, 1},))
-    precompile(Plots.getxy, (Plots.Plot{Plots.PyPlotBackend}, Int64,))
-    precompile(Plots.plot, (Array{Any, 1}, Array{Float64, 2},))
-    precompile(Plots.get_xy, (Array{Plots.OHLC, 1}, Base.UnitRange{Int64},))
-    precompile(Plots.convertToAnyVector, (Array{Function, 1}, Base.Dict{Symbol, Any},))
-    precompile(Plots.py_add_annotations, (Plots.Subplot{Plots.PyPlotBackend}, Int64, Float64, Plots.PlotText,))
-    precompile(Plots.plot!, (Array{Any, 1}, Array{Float64, 1},))
-    precompile(Plots.get_color_palette, (Symbol, ColorTypes.RGB{Float64}, Int64,))
-    precompile(Plots.py_add_annotations, (Plots.Subplot{Plots.PyPlotBackend}, Float64, Float64, Plots.PlotText,))
-    precompile(Plots.py_colormap, (Plots.ColorGradient, Float64,))
-    precompile(Plots.processMarkerArg, (Base.Dict{Symbol, Any}, Plots.Stroke,))
-    precompile(Plots.call, (Type{Plots.ColorVector}, Array{Symbol, 1},))
-    precompile(Plots.py_colormap, (Plots.ColorGradient, Void,))
-    precompile(Plots.py_fillcolor, (Base.Dict{Symbol, Any},))
-    precompile(Plots.processLineArg, (Base.Dict{Symbol, Any}, Float64,))
-    precompile(Plots.plot!, (Array{Any, 1}, Array{Float64, 2},))
-    precompile(Plots.processMarkerArg, (Base.Dict{Symbol, Any}, Symbol,))
-    precompile(Plots.call, (Type{Plots.Plot},))
-    precompile(Plots.call, (Type{Plots.ColorGradient}, Array{ColorTypes.RGBA{Float64}, 1},))
-    precompile(Plots.plot!, (Array{Any, 1}, Array{Int64, 1},))
-    precompile(Plots.getExtension, (UTF8String,))
-    precompile(Plots.call, (Array{Any, 1}, Type{Plots.EmptyLayout},))
-    precompile(Plots.update!, (Array{Any, 1}, Plots.Axis,))
-    precompile(Plots.frame, (Plots.Animation, Plots.Plot{Plots.PyPlotBackend},))
-    precompile(Plots.processMarkerArg, (Base.Dict{Symbol, Any}, Int64,))
-    precompile(Plots.link_axes!, (Array{Plots.AbstractLayout, 1}, Symbol,))
-    precompile(Plots.call, (Type{Plots.ColorGradient}, Array{ColorTypes.RGB{Float64}, 1},))
-    precompile(Plots.fakedata, (Int64,))
-    precompile(Plots.plot!, (Array{Any, 1}, Plots.Plot{Plots.PyPlotBackend},))
-    precompile(Plots.py_compute_axis_minval, (Plots.Axis,))
-    precompile(Plots.processLineArg, (Base.Dict{Symbol, Any}, Int64,))
-    precompile(Plots.command_idx, (Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any},))
-    precompile(Plots.getindex, (Plots.Axis, Symbol,))
-    precompile(Plots.__init__, ())
-    precompile(Plots.isvertical, (Base.Dict{Symbol, Any},))
-    precompile(Plots.getExtension, (ASCIIString,))
-    precompile(Plots.py_marker, (Symbol,))
-    precompile(Plots.py_init_subplot, (Plots.Plot{Plots.PyPlotBackend}, Plots.Subplot{Plots.PyPlotBackend},))
-    precompile(Plots.processMarkerArg, (Base.Dict{Symbol, Any}, ColorTypes.RGBA{Float64},))
-    precompile(Plots.bucket_index, (Float64, Base.LinSpace{Float64},))
-    precompile(Plots.default, (Array{Any, 1},))
-    precompile(Plots.filter_data!, (Base.Dict{Symbol, Any}, Array{Int64, 1},))
-    precompile(Plots.call, (Type{Plots.ColorGradient}, Array{Symbol, 1}, Base.LinSpace{Float64},))
-    precompile(Plots.slice_arg, (Array{Symbol, 2}, Int64,))
-    precompile(Plots.getindex, (Plots.Plot{Plots.UnicodePlotsBackend}, Symbol,))
-    precompile(Plots.plot!, (Array{Any, 1},))
-    precompile(Plots.push!, (Plots.Plot{Plots.PyPlotBackend}, Array{Float64, 1}, Array{Float64, 1},))
-    precompile(Plots.processMarkerArg, (Base.Dict{Symbol, Any}, Float64,))
-    precompile(Plots.expand_extrema!, (Plots.Axis, Base.FloatRange{Float64},))
-    precompile(Plots.getindex, (Plots.Plot{Plots.PyPlotBackend}, Symbol,))
-    precompile(Plots.handle_dfs, (DataFrames.DataFrame, Base.Dict{Symbol, Any}, ASCIIString, Symbol,))
-    precompile(Plots.filter_data, (Base.UnitRange{Int64}, Array{Int64, 1},))
-    precompile(Plots.call, (Type{Plots.ColorWrapper}, ColorTypes.RGBA{Float64},))
-    precompile(Plots.processMarkerArg, (Base.Dict{Symbol, Any}, Array{Symbol, 2},))
-    precompile(Plots.processLineArg, (Base.Dict{Symbol, Any}, Array{Symbol, 2},))
-    precompile(Plots.color_or_nothing!, (Base.Dict{Symbol, Any}, Symbol,))
-    precompile(Plots.processMarkerArg, (Base.Dict{Symbol, Any}, Plots.Shape,))
-    precompile(Plots.py_fillcolormap, (Base.Dict{Symbol, Any},))
-    precompile(Plots.transpose_z, (Base.Dict{Symbol, Any}, Array{Float64, 2}, Bool,))
-    precompile(Plots.py_linecolor, (Base.Dict{Symbol, Any},))
-    precompile(Plots.call, (Type{Plots.OHLC}, Float64, Float64, Float64, Float64,))
-    precompile(Plots.setxy!, (Plots.Plot{Plots.PyPlotBackend}, Tuple{Array{Float64, 1}, Array{Float64, 1}}, Int64,))
-    precompile(Plots.push!, (Plots.Segments, Float64, Float64, Float64, Float64,))
-    precompile(Plots.handle_group, (DataFrames.DataFrame, Base.Dict{Symbol, Any},))
-    precompile(Plots.lightness_from_background, (ColorTypes.RGB{Float64},))
-    precompile(Plots.expand_extrema!, (Plots.Axis, Base.LinSpace{Float64},))
-    precompile(Plots.py_bbox, (Array{Any, 1},))
-    precompile(Plots.py_markerstrokecolor, (Base.Dict{Symbol, Any},))
-    precompile(Plots.arrow, ())
-    precompile(Plots.convert, (Type{Array{Float64, 1}}, Base.StepRange{Int64, Int64},))
-    precompile(Plots.expand_extrema!, (Plots.Axis, Array{Float64, 1},))
-    precompile(Plots.convertLegendValue, (Symbol,))
-    precompile(Plots.slice_arg, (Array{Measures.Length{:mm, Float64}, 2}, Int64,))
-    precompile(Plots.calc_num_subplots, (Plots.GridLayout,))
-    precompile(Plots.processFillArg, (Base.Dict{Symbol, Any}, Int64,))
-    precompile(Plots.slice_arg, (Array{Plots.ColorWrapper, 2}, Int64,))
-    precompile(Plots.slice_arg, (Array{ASCIIString, 2}, Int64,))
-    precompile(Plots.filter_data, (Array{Float64, 1}, Array{Int64, 1},))
-    precompile(Plots.py_linecolormap, (Base.Dict{Symbol, Any},))
-    precompile(Plots.discrete_value!, (Plots.Axis, ASCIIString,))
-    precompile(Plots.allShapes, (ColorTypes.RGBA{Float64},))
-    precompile(Plots.expand_extrema!, (Plots.Axis, Array{Int64, 1},))
-    precompile(Plots.py_color_fix, (Tuple{Float64, Float64, Float64, Float64}, Base.LinSpace{Float64},))
-    precompile(Plots.discrete_value!, (Plots.Axis, Symbol,))
-    precompile(Plots.push!, (Plots.Segments, Float64, Int64, Int64, Float64,))
-    precompile(Plots.expand_extrema!, (Plots.Axis, Plots.Surface{Array{Float64, 2}},))
-    precompile(Plots.heatmap_edges, (Array{Float64, 1},))
-    precompile(Plots.expand_extrema!, (Plots.Axis, Base.StepRange{Int64, Int64},))
-    precompile(Plots.handleColors!, (Base.Dict{Symbol, Any}, Plots.Shape, Symbol,))
-    precompile(Plots.py_color, (Plots.ColorWrapper, Float64,))
-    precompile(Plots.call, (Type{Plots.GridLayout}, Int64, Int64,))
-    precompile(Plots.handleColors!, (Base.Dict{Symbol, Any}, ColorTypes.RGBA{Float64}, Symbol,))
-    precompile(Plots.handleColors!, (Base.Dict{Symbol, Any}, Bool, Symbol,))
-    precompile(Plots.hvline_limits, (Plots.Axis,))
-    precompile(Plots.current, ())
-    precompile(Plots.handleColors!, (Base.Dict{Symbol, Any}, Float64, Symbol,))
-    precompile(Plots.compute_gridsize, (Int64, Int64, Int64,))
-    precompile(Plots.py_color, (ColorTypes.RGB{Float64}, Void,))
-    precompile(Plots.interpolate_rgb, (ColorTypes.RGBA{Float64}, ColorTypes.RGBA{Float64}, Float64,))
-    precompile(Plots.expand_extrema!, (Plots.Axis, Base.UnitRange{Int64},))
-    precompile(Plots.allShapes, (Float64,))
-    precompile(Plots.warn_on_deprecated_backend, (Symbol,))
-    precompile(Plots.py_color_fix, (Tuple{Float64, Float64, Float64, Float64}, Array{Int64, 1},))
-    precompile(Plots.setindex!, (Plots.GridLayout, Plots.EmptyLayout, Int64, Int64,))
-    precompile(Plots.expand_extrema!, (Plots.Axis, Tuple{Int64, Int64},))
-    precompile(Plots.allShapes, (Int64,))
-    precompile(Plots.py_markercolormap, (Base.Dict{Symbol, Any},))
-    precompile(Plots.interpolate_rgb, (ColorTypes.RGB{Float64}, ColorTypes.RGB{Float64}, Float64,))
-    precompile(Plots.get_ticks, (Plots.Axis,))
-    precompile(Plots.backend, ())
-    precompile(Plots.get_xy, (Plots.OHLC{Float64}, Int64, Float64,))
-    precompile(Plots.allShapes, (Plots.Stroke,))
-    precompile(Plots.replaceAliases!, (Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any},))
-    precompile(Plots._create_backend_figure, (Plots.Plot{Plots.PyPlotBackend},))
-    precompile(Plots.png, (Plots.Plot{Plots.PyPlotBackend}, UTF8String,))
-    precompile(Plots.processFillArg, (Base.Dict{Symbol, Any}, Symbol,))
-    precompile(Plots.allShapes, (Plots.Shape,))
-    precompile(Plots.handleColors!, (Base.Dict{Symbol, Any}, Plots.Stroke, Symbol,))
-    precompile(Plots.py_color_fix, (Tuple{Float64, Float64, Float64, Float64}, Array{Float64, 1},))
-    precompile(Plots.plot, (Array{Float64, 1},))
-    precompile(Plots.rowsize, (Expr,))
-    precompile(Plots.get_axis, (Plots.Subplot{Plots.PyPlotBackend}, Symbol,))
-    precompile(Plots.png, (Plots.Plot{Plots.PyPlotBackend}, ASCIIString,))
-    precompile(Plots.expand_extrema!, (Plots.Axis, Tuple{Float64, Float64},))
-    precompile(Plots._markershape_supported, (Plots.PyPlotBackend, Plots.Shape,))
-    precompile(Plots.processFillArg, (Base.Dict{Symbol, Any}, Bool,))
-    precompile(Plots.supported_types, (Plots.PyPlotBackend,))
-    precompile(Plots.get_axis, (Plots.Subplot{Plots.UnicodePlotsBackend}, Symbol,))
-    precompile(Plots.setindex!, (Plots.GridLayout, Plots.GridLayout, Int64, Int64,))
-    precompile(Plots.plot, ())
-    precompile(Plots.py_color_fix, (Tuple{Float64, Float64, Float64, Float64}, Base.FloatRange{Float64},))
-    precompile(Plots._markershape_supported, (Plots.PyPlotBackend, Symbol,))
-    precompile(Plots.ok, (Float64, Float64, Int64,))
-    precompile(Plots.allShapes, (Symbol,))
-    precompile(Plots._initialize_backend, (Plots.PyPlotBackend,))
-    precompile(Plots.plot, (Plots.Plot{Plots.PyPlotBackend}, Plots.Plot{Plots.PyPlotBackend},))
-    precompile(Plots.bar, (Array{Float64, 1},))
-    precompile(Plots.call, (Type{Plots.ColorGradient}, Array{ColorTypes.RGBA{Float64}, 1}, Base.LinSpace{Float64},))
-    precompile(Plots.handleColors!, (Base.Dict{Symbol, Any}, Int64, Symbol,))
-    precompile(Plots.nanappend!, (Array{Float64, 1}, Array{Float64, 1},))
-    precompile(Plots.autopick, (Array{ColorTypes.RGBA, 1}, Int64,))
-    precompile(Plots.compute_xyz, (Void, Array{Int64, 1}, Void,))
-    precompile(Plots._add_markershape, (Base.Dict{Symbol, Any},))
-    precompile(Plots._backend_instance, (Symbol,))
-    precompile(Plots.py_color, (ColorTypes.RGBA{Float64}, Float64,))
-    precompile(Plots.update_child_bboxes!, (Plots.GridLayout,))
-    precompile(Plots._replace_markershape, (Symbol,))
-    precompile(Plots.has_black_border_for_default, (Symbol,))
-    precompile(Plots._filter_input_data!, (Base.Dict{Symbol, Any},))
-    precompile(Plots.compute_xyz, (Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64},))
-    precompile(Plots.text, (ASCIIString, Int64, Symbol,))
-    precompile(Plots.allShapes, (Array{Symbol, 2},))
-    precompile(Plots.py_color_fix, (Tuple{Float64, Float64, Float64, Float64}, Base.UnitRange{Int64},))
-    precompile(Plots.replaceAlias!, (Base.Dict{Symbol, Any}, Symbol, Base.Dict{Symbol, Any},))
-    precompile(Plots.compute_xyz, (Array{ASCIIString, 1}, Array{Float64, 1}, Void,))
-    precompile(Plots.layout_args, (Int64,))
-    precompile(Plots.text, (ASCIIString, Symbol, Int64,))
-    precompile(Plots.compute_xyz, (Base.FloatRange{Float64}, Base.FloatRange{Float64}, Plots.Surface{Array{Float64, 2}},))
-    precompile(Plots.all3D, (Base.Dict{Symbol, Any},))
-    precompile(Plots.cycle, (Array{Plots.Subplot, 1}, Int64,))
-    precompile(Plots.compute_xyz, (Base.StepRange{Int64, Int64}, Array{Float64, 1}, Void,))
-    precompile(Plots.plotarea!, (Plots.Subplot{Plots.PyPlotBackend}, Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}},))
-    precompile(Plots.like_surface, (Symbol,))
-    precompile(Plots.build_layout, (Base.Dict{Symbol, Any},))
-    precompile(Plots.compute_xyz, (Array{Union{UTF8String, ASCIIString}, 1}, Array{Union{UTF8String, ASCIIString}, 1}, Plots.Surface{Array{Float64, 2}},))
-    precompile(Plots.py_linestyle, (Symbol, Symbol,))
-    precompile(Plots.plot!, (Array{Float64, 2},))
-    precompile(Plots.plot!, (Plots.Plot{Plots.PyPlotBackend}, Array{Float64, 2},))
-    precompile(Plots.call, (Type{Plots.ColorGradient}, Array{ColorTypes.RGB{Float64}, 1}, Base.LinSpace{Float64},))
-    precompile(Plots.py_color, (ColorTypes.RGBA{Float64}, Void,))
-    precompile(Plots.yaxis!, (ASCIIString, Symbol,))
-    precompile(Plots.compute_xyz, (Base.LinSpace{Float64}, Array{Float64, 1}, Void,))
-    precompile(Plots.isijulia, ())
-    precompile(Plots.addExtension, (UTF8String, ASCIIString,))
-    precompile(Plots.call, (Type{Plots.ColorGradient}, Array{ColorTypes.RGBA{Float64}, 1}, Array{Float64, 1},))
-    precompile(Plots.expand_extrema!, (Plots.Subplot{Plots.PyPlotBackend}, Float64, Float64, Float64, Float64,))
-    precompile(Plots.plotarea!, (Plots.GridLayout, Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}},))
-    precompile(Plots.layout_args, (Base.Dict{Symbol, Any},))
-    precompile(Plots.compute_xyz, (Base.FloatRange{Float64}, Array{Float64, 1}, Void,))
-    precompile(Plots.addExtension, (ASCIIString, ASCIIString,))
-    precompile(Plots.handleColors!, (Base.Dict{Symbol, Any}, Symbol, Symbol,))
-    precompile(Plots._initialize_backend, (Plots.PlotlyBackend,))
-    precompile(Plots.push!, (Plots.Plot{Plots.PyPlotBackend}, Int64, Float64, Float64,))
-    precompile(Plots.bbox!, (Plots.Subplot{Plots.PyPlotBackend}, Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}},))
-    precompile(Plots.vline!, (Array{Int64, 1},))
-    precompile(Plots.supported_markers, (Plots.PyPlotBackend,))
-    precompile(Plots.bbox!, (Plots.GridLayout, Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}},))
-    precompile(Plots.stroke, (Int64,))
-    precompile(Plots.compute_xyz, (Array{Float64, 1}, Array{Float64, 1}, Void,))
-    precompile(Plots.right, (Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}},))
-    precompile(Plots.extractGroupArgs, (Symbol, DataFrames.DataFrame, Symbol,))
-    precompile(Plots.generate_colorgradient, (ColorTypes.RGB{Float64},))
-    precompile(Plots.expand_extrema!, (Plots.Extrema, Bool,))
-    precompile(Plots.py_colormap, (Plots.ColorWrapper, Void,))
-    precompile(Plots.expand_extrema!, (Plots.Extrema, Float64,))
-    precompile(Plots.contour, (Base.FloatRange{Float64},))
-    precompile(Plots.bottom, (Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}},))
-    precompile(Plots.text, (ASCIIString, Symbol,))
-    precompile(Plots.create_grid, (Symbol,))
-    precompile(Plots.expand_extrema!, (Plots.Axis, Bool,))
-    precompile(Plots.handleColors!, (Base.Dict{Symbol, Any}, Array{Symbol, 2}, Symbol,))
-    precompile(Plots.convertToAnyVector, (Void, Base.Dict{Symbol, Any},))
-    precompile(Plots.py_dpi_scale, (Plots.Plot{Plots.PyPlotBackend}, Int64,))
-    precompile(Plots.png, (ASCIIString,))
-    precompile(Plots.supported_scales, (Plots.PyPlotBackend,))
-    precompile(Plots.convertColor, (ColorTypes.RGBA{Float64}, Float64,))
-    precompile(Plots.extendSeriesData, (Array{Float64, 1}, Float64,))
-    precompile(Plots.compute_xyz, (Void, Array{Float64, 1}, Void,))
-    precompile(Plots.py_color, (Symbol,))
-    precompile(Plots.expand_extrema!, (Plots.Extrema, Int64,))
-    precompile(Plots.supported_styles, (Plots.PyPlotBackend,))
-    precompile(Plots._initialize_backend, (Plots.UnicodePlotsBackend,))
-    precompile(Plots._initialize_backend, (Plots.GRBackend,))
-    precompile(Plots.is3d, (Symbol,))
-    precompile(Plots.supported_types, (Plots.UnicodePlotsBackend,))
-    precompile(Plots.compute_xyz, (Array{Float64, 1}, Function, Void,))
-    precompile(Plots.py_color, (Symbol, Void,))
-    precompile(Plots.trueOrAllTrue, (Function, Array{Symbol, 2},))
-    precompile(Plots.typemin, (Measures.Length{:mm, Float64},))
-    precompile(Plots.expand_extrema!, (Plots.Axis, Float64,))
-    precompile(Plots.get_subplot_index, (Plots.Plot{Plots.UnicodePlotsBackend}, Plots.Subplot{Plots.UnicodePlotsBackend},))
-    precompile(Plots.leftpad, (Plots.GridLayout,))
-    precompile(Plots._update_subplot_args, (Plots.Plot{Plots.UnicodePlotsBackend}, Plots.Subplot{Plots.UnicodePlotsBackend}, Base.Dict{Symbol, Any}, Int64,))
-    precompile(Plots.centers, (Base.LinSpace{Float64},))
-    precompile(Plots.expand_extrema!, (Plots.Axis, Int64,))
-    precompile(Plots.text, (ASCIIString,))
-    precompile(Plots.convertColor, (ColorTypes.RGB{Float64},))
-    precompile(Plots.py_color, (Plots.ColorWrapper, Void,))
-    precompile(Plots.py_color, (Plots.ColorWrapper,))
-    precompile(Plots.trueOrAllTrue, (Function, Int64,))
-    precompile(Plots.convertColor, (ColorTypes.RGBA{Float64},))
-    precompile(Plots.extrema, (Plots.Axis,))
-    precompile(Plots.top, (Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}},))
-    precompile(Plots.convertColor, (Symbol,))
-    precompile(Plots.size, (Plots.Surface{Array{Float64, 2}},))
-    precompile(Plots.isdark, (ColorTypes.RGB{Float64},))
-    precompile(Plots.rowsize, (Symbol,))
-    precompile(Plots.series_list, (Plots.Subplot{Plots.PyPlotBackend},))
-    precompile(Plots.convertToAnyVector, (Array{Float64, 1}, Base.Dict{Symbol, Any},))
-    precompile(Plots.update!, (Plots.Axis,))
-    precompile(Plots.push!, (Plots.Plot{Plots.PyPlotBackend}, Float64, Array{Float64, 1},))
-    precompile(Plots.wraptuple, (Bool,))
-    precompile(Plots.call, (Type{Plots.Shape}, Array{Tuple{Float64, Float64}, 1},))
-    precompile(Plots.slice_arg, (Base.StepRange{Int64, Int64}, Int64,))
-    precompile(Plots.sticks_fillfrom, (Void, Int64,))
-    precompile(Plots.left, (Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}},))
-    precompile(Plots.gr, ())
-    precompile(Plots.leftpad, (Plots.Subplot{Plots.PyPlotBackend},))
-    precompile(Plots.supported_markers, ())
-    precompile(Plots.colorscheme, (Symbol,))
-    precompile(Plots.convertColor, (ColorTypes.RGB{Float64}, Void,))
-    precompile(Plots.isscalar, (Int64,))
-    precompile(Plots.wraptuple, (Int64,))
-    precompile(Plots.call, (Type{Plots.Plot}, Plots.UnicodePlotsBackend, Int64, Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Array{Plots.Series, 1}, Void, Array{Plots.Subplot, 1}, Base.Dict{Any, Plots.Subplot}, Plots.EmptyLayout, Array{Plots.Subplot, 1}, Bool,))
-    precompile(Plots.supported_styles, ())
-    precompile(Plots.frame, (Plots.Animation,))
-    precompile(Plots.toppad, (Plots.Subplot{Plots.PyPlotBackend},))
-    precompile(Plots.link_axes!, (Plots.Subplot{Plots.UnicodePlotsBackend}, Symbol,))
-    precompile(Plots.convertLegendValue, (Bool,))
-    precompile(Plots.convertColor, (ColorTypes.RGBA{Float64}, Void,))
-    precompile(Plots.plotly, ())
-    precompile(Plots.ispositive, (Measures.Length{:mm, Float64},))
-    precompile(Plots.rightpad, (Plots.Subplot{Plots.PyPlotBackend},))
-    precompile(Plots.call, (Type{Plots.GroupBy}, Array{ASCIIString, 1}, Array{Array{Int64, 1}, 1},))
-    precompile(Plots.px2inch, (Int64,))
-    precompile(Plots.slice_arg, (Tuple{Int64, Int64}, Int64,))
-    precompile(Plots.call, (Type{Plots.UnicodePlotsBackend},))
-    precompile(Plots.trueOrAllTrue, (Function, Symbol,))
-    precompile(Plots.bottompad, (Plots.Subplot{Plots.PyPlotBackend},))
-    precompile(Plots.annotate!, (Array{Tuple{Int64, Float64, Plots.PlotText}, 1},))
-    precompile(Plots.get_subplot_index, (Plots.Plot{Plots.PyPlotBackend}, Plots.Subplot{Plots.PyPlotBackend},))
-    precompile(Plots.call, (Type{Plots.Plot}, Plots.PyPlotBackend, Int64, Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Array{Plots.Series, 1}, Void, Array{Plots.Subplot, 1}, Base.Dict{Any, Plots.Subplot}, Plots.EmptyLayout, Array{Plots.Subplot, 1}, Bool,))
-    precompile(Plots.title!, (ASCIIString,))
-    precompile(Plots.slice_arg, (Bool, Int64,))
-    precompile(Plots.wraptuple, (Float64,))
-    precompile(Plots.bottompad, (Plots.GridLayout,))
-    precompile(Plots.py_stepstyle, (Symbol,))
-    precompile(Plots.link_axes!, (Plots.Subplot{Plots.PyPlotBackend}, Symbol,))
-    precompile(Plots.call, (Type{Plots.GRBackend},))
-    precompile(Plots.unicodeplots, ())
-    precompile(Plots.rightpad, (Plots.GridLayout,))
-    precompile(Plots.call, (Type{Plots.PlotlyBackend},))
-    precompile(Plots.py_color, (ColorTypes.RGBA{Float64},))
-    precompile(Plots.toppad, (Plots.GridLayout,))
-    precompile(Plots.calc_edges, (Array{Float64, 1}, Int64,))
-    precompile(Plots.colorscheme, (ColorTypes.RGBA{Float64},))
-    precompile(Plots.slice_arg, (Int64, Int64,))
-    precompile(Plots.pyplot, ())
-    precompile(Plots._update_subplot_args, (Plots.Plot{Plots.PyPlotBackend}, Plots.Subplot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Int64,))
-    precompile(Plots._series_added, (Plots.Plot{Plots.PyPlotBackend}, Plots.Series,))
-    precompile(Plots.get_color_palette, (Array{ColorTypes.RGBA, 1}, ColorTypes.RGB{Float64}, Int64,))
-    precompile(Plots._initialize_subplot, (Plots.Plot{Plots.UnicodePlotsBackend}, Plots.Subplot{Plots.UnicodePlotsBackend},))
-    precompile(Plots.slice_arg, (Void, Int64,))
-    precompile(Plots.cycle, (Int64, Int64,))
-    precompile(Plots._initialize_subplot, (Plots.Plot{Plots.PyPlotBackend}, Plots.Subplot{Plots.PyPlotBackend},))
-    precompile(Plots.call, (Type{Plots.PyPlotBackend},))
-    precompile(Plots.update_child_bboxes!, (Plots.Subplot{Plots.PyPlotBackend}, Array{Measures.Length{:mm, Float64}, 1},))
-    precompile(Plots.filter_data, (Void, Array{Int64, 1},))
-    precompile(Plots.slice_arg, (Symbol, Int64,))
-    precompile(Plots.slice_arg, (ASCIIString, Int64,))
-    precompile(Plots.layout_args, (Plots.GridLayout,))
-    precompile(Plots.wraptuple, (Tuple{},))
-    precompile(Plots.calc_num_subplots, (Plots.EmptyLayout,))
-    precompile(Plots.wraptuple, (Tuple{Symbol, Float64, Plots.Stroke},))
-    precompile(Plots.wraptuple, (Tuple{ASCIIString, Tuple{Int64, Int64}, Base.StepRange{Int64, Int64}, Symbol},))
-    precompile(Plots.wraptuple, (Tuple{Int64, Symbol, Float64, Array{Symbol, 2}},))
-    precompile(Plots.wraptuple, (Tuple{Int64, Array{Symbol, 2}},))
-    precompile(Plots.wraptuple, (Tuple{ASCIIString, Symbol},))
-    precompile(Plots._replace_markershape, (Array{Symbol, 2},))
-    precompile(Plots.wraptuple, (Tuple{Symbol, Int64},))
-    precompile(Plots.wraptuple, (Tuple{Array{Symbol, 2}, Int64},))
-    precompile(Plots.wraptuple, (Tuple{Int64, Symbol, Symbol},))
-    precompile(Plots.wraptuple, (Tuple{Int64, Float64, Symbol, Plots.Stroke},))
-    precompile(Plots.wraptuple, (Tuple{Float64, Array{Symbol, 2}, Int64},))
-    precompile(Plots.py_color, (ColorTypes.RGB{Float64},))
-    precompile(Plots.wraptuple, (Tuple{Int64, Float64, Symbol},))
-    precompile(Plots.tovec, (Array{Float64, 1},))
-    precompile(Plots.get_subplot, (Plots.Plot{Plots.PyPlotBackend}, Plots.Subplot{Plots.PyPlotBackend},))
-    precompile(Plots.eltype, (Plots.Surface{Array{Float64, 2}},))
-    precompile(Plots.nobigs, (Array{Float64, 1},))
-    precompile(Plots.get_subplot, (Plots.Plot{Plots.UnicodePlotsBackend}, Plots.Subplot{Plots.UnicodePlotsBackend},))
-    precompile(Plots.annotations, (Array{Any, 1},))
-    precompile(Plots.wraptuple, (Tuple{Int64, Symbol},))
-    precompile(Plots.colorscheme, (Plots.ColorWrapper,))
-    precompile(Plots.colorscheme, (Plots.ColorGradient,))
-    precompile(Plots.text, (Plots.PlotText,))
-    precompile(Plots._replace_markershape, (Plots.Shape,))
-    precompile(Plots.wraptuple, (Tuple{Array{Symbol, 2}, Int64, Float64, Plots.Stroke},))
-    precompile(Plots.wraptuple, (Tuple{Plots.Shape, Int64, ColorTypes.RGBA{Float64}},))
 end
@@ -0,0 +1,534 @@
+
+
+# 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(d::KW) = trueOrAllTrue(st -> st in (:contour, :contourf, :heatmap, :surface, :wireframe, :contour3d, :image), get(d, :seriestype, :none))
+
+# missing
+convertToAnyVector(v::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<: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
+
+# volume
+convertToAnyVector(v::Volume, d::KW) = Any[v], 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{F<:Function}(x::Void, y::FuncOrFuncs{F}, z)       = error("If you want to plot the function `$y`, you need to define the x values!")
+compute_xyz{F<:Function}(x::Void, y::Void, z::FuncOrFuncs{F}) = 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!")
+
+# --------------------------------------------------------------------
+
+
+# we are going to build recipes to do the processing and splitting of the args
+
+# ensure we dispatch to the slicer
+immutable 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, 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)
+    if mx > 0 && my > 0 && mz > 0
+        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)]
+            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
+
+            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{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 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(d, v::AbstractArray)
+    args = RecipesBase.apply_recipe(d, typeof(v[1]), v[1])[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(d, v::Surface)
+#     T = eltype(v.surf)
+#     @show T
+#     if T <: Integer || T <: AbstractFloat
+#         v
+#     else
+#         ret = _apply_type_recipe(d, 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{T<:Union{Integer,AbstractFloat}}(d, v::AbstractArray{T}) = 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(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
+# # --------------------------------------------------------------------
+
+# helper function to ensure relevant attributes are wrapped by Surface
+function wrap_surfaces(d::KW)
+    if haskey(d, :fill_z)
+        v = d[:fill_z]
+        if !isa(v, Surface)
+            d[:fill_z] = Surface(v)
+        end
+    end
+end
+
+@recipe f(n::Integer) = is3d(get(d,: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{T<:Union{Integer,AbstractFloat}}(mat::AMat{T})
+    if all3D(d)
+        n,m = size(mat)
+        wrap_surfaces(d)
+        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{T<:AbstractMatrix}(fmt::Formatted{T})
+    if all3D(d)
+        mat = fmt.data
+        n,m = size(mat)
+        wrap_surfaces(d)
+        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{T<:Number}(vol::AbstractArray{T,3}, args...)
+    seriestype := :volume
+    SliceIt, nothing, Volume(vol, args...), nothing
+end
+
+
+# # images - grays
+
+@recipe function f{T<:Gray}(mat::AMat{T})
+    if is_seriestype_supported(:image)
+        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})
+	n, m = size(mat)
+
+    if is_seriestype_supported(:image)
+        seriestype := :image
+        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
+    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<:Function}(f::FuncOrFuncs{F})
+    plt = d[:plot_object]
+    xmin, xmax = try
+        axis_limits(plt[1][:xaxis])
+    catch
+        -5, 5
+    end
+    f, xmin, xmax
+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<:Function}(f::FuncOrFuncs{F}, x)
+    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(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
+    wrap_surfaces(d)
+    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(d)
+    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
+    wrap_surfaces(d)
+    SliceIt, x, y, Surface(z)
+end
+
+#
+#
+# # --------------------------------------------------------------------
+# # Parametric functions
+# # --------------------------------------------------------------------
+
+#
+# # special handling... xmin/xmax with parametric function(s)
+@recipe function f(f::Function, xmin::Number, xmax::Number)
+    xs = adapted_grid(f, (xmin, xmax))
+    xs, f
+end
+@recipe function f{F<:Function}(fs::AbstractArray{F}, xmin::Number, xmax::Number)
+    xs = Any[adapted_grid(f, (xmin, xmax)) for f in fs]
+    xs, fs
+end
+@recipe f{F<:Function,G<:Function}(fx::FuncOrFuncs{F}, fy::FuncOrFuncs{G}, u::AVec)  = mapFuncOrFuncs(fx, u), mapFuncOrFuncs(fy, u)
+@recipe f{F<:Function,G<:Function}(fx::FuncOrFuncs{F}, fy::FuncOrFuncs{G}, umin::Number, umax::Number, n = 200) = fx, fy, linspace(umin, umax, n)
+
+#
+# # special handling... 3D parametric function(s)
+@recipe function f{F<:Function,G<:Function,H<:Function}(fx::FuncOrFuncs{F}, fy::FuncOrFuncs{G}, fz::FuncOrFuncs{H}, u::AVec)
+    mapFuncOrFuncs(fx, u), mapFuncOrFuncs(fy, u), mapFuncOrFuncs(fz, u)
+end
+@recipe function f{F<:Function,G<:Function,H<:Function}(fx::FuncOrFuncs{F}, fy::FuncOrFuncs{G}, fz::FuncOrFuncs{H}, 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
+
+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))
+
+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)
+
+# 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...))
+    for (i,glab) in enumerate(groupby.groupLabels)
+        @series begin
+            label     --> string(glab)
+            idxfilter --> groupby.groupIds[i]
+            for (key,val) in d
+                if splittable_kw(key, val, lengthGroup)
+                    :($key) := split_kw(key, val, groupby.groupIds[i])
+                end
+            end
+            args
+        end
+    end
+end
@@ -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
-
@@ -3,6 +3,7 @@
 function Subplot{T<:AbstractBackend}(::T; parent = RootLayout())
    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)

@@ -30,16 +36,16 @@ 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_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.d[: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,
+            :hexbin,:bins2d,:histogram2d,:hline,:vline,
+            :contour,:contourf,:contour3d,:surface,:wireframe,
            :heatmap, :pie, :image
        ))
 end
@@ -1,65 +1,46 @@
+"""
+    theme(s::Symbol)

-const _invisible = RGBA(0,0,0,0)
+Specify the colour theme for plots.
+"""
+function theme(s::Symbol; kw...)
+    # reset?
+    if s == :none || s == :default
+        PlotUtils.clibrary(:Plots)
+        PlotUtils.default_cgrad(default = :sequential, sequential = :inferno)
+        default(;
+            bg        = :white,
+            bglegend  = :match,
+            bginside  = :match,
+            bgoutside = :match,
+            fg        = :auto,
+            fglegend  = :match,
+            fggrid    = :match,
+            fgaxis    = :match,
+            fgtext    = :match,
+            fgborder  = :match,
+            fgguide   = :match,
+            palette   = :auto
+        )
+        return
+    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,
+    # update the default gradient and other defaults
+    thm = PlotThemes._themes[s]
+    if thm.gradient != nothing
+        PlotUtils.clibrary(:misc)
+        PlotUtils.default_cgrad(default = :sequential, sequential = PlotThemes.gradient_name(s))
+    end
+    default(;
+        bg       = thm.bg_secondary,
+        bginside = thm.bg_primary,
+        fg       = thm.lines,
+        fgtext   = thm.text,
+        fgguide  = thm.text,
+        fglegend = thm.text,
+        palette  = thm.palette,
+        kw...
    )
-)
-
-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
+@deprecate set_theme(s) theme(s)
@@ -2,16 +2,12 @@
 # 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}

 immutable PlotsDisplay <: Display end

-abstract AbstractBackend
-abstract AbstractPlot{T<:AbstractBackend}
-abstract AbstractLayout
-
 # -----------------------------------------------------------

 immutable InputWrapper{T}
@@ -21,11 +17,21 @@ wrap{T}(obj::T) = InputWrapper{T}(obj)
 Base.isempty(wrapper::InputWrapper) = false


+# -----------------------------------------------------------
+
+type Series
+    d::KW
+end
+
+attr(series::Series, k::Symbol) = series.d[k]
+attr!(series::Series, v, k::Symbol) = (series.d[k] = v)
+
 # -----------------------------------------------------------

 # a single subplot
 type 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,11 +40,13 @@ 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
+    sps::Vector{Subplot}
    d::KW
 end

@@ -50,18 +58,10 @@ 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}
    backend::T                   # the backend type
@@ -83,12 +83,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.endof(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.endof(sp::Subplot) = length(series_list(sp))

 # -----------------------------------------------------------------------
@@ -3,7 +3,7 @@ calcMidpoints(edges::AbstractVector) = Float64[0.5 * (edges[i] + edges[i+1]) for

 "Make histogram-like bins of data"
 function binData(data, nbins)
-  lo, hi = extrema(data)
+  lo, hi = ignorenan_extrema(data)
  edges = collect(linspace(lo, hi, nbins+1))
  midpoints = calcMidpoints(edges)
  buckets = Int[max(2, min(searchsortedfirst(edges, x), length(edges)))-1 for x in data]
@@ -109,7 +109,7 @@ function regressionXY(x, y)
  β, α = convert(Matrix{Float64}, [x ones(length(x))]) \ convert(Vector{Float64}, y)

  # make a line segment
-  regx = [minimum(x), maximum(x)]
+  regx = [ignorenan_minimum(x), ignorenan_maximum(x)]
  regy = β * regx + α
  regx, regy
 end
@@ -131,31 +131,48 @@ function replace_image_with_heatmap{T<:Colorant}(z::Array{T})
 end

 function imageHack(d::KW)
-    :heatmap in supported_types() || error("Neither :image or :heatmap are supported!")
+    is_seriestype_supported(:heatmap) || error("Neither :image or :heatmap are supported!")
    d[:seriestype] = :heatmap
    d[:z], d[:fillcolor] = replace_image_with_heatmap(d[:z].surf)
 end
 # ---------------------------------------------------------------

-
-type Segments
-    pts::Vector{Float64}
+"Build line segments for plotting"
+type Segments{T}
+    pts::Vector{T}
 end

-Segments() = Segments(zeros(0))
+# Segments() = Segments{Float64}(zeros(0))

-function Base.push!(segments::Segments, vs...)
-    push!(segments.pts, NaN)
+Segments() = Segments(Float64)
+Segments{T}(::Type{T}) = Segments(T[])
+Segments(p::Int) = Segments(NTuple{2,Float64}[])
+
+
+# Segments() = Segments(zeros(0))
+
+to_nan(::Type{Float64}) = NaN
+to_nan(::Type{NTuple{2,Float64}}) = (NaN, NaN)
+
+coords(segs::Segments{Float64}) = segs.pts
+coords(segs::Segments{NTuple{2,Float64}}) = Float64[p[1] for p in segs.pts], Float64[p[2] for p in segs.pts]
+
+function Base.push!{T}(segments::Segments{T}, vs...)
+    if !isempty(segments.pts)
+        push!(segments.pts, to_nan(T))
+    end
    for v in vs
-        push!(segments.pts, v)
+        push!(segments.pts, convert(T,v))
    end
    segments
 end

-function Base.push!(segments::Segments, vs::AVec)
-    push!(segments.pts, NaN)
+function Base.push!{T}(segments::Segments{T}, vs::AVec)
+    if !isempty(segments.pts)
+        push!(segments.pts, to_nan(T))
+    end
    for v in vs
-        push!(segments.pts, v)
+        push!(segments.pts, convert(T,v))
    end
    segments
 end
@@ -166,28 +183,34 @@ end

 type SegmentsIterator
    args::Tuple
-    nextidx::Int
    n::Int
 end
+
 function iter_segments(args...)
    tup = Plots.wraptuple(args)
    n = maximum(map(length, tup))
-    SegmentsIterator(tup, 0, n)
+    SegmentsIterator(tup, n)
 end

 # helpers to figure out if there are NaN values in a list of array types
-anynan(i::Int, args...) = any(a -> !isfinite(cycle(a,i)), args)
-anynan(istart::Int, iend::Int, args...) = any(i -> anynan(i, args...), istart:iend)
-allnan(istart::Int, iend::Int, args...) = all(i -> anynan(i, args...), istart:iend)
+anynan(i::Int, args::Tuple) = any(a -> !isfinite(_cycle(a,i)), args)
+anynan(istart::Int, iend::Int, args::Tuple) = any(i -> anynan(i, args), istart:iend)
+allnan(istart::Int, iend::Int, args::Tuple) = all(i -> anynan(i, args), istart:iend)

-Base.start(itr::SegmentsIterator) = (itr.nextidx = 1) #resets
-Base.done(itr::SegmentsIterator, unused::Int) = itr.nextidx > itr.n
-function Base.next(itr::SegmentsIterator, unused::Int)
-    i = istart = iend = itr.nextidx
+function Base.start(itr::SegmentsIterator)
+    nextidx = 1
+    if anynan(1, itr.args)
+        _, nextidx = next(itr, 1)
+    end
+    nextidx
+end
+Base.done(itr::SegmentsIterator, nextidx::Int) = nextidx > itr.n
+function Base.next(itr::SegmentsIterator, nextidx::Int)
+    i = istart = iend = nextidx

    # find the next NaN, and iend is the one before
    while i <= itr.n + 1
-        if i > itr.n || anynan(i, itr.args...)
+        if i > itr.n || anynan(i, itr.args)
            # done... array end or found NaN
            iend = i-1
            break
@@ -195,44 +218,55 @@ function Base.next(itr::SegmentsIterator, unused::Int)
        i += 1
    end

-    # find the next non-NaN, and set itr.nextidx
+    # find the next non-NaN, and set nextidx
    while i <= itr.n
-        if !anynan(i, itr.args...)
+        if !anynan(i, itr.args)
            break
        end
        i += 1
    end

-    itr.nextidx = i
-    istart:iend, 0
+    istart:iend, i
 end

+# Find minimal type that can contain NaN and x
+# To allow use of NaN separated segments with categorical x axis
+
+float_extended_type{T}(x::AbstractArray{T}) = Union{T,Float64}
+float_extended_type{T<:Real}(x::AbstractArray{T}) = Float64
+
 # ------------------------------------------------------------------------------------


 nop() = nothing
 notimpl() = error("This has not been implemented yet")

-Base.cycle(wrapper::InputWrapper, idx::Int) = wrapper.obj
-Base.cycle(wrapper::InputWrapper, idx::AVec{Int}) = wrapper.obj
+isnothing(x::Void) = true
+isnothing(x) = false

-Base.cycle(v::AVec, idx::Int) = v[mod1(idx, length(v))]
-Base.cycle(v::AMat, idx::Int) = size(v,1) == 1 ? v[1, mod1(idx, size(v,2))] : v[:, mod1(idx, size(v,2))]
-Base.cycle(v, idx::Int)       = v
+_cycle(wrapper::InputWrapper, idx::Int) = wrapper.obj
+_cycle(wrapper::InputWrapper, idx::AVec{Int}) = wrapper.obj

-Base.cycle(v::AVec, indices::AVec{Int}) = map(i -> cycle(v,i), indices)
-Base.cycle(v::AMat, indices::AVec{Int}) = map(i -> cycle(v,i), indices)
-Base.cycle(v, idx::AVec{Int})       = v
+_cycle(v::AVec, idx::Int) = v[mod1(idx, length(v))]
+_cycle(v::AMat, idx::Int) = size(v,1) == 1 ? v[1, mod1(idx, size(v,2))] : v[:, mod1(idx, size(v,2))]
+_cycle(v, idx::Int)       = v
+
+_cycle(v::AVec, indices::AVec{Int}) = map(i -> _cycle(v,i), indices)
+_cycle(v::AMat, indices::AVec{Int}) = map(i -> _cycle(v,i), indices)
+_cycle(v, indices::AVec{Int})       = fill(v, length(indices))
+
+_cycle(grad::ColorGradient, idx::Int) = _cycle(grad.colors, idx)
+_cycle(grad::ColorGradient, indices::AVec{Int}) = _cycle(grad.colors, indices)

 makevec(v::AVec) = v
 makevec{T}(v::T) = T[v]

 "duplicate a single value, or pass the 2-tuple through"
 maketuple(x::Real)                     = (x,x)
-maketuple{T,S}(x::@compat(Tuple{T,S})) = x
+maketuple{T,S}(x::Tuple{T,S}) = x

 mapFuncOrFuncs(f::Function, u::AVec)        = map(f, u)
-mapFuncOrFuncs(fs::AVec{Function}, u::AVec) = [map(f, u) for f in fs]
+mapFuncOrFuncs{F<:Function}(fs::AVec{F}, u::AVec) = [map(f, u) for f in fs]

 unzip{X,Y}(xy::AVec{Tuple{X,Y}})              = [t[1] for t in xy], [t[2] for t in xy]
 unzip{X,Y,Z}(xyz::AVec{Tuple{X,Y,Z}})         = [t[1] for t in xyz], [t[2] for t in xyz], [t[3] for t in xyz]
@@ -250,15 +284,16 @@ unzip{T}(xyuv::FixedSizeArrays.Vec{4,T})       = T[xyuv[1]], T[xyuv[2]], T[xyuv[
 # given 2-element lims and a vector of data x, widen lims to account for the extrema of x
 function _expand_limits(lims, x)
  try
-    e1, e2 = extrema(x)
-    lims[1] = min(lims[1], e1)
-    lims[2] = max(lims[2], e2)
+    e1, e2 = ignorenan_extrema(x)
+    lims[1] = NaNMath.min(lims[1], e1)
+    lims[2] = NaNMath.max(lims[2], e2)
  # catch err
  #   warn(err)
  end
  nothing
 end

+expand_data(v, n::Integer) = [_cycle(v, i) for i=1:n]

 # if the type exists in a list, replace the first occurence.  otherwise add it to the end
 function addOrReplace(v::AbstractVector, t::DataType, args...; kw...)
@@ -277,24 +312,20 @@ function replaceType(vec, val)
  push!(vec, val)
 end

-function replaceAlias!(d::KW, k::Symbol, aliases::KW)
+function replaceAlias!(d::KW, k::Symbol, aliases::Dict{Symbol,Symbol})
  if haskey(aliases, k)
    d[aliases[k]] = pop!(d, k)
  end
 end

-function replaceAliases!(d::KW, aliases::KW)
+function replaceAliases!(d::KW, aliases::Dict{Symbol,Symbol})
  ks = collect(keys(d))
  for k in ks
      replaceAlias!(d, k, aliases)
-    # if haskey(aliases, k)
-    #   d[aliases[k]] = d[k]
-    #   delete!(d, k)
-    # end
  end
 end

-createSegments(z) = collect(repmat(z',2,1))[2:end]
+createSegments(z) = collect(repmat(reshape(z,1,:),2,1))[2:end]

 Base.first(c::Colorant) = c
 Base.first(x::Symbol) = x
@@ -302,31 +333,44 @@ Base.first(x::Symbol) = x

 sortedkeys(d::Dict) = sort(collect(keys(d)))

+
+const _scale_base = Dict{Symbol, Real}(
+    :log10 => 10,
+    :log2 => 2,
+    :ln => e,
+)
+
 "create an (n+1) list of the outsides of heatmap rectangles"
-function heatmap_edges(v::AVec)
-  vmin, vmax = extrema(v)
-  extra = 0.5 * (vmax-vmin) / (length(v)-1)
-  vcat(vmin-extra, 0.5 * (v[1:end-1] + v[2:end]), vmax+extra)
+function heatmap_edges(v::AVec, scale::Symbol = :identity)
+  vmin, vmax = ignorenan_extrema(v)
+  extra_min = extra_max = 0.5 * (vmax-vmin) / (length(v)-1)
+  if scale in _logScales
+      vmin > 0 || error("The axis values must be positive for a $scale scale")
+      while vmin - extra_min <= 0
+          extra_min /= _scale_base[scale]
+      end
+  end
+  vcat(vmin-extra_min, 0.5 * (v[1:end-1] + v[2:end]), vmax+extra_max)
 end


 function calc_r_extrema(x, y)
-    xmin, xmax = extrema(x)
-    ymin, ymax = extrema(y)
-    r = 0.5 * min(xmax - xmin, ymax - ymin)
-    extrema(r)
+    xmin, xmax = ignorenan_extrema(x)
+    ymin, ymax = ignorenan_extrema(y)
+    r = 0.5 * NaNMath.min(xmax - xmin, ymax - ymin)
+    ignorenan_extrema(r)
 end

 function convert_to_polar(x, y, r_extrema = calc_r_extrema(x, y))
    rmin, rmax = r_extrema
    phi, r = x, y
-    r = 0.5 * (r - rmin) / (rmax - rmin)
+    r = (r - rmin) / (rmax - rmin)
    n = max(length(phi), length(r))
    x = zeros(n)
    y = zeros(n)
    for i in 1:n
-        x[i] = cycle(r,i) * cos(cycle(phi,i))
-        y[i] = cycle(r,i) * sin(cycle(phi,i))
+        x[i] = _cycle(r,i) * cos.(_cycle(phi,i))
+        y[i] = _cycle(r,i) * sin.(_cycle(phi,i))
    end
    x, y
 end
@@ -363,15 +407,15 @@ is_2tuple(v) = typeof(v) <: Tuple && length(v) == 2


 isvertical(d::KW) = get(d, :orientation, :vertical) in (:vertical, :v, :vert)
+isvertical(series::Series) = isvertical(series.d)


-# ticksType{T<:Real,S<:Real}(ticks::@compat(Tuple{T,S})) = :limits
 ticksType{T<:Real}(ticks::AVec{T})                      = :ticks
 ticksType{T<:AbstractString}(ticks::AVec{T})            = :labels
-ticksType{T<:AVec,S<:AVec}(ticks::@compat(Tuple{T,S}))  = :ticks_and_labels
+ticksType{T<:AVec,S<:AVec}(ticks::Tuple{T,S})  = :ticks_and_labels
 ticksType(ticks)                                        = :invalid

-limsType{T<:Real,S<:Real}(lims::@compat(Tuple{T,S}))    = :limits
+limsType{T<:Real,S<:Real}(lims::Tuple{T,S})    = :limits
 limsType(lims::Symbol)                                  = lims == :auto ? :auto : :invalid
 limsType(lims)                                          = :invalid

@@ -422,9 +466,10 @@ end
 # this is a helper function to determine whether we need to transpose a surface matrix.
 # it depends on whether the backend matches rows to x (transpose_on_match == true) or vice versa
 # for example: PyPlot sends rows to y, so transpose_on_match should be true
-function transpose_z(d::KW, z, transpose_on_match::Bool = true)
+function transpose_z(d, z, transpose_on_match::Bool = true)
    if d[:match_dimensions] == transpose_on_match
-        z'
+        # z'
+        permutedims(z, [2,1])
    else
        z
    end
@@ -438,7 +483,7 @@ ok(tup::Tuple) = ok(tup...)
 # compute one side of a fill range from a ribbon
 function make_fillrange_side(y, rib)
    frs = zeros(length(y))
-    for (i, (yi, ri)) in enumerate(zip(y, cycle(rib)))
+    for (i, (yi, ri)) in enumerate(zip(y, Base.Iterators.cycle(rib)))
        frs[i] = yi + ri
    end
    frs
@@ -449,13 +494,56 @@ function make_fillrange_from_ribbon(kw::KW)
    y, rib = kw[:y], kw[:ribbon]
    rib = wraptuple(rib)
    rib1, rib2 = -first(rib), last(rib)
-    kw[:ribbon] = nothing
+    # kw[:ribbon] = nothing
    kw[:fillrange] = make_fillrange_side(y, rib1), make_fillrange_side(y, rib2)
+    (get(kw, :fillalpha, nothing) == nothing) && (kw[:fillalpha] = 0.5)
 end

+#turn tuple of fillranges to one path
+function concatenate_fillrange(x,y::Tuple)
+    rib1, rib2 = first(y), last(y)
+    yline = vcat(rib1,(rib2)[end:-1:1])
+    xline = vcat(x,x[end:-1:1])
+    return xline, yline
+end
+
+function get_sp_lims(sp::Subplot, letter::Symbol)
+    axis_limits(sp[Symbol(letter, :axis)])
+end
+
+"""
+    xlims([plt])
+
+Returns the x axis limits of the current plot or subplot
+"""
+xlims(sp::Subplot) = get_sp_lims(sp, :x)
+
+"""
+    ylims([plt])
+
+Returns the y axis limits of the current plot or subplot
+"""
+ylims(sp::Subplot) = get_sp_lims(sp, :y)
+
+"""
+    zlims([plt])
+
+Returns the z axis limits of the current plot or subplot
+"""
+zlims(sp::Subplot) = get_sp_lims(sp, :z)
+
+xlims(plt::Plot, sp_idx::Int = 1) = xlims(plt[sp_idx])
+ylims(plt::Plot, sp_idx::Int = 1) = ylims(plt[sp_idx])
+zlims(plt::Plot, sp_idx::Int = 1) = zlims(plt[sp_idx])
+xlims(sp_idx::Int = 1) = xlims(current(), sp_idx)
+ylims(sp_idx::Int = 1) = ylims(current(), sp_idx)
+zlims(sp_idx::Int = 1) = zlims(current(), sp_idx)
+
 # ---------------------------------------------------------------

-wraptuple(x::@compat(Tuple)) = x
+makekw(; kw...) = KW(kw)
+
+wraptuple(x::Tuple) = x
 wraptuple(x) = (x,)

 trueOrAllTrue(f::Function, x::AbstractArray) = all(f, x)
@@ -463,7 +551,7 @@ trueOrAllTrue(f::Function, x) = f(x)

 allLineTypes(arg)   = trueOrAllTrue(a -> get(_typeAliases, a, a) in _allTypes, arg)
 allStyles(arg)      = trueOrAllTrue(a -> get(_styleAliases, a, a) in _allStyles, arg)
-allShapes(arg)      = trueOrAllTrue(a -> get(_markerAliases, a, a) in _allMarkers, arg) ||
+allShapes(arg)      = trueOrAllTrue(a -> is_marker_supported(get(_markerAliases, a, a)), arg) ||
                        trueOrAllTrue(a -> isa(a, Shape), arg)
 allAlphas(arg)      = trueOrAllTrue(a -> (typeof(a) <: Real && a > 0 && a < 1) ||
                        (typeof(a) <: AbstractFloat && (a == zero(typeof(a)) || a == one(typeof(a)))), arg)
@@ -477,7 +565,7 @@ allFunctions(arg)   = trueOrAllTrue(a -> isa(a, Function), arg)
 """
 Allows temporary setting of backend and defaults for Plots. Settings apply only for the `do` block.  Example:
 ```
-with(:gadfly, size=(400,400), type=:histogram) do
+with(:gr, size=(400,400), type=:histogram) do
  plot(rand(10))
  plot(rand(10))
 end
@@ -599,7 +687,7 @@ end
 # used in updating an existing series

 extendSeriesByOne(v::UnitRange{Int}, n::Int = 1) = isempty(v) ? (1:n) : (minimum(v):maximum(v)+n)
-extendSeriesByOne(v::AVec, n::Integer = 1)       = isempty(v) ? (1:n) : vcat(v, (1:n) + maximum(v))
+extendSeriesByOne(v::AVec, n::Integer = 1)       = isempty(v) ? (1:n) : vcat(v, (1:n) + ignorenan_maximum(v))
 extendSeriesData{T}(v::Range{T}, z::Real)        = extendSeriesData(float(collect(v)), z)
 extendSeriesData{T}(v::Range{T}, z::AVec)        = extendSeriesData(float(collect(v)), z)
 extendSeriesData{T}(v::AVec{T}, z::Real)         = (push!(v, convert(T, z)); v)
@@ -625,26 +713,86 @@ function setxy!{X,Y}(plt::Plot, xy::Tuple{X,Y}, i::Integer)
    series = plt.series_list[i]
    series.d[:x], series.d[:y] = xy
    sp = series.d[:subplot]
-    expand_extrema!(sp.attr[:xaxis], xy[1])
-    expand_extrema!(sp.attr[:yaxis], xy[2])
+    reset_extrema!(sp)
    _series_updated(plt, series)
 end
 function setxyz!{X,Y,Z}(plt::Plot, xyz::Tuple{X,Y,Z}, i::Integer)
    series = plt.series_list[i]
    series.d[:x], series.d[:y], series.d[:z] = xyz
    sp = series.d[:subplot]
-    expand_extrema!(sp.attr[:xaxis], xyz[1])
-    expand_extrema!(sp.attr[:yaxis], xyz[2])
-    expand_extrema!(sp.attr[:zaxis], xyz[3])
+    reset_extrema!(sp)
    _series_updated(plt, series)
 end

+function setxyz!{X,Y,Z<:AbstractMatrix}(plt::Plot, xyz::Tuple{X,Y,Z}, i::Integer)
+    setxyz!(plt, (xyz[1], xyz[2], Surface(xyz[3])), i)
+end
+
+
 # -------------------------------------------------------
 # indexing notation

-Base.getindex(plt::Plot, i::Integer) = getxy(plt, i)
-Base.setindex!{X,Y}(plt::Plot, xy::Tuple{X,Y}, i::Integer) = setxy!(plt, xy, i)
-Base.setindex!{X,Y,Z}(plt::Plot, xyz::Tuple{X,Y,Z}, i::Integer) = setxyz!(plt, xyz, i)
+# Base.getindex(plt::Plot, i::Integer) = getxy(plt, i)
+Base.setindex!{X,Y}(plt::Plot, xy::Tuple{X,Y}, i::Integer) = (setxy!(plt, xy, i); plt)
+Base.setindex!{X,Y,Z}(plt::Plot, xyz::Tuple{X,Y,Z}, i::Integer) = (setxyz!(plt, xyz, i); plt)
+
+# -------------------------------------------------------
+
+# operate on individual series
+
+function push_x!(series::Series, xi)
+    push!(series[:x], xi)
+    expand_extrema!(series[:subplot][:xaxis], xi)
+    return
+end
+function push_y!(series::Series, yi)
+    push!(series[:y], yi)
+    expand_extrema!(series[:subplot][:yaxis], yi)
+    return
+end
+function push_z!(series::Series, zi)
+    push!(series[:z], zi)
+    expand_extrema!(series[:subplot][:zaxis], zi)
+    return
+end
+
+function Base.push!(series::Series, yi)
+    x = extendSeriesByOne(series[:x])
+    expand_extrema!(series[:subplot][:xaxis], x[end])
+    series[:x] = x
+    push_y!(series, yi)
+end
+Base.push!(series::Series, xi, yi) = (push_x!(series,xi); push_y!(series,yi))
+Base.push!(series::Series, xi, yi, zi) = (push_x!(series,xi); push_y!(series,yi); push_z!(series,zi))
+
+# -------------------------------------------------------
+
+function attr!(series::Series; kw...)
+    d = KW(kw)
+    preprocessArgs!(d)
+    for (k,v) in d
+        if haskey(_series_defaults, k)
+            series[k] = v
+        else
+            warn("unused key $k in series attr")
+        end
+    end
+    _series_updated(series[:subplot].plt, series)
+    series
+end
+
+function attr!(sp::Subplot; kw...)
+    d = KW(kw)
+    preprocessArgs!(d)
+    for (k,v) in d
+        if haskey(_subplot_defaults, k)
+            sp[k] = v
+        else
+            warn("unused key $k in subplot attr")
+        end
+    end
+    sp
+end

 # -------------------------------------------------------
 # push/append for one series
@@ -765,9 +913,9 @@ mm2px(mm::Real)         = float(px / MM_PER_PX)


 "Smallest x in plot"
-xmin(plt::Plot) = minimum([minimum(series.d[:x]) for series in plt.series_list])
+xmin(plt::Plot) = ignorenan_minimum([ignorenan_minimum(series.d[:x]) for series in plt.series_list])
 "Largest x in plot"
-xmax(plt::Plot) = maximum([maximum(series.d[:x]) for series in plt.series_list])
+xmax(plt::Plot) = ignorenan_maximum([ignorenan_maximum(series.d[:x]) for series in plt.series_list])

 "Extrema of x-values in plot"
-Base.extrema(plt::Plot) = (xmin(plt), xmax(plt))
+ignorenan_extrema(plt::Plot) = (xmin(plt), xmax(plt))
@@ -1,16 +1,8 @@
-julia 0.4
-
-RecipesBase
-Colors
-Reexport
-Measures
-FactCheck
+StatPlots
 Images
-PyPlot
+ImageMagick
@osx QuartzImageIO
 GR
-DataFrames
 RDatasets
 VisualRegressionTests
 UnicodePlots
-Glob
@@ -13,8 +13,9 @@ try
 end


-using Plots, FactCheck
-using Glob
+using Plots
+using StatPlots
+using Base.Test

 default(size=(500,300))

@@ -22,7 +23,7 @@ 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.4"
+const _current_plots_version = v"0.12.4"


 function image_comparison_tests(pkg::Symbol, idx::Int; debug = false, popup = isinteractive(), sigma = [1,1], eps = 1e-2)
@@ -41,10 +42,8 @@ function image_comparison_tests(pkg::Symbol, idx::Int; debug = false, popup = is
    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

@@ -75,12 +74,12 @@ function image_comparison_tests(pkg::Symbol, idx::Int; debug = false, popup = is
        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)
@@ -96,7 +95,7 @@ function image_comparison_facts(pkg::Symbol;
  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, eps=eps) |> 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

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

-# facts("Gadfly") do
-#     @fact gadfly() --> Plots.GadflyBackend()
-#     @fact backend() --> Plots.GadflyBackend()
+@testset "GR" begin
+    ENV["GKSwstype"] = "100"
+    @test gr() == Plots.GRBackend()
+    @test backend() == Plots.GRBackend()
+
+    image_comparison_facts(:gr, eps=img_eps)
+end
+
+
+@testset "PyPlot" begin
+    @test pyplot() == Plots.PyPlotBackend()
+    @test backend() == Plots.PyPlotBackend()
+
+    image_comparison_facts(:pyplot, eps=img_eps)
+end
+
+@testset "UnicodePlots" begin
+    @test unicodeplots() == Plots.UnicodePlotsBackend()
+    @test backend() == Plots.UnicodePlotsBackend()
+
+    # lets just make sure it runs without error
+    @test isa(plot(rand(10)), Plots.Plot) == true
+end
+
+# The plotlyjs testimages return a connection error on travis:
+# connect: connection refused (ECONNREFUSED)
+
+# @testset "PlotlyJS" begin
+#     @test plotlyjs() == Plots.PlotlyJSBackend()
+#     @test backend() == Plots.PlotlyJSBackend()
 #
-#     @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)
+#     if is_linux() && isinteractive()
+#         image_comparison_facts(:plotlyjs,
+#             skip=[
+#                 2,  # animation (skipped for speed)
+#                 27, # (polar plots) takes very long / not working
+#                 31, # animation (skipped for speed)
+#             ],
+#             eps=img_eps)
+#     end
 # end

-facts("PyPlot") do
-    @fact pyplot() --> Plots.PyPlotBackend()
-    @fact backend() --> Plots.PyPlotBackend()

-    image_comparison_facts(:pyplot, skip=[30], eps=img_eps)
-end
+# InspectDR returns that error on travis:
+# ERROR: LoadError: InitError: Cannot open display:
+#  in Gtk.GLib.GError(::Gtk.##229#230) at /home/travis/.julia/v0.5/Gtk/src/GLib/gerror.jl:17

-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)
-end
+# @testset "InspectDR" begin
+#     @test inspectdr() == Plots.InspectDRBackend()
+#     @test backend() == Plots.InspectDRBackend()
+#
+#     image_comparison_facts(:inspectdr,
+#         skip=[
+#             2,  # animation
+#             6,  # heatmap not defined
+#             10, # heatmap not defined
+#             22, # contour not defined
+#             23, # pie not defined
+#             27, # polar plot not working
+#             28, # heatmap not defined
+#             31, # animation
+#         ],
+#         eps=img_eps)
+# end


-# facts("Immerse") do
-#     @fact immerse() --> Plots.ImmerseBackend()
-#     @fact backend() --> Plots.ImmerseBackend()
+# @testset "Plotly" begin
+#     @test plotly() == Plots.PlotlyBackend()
+#     @test backend() == Plots.PlotlyBackend()
+#
+#     # # until png generation is reliable on OSX, just test on linux
+#     # @static is_linux() && image_comparison_facts(:plotly, only=[1,3,4,7,8,9,10,11,12,14,15,20,22,23,27], eps=img_eps)
+# end
+
+
+# @testset "Immerse" begin
+#     @test immerse() == Plots.ImmerseBackend()
+#     @test 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()
+# @testset "PlotlyJS" begin
+#     @test plotlyjs() == Plots.PlotlyJSBackend()
+#     @test 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()
-
-    # lets just make sure it runs without error
-    @fact isa(plot(rand(10)), Plot) --> true
-end
+# @testset "Gadfly" begin
+#     @test gadfly() == Plots.GadflyBackend()
+#     @test backend() == Plots.GadflyBackend()
+#
+#     @test typeof(plot(1:10)) == Plots.Plot{Plots.GadflyBackend}
+#     @test plot(Int[1,2,3], rand(3)) == not(nothing)
+#     @test plot(sort(rand(10)), rand(Int, 10, 3)) == not(nothing)
+#     @test plot!(rand(10,3), rand(10,3)) == not(nothing)
+#
+#     image_comparison_facts(:gadfly, skip=[4,6,23,24,27], eps=img_eps)
+# 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


+# tests for preprocessing recipes
+
+# @testset "recipes" begin
+
+    # user recipe
+
+    # type T end
+    # @recipe function f(::T)
+    #     line := (3,0.3,:red)
+    #     marker := (20,0.5,:blue,:o)
+    #     bg := :yellow
+    #     rand(10)
+    # end
+    # plot(T())
+
+    # plot recipe
+
+    # @recipe function f(::Type{Val{:hiplt}},plt::Plot)
+    #     line := (3,0.3,:red)
+    #     marker := (20,0.5,:blue,:o)
+    #     t := :path
+    #     bg:=:green
+    #     ()
+    # end
+    # plot(rand(10),t=:hiplt)
+
+    # series recipe
+
+    # @recipe function f(::Type{Val{:hi}},x,y,z)
+    #     line := (3,0.3,:red)
+    #     marker := (20,0.5,:blue,:o)
+    #     t := :path
+    #     ()
+    # end
+    # plot(rand(10),t=:hiplt)
+
+# end


-FactCheck.exitstatus()
 end # module
@@ -4,7 +4,7 @@ import SnoopCompile
 # This only needs to be run once (to generate "/tmp/plots_compiles.csv")

 # SnoopCompile.@snoop "/tmp/plots_compiles.csv" begin
-#     include(Pkg.dir("Plots", "test","runtests.jl"))
+#     include(joinpath(dirname(@__FILE__), "runtests.jl"))
 # end

 # ----------------------------------------------------------
@@ -32,5 +32,5 @@ blacklist = ["MIME"]
 pc, discards = SnoopCompile.parcel(data[end:-1:1,2], subst=subst, blacklist=blacklist)
 SnoopCompile.write("/tmp/precompile", pc)

-pdir = Pkg.dir("Plots")
+pdir = joinpath(dirname(@__FILE__), "..")
 run(`cp /tmp/precompile/precompile_Plots.jl $pdir/src/precompile.jl`)
@@ -1,27 +1,31 @@
-# Pkg.clone(pwd())
-# Pkg.build("Plots")
-
-Pkg.clone("ImageMagick")
+Pkg.add("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.clone("https://github.com/JuliaStats/KernelDensity.jl.git")
+
+Pkg.clone("StatPlots")
+Pkg.checkout("PlotUtils")
+
+# Pkg.clone("Blink")
 # Pkg.build("Blink")
 # import Blink
 # Blink.AtomShell.install()
-# Pkg.clone("https://github.com/spencerlyon2/PlotlyJS.jl.git")
+# Pkg.add("Rsvg")
+# Pkg.add("PlotlyJS")

-Pkg.checkout("RecipesBase")
-Pkg.clone("VisualRegressionTests")
+# Pkg.checkout("RecipesBase")
+# Pkg.clone("VisualRegressionTests")

+# need this to use Conda
 ENV["PYTHON"] = ""
 Pkg.add("PyPlot")
 Pkg.build("PyPlot")

+# Pkg.add("InspectDR")
+
 Pkg.test("Plots"; coverage=false)