fix support for fill_z in pyplot

Add fill_z attribute and plotly impl

.travis.yml

@@ -2,10 +2,9 @@
 language: julia
 os:
   - linux
-  - osx
+  # - osx
 julia:
-  - release
-  - nightly
+  - 0.5
 matrix:
   allow_failures:
     - julia: nightly

NEWS.md

@@ -3,11 +3,209 @@
 
 #### notes on release changes, ongoing development, and future planned work
 
-- All new development should target 0.7!
+- All new development should target 0.9!
+- Minor version 0.8 is the last one to support Julia 0.4!!
+	- Critical bugfixes only
+    - `backports` branch is for Julia 0.4
 
 ---
 
-## 0.7 (current master/dev)
+## 0.9 (current master/dev)
+
+#### 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.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
+
+- rebuild violin and boxplot recipes
+- "plot recipes"
+- `cgrad` method for easy color gradient creation
+- improvements to inset subplots
+- Segments and iter_segments for NaN-separated vectors
+- `bar` recipe now creates a `shape` series
+- writemime fix for Interact.jl
+- `link = :square` option
+- !!! set `shape` attributes with line/fill, NOT marker/markerstroke !!!
+- basic DPI support
+- moved chorddiagram to PlotRecipes
+- GR:
+	- use temp files for img output
+	- basic support for marker strokes and other marker fixes
+- PyPlot:
+	- Switch to recipes for bar, histogram, histogram2d
+- GLVisualize
+	- subplots
+	- path/scatter and path3d/scatter3d
+	- initial drawing of axes
+- many smaller fixes and improvements
 
 #### 0.7.2
 
@@ -55,7 +253,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)
@@ -187,7 +385,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

README.md

@@ -12,24 +12,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
-pyplot(reuse=true)
-
-@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).

REQUIRE

@@ -1,8 +1,9 @@
-julia 0.4
+julia 0.5
 
 RecipesBase
-Colors
+PlotUtils
+PlotThemes
 Reexport
-Compat
 FixedSizeArrays
 Measures
+Showoff

appveyor.yml

@@ -1,15 +1,10 @@
 environment:
   matrix:
-  - JULIAVERSION: "julialang/bin/winnt/x86/0.3/julia-0.3-latest-win32.exe"
-  - JULIAVERSION: "julialang/bin/winnt/x64/0.3/julia-0.3-latest-win64.exe"
+  - JULIAVERSION: "julialang/bin/winnt/x86/0.5/julia-0.5-latest-win32.exe"
+  - JULIAVERSION: "julialang/bin/winnt/x64/0.5/julia-0.5-latest-win64.exe"
   - JULIAVERSION: "julianightlies/bin/winnt/x86/julia-latest-win32.exe"
   - JULIAVERSION: "julianightlies/bin/winnt/x64/julia-latest-win64.exe"
 
-branches:
-  only:
-    - master
-    - /release-.*/
-
 notifications:
   - provider: Email
     on_build_success: false
@@ -17,18 +12,21 @@ notifications:
     on_build_status_changed: false
 
 install:
+# 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://s3.amazonaws.com/"+$env:JULIAVERSION),
-        "C:\projects\julia-binary.exe")
+  - ps: (new-object net.webclient).DownloadFile($("http://s3.amazonaws.com/"+$env:JULIAVERSION), "C:\projects\julia-binary.exe")
 # Run installer silently, output to C:\projects\julia
   - C:\projects\julia-binary.exe /S /D=C:\projects\julia
 
 build_script:
 # Need to convert from shallow to complete for Pkg.clone to work
   - IF EXIST .git\shallow (git fetch --unshallow)
-  - C:\projects\julia\bin\julia -e "versioninfo();
-      Pkg.clone(pwd(), \"Plots\"); Pkg.build(\"Plots\")"
+  - C:\projects\julia\bin\julia -e "versioninfo(); Pkg.clone(pwd(), \"Plots\"); Pkg.build(\"Plots\")"
 
 test_script:
-  - C:\projects\julia\bin\julia --check-bounds=yes -e "Pkg.test(\"Plots\")"
+  # - C:\projects\julia\bin\julia -e "Pkg.test(\"Plots\")"
+  - C:\projects\julia\bin\julia -e "include(Pkg.dir(\"Plots\", \"test\", \"travis_commands.jl\"))"

src/Plots.jl

@@ -1,41 +1,33 @@
-
- __precompile__()
+__precompile__(false)
 
 module Plots
 
-using Compat
 using Reexport
-@reexport using Colors
-# using Requires
 using FixedSizeArrays
 @reexport using RecipesBase
 using Base.Meta
+@reexport using PlotUtils
+@reexport using PlotThemes
+import Showoff
 
 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,
+    twinx,
 
     @userplot,
     @shorthands,
@@ -59,57 +51,46 @@ export
     xaxis!,
     yaxis!,
 
+    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,
-
-    colorscheme,
-    ColorScheme,
-    ColorGradient,
-    ColorVector,
-    ColorWrapper,
-    ColorFunction,
-    ColorZFunction,
-    getColor,
-    getColorZ,
-
-    debugplots,
-
-    supported_args,
-    supported_types,
-    supported_styles,
-    supported_markers,
-    is_subplot_supported,
+    Segments,
+    Formatted,
 
     Animation,
     frame,
     gif,
+    mov,
+    mp4,
+    animate,
     @animate,
     @gif,
 
-    PlotRecipe,
-    spy,
-    arcdiagram,
-    chorddiagram,
-
     test_examples,
     iter_segments,
+    coords,
 
     translate,
     translate!,
@@ -118,9 +99,7 @@ export
     center,
     P2,
     P3,
-    BezierCurve,
-    curve_points,
-    directed_curve
+    BezierCurve
 
 # ---------------------------------------------------------
 
@@ -133,15 +112,14 @@ 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("backends.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")
@@ -176,6 +154,7 @@ end
 @shorthands vline
 @shorthands ohlc
 @shorthands contour
+@shorthands contourf
 @shorthands contour3d
 @shorthands surface
 @shorthands wireframe
@@ -214,28 +193,29 @@ yflip!(flip::Bool = true; kw...)                          = plot!(; yflip = flip
 xaxis!(args...; kw...)                                    = plot!(; xaxis = args, kw...)
 yaxis!(args...; kw...)                                    = plot!(; yaxis = args, kw...)
 
-title!(plt::Plot, s::AbstractString; kw...)                  = plot!(plt; title = s, kw...)
-xlabel!(plt::Plot, s::AbstractString; kw...)                 = plot!(plt; xlabel = s, kw...)
-ylabel!(plt::Plot, s::AbstractString; kw...)                 = plot!(plt; ylabel = s, kw...)
-xlims!{T<:Real,S<:Real}(plt::Plot, lims::Tuple{T,S}; kw...)  = plot!(plt; xlims = lims, kw...)
-ylims!{T<:Real,S<:Real}(plt::Plot, lims::Tuple{T,S}; kw...)  = plot!(plt; ylims = lims, kw...)
-zlims!{T<:Real,S<:Real}(plt::Plot, lims::Tuple{T,S}; kw...)  = plot!(plt; zlims = lims, kw...)
-xlims!(plt::Plot, xmin::Real, xmax::Real; kw...)                      = plot!(plt; xlims = (xmin,xmax), kw...)
-ylims!(plt::Plot, ymin::Real, ymax::Real; kw...)                      = plot!(plt; ylims = (ymin,ymax), kw...)
-zlims!(plt::Plot, zmin::Real, zmax::Real; kw...)                      = plot!(plt; zlims = (zmin,zmax), kw...)
-xticks!{T<:Real}(plt::Plot, ticks::AVec{T}; kw...)                    = plot!(plt; xticks = ticks, kw...)
-yticks!{T<:Real}(plt::Plot, ticks::AVec{T}; kw...)                    = plot!(plt; yticks = ticks, kw...)
-xticks!{T<:Real,S<:AbstractString}(plt::Plot,
-                          ticks::AVec{T}, labels::AVec{S}; kw...)     = plot!(plt; xticks = (ticks,labels), kw...)
-yticks!{T<:Real,S<:AbstractString}(plt::Plot,
-                          ticks::AVec{T}, labels::AVec{S}; kw...)     = plot!(plt; yticks = (ticks,labels), kw...)
-annotate!(plt::Plot, anns...; kw...)                                  = plot!(plt; annotation = anns, kw...)
-annotate!{T<:Tuple}(plt::Plot, anns::AVec{T}; kw...)                  = plot!(plt; annotation = anns, kw...)
-xflip!(plt::Plot, flip::Bool = true; kw...)                           = plot!(plt; xflip = flip, kw...)
-yflip!(plt::Plot, flip::Bool = true; kw...)                           = plot!(plt; yflip = flip, kw...)
-xaxis!(plt::Plot, args...; kw...)                                     = plot!(plt; xaxis = args, kw...)
-yaxis!(plt::Plot, args...; kw...)                                     = plot!(plt; yaxis = args, kw...)
-
+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...)
+    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
 
 
 # ---------------------------------------------------------
@@ -246,8 +226,8 @@ function __init__()
     setup_ijulia()
     setup_atom()
 
-    if haskey(ENV, "PLOTS_DEFAULTS")
-        for (k,v) in eval(parse(ENV["PLOTS_DEFAULTS"]))
+    if isdefined(Main, :PLOTS_DEFAULTS)
+        for (k,v) in Main.PLOTS_DEFAULTS
             default(k, v)
         end
     end

src/animation.jl

@@ -1,62 +1,109 @@
 
 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
 
 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 = 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")`
+            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(`$(joinpath(prefix, "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 +169,7 @@ Example:
 ```
 """
 macro gif(forloop::Expr, args...)
-  _animate(forloop, args...; callgif = true)
+    _animate(forloop, args...; callgif = true)
 end
 
 """
@@ -131,13 +178,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

src/arg_desc.jl

@@ -19,7 +19,7 @@ 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.",
 :smooth            	=> "Bool.  Add a regression line?",
@@ -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)",
@@ -62,6 +63,9 @@ const _arg_desc = KW(
 :overwrite_figure         => "Bool.  Should we reuse the same GUI window/figure when plotting (true) or open a new one (false).",
 :html_output_format       => "Symbol.  When writing html output, what is the format?  `:png` and `:svg` are currently supported.",
 :inset_subplots 		  => "nothing or vector of 2-tuple (parent,bbox).  optionally pass a vector of (parent,bbox) tuples which are the parent layout and the relative bounding box of inset subplots",
+:dpi 					  => "Number.  Dots Per Inch of output figures",
+: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.",
@@ -82,13 +86,14 @@ const _arg_desc = KW(
 :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.",
 
 # axis args
 :guide     				  => "String. Axis guide (label).",
@@ -97,11 +102,13 @@ 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).",
 
 )

src/args.jl

@@ -1,6 +1,6 @@
 
 
-const _keyAliases = KW()
+const _keyAliases = Dict{Symbol,Symbol}()
 
 function add_aliases(sym::Symbol, aliases::Symbol...)
     for alias in aliases
@@ -11,7 +11,7 @@ function add_aliases(sym::Symbol, aliases::Symbol...)
     end
 end
 
-function add_non_underscore_aliases!(aliases::KW)
+function add_non_underscore_aliases!(aliases::Dict{Symbol,Symbol})
     for (k,v) in aliases
         s = string(k)
         if '_' in s
@@ -24,14 +24,14 @@ end
 # ------------------------------------------------------------
 
 const _allAxes = [:auto, :left, :right]
-const _axesAliases = KW(
+const _axesAliases = Dict{Symbol,Symbol}(
     :a => :auto,
     :l => :left,
     :r => :right
 )
 
 const _3dTypes = [
-    :path3d, :scatter3d, :surface, :wireframe, :contour3d
+    :path3d, :scatter3d, :surface, :wireframe, :contour3d, :volume
 ]
 const _allTypes = vcat([
     :none, :line, :path, :steppre, :steppost, :sticks, :scatter,
@@ -39,7 +39,7 @@ const _allTypes = vcat([
     :contour, :pie, :shape, :image
 ], _3dTypes)
 
-@compat const _typeAliases = KW(
+const _typeAliases = Dict{Symbol,Symbol}(
     :n             => :none,
     :no            => :none,
     :l             => :line,
@@ -79,11 +79,11 @@ add_non_underscore_aliases!(_typeAliases)
 
 like_histogram(seriestype::Symbol) = seriestype in (:histogram, :density)
 like_line(seriestype::Symbol)      = seriestype in (:line, :path, :steppre, :steppost)
-like_surface(seriestype::Symbol)   = seriestype in (:contour, :contour3d, :heatmap, :surface, :wireframe, :image)
+like_surface(seriestype::Symbol)   = seriestype in (:contour, :contourf, :contour3d, :heatmap, :surface, :wireframe, :image)
 
 is3d(seriestype::Symbol) = seriestype in _3dTypes
 is3d(series::Series) = is3d(series.d)
-is3d(d::KW) = trueOrAllTrue(is3d, d[:seriestype])
+is3d(d::KW) = trueOrAllTrue(is3d, Symbol(d[:seriestype]))
 
 is3d(sp::Subplot) = string(sp.attr[:projection]) == "3d"
 ispolar(sp::Subplot) = string(sp.attr[:projection]) == "polar"
@@ -92,7 +92,7 @@ ispolar(series::Series) = ispolar(series.d[:subplot])
 # ------------------------------------------------------------
 
 const _allStyles = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
-@compat const _styleAliases = KW(
+const _styleAliases = Dict{Symbol,Symbol}(
     :a    => :auto,
     :s    => :solid,
     :d    => :dash,
@@ -101,7 +101,7 @@ const _allStyles = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
 )
 
 const _allMarkers = vcat(:none, :auto, _shape_keys) #sort(collect(keys(_shapes))))
-@compat const _markerAliases = KW(
+const _markerAliases = Dict{Symbol,Symbol}(
     :n            => :none,
     :no           => :none,
     :a            => :auto,
@@ -123,9 +123,19 @@ const _allMarkers = vcat(:none, :auto, _shape_keys) #sort(collect(keys(_shapes))
     :dtri         => :dtriangle,
     :downtri      => :dtriangle,
     :downtriangle => :dtriangle,
-    :+            => :cross,
+    :>            => :rtriangle,
+    :rt           => :rtriangle,
+    :rtri         => :rtriangle,
+    :righttri      => :rtriangle,
+    :righttriangle => :rtriangle,
+    :<            => :ltriangle,
+    :lt           => :ltriangle,
+    :ltri         => :ltriangle,
+    :lighttri      => :ltriangle,
+    :lighttriangle => :ltriangle,
+    # :+            => :cross,
     :plus         => :cross,
-    :x            => :xcross,
+    # :x            => :xcross,
     :X            => :xcross,
     :star         => :star5,
     :s            => :star5,
@@ -143,7 +153,7 @@ const _allMarkers = vcat(:none, :auto, _shape_keys) #sort(collect(keys(_shapes))
 )
 
 const _allScales = [:identity, :ln, :log2, :log10, :asinh, :sqrt]
-@compat const _scaleAliases = KW(
+const _scaleAliases = Dict{Symbol,Symbol}(
     :none => :identity,
     :log  => :log10,
 )
@@ -165,7 +175,7 @@ const _series_defaults = KW(
     :markershape       => :none,
     :markercolor       => :match,
     :markeralpha       => nothing,
-    :markersize        => 6,
+    :markersize        => 4,
     :markerstrokestyle => :solid,
     :markerstrokewidth => 1,
     :markerstrokecolor => :match,
@@ -178,6 +188,7 @@ const _series_defaults = KW(
     :z                 => nothing,   # depth for contour, surface, etc
     :marker_z          => nothing,   # value for color scale
     :line_z            => nothing,
+    :fill_z            => nothing,
     :levels            => 15,
     :orientation       => :vertical,
     :bar_position      => :overlay,  # for bar plots and histograms: could also be stack (stack up) or dodge (side by side)
@@ -194,7 +205,7 @@ const _series_defaults = KW(
     :match_dimensions  => false,     # do rows match x (true) or y (false) for heatmap/image/spy? see issue 196
                                      # this ONLY effects whether or not the z-matrix is transposed for a heatmap display!
     :subplot           => :auto,     # which subplot(s) does this series belong to?
-    :series_annotations => [],       # a list of annotations which apply to the coordinates of this series
+    :series_annotations => nothing,       # a list of annotations which apply to the coordinates of this series
     :primary            => true,     # when true, this "counts" as a series for color selection, etc.  the main use is to allow
                                      #     one logical series to be broken up (path and markers, for example)
     :hover              => nothing,  # text to display when hovering over the data points
@@ -216,6 +227,9 @@ const _plot_defaults = KW(
     :html_output_format          => :auto,
     :inset_subplots              => nothing,   # optionally pass a vector of (parent,bbox) tuples which are
                                                # the parent layout and the relative bounding box of inset subplots
+    :dpi                         => DPI,        # dots per inch for images, etc
+    :display_type                => :auto,
+    :extra_kwargs                => KW(),
 )
 
 
@@ -239,12 +253,13 @@ const _subplot_defaults = KW(
     :annotations              => [],                # annotation tuples... list of (x,y,annotation)
     :projection               => :none,             # can also be :polar or :3d
     :aspect_ratio             => :none,             # choose from :none or :equal
-    :margin                   => 2mm,
+    :margin                   => 1mm,
     :left_margin              => :match,
     :top_margin               => :match,
     :right_margin             => :match,
     :bottom_margin            => :match,
     :subplot_index            => -1,
+    :colorbar_title           => "",
 )
 
 const _axis_defaults = KW(
@@ -262,6 +277,8 @@ const _axis_defaults = KW(
     :foreground_color_text   => :match,            # tick text color,
     :foreground_color_guide  => :match,            # guide text color,
     :discrete_values => [],
+    :formatter => :auto,
+    :mirror => false,
 )
 
 const _suppress_warnings = Set{Symbol}([
@@ -281,22 +298,24 @@ const _suppress_warnings = Set{Symbol}([
 # add defaults for the letter versions
 const _axis_defaults_byletter = KW()
 for letter in (:x,:y,:z)
-    for k in (
-                :guide,
-                :lims,
-                :ticks,
-                :scale,
-                :rotation,
-                :flip,
-                :link,
-                :tickfont,
-                :guidefont,
-                :foreground_color_axis,
-                :foreground_color_border,
-                :foreground_color_text,
-                :foreground_color_guide,
-                :discrete_values
-            )
+    for k in keys(_axis_defaults)
+    # for k in (
+    #             :guide,
+    #             :lims,
+    #             :ticks,
+    #             :scale,
+    #             :rotation,
+    #             :flip,
+    #             :link,
+    #             :tickfont,
+    #             :guidefont,
+    #             :foreground_color_axis,
+    #             :foreground_color_border,
+    #             :foreground_color_text,
+    #             :foreground_color_guide,
+    #             :discrete_values,
+    #             :formatter,
+    #         )
         _axis_defaults_byletter[Symbol(letter,k)] = :match
 
         # allow the underscore version too: xguide or x_guide
@@ -312,10 +331,8 @@ const _all_defaults = KW[
 ]
 
 const _all_args = sort(collect(union(map(keys, _all_defaults)...)))
-supported_args(::AbstractBackend) = error("supported_args not defined") #_all_args
-supported_args() = supported_args(backend())
 
-RecipesBase.is_key_supported(k::Symbol) = (k in supported_args())
+RecipesBase.is_key_supported(k::Symbol) = is_attr_supported(k)
 
 # -----------------------------------------------------------------------------
 
@@ -327,7 +344,7 @@ autopick(notarr, idx::Integer) = notarr
 autopick_ignore_none_auto(arr::AVec, idx::Integer) = autopick(setdiff(arr, [:none, :auto]), idx)
 autopick_ignore_none_auto(notarr, idx::Integer) = notarr
 
-function aliasesAndAutopick(d::KW, sym::Symbol, aliases::KW, options::AVec, plotIndex::Int)
+function aliasesAndAutopick(d::KW, sym::Symbol, aliases::Dict{Symbol,Symbol}, options::AVec, plotIndex::Int)
     if d[sym] == :auto
         d[sym] = autopick_ignore_none_auto(options, plotIndex)
     elseif haskey(aliases, d[sym])
@@ -335,7 +352,7 @@ function aliasesAndAutopick(d::KW, sym::Symbol, aliases::KW, options::AVec, plot
     end
 end
 
-function aliases(aliasMap::KW, val)
+function aliases(aliasMap::Dict{Symbol,Symbol}, val)
     sortedkeys(filter((k,v)-> v==val, aliasMap))
 end
 
@@ -346,13 +363,16 @@ end
 add_aliases(:seriescolor, :c, :color, :colour)
 add_aliases(:linecolor, :lc, :lcolor, :lcolour, :linecolour)
 add_aliases(:markercolor, :mc, :mcolor, :mcolour, :markercolour)
-add_aliases(:markerstokecolor, :msc, :mscolor, :mscolour, :markerstokecolour)
+add_aliases(:markerstrokecolor, :msc, :mscolor, :mscolour, :markerstrokecolour)
+add_aliases(:markerstrokewidth, :msw, :mswidth)
 add_aliases(:fillcolor, :fc, :fcolor, :fcolour, :fillcolour)
 
 add_aliases(:background_color, :bg, :bgcolor, :bg_color, :background,
                               :background_colour, :bgcolour, :bg_colour)
 add_aliases(:background_color_legend, :bg_legend, :bglegend, :bgcolor_legend, :bg_color_legend, :background_legend,
                               :background_colour_legend, :bgcolour_legend, :bg_colour_legend)
+add_aliases(:background_color_subplot, :bg_subplot, :bgsubplot, :bgcolor_subplot, :bg_color_subplot, :background_subplot,
+                              :background_colour_subplot, :bgcolour_subplot, :bg_colour_subplot)
 add_aliases(:background_color_inside, :bg_inside, :bginside, :bgcolor_inside, :bg_color_inside, :background_inside,
                               :background_colour_inside, :bgcolour_inside, :bg_colour_inside)
 add_aliases(:background_color_outside, :bg_outside, :bgoutside, :bgcolor_outside, :bg_color_outside, :background_outside,
@@ -361,6 +381,8 @@ add_aliases(:foreground_color, :fg, :fgcolor, :fg_color, :foreground,
                             :foreground_colour, :fgcolour, :fg_colour)
 add_aliases(:foreground_color_legend, :fg_legend, :fglegend, :fgcolor_legend, :fg_color_legend, :foreground_legend,
                             :foreground_colour_legend, :fgcolour_legend, :fg_colour_legend)
+add_aliases(:foreground_color_subplot, :fg_subplot, :fgsubplot, :fgcolor_subplot, :fg_color_subplot, :foreground_subplot,
+                            :foreground_colour_subplot, :fgcolour_subplot, :fg_colour_subplot)
 add_aliases(:foreground_color_grid, :fg_grid, :fggrid, :fgcolor_grid, :fg_color_grid, :foreground_grid,
                             :foreground_colour_grid, :fgcolour_grid, :fg_colour_grid, :gridcolor)
 add_aliases(:foreground_color_title, :fg_title, :fgtitle, :fgcolor_title, :fg_color_title, :foreground_title,
@@ -377,7 +399,7 @@ add_aliases(:foreground_color_guide, :fg_guide, :fgguide, :fgcolor_guide, :fg_co
 # alphas
 add_aliases(:seriesalpha, :alpha, :α, :opacity)
 add_aliases(:linealpha, :la, :lalpha, :lα, :lineopacity, :lopacity)
-add_aliases(:makeralpha, :ma, :malpha, :mα, :makeropacity, :mopacity)
+add_aliases(:markeralpha, :ma, :malpha, :mα, :markeropacity, :mopacity)
 add_aliases(:markerstrokealpha, :msa, :msalpha, :msα, :markerstrokeopacity, :msopacity)
 add_aliases(:fillalpha, :fa, :falpha, :fα, :fillopacity, :fopacity)
 
@@ -410,6 +432,7 @@ add_aliases(:zguide, :zlabel, :zlab, :zl)
 add_aliases(:zlims, :zlim, :zlimit, :zlimits)
 add_aliases(:zticks, :ztick)
 add_aliases(:zrotation, :zrot, :zr)
+add_aliases(:fill_z, :fillz, :fz, :surfacecolor, :surfacecolour, :sc, :surfcolor, :surfcolour)
 add_aliases(:legend, :leg, :key)
 add_aliases(:colorbar, :cb, :cbar, :colorkey)
 add_aliases(:clims, :clim, :cbarlims, :cbar_lims, :climits, :color_limits)
@@ -429,9 +452,10 @@ add_aliases(:match_dimensions, :transpose, :transpose_z)
 add_aliases(:subplot, :sp, :subplt, :splt)
 add_aliases(:projection, :proj)
 add_aliases(:title_location, :title_loc, :titleloc, :title_position, :title_pos, :titlepos, :titleposition, :title_align, :title_alignment)
-add_aliases(:series_annotations, :series_ann, :seriesann, :series_anns, :seriesanns, :series_annotation)
+add_aliases(:series_annotations, :series_ann, :seriesann, :series_anns, :seriesanns, :series_annotation, :text, :txt, :texts, :txts)
 add_aliases(:html_output_format, :format, :fmt, :html_format)
 add_aliases(:orientation, :direction, :dir)
+add_aliases(:inset_subplots, :inset, :floating)
 
 
 # add all pluralized forms to the _keyAliases dict
@@ -449,6 +473,7 @@ end
 `default(key)` returns the current default value for that key
 `default(key, value)` sets the current default value for that key
 `default(; kw...)` will set the current default value for each key/value pair
+`default(d, key)` returns the key from d if it exists, otherwise `default(key)`
 """
 
 function default(k::Symbol)
@@ -485,6 +510,11 @@ function default(; kw...)
     end
 end
 
+function default(d::KW, k::Symbol)
+    get(d, k, default(k))
+end
+
+
 
 # -----------------------------------------------------------------------------
 
@@ -494,7 +524,8 @@ function handleColors!(d::KW, arg, csym::Symbol)
         if arg == :auto
             d[csym] = :auto
         else
-            c = colorscheme(arg)
+            # c = colorscheme(arg)
+            c = plot_color(arg)
             d[csym] = c
         end
         return true
@@ -515,13 +546,13 @@ function processLineArg(d::KW, arg)
 
     elseif typeof(arg) <: Stroke
         arg.width == nothing || (d[:linewidth] = arg.width)
-        arg.color == nothing || (d[:linecolor] = arg.color == :auto ? :auto : colorscheme(arg.color))
+        arg.color == nothing || (d[:linecolor] = arg.color == :auto ? :auto : plot_color(arg.color))
         arg.alpha == nothing || (d[:linealpha] = arg.alpha)
         arg.style == nothing || (d[:linestyle] = arg.style)
 
     elseif typeof(arg) <: Brush
         arg.size  == nothing || (d[:fillrange] = arg.size)
-        arg.color == nothing || (d[:fillcolor] = arg.color == :auto ? :auto : colorscheme(arg.color))
+        arg.color == nothing || (d[:fillcolor] = arg.color == :auto ? :auto : plot_color(arg.color))
         arg.alpha == nothing || (d[:fillalpha] = arg.alpha)
 
     elseif typeof(arg) <: Arrow || arg in (:arrow, :arrows)
@@ -554,13 +585,13 @@ function processMarkerArg(d::KW, arg)
 
     elseif typeof(arg) <: Stroke
         arg.width == nothing || (d[:markerstrokewidth] = arg.width)
-        arg.color == nothing || (d[:markerstrokecolor] = arg.color == :auto ? :auto : colorscheme(arg.color))
+        arg.color == nothing || (d[:markerstrokecolor] = arg.color == :auto ? :auto : plot_color(arg.color))
         arg.alpha == nothing || (d[:markerstrokealpha] = arg.alpha)
         arg.style == nothing || (d[:markerstrokestyle] = arg.style)
 
     elseif typeof(arg) <: Brush
         arg.size  == nothing || (d[:markersize]  = arg.size)
-        arg.color == nothing || (d[:markercolor] = arg.color == :auto ? :auto : colorscheme(arg.color))
+        arg.color == nothing || (d[:markercolor] = arg.color == :auto ? :auto : plot_color(arg.color))
         arg.alpha == nothing || (d[:markeralpha] = arg.alpha)
 
     # linealpha
@@ -580,9 +611,10 @@ end
 
 
 function processFillArg(d::KW, arg)
+    # fr = get(d, :fillrange, 0)
     if typeof(arg) <: Brush
         arg.size  == nothing || (d[:fillrange] = arg.size)
-        arg.color == nothing || (d[:fillcolor] = arg.color == :auto ? :auto : colorscheme(arg.color))
+        arg.color == nothing || (d[:fillcolor] = arg.color == :auto ? :auto : plot_color(arg.color))
         arg.alpha == nothing || (d[:fillalpha] = arg.alpha)
 
     # fillrange function
@@ -597,6 +629,8 @@ function processFillArg(d::KW, arg)
 
         d[:fillrange] = arg
     end
+    # d[:fillrange] = fr
+    return
 end
 
 _replace_markershape(shape::Symbol) = get(_markerAliases, shape, shape)
@@ -616,6 +650,21 @@ end
 function preprocessArgs!(d::KW)
     replaceAliases!(d, _keyAliases)
 
+    # clear all axis stuff
+    if haskey(d, :axis) && d[:axis] in (:none, nothing, false)
+        d[:ticks] = nothing
+        d[:foreground_color_border] = RGBA(0,0,0,0)
+        d[:grid] = false
+        delete!(d, :axis)
+    end
+    # for letter in (:x, :y, :z)
+    #     asym = Symbol(letter, :axis)
+    #     if haskey(d, asym) || d[asym] in (:none, nothing, false)
+    #         d[Symbol(letter, :ticks)] = nothing
+    #         d[Symbol(letter, :foreground_color_border)] = RGBA(0,0,0,0)
+    #     end
+    # end
+
     # handle axis args
     for letter in (:x, :y, :z)
         asym = Symbol(letter, :axis)
@@ -655,13 +704,18 @@ function preprocessArgs!(d::KW)
     end
     delete!(d, :fill)
 
+    # handle series annotations
+    if haskey(d, :series_annotations)
+        d[:series_annotations] = series_annotations(wraptuple(d[:series_annotations])...)
+    end
+
   # convert into strokes and brushes
 
     if haskey(d, :arrow)
         a = d[:arrow]
         d[:arrow] = if a == true
             arrow()
-        elseif a == false
+        elseif a in (false, nothing, :none)
             nothing
         elseif !(typeof(a) <: Arrow)
             arrow(wraptuple(a)...)
@@ -671,9 +725,9 @@ function preprocessArgs!(d::KW)
     end
 
 
-    if get(d, :arrow, false) == true
-        d[:arrow] = arrow()
-    end
+    # if get(d, :arrow, false) == true
+    #     d[:arrow] = arrow()
+    # end
 
     # legends
     if haskey(d, :legend)
@@ -683,21 +737,13 @@ function preprocessArgs!(d::KW)
         d[:colorbar] = convertLegendValue(d[:colorbar])
     end
 
-    # # handle subplot links
-    # if haskey(d, :link)
-    #     l = d[:link]
-    #     if isa(l, Bool)
-    #         d[:linkx] = l
-    #         d[:linky] = l
-    #     elseif isa(l, Function)
-    #         d[:linkx] = true
-    #         d[:linky] = true
-    #         d[:linkfunc] = l
-    #     else
-    #         warn("Unhandled/invalid link $l.  Should be a Bool or a function mapping (row,column) -> (linkx, linky), where linkx/y can be Bool or Void (nothing)")
-    #     end
-    #     delete!(d, :link)
-    # end
+    # warnings for moved recipes
+    st = get(d, :seriestype, :path)
+    if st in (:boxplot, :violin, :density) && !isdefined(Main, :StatPlots)
+        warn("seriestype $st has been moved to StatPlots.  To use: \`Pkg.add(\"StatPlots\"); using StatPlots\`")
+    end
+
+    return
 end
 
 # -----------------------------------------------------------------------------
@@ -747,43 +793,51 @@ end
 
 # -----------------------------------------------------------------------------
 
-const _already_warned = Set()
+const _already_warned = Dict{Symbol,Set{Symbol}}()
+const _to_warn = Set{Symbol}()
 
 function warnOnUnsupported_args(pkg::AbstractBackend, d::KW)
-    for k in sortedkeys(d)
-        k in supported_args(pkg) && continue
+    empty!(_to_warn)
+    bend = backend_name(pkg)
+    already_warned = get!(_already_warned, bend, Set{Symbol}())
+    for k in keys(d)
+        is_attr_supported(pkg, k) && continue
         k in _suppress_warnings && continue
         if d[k] != default(k)
-            if !((pkg, k) in _already_warned)
-                push!(_already_warned, (pkg,k))
-                warn("Keyword argument $k not supported with $pkg.  Choose from: $(supported_args(pkg))")
-            end
+            k in already_warned || push!(_to_warn, k)
+        end
+    end
+
+    if !isempty(_to_warn)
+        for k in sort(collect(_to_warn))
+            push!(already_warned, k)
+            warn("Keyword argument $k not supported with $pkg.  Choose from: $(supported_attrs(pkg))")
         end
     end
 end
 
-_markershape_supported(pkg::AbstractBackend, shape::Symbol) = shape in supported_markers(pkg)
-_markershape_supported(pkg::AbstractBackend, shape::Shape) = Shape in supported_markers(pkg)
-_markershape_supported(pkg::AbstractBackend, shapes::AVec) = all([_markershape_supported(pkg, shape) for shape in shapes])
+# _markershape_supported(pkg::AbstractBackend, shape::Symbol) = shape in supported_markers(pkg)
+# _markershape_supported(pkg::AbstractBackend, shape::Shape) = Shape in supported_markers(pkg)
+# _markershape_supported(pkg::AbstractBackend, shapes::AVec) = all([_markershape_supported(pkg, shape) for shape in shapes])
 
 function warnOnUnsupported(pkg::AbstractBackend, d::KW)
-    (d[:seriestype] == :none
-        || d[:seriestype] in supported_types(pkg)
-        || warn("seriestype $(d[:seriestype]) is unsupported with $pkg.  Choose from: $(supported_types(pkg))"))
-    (d[:linestyle] in supported_styles(pkg)
-        || warn("linestyle $(d[:linestyle]) is unsupported with $pkg.  Choose from: $(supported_styles(pkg))"))
-    (d[:markershape] == :none
-        || _markershape_supported(pkg, d[:markershape])
-        || warn("markershape $(d[:markershape]) is unsupported with $pkg.  Choose from: $(supported_markers(pkg))"))
+    if !is_seriestype_supported(pkg, d[:seriestype])
+        warn("seriestype $(d[:seriestype]) is unsupported with $pkg.  Choose from: $(supported_seriestypes(pkg))")
+    end
+    if !is_style_supported(pkg, d[:linestyle])
+        warn("linestyle $(d[:linestyle]) is unsupported with $pkg.  Choose from: $(supported_styles(pkg))")
+    end
+    if !is_marker_supported(pkg, d[:markershape])
+        warn("markershape $(d[:markershape]) is unsupported with $pkg.  Choose from: $(supported_markers(pkg))")
+    end
 end
 
 function warnOnUnsupported_scales(pkg::AbstractBackend, d::KW)
-    for k in (:xscale, :yscale, :zscale)
+    for k in (:xscale, :yscale, :zscale, :scale)
         if haskey(d, k)
             v = d[k]
-            v = get(_scaleAliases, v, v)
-            if !(v in supported_scales(pkg))
-                warn("scale $(d[k]) is unsupported with $pkg.  Choose from: $(supported_scales(pkg))")
+            if !is_scale_supported(pkg, v)
+                warn("scale $v is unsupported with $pkg.  Choose from: $(supported_scales(pkg))")
             end
         end
     end
@@ -805,6 +859,8 @@ function convertLegendValue(val::Symbol)
 end
 convertLegendValue(val::Bool) = val ? :best : :none
 convertLegendValue(val::Void) = :none
+convertLegendValue{S<:Real, T<:Real}(v::Tuple{S,T}) = v
+convertLegendValue(v::AbstractArray) = map(convertLegendValue, v)
 
 # -----------------------------------------------------------------------------
 
@@ -824,9 +880,9 @@ slice_arg(v, idx) = v
 # given an argument key (k), we want to extract the argument value for this index.
 # matrices are sliced by column, otherwise we
 # if nothing is set (or container is empty), return the default or the existing value.
-function slice_arg!(d_in::KW, d_out::KW, k::Symbol, default_value, idx::Int = 1; new_key::Symbol = k, remove_pair::Bool = true)
-    v = get(d_in, k, get(d_out, new_key, default_value))
-    d_out[new_key] = if haskey(d_in, k) && typeof(v) <: AMat && !isempty(v)
+function slice_arg!(d_in::KW, d_out::KW, k::Symbol, default_value, idx::Int, remove_pair::Bool)
+    v = get(d_in, k, get(d_out, k, default_value))
+    d_out[k] = if haskey(d_in, k) && typeof(v) <: AMat && !isempty(v)
         slice_arg(v, idx)
     else
         v
@@ -834,6 +890,7 @@ function slice_arg!(d_in::KW, d_out::KW, k::Symbol, default_value, idx::Int = 1;
     if remove_pair
         delete!(d_in, k)
     end
+    return
 end
 
 # -----------------------------------------------------------------------------
@@ -845,7 +902,7 @@ end
 #     d[k] = if v == :match
 #         match_color
 #     elseif v == nothing
-#         colorscheme(RGBA(0,0,0,0))
+#         plot_color(RGBA(0,0,0,0))
 #     else
 #         v
 #     end
@@ -854,10 +911,13 @@ end
 function color_or_nothing!(d::KW, k::Symbol)
     v = d[k]
     d[k] = if v == nothing || v == false
-        colorscheme(RGBA(0,0,0,0))
+        RGBA{Float64}(0,0,0,0)
+    elseif v != :match
+        plot_color(v)
     else
         v
     end
+    return
 end
 
 # -----------------------------------------------------------------------------
@@ -917,7 +977,7 @@ function Base.getindex(axis::Axis, k::Symbol)
     v = axis.d[k]
     if v == :match
         if haskey(_match_map2, k)
-            axis.sp[_match_map2[k]]
+            axis.sps[1][_match_map2[k]]
         else
             axis[_match_map[k]]
         end
@@ -926,38 +986,75 @@ function Base.getindex(axis::Axis, k::Symbol)
     end
 end
 
+function Base.getindex(series::Series, k::Symbol)
+    series.d[k]
+end
+
+Base.setindex!(plt::Plot, v, k::Symbol)      = (plt.attr[k] = v)
+Base.setindex!(sp::Subplot, v, k::Symbol)    = (sp.attr[k] = v)
+Base.setindex!(axis::Axis, v, k::Symbol)     = (axis.d[k] = v)
+Base.setindex!(series::Series, v, k::Symbol) = (series.d[k] = v)
+
+Base.get(plt::Plot, k::Symbol, v)      = get(plt.attr, k, v)
+Base.get(sp::Subplot, k::Symbol, v)    = get(sp.attr, k, v)
+Base.get(axis::Axis, k::Symbol, v)     = get(axis.d, k, v)
+Base.get(series::Series, k::Symbol, v) = get(series.d, k, v)
+
+
 # -----------------------------------------------------------------------------
 
+function fg_color(d::KW)
+    fg = default(d, :foreground_color)
+    if fg == :auto
+        bg = plot_color(default(d, :background_color))
+        fg = isdark(bg) ? colorant"white" : colorant"black"
+    else
+        plot_color(fg)
+    end
+end
+
+function fg_color_sp(d::KW)
+    fgsp = default(d, :foreground_color_subplot)
+    if fg == :match
+        fg_color(d)
+    else
+        plot_color(fgsp)
+    end
+end
+
+
+
 # update attr from an input dictionary
 function _update_plot_args(plt::Plot, d_in::KW)
     for (k,v) in _plot_defaults
-        slice_arg!(d_in, plt.attr, k, v)
+        slice_arg!(d_in, plt.attr, k, v, 1, true)
     end
 
     # handle colors
-    bg = convertColor(plt.attr[:background_color])
-    fg = plt.attr[:foreground_color]
-    if fg == :auto
-        fg = isdark(bg) ? colorant"white" : colorant"black"
-    end
-    plt.attr[:background_color] = bg
-    plt.attr[:foreground_color] = convertColor(fg)
-    # color_or_match!(plt.attr, :background_color_outside, bg)
+    d = plt.attr
+    plt[:background_color] = plot_color(d[:background_color])
+    plt[:foreground_color] = fg_color(d)
+    # bg = plot_color(plt.attr[:background_color])
+    # fg = plt.attr[:foreground_color]
+    # if fg == :auto
+    #     fg = isdark(bg) ? colorant"white" : colorant"black"
+    # end
+    # plt.attr[:background_color] = bg
+    # plt.attr[:foreground_color] = plot_color(fg)
     color_or_nothing!(plt.attr, :background_color_outside)
 end
 
+# -----------------------------------------------------------------------------
 
-# update a subplots args and axes
-function _update_subplot_args(plt::Plot, sp::Subplot, d_in::KW, subplot_index::Integer; remove_pair = true)
-    anns = pop!(sp.attr, :annotations, [])
-
-    # grab those args which apply to this subplot
-    for (k,v) in _subplot_defaults
-        slice_arg!(d_in, sp.attr, k, v, subplot_index, remove_pair = remove_pair)
+function _update_subplot_periphery(sp::Subplot, anns::AVec)
+    # extend annotations, and ensure we always have a (x,y,PlotText) tuple
+    newanns = vcat(anns, sp[:annotations])
+    for (i,ann) in enumerate(newanns)
+        x,y,tmp = ann
+        ptxt = isa(tmp, PlotText) ? tmp : text(tmp)
+        newanns[i] = (x,y,ptxt)
     end
-
-    # extend annotations
-    sp.attr[:annotations] = vcat(anns, sp[:annotations])
+    sp.attr[:annotations] = newanns
 
     # handle legend/colorbar
     sp.attr[:legend] = convertLegendValue(sp.attr[:legend])
@@ -965,11 +1062,13 @@ function _update_subplot_args(plt::Plot, sp::Subplot, d_in::KW, subplot_index::I
     if sp.attr[:colorbar] == :legend
         sp.attr[:colorbar] = sp.attr[:legend]
     end
+    return
+end
 
+function _update_subplot_colors(sp::Subplot)
     # background colors
-    # bg = color_or_match!(sp.attr, :background_color_subplot, plt.attr[:background_color])
     color_or_nothing!(sp.attr, :background_color_subplot)
-    bg = convertColor(sp[:background_color_subplot])
+    bg = plot_color(sp[:background_color_subplot])
     sp.attr[:color_palette] = get_color_palette(sp.attr[:color_palette], bg, 30)
     color_or_nothing!(sp.attr, :background_color_legend)
     color_or_nothing!(sp.attr, :background_color_inside)
@@ -979,64 +1078,200 @@ function _update_subplot_args(plt::Plot, sp::Subplot, d_in::KW, subplot_index::I
     color_or_nothing!(sp.attr, :foreground_color_legend)
     color_or_nothing!(sp.attr, :foreground_color_grid)
     color_or_nothing!(sp.attr, :foreground_color_title)
+    return
+end
 
-    # for k in (:left_margin, :top_margin, :right_margin, :bottom_margin)
-    #     if sp.attr[k] == :match
-    #         sp.attr[k] = sp.attr[:margin]
-    #     end
-    # end
+function _update_axis(plt::Plot, sp::Subplot, d_in::KW, letter::Symbol, subplot_index::Int)
+    # get (maybe initialize) the axis
+    axis = get_axis(sp, letter)
+
+    _update_axis(axis, d_in, letter, subplot_index)
+
+    # convert a bool into auto or nothing
+    if isa(axis[:ticks], Bool)
+        axis[:ticks] = axis[:ticks] ? :auto : nothing
+    end
+
+    _update_axis_colors(axis)
+    _update_axis_links(plt, axis, letter)
+    return
+end
+
+function _update_axis(axis::Axis, d_in::KW, letter::Symbol, subplot_index::Int)
+    # grab magic args (for example `xaxis = (:flip, :log)`)
+    args = wraptuple(get(d_in, Symbol(letter, :axis), ()))
+
+    # build the KW of arguments from the letter version (i.e. xticks --> ticks)
+    kw = KW()
+    for (k,v) in _axis_defaults
+        # first get the args without the letter: `tickfont = font(10)`
+        # note: we don't pop because we want this to apply to all axes! (delete after all have finished)
+        if haskey(d_in, k)
+            kw[k] = slice_arg(d_in[k], subplot_index)
+        end
+
+        # then get those args that were passed with a leading letter: `xlabel = "X"`
+        lk = Symbol(letter, k)
+        if haskey(d_in, lk)
+            kw[k] = slice_arg(d_in[lk], subplot_index)
+        end
+    end
+
+    # update the axis
+    attr!(axis, args...; kw...)
+    return
+end
+
+function _update_axis_colors(axis::Axis)
+    # # update the axis colors
+    color_or_nothing!(axis.d, :foreground_color_axis)
+    color_or_nothing!(axis.d, :foreground_color_border)
+    color_or_nothing!(axis.d, :foreground_color_guide)
+    color_or_nothing!(axis.d, :foreground_color_text)
+    return
+end
+
+function _update_axis_links(plt::Plot, axis::Axis, letter::Symbol)
+    # handle linking here.  if we're passed a list of
+    # other subplots to link to, link them together
+    link = axis[:link]
+    if !isempty(link)
+        for other_sp in link
+            other_sp = get_subplot(plt, other_sp)
+            link_axes!(axis, get_axis(other_sp, letter))
+        end
+        axis.d[:link] = []
+    end
+    return
+end
+
+# update a subplots args and axes
+function _update_subplot_args(plt::Plot, sp::Subplot, d_in::KW, subplot_index::Int, remove_pair::Bool)
+    anns = pop!(sp.attr, :annotations, [])
+
+    # grab those args which apply to this subplot
+    for (k,v) in _subplot_defaults
+        slice_arg!(d_in, sp.attr, k, v, subplot_index, remove_pair)
+    end
+
+    _update_subplot_periphery(sp, anns)
+    _update_subplot_colors(sp)
 
     for letter in (:x, :y, :z)
-        # get (maybe initialize) the axis
-        axis = get_axis(sp, letter)
-
-        # grab magic args (for example `xaxis = (:flip, :log)`)
-        args = wraptuple(get(d_in, Symbol(letter, :axis), ()))
-
-        # build the KW of arguments from the letter version (i.e. xticks --> ticks)
-        kw = KW()
-        for (k,v) in _axis_defaults
-            # first get the args without the letter: `tickfont = font(10)`
-            # note: we don't pop because we want this to apply to all axes! (delete after all have finished)
-            if haskey(d_in, k)
-                kw[k] = slice_arg(d_in[k], subplot_index)
-            end
-
-            # then get those args that were passed with a leading letter: `xlabel = "X"`
-            lk = Symbol(letter, k)
-            if haskey(d_in, lk)
-                kw[k] = slice_arg(d_in[lk], subplot_index)
-            end
-        end
-
-        # update the axis
-        update!(axis, args...; kw...)
-
-        # convert a bool into auto or nothing
-        if isa(axis[:ticks], Bool)
-            axis[:ticks] = axis[:ticks] ? :auto : nothing
-        end
-
-        # # update the axis colors
-        color_or_nothing!(axis.d, :foreground_color_axis)
-        color_or_nothing!(axis.d, :foreground_color_border)
-        color_or_nothing!(axis.d, :foreground_color_guide)
-        color_or_nothing!(axis.d, :foreground_color_text)
-
-        # handle linking here.  if we're passed a list of
-        # other subplots to link to, link them together
-        link = axis[:link]
-        if !isempty(link)
-            for other_sp in link
-                other_sp = get_subplot(plt, other_sp)
-                link_axes!(axis, get_axis(other_sp, letter))
-            end
-            axis.d[:link] = []
-        end
+        _update_axis(plt, sp, d_in, letter, subplot_index)
     end
 end
 
+# -----------------------------------------------------------------------------
 
 function has_black_border_for_default(st::Symbol)
-    like_histogram(st) || st in (:hexbin, :bar)
+    like_histogram(st) || st in (:hexbin, :bar, :shape)
+end
+
+
+# converts a symbol or string into a colorant (Colors.RGB), and assigns a color automatically
+function getSeriesRGBColor(c, α, sp::Subplot, n::Int)
+    if c == :auto
+        c = autopick(sp[:color_palette], n)
+    elseif isa(c, Int)
+        c = autopick(sp[:color_palette], c)
+    end
+    plot_color(c, α)
+end
+
+function ensure_gradient!(d::KW, csym::Symbol, asym::Symbol)
+    if !isa(d[csym], ColorGradient)
+        d[csym] = cgrad(alpha = d[asym])
+    end
+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
+
+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, false)
+    end
+
+    # this is how many series belong to this subplot
+    # plotIndex = count(series -> series.d[:subplot] === sp && series.d[:primary], plt.series_list)
+    plotIndex = 0
+    for series in sp.series_list
+        if series[:primary]
+            plotIndex += 1
+        end
+    end
+    # plotIndex = count(series -> series[:primary], sp.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 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
+
+    # update series color
+    d[:seriescolor] = getSeriesRGBColor(d[:seriescolor], d[:seriesalpha], sp, plotIndex)
+
+    # update other colors
+    for s in (:line, :marker, :fill)
+        csym, asym = Symbol(s,:color), Symbol(s,:alpha)
+        d[csym] = if d[csym] == :match
+            plot_color(if has_black_border_for_default(d[:seriestype]) && s == :line
+                sp[:foreground_color_subplot]
+            else
+                d[:seriescolor]
+            end, d[asym])
+        else
+            getSeriesRGBColor(d[csym], d[asym], sp, plotIndex)
+        end
+    end
+
+    # update markerstrokecolor
+    d[:markerstrokecolor] = if d[:markerstrokecolor] == :match
+        plot_color(sp[:foreground_color_subplot], d[:markerstrokealpha])
+    else
+        getSeriesRGBColor(d[:markerstrokecolor], d[:markerstrokealpha], sp, plotIndex)
+    end
+
+    # if marker_z or line_z are set, ensure we have a gradient
+    if d[:marker_z] != nothing
+        ensure_gradient!(d, :markercolor, :markeralpha)
+    end
+    if d[:line_z] != nothing
+        ensure_gradient!(d, :linecolor, :linealpha)
+    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

src/axes.jl

@@ -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
@@ -117,19 +120,121 @@ 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))
 
-# get discrete ticks, or not
+
+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)
+
+    # get a list of well-laid-out ticks
+    scaled_ticks = if ticks == nothing
+        optimize_ticks(
+            sf(amin),
+            sf(amax);
+            k_min = 5, # minimum number of ticks
+            k_max = 8, # maximum number of ticks
+        )[1]
+    else
+        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 = axis[:ticks]
+    ticks in (nothing, false) && return nothing
+
     dvals = axis[:discrete_values]
-    if !isempty(dvals) && ticks == :auto
+    cv, dv = if !isempty(dvals) && ticks == :auto
+        # discrete ticks...
         axis[:continuous_values], dvals
-    else
+    elseif ticks == :auto
+        # compute optimal ticks and labels
+        optimal_ticks_and_labels(axis)
+    elseif typeof(ticks) <: AVec
+        # override ticks, but get the labels
+        optimal_ticks_and_labels(axis, ticks)
+    elseif typeof(ticks) <: NTuple{2}
+        # 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
+        rng = Int[round(Int,i) for i in linspace(1, length(cv), 15)]
+        cv[rng], dv[rng]
+    else
+        cv, dv
     end
 end
 
 # -------------------------------------------------------------------------
 
+
+function reset_extrema!(sp::Subplot)
+    for asym in (:x,:y,:z)
+        sp[Symbol(asym,:axis)][:extrema] = Extrema()
+    end
+    for series in sp.series_list
+        expand_extrema!(sp, series.d)
+    end
+end
+
+
 function expand_extrema!(ex::Extrema, v::Number)
     ex.emin = min(v, ex.emin)
     ex.emax = max(v, ex.emax)
@@ -139,6 +244,12 @@ 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)
@@ -155,20 +266,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 +303,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
@@ -204,8 +327,6 @@ function expand_extrema!(sp::Subplot, d::KW)
         if bw == nothing
             bw = d[:bar_width] = 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))
@@ -232,10 +353,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 +381,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
@@ -330,3 +456,48 @@ 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)
+    spine_segs = Segments(2)
+    grid_segs = Segments(2)
+
+    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)))
+
+        push!(spine_segs, (xmin,ymin), (xmax,ymin)) # bottom spine
+        # push!(spine_segs, (xmin,ymax), (xmax,ymax)) # top spine
+        for xtick in xticks[1]
+            push!(spine_segs, (xtick, ymin), (xtick, t1)) # bottom tick
+            push!(grid_segs,  (xtick, t1),   (xtick, t2)) # vertical grid
+            # push!(spine_segs, (xtick, ymax), (xtick, t2)) # top tick
+        end
+    end
+
+    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)))
+
+        push!(spine_segs, (xmin,ymin), (xmin,ymax)) # left spine
+        # push!(spine_segs, (xmax,ymin), (xmax,ymax)) # right spine
+        for ytick in yticks[1]
+            push!(spine_segs, (xmin, ytick), (t1, ytick)) # left tick
+            push!(grid_segs,  (t1, ytick),   (t2, ytick)) # horizontal grid
+            # push!(spine_segs, (xmax, ytick), (t2, ytick)) # right tick
+        end
+    end
+
+    xticks, yticks, spine_segs, grid_segs
+end

src/backends.jl

@@ -26,24 +26,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 +51,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
@@ -127,14 +174,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 +199,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 +217,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 +247,7 @@ const _base_supported_args = [
     :subplot_index,
     :discrete_values,
     :projection,
-    
+
 ]
 
 function merge_with_base_supported(v::AVec)
@@ -225,5 +259,48 @@ 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
+
+# ---------------------------------------------------------
+
+# 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())

src/backends/gr.jl

@@ -3,7 +3,8 @@
 
 # significant contributions by @jheinen
 
-supported_args(::GRBackend) = merge_with_base_supported([
+
+const _gr_attr = merge_with_base_supported([
     :annotations,
     :background_color_legend, :background_color_inside, :background_color_outside,
     :foreground_color_legend, :foreground_color_grid, :foreground_color_axis,
@@ -28,19 +29,26 @@ supported_args(::GRBackend) = merge_with_base_supported([
     :aspect_ratio,
     :normalize, :weights,
     :inset_subplots,
+    :bar_width,
+    :arrow,
 ])
-supported_types(::GRBackend) = [
+const _gr_seriestype = [
     :path, :scatter,
     :heatmap, :pie, :image,
     :contour, :path3d, :scatter3d, :surface, :wireframe,
     :shape
 ]
-supported_styles(::GRBackend) = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
-supported_markers(::GRBackend) = vcat(_allMarkers, Shape)
-supported_scales(::GRBackend) = [:identity, :log10]
-is_subplot_supported(::GRBackend) = true
-
+const _gr_style = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
+const _gr_marker = _allMarkers
+const _gr_scale = [:identity, :log10]
+is_marker_supported(::GRBackend, shape::Shape) = true
 
+function add_backend_string(::GRBackend)
+    """
+    Pkg.add("GR")
+    Pkg.build("GR")
+    """
+end
 
 function _initialize_backend(::GRBackend; kw...)
     @eval begin
@@ -74,6 +82,8 @@ const gr_markertype = KW(
     :octagon => -24,
     :cross => 2,
     :xcross => 5,
+    :+ => 2,
+    :x => 5,
     :star4 => -25,
     :star5 => -26,
     :star6 => -27,
@@ -107,51 +117,22 @@ const gr_font_family = Dict(
 
 # --------------------------------------------------------------------------------------
 
-function gr_getcolorind(v, a =nothing)
-    c = getColor(v)
-    idx = convert(Int, GR.inqcolorfromrgb(c.r, c.g, c.b))
-    GR.settransparency(float(a==nothing ? alpha(c) : a))
-    idx
+function gr_getcolorind(c)
+    GR.settransparency(float(alpha(c)))
+    convert(Int, GR.inqcolorfromrgb(red(c), green(c), blue(c)))
 end
 
-gr_set_linecolor(c, a=nothing) = GR.setlinecolorind(gr_getcolorind(c, a))
-gr_set_fillcolor(c, a=nothing) = GR.setfillcolorind(gr_getcolorind(c, a))
-gr_set_markercolor(c, a=nothing) = GR.setmarkercolorind(gr_getcolorind(c, a))
-gr_set_textcolor(c, a=nothing) = GR.settextcolorind(gr_getcolorind(c, a))
+gr_set_linecolor(c)   = GR.setlinecolorind(gr_getcolorind(cycle(c,1)))
+gr_set_fillcolor(c)   = GR.setfillcolorind(gr_getcolorind(cycle(c,1)))
+gr_set_markercolor(c) = GR.setmarkercolorind(gr_getcolorind(cycle(c,1)))
+gr_set_textcolor(c)   = GR.settextcolorind(gr_getcolorind(cycle(c,1)))
 
 # --------------------------------------------------------------------------------------
 
-function gr_setmarkershape(d)
-    if d[:markershape] != :none
-        shape = d[:markershape]
-        if isa(shape, Shape)
-            d[:vertices] = vertices(shape)
-        else
-            GR.setmarkertype(gr_markertype[shape])
-            d[:vertices] = :none
-        end
-    end
-end
-
-function gr_polymarker(d, x, y)
-    if d[:vertices] != :none
-        vertices= d[:vertices]
-        dx = Float64[el[1] for el in vertices] * 0.03
-        dy = Float64[el[2] for el in vertices] * 0.03
-        GR.selntran(0)
-        for i = 1:length(x)
-            xn, yn = GR.wctondc(x[i], y[i])
-            GR.fillarea(xn + dx, yn + dy)
-        end
-        GR.selntran(1)
-    else
-        GR.polymarker(x, y)
-    end
-end
 
 # draw line segments, splitting x/y into contiguous/finite segments
 # note: this can be used for shapes by passing func `GR.fillarea`
-function gr_polyline(x, y, func = GR.polyline)
+function gr_polyline(x, y, func = GR.polyline; arrowside=:none)
     iend = 0
     n = length(x)
     while iend < n-1
@@ -179,12 +160,37 @@ function gr_polyline(x, y, func = GR.polyline)
         # if we found a start and end, draw the line segment, otherwise we're done
         if istart > 0 && iend > 0
             func(x[istart:iend], y[istart:iend])
+            if arrowside in (:head,:both)
+                GR.drawarrow(x[iend-1], y[iend-1], x[iend], y[iend])
+            end
+            if arrowside in (:tail,:both)
+                GR.drawarrow(x[istart+1], y[istart+1], x[istart], y[istart])
+            end
         else
             break
         end
     end
 end
 
+function gr_inqtext(x, y, s)
+    if length(s) >= 2 && s[1] == '$' && s[end] == '$'
+        GR.inqtextext(x, y, s[2:end-1])
+    elseif search(s, '\\') != 0 || search(s, '_') != 0 || search(s, '^') != 0
+        GR.inqtextext(x, y, s)
+    else
+        GR.inqtext(x, y, s)
+    end
+end
+
+function gr_text(x, y, s)
+    if length(s) >= 2 && s[1] == '$' && s[end] == '$'
+        GR.mathtex(x, y, s[2:end-1])
+    elseif search(s, '\\') != 0 || search(s, '_') != 0 || search(s, '^') != 0
+        GR.textext(x, y, s)
+    else
+        GR.text(x, y, s)
+    end
+end
 
 function gr_polaraxes(rmin, rmax)
     GR.savestate()
@@ -207,14 +213,14 @@ function gr_polaraxes(rmin, rmax)
             GR.drawarc(-r, r, -r, r, 0, 359)
         end
     end
-    for alpha in 0:45:315
-        a = alpha + 90
+    for α in 0:45:315
+        a = α + 90
         sinf = sin(a * pi / 180)
         cosf = cos(a * pi / 180)
         GR.polyline([sinf, 0], [cosf, 0])
         GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_HALF)
         x, y = GR.wctondc(1.1 * sinf, 1.1 * cosf)
-        GR.textext(x, y, string(alpha, "^o"))
+        GR.textext(x, y, string(α, "^o"))
     end
     GR.restorestate()
 end
@@ -260,59 +266,80 @@ function normalize_zvals(zv::AVec)
     end
 end
 
+# ---------------------------------------------------------
 
-function gr_draw_markers(d::KW, x, y, msize, mz, c, a)
-    if length(x) > 0
-        mz == nothing && gr_set_markercolor(c, a)
-        
-        if typeof(msize) <: Number && mz == nothing
-            # draw the markers all the same
-            GR.setmarkersize(msize)
-            gr_polymarker(d, x, y)
-        else
-            # draw each marker differently
-            for i = 1:length(x)
-                if mz != nothing
-                    ci = round(Int, 1000 + mz[i] * 255)
-                    GR.setmarkercolorind(ci)
-                end
-                GR.setmarkersize(isa(msize, Number) ? msize : msize[mod1(i, length(msize))])
-                gr_polymarker(d, [x[i]], [y[i]])
+# draw ONE Shape
+function gr_draw_marker(xi, yi, msize, shape::Shape)
+    sx, sy = coords(shape)
+    # convert to ndc coords (percentages of window)
+    GR.selntran(0)
+    xi, yi = GR.wctondc(xi, yi)
+    ms_ndc_x, ms_ndc_y = gr_pixels_to_ndc(msize, msize)
+    GR.fillarea(xi .+ sx .* ms_ndc_x,
+                yi .+ sy .* ms_ndc_y)
+    GR.selntran(1)
+end
+
+# draw ONE symbol marker
+function gr_draw_marker(xi, yi, msize::Number, shape::Symbol)
+    GR.setmarkertype(gr_markertype[shape])
+    GR.setmarkersize(0.3msize)
+    GR.polymarker([xi], [yi])
+end
+
+
+# draw the markers, one at a time
+function gr_draw_markers(series::Series, x, y, msize, mz)
+    shapes = series[:markershape]
+    if shapes != :none
+        for i=1:length(x)
+            msi = cycle(msize, i)
+            shape = cycle(shapes, i)
+            cfunc = isa(shape, Shape) ? gr_set_fillcolor : gr_set_markercolor
+            cfuncind = isa(shape, Shape) ? GR.setfillcolorind : GR.setmarkercolorind
+
+            # draw a filled in shape, slightly bigger, to estimate a stroke
+            if series[:markerstrokewidth] > 0
+                cfunc(cycle(series[:markerstrokecolor], i)) #, series[:markerstrokealpha])
+                gr_draw_marker(x[i], y[i], msi + series[:markerstrokewidth], shape)
             end
+
+            # draw the shape
+            if mz == nothing
+                cfunc(cycle(series[:markercolor], i)) #, series[:markeralpha])
+            else
+                # pick a color from the pre-loaded gradient
+                ci = round(Int, 1000 + cycle(mz, i) * 255)
+                cfuncind(ci)
+                GR.settransparency(_gr_gradient_alpha[ci-999])
+            end
+            gr_draw_marker(x[i], y[i], msi, shape)
         end
     end
 end
 
 function gr_draw_markers(series::Series, x, y)
-    d = series.d
-    msize = 0.5 * d[:markersize]
-    mz = normalize_zvals(d[:marker_z])
-
-    # draw the marker
-    gr_setmarkershape(d)
+    isempty(x) && return
+    mz = normalize_zvals(series[:marker_z])
     GR.setfillintstyle(GR.INTSTYLE_SOLID)
-    gr_draw_markers(d, x, y, msize, mz, d[:markercolor], d[:markeralpha])
-
-    # # draw the stroke
-    # GR.setfillintstyle(GR.INTSTYLE_HOLLOW)
-    # gr_draw_markers(d, x, y, msize, mz, d[:markerstrokecolor], d[:markerstrokealpha])
-
+    gr_draw_markers(series, x, y, series[:markersize], mz)
     if mz != nothing
-        gr_colorbar(d[:subplot])
+        gr_colorbar(series[:subplot])
     end
 end
 
+# ---------------------------------------------------------
 
-function gr_set_line(w, style, c, a)
+function gr_set_line(w, style, c) #, a)
     GR.setlinetype(gr_linetype[style])
     GR.setlinewidth(w)
-    gr_set_linecolor(c, a)
+    gr_set_linecolor(c) #, a)
 end
 
 
 
-function gr_set_fill(c, a)
-    gr_set_fillcolor(c, a)
+function gr_set_fill(c) #, a)
+    gr_set_fillcolor(c) #, a)
     GR.setfillintstyle(GR.INTSTYLE_SOLID)
 end
 
@@ -320,15 +347,24 @@ end
 const _gr_point_mult = zeros(1)
 
 # set the font attributes... assumes _gr_point_mult has been populated already
-function gr_set_font(f::Font)
+function gr_set_font(f::Font; halign = f.halign, valign = f.valign,
+                              color = f.color, rotation = f.rotation)
     family = lowercase(f.family)
     GR.setcharheight(_gr_point_mult[1] * f.pointsize)
-    GR.setcharup(sin(f.rotation), cos(f.rotation))
+    GR.setcharup(sind(-rotation), cosd(-rotation))
     if haskey(gr_font_family, family)
         GR.settextfontprec(100 + gr_font_family[family], GR.TEXT_PRECISION_STRING)
     end
-    gr_set_textcolor(f.color)
-    GR.settextalign(gr_halign[f.halign], gr_valign[f.valign])
+    gr_set_textcolor(color)
+    GR.settextalign(gr_halign[halign], gr_valign[valign])
+end
+
+function gr_nans_to_infs!(z)
+    for (i,zi) in enumerate(z)
+        if zi == NaN
+            z[i] = Inf
+        end
+    end
 end
 
 # --------------------------------------------------------------------------------------
@@ -338,6 +374,9 @@ end
 # values are [xmin, xmax, ymin, ymax].  they range [0,1].
 const viewport_plotarea = zeros(4)
 
+# the size of the current plot in pixels
+const gr_plot_size = zeros(2)
+
 function gr_viewport_from_bbox(bb::BoundingBox, w, h, viewport_canvas)
     viewport = zeros(4)
     viewport[1] = viewport_canvas[2] * (left(bb) / w)
@@ -392,16 +431,24 @@ gr_view_ycenter() = 0.5 * (viewport_plotarea[3] + viewport_plotarea[4])
 gr_view_xdiff() = viewport_plotarea[2] - viewport_plotarea[1]
 gr_view_ydiff() = viewport_plotarea[4] - viewport_plotarea[3]
 
+function gr_pixels_to_ndc(x_pixels, y_pixels)
+    w,h = gr_plot_size
+    totx = w * gr_view_xdiff()
+    toty = h * gr_view_ydiff()
+    x_pixels / totx, y_pixels / toty
+end
+
 
 # --------------------------------------------------------------------------------------
 
+const _gr_gradient_alpha = ones(256)
 
-function gr_set_gradient(c, a)
-    grad = isa(c, ColorGradient) ? c : default_gradient()
-    grad = ColorGradient(grad, alpha=a)
+function gr_set_gradient(c)
+    grad = isa(c, ColorGradient) ? c : cgrad()
     for (i,z) in enumerate(linspace(0, 1, 256))
-        c = getColorZ(grad, z)
+        c = grad[z]
         GR.setcolorrep(999+i, red(c), green(c), blue(c))
+        _gr_gradient_alpha[i] = alpha(c)
     end
     grad
 end
@@ -418,6 +465,7 @@ function gr_display(plt::Plot)
     # compute the viewport_canvas, normalized to the larger dimension
     viewport_canvas = Float64[0,1,0,1]
     w, h = plt[:size]
+    gr_plot_size[:] = [w, h]
     if w > h
         ratio = float(h) / w
         msize = display_width_ratio * w
@@ -439,7 +487,7 @@ function gr_display(plt::Plot)
 
     # update point mult
     px_per_pt = px / pt
-    _gr_point_mult[1] = px_per_pt / h
+    _gr_point_mult[1] = 1.5 * px_per_pt / max(h,w)
 
     # subplots:
     for sp in plt.subplots
@@ -454,9 +502,31 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
     # the viewports for this subplot
     viewport_subplot = gr_viewport_from_bbox(bbox(sp), w, h, viewport_canvas)
     viewport_plotarea[:] = gr_viewport_from_bbox(plotarea(sp), w, h, viewport_canvas)
+    # get data limits
+    data_lims = gr_xy_axislims(sp)
+
+    ratio = sp[:aspect_ratio]
+    if ratio != :none
+        if ratio == :equal
+            ratio = 1
+        end
+        viewport_ratio = (viewport_plotarea[2] - viewport_plotarea[1]) / (viewport_plotarea[4] - viewport_plotarea[3])
+        window_ratio = (data_lims[2] - data_lims[1]) / (data_lims[4] - data_lims[3]) / ratio
+        if window_ratio < viewport_ratio
+            viewport_center = 0.5 * (viewport_plotarea[1] + viewport_plotarea[2])
+            viewport_size = (viewport_plotarea[2] - viewport_plotarea[1]) * window_ratio / viewport_ratio
+            viewport_plotarea[1] = viewport_center - 0.5 * viewport_size
+            viewport_plotarea[2] = viewport_center + 0.5 * viewport_size
+        elseif window_ratio > viewport_ratio
+            viewport_center = 0.5 * (viewport_plotarea[3] + viewport_plotarea[4])
+            viewport_size = (viewport_plotarea[4] - viewport_plotarea[3]) * viewport_ratio / window_ratio
+            viewport_plotarea[3] = viewport_center - 0.5 * viewport_size
+            viewport_plotarea[4] = viewport_center + 0.5 * viewport_size
+        end
+    end
 
     # fill in the plot area background
-    bg = getColor(sp[:background_color_inside])
+    bg = plot_color(sp[:background_color_inside])
     gr_fill_viewport(viewport_plotarea, bg)
 
     # reduced from before... set some flags based on the series in this subplot
@@ -466,8 +536,8 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
     draw_axes = true
     # axes_2d = true
     for series in series_list(sp)
-        st = series.d[:seriestype]
-        if st in (:contour, :surface, :heatmap) || series.d[:marker_z] != nothing
+        st = series[:seriestype]
+        if st in (:contour, :surface, :heatmap) || series[:marker_z] != nothing
             cmap = true
         end
         if st == :pie
@@ -491,18 +561,18 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
     yaxis = sp[:yaxis]
     zaxis = sp[:zaxis]
 
-    # get data limits and set the scale flags and window
-    data_lims = gr_xy_axislims(sp)
+    # set the scale flags and window
     xmin, xmax, ymin, ymax = data_lims
-    scale = 0
+    scaleop = 0
+    xtick, ytick = 1, 1
     if xmax > xmin && ymax > ymin
         # NOTE: for log axes, the major_x and major_y - if non-zero (omit labels) - control the minor grid lines (1 = draw 9 minor grid lines, 2 = no minor grid lines)
         # NOTE: for log axes, the x_tick and y_tick - if non-zero (omit axes) - only affect the output appearance (1 = nomal, 2 = scientiic notation)
-        xaxis[:scale] == :log10 && (scale |= GR.OPTION_X_LOG)
-        yaxis[:scale] == :log10 && (scale |= GR.OPTION_Y_LOG)
-        xaxis[:flip]            && (scale |= GR.OPTION_FLIP_X)
-        yaxis[:flip]            && (scale |= GR.OPTION_FLIP_Y)
-        if scale & GR.OPTION_X_LOG == 0
+        xaxis[:scale] == :log10 && (scaleop |= GR.OPTION_X_LOG)
+        yaxis[:scale] == :log10 && (scaleop |= GR.OPTION_Y_LOG)
+        xaxis[:flip]            && (scaleop |= GR.OPTION_FLIP_X)
+        yaxis[:flip]            && (scaleop |= GR.OPTION_FLIP_Y)
+        if scaleop & GR.OPTION_X_LOG == 0
             majorx = 1 #5
             xtick = GR.tick(xmin, xmax) / majorx
         else
@@ -510,7 +580,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
             xtick = 2  # scientific notation
             majorx = 2 # no minor grid lines
         end
-        if scale & GR.OPTION_Y_LOG == 0
+        if scaleop & GR.OPTION_Y_LOG == 0
             majory = 1 #5
             ytick = GR.tick(ymin, ymax) / majory
         else
@@ -521,7 +591,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
 
         # NOTE: setwindow sets the "data coordinate" limits of the current "viewport"
         GR.setwindow(xmin, xmax, ymin, ymax)
-        GR.setscale(scale)
+        GR.setscale(scaleop)
     end
 
     # draw the axes
@@ -531,6 +601,11 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
 
     if is3d(sp)
         zmin, zmax = gr_lims(zaxis, true)
+        clims = sp[:clims]
+        if is_2tuple(clims)
+            isfinite(clims[1]) && (zmin = clims[1])
+            isfinite(clims[2]) && (zmax = clims[2])
+        end
         GR.setspace(zmin, zmax, 40, 70)
         xtick = GR.tick(xmin, xmax) / 2
         ytick = GR.tick(ymin, ymax) / 2
@@ -539,8 +614,8 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
 
         # GR.setlinetype(GR.LINETYPE_DOTTED)
         if sp[:grid]
-            GR.grid3d(xtick, 0, ztick, xmin, ymin, zmin, 2, 0, 2)
-            GR.grid3d(0, ytick, 0, xmax, ymin, zmin, 0, 2, 0)
+            GR.grid3d(xtick, 0, ztick, xmin, ymax, zmin, 2, 0, 2)
+            GR.grid3d(0, ytick, 0, xmin, ymax, zmin, 0, 2, 0)
         end
         GR.axes3d(xtick, 0, ztick, xmin, ymin, zmin, 2, 0, 2, -ticksize)
         GR.axes3d(0, ytick, 0, xmax, ymin, zmin, 0, 2, 0, ticksize)
@@ -548,29 +623,75 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
     elseif ispolar(sp)
         r = gr_set_viewport_polar()
         rmin, rmax = GR.adjustrange(minimum(r), maximum(r))
+        # rmin, rmax = axis_limits(sp[:yaxis])
         gr_polaraxes(rmin, rmax)
 
     elseif draw_axes
+        if xmax > xmin && ymax > ymin
+            GR.setwindow(xmin, xmax, ymin, ymax)
+        end
+
+        xticks, yticks, spine_segs, grid_segs = axis_drawing_info(sp)
+        # @show xticks yticks #spine_segs grid_segs
+
         # draw the grid lines
-        # TODO: control line style/width
-        # GR.setlinetype(GR.LINETYPE_DOTTED)
         if sp[:grid]
-            gr_set_linecolor(sp[:foreground_color_grid])
-            GR.grid(xtick, ytick, 0, 0, majorx, majory)
+            # gr_set_linecolor(sp[:foreground_color_grid])
+            # GR.grid(xtick, ytick, 0, 0, majorx, majory)
+            gr_set_line(1, :dot, sp[:foreground_color_grid])
+            GR.settransparency(0.5)
+            gr_polyline(coords(grid_segs)...)
+        end
+        GR.settransparency(1.0)
+
+        # spine (border) and tick marks
+        gr_set_line(1, :solid, sp[:xaxis][:foreground_color_axis])
+        gr_polyline(coords(spine_segs)...)
+
+        if !(xticks in (nothing, false))
+            # x labels
+            flip = sp[:yaxis][:flip]
+            mirror = sp[:xaxis][:mirror]
+            gr_set_font(sp[:xaxis][:tickfont],
+                        valign = (mirror ? :bottom : :top),
+                        color = sp[:xaxis][:foreground_color_axis],
+                        rotation = sp[:xaxis][:rotation])
+            for (cv, dv) in zip(xticks...)
+                # use xor ($) to get the right y coords
+                xi, yi = GR.wctondc(cv, (flip $ mirror) ? ymax : ymin)
+                # @show cv dv ymin xi yi flip mirror (flip $ mirror)
+                gr_text(xi, yi + (mirror ? 1 : -1) * 2e-3, string(dv))
+            end
         end
 
-        window_diag = sqrt(gr_view_xdiff()^2 + gr_view_ydiff()^2)
-        ticksize = 0.0075 * window_diag
-        if outside_ticks
-            ticksize = -ticksize
+        if !(yticks in (nothing, false))
+            # y labels
+            flip = sp[:xaxis][:flip]
+            mirror = sp[:yaxis][:mirror]
+            gr_set_font(sp[:yaxis][:tickfont],
+                        halign = (mirror ? :left : :right),
+                        color = sp[:yaxis][:foreground_color_axis],
+                        rotation = sp[:yaxis][:rotation])
+            for (cv, dv) in zip(yticks...)
+                # use xor ($) to get the right y coords
+                xi, yi = GR.wctondc((flip $ mirror) ? xmax : xmin, cv)
+                # @show cv dv xmin xi yi
+                gr_text(xi + (mirror ? 1 : -1) * 2e-3, yi, string(dv))
+            end
         end
-        # TODO: this should be done for each axis separately
-        gr_set_linecolor(xaxis[:foreground_color_axis])
 
-        x1, x2 = xaxis[:flip] ? (xmax,xmin) : (xmin,xmax)
-        y1, y2 = yaxis[:flip] ? (ymax,ymin) : (ymin,ymax)
-        GR.axes(xtick, ytick, x1, y1, 1, 1, ticksize)
-        GR.axes(xtick, ytick, x2, y2, -1, -1, -ticksize)
+        # window_diag = sqrt(gr_view_xdiff()^2 + gr_view_ydiff()^2)
+        # ticksize = 0.0075 * window_diag
+        # if outside_ticks
+        #     ticksize = -ticksize
+        # end
+        # # TODO: this should be done for each axis separately
+        # gr_set_linecolor(xaxis[:foreground_color_axis])
+
+        # x1, x2 = xaxis[:flip] ? (xmax,xmin) : (xmin,xmax)
+        # y1, y2 = yaxis[:flip] ? (ymax,ymin) : (ymin,ymax)
+        # GR.axes(xtick, ytick, x1, y1, 1, 1, ticksize)
+        # GR.axes(xtick, ytick, x2, y2, -1, -1, -ticksize)
     end
     # end
 
@@ -580,14 +701,14 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
         gr_set_font(sp[:titlefont])
         GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_TOP)
         gr_set_textcolor(sp[:foreground_color_title])
-        GR.text(gr_view_xcenter(), viewport_subplot[4], sp[:title])
+        gr_text(gr_view_xcenter(), viewport_subplot[4], sp[:title])
     end
 
     if xaxis[:guide] != ""
         gr_set_font(xaxis[:guidefont])
         GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_BOTTOM)
         gr_set_textcolor(xaxis[:foreground_color_guide])
-        GR.text(gr_view_xcenter(), viewport_subplot[3], xaxis[:guide])
+        gr_text(gr_view_xcenter(), viewport_subplot[3], xaxis[:guide])
     end
 
     if yaxis[:guide] != ""
@@ -595,27 +716,28 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
         GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_TOP)
         GR.setcharup(-1, 0)
         gr_set_textcolor(yaxis[:foreground_color_guide])
-        GR.text(viewport_subplot[1], gr_view_ycenter(), yaxis[:guide])
+        gr_text(viewport_subplot[1], gr_view_ycenter(), yaxis[:guide])
     end
     GR.restorestate()
 
-    # TODO: can we remove?
     gr_set_font(xaxis[:tickfont])
+
+    # this needs to be here to point the colormap to the right indices
     GR.setcolormap(1000 + GR.COLORMAP_COOLWARM)
 
     for (idx, series) in enumerate(series_list(sp))
-        d = series.d
-        st = d[:seriestype]
+        st = series[:seriestype]
 
         # update the current stored gradient
         if st in (:contour, :surface, :wireframe, :heatmap)
-            gr_set_gradient(d[:fillcolor], d[:fillalpha])
-        elseif d[:marker_z] != nothing
-            d[:markercolor] = gr_set_gradient(d[:markercolor], d[:markeralpha])
+            gr_set_gradient(series[:fillcolor]) #, series[:fillalpha])
+        elseif series[:marker_z] != nothing
+            series[:markercolor] = gr_set_gradient(series[:markercolor])
         end
 
         GR.savestate()
 
+
         # update the bounding window
         if ispolar(sp)
             gr_set_viewport_polar()
@@ -626,12 +748,20 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
             end
         end
 
-        x, y, z = d[:x], d[:y], d[:z]
-        frng = d[:fillrange]
+        x, y, z = series[:x], series[:y], series[:z]
+        frng = series[:fillrange]
+
+        # add custom frame shapes to markershape?
+        series_annotations_shapes!(series)
+        # -------------------------------------------------------
 
         # recompute data
-        if st in (:contour, :surface, :wireframe)
-            z = vec(transpose_z(d, z.surf, false))
+        if typeof(z) <: Surface
+            # if st == :heatmap
+            #     expand_extrema!(sp[:xaxis], (x[1]-0.5*(x[2]-x[1]), x[end]+0.5*(x[end]-x[end-1])))
+            #     expand_extrema!(sp[:yaxis], (y[1]-0.5*(y[2]-y[1]), y[end]+0.5*(y[end]-y[end-1])))
+            # end
+            z = vec(transpose_z(series, z.surf, false))
         elseif ispolar(sp)
             if frng != nothing
                 _, frng = convert_to_polar(x, frng, (rmin, rmax))
@@ -641,48 +771,52 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
 
         if st in (:path, :scatter)
             if length(x) > 1
-
                 # do area fill
                 if frng != nothing
-                    gr_set_fillcolor(d[:fillcolor], d[:fillalpha])
                     GR.setfillintstyle(GR.INTSTYLE_SOLID)
-                    frng = isa(frng, Number) ? Float64[frng] : frng
-                    nx, ny, nf = length(x), length(y), length(frng)
-                    n = max(nx, ny)
-                    fx, fy = zeros(2n), zeros(2n)
-                    for i=1:n
-                        fx[i] = fx[end-i+1] = cycle(x,i)
-                        fy[i] = cycle(y,i)
-                        fy[end-i+1] = cycle(frng,i)
+                    fr_from, fr_to = (is_2tuple(frng) ? frng : (y, frng))
+                    for (i,rng) in enumerate(iter_segments(series[:x], series[:y]))
+                        if length(rng) > 1
+                            gr_set_fillcolor(cycle(series[:fillcolor], i))
+                            fx = cycle(x, vcat(rng, reverse(rng)))
+                            fy = vcat(cycle(fr_from,rng), cycle(fr_to,reverse(rng)))
+                            # @show i rng fx fy
+                            GR.fillarea(fx, fy)
+                        end
                     end
-                    GR.fillarea(fx, fy)
                 end
 
                 # draw the line(s)
                 if st == :path
-                    gr_set_line(d[:linewidth], d[:linestyle], d[:linecolor], d[:linealpha])
-                    gr_polyline(x, y)
+                    gr_set_line(series[:linewidth], series[:linestyle], series[:linecolor]) #, series[:linealpha])
+                    arrowside = isa(series[:arrow], Arrow) ? series[:arrow].side : :none
+                    gr_polyline(x, y; arrowside = arrowside)
                 end
             end
 
-            if d[:markershape] != :none
+            if series[:markershape] != :none
                 gr_draw_markers(series, x, y)
             end
 
         elseif st == :contour
             zmin, zmax = gr_lims(zaxis, false)
-            if typeof(d[:levels]) <: Array
-                h = d[:levels]
+            clims = sp[:clims]
+            if is_2tuple(clims)
+                isfinite(clims[1]) && (zmin = clims[1])
+                isfinite(clims[2]) && (zmax = clims[2])
+            end
+            if typeof(series[:levels]) <: Array
+                h = series[:levels]
             else
-                h = linspace(zmin, zmax, d[:levels])
+                h = linspace(zmin, zmax, series[:levels])
             end
             GR.setspace(zmin, zmax, 0, 90)
-            if d[:fillrange] != nothing
+            if series[:fillrange] != nothing
                 GR.surface(x, y, z, GR.OPTION_CELL_ARRAY)
             else
                 GR.contour(x, y, h, z, 1000)
             end
-            
+
             # create the colorbar of contour levels
             if sp[:colorbar] != :none
                 gr_set_viewport_cmap(sp)
@@ -696,7 +830,11 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
 
         elseif st in [:surface, :wireframe]
             if st == :surface
-                GR.gr3.surface(x, y, z, GR.OPTION_COLORED_MESH)
+                if length(x) == length(y) == length(z)
+                    GR.trisurface(x, y, z)
+                else
+                    GR.gr3.surface(x, y, z, GR.OPTION_COLORED_MESH)
+                end
             else
                 GR.setfillcolorind(0)
                 GR.surface(x, y, z, GR.OPTION_FILLED_MESH)
@@ -704,23 +842,32 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
             cmap && gr_colorbar(sp)
 
         elseif st == :heatmap
-            z = vec(transpose_z(d, z.surf, false))
             zmin, zmax = gr_lims(zaxis, true)
-            GR.setspace(zmin, zmax, 0, 90)
-            GR.surface(x, y, z, GR.OPTION_COLORED_MESH)
+            clims = sp[:clims]
+            if is_2tuple(clims)
+                isfinite(clims[1]) && (zmin = clims[1])
+                isfinite(clims[2]) && (zmax = clims[2])
+            end
+            grad = isa(series[:fillcolor], ColorGradient) ? series[:fillcolor] : cgrad()
+            colors = [grad[clamp((zi-zmin) / (zmax-zmin), 0, 1)] for zi=z]
+            rgba = map(c -> UInt32( round(Int, alpha(c) * 255) << 24 +
+                                    round(Int,  blue(c) * 255) << 16 +
+                                    round(Int, green(c) * 255) << 8  +
+                                    round(Int,   red(c) * 255) ), colors)
+            GR.drawimage(xmin, xmax, ymax, ymin, length(x), length(y), rgba)
             cmap && gr_colorbar(sp)
 
         elseif st in (:path3d, :scatter3d)
             # draw path
             if st == :path3d
                 if length(x) > 1
-                    gr_set_line(d[:linewidth], d[:linestyle], d[:linecolor], d[:linealpha])
+                    gr_set_line(series[:linewidth], series[:linestyle], series[:linecolor]) #, series[:linealpha])
                     GR.polyline3d(x, y, z)
                 end
             end
 
             # draw markers
-            if st == :scatter3d || d[:markershape] != :none
+            if st == :scatter3d || series[:markershape] != :none
                 x2, y2 = unzip(map(GR.wc3towc, x, y, z))
                 gr_draw_markers(series, x2, y2)
             end
@@ -741,7 +888,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
                 ymin, ymax = ycenter - r, ycenter + r
             end
             labels = pie_labels(sp, series)
-            slices = d[:y]
+            slices = series[:y]
             numslices = length(slices)
             total = sum(slices)
             a1 = 0
@@ -751,22 +898,22 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
                 a2 = round(Int, a1 + (slices[i] / total) * 360.0)
                 GR.setfillcolorind(980 + (i-1) % 20)
                 GR.fillarc(xmin, xmax, ymin, ymax, a1, a2)
-                alpha = 0.5 * (a1 + a2)
-                cosf = r * cos(alpha * pi / 180)
-                sinf = r * sin(alpha * pi / 180)
+                α = 0.5 * (a1 + a2)
+                cosf = r * cos(α * pi / 180)
+                sinf = r * sin(α * pi / 180)
                 x[1] = xcenter + cosf
                 y[1] = ycenter + sinf
                 x[2] = x[1] + 0.1 * cosf
                 y[2] = y[1] + 0.1 * sinf
                 y[3] = y[2]
-                if 90 <= alpha < 270
+                if 90 <= α < 270
                     x[3] = x[2] - 0.05
                     GR.settextalign(GR.TEXT_HALIGN_RIGHT, GR.TEXT_VALIGN_HALF)
-                    GR.text(x[3] - 0.01, y[3], string(labels[i]))
+                    gr_text(x[3] - 0.01, y[3], string(labels[i]))
                 else
                     x[3] = x[2] + 0.05
                     GR.settextalign(GR.TEXT_HALIGN_LEFT, GR.TEXT_VALIGN_HALF)
-                    GR.text(x[3] + 0.01, y[3], string(labels[i]))
+                    gr_text(x[3] + 0.01, y[3], string(labels[i]))
                 end
                 gr_polyline(x, y)
                 a1 = a2
@@ -774,31 +921,47 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
             GR.selntran(1)
 
         elseif st == :shape
-            # draw the shapes
-            gr_set_line(d[:markerstrokewidth], :solid, d[:markerstrokecolor], d[:markerstrokealpha])
-            gr_polyline(d[:x], d[:y])
+            for (i,rng) in enumerate(iter_segments(series[:x], series[:y]))
+                if length(rng) > 1
+                    # connect to the beginning
+                    rng = vcat(rng, rng[1])
 
-            # draw the interior
-            gr_set_fill(d[:markercolor], d[:markeralpha])
-            gr_polyline(d[:x], d[:y], GR.fillarea)
+                    # get the segments
+                    x, y = series[:x][rng], series[:y][rng]
 
+                    # draw the interior
+                    gr_set_fill(cycle(series[:fillcolor], i))
+                    GR.fillarea(x, y)
+
+                    # draw the shapes
+                    gr_set_line(series[:linewidth], :solid, cycle(series[:linecolor], i))
+                    GR.polyline(x, y)
+                end
+            end
 
 
         elseif st == :image
-            img = d[:z].surf
-            w, h = size(img)
-            if eltype(img) <: Colors.AbstractGray
-                grey = round(UInt8, float(img) * 255)
+            z = transpose_z(series, series[:z].surf, true)
+            h, w = size(z)
+            if eltype(z) <: Colors.AbstractGray
+                grey = round(UInt8, float(z) * 255)
                 rgba = map(c -> UInt32( 0xff000000 + Int(c)<<16 + Int(c)<<8 + Int(c) ), grey)
             else
                 rgba = map(c -> UInt32( round(Int, alpha(c) * 255) << 24 +
                                         round(Int,  blue(c) * 255) << 16 +
                                         round(Int, green(c) * 255) << 8  +
-                                        round(Int,   red(c) * 255) ), img)
+                                        round(Int,   red(c) * 255) ), z)
             end
             GR.drawimage(xmin, xmax, ymax, ymin, w, h, rgba)
         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)
+            gr_set_font(fnt)
+            gr_text(GR.wctondc(xi, yi)..., str)
+        end
+
         GR.restorestate()
     end
 
@@ -815,13 +978,13 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
         for series in series_list(sp)
             should_add_to_legend(series) || continue
             n += 1
-            if typeof(series.d[:label]) <: Array
+            if typeof(series[:label]) <: Array
                 i += 1
-                lab = series.d[:label][i]
+                lab = series[:label][i]
             else
-                lab = series.d[:label]
+                lab = series[:label]
             end
-            tbx, tby = GR.inqtext(0, 0, lab)
+            tbx, tby = gr_inqtext(0, 0, lab)
             w = max(w, tbx[3] - tbx[1])
         end
         if w > 0
@@ -837,32 +1000,33 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
             i = 0
             for series in series_list(sp)
                 should_add_to_legend(series) || continue
-                d = series.d
-                st = d[:seriestype]
-                GR.setlinewidth(d[:linewidth])
+                st = series[:seriestype]
+                gr_set_line(series[:linewidth], series[:linestyle], series[:linecolor]) #, series[:linealpha])
                 if st == :path
-                    gr_set_linecolor(d[:linecolor], d[:linealpha])
-                    GR.setlinetype(gr_linetype[d[:linestyle]])
                     GR.polyline([xpos - 0.07, xpos - 0.01], [ypos, ypos])
+                elseif st == :shape
+                    gr_set_fill(series[:fillcolor]) #, series[:fillalpha])
+                    l, r = xpos-0.07, xpos-0.01
+                    b, t = ypos-0.4dy, ypos+0.4dy
+                    x = [l, r, r, l, l]
+                    y = [b, b, t, t, b]
+                    gr_polyline(x, y, GR.fillarea)
+                    gr_polyline(x, y)
                 end
-                if st == :scatter || d[:markershape] != :none
-                    gr_set_markercolor(d[:markercolor], d[:markeralpha])
-                    gr_setmarkershape(d)
-                    if st == :path
-                        gr_polymarker(d, [xpos - 0.06, xpos - 0.02], [ypos, ypos])
-                    else
-                        gr_polymarker(d, [xpos - 0.06, xpos - 0.04, xpos - 0.02], [ypos, ypos, ypos])
-                    end
+
+                if series[:markershape] != :none
+                    gr_draw_markers(series, xpos-[0.06,0.02], [ypos,ypos], 10, nothing)
                 end
-                if typeof(d[:label]) <: Array
+
+                if typeof(series[:label]) <: Array
                     i += 1
-                    lab = d[:label][i]
+                    lab = series[:label][i]
                 else
-                    lab = d[:label]
+                    lab = series[:label]
                 end
                 GR.settextalign(GR.TEXT_HALIGN_LEFT, GR.TEXT_VALIGN_HALF)
                 gr_set_textcolor(sp[:foreground_color_legend])
-                GR.text(xpos, ypos, lab)
+                gr_text(xpos, ypos, lab)
                 ypos -= dy
             end
         end
@@ -872,11 +1036,24 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
 
     # add annotations
     GR.savestate()
+    # update the bounding window
+    if ispolar(sp)
+        gr_set_viewport_polar()
+    else
+        xmin, xmax, ymin, ymax = data_lims
+        if xmax > xmin && ymax > ymin
+            GR.setwindow(xmin, xmax, ymin, ymax)
+        end
+    end
     for ann in sp[:annotations]
         x, y, val = ann
-        x, y = GR.wctondc(x, y)
+        x, y = if is3d(sp)
+            # GR.wc3towc(x, y, z)
+        else
+            GR.wctondc(x, y)
+        end
         gr_set_font(val.font)
-        GR.text(x, y, val.str)
+        gr_text(x, y, val.str)
     end
     GR.restorestate()
 end
@@ -891,19 +1068,49 @@ const _gr_mimeformats = Dict(
     "image/svg+xml"           => "svg",
 )
 
+const _gr_wstype_default = @static if is_linux()
+    "x11"
+    # "cairox11"
+elseif is_apple()
+    "quartz"
+else
+    "use_default"
+end
+
+const _gr_wstype = Ref(get(ENV, "GKSwstype", _gr_wstype_default))
+gr_set_output(wstype::String) = (_gr_wstype[] = wstype)
 
 for (mime, fmt) in _gr_mimeformats
-    @eval function _writemime(io::IO, ::MIME{Symbol($mime)}, plt::Plot{GRBackend})
+    @eval function _show(io::IO, ::MIME{Symbol($mime)}, plt::Plot{GRBackend})
         GR.emergencyclosegks()
-        wstype = haskey(ENV, "GKS_WSTYPE") ? ENV["GKS_WSTYPE"] : "0"
-        ENV["GKS_WSTYPE"] = $fmt
+        filepath = tempname() * "." * $fmt
+        ENV["GKSwstype"] = $fmt
+        ENV["GKS_FILEPATH"] = filepath
         gr_display(plt)
         GR.emergencyclosegks()
-        write(io, readall("gks." * $fmt))
-        ENV["GKS_WSTYPE"] = wstype
+        write(io, readstring(filepath))
+        rm(filepath)
     end
 end
 
 function _display(plt::Plot{GRBackend})
-    gr_display(plt)
+    if plt[:display_type] == :inline
+        GR.emergencyclosegks()
+        filepath = tempname() * ".pdf"
+        ENV["GKSwstype"] = "pdf"
+        ENV["GKS_FILEPATH"] = filepath
+        gr_display(plt)
+        GR.emergencyclosegks()
+        content = string("\033]1337;File=inline=1;preserveAspectRatio=0:", base64encode(open(readbytes, filepath)), "\a")
+        println(content)
+        rm(filepath)
+    else
+        ENV["GKS_DOUBLE_BUF"] = true
+        if _gr_wstype[] != "use_default"
+            ENV["GKSwstype"] = _gr_wstype[]
+        end
+        gr_display(plt)
+    end
 end
+
+closeall(::GRBackend) = GR.emergencyclosegks()

src/backends/inspectdr.jl

@@ -0,0 +1,488 @@
+
+# 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
+
+#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)
+#TODO: Support :asinh, :sqrt
+    if :log2 == s
+        return InspectDR.AxisScale(:log2)
+    elseif :log10 == s
+        return InspectDR.AxisScale(:log10)
+    elseif :ln == s
+        return InspectDR.AxisScale(:ln)
+    else #identity
+        return InspectDR.AxisScale(:lin)
+    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.markers = [] #Clear old markers
+    plot.atext = [] #Clear old annotation
+    plot.apline = [] #Clear old poly lines
+
+    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])
+
+    # 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
+                )
+                push!(plot.apline, 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 gridon = InspectDR.grid(vmajor=true, hmajor=true)
+    const gridoff = InspectDR.grid()
+    const plot = sp.o
+
+    xaxis = sp[:xaxis]; yaxis = sp[:yaxis]
+        xscale = _inspectdr_getscale(xaxis[:scale])
+        yscale = _inspectdr_getscale(yaxis[:scale])
+        plot.axes = InspectDR.AxesRect(xscale, yscale)
+        xmin, xmax  = axis_limits(xaxis)
+        ymin, ymax  = axis_limits(yaxis)
+        plot.ext = InspectDR.PExtents2D() #reset
+        plot.ext_full = InspectDR.PExtents2D(xmin, xmax, ymin, ymax)
+    a = plot.annotation
+        a.title = sp[:title]
+        a.xlabel = xaxis[:guide]; a.ylabel = yaxis[:guide]
+
+    l = plot.layout
+        l.framedata.fillcolor = _inspectdr_mapcolor(sp[:background_color_inside])
+        l.framedata.line.color = _inspectdr_mapcolor(xaxis[:foreground_color_axis])
+        l.fnttitle = 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.fntaxlabel = InspectDR.Font(xaxis[:guidefont].family,
+            _inspectdr_mapptsize(xaxis[:guidefont].pointsize),
+            color = _inspectdr_mapcolor(xaxis[:foreground_color_guide])
+        )
+        l.fntticklabel = InspectDR.Font(xaxis[:tickfont].family,
+            _inspectdr_mapptsize(xaxis[:tickfont].pointsize),
+            color = _inspectdr_mapcolor(xaxis[:foreground_color_text])
+        )
+        #No independent control of grid???
+        l.grid = sp[:grid]? gridon: gridoff
+    leg = l.legend
+        leg.enabled = (sp[:legend] != :none)
+        #leg.width = 150 #TODO: compute???
+        leg.font = InspectDR.Font(sp[:legendfont].family,
+            _inspectdr_mapptsize(sp[:legendfont].pointsize),
+            color = _inspectdr_mapcolor(sp[:foreground_color_legend])
+        )
+        leg.frame.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
+
+    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]
+        _initialize_subplot(plt, sp)
+        _inspectdr_setupsubplot(sp)
+
+            sp.o.layout.frame.fillcolor =
+                _inspectdr_mapcolor(plt[:background_color_outside])
+
+        # add the annotations
+        for ann in sp[:annotations]
+            _inspectdr_add_annotations(mplot.subplots[i], ann...)
+        end
+    end
+
+    #Do not yet support absolute plot positionning.
+    #Just try to make things look more-or less ok:
+    if nsubplots <= 1
+        mplot.ncolumns = 1
+    elseif nsubplots <= 4
+        mplot.ncolumns = 2
+    elseif nsubplots <= 6
+        mplot.ncolumns = 3
+    elseif nsubplots <= 12
+        mplot.ncolumns = 4
+    else
+        mplot.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})
+    sp.minpad = (20mm, 5mm, 2mm, 10mm)
+    #TODO: Add support for padding.
+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
+    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) =
+    throw(ErrorException("Cannot show(::IO, ...) plot - not yet generated"))
+_inspectdr_show(io::IO, mime::MIME, mplot) = show(io, mime, mplot)
+
+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))
+    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))
+    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

src/backends/pgfplots.jl

@@ -2,7 +2,7 @@
 
 # significant contributions by: @pkofod
 
-supported_args(::PGFPlotsBackend) = merge_with_base_supported([
+const _pgfplots_attr = merge_with_base_supported([
     # :annotations,
     # :background_color_legend,
     :background_color_inside,
@@ -32,15 +32,20 @@ supported_args(::PGFPlotsBackend) = merge_with_base_supported([
     :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]
+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 => "*",
@@ -94,20 +101,18 @@ const _pgf_series_extrastyle = KW(
 # --------------------------------------------------------------------------------------
 
 # 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)
     cstr = @sprintf("{rgb,1:red,%.8f;green,%.8f;blue,%.8f}", red(c), green(c), blue(c))
-    a = float(a == nothing ? alpha(c) : a)
-    cstr, a
+    cstr, alpha(c)
 end
 
 function pgf_fillstyle(d::KW)
-    cstr,a = pgf_color(d[:fillcolor], d[:fillalpha])
+    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 +122,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]),
@@ -149,6 +154,8 @@ function pgf_series(sp::Subplot, series::Series)
     # add to legend?
     if sp[:legend] != :none && should_add_to_legend(series)
         kw[:legendentry] = d[:label]
+    else
+        push!(style, "forget plot")
     end
 
     # function args
@@ -214,6 +221,11 @@ 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
+
     # limits
     # TODO: support zlims
     if letter != :z
@@ -222,6 +234,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,7 +247,7 @@ end
 # ----------------------------------------------------------------
 
 
-function _make_pgf_plot!(plt::Plot)
+function _update_plot_object(plt::Plot{PGFPlotsBackend})
     plt.o = PGFPlots.Axis[]
     for sp in plt.subplots
         # first build the PGFPlots.Axis object
@@ -240,6 +258,7 @@ 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
@@ -250,13 +269,13 @@ function _make_pgf_plot!(plt::Plot)
         push!(style, """
             xshift = $(left(bb).value)mm,
             yshift = $((height(bb) - (bottom(bb))).value)mm,
-            width = $(width(bb).value)mm,
-            height = $(height(bb).value)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")
@@ -282,14 +301,11 @@ function _make_pgf_plot!(plt::Plot)
 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 +314,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

src/backends/plotly.jl

@@ -1,7 +1,7 @@
 
 # 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,
@@ -20,40 +20,50 @@ supported_args(::PlotlyBackend) = merge_with_base_supported([
     :guide, :lims, :ticks, :scale, :flip, :rotation,
     :tickfont, :guidefont, :legendfont,
     :grid, :legend, :colorbar,
-    :marker_z, :levels,
+    :marker_z, :fill_z, :levels,
     :ribbon, :quiver,
     :orientation,
     # :overwrite_figure,
     :polar,
     :normalize, :weights,
-    # :contours, :aspect_ratio,
+    # :contours,
+    :aspect_ratio,
     :hover,
     :inset_subplots,
+    :bar_width,
   ])
 
-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 +94,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 +133,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 +151,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 +168,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
@@ -159,6 +214,7 @@ function plotly_axis(axis::Axis, sp::Subplot)
         :title      => axis[:guide],
         :showgrid   => sp[:grid],
         :zeroline   => false,
+        :ticks      => "inside",
     )
 
     if letter in (:x,:y)
@@ -166,22 +222,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_border])
+        ax[:linecolor] = rgba_string(axis[:foreground_color_border])
 
         # lims
         lims = axis[:lims]
         if lims != :auto && limsType(lims) == :limits
-            ax[:range] = lims
+            ax[:range] = map(scalefunc(axis[:scale]), lims)
         end
 
         # flip
@@ -190,7 +243,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,7 +267,7 @@ 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[:paper_bgcolor] = rgba_string(plt[:background_color_outside])
     d_out[:margin] = KW(:l=>0, :b=>0, :r=>0, :t=>20)
 
     d_out[:annotations] = KW[]
@@ -222,6 +275,7 @@ function plotly_layout(plt::Plot)
     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 +293,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 +309,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 +365,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 +395,27 @@ 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)
+
 # 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,14 +424,20 @@ 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)
 
+    # 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
+
     # set the "type"
     if st in (:path, :scatter, :scattergl)
         d_out[:type] = st==:scattergl ? "scattergl" : "scatter"
@@ -358,76 +446,53 @@ 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
             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 !(series[:fillrange] in (false, nothing))
+            warn("fillrange ignored... plotly only supports filling to zero. 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[:markercolor], d[:markeralpha])
-        if d[:markerstrokewidth] > 0
-            d_out[:line] = KW(
-                :color => webcolor(d[:markerstrokecolor], d[:markerstrokealpha]),
-                :width => d[:markerstrokewidth],
-                :dash => string(d[:markerstrokestyle]),
-            )
-        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])
 
     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])
 
     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)
+        else
+            d_out[:colorscale] = plotly_colorscale(series[:fillcolor], series[:fillalpha])
+            if series[:fill_z] != nothing
+                d_out[:surfacecolor] = plotly_surface_data(series, series[:fill_z])
+            end
+        end
 
     elseif st == :pie
         d_out[:type] = "pie"
@@ -443,7 +508,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 +518,32 @@ 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 = series[:markercolor]
+            zmin, zmax = extrema(series[:marker_z])
+            [rgba_string(grad[(zi - zmin) / (zmax - zmin)]) 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 +551,95 @@ 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])
+
+    [d_out]
+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 +669,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
 

src/backends/plotlyjs.jl

@@ -1,15 +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())
-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
@@ -26,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
 
@@ -60,16 +85,30 @@ 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 _display(plt::Plot{PlotlyJSBackend})
     display(plt.o)
 end
+
+
+function closeall(::PlotlyJSBackend)
+    if !isplotnull() && isa(current().o, PlotlyJS.SyncPlot)
+        close(current().o)
+    end
+end

src/backends/template.jl

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

src/backends/unicodeplots.jl

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

src/backends/web.jl

@@ -20,13 +20,13 @@ 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()
         return run(`xdg-open $(filename)`)
     end
-    @compat @static if is_windows()
+    @static if is_windows()
         return run(`$(ENV["COMSPEC"]) /c start $(filename)`)
     end
     warn("Unknown OS... cannot open browser window.")
@@ -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)
 

src/components.jl

@@ -14,30 +14,33 @@ 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(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)
+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 +50,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 +75,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 +91,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 +113,8 @@ const _shape_keys = Symbol[
   :xcross,
   :utriangle,
   :dtriangle,
+  :rtriangle,
+  :ltriangle,
   :pentagon,
   :heptagon,
   :octagon,
@@ -119,14 +124,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 +150,14 @@ 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
 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
@@ -164,7 +175,7 @@ function center(shape::Shape)
 end
 
 function Base.scale!(shape::Shape, x::Real, y::Real = x, c = center(shape))
-    sx, sy = shape_coords(shape)
+    sx, sy = coords(shape)
     cx, cy = c
     for i=1:length(sx)
         sx[i] = (sx[i] - cx) * x + cx
@@ -175,11 +186,11 @@ end
 
 function Base.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
 
 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 +200,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,11 +217,12 @@ 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
@@ -223,7 +235,7 @@ end
 # -----------------------------------------------------------------------
 
 
-immutable Font
+type Font
   family::AbstractString
   pointsize::Int
   halign::Symbol
@@ -236,7 +248,7 @@ end
 function font(args...)
 
   # defaults
-  family = "Helvetica"
+  family = "sans-serif"
   pointsize = 14
   halign = :hcenter
   valign = :vcenter
@@ -280,6 +292,17 @@ 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
+function scalefontsizes(factor::Number)
+    for k in (:titlefont, :guidefont, :tickfont, :legendfont)
+        scalefontsize(k, factor)
+    end
+end
+
 "Wrap a string with font info"
 immutable PlotText
   str::AbstractString
@@ -293,11 +316,7 @@ 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)
 
 # -----------------------------------------------------------------------
 
@@ -311,9 +330,9 @@ immutable Stroke
 end
 
 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 +366,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,6 +392,109 @@ 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}
@@ -399,8 +521,8 @@ Base.Array(surf::Surface) = surf.surf
 for f in (:length, :size)
   @eval Base.$f(surf::Surface, args...) = $f(surf.surf, args...)
 end
-Base.copy(surf::Surface) = Surface(copy(surf.surf))
-Base.eltype(surf::Surface) = eltype(surf.surf)
+Base.copy(surf::Surface) = Surface{typeof(surf.surf)}(copy(surf.surf))
+Base.eltype{T}(surf::Surface{T}) = eltype(T)
 
 function expand_extrema!(a::Axis, surf::Surface)
     ex = a[:extrema]
@@ -415,24 +537,59 @@ 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
 
 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 +603,7 @@ function arrow(args...)
             warn("Skipped arrow arg $arg")
         end
     end
-    Arrow(style, headlength, headwidth)
+    Arrow(style, side, headlength, headwidth)
 end
 
 
@@ -465,58 +622,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
 
 # -----------------------------------------------------------------------
 
 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)
 
-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 = extrema(v)
+    vdiff = vmax-vmin
+    buffer = vdiff * buffmult
+    vmin - buffer, vmax + buffer
 end

src/deprecated/backends/bokeh.jl

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

src/deprecated/backends/gadfly.jl

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

src/deprecated/backends/immerse.jl

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

src/deprecated/backends/qwt.jl

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

src/deprecated/backends/winston.jl

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

src/deprecated/colors.jl

@@ -1,10 +1,38 @@
 
 abstract ColorScheme
 
+Base.getindex(scheme::ColorScheme, i::Integer) = getColor(scheme, i)
+
+export
+    cgrad
+
+cgrad() = default_gradient()
+
+function cgrad(arg, values = nothing; alpha = nothing, scale = :identity)
+    colors = ColorGradient(arg, alpha=alpha).colors
+    values = if values != nothing
+        values
+    elseif scale in (:log, :log10)
+        log10(linspace(1,10,30))
+    elseif scale == :log2
+        log2(linspace(1,2,30))
+    elseif scale == :ln
+        log(linspace(1,pi,30))
+    elseif scale in (:exp, :exp10)
+        (exp10(linspace(0,1,30)) - 1) / 9
+    else
+        linspace(0, 1, length(colors))
+    end
+    ColorGradient(colors, values)
+end
+
+# --------------------------------------------------------------
+
 getColor(scheme::ColorScheme) = getColor(scheme, 1)
 getColorVector(scheme::ColorScheme) = [getColor(scheme)]
 
 colorscheme(scheme::ColorScheme) = scheme
+colorscheme(s::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...)
@@ -28,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)
@@ -51,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)]
 
@@ -103,6 +131,12 @@ immutable ColorGradient <: ColorScheme
   end
 end
 
+
+
+Base.getindex(cs::ColorGradient, i::Integer) = getColor(cs, i)
+Base.getindex(cs::ColorGradient, z::Number) = getColorZ(cs, z)
+
+
 # create a gradient from a symbol (blues, reds, etc) and vector of boundary values
 function ColorGradient{T<:Real}(s::Symbol, vals::AVec{T} = 0:0; kw...)
   haskey(_gradients, s) || error("Invalid gradient symbol.  Choose from: ", sort(collect(keys(_gradients))))
@@ -187,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)
 
 # --------------------------------------------------------------
 
@@ -213,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
 
 # --------------------------------------------------------------
 

src/deprecated/series_args.jl

@@ -0,0 +1,99 @@
+
+# create a new "build_series_args" which converts all inputs into xs = Any[xitems], ys = Any[yitems].
+# Special handling for: no args, xmin/xmax, parametric, dataframes
+# Then once inputs have been converted, build the series args, map functions, etc.
+# This should cut down on boilerplate code and allow more focused dispatch on type
+# note: returns meta information... mainly for use with automatic labeling from DataFrames for now
+
+typealias FuncOrFuncs @compat(Union{Function, AVec{Function}})
+
+all3D(d::KW) = trueOrAllTrue(st -> st in (:contour, :contourf, :heatmap, :surface, :wireframe, :contour3d, :image), get(d, :seriestype, :none))
+
+# missing
+convertToAnyVector(v::@compat(Void), d::KW) = Any[nothing], nothing
+
+# fixed number of blank series
+convertToAnyVector(n::Integer, d::KW) = Any[zeros(0) for i in 1:n], nothing
+
+# numeric vector
+convertToAnyVector{T<:Number}(v::AVec{T}, d::KW) = Any[v], nothing
+
+# string vector
+convertToAnyVector{T<:@compat(AbstractString)}(v::AVec{T}, d::KW) = Any[v], nothing
+
+function convertToAnyVector(v::AMat, d::KW)
+    if all3D(d)
+        Any[Surface(v)]
+    else
+        Any[v[:,i] for i in 1:size(v,2)]
+    end, nothing
+end
+
+# function
+convertToAnyVector(f::Function, d::KW) = Any[f], nothing
+
+# surface
+convertToAnyVector(s::Surface, d::KW) = Any[s], nothing
+
+# # vector of OHLC
+# convertToAnyVector(v::AVec{OHLC}, d::KW) = Any[v], nothing
+
+# dates
+convertToAnyVector{D<:Union{Date,DateTime}}(dts::AVec{D}, d::KW) = Any[dts], nothing
+
+# list of things (maybe other vectors, functions, or something else)
+function convertToAnyVector(v::AVec, d::KW)
+    if all(x -> typeof(x) <: Number, v)
+        # all real numbers wrap the whole vector as one item
+        Any[convert(Vector{Float64}, v)], nothing
+    else
+        # something else... treat each element as an item
+        vcat(Any[convertToAnyVector(vi, d)[1] for vi in v]...), nothing
+        # Any[vi for vi in v], nothing
+    end
+end
+
+convertToAnyVector(t::Tuple, d::KW) = Any[t], nothing
+
+
+function convertToAnyVector(args...)
+    error("In convertToAnyVector, could not handle the argument types: $(map(typeof, args[1:end-1]))")
+end
+
+# --------------------------------------------------------------------
+
+# TODO: can we avoid the copy here?  one error that crops up is that mapping functions over the same array
+#       result in that array being shared.  push!, etc will add too many items to that array
+
+compute_x(x::Void, y::Void, z)      = 1:size(z,1)
+compute_x(x::Void, y, z)            = 1:size(y,1)
+compute_x(x::Function, y, z)        = map(x, y)
+compute_x(x, y, z)                  = copy(x)
+
+# compute_y(x::Void, y::Function, z)  = error()
+compute_y(x::Void, y::Void, z)      = 1:size(z,2)
+compute_y(x, y::Function, z)        = map(y, x)
+compute_y(x, y, z)                  = copy(y)
+
+compute_z(x, y, z::Function)        = map(z, x, y)
+compute_z(x, y, z::AbstractMatrix)  = Surface(z)
+compute_z(x, y, z::Void)            = nothing
+compute_z(x, y, z)                  = copy(z)
+
+nobigs(v::AVec{BigFloat}) = map(Float64, v)
+nobigs(v::AVec{BigInt}) = map(Int64, v)
+nobigs(v) = v
+
+@noinline function compute_xyz(x, y, z)
+    x = compute_x(x,y,z)
+    y = compute_y(x,y,z)
+    z = compute_z(x,y,z)
+    nobigs(x), nobigs(y), nobigs(z)
+end
+
+# not allowed
+compute_xyz(x::Void, y::FuncOrFuncs, z)       = error("If you want to plot the function `$y`, you need to define the x values!")
+compute_xyz(x::Void, y::Void, z::FuncOrFuncs) = error("If you want to plot the function `$z`, you need to define x and y values!")
+compute_xyz(x::Void, y::Void, z::Void)        = error("x/y/z are all nothing!")
+
+# --------------------------------------------------------------------

src/examples.jl

@@ -40,7 +40,7 @@ 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)
+        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,7 +61,7 @@ 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",
@@ -115,7 +115,7 @@ 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])'
         n = length(styles)
         y = cumsum(randn(20,n),1)
         plot(y, line = (5, styles), label = map(string,styles))
@@ -125,7 +125,7 @@ PlotExample("Line styles",
 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)'
         n = length(markers)
         x = linspace(0,10,n+2)[2:end-1]
         y = repmat(reverse(x)', n, 1)
@@ -221,12 +221,6 @@ PlotExample("Contours",
         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 +252,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)]
 ),
 
@@ -303,8 +297,8 @@ PlotExample("Boxplot and Violin series recipes",
     [:(begin
         import RDatasets
         singers = RDatasets.dataset("lattice", "singer")
-        violin(singers, :VoicePart, :Height, marker = (0.2, :blue, stroke(0)))
-        boxplot!(singers, :VoicePart, :Height, marker = (0.3, :orange, stroke(2)))
+        violin(singers, :VoicePart, :Height, line = 0, fill = (0.2, :blue))
+        boxplot!(singers, :VoicePart, :Height, line = (2,:black), fill = (0.3, :orange))
     end)]
 )
 

src/layouts.jl

@@ -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.:.*(m::Measure, n::Number) = m * n
+Base.:.*(n::Number, m::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,24 +96,83 @@ 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
 
 Base.show(io::IO, layout::AbstractLayout) = print(io, "$(typeof(layout))$(size(layout))")
 
+make_measure_hor(n::Number) = n * w
+make_measure_hor(m::Measure) = m
+
+make_measure_vert(n::Number) = n * h
+make_measure_vert(m::Measure) = m
+
+
+function bbox(x, y, w, h, oarg1::Symbol, originargs::Symbol...)
+    oargs = vcat(oarg1, originargs...)
+    orighor = :left
+    origver = :top
+    for oarg in oargs
+        if oarg == :center
+            orighor = origver = oarg
+        elseif oarg in (:left, :right, :hcenter)
+            orighor = oarg
+        elseif oarg in (:top, :bottom, :vcenter)
+            origver = oarg
+        else
+            warn("Unused origin arg in bbox construction: $oarg")
+        end
+    end
+    bbox(x, y, w, h; h_anchor = orighor, v_anchor = origver)
+end
+
 # create a new bbox
-function bbox(x, y, w, h; h_anchor = :left, v_anchor = :top)
+function bbox(x, y, width, height; h_anchor = :left, v_anchor = :top)
+    x = make_measure_hor(x)
+    y = make_measure_vert(y)
+    width = make_measure_hor(width)
+    height = make_measure_vert(height)
     left = if h_anchor == :left
         x
+    elseif h_anchor in (:center, :hcenter)
+        0.5w - 0.5width + x
     else
-        x - w * (h_anchor == :right ? 1.0 : 0.5)
+        1w - x - width
     end
     top = if v_anchor == :top
         y
+    elseif v_anchor in (:center, :vcenter)
+        0.5h - 0.5height + y
     else
-        y - h * (v_anchor == :bottom ? 1.0 : 0.5)
+        1h - y - height
     end
-    BoundingBox(left, top, w, h)
+    BoundingBox(left, top, width, height)
 end
 
 # this is the available area for drawing everything in this layout... as percentages of total canvas
@@ -212,7 +271,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
 
@@ -229,7 +290,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
@@ -284,7 +345,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
@@ -293,7 +353,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])
@@ -304,22 +363,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
@@ -360,7 +415,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(
@@ -409,7 +463,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
@@ -475,6 +529,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)
@@ -511,6 +571,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)
@@ -570,7 +636,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
 
@@ -607,13 +673,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)
@@ -627,20 +698,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, 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...)
@@ -664,6 +757,16 @@ function link_axes!(layout::GridLayout, link::Symbol)
             link_axes!(layout.grid[r,:], :yaxis)
         end
     end
+    if link == :square
+        sps = filter(l -> isa(l, Subplot), layout.grid)
+        if !isempty(sps)
+            base_axis = sps[1][:xaxis]
+            for sp in sps
+                link_axes!(base_axis, sp[:xaxis])
+                link_axes!(base_axis, sp[:yaxis])
+            end
+        end
+    end
     if link == :all
         link_axes!(layout.grid, :xaxis)
         link_axes!(layout.grid, :yaxis)
@@ -672,3 +775,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])

src/output.jl

@@ -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)
@@ -103,6 +122,13 @@ savefig(fn::AbstractString) = savefig(current(), fn)
 
 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 +137,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,63 +154,73 @@ 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 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
 
+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, readall(open(pngfn)))
     end
 end
 
@@ -187,12 +230,12 @@ 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")
@@ -205,7 +248,7 @@ end
 # IJulia
 # ---------------------------------------------------------
 
-const _ijulia_output = Compat.ASCIIString["text/html"]
+const _ijulia_output = String["text/html"]
 
 function setup_ijulia()
     # override IJulia inline display
@@ -220,7 +263,12 @@ function setup_ijulia()
             end
             function IJulia.display_dict(plt::Plot)
                 global _ijulia_output
-                Dict{Compat.ASCIIString, ByteString}(_ijulia_output[1] => sprint(writemime, _ijulia_output[1], plt))
+                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
         end
         set_ijulia_output("text/html")
@@ -232,28 +280,48 @@ end
 # ---------------------------------------------------------
 
 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 isatom()
+        @eval import Atom, Media
+        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)))"
-
-        # 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))))
+        # default text/plain so it doesn't complain
+        function Base.show{B}(io::IO, ::MIME"text/plain", plt::Plot{B})
+            print(io, "Plot{$B}()")
         end
 
+        function Media.render(e::Atom.Editor, plt::Plot)
+            Media.render(e, nothing)
+        end
 
-        # function Atom.Media.render(pane::Atom.PlotPane, plt::Plot{PlotlyBackend})
-        #     html = Media.render(pane, Atom.div(Atom.d(), Atom.HTML(stringmime(MIME("text/html"), plt))))
-        # end
+        if get(ENV, "PLOTS_USE_ATOM_PLOTPANE", true) in (true, 1, "1", "true", "yes")
+            # this is like "display"... sends an html div with the plot to the PlotPane
+            function Media.render(pane::Atom.PlotPane, plt::Plot)
+                # temporarily overwrite size to be Atom.plotsize
+                sz = plt[:size]
+                plt[:size] = Juno.plotsize()
+                Media.render(pane, Atom.div(".fill", Atom.HTML(stringmime(MIME("text/html"), plt))))
+                plt[:size] = sz
+            end
+        else
+            #
+            function Media.render(pane::Atom.PlotPane, plt::Plot)
+                display(Plots.PlotsDisplay(), plt)
+                s = "PlotPane turned off.  Unset ENV[\"PLOTS_USE_ATOM_PLOTPANE\"] and restart Julia to enable it."
+                Media.render(pane, Atom.div(Atom.HTML(s)))
+            end
+        end
+
+        # special handling for plotly... use PlotsDisplay
+        function Media.render(pane::Atom.PlotPane, plt::Plot{PlotlyBackend})
+            display(Plots.PlotsDisplay(), plt)
+            s = "PlotPane turned off.  The plotly and plotlyjs backends cannot render in the PlotPane due to javascript issues."
+            Media.render(pane, Atom.div(Atom.HTML(s)))
+        end
+
+        # special handling for PlotlyJS to pass through to that render method
+        function Media.render(pane::Atom.PlotPane, plt::Plot{PlotlyJSBackend})
+            Plots.prepare_output(plt)
+            Media.render(pane, plt.o)
+        end
     end
 end

src/pipeline.jl

@@ -0,0 +1,414 @@
+
+
+# ------------------------------------------------------------------
+# 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 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.
+    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)
+        next_series = shift!(still_to_process)
+        rd_list = RecipesBase.apply_recipe(next_series.d, next_series.args...)
+        for recipedata in rd_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)
+                _process_userrecipe(plt, kw_list, recipedata)
+            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
+    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 = [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
+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 = _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
+        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, :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

src/plot.jl

@@ -49,7 +49,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
@@ -89,8 +89,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 +108,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,341 +148,75 @@ 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)
-    st = d[:seriestype]
-    # @show st
-    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 = 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
+    _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...)
-    # d = plt.user_attr
+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...)
+    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.
+    kw_list = _process_userrecipes(plt, d, args)
+
+    # info(1)
+    # map(DD, kw_list)
+
+
+    # --------------------------------
+    # "PLOT RECIPES"
+    # --------------------------------
+
+    # "plot recipe", which acts like a series type, and is processed before
+    # the plot layout is created, which allows for setting layouts and other plot-wide attributes.
+    # we get inputs which have been fully processed by "user recipes" and "type recipes",
+    # so we can expect standard vectors, surfaces, etc.  No defaults have been set yet.
+    still_to_process = kw_list
     kw_list = KW[]
-    still_to_process = isempty(args) ? [] : [RecipeData(copy(d), args)]
     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)
-        next_series = shift!(still_to_process)
-        for recipedata in RecipesBase.apply_recipe(next_series.d, next_series.args...)
-
-            # 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
+        next_kw = shift!(still_to_process)
+        _process_plotrecipe(plt, next_kw, kw_list, still_to_process)
     end
 
-    # don't allow something else to handle it
-    d[:smooth] = false
+    # info(2)
+    # map(DD, kw_list)
 
-    # merge in anything meant for plot/subplot/axis
-    for kw in kw_list
-        for (k,v) in kw
-            for defdict in (_plot_defaults,)
-                            # _subplot_defaults,
-                            # _axis_defaults,
-                            # _axis_defaults_byletter)
-                if haskey(defdict, k)
-                    d[k] = pop!(kw, k)
-                end
-            end
-        end
-    end
-
-    # TODO: init subplots here
-    _update_plot_args(plt, d)
-    if !plt.init
-        plt.o = _create_backend_figure(plt)
-        # DD(d)
-
-        # 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
-        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
-            push!(plt.subplots, sp)
-            sp.attr[:subplot_index] = length(plt.subplots)
-            push!(plt.inset_subplots, sp)
-        end
-    end
-
-    # we'll keep a map of subplot to an attribute override dict.
-    # any series which belong to that subplot
-    sp_attrs = Dict{Subplot,Any}()
-    for kw in kw_list
-        # get the Subplot object to which the series belongs
-        sp = get(kw, :subplot, :auto)
-        command_idx = kw[:series_plotindex] - kw_list[1][:series_plotindex] + 1
-        sp = if sp == :auto
-            cycle(plt.subplots, command_idx)
-            # mod1(command_idx, length(plt.subplots))
-        else
-            slice_arg(sp, command_idx)
-        end
-        sp = kw[:subplot] = get_subplot(plt, sp)
-        # idx = get_subplot_index(plt, 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
-
-
-
-    # # 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)
-        # if we picked up any subplot-specific overrides, merge them here
-        attr = merge(d, get(sp_attrs, sp, KW()))
-        # DD(attr, "sp$idx")
-        _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/Subplot/Layout setup
+    # --------------------------------
+    _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 !!!
 
-    # this is it folks!
-    # TODO: we probably shouldn't use i for tracking series index, but rather explicitly track it in recipes
+    # --------------------------------
+    # "SERIES RECIPES"
+    # --------------------------------
+
+    # info(3)
+    # map(DD, kw_list)
+
     for kw in kw_list
-        command_idx = kw[:series_plotindex] - kw_list[1][:series_plotindex] + 1
+        sp::Subplot = kw[:subplot]
+        # idx = get_subplot_index(plt, sp)
 
-        # # get the Subplot object to which the series belongs
-        # sp = get(kw, :subplot, :auto)
-        # sp = if sp == :auto
-        #     mod1(i,length(plt.subplots))
-        # else
-        #     slice_arg(sp, i)
-        # end
-        # sp = kw[:subplot] = get_subplot(plt, sp)
-        sp = kw[:subplot]
-        idx = get_subplot_index(plt, sp)
-
-        # # 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!(kw, :series_annotations, []))
-        # if length(anns) > 0
-        #     x, y = kw[:x], kw[: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)
-
-        # we update subplot args in case something like the color palatte is part of the recipe
-        _update_subplot_args(plt, sp, kw, idx)
+        # # we update subplot args in case something like the color palatte is part of the recipe
+        # _update_subplot_args(plt, sp, kw, idx, true)
 
         # set default values, select from attribute cycles, and generally set the final attributes
-        _add_defaults!(kw, plt, sp, command_idx)
+        _add_defaults!(kw, plt, sp, command_idx(kw_list,kw))
 
         # now we have a fully specified series, with colors chosen.   we must recursively handle
         # series recipes, which dispatch on seriestype.  If a backend does not natively support a seriestype,
@@ -492,29 +224,23 @@ 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
 
+    # --------------------------------
+
     current(plt)
 
-    # note: lets ignore the show param and effectively use the semicolon at the end of the REPL statement
-    # # do we want to show it?
-    # if haskey(d, :show) && d[:show]
-    if get(d, :show, default(:show))
-        gui()
-    end
+    # do we want to force display?
+    # 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)
@@ -540,81 +266,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
 
 # --------------------------------------------------------------------

src/precompile.jl

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

src/recipes.jl

@@ -1,10 +1,5 @@
 
 
-# TODO: there should be a distinction between an object that will manage a full plot, vs a component of a plot.
-# the PlotRecipe as currently implemented is more of a "custom component"
-# a recipe should fully describe the plotting command(s) and call them, likewise for updating.
-#   actually... maybe those should explicitly derive from AbstractPlot???
-
 
 """
 You can easily define your own plotting recipes with convenience methods:
@@ -66,10 +61,10 @@ end
 # returns :no, :native, or :recipe depending on how it's supported
 function seriestype_supported(pkg::AbstractBackend, st::Symbol)
     # is it natively supported
-    if st in supported_types(pkg)
+    if is_seriestype_supported(pkg, st)
         return :native
     end
-    
+
     haskey(_series_recipe_deps, st) || return :no
 
     supported = true
@@ -82,7 +77,7 @@ function seriestype_supported(pkg::AbstractBackend, st::Symbol)
 end
 
 macro deps(st, args...)
-    :(series_recipe_dependencies($(quot(st)), $(map(quot, args)...)))
+    :(Plots.series_recipe_dependencies($(quot(st)), $(map(quot, args)...)))
 end
 
 # get a list of all seriestypes
@@ -90,7 +85,7 @@ function all_seriestypes()
     sts = Set{Symbol}(keys(_series_recipe_deps))
     for bsym in backends()
         btype = _backendType[bsym]
-        sts = union(sts, Set{Symbol}(supported_types(btype())))
+        sts = union(sts, Set{Symbol}(supported_seriestypes(btype())))
     end
     sort(collect(sts))
 end
@@ -98,92 +93,13 @@ end
 
 # ----------------------------------------------------------------------------------
 
-abstract PlotRecipe
-
-getRecipeXY(recipe::PlotRecipe) = Float64[], Float64[]
-getRecipeArgs(recipe::PlotRecipe) = ()
-
-plot(recipe::PlotRecipe, args...; kw...) = plot(getRecipeXY(recipe)..., args...; getRecipeArgs(recipe)..., kw...)
-plot!(recipe::PlotRecipe, args...; kw...) = plot!(getRecipeXY(recipe)..., args...; getRecipeArgs(recipe)..., kw...)
-plot!(plt::Plot, recipe::PlotRecipe, args...; kw...) = plot!(getRecipeXY(recipe)..., args...; getRecipeArgs(recipe)..., kw...)
-
 num_series(x::AMat) = size(x,2)
 num_series(x) = 1
 
-
-# # if it's not a recipe, just do nothing and return the args
-# function RecipesBase.apply_recipe(d::KW, args...; issubplot=false)
-#     if issubplot && !isempty(args) && !haskey(d, :n) && !haskey(d, :layout)
-#         # put in a sensible default
-#         d[:n] = maximum(map(num_series, args))
-#     end
-#     args
-# end
-
-
-if is_installed("DataFrames")
-    @eval begin
-        import DataFrames
-        DFS = Union{Symbol, AbstractArray{Symbol}}
-
-        function handle_dfs(df::DataFrames.AbstractDataFrame, d::KW, letter, dfs::DFS)
-            if isa(dfs, Symbol)
-                get!(d, Symbol(letter * "guide"), string(dfs))
-                collect(df[dfs])
-            else
-                get!(d, :label, reshape(dfs, 1, length(dfs)))
-                Any[collect(df[s]) for s in dfs]
-            end
-        end
-
-        function extractGroupArgs(group::Symbol, df::DataFrames.AbstractDataFrame, args...)
-            extractGroupArgs(collect(df[group]))
-        end
-
-
-        function handle_group(df::DataFrames.AbstractDataFrame, d::KW)
-            if haskey(d, :group)
-                g = d[:group]
-                if isa(g, Symbol)
-                    d[:group] = collect(df[g])
-                end
-            end
-        end
-
-        @recipe function f(df::DataFrames.AbstractDataFrame, sy::DFS)
-            handle_group(df, d)
-            handle_dfs(df, d, "y", sy)
-        end
-
-        @recipe function f(df::DataFrames.AbstractDataFrame, sx::DFS, sy::DFS)
-            handle_group(df, d)
-            x = handle_dfs(df, d, "x", sx)
-            y = handle_dfs(df, d, "y", sy)
-            x, y
-        end
-
-        @recipe function f(df::DataFrames.AbstractDataFrame, sx::DFS, sy::DFS, sz::DFS)
-            handle_group(df, d)
-            x = handle_dfs(df, d, "x", sx)
-            y = handle_dfs(df, d, "y", sy)
-            z = handle_dfs(df, d, "z", sz)
-            x, y, z
-        end
-    end
-end
-
+RecipesBase.apply_recipe{T}(d::KW, ::Type{T}, plt::Plot) = throw(MethodError("Unmatched plot recipe: $T"))
 
 # ---------------------------------------------------------------------------
 
-# """
-# `apply_series_recipe` should take a processed series KW dict and break it up
-# into component parts.  For example, a box plot is made up of `shape` for the
-# boxes, `path` for the lines, and `scatter` for the outliers.
-#
-# Returns a Vector{KW}.
-# """
-# apply_series_recipe(d::KW, st) = KW[d]
-
 
 # for seriestype `line`, need to sort by x values
 @recipe function f(::Type{Val{:line}}, x, y, z)
@@ -198,24 +114,21 @@ end
 end
 @deps line path
 
-# @recipe function f(::Type{Val{:sticks}}, x, y, z)
-#     nx = length(x)
-#     n = 3nx
-#     newx, newy = zeros(n), zeros(n)
-#     for i=1:nx
-#         rng = 3i-2:3i
-#         newx[rng] = x[i]
-#         newy[rng] = [0., y[i], 0.]
-#     end
-#     x := newx
-#     y := newy
-#     seriestype := :path
-#     ()
-# end
-# @deps sticks path
+
+function hvline_limits(axis::Axis)
+    vmin, vmax = axis_limits(axis)
+    if vmin >= vmax
+        if isfinite(vmin)
+            vmax = vmin + 1
+        else
+            vmin, vmax = 0.0, 1.1
+        end
+    end
+    vmin, vmax
+end
 
 @recipe function f(::Type{Val{:hline}}, x, y, z)
-    xmin, xmax = axis_limits(d[:subplot][:xaxis])
+    xmin, xmax = hvline_limits(d[:subplot][:xaxis])
     n = length(y)
     newx = repmat(Float64[xmin, xmax, NaN], n)
     newy = vec(Float64[yi for i=1:3,yi=y])
@@ -227,7 +140,7 @@ end
 @deps hline path
 
 @recipe function f(::Type{Val{:vline}}, x, y, z)
-    ymin, ymax = axis_limits(d[:subplot][:yaxis])
+    ymin, ymax = hvline_limits(d[:subplot][:yaxis])
     n = length(y)
     newx = vec(Float64[yi for i=1:3,yi=y])
     newy = repmat(Float64[ymin, ymax, NaN], n)
@@ -243,6 +156,7 @@ end
 
 function make_steps(x, y, st)
     n = length(x)
+    n == 0 && return zeros(0),zeros(0)
     newx, newy = zeros(2n-1), zeros(2n-1)
     for i=1:n
         idx = 2i-1
@@ -302,19 +216,23 @@ end
 # ---------------------------------------------------------------------------
 # sticks
 
-sticks_fillfrom(fr::Void, i::Integer) = 0.0
-sticks_fillfrom(fr::Number, i::Integer) = fr
-sticks_fillfrom(fr::AVec, i::Integer) = fr[mod1(i, length(fr))]
-
 # create vertical line segments from fill
 @recipe function f(::Type{Val{:sticks}}, x, y, z)
     n = length(x)
     fr = d[:fillrange]
+    if fr == nothing
+        yaxis = d[:subplot][:yaxis]
+        fr = if yaxis[:scale] == :identity
+            0.0
+        else
+            min(axis_limits(yaxis)[1], minimum(y))
+        end
+    end
     newx, newy = zeros(3n), zeros(3n)
     for i=1:n
         rng = 3i-2:3i
         newx[rng] = [x[i], x[i], NaN]
-        newy[rng] = [sticks_fillfrom(fr,i), y[i], NaN]
+        newy[rng] = [cycle(fr,i), y[i], NaN]
     end
     x := newx
     y := newy
@@ -341,7 +259,7 @@ end
 # ---------------------------------------------------------------------------
 # bezier curves
 
-# get the value of the curve point at position t 
+# get the value of the curve point at position t
 function bezier_value(pts::AVec, t::Real)
     val = 0.0
     n = length(pts)-1
@@ -352,15 +270,14 @@ function bezier_value(pts::AVec, t::Real)
 end
 
 # create segmented bezier curves in place of line segments
-@recipe function f(::Type{Val{:curves}}, x, y, z)
+@recipe function f(::Type{Val{:curves}}, x, y, z; npoints = 30)
     args = z != nothing ? (x,y,z) : (x,y)
     newx, newy = zeros(0), zeros(0)
     fr = d[:fillrange]
     newfr = fr != nothing ? zeros(0) : nothing
     newz = z != nothing ? zeros(0) : nothing
-    lz = d[:line_z]
-    newlz = lz != nothing ? zeros(0) : nothing
-    npoints = pop!(d, :npoints, 30)
+    # lz = d[:line_z]
+    # newlz = lz != nothing ? zeros(0) : nothing
 
     # for each line segment (point series with no NaNs), convert it into a bezier curve
     # where the points are the control points of the curve
@@ -375,15 +292,11 @@ end
         if fr != nothing
             nanappend!(newfr, map(t -> bezier_value(cycle(fr,rng), t), ts))
         end
-        if lz != nothing
-            lzrng = cycle(lz, rng) # the line_z's for this segment
-            # @show lzrng, sizeof(lzrng) map(t -> 1+floor(Int, t * (length(rng)-1)), ts)
-            # choose the line_z value of the control point just before this t
-            push!(newlz, 0.0)
-            append!(newlz, map(t -> lzrng[1+floor(Int, t * (length(rng)-1))], ts))
-            # lzrng = vcat()
-            # nanappend!(newlz,   #map(t -> bezier_value(cycle(lz,rng), t), ts))
-        end
+        # if lz != nothing
+        #     lzrng = cycle(lz, rng) # the line_z's for this segment
+        #     push!(newlz, 0.0)
+        #     append!(newlz, map(t -> lzrng[1+floor(Int, t * (length(rng)-1))], ts))
+        # end
     end
 
     x := newx
@@ -397,10 +310,10 @@ end
     if fr != nothing
         fillrange := newfr
     end
-    if lz != nothing
-        line_z := newlz
-        linecolor := (isa(d[:linecolor], ColorGradient) ? d[:linecolor] : default_gradient())
-    end
+    # if lz != nothing
+    #     # line_z := newlz
+    #     linecolor := (isa(d[:linecolor], ColorGradient) ? d[:linecolor] : cgrad())
+    # end
     # Plots.DD(d)
     ()
 end
@@ -411,61 +324,59 @@ end
 # create a bar plot as a filled step function
 @recipe function f(::Type{Val{:bar}}, x, y, z)
     nx, ny = length(x), length(y)
-    edges = if nx == ny
-        # x is centers, calc the edges
-        # TODO: use bar_width, etc
-        midpoints = x
-        halfwidths = diff(midpoints) * 0.5
-        Float64[if i == 1
-            midpoints[1] - halfwidths[1]
-        elseif i == ny+1
-            midpoints[i-1] + halfwidths[i-2]
-        else
-            midpoints[i-1] + halfwidths[i-1]
-        end for i=1:ny+1]
+    axis = d[:subplot][isvertical(d) ? :xaxis : :yaxis]
+    cv = [discrete_value!(axis, xi)[1] for xi=x]
+    x = if nx == ny
+        cv
     elseif nx == ny + 1
-        # x is edges
-        x
+        0.5diff(cv) + cv[1:end-1]
     else
         error("bar recipe: x must be same length as y (centers), or one more than y (edges).\n\t\tlength(x)=$(length(x)), length(y)=$(length(y))")
     end
 
+    # compute half-width of bars
+    bw = d[:bar_width]
+    hw = if bw == nothing
+        0.5mean(diff(x))
+    else
+        Float64[0.5cycle(bw,i) for i=1:length(x)]
+    end
+
     # make fillto a vector... default fills to 0
     fillto = d[:fillrange]
     if fillto == nothing
-        fillto = zeros(1)
-    elseif isa(fillto, Number)
-        fillto = Float64[fillto]
+        fillto = 0
     end
-    nf = length(fillto)
 
-    npts = 3ny + 1
-    heights = y
-    x = zeros(npts)
-    y = zeros(npts)
-    fillrng = zeros(npts)
-
-    # create the path in triplets.  after the first bottom-left coord of the first bar:
-    # add the top-left, top-right, and bottom-right coords for each height
-    x[1] = edges[1]
-    y[1] = fillto[1]
-    fillrng[1] = fillto[1]
+    # create the bar shapes by adding x/y segments
+    xseg, yseg = Segments(), Segments()
     for i=1:ny
-        idx = 3i
-        rng = idx-1:idx+1
-        fi = fillto[mod1(i,nf)]
-        x[rng] = [edges[i], edges[i+1], edges[i+1]]
-        y[rng] = [heights[i], heights[i], fi]
-        fillrng[rng] = [fi, fi, fi]
+        center = x[i]
+        hwi = cycle(hw,i)
+        yi = y[i]
+        fi = cycle(fillto,i)
+        push!(xseg, center-hwi, center-hwi, center+hwi, center+hwi, center-hwi)
+        push!(yseg, yi, fi, fi, yi, yi)
     end
 
-    x := x
-    y := y
-    fillrange := fillrng
-    seriestype := :path
+    # widen limits out a bit
+    expand_extrema!(axis, widen(extrema(xseg.pts)...))
+
+    # switch back
+    if !isvertical(d)
+        xseg, yseg = yseg, xseg
+    end
+
+
+    # reset orientation
+    orientation := default(:orientation)
+
+    x := xseg.pts
+    y := yseg.pts
+    seriestype := :shape
     ()
 end
-@deps bar path
+@deps bar shape
 
 # ---------------------------------------------------------------------------
 # Histograms
@@ -477,7 +388,7 @@ function calc_edges(v, bins::Integer)
 end
 
 # just pass through arrays
-calc_edges(v, bins::AVec) = v
+calc_edges(v, bins::AVec) = bins
 
 # find the bucket index of this value
 function bucket_index(vi, edges)
@@ -548,15 +459,21 @@ function my_hist_2d(x, y, bins; normed = false, weights = nothing)
     xedges, yedges, counts ./ norm_denom
 end
 
-centers(v::AVec) = v[1] + cumsum(diff(v))
+centers(v::AVec) = 0.5 * (v[1:end-1] + v[2:end])
 
 @recipe function f(::Type{Val{:histogram2d}}, x, y, z)
     xedges, yedges, counts = my_hist_2d(x, y, d[:bins],
                                               normed = d[:normalize],
                                               weights = d[:weights])
+    for (i,c) in enumerate(counts)
+        if c == 0
+            counts[i] = NaN
+        end
+    end
     x := centers(xedges)
     y := centers(yedges)
     z := Surface(counts)
+    linewidth := 0
     seriestype := :heatmap
     ()
 end
@@ -578,198 +495,15 @@ end
 
 # note: don't add dependencies because this really isn't a drop-in replacement
 
-# ---------------------------------------------------------------------------
-# Box Plot
-
-const _box_halfwidth = 0.4
-
-notch_width(q2, q4, N) = 1.58 * (q4-q2)/sqrt(N)
-
-# function apply_series_recipe(d::KW, ::Type{Val{:box}})
-@recipe function f(::Type{Val{:boxplot}}, x, y, z; notch=false, range=1.5)
-    # Plots.dumpdict(d, "box before", true)
-
-    # create a list of shapes, where each shape is a single boxplot
-    shapes = Shape[]
-    groupby = extractGroupArgs(x)
-    outliers_y = Float64[]
-    outliers_x = Float64[]
-
-    warning = false
-
-    for (i, glabel) in enumerate(groupby.groupLabels)
-
-        # filter y values
-        values = d[:y][groupby.groupIds[i]]
-        # then compute quantiles
-        q1,q2,q3,q4,q5 = quantile(values, linspace(0,1,5))
-        # notch
-        n = notch_width(q2, q4, length(values))
-
-        if notch && !warning && ( (q2>(q3-n)) || (q4<(q3+n)) )
-            warn("Boxplot's notch went outside hinges. Set notch to false.")
-            warning = true # Show the warning only one time
-        end
-
-        # make the shape
-        center = discrete_value!(d[:subplot][:xaxis], glabel)[1]
-        l, m, r = center - _box_halfwidth, center, center + _box_halfwidth
-        # internal nodes for notches
-        L, R = center - 0.5 * _box_halfwidth, center + 0.5 * _box_halfwidth
-        # outliers
-        if Float64(range) != 0.0  # if the range is 0.0, the whiskers will extend to the data
-            limit = range*(q4-q2)
-            inside = Float64[]
-            for value in values
-                if (value < (q2 - limit)) || (value > (q4 + limit))
-                    push!(outliers_y, value)
-                    push!(outliers_x, center)
-                else
-                    push!(inside, value)
-                end
-            end
-            # change q1 and q5 to show outliers
-            # using maximum and minimum values inside the limits
-            q1, q5 = extrema(inside)
-        end
-        # Box
-        xcoords = notch::Bool ? [
-            m, l, r, m, m, NaN,       # lower T
-            l, l, L, R, r, r, l, NaN, # lower box
-            l, l, L, R, r, r, l, NaN, # upper box
-            m, l, r, m, m, NaN,       # upper T
-        ] : [
-            m, l, r, m, m, NaN,         # lower T
-            l, l, r, r, l, NaN,         # lower box
-            l, l, r, r, l, NaN,         # upper box
-            m, l, r, m, m, NaN,         # upper T
-        ]
-        ycoords = notch::Bool ? [
-            q1, q1, q1, q1, q2, NaN,             # lower T
-            q2, q3-n, q3, q3, q3-n, q2, q2, NaN, # lower box
-            q4, q3+n, q3, q3, q3+n, q4, q4, NaN, # upper box
-            q5, q5, q5, q5, q4, NaN,             # upper T
-        ] : [
-            q1, q1, q1, q1, q2, NaN,    # lower T
-            q2, q3, q3, q2, q2, NaN,    # lower box
-            q4, q3, q3, q4, q4, NaN,    # upper box
-            q5, q5, q5, q5, q4, NaN,    # upper T
-        ]
-        push!(shapes, Shape(xcoords, ycoords))
-    end
-
-    # d[:plotarg_overrides] = KW(:xticks => (1:length(shapes), groupby.groupLabels))
-
-    seriestype := :shape
-    # n = length(groupby.groupLabels)
-    # xticks --> (linspace(0.5,n-0.5,n), groupby.groupLabels)
-
-    # clean d
-    pop!(d, :notch)
-    pop!(d, :range)
-
-    # we want to set the fields directly inside series recipes... args are ignored
-    d[:x], d[:y] = Plots.shape_coords(shapes)
-
-    # Outliers
-    @series begin
-        seriestype := :scatter
-        markershape := :circle
-        x := outliers_x
-        y := outliers_y
-        label := ""
-        primary := false
-        ()
-    end
-
-    () # expects a tuple returned
-end
-@deps boxplot shape scatter
 
 # ---------------------------------------------------------------------------
-# Violin Plot
+# contourf - filled contours
 
-# if the user has KernelDensity installed, use this for violin plots.
-# otherwise, just use a histogram
-if is_installed("KernelDensity")
-    @eval import KernelDensity
-    @eval function violin_coords(y; trim::Bool=false)
-        kd = KernelDensity.kde(y, npoints = 200)
-        if trim
-            xmin, xmax = extrema(y)
-            inside = Bool[ xmin <= x <= xmax for x in kd.x]
-            return(kd.density[inside], kd.x[inside])
-        end
-        kd.density, kd.x
-    end
-else
-    @eval function violin_coords(y; trim::Bool=false)
-        edges, widths = hist(y, 30)
-        centers = 0.5 * (edges[1:end-1] + edges[2:end])
-        ymin, ymax = extrema(y)
-        vcat(0.0, widths, 0.0), vcat(ymin, centers, ymax)
-    end
-end
-
-
-# function apply_series_recipe(d::KW, ::Type{Val{:violin}})
-@recipe function f(::Type{Val{:violin}}, x, y, z; trim=true)
-    # dumpdict(d, "box before", true)
-    # TODO: add scatter series with outliers
-
-    # create a list of shapes, where each shape is a single boxplot
-    shapes = Shape[]
-    groupby = extractGroupArgs(d[:x])
-
-    for (i, glabel) in enumerate(groupby.groupLabels)
-
-        # get the edges and widths
-        y = d[:y][groupby.groupIds[i]]
-        widths, centers = violin_coords(y, trim=trim)
-
-        # normalize
-        widths = _box_halfwidth * widths / maximum(widths)
-
-        # make the violin
-        xcenter = discrete_value!(d[:subplot][:xaxis], glabel)[1]
-        xcoords = vcat(widths, -reverse(widths)) + xcenter
-        ycoords = vcat(centers, reverse(centers))
-        push!(shapes, Shape(xcoords, ycoords))
-    end
-
-    # d[:plotarg_overrides] = KW(:xticks => (1:length(shapes), groupby.groupLabels))
-    seriestype := :shape
-    # n = length(groupby.groupLabels)
-    # xticks --> (linspace(0.5,n-0.5,n), groupby.groupLabels)
-
-    # clean up d
-    pop!(d, :trim)
-
-    d[:x], d[:y] = shape_coords(shapes)
+@recipe function f(::Type{Val{:contourf}}, x, y, z)
+    fillrange := true
+    seriestype := :contour
     ()
 end
-@deps violin shape
-
-# ---------------------------------------------------------------------------
-# density
-
-@recipe function f(::Type{Val{:density}}, x, y, z; trim=false)
-    newx, newy = violin_coords(y, trim=trim)
-    if isvertical(d)
-        newx, newy = newy, newx
-    end
-    x := newx
-    y := newy
-    seriestype := :path
-
-    # clean up d
-    pop!(d, :trim)
-
-    ()
-end
-@deps density path
-
-
 
 # ---------------------------------------------------------------------------
 # Error Bars
@@ -792,8 +526,7 @@ end
 
 function error_coords(xorig, yorig, ebar)
     # init empty x/y, and zip errors if passed Tuple{Vector,Vector}
-    x, y = zeros(0), zeros(0)
-
+    x, y = Array(float_extended_type(xorig), 0), Array(Float64, 0)
     # for each point, create a line segment from the bottom to the top of the errorbar
     for i = 1:max(length(xorig), length(yorig))
         xi = cycle(xorig, i)
@@ -831,6 +564,8 @@ end
 @deps xerror path
 
 
+# TODO: move quiver to PlotRecipes
+
 # ---------------------------------------------------------------------------
 # quiver
 
@@ -921,7 +656,7 @@ end
 
 # function apply_series_recipe(d::KW, ::Type{Val{:quiver}})
 @recipe function f(::Type{Val{:quiver}}, x, y, z)
-    if :arrow in supported_args()
+    if :arrow in supported_attrs()
         quiver_using_arrows(d)
     else
         quiver_using_hack(d)
@@ -931,56 +666,10 @@ end
 @deps quiver shape path
 
 
-# ---------------------------------------------------------------------------
-# ---------------------------------------------------------------------------
-# ---------------------------------------------------------------------------
-
-# function rotate(x::Real, y::Real, θ::Real; center = (0,0))
-#   cx = x - center[1]
-#   cy = y - center[2]
-#   xrot = cx * cos(θ) - cy * sin(θ)
-#   yrot = cy * cos(θ) + cx * sin(θ)
-#   xrot + center[1], yrot + center[2]
-# end
-#
-# # ---------------------------------------------------------------------------
-#
-# type EllipseRecipe <: PlotRecipe
-#   w::Float64
-#   h::Float64
-#   x::Float64
-#   y::Float64
-#   θ::Float64
-# end
-# EllipseRecipe(w,h,x,y) = EllipseRecipe(w,h,x,y,0)
-#
-# # return x,y coords of a rotated ellipse, centered at the origin
-# function rotatedEllipse(w, h, x, y, θ, rotθ)
-#   # # coord before rotation
-#   xpre = w * cos(θ)
-#   ypre = h * sin(θ)
-#
-#   # rotate and translate
-#   r = rotate(xpre, ypre, rotθ)
-#   x + r[1], y + r[2]
-# end
-#
-# function getRecipeXY(ep::EllipseRecipe)
-#   x, y = unzip([rotatedEllipse(ep.w, ep.h, ep.x, ep.y, u, ep.θ) for u in linspace(0,2π,100)])
-#   top = rotate(0, ep.h, ep.θ)
-#   right = rotate(ep.w, 0, ep.θ)
-#   linex = Float64[top[1], 0, right[1]] + ep.x
-#   liney = Float64[top[2], 0, right[2]] + ep.y
-#   Any[x, linex], Any[y, liney]
-# end
-#
-# function getRecipeArgs(ep::EllipseRecipe)
-#   [(:line, (3, [:dot :solid], [:red :blue], :path))]
-# end
-
 # -------------------------------------------------
 
-# TODO: this should really be in another package...
+# TODO: move OHLC to PlotRecipes finance.jl
+
 type OHLC{T<:Real}
   open::T
   high::T
@@ -1043,15 +732,52 @@ end
 #       series recipe or moved to PlotRecipes
 
 
-"Sparsity plot... heatmap of non-zero values of a matrix"
-function spy{T<:Real}(z::AMat{T}; kw...)
-    mat = map(zi->float(zi!=0), z)'
-    xn, yn = size(mat)
-    heatmap(mat; leg=false, yflip=true, aspect_ratio=:equal,
-        xlim=(0.5, xn+0.5), ylim=(0.5, yn+0.5),
-        kw...)
+# "Sparsity plot... heatmap of non-zero values of a matrix"
+# function spy{T<:Real}(z::AMat{T}; kw...)
+#     mat = map(zi->float(zi!=0), z)'
+#     xn, yn = size(mat)
+#     heatmap(mat; leg=false, yflip=true, aspect_ratio=:equal,
+#         xlim=(0.5, xn+0.5), ylim=(0.5, yn+0.5),
+#         kw...)
+# end
+
+# Only allow matrices through, and make it seriestype :spy so the backend can
+# optionally handle it natively.
+
+@userplot Spy
+
+@recipe function f(g::Spy)
+    @assert length(g.args) == 1 && typeof(g.args[1]) <: AbstractMatrix
+    seriestype := :spy
+    mat = g.args[1]
+    n,m = size(mat)
+    Plots.SliceIt, 1:m, 1:n, Surface(mat)
 end
 
+@recipe function f(::Type{Val{:spy}}, x,y,z)
+    yflip := true
+    aspect_ratio := 1
+    rs, cs, zs = findnz(z.surf)
+    xlim := extrema(cs)
+    ylim := extrema(rs)
+    if d[:markershape] == :none
+        markershape := :circle
+    end
+    if d[:markersize] == default(:markersize)
+        markersize := 1
+    end
+    markerstrokewidth := 0
+    marker_z := zs
+    label := ""
+    x := cs
+    y := rs
+    z := nothing
+    seriestype := :scatter
+    ()
+end
+
+# -------------------------------------------------
+
 "Adds a+bx... straight line over the current plot"
 function abline!(plt::Plot, a, b; kw...)
     plot!(plt, [extrema(plt)...], x -> b + a*x; kw...)
@@ -1059,188 +785,20 @@ end
 
 abline!(args...; kw...) = abline!(current(), args...; kw...)
 
-# =================================================
-# Arc and chord diagrams
 
-"Takes an adjacency matrix and returns source, destiny and weight lists"
-function mat2list{T}(mat::AbstractArray{T,2})
-    nrow, ncol = size(mat) # rows are sources and columns are destinies
+# -------------------------------------------------
+# Dates
 
-    nosymmetric = !issym(mat) # plots only triu for symmetric matrices
-    nosparse = !issparse(mat) # doesn't plot zeros from a sparse matrix
+@recipe f(::Type{Date}, dt::Date) = (dt -> convert(Int,dt), dt -> string(convert(Date,dt)))
+@recipe f(::Type{DateTime}, dt::DateTime) = (dt -> convert(Int,dt), dt -> string(convert(DateTime,dt)))
 
-    L = length(mat)
+# -------------------------------------------------
+# Complex Numbers
 
-    source  = Array(Int, L)
-    destiny = Array(Int, L)
-    weight  = Array(T, L)
-
-    idx = 1
-    for i in 1:nrow, j in 1:ncol
-        value = mat[i, j]
-        if !isnan(value) && ( nosparse || value != zero(T) ) # TODO: deal with Nullable
-
-            if i < j
-                source[idx]  = i
-                destiny[idx] = j
-                weight[idx]  = value
-                idx += 1
-            elseif nosymmetric && (i > j)
-                source[idx]  = i
-                destiny[idx] = j
-                weight[idx]  = value
-                idx += 1
-            end
-
-        end
-    end
-
-    resize!(source, idx-1), resize!(destiny, idx-1), resize!(weight, idx-1)
+@userplot ComplexPlot
+@recipe function f(cp::ComplexPlot)
+    xguide --> "Real Part"
+    yguide --> "Imaginary Part"
+    seriestype --> :scatter
+    real(cp.args[1]), imag(cp.args[1])
 end
-
-# ---------------------------------------------------------------------------
-# Arc Diagram
-
-curvecolor(value, min, max, grad) = getColorZ(grad, (value-min)/(max-min))
-
-# "Plots a clockwise arc, from source to destiny, colored by weight"
-# function arc!(source, destiny, weight, min, max, grad)
-#     radius = (destiny - source) / 2
-#     arc = Plots.partialcircle(0, π, 30, radius)
-#     x, y = Plots.unzip(arc)
-#     plot!(x .+ radius .+ source,  y, line = (curvecolor(weight, min, max, grad), 0.5, 2), legend=false)
-# end
-
-# """
-# `arcdiagram(source, destiny, weight[, grad])`
-
-# Plots an arc diagram, form `source` to `destiny` (clockwise), using `weight` to determine the colors.
-# """
-# function arcdiagram(source, destiny, weight; kargs...)
-
-#     args = KW(kargs)
-#     grad = pop!(args, :grad,   ColorGradient([colorant"darkred", colorant"darkblue"]))
-
-#     if length(source) == length(destiny) == length(weight)
-
-#         vertices = unique(vcat(source, destiny))
-#         sort!(vertices)
-
-#         xmin, xmax = extrema(vertices)
-#         plot(xlim=(xmin - 0.5, xmax + 0.5), legend=false)
-
-#         wmin,wmax = extrema(weight)
-
-#         for (i, j, value) in zip(source,destiny,weight)
-#             arc!(i, j, value, wmin, wmax, grad)
-#         end
-
-#         scatter!(vertices, zeros(length(vertices)); legend=false, args...)
-
-#     else
-
-#         throw(ArgumentError("source, destiny and weight should have the same length"))
-
-#     end
-# end
-
-# """
-# `arcdiagram(mat[, grad])`
-
-# Plots an arc diagram from an adjacency matrix, form rows to columns (clockwise),
-# using the values on the matrix as weights to determine the colors.
-# Doesn't show edges with value zero if the input is sparse.
-# For simmetric matrices, only the upper triangular values are used.
-# """
-# arcdiagram{T}(mat::AbstractArray{T,2}; kargs...) = arcdiagram(mat2list(mat)...; kargs...)
-
-# ---------------------------------------------------------------------------
-# Chord diagram
-
-arcshape(θ1, θ2) = Shape(vcat(Plots.partialcircle(θ1, θ2, 15, 1.1),
-                            reverse(Plots.partialcircle(θ1, θ2, 15, 0.9))))
-
-colorlist(grad, ::Void) = :darkgray
-
-function colorlist(grad, z)
-    zmin, zmax = extrema(z)
-    RGBA{Float64}[getColorZ(grad, (zi-zmin)/(zmax-zmin)) for zi in z]'
-end
-
-"""
-`chorddiagram(source, destiny, weight[, grad, zcolor, group])`
-
-Plots a chord diagram, form `source` to `destiny`,
-using `weight` to determine the edge colors using `grad`.
-`zcolor` or `group` can be used to determine the node colors.
-"""
-function chorddiagram(source, destiny, weight; kargs...)
-
-    args  = KW(kargs)
-    grad  = pop!(args, :grad,   ColorGradient([colorant"darkred", colorant"darkblue"]))
-    zcolor= pop!(args, :zcolor, nothing)
-    group = pop!(args, :group,  nothing)
-
-    if zcolor !== nothing && group !== nothing
-        throw(ErrorException("group and zcolor can not be used together."))
-    end
-
-    if length(source) == length(destiny) == length(weight)
-
-        plt = plot(xlim=(-2,2), ylim=(-2,2), legend=false, grid=false,
-        xticks=nothing, yticks=nothing,
-        xlim=(-1.2,1.2), ylim=(-1.2,1.2))
-
-        nodemin, nodemax = extrema(vcat(source, destiny))
-
-        weightmin, weightmax = extrema(weight)
-
-        A  = 1.5π # Filled space
-        B  = 0.5π # White space (empirical)
-
-        Δα = A / nodemax
-        Δβ = B / nodemax
-
-        δ = Δα  + Δβ
-
-        for i in 1:length(source)
-            curve = BezierCurve(P2[ (cos((source[i ]-1)*δ + 0.5Δα), sin((source[i ]-1)*δ + 0.5Δα)), (0,0),
-                                    (cos((destiny[i]-1)*δ + 0.5Δα), sin((destiny[i]-1)*δ + 0.5Δα)) ])
-            plot!(curve_points(curve), line = (Plots.curvecolor(weight[i], weightmin, weightmax, grad), 1, 1))
-        end
-
-        if group === nothing
-            c =  colorlist(grad, zcolor)
-        elseif length(group) == nodemax
-
-            idx = collect(0:(nodemax-1))
-
-            for g in group
-                plot!([arcshape(n*δ, n*δ + Δα) for n in idx[group .== g]]; args...)
-            end
-
-            return plt
-
-        else
-            throw(ErrorException("group should the ", nodemax, " elements."))
-        end
-
-        plot!([arcshape(n*δ, n*δ + Δα) for n in 0:(nodemax-1)]; mc=c, args...)
-
-        return plt
-
-    else
-        throw(ArgumentError("source, destiny and weight should have the same length"))
-    end
-end
-
-"""
-`chorddiagram(mat[, grad, zcolor, group])`
-
-Plots a chord diagram from an adjacency matrix,
-using the values on the matrix as weights to determine edge colors.
-Doesn't show edges with value zero if the input is sparse.
-For simmetric matrices, only the upper triangular values are used.
-`zcolor` or `group` can be used to determine the node colors.
-"""
-chorddiagram(mat::AbstractMatrix; kargs...) = chorddiagram(mat2list(mat)...; kargs...)

src/series.jl

@@ -1,88 +1,130 @@
 
-# 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]
+# 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
 
-    # 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
+typealias FuncOrFuncs{F} Union{F, Vector{F}, Matrix{F}}
 
-    # 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
+all3D(d::KW) = trueOrAllTrue(st -> st in (:contour, :contourf, :heatmap, :surface, :wireframe, :contour3d, :image), get(d, :seriestype, :none))
 
-    aliasesAndAutopick(d, :linestyle, _styleAliases, supported_styles(pkg), plotIndex)
-    aliasesAndAutopick(d, :markershape, _markerAliases, supported_markers(pkg), plotIndex)
+# missing
+convertToAnyVector(v::Void, d::KW) = Any[nothing], nothing
 
-    # update color
-    d[:seriescolor] = getSeriesRGBColor(d[:seriescolor], sp, plotIndex)
+# fixed number of blank series
+convertToAnyVector(n::Integer, d::KW) = Any[zeros(0) for i in 1:n], nothing
 
-    # 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
+# numeric vector
+convertToAnyVector{T<:Number}(v::AVec{T}, d::KW) = Any[v], nothing
 
-    # update markerstrokecolor
-    c = d[:markerstrokecolor]
-    c = if c == :match
-        sp[:foreground_color_subplot]
+# 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
-        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
+        Any[v[:,i] for i in 1:size(v,2)]
+    end, nothing
 end
 
-# -------------------------------------------------------------------
-# -------------------------------------------------------------------
+# function
+convertToAnyVector(f::Function, d::KW) = Any[f], nothing
 
-# instead of process_inputs:
+# 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)
-    # @show "HERE", typeof((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)
@@ -100,21 +142,19 @@ immutable SliceIt end
     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]))
+    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
+            # 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, ()))
+            push!(series_list, RecipeData(di, ()))
+        end
     end
     nothing  # don't add a series for the main block
 end
@@ -127,6 +167,38 @@ end
 
 _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
@@ -180,37 +252,57 @@ end
     newargs
 end
 
-# @recipe f(x, y, z)  = SliceIt, apply_recipe(typeof(x), x), apply_recipe(typeof(y), y), apply_recipe(typeof(z), z)
-# @recipe f(x, y)     = SliceIt, apply_recipe(typeof(x), x), apply_recipe(typeof(y), y), nothing
-# @recipe f(y)        = SliceIt, nothing, apply_recipe(typeof(y), y), nothing
-
-# # pass these through to the slicer
-# @recipe f(x, y, z)  = SliceIt, x, y, z
-# @recipe f(x, y)     = SliceIt, x, y, nothing
-# @recipe f(y)        = SliceIt, nothing, y, nothing
-
 
 # # --------------------------------------------------------------------
 # # 1 argument
 # # --------------------------------------------------------------------
 
-@recipe f(n::Integer) = n, n, n
+# 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<:Number}(mat::AMat{T})
+@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 nativeImagesSupported()
+    if is_seriestype_supported(:image)
         seriestype := :image
         n, m = size(mat)
         SliceIt, 1:m, 1:n, Surface(mat)
@@ -225,7 +317,7 @@ end
 # # images - colors
 
 @recipe function f{T<:Colorant}(mat::AMat{T})
-    if nativeImagesSupported()
+    if is_seriestype_supported(:image)
         seriestype := :image
         n, m = size(mat)
         SliceIt, 1:m, 1:n, Surface(mat)
@@ -241,32 +333,34 @@ end
 # # plotting arbitrary shapes/polygons
 
 @recipe function f(shape::Shape)
-    seriestype := :shape
-    shape_coords(shape)
+    seriestype --> :shape
+    coords(shape)
 end
 
 @recipe function f(shapes::AVec{Shape})
-    seriestype := :shape
-    shape_coords(shapes)
+    seriestype --> :shape
+    coords(shapes)
 end
 
 @recipe function f(shapes::AMat{Shape})
+    seriestype --> :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]))))
+        @series 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)
+
+# function without range... use the current range of the x-axis
+
+@recipe function f{F<:Function}(f::FuncOrFuncs{F})
     plt = d[:plot_object]
-    f, xmin(plt), xmax(plt)
+    xmin, xmax = try
+        axis_limits(plt[1][:xaxis])
+    catch
+        -5, 5
+    end
+    f, xmin, xmax
 end
 
 #
@@ -278,8 +372,9 @@ end
 # # 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
+@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
 
@@ -308,6 +403,7 @@ end
     #         seriestype := :path3d
     #     end
     # end
+    wrap_surfaces(d)
     SliceIt, x, y, z
 end
 
@@ -317,6 +413,7 @@ end
 @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
 
@@ -327,6 +424,7 @@ end
     if !like_surface(get(d, :seriestype, :none))
         d[:seriestype] = :contour
     end
+    wrap_surfaces(d)
     SliceIt, x, y, Surface(z)
 end
 
@@ -338,16 +436,23 @@ end
 
 #
 # # 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)
+@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(fx::FuncOrFuncs, fy::FuncOrFuncs, fz::FuncOrFuncs, u::AVec)
+@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(fx::FuncOrFuncs, fy::FuncOrFuncs, fz::FuncOrFuncs, umin::Number, umax::Number, numPoints = 200)
+@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
 
@@ -413,4 +518,3 @@ end
         end
     end
 end
-

src/series_args.jl

@@ -1,550 +0,0 @@
-
-# create a new "build_series_args" which converts all inputs into xs = Any[xitems], ys = Any[yitems].
-# Special handling for: no args, xmin/xmax, parametric, dataframes
-# Then once inputs have been converted, build the series args, map functions, etc.
-# This should cut down on boilerplate code and allow more focused dispatch on type
-# note: returns meta information... mainly for use with automatic labeling from DataFrames for now
-
-typealias FuncOrFuncs @compat(Union{Function, AVec{Function}})
-
-all3D(d::KW) = trueOrAllTrue(st -> st in (:contour, :heatmap, :surface, :wireframe, :contour3d), get(d, :seriestype, :none))
-
-# missing
-convertToAnyVector(v::@compat(Void), d::KW) = Any[nothing], nothing
-
-# fixed number of blank series
-convertToAnyVector(n::Integer, d::KW) = Any[zeros(0) for i in 1:n], nothing
-
-# numeric vector
-convertToAnyVector{T<:Number}(v::AVec{T}, d::KW) = Any[v], nothing
-
-# string vector
-convertToAnyVector{T<:@compat(AbstractString)}(v::AVec{T}, d::KW) = Any[v], nothing
-
-# numeric matrix
-function convertToAnyVector{T<:Number}(v::AMat{T}, d::KW)
-    if all3D(d)
-        Any[Surface(v)]
-    else
-        Any[v[:,i] for i in 1:size(v,2)]
-    end, nothing
-end
-
-# other matrix... vector of columns
-function convertToAnyVector(m::AMat, d::KW)
-    Any[begin
-        v = vec(m[:,i])
-        length(v) == 1 ? v[1] : v
-    end for i=1:size(m,2)], nothing
-end
-
-# function
-convertToAnyVector(f::Function, d::KW) = Any[f], nothing
-
-# surface
-convertToAnyVector(s::Surface, d::KW) = Any[s], nothing
-
-# # vector of OHLC
-# convertToAnyVector(v::AVec{OHLC}, d::KW) = Any[v], nothing
-
-# dates
-convertToAnyVector{D<:Union{Date,DateTime}}(dts::AVec{D}, d::KW) = Any[dts], nothing
-
-# list of things (maybe other vectors, functions, or something else)
-function convertToAnyVector(v::AVec, d::KW)
-    if all(x -> typeof(x) <: Number, v)
-        # all real numbers wrap the whole vector as one item
-        Any[convert(Vector{Float64}, v)], nothing
-    else
-        # something else... treat each element as an item
-        vcat(Any[convertToAnyVector(vi, d)[1] for vi in v]...), nothing
-        # Any[vi for vi in v], nothing
-    end
-end
-
-convertToAnyVector(t::Tuple, d::KW) = Any[t], nothing
-
-
-function convertToAnyVector(args...)
-    error("In convertToAnyVector, could not handle the argument types: $(map(typeof, args[1:end-1]))")
-end
-
-# --------------------------------------------------------------------
-
-# TODO: can we avoid the copy here?  one error that crops up is that mapping functions over the same array
-#       result in that array being shared.  push!, etc will add too many items to that array
-
-compute_x(x::Void, y::Void, z)      = 1:size(z,1)
-compute_x(x::Void, y, z)            = 1:size(y,1)
-compute_x(x::Function, y, z)        = map(x, y)
-compute_x(x, y, z)                  = copy(x)
-
-# compute_y(x::Void, y::Function, z)  = error()
-compute_y(x::Void, y::Void, z)      = 1:size(z,2)
-compute_y(x, y::Function, z)        = map(y, x)
-compute_y(x, y, z)                  = copy(y)
-
-compute_z(x, y, z::Function)        = map(z, x, y)
-compute_z(x, y, z::AbstractMatrix)  = Surface(z)
-compute_z(x, y, z::Void)            = nothing
-compute_z(x, y, z)                  = copy(z)
-
-nobigs(v::AVec{BigFloat}) = map(Float64, v)
-nobigs(v::AVec{BigInt}) = map(Int64, v)
-nobigs(v) = v
-
-@noinline function compute_xyz(x, y, z)
-    x = compute_x(x,y,z)
-    y = compute_y(x,y,z)
-    z = compute_z(x,y,z)
-    nobigs(x), nobigs(y), nobigs(z)
-end
-
-# not allowed
-compute_xyz(x::Void, y::FuncOrFuncs, z)       = error("If you want to plot the function `$y`, you need to define the x values!")
-compute_xyz(x::Void, y::Void, z::FuncOrFuncs) = error("If you want to plot the function `$z`, you need to define x and y values!")
-compute_xyz(x::Void, y::Void, z::Void)        = error("x/y/z are all nothing!")
-
-# --------------------------------------------------------------------
-
-# # create n=max(mx,my) series arguments. the shorter list is cycled through
-# # note: everything should flow through this
-# function build_series_args(plt::AbstractPlot, kw::KW) #, idxfilter)
-#     x, y, z = map(sym -> pop!(kw, sym, nothing), (:x, :y, :z))
-#     if nothing == x == y == z
-#         return [], nothing, nothing
-#     end
-#
-#     xs, xmeta = convertToAnyVector(x, kw)
-#     ys, ymeta = convertToAnyVector(y, kw)
-#     zs, zmeta = convertToAnyVector(z, kw)
-#
-#     fr = pop!(kw, :fillrange, nothing)
-#     fillranges, _ = if typeof(fr) <: Number
-#         ([fr],nothing)
-#     else
-#         convertToAnyVector(fr, kw)
-#     end
-#
-#     mx = length(xs)
-#     my = length(ys)
-#     mz = length(zs)
-#     ret = Any[]
-#     for i in 1:max(mx, my, mz)
-#
-#         # try to set labels using ymeta
-#         d = copy(kw)
-#         if !haskey(d, :label) && ymeta != nothing
-#             if isa(ymeta, Symbol)
-#                 d[:label] = string(ymeta)
-#             elseif isa(ymeta, AVec{Symbol})
-#                 d[:label] = string(ymeta[mod1(i,length(ymeta))])
-#             end
-#         end
-#
-#         # build the series arg dict
-#         numUncounted = pop!(d, :numUncounted, 0)
-#         commandIndex = i + numUncounted
-#         n = plt.n + i
-#
-#         dumpdict(d, "before getSeriesArgs")
-#         d = getSeriesArgs(plt.backend, getattr(plt, n), d, commandIndex, convertSeriesIndex(plt, n), n)
-#         dumpdict(d, "after getSeriesArgs")
-#
-#         d[:x], d[:y], d[:z] = compute_xyz(xs[mod1(i,mx)], ys[mod1(i,my)], zs[mod1(i,mz)])
-#         st = d[:seriestype]
-#
-#         # for seriestype `line`, need to sort by x values
-#         if st == :line
-#             # order by x
-#             indices = sortperm(d[:x])
-#             d[:x] = d[:x][indices]
-#             d[:y] = d[:y][indices]
-#             d[:seriestype] = :path
-#         end
-#
-#         # special handling for missing x in box plot... all the same category
-#         if st == :box && xs[mod1(i,mx)] == nothing
-#             d[:x] = ones(Int, length(d[:y]))
-#         end
-#
-#         # map functions to vectors
-#         if isa(d[:marker_z], Function)
-#             d[:marker_z] = map(d[:marker_z], d[:x])
-#         end
-#
-#         # @show fillranges
-#         d[:fillrange] = fillranges[mod1(i,length(fillranges))]
-#         if isa(d[:fillrange], Function)
-#             d[:fillrange] = map(d[:fillrange], d[:x])
-#         end
-#
-#         # handle error bars
-#         for esym in (:xerror, :yerror)
-#             if get(d, esym, nothing) != nothing
-#                 # we make a copy of the KW and apply an errorbar recipe
-#                 append!(ret, apply_series_recipe(copy(d), Val{esym}))
-#             end
-#         end
-#
-#         # handle ribbons
-#         if get(d, :ribbon, nothing) != nothing
-#             rib = d[:ribbon]
-#             d[:fillrange] = (d[:y] - rib, d[:y] + rib)
-#         end
-#
-#         # handle quiver plots
-#         # either a series of velocity vectors are passed in (`:quiver` keyword),
-#         # or we just add arrows to the path
-#
-#         # if st == :quiver
-#         #     d[:seriestype] = st = :path
-#         #     d[:linewidth] = 0
-#         # end
-#         if get(d, :quiver, nothing) != nothing
-#             append!(ret, apply_series_recipe(copy(d), Val{:quiver}))
-#         elseif st == :quiver
-#             d[:seriestype] = st = :path
-#             d[:arrow] = arrow()
-#         end
-#
-#         # now that we've processed a given series... optionally split into
-#         # multiple dicts through a recipe (for example, a box plot is split into component
-#         # parts... polygons, lines, and scatters)
-#         # note: we pass in a Val type (i.e. Val{:box}) so that we can dispatch on the seriestype
-#         kwlist = apply_series_recipe(d, Val{st})
-#         append!(ret, kwlist)
-#
-#         # # add it to our series list
-#         # push!(ret, d)
-#     end
-#
-#     ret, xmeta, ymeta
-# end
-#
-#
-# # --------------------------------------------------------------------
-# # process_inputs
-# # --------------------------------------------------------------------
-#
-# # These methods take a plot and the keyword arguments, and processes the input
-# # arguments (x/y/z, group, etc), populating the KW dict with appropriate values.
-#
-# # --------------------------------------------------------------------
-# # 0 arguments
-# # --------------------------------------------------------------------
-#
-# # don't do anything
-# function process_inputs(plt::AbstractPlot, d::KW)
-# end
-#
-# # --------------------------------------------------------------------
-# # 1 argument
-# # --------------------------------------------------------------------
-#
-# function process_inputs(plt::AbstractPlot, d::KW, n::Integer)
-#     # d[:x], d[:y], d[:z] = zeros(0), zeros(0), zeros(0)
-#     d[:x] = d[:y] = d[:z] = n
-# end
-#
-# # no special handling... assume x and z are nothing
-# function process_inputs(plt::AbstractPlot, d::KW, y)
-#     d[:y] = y
-# end
-#
-# # matrix... is it z or y?
-# function process_inputs{T<:Number}(plt::AbstractPlot, d::KW, mat::AMat{T})
-#     if all3D(d)
-#         n,m = size(mat)
-#         d[:x], d[:y], d[:z] = 1:n, 1:m, mat
-#     else
-#         d[:y] = mat
-#     end
-# end
-#
-# # images - grays
-# function process_inputs{T<:Gray}(plt::AbstractPlot, d::KW, mat::AMat{T})
-#     d[:seriestype] = :image
-#     n,m = size(mat)
-#     d[:x], d[:y], d[:z] = 1:n, 1:m, Surface(mat)
-#     # handle images... when not supported natively, do a hack to use heatmap machinery
-#     if !nativeImagesSupported()
-#         d[:seriestype] = :heatmap
-#         d[:yflip] = true
-#         d[:z] = Surface(convert(Matrix{Float64}, mat.surf))
-#         d[:fillcolor] = ColorGradient([:black, :white])
-#     end
-# end
-#
-# # images - colors
-# function process_inputs{T<:Colorant}(plt::AbstractPlot, d::KW, mat::AMat{T})
-#     d[:seriestype] = :image
-#     n,m = size(mat)
-#     d[:x], d[:y], d[:z] = 1:n, 1:m, Surface(mat)
-#     # handle images... when not supported natively, do a hack to use heatmap machinery
-#     if !nativeImagesSupported()
-#         d[:yflip] = true
-#         imageHack(d)
-#     end
-# end
-#
-#
-# # plotting arbitrary shapes/polygons
-# function process_inputs(plt::AbstractPlot, d::KW, shape::Shape)
-#     d[:x], d[:y] = shape_coords(shape)
-#     d[:seriestype] = :shape
-# end
-# function process_inputs(plt::AbstractPlot, d::KW, shapes::AVec{Shape})
-#     d[:x], d[:y] = shape_coords(shapes)
-#     d[:seriestype] = :shape
-# end
-# function process_inputs(plt::AbstractPlot, d::KW, shapes::AMat{Shape})
-#     x, y = [], []
-#     for j in 1:size(shapes, 2)
-#         tmpx, tmpy = shape_coords(vec(shapes[:,j]))
-#         push!(x, tmpx)
-#         push!(y, tmpy)
-#     end
-#     d[:x], d[:y] = x, y
-#     d[:seriestype] = :shape
-# end
-#
-#
-# # function without range... use the current range of the x-axis
-# function process_inputs(plt::AbstractPlot, d::KW, f::FuncOrFuncs)
-#     process_inputs(plt, d, f, xmin(plt), xmax(plt))
-# end
-#
-# # --------------------------------------------------------------------
-# # 2 arguments
-# # --------------------------------------------------------------------
-#
-# function process_inputs(plt::AbstractPlot, d::KW, x, y)
-#     d[:x], d[:y] = x, y
-# end
-#
-# # 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)
-# function process_inputs(plt::AbstractPlot, d::KW, f::FuncOrFuncs, x)
-#     @assert !(typeof(x) <: FuncOrFuncs)  # otherwise we'd hit infinite recursion here
-#     process_inputs(plt, d, x, f)
-# end
-#
-# # --------------------------------------------------------------------
-# # 3 arguments
-# # --------------------------------------------------------------------
-#
-# # no special handling... just pass them through
-# function process_inputs(plt::AbstractPlot, d::KW, x, y, z)
-#     d[:x], d[:y], d[:z] = x, y, z
-# end
-#
-# # 3d line or scatter
-# function process_inputs(plt::AbstractPlot, d::KW, x::AVec, y::AVec, zvec::AVec)
-#     # default to path3d if we haven't set a 3d seriestype
-#     st = get(d, :seriestype, :none)
-#     if st == :scatter
-#         d[:seriestype] = :scatter3d
-#     elseif !(st in _3dTypes)
-#         d[:seriestype] = :path3d
-#     end
-#     d[:x], d[:y], d[:z] = x, y, zvec
-# end
-#
-# # surface-like... function
-# function process_inputs{TX,TY}(plt::AbstractPlot, d::KW, x::AVec{TX}, y::AVec{TY}, zf::Function)
-#     x = TX <: Number ? sort(x) : x
-#     y = TY <: Number ? sort(y) : y
-#     # x, y = sort(x), sort(y)
-#     d[:z] = Surface(zf, x, y)  # TODO: replace with SurfaceFunction when supported
-#     d[:x], d[:y] = x, y
-# end
-#
-# # surface-like... matrix grid
-# function process_inputs{TX,TY,TZ}(plt::AbstractPlot, d::KW, x::AVec{TX}, y::AVec{TY}, zmat::AMat{TZ})
-#     # @assert size(zmat) == (length(x), length(y))
-#     # if TX <: Number && !issorted(x)
-#     #     idx = sortperm(x)
-#     #     x, zmat = x[idx], zmat[idx, :]
-#     # end
-#     # if TY <: Number && !issorted(y)
-#     #     idx = sortperm(y)
-#     #     y, zmat = y[idx], zmat[:, idx]
-#     # end
-#     d[:x], d[:y], d[:z] = x, y, Surface{Matrix{TZ}}(zmat)
-#     if !like_surface(get(d, :seriestype, :none))
-#         d[:seriestype] = :contour
-#     end
-# end
-#
-# # surfaces-like... general x, y grid
-# function process_inputs{T<:Number}(plt::AbstractPlot, d::KW, x::AMat{T}, y::AMat{T}, zmat::AMat{T})
-#     @assert size(zmat) == size(x) == size(y)
-#     # d[:x], d[:y], d[:z] = Any[x], Any[y], Surface{Matrix{Float64}}(zmat)
-#     d[:x], d[:y], d[:z] = map(Surface{Matrix{Float64}}, (x, y, zmat))
-#     if !like_surface(get(d, :seriestype, :none))
-#         d[:seriestype] = :contour
-#     end
-# end
-#
-#
-# # --------------------------------------------------------------------
-# # Parametric functions
-# # --------------------------------------------------------------------
-#
-# # special handling... xmin/xmax with function(s)
-# function process_inputs(plt::AbstractPlot, d::KW, f::FuncOrFuncs, xmin::Number, xmax::Number)
-#     width = get(plt.attr, :size, (100,))[1]
-#     x = linspace(xmin, xmax, width)
-#     process_inputs(plt, d, x, f)
-# end
-#
-# # special handling... xmin/xmax with parametric function(s)
-# process_inputs{T<:Number}(plt::AbstractPlot, d::KW, fx::FuncOrFuncs, fy::FuncOrFuncs, u::AVec{T}) = process_inputs(plt, d, mapFuncOrFuncs(fx, u), mapFuncOrFuncs(fy, u))
-# process_inputs{T<:Number}(plt::AbstractPlot, d::KW, u::AVec{T}, fx::FuncOrFuncs, fy::FuncOrFuncs) = process_inputs(plt, d, mapFuncOrFuncs(fx, u), mapFuncOrFuncs(fy, u))
-# process_inputs(plt::AbstractPlot, d::KW, fx::FuncOrFuncs, fy::FuncOrFuncs, umin::Number, umax::Number, numPoints::Int = 1000) = process_inputs(plt, d, fx, fy, linspace(umin, umax, numPoints))
-#
-# # special handling... 3D parametric function(s)
-# process_inputs{T<:Number}(plt::AbstractPlot, d::KW, fx::FuncOrFuncs, fy::FuncOrFuncs, fz::FuncOrFuncs, u::AVec{T}) = process_inputs(plt, d, mapFuncOrFuncs(fx, u), mapFuncOrFuncs(fy, u), mapFuncOrFuncs(fz, u))
-# process_inputs{T<:Number}(plt::AbstractPlot, d::KW, u::AVec{T}, fx::FuncOrFuncs, fy::FuncOrFuncs, fz::FuncOrFuncs) = process_inputs(plt, d, mapFuncOrFuncs(fx, u), mapFuncOrFuncs(fy, u), mapFuncOrFuncs(fz, u))
-# process_inputs(plt::AbstractPlot, d::KW, fx::FuncOrFuncs, fy::FuncOrFuncs, fz::FuncOrFuncs, umin::Number, umax::Number, numPoints::Int = 1000) = process_inputs(plt, d, fx, fy, fz, linspace(umin, umax, numPoints))
-#
-#
-# # --------------------------------------------------------------------
-# # Lists of tuples and FixedSizeArrays
-# # --------------------------------------------------------------------
-#
-# # if we get an unhandled tuple, just splat it in
-# function process_inputs(plt::AbstractPlot, d::KW, tup::Tuple)
-#     process_inputs(plt, d, tup...)
-# end
-#
-# # (x,y) tuples
-# function process_inputs{R1<:Number,R2<:Number}(plt::AbstractPlot, d::KW, xy::AVec{Tuple{R1,R2}})
-#     process_inputs(plt, d, unzip(xy)...)
-# end
-# function process_inputs{R1<:Number,R2<:Number}(plt::AbstractPlot, d::KW, xy::Tuple{R1,R2})
-#     process_inputs(plt, d, [xy[1]], [xy[2]])
-# end
-#
-# # (x,y,z) tuples
-# function process_inputs{R1<:Number,R2<:Number,R3<:Number}(plt::AbstractPlot, d::KW, xyz::AVec{Tuple{R1,R2,R3}})
-#     process_inputs(plt, d, unzip(xyz)...)
-# end
-# function process_inputs{R1<:Number,R2<:Number,R3<:Number}(plt::AbstractPlot, d::KW, xyz::Tuple{R1,R2,R3})
-#     process_inputs(plt, d, [xyz[1]], [xyz[2]], [xyz[3]])
-# end
-#
-# # 2D FixedSizeArrays
-# function process_inputs{T<:Number}(plt::AbstractPlot, d::KW, xy::AVec{FixedSizeArrays.Vec{2,T}})
-#     process_inputs(plt, d, unzip(xy)...)
-# end
-# function process_inputs{T<:Number}(plt::AbstractPlot, d::KW, xy::FixedSizeArrays.Vec{2,T})
-#     process_inputs(plt, d, [xy[1]], [xy[2]])
-# end
-#
-# # 3D FixedSizeArrays
-# function process_inputs{T<:Number}(plt::AbstractPlot, d::KW, xyz::AVec{FixedSizeArrays.Vec{3,T}})
-#     process_inputs(plt, d, unzip(xyz)...)
-# end
-# function process_inputs{T<:Number}(plt::AbstractPlot, d::KW, xyz::FixedSizeArrays.Vec{3,T})
-#     process_inputs(plt, d, [xyz[1]], [xyz[2]], [xyz[3]])
-# end
-#
-# # --------------------------------------------------------------------
-# # handle grouping
-# # --------------------------------------------------------------------
-#
-# # function process_inputs(plt::AbstractPlot, d::KW, groupby::GroupBy, args...)
-# #     ret = Any[]
-# #     error("unfinished after series reorg")
-# #     for (i,glab) in enumerate(groupby.groupLabels)
-# #         # TODO: don't automatically overwrite labels
-# #         kwlist, xmeta, ymeta = process_inputs(plt, d, args...,
-# #                                             idxfilter = groupby.groupIds[i],
-# #                                             label = string(glab),
-# #                                             numUncounted = length(ret))  # we count the idx from plt.n + numUncounted + i
-# #         append!(ret, kwlist)
-# #     end
-# #     ret, nothing, nothing # TODO: handle passing meta through
-# # end
-
-# --------------------------------------------------------------------
-# For DataFrame support.  Imports DataFrames and defines the necessary methods which support them.
-# --------------------------------------------------------------------
-
-# function setup_dataframes()
-#     @require DataFrames begin
-#     # @eval begin
-#         # import DataFrames
-#
-#         DFS = Union{Symbol, AbstractArray{Symbol}}
-#
-#         function handle_dfs(df::DataFrames.AbstractDataFrame, d::KW, letter, dfs::DFS)
-#             if isa(dfs, Symbol)
-#                 get!(d, Symbol(letter * "label"), string(dfs))
-#                 collect(df[dfs])
-#             else
-#                 get!(d, :label, reshape(dfs, 1, length(dfs)))
-#                 Any[collect(df[s]) for s in dfs]
-#             end
-#         end
-#
-#         function handle_group(df::DataFrames.AbstractDataFrame, d::KW)
-#             if haskey(d, :group)
-#                 g = d[:group]
-#                 if isa(g, Symbol)
-#                     d[:group] = collect(df[g])
-#                 end
-#             end
-#         end
-#
-#         @recipe function plot(df::DataFrames.AbstractDataFrame, sy::DFS)
-#             handle_group(df, d)
-#             handle_dfs(df, d, "y", sy)
-#         end
-#
-#         @recipe function plot(df::DataFrames.AbstractDataFrame, sx::DFS, sy::DFS)
-#             handle_group(df, d)
-#             x = handle_dfs(df, d, "x", sx)
-#             y = handle_dfs(df, d, "y", sy)
-#             x, y
-#         end
-#
-#         @recipe function plot(df::DataFrames.AbstractDataFrame, sx::DFS, sy::DFS, sz::DFS)
-#             handle_group(df, d)
-#             x = handle_dfs(df, d, "x", sx)
-#             y = handle_dfs(df, d, "y", sy)
-#             z = handle_dfs(df, d, "z", sz)
-#             x, y, z
-#         end
-#
-#         # get_data(df::DataFrames.AbstractDataFrame, arg::Symbol) = df[arg]
-#         # get_data(df::DataFrames.AbstractDataFrame, arg) = arg
-#         #
-#         # function process_inputs(plt::AbstractPlot, d::KW, df::DataFrames.AbstractDataFrame, args...)
-#         #     # d[:dataframe] = df
-#         #     process_inputs(plt, d, map(arg -> get_data(df, arg), args)...)
-#         # end
-#         #
-#         # # expecting the column name of a dataframe that was passed in... anything else should error
-#         # function extractGroupArgs(s::Symbol, df::DataFrames.AbstractDataFrame, args...)
-#         #     if haskey(df, s)
-#         #         return extractGroupArgs(df[s])
-#         #     else
-#         #         error("Got a symbol, and expected that to be a key in d[:dataframe]. s=$s d=$d")
-#         #     end
-#         # end
-#
-#         # function getDataFrameFromKW(d::KW)
-#         #     get(d, :dataframe) do
-#         #         error("Missing dataframe argument!")
-#         #     end
-#         # end
-#
-#         # # the conversion functions for when we pass symbols or vectors of symbols to reference dataframes
-#         # convertToAnyVector(s::Symbol, d::KW) = Any[getDataFrameFromKW(d)[s]], s
-#         # convertToAnyVector(v::AVec{Symbol}, d::KW) = (df = getDataFrameFromKW(d); Any[df[s] for s in v]), v
-#
-#     end
-# end

src/subplots.jl

@@ -3,6 +3,7 @@
 function Subplot{T<:AbstractBackend}(::T; parent = RootLayout())
     Subplot{T}(
         parent,
+        Series[],
         (20mm, 5mm, 2mm, 10mm),
         defaultbox,
         defaultbox,
@@ -30,16 +31,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, idx::Integer) = Int(idx)
 get_subplot_index(plt::Plot, sp::Subplot) = findfirst(_ -> _ === 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,
+            :contour,:contourf,:contour3d,:surface,:wireframe,
             :heatmap, :pie, :image
         ))
 end

src/themes.jl

@@ -1,65 +1,40 @@
 
-const _invisible = RGBA(0,0,0,0)
+function theme(s::Symbol; kw...)
+    # reset?
+    if s == :none || s == :default
+        PlotUtils._default_gradient[] = :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._default_gradient[] = 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)

src/types.jl

@@ -21,11 +21,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 +44,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
 
@@ -54,14 +66,6 @@ typealias 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 +87,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))
 
 # -----------------------------------------------------------------------

src/utils.jl

@@ -131,39 +131,85 @@ 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{T}
+    pts::Vector{T}
+end
+
+# Segments() = Segments{Float64}(zeros(0))
+
+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, convert(T,v))
+    end
+    segments
+end
+
+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, convert(T,v))
+    end
+    segments
+end
+
+
 # -----------------------------------------------------
 # helper to manage NaN-separated segments
 
 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
@@ -171,41 +217,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(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
+isnothing(x::Void) = true
+isnothing(x) = false
 
-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(wrapper::InputWrapper, idx::Int) = wrapper.obj
+cycle(wrapper::InputWrapper, idx::AVec{Int}) = wrapper.obj
+
+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]
@@ -232,6 +292,7 @@ function _expand_limits(lims, x)
   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...)
@@ -250,20 +311,16 @@ 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
 
@@ -336,15 +393,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
 
@@ -395,9 +452,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
@@ -411,7 +469,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.cycle(rib)))
         frs[i] = yi + ri
     end
     frs
@@ -426,9 +484,24 @@ function make_fillrange_from_ribbon(kw::KW)
     kw[:fillrange] = make_fillrange_side(y, rib1), make_fillrange_side(y, rib2)
 end
 
+function get_sp_lims(sp::Subplot, letter::Symbol)
+    axis_limits(sp[Symbol(letter, :axis)])
+end
+xlims(sp::Subplot) = get_sp_lims(sp, :x)
+ylims(sp::Subplot) = get_sp_lims(sp, :y)
+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)
@@ -436,7 +509,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)
@@ -598,26 +671,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

test/REQUIRE

@@ -1,15 +1,9 @@
-julia 0.4
-
-RecipesBase
-Colors
-Reexport
-Measures
+StatPlots
 FactCheck
 Images
-PyPlot
+ImageMagick
 @osx QuartzImageIO
 GR
-DataFrames
 RDatasets
 VisualRegressionTests
 UnicodePlots

test/imgcomp.jl

@@ -13,7 +13,9 @@ try
 end
 
 
-using Plots, FactCheck
+using Plots
+using StatPlots
+using FactCheck
 using Glob
 
 default(size=(500,300))
@@ -22,7 +24,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.2"
+const _current_plots_version = v"0.9.6"
 
 
 function image_comparison_tests(pkg::Symbol, idx::Int; debug = false, popup = isinteractive(), sigma = [1,1], eps = 1e-2)
@@ -41,9 +43,10 @@ function image_comparison_tests(pkg::Symbol, idx::Int; debug = false, popup = is
     fn = "ref$idx.png"
 
     # firgure out version info
-    G = glob(relpath(refdir) * "/*")
+    G = glob(joinpath(relpath(refdir), "*"))
     # @show refdir fn G
-    versions = map(fn -> VersionNumber(split(fn,"/")[end]), G)
+    slash = (@static is_windows() ? "\\" : "/")
+    versions = map(fn -> VersionNumber(split(fn, slash)[end]), G)
     versions = reverse(sort(versions))
     versions = filter(v -> v <= _current_plots_version, versions)
     # @show refdir fn versions
@@ -75,12 +78,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)

test/runtests.jl

@@ -5,7 +5,7 @@ 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()
@@ -23,14 +23,16 @@ facts("PyPlot") do
     @fact pyplot() --> Plots.PyPlotBackend()
     @fact backend() --> Plots.PyPlotBackend()
 
-    image_comparison_facts(:pyplot, skip=[30], eps=img_eps)
+    image_comparison_facts(:pyplot, skip=[25,30], eps=img_eps)
 end
 
 facts("GR") do
     @fact gr() --> Plots.GRBackend()
     @fact backend() --> Plots.GRBackend()
 
-    @linux_only image_comparison_facts(:gr, skip=[30], eps=img_eps)
+    if is_linux() && isinteractive()
+        image_comparison_facts(:gr, skip=[2,25,30], eps=img_eps)
+    end
 end
 
 facts("Plotly") do
@@ -38,7 +40,7 @@ facts("Plotly") do
     @fact backend() --> Plots.PlotlyBackend()
 
     # # until png generation is reliable on OSX, just test on linux
-    # @linux_only image_comparison_facts(:plotly, only=[1,3,4,7,8,9,10,11,12,14,15,20,22,23,27], eps=img_eps)
+    # @static 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
 
 
@@ -65,7 +67,7 @@ facts("UnicodePlots") do
     @fact backend() --> Plots.UnicodePlotsBackend()
 
     # lets just make sure it runs without error
-    @fact isa(plot(rand(10)), Plot) --> true
+    @fact isa(plot(rand(10)), Plots.Plot) --> true
 end
 
 
@@ -73,7 +75,7 @@ end
 facts("Axes") do
     p = plot()
     axis = p.subplots[1][:xaxis]
-    @fact typeof(axis) --> Axis
+    @fact typeof(axis) --> Plots.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)
@@ -85,6 +87,44 @@ facts("Axes") do
 end
 
 
+# tests for preprocessing recipes
+
+# facts("recipes") do
+
+    # 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()

test/snoop.jl

@@ -0,0 +1,36 @@
+import SnoopCompile
+
+### Log the compiles
+# This only needs to be run once (to generate "/tmp/plots_compiles.csv")
+
+# SnoopCompile.@snoop "/tmp/plots_compiles.csv" begin
+#     include(joinpath(dirname(@__FILE__), "runtests.jl"))
+# end
+
+# ----------------------------------------------------------
+
+### Parse the compiles and generate precompilation scripts
+# This can be run repeatedly to tweak the scripts
+
+# IMPORTANT: we must have the module(s) defined for the parcelation
+# step, otherwise we will get no precompiles for the Plots module
+using Plots
+
+data = SnoopCompile.read("/tmp/plots_compiles.csv")
+
+# The Plots tests are run inside a module PlotsTest, so all
+# the precompiles get credited to PlotsTest. Credit them to Plots instead.
+subst = Dict("PlotsTests"=>"Plots")
+
+# Blacklist helps fix problems:
+# - MIME uses type-parameters with symbols like :image/png, which is
+#   not parseable
+blacklist = ["MIME"]
+
+# Use these two lines if you want to create precompile functions for
+# individual packages
+pc, discards = SnoopCompile.parcel(data[end:-1:1,2], subst=subst, blacklist=blacklist)
+SnoopCompile.write("/tmp/precompile", pc)
+
+pdir = joinpath(dirname(@__FILE__), "..")
+run(`cp /tmp/precompile/precompile_Plots.jl $pdir/src/precompile.jl`)

test/travis_commands.jl

@@ -1,25 +1,26 @@
-# Pkg.clone(pwd())
-# Pkg.build("Plots")
+# Pkg.clone("ImageMagick")
+# Pkg.build("ImageMagick")
 
-Pkg.clone("ImageMagick")
-Pkg.build("ImageMagick")
+# Pkg.clone("GR")
+# Pkg.build("GR")
 
-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/JuliaStats/KernelDensity.jl.git")
+
+Pkg.clone("StatPlots")
+Pkg.checkout("PlotUtils")
+
 # Pkg.clone("https://github.com/JunoLab/Blink.jl.git")
 # Pkg.build("Blink")
 # import Blink
 # Blink.AtomShell.install()
 # Pkg.clone("https://github.com/spencerlyon2/PlotlyJS.jl.git")
 
-Pkg.checkout("RecipesBase")
-Pkg.clone("VisualRegressionTests")
+# Pkg.checkout("RecipesBase")
+# Pkg.clone("VisualRegressionTests")
 
+# need this to use Conda
 ENV["PYTHON"] = ""
 Pkg.add("PyPlot")
 Pkg.build("PyPlot")