Merge pull request #814 from ChrisRackauckas/patch-2

Fix plotpane notice

.gitignore

@@ -4,3 +4,4 @@
 .DS_Store
 examples/.ipynb_checkpoints/*
 examples/meetup/.ipynb_checkpoints/*
+deps/plotly-latest.min.js

.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,15 +3,290 @@
 
 #### notes on release changes, ongoing development, and future planned work
 
-- All new development should target 0.7!
+- All new development should target 0.12!
+- Minor version 0.11 is the last one to support Julia 0.5!!
+	- Critical bugfixes only
+    - `backports` branch is for Julia 0.4
 
 ---
 
-## 0.7 (current master/dev)
+## 0.11 (current master/dev)
+
+#### 0.11.0
+
+- julia 0.6 compatibility
+- matplotlib 0.2.0 compatibility
+- add inspectdr backend
+- improved histogram functionality:
+- added a `:stephist` and `:scatterhist` series type as well as ``:barhist` (the default)
+- support for log scale axes with histograms
+- support for plotting `StatsBase.Histogram`
+- allowing bins to be specified as `:sturges`, `:rice`, `:scott` or :fd
+- allow `normalization` to be specified as :density (for unequal bins) or :pdf (sum to 1)
+- add a `plotattr` function to access documentation for Plots attribute
+- add `fill_z` attribute for pyplot
+- add colorbar_title to plotlyjs
+- enable standalone window for plotlyjs
+- improved support for pgfplots, ticks rotation, clims, series_annotations
+- restore colorbars for GR
+- better axis labels for heatmap in GR
+- better marker sizes in GR
+- fix color representation in GR
+- update GR legend
+- fix image bug on GR
+- fix glvisualize dependencies
+- set dotted grid lines for pyplot
+- several improvements to inspectdr
+- improved tick positions for TimeType x axes
+- support for improved color gradient capability in PlotUtils
+- add a showlibrary recipe to display color libraries
+- add a showgradient recipe to display color gradients
+- add `vectorfield` as an alias for `quiver`
+- use `PlotUtils.adaptedgrid` for functions
+
+
+#### 0.9.5
+
+- added dependency on PlotThemes
+- set_theme --> theme
+- remove Compat from REQUIRE
+- warning for DataFrames without StatPlots
+- closeall exported and implemented for gr/pyplot
+- fix DateTime recipe
+- reset theme with theme(:none)
+- fix link_axes! for nested subplots
+- fix plotly lims for log scale
+
+#### 0.9.4
+
+- optimizations surrounding Subplot.series_list
+- better Atom support, support plotlyjs
+- gr:
+    - gks_wstype defaults and gr_set_output
+    - heatmap uses GR.drawimage
+- histogram2d puts NaN for zeros
+- improved support of NaN in heatmaps
+- rebuilt spy recipes to output scatters with marker_z set
+- deprecate png support in plotly... point to plotlyjs
+- fixes:
+    - axis widen with lims set
+    - reset_extrema, setxyz
+    - bar plot widen
+    - better tick padding
+    - consistent tick rotation
+    - consistent aspect_ratio
+    - pyplot dpi
+    - plotly horizontal bars
+    - handle series attributes when combining subplots
+    - gr images transposed
+    - converted Date/DateTime to new type recipe approach for arrays
+- issues closed include: #505 #513 #479 #523 #526 #529
+
+#### 0.9.3
+
+- support pdf and eps in plotlyjs backend
+- allow curly after grid: `@layout [a b; grid(4,4){0.8h}]`
+- add_backend redesign
+
+#### 0.9.2
+
+- glvisualize backend (@SimonDanisch)
+    - too much to list! ready for alpha testing
+- Volume and volume seriestype
+- Atom: support for PlotPane and proper gui display
+- gr:
+    - clims
+    - aspect ratio
+- pgfplots:
+    - fixes for ticks, axes, and more
+- pyplot:
+    - font families
+    - colorbar guide
+    - pixel marker
+- unicodeplots
+    - basic support for shapes
+- improved add_backend
+- refactor of is_supported methods
+- element-wise type recipes (see https://github.com/tbreloff/Plots.jl/issues/460#issuecomment-248428908)
+- several other fixes/improvements
+
+#### 0.9.1
+
+- Pkg.dir --> dirname (@tkelman)
+- `axis = nothing` magic
+- fixes:
+    - clim for line_z
+    - sticks default range for log scale
+    - rotate method
+    - pyplot heatmap
+    - spurious scale warnings
+    - gr image/alpha
+    - plotly.js path
+    - orientation extrema
+    - bar, reset orientation
+- switch transpose_z to use permutedims
+- skinny x/+ markers
+- ticks in pgfplots
+- eps in savefig (@anriseth)
+- add_backend convenience
+- type recipes for Date/DateTime (@maximsch2)
+- mirror attribute and twinx convenience
+- Axis.sp --> Axis.sps
+- recipe postprocessing for allowing aliases and magic args in recipe bodies
+
+
+
+#### 0.9.0
+
+- fixes to cycle
+- add back single function recipe: `plot!(cos)`
+- new axis formatter attribute... accepts functions to convert numbers to strings
+- fix for inset plots
+- GR:
+	- fillrange fix
+	- annotations fix
+	- force double buffering in display
+
+---
+
+## 0.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
+
+- line_z arg for multicolored line segments
+- pyplot
+	- line_z (2d and 3d)
+	- pushed all fig updates into display pipeline
+	- remove native sticks/hline/vline in favor of recipes
+- unicodeplots cleanup, ijulia fixes, ascii canvas
+- `curves` series type
+- `iter_segments` iterator
+- moved arcdiagram out and into PlotRecipes (thanks @diegozea)
+- several other fixes/checks
+
+#### 0.7.1
+
+- inset (floating) subplots
+- change: when setting subplot/axis args from user recipes, they should apply only to their own subplot
+- trim for violin/boxplot
+- scatter3d recipe
+- removed plotly.js in favor of build.jl download
+- improvements/fixes to pgfplots backend
+- improvements/fixes to plotly/plotlyjs backends
+	- titles are annotations and properly placed with title_position
+	- hover attribute
+	- shapes (almost)
+	- scattergl
+- minimum perimeter logic in layout calc... fixed misaligned subplots
+- new clims attribute
+- more options for test_examples
+- GR refactor
+	- added transparency
+	- moved axis/grid logic out of series loop
+	- generalized 3d and polar projections
+- renamed get_mod to Base.cycle
+- pyplot log scale fixes
+- PLOTS_DEFAULTS environment var processing
+- rename :ellipse to :circle, :ellipse is now an alias
+- supported args/types cleanup
+- seriestype dependency methods and `@deps` macro
+- bbox `h_anchor`/`v_anchor`
+- new axis arg: `:link` is a list of subplots to link axes with
+- cleanup/simplification of glvisualize backend
+
 
 #### 0.7.0
 
-- Check out [the summary](http://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)
@@ -143,7 +418,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

@@ -1,6 +1,6 @@
 # Plots
 
-[![Build Status](https://travis-ci.org/tbreloff/Plots.jl.svg?branch=master)](https://travis-ci.org/tbreloff/Plots.jl)
+[![Build Status](https://travis-ci.org/JuliaPlots/Plots.jl.svg?branch=master)](https://travis-ci.org/JuliaPlots/Plots.jl)
 [![Join the chat at https://gitter.im/tbreloff/Plots.jl](https://badges.gitter.im/tbreloff/Plots.jl.svg)](https://gitter.im/tbreloff/Plots.jl?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 <!-- [![Plots](http://pkg.julialang.org/badges/Plots_0.3.svg)](http://pkg.julialang.org/?pkg=Plots&ver=0.3) -->
 <!-- [![Plots](http://pkg.julialang.org/badges/Plots_0.4.svg)](http://pkg.julialang.org/?pkg=Plots&ver=0.4) -->
@@ -12,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,10 @@
-julia 0.4
+julia 0.5
 
 RecipesBase
-Colors
+PlotUtils
+PlotThemes
 Reexport
-Compat
 FixedSizeArrays
 Measures
+Showoff
+StatsBase 0.14.0

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

deps/build.jl

@@ -0,0 +1,8 @@
+
+#TODO: download https://cdn.plot.ly/plotly-latest.min.js to deps/ if it doesn't exist
+
+local_fn = joinpath(dirname(@__FILE__), "plotly-latest.min.js")
+if !isfile(local_fn)
+	info("Cannot find deps/plotly-latest.min.js... downloading latest version.")
+	download("https://cdn.plot.ly/plotly-latest.min.js", local_fn)
+end

src/Plots.jl

@@ -1,95 +1,42 @@
-
- __precompile__()
+__precompile__(true)
 
 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
+import StatsBase
 
 export
-    AbstractPlot,
-    Plot,
-    Subplot,
-    AbstractLayout,
-    GridLayout,
     grid,
-    EmptyLayout,
+    bbox,
+    plotarea,
     @layout,
-    # RowsLayout,
-    # FlexLayout,
-    AVec,
-    AMat,
     KW,
-    # attr,
-    # attr!,
 
     wrap,
-    set_theme,
-    add_theme,
+    theme,
 
     plot,
     plot!,
-    # subplot,
-    # subplot!,
+    attr!,
 
     current,
     default,
     with,
+    twinx,
 
     @userplot,
     @shorthands,
-    # scatter,
-    # scatter!,
-    # bar,
-    # bar!,
-    # barh,
-    # barh!,
-    # histogram,
-    # histogram!,
-    # histogram2d,
-    # histogram2d!,
-    # density,
-    # density!,
-    # heatmap,
-    # heatmap!,
-    # hexbin,
-    # hexbin!,
-    # sticks,
-    # sticks!,
-    # hline,
-    # hline!,
-    # vline,
-    # vline!,
-    # ohlc,
-    # ohlc!,
+
     pie,
     pie!,
-    # contour,
-    # contour!,
-    # contour3d,
-    # contour3d!,
-    # surface,
-    # surface!,
-    # wireframe,
-    # wireframe!,
-    # path3d,
-    # path3d!,
     plot3d,
     plot3d!,
-    # scatter3d,
-    # scatter3d!,
-    # abline!,
-    # boxplot,
-    # boxplot!,
-    # violin,
-    # violin!,
-    # quiver,
-    # quiver!,
 
     title!,
     xlabel!,
@@ -105,64 +52,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,
-    # xaxis,
-    # yaxis,
-    # zaxis,
     stroke,
     brush,
     Surface,
     OHLC,
     arrow,
-
-    colorscheme,
-    ColorScheme,
-    ColorGradient,
-    ColorVector,
-    ColorWrapper,
-    ColorFunction,
-    ColorZFunction,
-    getColor,
-    getColorZ,
-
-    debugplots,
-
-    supportedArgs,
-    supportedAxes,
-    supportedTypes,
-    supportedStyles,
-    supportedMarkers,
-    subplotSupported,
+    Segments,
+    Formatted,
 
     Animation,
     frame,
     gif,
+    mov,
+    mp4,
+    animate,
     @animate,
     @gif,
 
-    PlotRecipe,
-    spy,
-    arcdiagram,
-    chorddiagram,
-
-    # @kw,
-    # @recipe,
-    # @plotrecipe,
-
     test_examples,
+    iter_segments,
+    coords,
 
     translate,
     translate!,
@@ -172,29 +101,28 @@ export
     P2,
     P3,
     BezierCurve,
-    curve_points,
-    directed_curve
+
+    plotattr
 
 # ---------------------------------------------------------
 
 import Measures
-import Measures: Length, AbsoluteLength, Measure, BoundingBox, mm, cm, inch, pt, width, height
+import Measures: Length, AbsoluteLength, Measure, BoundingBox, mm, cm, inch, pt, width, height, w, h
 typealias BBox Measures.Absolute2DBox
-export BBox, BoundingBox, mm, cm, inch, pt, px, pct
+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")
@@ -202,6 +130,7 @@ include("animation.jl")
 include("output.jl")
 include("examples.jl")
 include("arg_desc.jl")
+include("plotattr.jl")
 
 
 # ---------------------------------------------------------
@@ -209,20 +138,20 @@ include("arg_desc.jl")
 # define and export shorthand plotting method definitions
 macro shorthands(funcname::Symbol)
     funcname2 = Symbol(funcname, "!")
-    ret = esc(quote
+    esc(quote
         export $funcname, $funcname2
         $funcname(args...; kw...) = plot(args...; kw..., seriestype = $(quot(funcname)))
         $funcname2(args...; kw...) = plot!(args...; kw..., seriestype = $(quot(funcname)))
     end)
-    # dump(ret,20)
-    # @show ret
-    ret
 end
 
 @shorthands scatter
 @shorthands bar
 @shorthands barh
 @shorthands histogram
+@shorthands barhist
+@shorthands stephist
+@shorthands scatterhist
 @shorthands histogram2d
 @shorthands density
 @shorthands heatmap
@@ -231,8 +160,8 @@ end
 @shorthands hline
 @shorthands vline
 @shorthands ohlc
-# @shorthands pie
 @shorthands contour
+@shorthands contourf
 @shorthands contour3d
 @shorthands surface
 @shorthands wireframe
@@ -241,53 +170,12 @@ end
 @shorthands boxplot
 @shorthands violin
 @shorthands quiver
+@shorthands curves
 
-# scatter(args...; kw...)    = plot(args...; kw...,  seriestype = :scatter)
-# scatter!(args...; kw...)   = plot!(args...; kw..., seriestype = :scatter)
-# bar(args...; kw...)        = plot(args...; kw...,  seriestype = :bar)
-# bar!(args...; kw...)       = plot!(args...; kw..., seriestype = :bar)
-# barh(args...; kw...)        = plot(args...; kw...,  seriestype = :barh, orientation = :h)
-# barh!(args...; kw...)       = plot!(args...; kw..., seriestype = :barh, orientation = :h)
-# histogram(args...; kw...)  = plot(args...; kw...,  seriestype = :histogram)
-# histogram!(args...; kw...) = plot!(args...; kw..., seriestype = :histogram)
-# histogram2d(args...; kw...)  = plot(args...; kw...,  seriestype = :histogram2d)
-# histogram2d!(args...; kw...) = plot!(args...; kw..., seriestype = :histogram2d)
-# density(args...; kw...)    = plot(args...; kw...,  seriestype = :density)
-# density!(args...; kw...)   = plot!(args...; kw..., seriestype = :density)
-# heatmap(args...; kw...)    = plot(args...; kw...,  seriestype = :heatmap)
-# heatmap!(args...; kw...)   = plot!(args...; kw..., seriestype = :heatmap)
-# hexbin(args...; kw...)     = plot(args...; kw...,  seriestype = :hexbin)
-# hexbin!(args...; kw...)    = plot!(args...; kw..., seriestype = :hexbin)
-# sticks(args...; kw...)     = plot(args...; kw...,  seriestype = :sticks, marker = :ellipse)
-# sticks!(args...; kw...)    = plot!(args...; kw..., seriestype = :sticks, marker = :ellipse)
-# hline(args...; kw...)      = plot(args...; kw...,  seriestype = :hline)
-# hline!(args...; kw...)     = plot!(args...; kw..., seriestype = :hline)
-# vline(args...; kw...)      = plot(args...; kw...,  seriestype = :vline)
-# vline!(args...; kw...)     = plot!(args...; kw..., seriestype = :vline)
-# ohlc(args...; kw...)       = plot(args...; kw...,  seriestype = :ohlc)
-# ohlc!(args...; kw...)      = plot!(args...; kw..., seriestype = :ohlc)
 pie(args...; kw...)        = plot(args...; kw...,  seriestype = :pie, aspect_ratio = :equal, grid=false, xticks=nothing, yticks=nothing)
 pie!(args...; kw...)       = plot!(args...; kw..., seriestype = :pie, aspect_ratio = :equal, grid=false, xticks=nothing, yticks=nothing)
-# contour(args...; kw...)    = plot(args...; kw...,  seriestype = :contour)
-# contour!(args...; kw...)   = plot!(args...; kw..., seriestype = :contour)
-# contour3d(args...; kw...)  = plot(args...; kw...,  seriestype = :contour3d)
-# contour3d!(args...; kw...) = plot!(args...; kw..., seriestype = :contour3d)
-# surface(args...; kw...)    = plot(args...; kw...,  seriestype = :surface)
-# surface!(args...; kw...)   = plot!(args...; kw..., seriestype = :surface)
-# wireframe(args...; kw...)  = plot(args...; kw...,  seriestype = :wireframe)
-# wireframe!(args...; kw...) = plot!(args...; kw..., seriestype = :wireframe)
-# path3d(args...; kw...)     = plot(args...; kw...,  seriestype = :path3d)
-# path3d!(args...; kw...)    = plot!(args...; kw..., seriestype = :path3d)
 plot3d(args...; kw...)     = plot(args...; kw...,  seriestype = :path3d)
 plot3d!(args...; kw...)    = plot!(args...; kw..., seriestype = :path3d)
-# scatter3d(args...; kw...)  = plot(args...; kw...,  seriestype = :scatter3d)
-# scatter3d!(args...; kw...) = plot!(args...; kw..., seriestype = :scatter3d)
-# boxplot(args...; kw...)    = plot(args...; kw...,  seriestype = :boxplot)
-# boxplot!(args...; kw...)   = plot!(args...; kw..., seriestype = :boxplot)
-# violin(args...; kw...)     = plot(args...; kw...,  seriestype = :violin)
-# violin!(args...; kw...)    = plot!(args...; kw..., seriestype = :violin)
-# quiver(args...; kw...)     = plot(args...; kw...,  seriestype = :quiver)
-# quiver!(args...; kw...)    = plot!(args...; kw..., seriestype = :quiver)
 
 
 title!(s::AbstractString; kw...)                 = plot!(; title = s, kw...)
@@ -312,41 +200,44 @@ 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
 
 
 # ---------------------------------------------------------
 
 const CURRENT_BACKEND = CurrentBackend(:none)
 
-# setup_dataframes()
-
 function __init__()
     setup_ijulia()
-    # setup_dataframes()
     setup_atom()
-    # add_axis_letter_defaults()
+
+    if isdefined(Main, :PLOTS_DEFAULTS)
+        for (k,v) in Main.PLOTS_DEFAULTS
+            default(k, v)
+        end
+    end
 end
 
 # ---------------------------------------------------------

src/animation.jl

@@ -1,62 +1,110 @@
 
 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::Compat.ASCIIString = "tmp.gif"; fps::Integer = 20)
-  fn = abspath(fn)
+file_extension(fn) = Base.Filesystem.splitext(fn)[2][2:end]
 
-  try
+gif(anim::Animation, fn = giffn(); kw...) = buildanimation(anim.dir, fn; kw...)
+mov(anim::Animation, fn = movfn(); kw...) = buildanimation(anim.dir, fn; kw...)
+mp4(anim::Animation, fn = mp4fn(); kw...) = buildanimation(anim.dir, fn; kw...)
 
-    # high quality
-    speed = round(Int, 100 / fps)
-    file = joinpath(Pkg.dir("ImageMagick"), "deps","deps.jl")
-    if isfile(file) && !haskey(ENV, "MAGICK_CONFIGURE_PATH")
-        include(file)
+const _imagemagick_initialized = Ref(false)
+
+function buildanimation(animdir::AbstractString, fn::AbstractString;
+                        fps::Integer = 20, loop::Integer = 0)
+    fn = abspath(fn)
+    try
+        if !_imagemagick_initialized[]
+            file = joinpath(Pkg.dir("ImageMagick"), "deps","deps.jl")
+            if isfile(file) && !haskey(ENV, "MAGICK_CONFIGURE_PATH")
+                include(file)
+            end
+            _imagemagick_initialized[] = true
+        end
+
+        # prefix = get(ENV, "MAGICK_CONFIGURE_PATH", "")
+        # high quality
+        speed = round(Int, 100 / fps)
+        run(`convert -delay $speed -loop $loop $(joinpath(animdir, "*.png")) -alpha off $fn`)
+
+    catch err
+        warn("""Tried to create gif using convert (ImageMagick), but got error: $err
+            ImageMagick can be installed by executing `Pkg.add("ImageMagick")`.
+            You may also need to install the imagemagick c++ library through your operating system. 
+            Will try ffmpeg, but it's lower quality...)""")
+
+        # low quality
+        run(`ffmpeg -v 0 -framerate $fps -loop $loop -i $(animdir)/%06d.png -y $fn`)
+        # run(`ffmpeg -v warning -i  "fps=$fps,scale=320:-1:flags=lanczos"`)
     end
-    prefix = get(ENV, "MAGICK_CONFIGURE_PATH", "")
-    run(`$(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 +170,7 @@ Example:
 ```
 """
 macro gif(forloop::Expr, args...)
-  _animate(forloop, args...; callgif = true)
+    _animate(forloop, args...; callgif = true)
 end
 
 """
@@ -131,13 +179,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,15 +19,17 @@ const _arg_desc = KW(
 :markersize        	=> "Number or AbstractVector. Size (radius pixels) of the markers.",
 :markerstrokestyle 	=> "Symbol. Style of the marker stroke (border).  Choose from $(_allStyles)",
 :markerstrokewidth 	=> "Number. Width of the marker stroke (border. in pixels)",
-:markerstrokecolor 	=> "Color Type. Color of the marker stroke (border).  `:match` will take the value from `:seriescolor`.",
+:markerstrokecolor 	=> "Color Type. Color of the marker stroke (border).  `:match` will take the value from `:foreground_color_subplot`.",
 :markerstrokealpha 	=> "Number in [0,1]. The alpha/opacity override for the marker stroke (border).  `nothing` (the default) means it will take the alpha value of markerstrokecolor.",
-:bins              	=> "Integer, NTuple{2,Integer}, AbstractVector. For histogram-types, defines the number of bins, or the edges, of the histogram.",
+:bins              	=> "Integer, NTuple{2,Integer}, AbstractVector or Symbol. Default is :auto. For histogram-types, defines the number of bins, or the edges, of the histogram, or the auto-binning algorithm to use (:sturges, :sqrt, :rice, :scott or :fd)",
 :smooth            	=> "Bool.  Add a regression line?",
 :group             	=> "AbstractVector. Data is split into a separate series, one for each unique value in `group`.",
 :x                 	=> "Various. Input data. First Dimension",
 :y                 	=> "Various. Input data. Second Dimension",
 :z                 	=> "Various. Input data. Third Dimension. May be wrapped by a `Surface` for surface and heatmap types.",
-:marker_z          	=> "AbstractVector. z-values for each series data point, which correspond to the color to be used from a markercolor gradient.",
+: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)",
@@ -38,13 +40,14 @@ const _arg_desc = KW(
 :ribbon            	=> "Number or AbstractVector.  Creates a fillrange around the data points.",
 :quiver            	=> "AbstractVector or 2-Tuple of vectors.  The directional vectors U,V which specify velocity/gradient vectors for a quiver plot.",
 :arrow             	=> "nothing (no arrows), Bool (if true, default arrows), Arrow object, or arg(s) that could be style or head length/widths.  Defines arrowheads that should be displayed at the end of path line segments (just before a NaN and the last non-NaN point).  Used in quiverplot, streamplot, or similar.",
-:normalize         	=> "Bool. Should normalize histogram types?  Trying for area == 1.",
+:normalize         	=> "Bool or Symbol. Histogram normalization mode. Possible values are: false/:none (no normalization, default), true/:pdf (normalize to a PDF with integral of 1) and :density (only normalize in respect to bin sizes).",
 :weights           	=> "AbstractVector. Used in histogram types for weighted counts.",
 :contours          	=> "Bool. Add contours to the side-grids of 3D plots?  Used in surface/wireframe.",
 :match_dimensions  	=> "Bool. For heatmap types... should the first dimension of a matrix (rows) correspond to the first dimension of the plot (x-axis)?  The default is false, which matches the behavior of Matplotlib, Plotly, and others.  Note: when passing a function for z, the function should still map `(x,y) -> z`.",
 :subplot           	=> "Integer (subplot index) or Subplot object.  The subplot that this series belongs to.",
 :series_annotations => "AbstractVector of String or PlotText.  These are annotations which are mapped to data points/positions.",
 :primary            => "Bool.  Does this count as a 'real series'?  For example, you could have a path (primary), and a scatter (secondary) as 2 separate series, maybe with different data (see sticks recipe for an example).  The secondary series will get the same color, etc as the primary.",
+:hover 				=> "nothing or vector of strings. Text to display when hovering over each data point.",
 
 # plot args
 :plot_title               => "String. Title for the whole plot (not the subplots) (Note: Not currently implemented)",
@@ -59,6 +62,10 @@ const _arg_desc = KW(
 :link                     => "Symbol.  How/whether to link axis limits between subplots. Values: `:none`, `:x` (x axes are linked by columns), `:y` (y axes are linked by rows), `:both` (x and y are linked), `:all` (every subplot is linked together regardless of layout position).",
 :overwrite_figure         => "Bool.  Should we reuse the same GUI window/figure when plotting (true) or open a new one (false).",
 :html_output_format       => "Symbol.  When writing html output, what is the format?  `:png` and `:svg` are currently supported.",
+:inset_subplots 		  => "nothing or vector of 2-tuple (parent,bbox).  optionally pass a vector of (parent,bbox) tuples which are the parent layout and the relative bounding box of inset subplots",
+:dpi 					  => "Number.  Dots Per Inch of output figures",
+: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.",
@@ -74,17 +81,19 @@ const _arg_desc = KW(
 :color_palette            => "Vector of colors (cycle through) or color gradient (generate list from gradient) or `:auto` (generate a color list using `Colors.distiguishable_colors` and custom seed colors chosen to contrast with the background).  The color palette is a color list from which series colors are automatically chosen.",
 :legend                   => "Bool (show the legend?) or Symbol (legend position).  Symbol values: `:none`, `:best`, `:right`, `:left`, `:top`, `:bottom`, `:inside`, `:legend`, `:topright`, `:topleft`, `:bottomleft`, `:bottomright` (note: only some may be supported in each backend)",
 :colorbar                 => "Bool (show the colorbar?) or Symbol (colorbar position).  Symbol values: `:none`, `:best`, `:right`, `:left`, `:top`, `:bottom`, `:legend` (matches legend value) (note: only some may be supported in each backend)",
+:clims 					  => "`:auto` or NTuple{2,Number}.  Fixes the limits of the colorbar.",
 :legendfont               => "Font. Font of legend items.",
 :grid                     => "Bool. Show the grid lines?",
 :annotations              => "(x,y,text) tuple(s).  Can be a single tuple or a list of them.  Text can be String or PlotText (created with `text(args...)`)  Add one-off text annotations at the x,y coordinates.",
 :projection               => "Symbol or String.  '3d' or 'polar'",
-:aspect_ratio             => "Symbol (:equal) or Number (width to height ratio of plot area).",
+:aspect_ratio             => "Symbol (:equal) or Number. Plot area is resized so that 1 y-unit is the same size as `apect_ratio` x-units.",
 :margin                   => "Measure (multiply by `mm`, `px`, etc). Base for individual margins... not directly used.  Specifies the extra padding around subplots.",
 :left_margin              => "Measure (multiply by `mm`, `px`, etc) or `:match` (matches `:margin`).  Specifies the extra padding to the left of the subplot.",
 :top_margin               => "Measure (multiply by `mm`, `px`, etc) or `:match` (matches `:margin`).  Specifies the extra padding on the top of the subplot.",
 :right_margin             => "Measure (multiply by `mm`, `px`, etc) or `:match` (matches `:margin`).  Specifies the extra padding to the right of the subplot.",
 :bottom_margin            => "Measure (multiply by `mm`, `px`, etc) or `:match` (matches `:margin`).  Specifies the extra padding on the bottom of the subplot.",
 :subplot_index            => "Integer.  Internal (not set by user).  Specifies the index of this subplot in the Plot's `plt.subplot` list.",
+:colorbar_title           => "String.  Title of colorbar.",
 
 # axis args
 :guide     				  => "String. Axis guide (label).",
@@ -93,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/axes.jl

@@ -23,13 +23,22 @@ 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)
+    axissym = Symbol(letter, :axis)
+    if haskey(sp.attr, axissym)
+        sp.attr[axissym]
+    else
+        sp.attr[axissym] = Axis(sp, letter)
+    end::Axis
 end
 
 function process_axis_arg!(d::KW, arg, letter = "")
@@ -64,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")
 
@@ -71,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
@@ -91,6 +103,12 @@ function update!(axis::Axis, args...; kw...)
             end
         end
     end
+
+    # replace scale aliases
+    if haskey(_scaleAliases, d[:scale])
+        d[:scale] = _scaleAliases[d[:scale]]
+    end
+
     axis
 end
 
@@ -102,19 +120,145 @@ 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)
+
+    # If the axis input was a Date or DateTime use a special logic to find
+    # "round" Date(Time)s as ticks
+    # This bypasses the rest of optimal_ticks_and_labels, because
+    # optimize_datetime_ticks returns ticks AND labels: the label format (Date
+    # or DateTime) is chosen based on the time span between amin and amax
+    # rather than on the input format
+    # TODO: maybe: non-trivial scale (:ln, :log2, :log10) for date/datetime
+    if ticks == nothing && scale == :identity
+        if axis[:formatter] == dateformatter
+            # optimize_datetime_ticks returns ticks and labels(!) based on
+            # integers/floats corresponding to the DateTime type. Thus, the axes
+            # limits, which resulted from converting the Date type to integers,
+            # are converted to 'DateTime integers' (actually floats) before
+            # being passed to optimize_datetime_ticks.
+            # (convert(Int, convert(DateTime, convert(Date, i))) == 87600000*i)
+            ticks, labels = optimize_datetime_ticks(864e5 * amin, 864e5 * amax;
+                k_min = 2, k_max = 4)
+            # Now the ticks are converted back to floats corresponding to Dates.
+            return ticks / 864e5, labels
+        elseif axis[:formatter] == datetimeformatter
+            return optimize_datetime_ticks(amin, amax; k_min = 2, k_max = 4)
+        end
+    end
+
+    # get a list of well-laid-out ticks
+    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 && ticks == :auto
+        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)
@@ -124,6 +268,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)
@@ -140,20 +290,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
 
@@ -164,7 +327,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
@@ -189,8 +351,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))
@@ -213,12 +373,17 @@ function widen(lmin, lmax)
     lmin-eps, lmax+eps
 end
 
-# figure out if widening is a good idea
+# figure out if widening is a good idea.  if there's a scale set it's too tricky,
+# so lazy out and don't widen
 function default_should_widen(axis::Axis)
     should_widen = false
-    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
     should_widen
@@ -229,7 +394,7 @@ function axis_limits(axis::Axis, should_widen::Bool = default_should_widen(axis)
     ex = axis[:extrema]
     amin, amax = ex.emin, ex.emax
     lims = axis[:lims]
-    if isa(lims, Tuple) && length(lims) == 2
+    if (isa(lims, Tuple) || isa(lims, AVec)) && length(lims) == 2
         if isfinite(lims[1])
             amin = lims[1]
         end
@@ -237,9 +402,12 @@ function axis_limits(axis::Axis, should_widen::Bool = default_should_widen(axis)
             amax = lims[2]
         end
     end
-    if amax <= amin
+    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
@@ -312,3 +480,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,24 +217,90 @@ function warn_on_deprecated_backend(bsym::Symbol)
     end
 end
 
-# ---------------------------------------------------------
 
-supportedAxes(::AbstractBackend) = [:left]
-supportedTypes(::AbstractBackend) = []
-supportedStyles(::AbstractBackend) = [:solid]
-supportedMarkers(::AbstractBackend) = [:none]
-supportedScales(::AbstractBackend) = [:identity]
-subplotSupported(::AbstractBackend) = false
-stringsSupported(::AbstractBackend) = false
-nativeImagesSupported(b::AbstractBackend) = :image in supportedTypes(b)
-
-supportedAxes() = supportedAxes(backend())
-supportedTypes() = supportedTypes(backend())
-supportedStyles() = supportedStyles(backend())
-supportedMarkers() = supportedMarkers(backend())
-supportedScales() = supportedScales(backend())
-subplotSupported() = subplotSupported(backend())
-stringsSupported() = stringsSupported(backend())
-nativeImagesSupported() = nativeImagesSupported(backend())
 
 # ---------------------------------------------------------
+
+# these are args which every backend supports because they're not used in the backend code
+const _base_supported_args = [
+    :color_palette,
+    :background_color, :background_color_subplot,
+    :foreground_color, :foreground_color_subplot,
+    :group,
+    :seriestype,
+    :seriescolor, :seriesalpha,
+    :smooth,
+    :xerror, :yerror,
+    :subplot,
+    :x, :y, :z,
+    :show, :size,
+    :margin,
+    :left_margin,
+    :right_margin,
+    :top_margin,
+    :bottom_margin,
+    :html_output_format,
+    :layout,
+    :link,
+    :primary,
+    :series_annotations,
+    :subplot_index,
+    :discrete_values,
+    :projection,
+
+]
+
+function merge_with_base_supported(v::AVec)
+    v = vcat(v, _base_supported_args)
+    for vi in v
+        if haskey(_axis_defaults, vi)
+            for letter in (:x,:y,:z)
+                push!(v, Symbol(letter,vi))
+            end
+        end
+    end
+    Set(v)
+end
+
+
+
+# @init_backend 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/inspectdr.jl

@@ -0,0 +1,529 @@
+
+# https://github.com/ma-laforge/InspectDR.jl
+
+#=TODO:
+    Tweak scale factor for width & other sizes
+
+Not supported by InspectDR:
+    :foreground_color_grid
+    :foreground_color_border
+    :polar,
+
+Add in functionality to Plots.jl:
+    :aspect_ratio,
+=#
+
+# ---------------------------------------------------------------------------
+#TODO: remove features
+const _inspectdr_attr = merge_with_base_supported([
+    :annotations,
+    :background_color_legend, :background_color_inside, :background_color_outside,
+    :foreground_color_grid, :foreground_color_legend, :foreground_color_title,
+    :foreground_color_axis, :foreground_color_border, :foreground_color_guide, :foreground_color_text,
+    :label,
+    :linecolor, :linestyle, :linewidth, :linealpha,
+    :markershape, :markercolor, :markersize, :markeralpha,
+    :markerstrokewidth, :markerstrokecolor, :markerstrokealpha,
+    :markerstrokestyle, #Causes warning not to have it... what is this?
+    :fillcolor, :fillalpha, #:fillrange,
+#    :bins, :bar_width, :bar_edges, :bar_position,
+    :title, :title_location, :titlefont,
+    :window_title,
+    :guide, :lims, :scale, #:ticks, :flip, :rotation,
+    :tickfont, :guidefont, :legendfont,
+    :grid, :legend, #:colorbar,
+#    :marker_z,
+#    :line_z,
+#    :levels,
+ #   :ribbon, :quiver, :arrow,
+#    :orientation,
+    :overwrite_figure,
+    :polar,
+#    :normalize, :weights,
+#    :contours, :aspect_ratio,
+    :match_dimensions,
+#    :clims,
+#    :inset_subplots,
+    :dpi,
+#    :colorbar_title,
+  ])
+const _inspectdr_style = [:auto, :solid, :dash, :dot, :dashdot]
+const _inspectdr_seriestype = [
+        :path, :scatter, :shape #, :steppre, :steppost
+    ]
+#see: _allMarkers, _shape_keys
+const _inspectdr_marker = Symbol[
+    :none, :auto,
+    :circle, :rect, :diamond,
+    :cross, :xcross,
+    :utriangle, :dtriangle, :rtriangle, :ltriangle,
+    :pentagon, :hexagon, :heptagon, :octagon,
+    :star4, :star5, :star6, :star7, :star8,
+    :vline, :hline, :+, :x,
+]
+
+const _inspectdr_scale = [:identity, :ln, :log2, :log10]
+
+is_marker_supported(::InspectDRBackend, shape::Shape) = true
+
+_inspectdr_to_pixels(bb::BoundingBox) =
+    InspectDR.BoundingBox(to_pixels(left(bb)), to_pixels(right(bb)), to_pixels(top(bb)), to_pixels(bottom(bb)))
+
+#Do we avoid Map to avoid possible pre-comile issues?
+function _inspectdr_mapglyph(s::Symbol)
+    s == :rect && return :square
+    return s
+end
+
+function _inspectdr_mapglyph(s::Shape)
+    x, y = coords(s)
+    return InspectDR.GlyphPolyline(x, y)
+end
+
+# py_marker(markers::AVec) = map(py_marker, markers)
+function _inspectdr_mapglyph(markers::AVec)
+    warn("Vectors of markers are currently unsupported in InspectDR.")
+    _inspectdr_mapglyph(markers[1])
+end
+
+_inspectdr_mapglyphsize(v::Real) = v
+function _inspectdr_mapglyphsize(v::Vector)
+    warn("Vectors of marker sizes are currently unsupported in InspectDR.")
+    _inspectdr_mapglyphsize(v[1])
+end
+
+_inspectdr_mapcolor(v::Colorant) = v
+function _inspectdr_mapcolor(g::PlotUtils.ColorGradient)
+    warn("Color gradients are currently unsupported in InspectDR.")
+    #Pick middle color:
+    _inspectdr_mapcolor(g.colors[div(1+end,2)])
+end
+function _inspectdr_mapcolor(v::AVec)
+    warn("Vectors of colors are currently unsupported in InspectDR.")
+    #Pick middle color:
+    _inspectdr_mapcolor(v[div(1+end,2)])
+end
+
+#Hack: suggested point size does not seem adequate relative to plot size, for some reason.
+_inspectdr_mapptsize(v) = 1.5*v
+
+function _inspectdr_add_annotations(plot, x, y, val)
+    #What kind of annotation is this?
+end
+
+#plot::InspectDR.Plot2D
+function _inspectdr_add_annotations(plot, x, y, val::PlotText)
+    vmap = Dict{Symbol, Symbol}(:top=>:t, :bottom=>:b) #:vcenter
+    hmap = Dict{Symbol, Symbol}(:left=>:l, :right=>:r) #:hcenter
+    align = Symbol(get(vmap, val.font.valign, :c), get(hmap, val.font.halign, :c))
+    fnt = InspectDR.Font(val.font.family, val.font.pointsize,
+        color =_inspectdr_mapcolor(val.font.color)
+    )
+    ann = InspectDR.atext(val.str, x=x, y=y,
+        font=fnt, angle=val.font.rotation, align=align
+    )
+    InspectDR.add(plot, ann)
+    return
+end
+
+# ---------------------------------------------------------------------------
+
+function _inspectdr_getscale(s::Symbol, yaxis::Bool)
+#TODO: Support :asinh, :sqrt
+    kwargs = yaxis? (:tgtmajor=>8, :tgtminor=>2): () #More grid lines on y-axis
+    if :log2 == s
+        return InspectDR.AxisScale(:log2; kwargs...)
+    elseif :log10 == s
+        return InspectDR.AxisScale(:log10; kwargs...)
+    elseif :ln == s
+        return InspectDR.AxisScale(:ln; kwargs...)
+    else #identity
+        return InspectDR.AxisScale(:lin; kwargs...)
+    end
+end
+
+# ---------------------------------------------------------------------------
+
+function add_backend_string(::InspectDRBackend)
+    """
+    if !Plots.is_installed("InspectDR")
+        Pkg.add("InspectDR")
+    end
+    """
+end
+
+function _initialize_backend(::InspectDRBackend; kw...)
+    @eval begin
+        import InspectDR
+        export InspectDR
+
+        #Glyph used when plotting "Shape"s:
+        const INSPECTDR_GLYPH_SHAPE = InspectDR.GlyphPolyline(
+            2*InspectDR.GLYPH_SQUARE.x, InspectDR.GLYPH_SQUARE.y
+        )
+
+        type InspecDRPlotRef
+            mplot::Union{Void, InspectDR.Multiplot}
+            gui::Union{Void, InspectDR.GtkPlot}
+        end
+
+        _inspectdr_getmplot(::Any) = nothing
+        _inspectdr_getmplot(r::InspecDRPlotRef) = r.mplot
+
+        _inspectdr_getgui(::Any) = nothing
+        _inspectdr_getgui(gplot::InspectDR.GtkPlot) = (gplot.destroyed? nothing: gplot)
+        _inspectdr_getgui(r::InspecDRPlotRef) = _inspectdr_getgui(r.gui)
+    end
+end
+
+# ---------------------------------------------------------------------------
+
+# Create the window/figure for this backend.
+function _create_backend_figure(plt::Plot{InspectDRBackend})
+    mplot = _inspectdr_getmplot(plt.o)
+    gplot = _inspectdr_getgui(plt.o)
+
+    #:overwrite_figure: want to reuse current figure
+    if plt[:overwrite_figure] && mplot != nothing
+        mplot.subplots = [] #Reset
+        if gplot != nothing #Ensure still references current plot
+            gplot.src = mplot
+        end
+    else #want new one:
+        mplot = InspectDR.Multiplot()
+        gplot = nothing #Will be created later
+    end
+
+    #break link with old subplots
+    for sp in plt.subplots
+        sp.o = nothing
+    end
+
+    return InspecDRPlotRef(mplot, gplot)
+end
+
+# ---------------------------------------------------------------------------
+
+# # this is called early in the pipeline, use it to make the plot current or something
+# function _prepare_plot_object(plt::Plot{InspectDRBackend})
+# end
+
+# ---------------------------------------------------------------------------
+
+# Set up the subplot within the backend object.
+function _initialize_subplot(plt::Plot{InspectDRBackend}, sp::Subplot{InspectDRBackend})
+    plot = sp.o
+    #Don't do anything without a "subplot" object:  Will process later.
+    if nothing == plot; return; end
+    plot.data = []
+    plot.userannot = [] #Clear old markers/text annotation/polyline "annotation"
+    return plot
+end
+
+# ---------------------------------------------------------------------------
+
+# Add one series to the underlying backend object.
+# Called once per series
+# NOTE: Seems to be called when user calls plot()... even if backend
+#       plot, sp.o has not yet been constructed...
+function _series_added(plt::Plot{InspectDRBackend}, series::Series)
+    st = series[:seriestype]
+    sp = series[:subplot]
+    plot = sp.o
+
+    #Don't do anything without a "subplot" object:  Will process later.
+    if nothing == plot; return; end
+
+    _vectorize(v) = isa(v, Vector)? v: collect(v) #InspectDR only supports vectors
+    x = _vectorize(series[:x]); y = _vectorize(series[:y])
+
+    #No support for polar grid... but can still perform polar transformation:
+    if ispolar(sp)
+        Θ = x; r = y
+        x = r.*cos(Θ); y = r.*sin(Θ)
+    end
+
+    # doesn't handle mismatched x/y - wrap data (pyplot behaviour):
+    nx = length(x); ny = length(y)
+    if nx < ny
+        series[:x] = Float64[x[mod1(i,nx)] for i=1:ny]
+    elseif ny > nx
+        series[:y] = Float64[y[mod1(i,ny)] for i=1:nx]
+    end
+
+#= TODO: Eventually support
+    series[:fillcolor] #I think this is fill under line
+    zorder = series[:series_plotindex]
+
+For st in :shape:
+    zorder = series[:series_plotindex],
+=#
+
+    if st in (:shape,)
+        nmax = 0
+        for (i,rng) in enumerate(iter_segments(x, y))
+            nmax = i
+            if length(rng) > 1
+                linewidth = series[:linewidth]
+                linecolor = _inspectdr_mapcolor(cycle(series[:linecolor], i))
+                fillcolor = _inspectdr_mapcolor(cycle(series[:fillcolor], i))
+                line = InspectDR.line(
+                    style=:solid, width=linewidth, color=linecolor
+                )
+                apline = InspectDR.PolylineAnnotation(
+                    x[rng], y[rng], line=line, fillcolor=fillcolor
+                )
+                InspectDR.add(plot, apline)
+            end
+        end
+
+        i = (nmax >= 2? div(nmax, 2): nmax) #Must pick one set of colors for legend
+        if i > 1 #Add dummy waveform for legend entry:
+            linewidth = series[:linewidth]
+            linecolor = _inspectdr_mapcolor(cycle(series[:linecolor], i))
+            fillcolor = _inspectdr_mapcolor(cycle(series[:fillcolor], i))
+            wfrm = InspectDR.add(plot, Float64[], Float64[], id=series[:label])
+            wfrm.line = InspectDR.line(
+                style=:none, width=linewidth, #linewidth affects glyph
+            )
+            wfrm.glyph = InspectDR.glyph(
+                shape = INSPECTDR_GLYPH_SHAPE, size = 8,
+                color = linecolor, fillcolor = fillcolor
+            )
+        end
+   elseif st in (:path, :scatter) #, :steppre, :steppost)
+        #NOTE: In Plots.jl, :scatter plots have 0-linewidths (I think).
+        linewidth = series[:linewidth]
+        #More efficient & allows some support for markerstrokewidth:
+        _style = (0==linewidth? :none: series[:linestyle])
+        wfrm = InspectDR.add(plot, x, y, id=series[:label])
+        wfrm.line = InspectDR.line(
+            style = _style,
+            width = series[:linewidth],
+            color = series[:linecolor],
+        )
+        #InspectDR does not control markerstrokewidth independently.
+        if :none == _style
+            #Use this property only if no line is displayed:
+            wfrm.line.width = series[:markerstrokewidth]
+        end
+        wfrm.glyph = InspectDR.glyph(
+            shape = _inspectdr_mapglyph(series[:markershape]),
+            size = _inspectdr_mapglyphsize(series[:markersize]),
+            color = _inspectdr_mapcolor(series[:markerstrokecolor]),
+            fillcolor = _inspectdr_mapcolor(series[:markercolor]),
+        )
+    end
+
+    # this is all we need to add the series_annotations text
+    anns = series[:series_annotations]
+    for (xi,yi,str,fnt) in EachAnn(anns, x, y)
+        _inspectdr_add_annotations(plot, xi, yi, PlotText(str, fnt))
+    end
+    return
+end
+
+# ---------------------------------------------------------------------------
+
+# When series data is added/changed, this callback can do dynamic updates to the backend object.
+# note: if the backend rebuilds the plot from scratch on display, then you might not do anything here.
+function _series_updated(plt::Plot{InspectDRBackend}, series::Series)
+    #Nothing to do
+end
+
+# ---------------------------------------------------------------------------
+
+function _inspectdr_setupsubplot(sp::Subplot{InspectDRBackend})
+    const gridon = InspectDR.GridRect(vmajor=true, hmajor=true)
+    const gridoff = InspectDR.GridRect()
+    const plot = sp.o
+    const strip = plot.strips[1] #Only 1 strip supported with Plots.jl
+
+	#No independent control of grid???
+	strip.grid = sp[:grid]? gridon: gridoff
+
+    xaxis = sp[:xaxis]; yaxis = sp[:yaxis]
+        plot.xscale = _inspectdr_getscale(xaxis[:scale], false)
+        strip.yscale = _inspectdr_getscale(yaxis[:scale], true)
+        xmin, xmax  = axis_limits(xaxis)
+        ymin, ymax  = axis_limits(yaxis)
+        if ispolar(sp)
+            #Plots.jl appears to give (xmin,xmax) ≜ (Θmin,Θmax) & (ymin,ymax) ≜ (rmin,rmax)
+            rmax = max(abs(ymin), abs(ymax))
+            xmin, xmax = -rmax, rmax
+            ymin, ymax = -rmax, rmax
+        end
+        plot.xext = InspectDR.PExtents1D() #reset
+        strip.yext = InspectDR.PExtents1D() #reset
+        plot.xext_full = InspectDR.PExtents1D(xmin, xmax)
+        strip.yext_full = InspectDR.PExtents1D(ymin, ymax)
+    a = plot.annotation
+        a.title = sp[:title]
+        a.xlabel = xaxis[:guide]; a.ylabels = [yaxis[:guide]]
+
+    l = plot.layout
+        l.frame.fillcolor = _inspectdr_mapcolor(sp[:background_color_subplot])
+        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])
+        )
+    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
+
+    mplot.title = plt[:plot_title]
+    if "" == mplot.title
+        #Don't use window_title... probably not what you want.
+        #mplot.title = plt[:window_title]
+    end
+    mplot.frame.fillcolor = _inspectdr_mapcolor(plt[:background_color_outside])
+
+    resize!(mplot.subplots, length(plt.subplots))
+    nsubplots = length(plt.subplots)
+    for (i, sp) in enumerate(plt.subplots)
+        if !isassigned(mplot.subplots, i)
+            mplot.subplots[i] = InspectDR.Plot2D()
+        end
+        sp.o = mplot.subplots[i]
+        plot = sp.o
+        _initialize_subplot(plt, sp)
+        _inspectdr_setupsubplot(sp)
+
+        # add the annotations
+        for ann in sp[:annotations]
+            _inspectdr_add_annotations(plot, ann...)
+        end
+    end
+
+    #Do not yet support absolute plot positionning.
+    #Just try to make things look more-or less ok:
+    if nsubplots <= 1
+        mplot.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})
+    plot = sp.o
+    if !isa(plot, InspectDR.Plot2D); return sp.minpad; end
+    #Computing plotbounds with 0-BoundingBox returns required padding:
+    bb = InspectDR.plotbounds(plot.layout, InspectDR.BoundingBox(0,0,0,0))
+    #NOTE: plotbounds always pads for titles, legends, etc. even if not in use.
+    #TODO: possibly zero-out items not in use??
+
+    # add in the user-specified margin to InspectDR padding:
+    leftpad   = abs(bb.xmin)*px + sp[:left_margin]
+    toppad    = abs(bb.ymin)*px + sp[:top_margin]
+    rightpad  = abs(bb.xmax)*px + sp[:right_margin]
+    bottompad = abs(bb.ymax)*px + sp[:bottom_margin]
+    sp.minpad = (leftpad, toppad, rightpad, bottompad)
+end
+
+# ----------------------------------------------------------------
+
+# Override this to update plot items (title, xlabel, etc), and add annotations (d[:annotations])
+function _update_plot_object(plt::Plot{InspectDRBackend})
+    mplot = _inspectdr_getmplot(plt.o)
+    if nothing == mplot; return; end
+
+    for (i, sp) in enumerate(plt.subplots)
+        graphbb = _inspectdr_to_pixels(plotarea(sp))
+        plot = mplot.subplots[i]
+        plot.plotbb = InspectDR.plotbounds(plot.layout, graphbb)
+    end
+
+    gplot = _inspectdr_getgui(plt.o)
+    if nothing == gplot; return; end
+
+    gplot.src = mplot #Ensure still references current plot
+    InspectDR.refresh(gplot)
+    return
+end
+
+# ----------------------------------------------------------------
+
+const _inspectdr_mimeformats_dpi = Dict(
+    "image/png"               => "png"
+)
+const _inspectdr_mimeformats_nodpi = Dict(
+    "image/svg+xml"           => "svg",
+    "application/eps"         => "eps",
+    "image/eps"               => "eps",
+#    "application/postscript"  => "ps", #TODO: support once Cairo supports PSSurface
+    "application/pdf"         => "pdf"
+)
+_inspectdr_show(io::IO, mime::MIME, ::Void, w, h) =
+    throw(ErrorException("Cannot show(::IO, ...) plot - not yet generated"))
+function _inspectdr_show(io::IO, mime::MIME, mplot, w, h)
+    InspectDR._show(io, mime, mplot, Float64(w), Float64(h))
+end
+
+for (mime, fmt) in _inspectdr_mimeformats_dpi
+    @eval function _show(io::IO, mime::MIME{Symbol($mime)}, plt::Plot{InspectDRBackend})
+        dpi = plt[:dpi]#TODO: support
+        _inspectdr_show(io, mime, _inspectdr_getmplot(plt.o), plt[:size]...)
+    end
+end
+for (mime, fmt) in _inspectdr_mimeformats_nodpi
+    @eval function _show(io::IO, mime::MIME{Symbol($mime)}, plt::Plot{InspectDRBackend})
+        _inspectdr_show(io, mime, _inspectdr_getmplot(plt.o), plt[:size]...)
+    end
+end
+_show(io::IO, mime::MIME"text/plain", plt::Plot{InspectDRBackend}) = nothing #Don't show
+
+# ----------------------------------------------------------------
+
+# Display/show the plot (open a GUI window, or browser page, for example).
+function _display(plt::Plot{InspectDRBackend})
+    mplot = _inspectdr_getmplot(plt.o)
+    if nothing == mplot; return; end
+    gplot = _inspectdr_getgui(plt.o)
+
+    if nothing == gplot
+        gplot = display(InspectDR.GtkDisplay(), mplot)
+    else
+        #redundant... Plots.jl will call _update_plot_object:
+        #InspectDR.refresh(gplot)
+    end
+    plt.o = InspecDRPlotRef(mplot, gplot)
+    return gplot
+end

src/backends/pgfplots.jl

@@ -2,63 +2,56 @@
 
 # significant contributions by: @pkofod
 
-supportedArgs(::PGFPlotsBackend) = [
-    # :annotations,
-    :background_color, :foreground_color,
-    :color_palette,
+const _pgfplots_attr = merge_with_base_supported([
+    :annotations,
     # :background_color_legend,
     :background_color_inside,
     # :background_color_outside,
     # :foreground_color_legend, :foreground_color_grid, :foreground_color_axis,
     #     :foreground_color_text, :foreground_color_border,
-    :group,
     :label,
-    :seriestype,
     :seriescolor, :seriesalpha,
     :linecolor, :linestyle, :linewidth, :linealpha,
     :markershape, :markercolor, :markersize, :markeralpha,
-    :markerstrokewidth, :markerstrokecolor, :markerstrokealpha,
+    :markerstrokewidth, :markerstrokecolor, :markerstrokealpha, :markerstrokestyle,
     :fillrange, :fillcolor, :fillalpha,
     :bins,
     # :bar_width, :bar_edges,
-    # :n, :nc, :nr,
-    :layout,
-    # :smooth,
     :title,
     # :window_title,
-    :show, :size,
-    :x, :xguide, :xlims, :xticks, :xscale, :xflip, :xrotation,
-    :y, :yguide, :ylims, :yticks, :yscale, :yflip, :yrotation,
-    :z, :zguide, :zlims, :zticks, :zscale, :zflip, :zrotation,
+    :guide, :lims, :ticks, :scale, :flip, :rotation,
     :tickfont, :guidefont, :legendfont,
     :grid, :legend,
-    # :colorbar,
-    # :marker_z, :levels,
-    # :xerror, :yerror,
+    :colorbar,
+    :marker_z, #:levels,
     # :ribbon, :quiver, :arrow,
     # :orientation,
     # :overwrite_figure,
-    # :polar,
+    :polar,
     # :normalize, :weights, :contours,
     :aspect_ratio,
     # :match_dimensions,
-  ]
-supportedAxes(::PGFPlotsBackend) = [:auto, :left]
-supportedTypes(::PGFPlotsBackend) = [:path, :path3d, :scatter, :steppre, :stepmid, :steppost, :histogram2d, :ysticks, :xsticks, :contour]
-supportedStyles(::PGFPlotsBackend) = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
-supportedMarkers(::PGFPlotsBackend) = [:none, :auto, :ellipse, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5, :pentagon] #vcat(_allMarkers, Shape)
-supportedScales(::PGFPlotsBackend) = [:identity, :ln, :log2, :log10] # :asinh, :sqrt]
-subplotSupported(::PGFPlotsBackend) = false
+  ])
+const _pgfplots_seriestype = [:path, :path3d, :scatter, :steppre, :stepmid, :steppost, :histogram2d, :ysticks, :xsticks, :contour, :shape]
+const _pgfplots_style = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
+const _pgfplots_marker = [:none, :auto, :circle, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5, :pentagon] #vcat(_allMarkers, Shape)
+const _pgfplots_scale = [:identity, :ln, :log2, :log10]
 
 
 # --------------------------------------------------------------------------------------
 
+function add_backend_string(::PGFPlotsBackend)
+    """
+    Pkg.add("PGFPlots")
+    Pkg.build("PGFPlots")
+    """
+end
 
 function _initialize_backend(::PGFPlotsBackend; kw...)
-  @eval begin
-    import PGFPlots
-    export PGFPlots
-  end
+    @eval begin
+        import PGFPlots
+        export PGFPlots
+    end
 end
 
 
@@ -76,9 +69,11 @@ const _pgfplots_markers = KW(
     :none => "none",
     :cross => "+",
     :xcross => "x",
+    :+ => "+",
+    :x => "x",
     :utriangle => "triangle*",
     :dtriangle => "triangle*",
-    :ellipse => "*",
+    :circle => "*",
     :rect => "square*",
     :star5 => "star",
     :star6 => "asterisk",
@@ -103,23 +98,42 @@ const _pgf_series_extrastyle = KW(
     :xsticks => "xcomb",
 )
 
+# PGFPlots uses the anchors to define orientations for example to align left 
+# one needs to use the right edge as anchor
+const _pgf_annotation_halign = KW(
+    :center => "",
+    :left => "right",
+    :right => "left"
+)
+
 # --------------------------------------------------------------------------------------
 
 # takes in color,alpha, and returns color and alpha appropriate for pgf style
-function pgf_color(c, a = nothing)
-    c = getColor(c)
+function pgf_color(c::Colorant)
     cstr = @sprintf("{rgb,1:red,%.8f;green,%.8f;blue,%.8f}", red(c), green(c), blue(c))
-    a = float(a == nothing ? alpha(c) : a)
-    cstr, a
+    cstr, alpha(c)
+end
+
+function pgf_color(grad::ColorGradient)
+    # Can't handle ColorGradient here, fallback to defaults.
+    cstr = @sprintf("{rgb,1:red,%.8f;green,%.8f;blue,%.8f}", 0.0, 0.60560316,0.97868012)
+    cstr, 1
+end
+
+# Generates a colormap for pgfplots based on a ColorGradient
+function pgf_colormap(grad::ColorGradient) 
+    join(map(grad.colors) do c
+        @sprintf("rgb=(%.8f,%.8f,%.8f)", red(c), green(c),blue(c))
+    end,", ")
 end
 
 function pgf_fillstyle(d::KW)
-    cstr,a = pgf_color(d[:fillcolor], d[:fillalpha])
+    cstr,a = pgf_color(d[:fillcolor])
     "fill = $cstr, fill opacity=$a"
 end
 
 function pgf_linestyle(d::KW)
-    cstr,a = pgf_color(d[:linecolor], d[:linealpha])
+    cstr,a = pgf_color(d[:linecolor])
     """
     color = $cstr,
     draw opacity=$a,
@@ -129,8 +143,8 @@ end
 
 function pgf_marker(d::KW)
     shape = d[:markershape]
-    cstr, a = pgf_color(d[:markercolor], d[:markeralpha])
-    cstr_stroke, a_stroke = pgf_color(d[:markerstrokecolor], d[:markerstrokealpha])
+    cstr, a = pgf_color(d[:markercolor])
+    cstr_stroke, a_stroke = pgf_color(d[:markerstrokecolor])
     """
     mark = $(get(_pgfplots_markers, shape, "*")),
     mark size = $(0.5 * d[:markersize]),
@@ -143,25 +157,38 @@ function pgf_marker(d::KW)
     }"""
 end
 
-# --------------------------------------------------------------------------------------
+function pgf_add_annotation!(o,x,y,val)
+    # Construct the style string.
+    # Currently supports color and orientation
+    cstr,a = pgf_color(val.font.color)
+    push!(o, PGFPlots.Plots.Node(val.str, # Annotation Text
+                                 x, y,
+                                 style="""
+                                 $(get(_pgf_annotation_halign,val.font.halign,"")),
+                                 color=$cstr, draw opacity=$(convert(Float16,a)),
+                                 rotate=$(val.font.rotation)
+                                 """))
+end
 
+# --------------------------------------------------------------------------------------
 
 function pgf_series(sp::Subplot, series::Series)
     d = series.d
     st = d[:seriestype]
     style = []
     kw = KW()
-
     push!(style, pgf_linestyle(d))
     push!(style, pgf_marker(d))
 
-    if d[:fillrange] != nothing
+    if d[:fillrange] != nothing || st in (:shape,)
         push!(style, pgf_fillstyle(d))
     end
 
     # add to legend?
     if sp[:legend] != :none && should_add_to_legend(series)
         kw[:legendentry] = d[:label]
+    else
+        push!(style, "forget plot")
     end
 
     # function args
@@ -169,10 +196,26 @@ function pgf_series(sp::Subplot, series::Series)
         d[:z].surf, d[:x], d[:y]
     elseif is3d(st)
         d[:x], d[:y], d[:z]
+    elseif d[:marker_z] != nothing
+        # If a marker_z is used pass it as third coordinate to a 2D plot.
+        # See "Scatter Plots" in PGFPlots documentation
+        d[:x], d[:y], d[:marker_z]
     else
         d[:x], d[:y]
     end
 
+    # PGFPlots can't handle non-Vector?
+    args = map(a -> if typeof(a) <: AbstractVector && typeof(a) != Vector
+            collect(a)
+        else
+            a
+        end, args)
+    # for (i,a) in enumerate(args)
+    #     if typeof(a) <: AbstractVector && typeof(a) != Vector
+    #         args[i] = collect(a)
+    #     end
+    # end
+
     # include additional style, then add to the kw
     if haskey(_pgf_series_extrastyle, st)
         push!(style, _pgf_series_extrastyle[st])
@@ -205,6 +248,9 @@ function pgf_axis(sp::Subplot, letter)
     # axis guide
     kw[Symbol(letter,:label)] = axis[:guide]
 
+    # Add ticklabel rotations
+    push!(style, "$(letter)ticklabel style={rotate = $(axis[:rotation])}")
+
     # flip/reverse?
     axis[:flip] && push!(style, "$letter dir=reverse")
 
@@ -215,10 +261,24 @@ 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
-    lims = axis_limits(axis)
-    kw[Symbol(letter,:min)] = lims[1]
-    kw[Symbol(letter,:max)] = lims[2]
+    # TODO: support zlims
+    if letter != :z
+        lims = axis_limits(axis)
+        kw[Symbol(letter,:min)] = lims[1]
+        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
@@ -227,10 +287,14 @@ end
 # ----------------------------------------------------------------
 
 
-function _make_pgf_plot!(plt::Plot)
+function _update_plot_object(plt::Plot{PGFPlotsBackend})
     plt.o = PGFPlots.Axis[]
+    # Obtain the total height of the plot by extracting the maximal bottom
+    # coordinate from the bounding box.
+    total_height = bottom(bbox(plt.layout))
+
     for sp in plt.subplots
-        # first build the PGFPlots.Axis object
+       # first build the PGFPlots.Axis object
         style = ["unbounded coords=jump"]
         kw = KW()
 
@@ -238,23 +302,26 @@ function _make_pgf_plot!(plt::Plot)
         for letter in (:x, :y, :z)
             if letter != :z || is3d(sp)
                 axisstyle, axiskw = pgf_axis(sp, letter)
+                append!(style, axisstyle)
                 merge!(kw, axiskw)
             end
         end
 
         # bounding box values are in mm
         # note: bb origin is top-left, pgf is bottom-left
+        # A round on 2 decimal places should be enough precision for 300 dpi
+        # plots.
         bb = bbox(sp)
         push!(style, """
             xshift = $(left(bb).value)mm,
-            yshift = $((height(bb) - (bottom(bb))).value)mm,
-            width = $(width(bb).value)mm,
-            height = $(height(bb).value)mm,
+            yshift = $(round((total_height - (bottom(bb))).value,2))mm,
             axis background/.style={fill=$(pgf_color(sp[:background_color_inside])[1])}
         """)
+        kw[:width] = "$(width(bb).value)mm"
+        kw[:height] = "$(height(bb).value)mm"
 
         if sp[:title] != ""
-            push!(style, "title = $(sp[:title])")
+            kw[:title] = "$(sp[:title])"
         end
 
         sp[:grid] && push!(style, "grid = major")
@@ -267,30 +334,98 @@ function _make_pgf_plot!(plt::Plot)
             kw[:legendPos] = _pgfplots_legend_pos[legpos]
         end
 
-        o = PGFPlots.Axis(; style = style, kw...)
+        axisf = PGFPlots.Axis
+        if sp[:projection] == :polar
+            axisf = PGFPlots.PolarAxis
+        end
+
+        # Search series for any gradient. In case one series uses a gradient set
+        # the colorbar and colomap.
+        # The reasoning behind doing this on the axis level is that pgfplots
+        # colorbar seems to only works on axis level and needs the proper colormap for
+        # correctly displaying it.
+        # It's also possible to assign the colormap to the series itself but
+        # then the colormap needs to be added twice, once for the axis and once for the
+        # series.
+        # As it is likely that all series within the same axis use the same
+        # colormap this should not cause any problem.
+        for series in series_list(sp)
+            for col in (:markercolor, :fillcolor)
+                if typeof(series.d[col]) == ColorGradient
+                    push!(style,"colormap={plots}{$(pgf_colormap(series.d[col]))}")
+
+                    if sp[:colorbar] == :none
+                        kw[:colorbar] = "false"
+                    else
+                        kw[:colorbar] = "true"
+                    end
+                    # goto is needed to break out of col and series for
+                    @goto colorbar_end 
+                end
+            end
+        end
+        @label colorbar_end
+
+        o = axisf(; style = style, kw...)
 
         # add the series object to the PGFPlots.Axis
         for series in series_list(sp)
             push!(o, pgf_series(sp, series))
+
+            # add series annotations
+            anns = series[:series_annotations]
+            for (xi,yi,str,fnt) in EachAnn(anns, series[:x], series[:y])
+                pgf_add_annotation!(o, xi, yi, PlotText(str, fnt))
+            end
         end
 
+        # add the annotations
+        for ann in sp[:annotations]
+            pgf_add_annotation!(o,ann...)
+        end
+
+
         # add the PGFPlots.Axis to the list
         push!(plt.o, o)
     end
 end
 
-
-function _writemime(io::IO, mime::MIME"image/svg+xml", plt::Plot{PGFPlotsBackend})
-  _make_pgf_plot!(plt)
-  writemime(io, mime, plt.o)
+function _show(io::IO, mime::MIME"image/svg+xml", plt::Plot{PGFPlotsBackend})
+    show(io, mime, plt.o)
 end
 
-function _writemime(io::IO, mime::MIME"image/png", plt::Plot{PGFPlotsBackend})
-  _make_pgf_plot!(plt)
-  writemime(io, mime, plt.o)
+function _show(io::IO, mime::MIME"application/pdf", plt::Plot{PGFPlotsBackend})
+    # prepare the object
+    pgfplt = PGFPlots.plot(plt.o)
+
+    # save a pdf
+    fn = tempname()*".pdf"
+    PGFPlots.save(PGFPlots.PDF(fn), pgfplt)
+
+    # read it into io
+    write(io, 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})
-  _make_pgf_plot!(plt)
-  display(plt.o)
+    # prepare the object
+    pgfplt = PGFPlots.plot(plt.o)
+
+    # save an svg
+    fn = string(tempname(), ".svg")
+    PGFPlots.save(PGFPlots.SVG(fn), pgfplt)
+
+    # show it
+    open_browser_window(fn)
+
+    # cleanup
+    PGFPlots.cleanup(plt.o)
 end

src/backends/plotly.jl

@@ -1,60 +1,70 @@
 
 # https://plot.ly/javascript/getting-started
 
-supportedArgs(::PlotlyBackend) = [
+const _plotly_attr = merge_with_base_supported([
     :annotations,
-    :background_color, :foreground_color, :color_palette,
-    # :background_color_legend, :background_color_inside, :background_color_outside,
-    # :foreground_color_legend, :foreground_color_grid, :foreground_color_axis,
-    #     :foreground_color_text, :foreground_color_border,
-    :group,
+    :background_color_legend, :background_color_inside, :background_color_outside,
+    :foreground_color_legend, :foreground_color_guide,
+    # :foreground_color_grid, :foreground_color_axis,
+    :foreground_color_text, :foreground_color_border,
+    :foreground_color_title,
     :label,
-    :seriestype,
     :seriescolor, :seriesalpha,
     :linecolor, :linestyle, :linewidth, :linealpha,
     :markershape, :markercolor, :markersize, :markeralpha,
-    :markerstrokewidth, :markerstrokecolor, :markerstrokealpha,
+    :markerstrokewidth, :markerstrokecolor, :markerstrokealpha, :markerstrokestyle,
     :fillrange, :fillcolor, :fillalpha,
     :bins,
-    :n, :nc, :nr, :layout,
-    # :smooth,
-    :title, :window_title, :show, :size,
-    :x, :xguide, :xlims, :xticks, :xscale, :xflip, :xrotation,
-    :y, :yguide, :ylims, :yticks, :yscale, :yflip, :yrotation,
-    :z, :zguide, :zlims, :zticks, :zscale, :zflip, :zrotation,
-    :z,
+    :title, :title_location, :titlefont,
+    :window_title,
+    :guide, :lims, :ticks, :scale, :flip, :rotation,
     :tickfont, :guidefont, :legendfont,
-    :grid, :legend, :colorbar,
-    :marker_z, :levels,
-    :xerror, :yerror,
+    :grid, :legend, :colorbar, :colorbar_title,
+    :marker_z, :fill_z, :levels,
     :ribbon, :quiver,
     :orientation,
     # :overwrite_figure,
     :polar,
-    # :normalize, :weights, :contours, :aspect_ratio
-  ]
+    :normalize, :weights,
+    # :contours,
+    :aspect_ratio,
+    :hover,
+    :inset_subplots,
+    :bar_width,
+    :clims,
+  ])
 
-supportedAxes(::PlotlyBackend) = [:auto, :left]
-supportedTypes(::PlotlyBackend) = [:none, :line, :path, :scatter, :steppre, :steppost,
-                                   :histogram2d, :histogram, :density, :bar, :contour, :surface, :path3d, :scatter3d,
-                                   :pie, :heatmap] #,, :sticks, :hexbin, :hline, :vline]
-supportedStyles(::PlotlyBackend) = [:auto, :solid, :dash, :dot, :dashdot]
-supportedMarkers(::PlotlyBackend) = [:none, :auto, :ellipse, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross,
-                                     :pentagon, :hexagon, :octagon, :vline, :hline] #vcat(_allMarkers, Shape)
-supportedScales(::PlotlyBackend) = [:identity, :log10] #, :ln, :log2, :log10, :asinh, :sqrt]
-subplotSupported(::PlotlyBackend) = true
-stringsSupported(::PlotlyBackend) = true
+const _plotly_seriestype = [
+    :path, :scatter, :bar, :pie, :heatmap,
+    :contour, :surface, :wireframe, :path3d, :scatter3d, :shape, :scattergl,
+]
+const _plotly_style = [:auto, :solid, :dash, :dot, :dashdot]
+const _plotly_marker = [
+    :none, :auto, :circle, :rect, :diamond, :utriangle, :dtriangle,
+    :cross, :xcross, :pentagon, :hexagon, :octagon, :vline, :hline
+]
+const _plotly_scale = [:identity, :log10]
+is_subplot_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 = """
@@ -85,31 +95,46 @@ end
 
 # ----------------------------------------------------------------
 
-function plotlyfont(font::Font, color = font.color)
+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 get_annotation_dict(x, y, val)
+
+function plotly_annotation_dict(x, y, val; xref="paper", yref="paper")
     KW(
         :text => val,
-        :xref => "x",
+        :xref => xref,
         :x => x,
-        :yref => "y",
+        :yref => xref,
         :y => y,
         :showarrow => false,
     )
 end
 
-function get_annotation_dict(x, y, ptxt::PlotText)
-    merge(get_annotation_dict(x, y, ptxt.str), KW(
-        :font => plotlyfont(ptxt.font),
+function plotly_annotation_dict(x, y, ptxt::PlotText; xref="paper", yref="paper")
+    merge(plotly_annotation_dict(x, y, ptxt.str; xref=xref, yref=yref), KW(
+        :font => plotly_font(ptxt.font),
         :xanchor => ptxt.font.halign == :hcenter ? :center : ptxt.font.halign,
         :yanchor => ptxt.font.valign == :vcenter ? :middle : ptxt.font.valign,
-        :rotation => ptxt.font.rotation,
+        :rotation => -ptxt.font.rotation,
     ))
 end
 
@@ -127,7 +152,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,
@@ -136,7 +161,7 @@ end
 #     )
 # end
 
-function plotlyscale(scale::Symbol)
+function plotly_scale(scale::Symbol)
     if scale == :log10
         "log"
     else
@@ -144,12 +169,41 @@ function plotlyscale(scale::Symbol)
     end
 end
 
-use_axis_field(ticks) = !(ticks in (nothing, :none))
+function shrink_by(lo, sz, ratio)
+    amt = 0.5 * (1.0 - ratio) * sz
+    lo + amt, sz - 2amt
+end
+
+function plotly_apply_aspect_ratio(sp::Subplot, plotarea, pcts)
+    aspect_ratio = sp[:aspect_ratio]
+    if aspect_ratio != :none
+        if aspect_ratio == :equal
+            aspect_ratio = 1.0
+        end
+        xmin,xmax = axis_limits(sp[:xaxis])
+        ymin,ymax = axis_limits(sp[:yaxis])
+        want_ratio = ((xmax-xmin) / (ymax-ymin)) / aspect_ratio
+        parea_ratio = width(plotarea) / height(plotarea)
+        if want_ratio > parea_ratio
+            # need to shrink y
+            ratio = parea_ratio / want_ratio
+            pcts[2], pcts[4] = shrink_by(pcts[2], pcts[4], ratio)
+        elseif want_ratio < parea_ratio
+            # need to shrink x
+            ratio = want_ratio / parea_ratio
+            pcts[1], pcts[3] = shrink_by(pcts[1], pcts[3], ratio)
+        end
+        pcts
+    end
+    pcts
+end
+
 
 # this method gets the start/end in percentage of the canvas for this axis direction
 function plotly_domain(sp::Subplot, letter)
     figw, figh = sp.plt[:size]
     pcts = bbox_to_pcts(sp.plotarea, figw*px, figh*px)
+    pcts = plotly_apply_aspect_ratio(sp, sp.plotarea, pcts)
     i1,i2 = (letter == :x ? (1,3) : (2,4))
     [pcts[i1], pcts[i1]+pcts[i2]]
 end
@@ -157,40 +211,31 @@ end
 
 function plotly_axis(axis::Axis, sp::Subplot)
     letter = axis[:letter]
-    # d = axis.d
     ax = KW(
         :title      => axis[:guide],
         :showgrid   => sp[:grid],
         :zeroline   => false,
+        :ticks      => "inside",
     )
 
-    # fgcolor = webcolor(axis[:foreground_color])
-    # tsym = tickssym(letter)
-
-    # spidx = sp[:subplot_index]
-    # d_out[:xaxis] = "x$spidx"
-    # d_out[:yaxis] = "y$spidx"
     if letter in (:x,:y)
         ax[:domain] = plotly_domain(sp, letter)
         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 use_axis_field(axis[:ticks])
-        ax[:titlefont] = plotlyfont(axis[:guidefont], webcolor(axis[:foreground_color_guide]))
-        ax[:type] = plotlyscale(axis[:scale])
-        ax[:tickfont] = plotlyfont(axis[:tickfont], webcolor(axis[:foreground_color_text]))
-        ax[:tickcolor] = webcolor(axis[:foreground_color_border])
-        ax[:linecolor] = webcolor(axis[:foreground_color_border])
+    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] = 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
@@ -199,7 +244,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
@@ -218,36 +263,38 @@ function plotly_axis(axis::Axis, sp::Subplot)
     ax
 end
 
-# function plotly_layout_json(plt::Plot{PlotlyBackend})
-#   d = plt
-# function plotly_layout(d::KW, seriesargs::AVec{KW})
 function plotly_layout(plt::Plot)
     d_out = KW()
 
-    # # for now, we only support 1 subplot
-    # if length(plt.subplots) > 1
-    #     warn("Subplots not supported yet")
-    # end
-    # sp = plt.subplots[1]
+    w, h = plt[:size]
+    d_out[:width], d_out[:height] = w, h
+    d_out[:paper_bgcolor] = rgba_string(plt[:background_color_outside])
+    d_out[:margin] = KW(:l=>0, :b=>20, :r=>0, :t=>20)
 
-    d_out[:width], d_out[:height] = plt[:size]
-    d_out[:paper_bgcolor] = webcolor(plt[:background_color_outside])
+    d_out[:annotations] = KW[]
 
     for sp in plt.subplots
-        sp_out = KW()
         spidx = plotly_subplot_index(sp)
 
-        # set the fields for the plot
-        d_out[:title] = sp[:title]
-        d_out[:titlefont] = plotlyfont(sp[:titlefont], webcolor(sp[:foreground_color_title]))
 
-        # # TODO: use subplot positioning logic
-        # d_out[:margin] = KW(:l=>35, :b=>30, :r=>8, :t=>20)
-        d_out[:margin] = KW(:l=>0, :b=>0, :r=>0, :t=>30)
+        # add an annotation for the title... positioned horizontally relative to plotarea,
+        # but vertically just below the top of the subplot bounding box
+        if sp[:title] != ""
+            bb = plotarea(sp)
+            tpos = sp[:title_location]
+            xmm = if tpos == :left
+                left(bb)
+            elseif tpos == :right
+                right(bb)
+            else
+                0.5 * (left(bb) + right(bb))
+            end
+            titlex, titley = xy_mm_to_pcts(xmm, top(bbox(sp)), w*px, h*px)
+            titlefont = font(sp[:titlefont], :top, sp[:foreground_color_title])
+            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)
@@ -263,20 +310,30 @@ 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]),
-                :font     => plotlyfont(sp[:legendfont]),
+                :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
-        anns = sp[:annotations]
-        d_out[:annotations] = if isempty(anns)
-            KW[]
-        else
-            KW[get_annotation_dict(ann...) for ann in anns]
+        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
@@ -288,8 +345,6 @@ function plotly_layout(plt::Plot)
         #         end
         #     end
         # end
-        # dumpdict(d_out,"",true)
-        # @show d_out[:annotations]
 
         if ispolar(sp)
             d_out[:direction] = "counterclockwise"
@@ -298,6 +353,11 @@ function plotly_layout(plt::Plot)
         d_out
     end
 
+    # turn off hover if nothing's using it
+    if all(series -> series.d[:hover] in (false,:none), plt.series_list)
+        d_out[:hovermode] = "none"
+    end
+
     d_out
 end
 
@@ -306,14 +366,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",
@@ -327,88 +390,124 @@ function plotly_subplot_index(sp::Subplot)
 end
 
 
+# the Shape contructor will automatically close the shape. since we need it closed,
+# we split by NaNs and then construct/destruct the shapes to get the closed coords
+function plotly_close_shapes(x, y)
+    xs, ys = nansplit(x), nansplit(y)
+    for i=1:length(xs)
+        shape = Shape(xs[i], ys[i])
+        xs[i], ys[i] = coords(shape)
+    end
+    nanvcat(xs), nanvcat(ys)
+end
+
+plotly_data(v) = collect(v)
+plotly_data(surf::Surface) = surf.surf
+plotly_data{R<:Rational}(v::AbstractArray{R}) = float(v)
+
+plotly_surface_data(series::Series, a::AbstractVector) = a
+plotly_surface_data(series::Series, a::AbstractMatrix) = transpose_z(series, a, false)
+plotly_surface_data(series::Series, a::Surface) = plotly_surface_data(series, a.surf)
+
+#ensures that a gradient is called if a single color is supplied where a gradient is needed (e.g. if a series recipe defines marker_z)
+as_gradient(grad::ColorGradient, α) = grad
+as_gradient(grad, α) = cgrad(alpha = α)
+
+# allows passing a ColorGradient where a single color is expected - the other backends allow this
+PlotUtils.rgba_string(cg::ColorGradient) = rgba_string(cg[1])
+
 # 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
     spidx = plotly_subplot_index(sp)
     d_out[:xaxis] = "x$spidx"
     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]
-    isscatter = st in (:scatter, :scatter3d)
-    hasmarker = isscatter || d[:markershape] != :none
-    hasline = !isscatter
+    x, y = plotly_data(series[:x]), plotly_data(series[:y])
+    d_out[:name] = series[:label]
+
+    isscatter = st in (:scatter, :scatter3d, :scattergl)
+    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
+
+    d_out[:colorbar] = KW(:title => sp[:colorbar_title])
+
+    clims = sp[:clims]
+    if is_2tuple(clims)
+        d_out[:zmin], d_out[:zmax] = clims
+    end
 
     # set the "type"
-    if st in (:line, :path, :scatter, :steppre, :steppost)
-        d_out[:type] = "scatter"
+    if st in (:path, :scatter, :scattergl)
+        d_out[:type] = st==:scattergl ? "scattergl" : "scatter"
         d_out[:mode] = if hasmarker
             hasline ? "lines+markers" : "markers"
         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 == :bar
         d_out[:type] = "bar"
-        d_out[:x], d_out[:y] = x, y
-
-    elseif st == :histogram2d
-        d_out[:type] = "histogram2d"
-        d_out[:x], d_out[:y] = x, y
-        if isa(d[:bins], Tuple)
-            xbins, ybins = d[:bins]
+        d_out[:x], d_out[:y], d_out[:orientation] = if isvertical(series)
+            x, y, "v"
         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"
+            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] = x, y
-        # d_out[:z] = d[:z].surf
-        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] = x, y
-        # d_out[:z] = d[:z].surf
-        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] = x, y
-        # d_out[:z] = d[:z].surf
-        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"
@@ -424,7 +523,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.")
@@ -434,32 +533,33 @@ function plotly_series(plt::Plot, series::Series)
     # add "marker"
     if hasmarker
         d_out[:marker] = KW(
-            :symbol => get(_plotly_markers, d[:markershape], string(d[:markershape])),
-            :opacity => d[:markeralpha],
-            :size => 2 * d[:markersize],
-            :color => webcolor(d[:markercolor], d[:markeralpha]),
+            :symbol => get(_plotly_markers, series[:markershape], string(series[:markershape])),
+            # :opacity => series[:markeralpha],
+            :size => 2 * series[:markersize],
+            # :color => rgba_string(series[:markercolor]),
             :line => KW(
-                :color => webcolor(d[:markerstrokecolor], d[:markerstrokealpha]),
-                :width => d[:markerstrokewidth],
+                :color => rgba_string(series[:markerstrokecolor]),
+                :width => series[:markerstrokewidth],
             ),
         )
 
         # gotta hack this (for now?) since plotly can't handle rgba values inside the gradient
-        if d[:marker_z] != nothing
-            # d_out[:marker][:color] = d[:marker_z]
-            # d_out[:marker][:colorscale] = plotly_colorscale(d[:markercolor], d[:markeralpha])
-            # d_out[:showscale] = true
-            grad = ColorGradient(d[:markercolor], alpha=d[:markeralpha])
-            zmin, zmax = extrema(d[:marker_z])
-            d_out[:marker][:color] = [webcolor(getColorZ(grad, (zi - zmin) / (zmax - zmin))) for zi in d[:marker_z]]
+        d_out[:marker][:color] = if series[:marker_z] == nothing
+            rgba_string(series[:markercolor])
+        else
+            # grad = ColorGradient(series[:markercolor], alpha=series[:markeralpha])
+            grad = as_gradient(series[:markercolor], series[:markeralpha])
+            zmin, zmax = extrema(series[:marker_z])
+            zrange = zmax == zmin ? 1 : zmax - zmin # if all marker_z values are the same, plot all markers same color (avoids division by zero in next line)
+            [rgba_string(grad[(zi - zmin) / zrange]) for zi in series[:marker_z]]
         end
     end
 
     # add "line"
     if hasline
         d_out[:line] = KW(
-            :color => webcolor(d[:linecolor], d[:linealpha]),
-            :width => d[:linewidth],
+            :color => rgba_string(series[:linecolor]),
+            :width => series[:linewidth],
             :shape => if st == :steppre
                 "vh"
             elseif st == :steppost
@@ -467,29 +567,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
 
-    d_out
+function plotly_hover!(d_out::KW, hover)
+    # hover text
+    if hover in (:none, false)
+        d_out[:hoverinfo] = "none"
+    elseif hover != nothing
+        d_out[:hoverinfo] = "text"
+        d_out[:text] = hover
+    end
 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)
@@ -519,15 +685,15 @@ 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"text/html", plt::Plot{PlotlyBackend})
+function _show(io::IO, ::MIME"image/svg+xml", plt::Plot{PlotlyBackend})
     write(io, html_head(plt) * html_body(plt))
 end
 
-# function Base.display(::PlotsDisplay, plt::Plot{PlotlyBackend})
 function _display(plt::Plot{PlotlyBackend})
     standalone_html_window(plt)
 end

src/backends/plotlyjs.jl

@@ -1,187 +1,124 @@
 
 # https://github.com/spencerlyon2/PlotlyJS.jl
 
-supportedArgs(::PlotlyJSBackend) = [
-    :annotation,
-    # :axis,
-    :background_color,
-    :color_palette,
-    :fillrange,
-    :fillcolor,
-    :fillalpha,
-    :foreground_color,
-    :group,
-    :label,
-    :layout,
-    :legend,
-    :seriescolor, :seriesalpha,
-    :linecolor,
-    :linestyle,
-    :seriestype,
-    :linewidth,
-    :linealpha,
-    :markershape,
-    :markercolor,
-    :markersize,
-    :markeralpha,
-    :markerstrokewidth,
-    :markerstrokecolor,
-    :markerstrokestyle,
-    :n,
-    :bins,
-    :nc,
-    :nr,
-    # :pos,
-    # :smooth,
-    :show,
-    :size,
-    :title,
-    :window_title,
-    :x,
-    :xguide,
-    :xlims,
-    :xticks,
-    :y,
-    :yguide,
-    :ylims,
-    # :yrightlabel,
-    :yticks,
-    :xscale,
-    :yscale,
-    :xflip,
-    :yflip,
-    :z,
-    :marker_z,
-    :tickfont,
-    :guidefont,
-    :legendfont,
-    :grid,
-    :levels,
-    :xerror,
-    :yerror,
-    :ribbon,
-    :quiver,
-    :orientation,
-    :polar,
-  ]
-supportedAxes(::PlotlyJSBackend) = [:auto, :left]
-supportedTypes(::PlotlyJSBackend) = [:none, :line, :path, :scatter, :steppre, :steppost,
-                                   :histogram2d, :histogram, :density, :bar, :contour, :surface, :path3d, :scatter3d,
-                                   :pie, :heatmap] #,, :sticks, :hexbin, :hline, :vline]
-supportedStyles(::PlotlyJSBackend) = [:auto, :solid, :dash, :dot, :dashdot]
-supportedMarkers(::PlotlyJSBackend) = [:none, :auto, :ellipse, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross,
-                                     :pentagon, :hexagon, :octagon, :vline, :hline] #vcat(_allMarkers, Shape)
-supportedScales(::PlotlyJSBackend) = [:identity, :log10] #, :ln, :log2, :log10, :asinh, :sqrt]
-subplotSupported(::PlotlyJSBackend) = true
-stringsSupported(::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
         export PlotlyJS
     end
 
-    for (mime, fmt) in PlotlyJS._mimeformats
-        # mime == "image/png" && continue  # don't use plotlyjs's writemime for png
-        @eval Base.writemime(io::IO, m::MIME{Symbol($mime)}, p::Plot{PlotlyJSBackend}) = writemime(io, m, p.o)
-    end
-
-    # override IJulia inline display
-    if isijulia()
-        IJulia.display_dict(plt::AbstractPlot{PlotlyJSBackend}) = IJulia.display_dict(plt.o)
-    end
+    # # override IJulia inline display
+    # if isijulia()
+    #     IJulia.display_dict(plt::AbstractPlot{PlotlyJSBackend}) = IJulia.display_dict(plt.o)
+    # end
 end
 
 # ---------------------------------------------------------------------------
 
-# function _create_plot(pkg::PlotlyJSBackend, d::KW)
-#     # TODO: create the window/canvas/context that is the plot within the backend (call it `o`)
-#     # TODO: initialize the plot... title, xlabel, bgcolor, etc
-#     # o = PlotlyJS.Plot(PlotlyJS.GenericTrace[], PlotlyJS.Layout(),
-#     #                   Base.Random.uuid4(), PlotlyJS.ElectronDisplay())
-#     # T = isijulia() ? PlotlyJS.JupyterPlot : PlotlyJS.ElectronPlot
-#     # o = T(PlotlyJS.Plot())
-#     o = PlotlyJS.plot()
-#
-#     Plot(o, pkg, 0, d, KW[])
-# 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
 
 
 # ----------------------------------------------------------------
 
-# TODO: override this to update plot items (title, xlabel, etc) after creation
 function _update_plot_object(plt::Plot{PlotlyJSBackend})
     pdict = plotly_layout(plt)
     syncplot = plt.o
     w,h = plt[:size]
-    # DD(pdict)
     PlotlyJS.relayout!(syncplot, pdict, width = w, height = h)
 end
 
 
 # ----------------------------------------------------------------
 
-# accessors for x/y data
+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 getxy(plt::Plot{PlotlyJSBackend}, i::Int)
-#   d = plt.seriesargs[i]
-#   d[:x], d[:y]
-# end
-
-# function setxy!{X,Y}(plt::Plot{PlotlyJSBackend}, xy::Tuple{X,Y}, i::Integer)
-#   d = plt.seriesargs[i]
-#   ispolar = get(plt.attr, :polar, false)
-#   xsym = ispolar ? :t : :x
-#   ysym = ispolar ? :r : :y
-#   d[xsym], d[ysym] = xy
-#   # TODO: this is likely ineffecient... we should make a call that ONLY changes the plot data
-#   PlotlyJS.restyle!(plt.o, i, KW(xsym=>(d[xsym],), ysym=>(d[ysym],)))
-#   plt
-# end
-
-
-# ----------------------------------------------------------------
-
-# function _update_min_padding!(sp::Subplot{PlotlyBackend})
-#     sp.minpad = plotly_minpad(sp)
-# end
-
-# function plotlyjs_finalize(plt::Plot)
-#     plotly_finalize(plt)
-#     PlotlyJS.relayout!(plt.o, plotly_layout(plt))
-# end
-
-function _writemime(io::IO, ::MIME"image/png", plt::Plot{PlotlyJSBackend})
-    tmpfn = tempname() * "png"
+function plotlyjs_save_hack(io::IO, plt::Plot{PlotlyJSBackend}, ext::String)
+    tmpfn = tempname() * "." * ext
     PlotlyJS.savefig(plt.o, tmpfn)
     write(io, read(open(tmpfn)))
 end
+_show(io::IO, ::MIME"image/png", plt::Plot{PlotlyJSBackend}) = plotlyjs_save_hack(io, plt, "png")
+_show(io::IO, ::MIME"application/pdf", plt::Plot{PlotlyJSBackend}) = plotlyjs_save_hack(io, plt, "pdf")
+_show(io::IO, ::MIME"image/eps", plt::Plot{PlotlyJSBackend}) = plotlyjs_save_hack(io, plt, "eps")
+
+function write_temp_html(plt::Plot{PlotlyJSBackend})
+    filename = string(tempname(), ".html")
+    savefig(plt, filename)
+    filename
+end
 
 function _display(plt::Plot{PlotlyJSBackend})
-    # plotlyjs_finalize(plt)
-    display(plt.o)
+    if get(ENV, "PLOTS_USE_ATOM_PLOTPANE", true) in (true, 1, "1", "true", "yes")
+        display(plt.o)
+    else
+        standalone_html_window(plt)
+    end
+end
+
+
+function closeall(::PlotlyJSBackend)
+    if !isplotnull() && isa(current().o, PlotlyJS.SyncPlot)
+        close(current().o)
+    end
 end

src/backends/template.jl

@@ -19,9 +19,9 @@ function _create_backend_figure(plt::Plot{[PkgName]Backend})
     nothing
 end
 
-# this is called early in the pipeline, use it to make the plot current or something
-function _prepare_plot_object(plt::Plot{[PkgName]Backend})
-end
+# # this is called early in the pipeline, use it to make the plot current or something
+# function _prepare_plot_object(plt::Plot{[PkgName]Backend})
+# end
 
 # Set up the subplot within the backend object.
 function _initialize_subplot(plt::Plot{[PkgName]Backend}, sp::Subplot{[PkgName]Backend})
@@ -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,86 +1,67 @@
 
 # https://github.com/Evizero/UnicodePlots.jl
 
-supportedArgs(::UnicodePlotsBackend) = [
-    # :annotations,
-    # :args,
-    # :axis,
-    # :background_color,
-    # :linecolor,
-    # :fill,
-    # :foreground_color,
-    :group,
-    # :heatmap_c,
-    # :kwargs,
+const _unicodeplots_attr = merge_with_base_supported([
     :label,
-    # :layout,
     :legend,
-    :seriescolor, :seriesalpha,
+    :seriescolor,
+    :seriesalpha,
     :linestyle,
-    :seriestype,
-    # :linewidth,
     :markershape,
-    # :markercolor,
-    # :markersize,
-    # :markerstrokewidth,
-    # :markerstrokecolor,
-    # :markerstrokestyle,
-    # :n,
     :bins,
-    # :nc,
-    # :nr,
-    # :pos,
-    # :reg,
-    # :ribbon,
-    :show,
-    :size,
     :title,
-    :window_title,
-    :x,
-    :xguide,
-    :xlims,
-    # :xticks,
-    :y,
-    :yguide,
-    :ylims,
-    # :yrightlabel,
-    # :yticks,
-    # :xscale,
-    # :yscale,
-    # :xflip,
-    # :yflip,
-    # :z,
-  ]
-supportedAxes(::UnicodePlotsBackend) = [:auto, :left]
-supportedTypes(::UnicodePlotsBackend) = [
-    :path, :steppre, :steppost, :scatter,
-    :histogram2d, :hline, :vline
+    :guide, :lims,
+  ])
+const _unicodeplots_seriestype = [
+    :path, :scatter,
+    # :bar,
+    :shape,
+    :histogram2d,
+    :spy
 ]
-supportedStyles(::UnicodePlotsBackend) = [:auto, :solid]
-supportedMarkers(::UnicodePlotsBackend) = [:none, :auto, :ellipse]
-supportedScales(::UnicodePlotsBackend) = [:identity]
-subplotSupported(::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!!
-warnOnUnsupportedArgs(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
-    export UnicodePlots
-  end
+    @eval begin
+        import UnicodePlots
+        export UnicodePlots
+    end
 end
 
 # -------------------------------
 
-# convert_size_from_pixels(sz) =
+const _canvas_type = Ref(:auto)
+
+function _canvas_map()
+    KW(
+        :braille => UnicodePlots.BrailleCanvas,
+        :ascii => UnicodePlots.AsciiCanvas,
+        :block => UnicodePlots.BlockCanvas,
+        :dot => UnicodePlots.DotCanvas,
+        :density => UnicodePlots.DensityCanvas,
+    )
+end
+
 
 # do all the magic here... build it all at once, since we need to know about all the series at the very beginning
-function rebuildUnicodePlot!(plt::Plot)
+function rebuildUnicodePlot!(plt::Plot, width, height)
     plt.o = []
+
     for sp in plt.subplots
         xaxis = sp[:xaxis]
         yaxis = sp[:yaxis]
@@ -97,13 +78,40 @@ 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]
-        o = UnicodePlots.Plot(x, y;
+        ct = _canvas_type[]
+        canvas_type = if ct == :auto
+            isijulia() ? UnicodePlots.AsciiCanvas : UnicodePlots.BrailleCanvas
+        else
+            _canvas_map()[ct]
+        end
+
+        # special handling for spy
+        if length(sp.series_list) == 1
+            series = sp.series_list[1]
+            if series[:seriestype] == :spy
+                push!(plt.o, UnicodePlots.spy(
+                    series[:z].surf,
+                    width = width,
+                    height = height,
+                    title = sp[:title],
+                    canvas = canvas_type
+                ))
+                continue
+            end
+        end
+
+        # # make it a bar canvas if plotting bar
+        # if any(series -> series[:seriestype] == :bar, series_list(sp))
+        #     canvas_type = UnicodePlots.BarplotGraphics
+        # end
+
+        o = UnicodePlots.Plot(x, y, canvas_type;
             width = width,
             height = height,
             title = sp[:title],
             xlim = xlim,
-            ylim = ylim
+            ylim = ylim,
+            border = isijulia() ? :ascii : :solid
         )
 
         # set the axis labels
@@ -120,213 +128,87 @@ function rebuildUnicodePlot!(plt::Plot)
     end
 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)
-#
-#   # figure out the plotting area xlim = [xmin, xmax] and ylim = [ymin, ymax]
-#   sargs = plt.seriesargs
-#   iargs = plt.attr
-#
-#   # get the x/y limits
-#   if get(iargs, :xlims, :auto) == :auto
-#     xlim = [Inf, -Inf]
-#     for d in sargs
-#       _expand_limits(xlim, d[:x])
-#     end
-#   else
-#     xmin, xmax = iargs[:xlims]
-#     xlim = [xmin, xmax]
-#   end
-#
-#   if get(iargs, :ylims, :auto) == :auto
-#     ylim = [Inf, -Inf]
-#     for d in sargs
-#       _expand_limits(ylim, d[:y])
-#     end
-#   else
-#     ymin, ymax = iargs[:ylims]
-#     ylim = [ymin, ymax]
-#   end
-#
-#   # we set x/y to have a single point, since we need to create the plot with some data.
-#   # since this point is at the bottom left corner of the plot, it shouldn't actually be shown
-#   x = Float64[xlim[1]]
-#   y = Float64[ylim[1]]
-#
-#   # create a plot window with xlim/ylim set, but the X/Y vectors are outside the bounds
-#   width, height = iargs[:size]
-#   o = UnicodePlots.Plot(x, y; width = width,
-#                                 height = height,
-#                                 title = iargs[:title],
-#                                 # labels = iargs[:legend],
-#                                 xlim = xlim,
-#                                 ylim = ylim)
-#
-#   # set the axis labels
-#   UnicodePlots.xlabel!(o, iargs[:xguide])
-#   UnicodePlots.ylabel!(o, iargs[:yguide])
-#
-#   # now use the ! functions to add to the plot
-#   for d in sargs
-#     addUnicodeSeries!(o, d, iargs[:legend] != :none, xlim, ylim)
-#   end
-#
-#   # save the object
-#   plt.o = o
-# end
-
 
 # add a single series
 function addUnicodeSeries!(o, d::KW, addlegend::Bool, xlim, ylim)
-
     # get the function, or special handling for step/bar/hist
     st = d[:seriestype]
-
-    # handle hline/vline separately
-    if st in (:hline,:vline)
-        for yi in d[:y]
-            if st == :hline
-                UnicodePlots.lineplot!(o, xlim, [yi,yi])
-            else
-                UnicodePlots.lineplot!(o, [yi,yi], ylim)
-            end
-        end
-        return
-
-    # elseif st == :bar
-    #     UnicodePlots.barplot!(o, d[:x], d[:y])
-    #     return
-
-    # elseif st == :histogram
-    #     UnicodePlots.histogram!(o, d[:y], bins = d[:bins])
-    #     return
-
-    elseif st == :histogram2d
+    if st == :histogram2d
         UnicodePlots.densityplot!(o, d[:x], d[:y])
         return
-
     end
 
-  stepstyle = :post
-  if st == :path
-    func = UnicodePlots.lineplot!
-  elseif st == :scatter || d[:markershape] != :none
-    func = UnicodePlots.scatterplot!
-  elseif st == :steppost
-    func = UnicodePlots.stairs!
-  elseif st == :steppre
-    func = UnicodePlots.stairs!
-    stepstyle = :pre
-  else
-    error("Linestyle $st not supported by UnicodePlots")
-  end
+    if st == :path
+        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
 
-  # get the series data and label
-  x, y = [collect(float(d[s])) for s in (:x, :y)]
-  label = addlegend ? d[:label] : ""
+    # get the series data and label
+    x, y = [collect(float(d[s])) for s in (:x, :y)]
+    label = addlegend ? d[:label] : ""
 
-  # if we happen to pass in allowed color symbols, great... otherwise let UnicodePlots decide
-  color = d[:linecolor] in UnicodePlots.color_cycle ? d[:linecolor] : :auto
+    # if we happen to pass in allowed color symbols, great... otherwise let UnicodePlots decide
+    color = d[:linecolor] in UnicodePlots.color_cycle ? d[:linecolor] : :auto
 
-  # add the series
-  func(o, x, y; color = color, name = label, style = stepstyle)
+    # 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
 
-
-# function handlePlotColors(::UnicodePlotsBackend, d::KW)
-#   # TODO: something special for unicodeplots, since it doesn't take kindly to people messing with its color palette
-#   d[:color_palette] = [RGB(0,0,0)]
-# end
-
 # -------------------------------
 
-
-# function _create_plot(pkg::UnicodePlotsBackend, d::KW)
-  # plt = Plot(nothing, pkg, 0, d, KW[])
-
-function _create_backend_figure(plt::Plot{UnicodePlotsBackend})
-  # do we want to give a new default size?
-  # if !haskey(plt.attr, :size) || plt.attr[:size] == default(:size)
-  #   plt.attr[:size] = (60,20)
-  # end
-  w, h = plt[:size]
-  plt.attr[:size] = div(w, 10), div(h, 20)
-  plt.attr[:color_palette] = [RGB(0,0,0)]
-  nothing
-
-  # plt
-end
-
-# function _series_added(plt::Plot{UnicodePlotsBackend}, series::Series)
-#     d = series.d
-#     # TODO don't need these once the "bar" series recipe is done
-#   if d[:seriestype] in (:sticks, :bar)
-#     d = barHack(; d...)
-#   elseif d[:seriestype] == :histogram
-#     d = barHack(; histogramHack(; d...)...)
-#   end
-#   # push!(plt.seriesargs, d)
-#   # plt
-# end
-#
-#
-# function _update_plot_object(plt::Plot{UnicodePlotsBackend}, d::KW)
-#   for k in (:title, :xguide, :yguide, :xlims, :ylims)
-#     if haskey(d, k)
-#       plt.attr[k] = d[k]
-#     end
-#   end
-# 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")
+    fn = addExtension(fn, "png")
 
-  # make some whitespace and show the plot
-  println("\n\n\n\n\n\n")
-  gui(plt)
+    # make some whitespace and show the plot
+    println("\n\n\n\n\n\n")
+    gui(plt)
 
-  # @osx_only begin
-  @compat @static if is_apple()
-    # BEGIN HACK
+    # @osx_only begin
+    @static if is_apple()
+        # BEGIN HACK
 
-    # wait while the plot gets drawn
-    sleep(0.5)
+        # wait while the plot gets drawn
+        sleep(0.5)
 
-    # use osx screen capture when my terminal is maximized and cursor starts at the bottom (I know, right?)
-    # TODO: compute size of plot to adjust these numbers (or maybe implement something good??)
-    run(`screencapture -R50,600,700,420 $fn`)
+        # use osx screen capture when my terminal is maximized and cursor starts at the bottom (I know, right?)
+        # TODO: compute size of plot to adjust these numbers (or maybe implement something good??)
+        run(`screencapture -R50,600,700,420 $fn`)
 
-    # END HACK (phew)
-    return
-  end
+        # END HACK (phew)
+        return
+    end
 
-  error("Can only savepng on osx with UnicodePlots (though even then I wouldn't do it)")
+    error("Can only savepng on osx with UnicodePlots (though even then I wouldn't do it)")
 end
 
 # -------------------------------
 
 # we don't do very much for subplots... just stack them vertically
 
-# function _create_subplot(subplt::Subplot{UnicodePlotsBackend}, isbefore::Bool)
-#   isbefore && return false
-#   true
-# end
+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 _display(plt::Plot{UnicodePlotsBackend})
-  rebuildUnicodePlot!(plt)
-  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 Base.display(::PlotsDisplay, subplt::Subplot{UnicodePlotsBackend})
-#   for plt in subplt.plts
-#     gui(plt)
-#   end
-# end
+function _display(plt::Plot{UnicodePlotsBackend})
+    unicodeplots_rebuild(plt)
+    map(show, plt.o)
+    nothing
+end

src/backends/web.jl

@@ -20,14 +20,14 @@ function standalone_html(plt::AbstractPlot; title::AbstractString = get(plt.attr
 end
 
 function open_browser_window(filename::AbstractString)
-    @compat @static if is_apple()
+    @static if is_apple()
         return run(`open $(filename)`)
     end
-    @compat @static if is_linux()
+    @static if is_linux() || is_bsd()    # is_bsd() addition is as yet untested, but based on suggestion in https://github.com/JuliaPlots/Plots.jl/issues/681
         return run(`xdg-open $(filename)`)
     end
-    @compat @static if is_windows()
-        return run(`$(ENV["COMSPEC"]) /c start $(filename)`)
+    @static if is_windows()
+        return run(`$(ENV["COMSPEC"]) /c start "" "$(filename)"`)
     end
     warn("Unknown OS... cannot open browser window.")
 end
@@ -51,7 +51,7 @@ function html_to_png(html_fn, png_fn, w, h)
     run(`wkhtmltoimage -f png -q --width $w --height $h --disable-smart-width $html_fn $png_fn`)
 end
 
-function writemime_png_from_html(io::IO, plt::AbstractPlot)
+function show_png_from_html(io::IO, plt::AbstractPlot)
     # write html to a temporary file
     html_fn = write_temp_html(plt)
 

src/components.jl

@@ -12,25 +12,35 @@ compute_angle(v::P2) = (angle = atan2(v[2], v[1]); angle < 0 ? 2π - angle : ang
 # -------------------------------------------------------------
 
 immutable Shape
-  x::AVec
-  y::AVec
+    x::Vector{Float64}
+    y::Vector{Float64}
+    # function Shape(x::AVec, y::AVec)
+    #     # if x[1] != x[end] || y[1] != y[end]
+    #     #     new(vcat(x, x[1]), vcat(y, y[1]))
+    #     # else
+    #         new(x, y)
+    #     end
+    # end
 end
 Shape(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)
@@ -40,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)"
@@ -65,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
 
 
@@ -81,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
 
 
@@ -93,12 +103,39 @@ function makearrowhead(angle; h = 2.0, w = 0.4)
         from_polar(angle + 0.5π, w) - tip, (0,0)])
 end
 
+const _shape_keys = Symbol[
+  :circle,
+  :rect,
+  :star5,
+  :diamond,
+  :hexagon,
+  :cross,
+  :xcross,
+  :utriangle,
+  :dtriangle,
+  :rtriangle,
+  :ltriangle,
+  :pentagon,
+  :heptagon,
+  :octagon,
+  :star4,
+  :star6,
+  :star7,
+  :star8,
+  :vline,
+  :hline,
+  :+,
+  :x,
+]
+
 const _shapes = KW(
-    :ellipse    => makeshape(20),
+    :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),
@@ -113,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
@@ -135,8 +174,8 @@ function center(shape::Shape)
     Cx / 6A, Cy / 6A
 end
 
-function Base.scale!(shape::Shape, x::Real, y::Real = x, c = center(shape))
-    sx, sy = shape_coords(shape)
+function scale!(shape::Shape, x::Real, y::Real = x, c = center(shape))
+    sx, sy = coords(shape)
     cx, cy = c
     for i=1:length(sx)
         sx[i] = (sx[i] - cx) * x + cx
@@ -145,13 +184,13 @@ function Base.scale!(shape::Shape, x::Real, y::Real = x, c = center(shape))
     shape
 end
 
-function Base.scale(shape::Shape, x::Real, y::Real = x, c = center(shape))
+function scale(shape::Shape, x::Real, y::Real = x, c = center(shape))
     shapecopy = deepcopy(shape)
-    scale!(shape, x, y, c)
+    scale!(shapecopy, x, y, c)
 end
 
 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
@@ -161,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)
@@ -178,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
@@ -195,7 +235,7 @@ end
 # -----------------------------------------------------------------------
 
 
-immutable Font
+type Font
   family::AbstractString
   pointsize::Int
   halign::Symbol
@@ -208,7 +248,7 @@ end
 function font(args...)
 
   # defaults
-  family = "Helvetica"
+  family = "sans-serif"
   pointsize = 14
   halign = :hcenter
   valign = :vcenter
@@ -218,7 +258,14 @@ function font(args...)
   for arg in args
     T = typeof(arg)
 
-    if arg == :center
+    if T == Font
+      family = arg.family
+      pointsize = arg.pointsize
+      halign = arg.halign
+      valign = arg.valign
+      rotation = arg.rotation
+      color = arg.color
+    elseif arg == :center
       halign = :hcenter
       valign = :vcenter
     elseif arg in (:hcenter, :left, :right)
@@ -245,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
@@ -253,15 +311,12 @@ end
 PlotText(str) = PlotText(string(str), font())
 
 text(t::PlotText) = t
+text(str::AbstractString, f::Font) = PlotText(str, f)
 function text(str, args...)
   PlotText(string(str), font(args...))
 end
 
-
-annotations(::Void) = []
-annotations(anns::AVec) = anns
-annotations(anns) = Any[anns]
-
+Base.length(t::PlotText) = length(t.str)
 
 # -----------------------------------------------------------------------
 
@@ -275,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)
@@ -311,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)
@@ -337,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}
@@ -364,7 +522,7 @@ for f in (:length, :size)
   @eval Base.$f(surf::Surface, args...) = $f(surf.surf, args...)
 end
 Base.copy(surf::Surface) = Surface(copy(surf.surf))
-Base.eltype(surf::Surface) = eltype(surf.surf)
+Base.eltype{T}(surf::Surface{T}) = eltype(T)
 
 function expand_extrema!(a::Axis, surf::Surface)
     ex = a[:extrema]
@@ -379,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)
@@ -410,7 +603,7 @@ function arrow(args...)
             warn("Skipped arrow arg $arg")
         end
     end
-    Arrow(style, headlength, headwidth)
+    Arrow(style, side, headlength, headwidth)
 end
 
 
@@ -429,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
 
 
-supportedArgs(::BokehBackend) = [
+supported_attrs(::BokehBackend) = merge_with_base_supported([
     # :annotations,
     # :axis,
     # :background_color,
@@ -58,13 +58,12 @@ supportedArgs(::BokehBackend) = [
     # :grid,
     # :surface,
     # :levels,
-  ]
-supportedAxes(::BokehBackend) = [:auto, :left]
-supportedTypes(::BokehBackend) = [:none, :path, :scatter] #,:steppre, :steppost, :sticks, :histogram2d, :hexbin, :histogram, :bar, :hline, :vline, :contour]
-supportedStyles(::BokehBackend) = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
-supportedMarkers(::BokehBackend) = [:none, :auto, :ellipse, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5] #vcat(_allMarkers, Shape)
-supportedScales(::BokehBackend) = [:identity, :ln] #, :ln, :log2, :log10, :asinh, :sqrt]
-subplotSupported(::BokehBackend) = false
+  ])
+supported_types(::BokehBackend) = [:path, :scatter]
+supported_styles(::BokehBackend) = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
+supported_markers(::BokehBackend) = [:none, :auto, :circle, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5]
+supported_scales(::BokehBackend) = [:identity, :ln]
+is_subplot_supported(::BokehBackend) = false
 
 
 # --------------------------------------------------------------------------------------
@@ -81,7 +80,7 @@ end
 
 
 const _glyphtypes = KW(
-    :ellipse    => :Circle,
+    :circle    => :Circle,
     :rect       => :Square,
     :diamond    => :Diamond,
     :utriangle  => :Triangle,
@@ -100,7 +99,7 @@ function bokeh_glyph_type(d::KW)
   st = d[:seriestype]
   mt = d[:markershape]
   if st == :scatter && mt == :none
-    mt = :ellipse
+    mt = :circle
   end
 
   # if we have a marker, use that
@@ -195,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
 
 
-supportedArgs(::GadflyBackend) = [
+supported_attrs(::GadflyBackend) = merge_with_base_supported([
     :annotations,
     :background_color, :foreground_color, :color_palette,
     :group, :label, :seriestype,
@@ -15,7 +15,6 @@ supportedArgs(::GadflyBackend) = [
     :title, :window_title, :show, :size,
     :x, :xguide, :xlims, :xticks, :xscale, :xflip,
     :y, :yguide, :ylims, :yticks, :yscale, :yflip,
-    # :z, :zguide, :zlims, :zticks, :zscale, :zflip,
     :z,
     :tickfont, :guidefont, :legendfont,
     :grid, :legend, :colorbar,
@@ -23,18 +22,17 @@ supportedArgs(::GadflyBackend) = [
     :xerror, :yerror,
     :ribbon, :quiver,
     :orientation,
-  ]
-supportedAxes(::GadflyBackend) = [:auto, :left]
-supportedTypes(::GadflyBackend) = [
-        :none, :line, :path, :steppre, :steppost, :sticks,
-        :scatter, :histogram2d, :hexbin, :histogram,
-        :bar, #:box, :violin, :quiver,
-        :hline, :vline, :contour, :shape
+  ])
+supported_types(::GadflyBackend) = [
+        :path,
+        :scatter, :hexbin,
+        :bar,
+        :contour, :shape
     ]
-supportedStyles(::GadflyBackend) = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
-supportedMarkers(::GadflyBackend) = vcat(_allMarkers, Shape)
-supportedScales(::GadflyBackend) = [:identity, :ln, :log2, :log10, :asinh, :sqrt]
-subplotSupported(::GadflyBackend) = true
+supported_styles(::GadflyBackend) = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
+supported_markers(::GadflyBackend) = vcat(_allMarkers, Shape)
+supported_scales(::GadflyBackend) = [:identity, :ln, :log2, :log10, :asinh, :sqrt]
+is_subplot_supported(::GadflyBackend) = true
 
 
 # --------------------------------------------------------------------------------------
@@ -43,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
 
@@ -246,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
@@ -303,7 +301,7 @@ function addGadflySeries!(plt::Plot, d::KW)
     if st in (:histogram2d, :hexbin) && (isa(d[:fillcolor], ColorGradient) || isa(d[:fillcolor], ColorFunction))
         push!(gplt.scales, Gadfly.Scale.ContinuousColorScale(p -> RGB(getColorZ(d[:fillcolor], p))))
     elseif st == :scatter && d[:markershape] == :none
-        d[:markershape] = :ellipse
+        d[:markershape] = :circle
     end
 
     # markers
@@ -458,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...)
@@ -539,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)
@@ -560,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
@@ -679,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)
@@ -694,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/gadfly_shapes.jl

@@ -84,7 +84,7 @@ function make_polygon(geom::ShapeGeometry, xs::AbstractArray, ys::AbstractArray,
     x = Compose.x_measure(xs[mod1(i, length(xs))])
     y = Compose.y_measure(ys[mod1(i, length(ys))])
     r = rs[mod1(i, length(rs))]
-    polys[i] = T[(x + r * sx, y + r * sy) for (sx,sy) in get_mod(geom.vertices, i)]
+    polys[i] = T[(x + r * sx, y + r * sy) for (sx,sy) in cycle(geom.vertices, i)]
   end
   Gadfly.polygon(polys, geom.tag)
 end

src/deprecated/backends/immerse.jl

@@ -1,13 +1,12 @@
 
 # https://github.com/JuliaGraphics/Immerse.jl
 
-supportedArgs(::ImmerseBackend) = supportedArgs(GadflyBackend())
-supportedAxes(::ImmerseBackend) = supportedAxes(GadflyBackend())
-supportedTypes(::ImmerseBackend) = supportedTypes(GadflyBackend())
-supportedStyles(::ImmerseBackend) = supportedStyles(GadflyBackend())
-supportedMarkers(::ImmerseBackend) = supportedMarkers(GadflyBackend())
-supportedScales(::ImmerseBackend) = supportedScales(GadflyBackend())
-subplotSupported(::ImmerseBackend) = true
+supported_attrs(::ImmerseBackend) = supported_attrs(GadflyBackend())
+supported_types(::ImmerseBackend) = supported_types(GadflyBackend())
+supported_styles(::ImmerseBackend) = supported_styles(GadflyBackend())
+supported_markers(::ImmerseBackend) = supported_markers(GadflyBackend())
+supported_scales(::ImmerseBackend) = supported_scales(GadflyBackend())
+is_subplot_supported(::ImmerseBackend) = true
 
 # --------------------------------------------------------------------------------------
 
@@ -15,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
 
@@ -62,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,52 +2,29 @@
 # https://github.com/tbreloff/Qwt.jl
 
 
-supportedArgs(::QwtBackend) = [
+supported_attrs(::QwtBackend) = merge_with_base_supported([
     :annotations,
-    :axis,
-    :background_color,
     :linecolor,
-    :color_palette,
     :fillrange,
     :fillcolor,
-    :foreground_color,
-    :group,
     :label,
-    :layout,
     :legend,
     :seriescolor, :seriesalpha,
     :linestyle,
-    :seriestype,
     :linewidth,
     :markershape,
     :markercolor,
     :markersize,
-    :n,
     :bins,
-    :nc,
-    :nr,
     :pos,
-    :smooth,
-    :show,
-    :size,
     :title,
     :window_title,
-    :x,
-    :xguide,
-    :xlims,
-    :xticks,
-    :y,
-    :yguide,
-    :ylims,
-    :yrightlabel,
-    :yticks,
-    :xscale,
-    :yscale,
-  ]
-supportedTypes(::QwtBackend) = [:none, :line, :path, :steppre, :steppost, :sticks, :scatter, :histogram2d, :hexbin, :histogram, :bar, :hline, :vline]
-supportedMarkers(::QwtBackend) = [:none, :auto, :rect, :ellipse, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5, :star8, :hexagon]
-supportedScales(::QwtBackend) = [:identity, :log10]
-subplotSupported(::QwtBackend) = true
+    :guide, :lims, :ticks, :scale,
+  ])
+supported_types(::QwtBackend) = [:path, :scatter, :hexbin, :bar]
+supported_markers(::QwtBackend) = [:none, :auto, :rect, :circle, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5, :star8, :hexagon]
+supported_scales(::QwtBackend) = [:identity, :log10]
+is_subplot_supported(::QwtBackend) = true
 
 
 # --------------------------------------------------------------------------------------
@@ -62,7 +39,7 @@ end
 
 # -------------------------------
 
-@compat const _qwtAliases = KW(
+const _qwtAliases = KW(
     :bins => :heatmap_n,
     :fillrange => :fillto,
     :linewidth => :width,
@@ -95,13 +72,13 @@ function adjustQwtKeywords(plt::Plot{QwtBackend}, iscreating::Bool; kw...)
   if st == :scatter
     d[:seriestype] = :none
     if d[:markershape] == :none
-      d[:markershape] = :ellipse
+      d[:markershape] = :circle
     end
 
   elseif st in (:hline, :vline)
     addLineMarker(plt, d)
     d[:seriestype] = :none
-    d[:markershape] = :ellipse
+    d[:markershape] = :circle
     d[:markersize] = 1
     if st == :vline
       d[:x], d[:y] = d[:y], d[:x]
@@ -156,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
@@ -184,7 +161,7 @@ function updateLimsAndTicks(plt::Plot{QwtBackend}, d::KW, isx::Bool)
     # scaletype == :log       && w[:setAxisScaleEngine](axisid, Qwt.QWT.QwtLogScaleEngine(e))
     # scaletype == :log2      && w[:setAxisScaleEngine](axisid, Qwt.QWT.QwtLogScaleEngine(2))
     scaletype == :log10     && w[:setAxisScaleEngine](axisid, Qwt.QWT.QwtLog10ScaleEngine())
-    scaletype in supportedScales() || warn("Unsupported scale type: ", scaletype)
+    scaletype in supported_scales() || warn("Unsupported scale type: ", scaletype)
   end
 
 end
@@ -234,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
@@ -265,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)
@@ -305,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,64 +3,29 @@
 
 # credit goes to https://github.com/jverzani for contributing to the first draft of this backend implementation
 
-supportedArgs(::WinstonBackend) = [
+supported_attrs(::WinstonBackend) = merge_with_base_supported([
     :annotations,
-    # :args,
-    # :axis,
-    # :background_color,
     :linecolor,
-    :color_palette,
     :fillrange,
     :fillcolor,
-    # :foreground_color,
-    :group,
-    # :heatmap_c,
-    # :kwargs,
     :label,
-    # :layout,
     :legend,
     :seriescolor, :seriesalpha,
     :linestyle,
-    :seriestype,
     :linewidth,
     :markershape,
     :markercolor,
     :markersize,
-    # :markerstrokewidth,
-    # :markerstrokecolor,
-    # :markerstrokestyle,
-    # :n,
     :bins,
-    # :nc,
-    # :nr,
-    # :pos,
-    :smooth,
-    # :ribbon,
-    :show,
-    :size,
     :title,
     :window_title,
-    :x,
-    :xguide,
-    :xlims,
-    # :xticks,
-    :y,
-    :yguide,
-    :ylims,
-    # :yrightlabel,
-    # :yticks,
-    :xscale,
-    :yscale,
-    # :xflip,
-    # :yflip,
-    # :z,
-  ]
-supportedAxes(::WinstonBackend) = [:auto, :left]
-supportedTypes(::WinstonBackend) = [:none, :line, :path, :sticks, :scatter, :histogram, :bar]
-supportedStyles(::WinstonBackend) = [:auto, :solid, :dash, :dot, :dashdot]
-supportedMarkers(::WinstonBackend) = [:none, :auto, :rect, :ellipse, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5]
-supportedScales(::WinstonBackend) = [:identity, :log10]
-subplotSupported(::WinstonBackend) = false
+    :guide, :lims, :scale,
+  ])
+supported_types(::WinstonBackend) = [:path, :scatter, :bar]
+supported_styles(::WinstonBackend) = [:auto, :solid, :dash, :dot, :dashdot]
+supported_markers(::WinstonBackend) = [:none, :auto, :rect, :circle, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5]
+supported_scales(::WinstonBackend) = [:identity, :log10]
+is_subplot_supported(::WinstonBackend) = false
 
 
 # --------------------------------------------------------------------------------------
@@ -79,15 +44,15 @@ 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",
-                            :ellipse=>"circle",
+                            :circle=>"circle",
                             :diamond=>"diamond",
                             :utriangle=>"triangle",
                             :dtriangle=>"down-triangle",
@@ -170,7 +135,7 @@ function _series_added(plt::Plot{WinstonBackend}, series::Series)
 
   elseif d[:seriestype] == :scatter
     if d[:markershape] == :none
-      d[:markershape] = :ellipse
+      d[:markershape] = :circle
     end
 
   # elseif d[:seriestype] == :step
@@ -220,7 +185,7 @@ end
 
 # ----------------------------------------------------------------
 
-@compat const _winstonNames = KW(
+const _winstonNames = KW(
     :xlims => :xrange,
     :ylims => :yrange,
     :xscale => :xlog,
@@ -248,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
@@ -273,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...)
@@ -23,13 +51,15 @@ convertColor(c::Symbol) = parse(Colorant, string(c))
 convertColor(c::Colorant) = c
 convertColor(cvec::AbstractVector) = map(convertColor, cvec)
 convertColor(c::ColorScheme) = c
+convertColor(v::Void) = RGBA(0,0,0,0)
+convertColor(b::Bool) = b ? RGBA(0,0,0,1) : RGBA(0,0,0,0)
 
 function convertColor(c, α::Real)
   c = convertColor(c)
-  RGBA(RGB(c), α)
+  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)
@@ -49,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)]
 
@@ -101,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))))
@@ -119,6 +155,11 @@ function ColorGradient(grad::ColorGradient; alpha = nothing)
   ColorGradient(convertColor(grad.colors, alpha), grad.values)
 end
 
+# anything else just gets the default gradient
+function ColorGradient(cw; alpha=nothing)
+    ColorGradient(default_gradient(), alpha=alpha)
+end
+
 getColor(gradient::ColorGradient, idx::Int) = gradient.colors[mod1(idx, length(gradient.colors))]
 
 function getColorZ(gradient::ColorGradient, z::Real)
@@ -180,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)
 
 # --------------------------------------------------------------
 
@@ -206,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,15 +115,17 @@ PlotExample("Line types",
 PlotExample("Line styles",
     "",
     [:(begin
-        styles = setdiff(supportedStyles(), [:auto])'
-        plot(cumsum(randn(20,length(styles)),1), style=:auto, label=map(string,styles), w=5)
+        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))
     end)]
 ),
 
 PlotExample("Marker types",
     "",
     [:(begin
-        markers = setdiff(supportedMarkers(), [:none,:auto,Shape])'
+        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)
@@ -170,6 +172,24 @@ PlotExample("",
     end)]
 ),
 
+PlotExample("Animation with subplots",
+    "The `layout` macro can be used to create an animation with subplots.",
+    [:(begin
+        l = @layout([[a; b] c])
+        p = plot(plot([sin,cos],1,leg=false),
+        scatter([atan,cos],1,leg=false),
+        plot(log,1,xlims=(1,10π),ylims=(0,5),leg=false),layout=l)
+
+        anim = Animation()
+        for x = linspace(1,10π,100)
+          plot(push!(p,x,Float64[sin(x),cos(x),atan(x),cos(x),log(x)]))
+          frame(anim)
+        end
+    end)]
+),
+
+
+
 PlotExample("Open/High/Low/Close",
     "Create an OHLC chart.  Pass in a list of (open,high,low,close) tuples as your `y` argument.  This uses recipes to first convert the tuples to OHLC objects, and subsequently create a :path series with the appropriate line segments.",
     [:(begin
@@ -219,12 +239,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",
@@ -256,7 +270,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)]
 ),
 
@@ -264,7 +278,7 @@ PlotExample("Groups and Subplots",
     "",
     [:(begin
         group = rand(map(i->"group $i",1:4),100)
-        plot(rand(100), layout=@layout([a b;c]), group=group, n=3, linetype=[:bar :scatter :steppre])
+        plot(rand(100), layout=@layout([a b;c]), group=group, linetype=[:bar :scatter :steppre])
     end)]
 ),
 
@@ -301,8 +315,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)]
 )
 
@@ -325,11 +339,13 @@ function test_examples(pkgname::Symbol, idx::Int; debug = false, disp = true)
 end
 
 # generate all plots and create a dict mapping idx --> plt
-function test_examples(pkgname::Symbol; debug = false, disp = true)
+function test_examples(pkgname::Symbol; debug = false, disp = true, sleep = nothing,
+                                        skip = [], only = nothing)
   Plots._debugMode.on = debug
   plts = Dict()
   for i in 1:length(_examples)
-
+    only != nothing && !(i in only) && continue
+    i in skip && continue
     try
       plt = test_examples(pkgname, i, debug=debug, disp=disp)
       plts[i] = plt
@@ -337,6 +353,9 @@ function test_examples(pkgname::Symbol; debug = false, disp = true)
       # TODO: put error info into markdown?
       warn("Example $pkgname:$i:$(_examples[i].header) failed with: $ex")
     end
+    if sleep != nothing
+        Base.sleep(sleep)
+    end
   end
   plts
 end

src/layouts.jl

@@ -5,12 +5,14 @@
 const px = AbsoluteLength(0.254)
 const pct = Length{:pct, Float64}(1.0)
 
+to_pixels(m::AbsoluteLength) = m.value / 0.254
+
 const _cbar_width = 5mm
 
-@compat Base.:.*(m::Measure, n::Number) = m * n
-@compat Base.:.*(n::Number, m::Measure) = m * n
-@compat Base.:-(m::Measure, a::AbstractArray) = map(ai -> m - ai, a)
-@compat Base.:-(a::AbstractArray, m::Measure) = map(ai -> ai - m, a)
+Base.:.*(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
@@ -18,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
@@ -42,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
@@ -70,6 +72,16 @@ function crop(parent::BoundingBox, child::BoundingBox)
     BoundingBox(l, t, w, h)
 end
 
+# convert x,y coordinates from absolute coords to percentages...
+# returns x_pct, y_pct
+function xy_mm_to_pcts(x::AbsoluteLength, y::AbsoluteLength, figw, figh, flipy = true)
+    xmm, ymm = x.value, y.value
+    if flipy
+        ymm = figh.value - ymm  # flip y when origin in bottom-left
+    end
+    xmm / figw.value, ymm / figh.value
+end
+
 # convert a bounding box from absolute coords to percentages...
 # returns an array of percentages of figure size: [left, bottom, width, height]
 function bbox_to_pcts(bb::BoundingBox, figw, figh, flipy = true)
@@ -84,11 +96,85 @@ 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, width, height; h_anchor = :left, v_anchor = :top)
+    x = make_measure_hor(x)
+    y = make_measure_vert(y)
+    width = make_measure_hor(width)
+    height = make_measure_vert(height)
+    left = if h_anchor == :left
+        x
+    elseif h_anchor in (:center, :hcenter)
+        0.5w - 0.5width + x
+    else
+        1w - x - width
+    end
+    top = if v_anchor == :top
+        y
+    elseif v_anchor in (:center, :vcenter)
+        0.5h - 0.5height + y
+    else
+        1h - y - height
+    end
+    BoundingBox(left, top, width, height)
+end
+
 # this is the available area for drawing everything in this layout... as percentages of total canvas
 bbox(layout::AbstractLayout) = layout.bbox
 bbox!(layout::AbstractLayout, bb::BoundingBox) = (layout.bbox = bb)
@@ -97,25 +183,23 @@ bbox!(layout::AbstractLayout, bb::BoundingBox) = (layout.bbox = bb)
 Base.parent(layout::AbstractLayout) = layout.parent
 parent_bbox(layout::AbstractLayout) = bbox(parent(layout))
 
-# NOTE: these should be implemented for subplots in each backend!
-# they represent the minimum size of the axes and guides
-min_padding_left(layout::AbstractLayout)   = 0mm
-min_padding_top(layout::AbstractLayout)    = 0mm
-min_padding_right(layout::AbstractLayout)  = 0mm
-min_padding_bottom(layout::AbstractLayout) = 0mm
+# padding_w(layout::AbstractLayout) = left_padding(layout) + right_padding(layout)
+# padding_h(layout::AbstractLayout) = bottom_padding(layout) + top_padding(layout)
+# padding(layout::AbstractLayout) = (padding_w(layout), padding_h(layout))
 
-padding_w(layout::AbstractLayout) = left_padding(layout) + right_padding(layout)
-padding_h(layout::AbstractLayout) = bottom_padding(layout) + top_padding(layout)
-padding(layout::AbstractLayout) = (padding_w(layout), padding_h(layout))
+update_position!(layout::AbstractLayout) = nothing
+update_child_bboxes!(layout::AbstractLayout, minimum_perimeter = [0mm,0mm,0mm,0mm]) = nothing
 
-_update_position!(layout::AbstractLayout) = nothing
-update_child_bboxes!(layout::AbstractLayout) = nothing
+left(layout::AbstractLayout) = left(bbox(layout))
+top(layout::AbstractLayout) = top(bbox(layout))
+right(layout::AbstractLayout) = right(bbox(layout))
+bottom(layout::AbstractLayout) = bottom(bbox(layout))
+width(layout::AbstractLayout) = width(bbox(layout))
+height(layout::AbstractLayout) = height(bbox(layout))
 
-width(layout::AbstractLayout) = width(layout.bbox)
-height(layout::AbstractLayout) = height(layout.bbox)
-
-plotarea(layout::AbstractLayout) = defaultbox
-plotarea!(layout::AbstractLayout, bbox::BoundingBox) = nothing
+# pass these through to the bbox methods if there's no plotarea
+plotarea(layout::AbstractLayout) = bbox(layout)
+plotarea!(layout::AbstractLayout, bb::BoundingBox) = bbox!(layout, bb)
 
 attr(layout::AbstractLayout, k::Symbol) = layout.attr[k]
 attr(layout::AbstractLayout, k::Symbol, v) = get(layout.attr, k, v)
@@ -187,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
 
@@ -204,6 +290,12 @@ rightpad(layout::GridLayout)  = layout.minpad[3]
 bottompad(layout::GridLayout) = layout.minpad[4]
 
 
+# here's how this works... first we recursively "update the minimum padding" (which
+# means to calculate the minimum size needed from the edge of the subplot to plot area)
+# for the whole layout tree.  then we can compute the "padding borders" of this
+# layout as the biggest padding of the children on the perimeter.  then we need to
+# recursively pass those borders back down the tree, one side at a time, but ONLY
+# to those perimeter children.
 
 # leftpad, toppad, rightpad, bottompad
 function _update_min_padding!(layout::GridLayout)
@@ -217,10 +309,11 @@ function _update_min_padding!(layout::GridLayout)
 end
 
 
-function _update_position!(layout::GridLayout)
-    map(_update_position!, layout.grid)
+function update_position!(layout::GridLayout)
+    map(update_position!, layout.grid)
 end
 
+# some lengths are fixed... we have to split up the free space among the list v
 function recompute_lengths(v)
     # dump(v)
     tot = 0pct
@@ -242,17 +335,16 @@ function recompute_lengths(v)
 end
 
 # recursively compute the bounding boxes for the layout and plotarea (relative to canvas!)
-function update_child_bboxes!(layout::GridLayout)
+function update_child_bboxes!(layout::GridLayout, minimum_perimeter = [0mm,0mm,0mm,0mm])
     nr, nc = size(layout)
 
-    # create a matrix for each minimum padding direction
-    _update_min_padding!(layout)
+    # # create a matrix for each minimum padding direction
+    # _update_min_padding!(layout)
 
     minpad_left   = map(leftpad,   layout.grid)
     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
@@ -261,27 +353,28 @@ function update_child_bboxes!(layout::GridLayout)
     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])
+    pad_top[1]      = max(pad_top[1], minimum_perimeter[2])
+    pad_right[end]  = max(pad_right[end], minimum_perimeter[3])
+    pad_bottom[end] = max(pad_bottom[end], minimum_perimeter[4])
 
     # scale this up to the total padding in each direction
     total_pad_horizontal = sum(pad_left + pad_right)
     total_pad_vertical   = sum(pad_top + pad_bottom)
-    # @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
@@ -303,11 +396,35 @@ function update_child_bboxes!(layout::GridLayout)
         child_height = pad_top[r] + plotarea_height + pad_bottom[r]
         bbox!(child, BoundingBox(child_left, child_top, child_width, child_height))
 
+        # this is the minimum perimeter as decided by this child's parent, so that
+        # all children on this border have the same value
+        min_child_perimeter = [
+            c == 1  ? layout.minpad[1] : 0mm,
+            r == 1  ? layout.minpad[2] : 0mm,
+            c == nc ? layout.minpad[3] : 0mm,
+            r == nr ? layout.minpad[4] : 0mm
+        ]
+
         # recursively update the child's children
-        update_child_bboxes!(child)
+        update_child_bboxes!(child, min_child_perimeter)
     end
 end
 
+# for each inset (floating) subplot, resolve the relative position
+# to absolute canvas coordinates, relative to the parent's plotarea
+function update_inset_bboxes!(plt::Plot)
+    for sp in plt.inset_subplots
+        p_area = Measures.resolve(plotarea(sp.parent), sp[:relative_bbox])
+        plotarea!(sp, p_area)
+
+        bbox!(sp, bbox(
+            left(p_area) - leftpad(sp),
+            top(p_area) - toppad(sp),
+            width(p_area) + leftpad(sp) + rightpad(sp),
+            height(p_area) + toppad(sp) + bottompad(sp)
+        ))
+    end
+end
 
 # ----------------------------------------------------------------------
 
@@ -346,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
@@ -376,40 +493,21 @@ end
 
 layout_args(huh) = error("unhandled layout type $(typeof(huh)): $huh")
 
-# # pass the layout arg through
-# function build_layout(d::KW)
-#     build_layout(get(d, :layout, default(:layout)))
-# end
-#
-# function build_layout(n::Integer)
-#     nr, nc = compute_gridsize(n, -1, -1)
-#     build_layout(GridLayout(nr, nc), n)
-# end
-#
-# function build_layout{I<:Integer}(sztup::NTuple{2,I})
-#     nr, nc = sztup
-#     build_layout(GridLayout(nr, nc))
-# end
-#
-# function build_layout{I<:Integer}(sztup::NTuple{3,I})
-#     n, nr, nc = sztup
-#     nr, nc = compute_gridsize(n, nr, nc)
-#     build_layout(GridLayout(nr, nc), n)
-# end
-#
-# # compute number of subplots
-# function build_layout(layout::GridLayout)
-#     # recursively get the size of the grid
-#     n = calc_num_subplots(layout)
-#     build_layout(layout, n)
-# end
+
+# ----------------------------------------------------------------------
+
 
 function build_layout(args...)
     layout, n = layout_args(args...)
     build_layout(layout, n)
 end
 
-# n is the number of subplots
+# # just a single subplot
+# function build_layout(sp::Subplot, n::Integer)
+#     sp, Subplot[sp], SubplotMap(gensym() => sp)
+# end
+
+# n is the number of subplots... build a grid and initialize the inner subplots recursively
 function build_layout(layout::GridLayout, n::Integer)
     nr, nc = size(layout)
     subplots = Subplot[]
@@ -431,10 +529,18 @@ 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)
             i += length(sps)
+        elseif isa(l, Subplot)
+            error("Subplot exists. Cannot re-use existing layout.  Please make a new one.")
         end
         i >= n && break  # only add n subplots
     end
@@ -465,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)
@@ -512,67 +624,33 @@ rowsize(v) = isrow(v) ? length(v.args) : 1
 
 
 function create_grid(expr::Expr)
-    # cellsym = gensym(:cell)
-    # @show expr
     if iscol(expr)
         create_grid_vcat(expr)
-        # rowsizes = map(rowsize, expr.args)
-        # rmin, rmax = extrema(rowsizes)
-        # if rmin > 0 && rmin == rmax
-        #     # we have a grid... build the whole thing
-        #     # note: rmin is the number of columns
-        #     nr = length(expr.args)
-        #     nc = rmin
-        #
-        #     :(let cell = GridLayout($nr, $nc)
-        #         $([:(cell[$r,$c] = $(create_grid(expr.args[r], c))) for r=1:nr, c=1:nc]...)
-        #         for r=1:nr
-        #             layout = $(create_grid(expr.args[r])
-        #             cell[r,]
-        #         $([:($cellsym[$r,1] = $(create_grid(expr.args[r]))) for r=1:length(expr.args)]...)
-        #         $cellsym
-        #     end)
-        # else
-        #     # otherwise just build one row at a time
-        #     :(let
-        #         $cellsym = GridLayout($(length(expr.args)), 1)
-        #         $([:($cellsym[$i,1] = $(create_grid(expr.args[i]))) for i=1:length(expr.args)]...)
-        #         $cellsym
-        #     end)
-        # end
     elseif isrow(expr)
         :(let cell = GridLayout(1, $(length(expr.args)))
             $([:(cell[1,$i] = $(create_grid(v))) for (i,v) in enumerate(expr.args)]...)
             cell
         end)
-        # :(let
-        #     $cellsym = GridLayout(1, $(length(expr.args)))
-        #     $([:($cellsym[1,$i] = $(create_grid(expr.args[i]))) for i=1:length(expr.args)]...)
-        #     $cellsym
-        # end)
 
     elseif expr.head == :curly
         create_grid_curly(expr)
     else
         # if it's something else, just return that (might be an existing layout?)
-        expr
+        esc(expr)
     end
 end
 
 function create_grid_vcat(expr::Expr)
     rowsizes = map(rowsize, expr.args)
     rmin, rmax = extrema(rowsizes)
-    # @show rmin, rmax
     if rmin > 0 && rmin == rmax
         # we have a grid... build the whole thing
         # note: rmin is the number of columns
         nr = length(expr.args)
         nc = rmin
-        # @show nr, nc
         body = Expr(:block)
         for r=1:nr
             arg = expr.args[r]
-            # @show r, arg
             if isrow(arg)
                 for (c,item) in enumerate(arg.args)
                     push!(body.args, :(cell[$r,$c] = $(create_grid(item))))
@@ -581,41 +659,32 @@ function create_grid_vcat(expr::Expr)
                 push!(body.args, :(cell[$r,1] = $(create_grid(arg))))
             end
         end
-        # @show body
         :(let cell = GridLayout($nr, $nc)
             $body
             cell
         end)
-        # :(let cell = GridLayout($nr, $nc)
-        #     $([:(cell[$r,$c] = $(create_grid(expr.args[r], c))) for r=1:nr, c=1:nc]...)
-        #     for r=1:nr
-        #         layout = $(create_grid(expr.args[r])
-        #         cell[r,]
-        #     $([:($cellsym[$r,1] = $(create_grid(expr.args[r]))) for r=1:length(expr.args)]...)
-        #     $cellsym
-        # end)
     else
         # otherwise just build one row at a time
         :(let cell = GridLayout($(length(expr.args)), 1)
             $([:(cell[$i,1] = $(create_grid(v))) for (i,v) in enumerate(expr.args)]...)
             cell
         end)
-        # :(let
-        #     $cellsym = GridLayout($(length(expr.args)), 1)
-        #     $([:($cellsym[$i,1] = $(create_grid(expr.args[i]))) for i=1:length(expr.args)]...)
-        #     $cellsym
-        # end)
     end
 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)
@@ -629,22 +698,46 @@ 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]
-    link_axes!(axes...)
+    if length(axes) > 0
+        link_axes!(axes...)
+    end
 end
 
 # don't do anything for most layout types
@@ -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(
@@ -119,46 +152,90 @@ const _mimeformats = Dict(
     "application/pdf"         => "pdf",
     "image/png"               => "png",
     "application/postscript"  => "ps",
-    "image/svg+xml"           => "svg"
+    "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
+        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 import FileIO
+    function _show(io::IO, ::MIME"image/png", plt::Plot)
+        fn = tempname()
+
+        # first save a pdf file
+        pdf(plt, fn)
+
+        # load that pdf into a FileIO Stream
+        s = FileIO.load(fn * ".pdf")
+
+        # save a png
+        pngfn = fn * ".png"
+        FileIO.save(pngfn, s)
+
+        # now write from the file
+        write(io, readall(open(pngfn)))
+    end
+end
+
+
+
+
+
 # function html_output_format(fmt)
 #     if fmt == "png"
-#         @eval function Base.writemime(io::IO, ::MIME"text/html", plt::Plot)
-#             print(io, "<img src=\"data:image/png;base64,", base64(writemime, MIME("image/png"), plt), "\" />")
+#         @eval function Base.show(io::IO, ::MIME"text/html", plt::Plot)
+#             print(io, "<img src=\"data:image/png;base64,", base64(show, MIME("image/png"), plt), "\" />")
 #         end
 #     elseif fmt == "svg"
-#         @eval function Base.writemime(io::IO, ::MIME"text/html", plt::Plot)
-#             writemime(io, MIME("image/svg+xml"), plt)
+#         @eval function Base.show(io::IO, ::MIME"text/html", plt::Plot)
+#             show(io, MIME("image/svg+xml"), plt)
 #         end
 #     else
 #         error("only png or svg allowed. got: $fmt")
@@ -171,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
@@ -186,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")
@@ -198,28 +280,46 @@ 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
+            # special handling for PlotlyJS
+            function Media.render(pane::Atom.PlotPane, plt::Plot{PlotlyJSBackend})
+                display(Plots.PlotsDisplay(), plt)
+            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 backend cannot render in the PlotPane due to javascript issues. Plotlyjs is similar to plotly and is compatible with the plot pane."
+            Media.render(pane, Atom.div(Atom.HTML(s)))
+        end
     end
 end

src/pipeline.jl

@@ -0,0 +1,421 @@
+
+
+# ------------------------------------------------------------------
+# 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
+            for k in (:scale,), letter in (:x,:y,:z)
+                # Series recipes may need access to this information
+                lk = Symbol(letter,k)
+                if haskey(attr, lk)
+                    kw[lk] = attr[lk]
+                end
+            end
+        end
+        sp_attrs[sp] = attr
+    end
+
+    # override subplot/axis args.  `sp_attrs` take precendence
+    for (idx,sp) in enumerate(plt.subplots)
+        attr = if !haskey(d, :subplot) || d[:subplot] == idx
+            merge(d, get(sp_attrs, sp, KW()))
+        else
+            get(sp_attrs, sp, KW())
+        end
+        _update_subplot_args(plt, sp, attr, idx, false)
+    end
+
+    # do we need to link any axes together?
+    link_axes!(plt.layout, plt[:link])
+end
+
+# getting ready to add the series... last update to subplot from anything
+# that might have been added during series recipes
+function _prepare_subplot{T}(plt::Plot{T}, d::KW)
+    st::Symbol = d[:seriestype]
+    sp::Subplot{T} = d[:subplot]
+    sp_idx = get_subplot_index(plt, sp)
+    _update_subplot_args(plt, sp, d, sp_idx, true)
+
+    st = _override_seriestype_check(d, st)
+
+    # change to a 3d projection for this subplot?
+    if is3d(st)
+        sp.attr[:projection] = "3d"
+    end
+
+    # initialize now that we know the first series type
+    if !haskey(sp.attr, :init)
+        _initialize_subplot(plt, sp)
+        sp.attr[:init] = true
+    end
+    sp
+end
+
+# ------------------------------------------------------------------
+# series types
+
+function _override_seriestype_check(d::KW, st::Symbol)
+    # do we want to override the series type?
+    if !is3d(st)
+        z = d[:z]
+        if !isa(z, Void) && (size(d[:x]) == size(d[:y]) == size(z))
+            st = (st == :scatter ? :scatter3d : :path3d)
+            d[:seriestype] = st
+        end
+    end
+    st
+end
+
+function _prepare_annotations(sp::Subplot, d::KW)
+    # strip out series annotations (those which are based on series x/y coords)
+    # and add them to the subplot attr
+    sp_anns = annotations(sp[:annotations])
+    # series_anns = annotations(pop!(d, :series_annotations, []))
+    # if isa(series_anns, SeriesAnnotations)
+    #     series_anns.x = d[:x]
+    #     series_anns.y = d[:y]
+    # elseif length(series_anns) > 0
+    #     x, y = d[:x], d[:y]
+    #     nx, ny, na = map(length, (x,y,series_anns))
+    #     n = max(nx, ny, na)
+    #     series_anns = [(x[mod1(i,nx)], y[mod1(i,ny)], text(series_anns[mod1(i,na)])) for i=1:n]
+    # end
+    # sp.attr[:annotations] = vcat(sp_anns, series_anns)
+end
+
+function _expand_subplot_extrema(sp::Subplot, d::KW, st::Symbol)
+    # adjust extrema and discrete info
+    if st == :image
+        w, h = size(d[:z])
+        expand_extrema!(sp[:xaxis], (0,w))
+        expand_extrema!(sp[:yaxis], (0,h))
+        sp[:yaxis].d[:flip] = true
+    elseif !(st in (:pie, :histogram, :bins2d, :histogram2d))
+        expand_extrema!(sp, d)
+    end
+end
+
+function _add_the_series(plt, sp, d)
+    warnOnUnsupported_args(plt.backend, d)
+    warnOnUnsupported(plt.backend, d)
+    series = Series(d)
+    push!(plt.series_list, series)
+    push!(sp.series_list, series)
+    _series_added(plt, series)
+end
+
+# -------------------------------------------------------------------------------
+
+# this method recursively applies series recipes when the seriestype is not supported
+# natively by the backend
+function _process_seriesrecipe(plt::Plot, d::KW)
+    # replace seriestype aliases
+    st = Symbol(d[:seriestype])
+    st = d[:seriestype] = get(_typeAliases, st, st)
+
+    # shapes shouldn't have fillrange set
+    if d[:seriestype] == :shape
+        d[:fillrange] = nothing
+    end
+
+    # if it's natively supported, finalize processing and pass along to the backend, otherwise recurse
+    if is_seriestype_supported(st)
+        sp = _prepare_subplot(plt, d)
+        _prepare_annotations(sp, d)
+        _expand_subplot_extrema(sp, d, st)
+        _add_the_series(plt, sp, d)
+
+    else
+        # get a sub list of series for this seriestype
+        datalist = RecipesBase.apply_recipe(d, Val{st}, d[:x], d[:y], d[:z])
+
+        # assuming there was no error, recursively apply the series recipes
+        for data in datalist
+            if isa(data, RecipeData)
+                preprocessArgs!(data.d)
+                if data.d[:seriestype] == st
+                    error("The seriestype didn't change in series recipe $st.  This will cause a StackOverflow.")
+                end
+                _process_seriesrecipe(plt, data.d)
+            else
+                warn("Unhandled recipe: $(data)")
+                break
+            end
+        end
+    end
+    nothing
+end

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,24 +89,44 @@ function plot(plt1::Plot, plts_tail::Plot...; kw...)
     plt.o = _create_backend_figure(plt)
     plt.init = true
 
-    # create the layout and initialize the subplots
-    plt.layout, plt.subplots, plt.spmap = build_layout(layout, num_sp, copy(plts))
-    for (idx, sp) in enumerate(plt.subplots)
-        _initialize_subplot(plt, sp)
-        serieslist = series_list(sp)
-        sp.plt = plt
-        sp.attr[:subplot_index] = idx
-        for series in serieslist
-            push!(plt.series_list, series)
-            _series_added(plt, series)
+    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)
+        if sp in sp.plt.inset_subplots
+            push!(plt.inset_subplots, sp)
+        end
+        sp.plt = plt
+        sp.attr[:subplot_index] = idx
+        for series in serieslist
+            merge!(series.d, series_attr)
+            _add_defaults!(series.d, plt, sp, cmdidx)
+            push!(plt.series_list, series)
+            _series_added(plt, series)
+            cmdidx += 1
+        end
+    end
+
+    # first apply any args for the subplots
+    for (idx,sp) in enumerate(plt.subplots)
+        _update_subplot_args(plt, sp, d, idx, false)
+    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
 
@@ -128,261 +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 supportedTypes()
-
-        # 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)
-
-        # 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
-
-        # 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!
-        warnOnUnsupportedArgs(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])
-                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
-                warnOnUnsupportedScales(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,
-                    )))
-
-                    # don't allow something else to handle it
-                    d[:smooth] = 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
 
-    # merge in anything meant for plot/subplot
-    for kw in kw_list
-        for (k,v) in kw
-            for defdict in (_plot_defaults, _subplot_defaults)
-                if haskey(defdict, k)
-                    d[k] = pop!(kw, k)
-                end
-            end
-            # if haskey(_plot_defaults, k) || haskey(_subplot_defaults, k)
-            #     d[k] = v
-            # end
-        end
-    end
+    # info(2)
+    # map(DD, kw_list)
 
-    # 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
-
-    # 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)
-    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
-    for (i,kw) in enumerate(kw_list)
-        # if !(get(kw, :seriestype, :none) in (:xerror, :yerror))
-        #     plt.n += 1
-        # end
-        command_idx = kw[:series_plotindex] - kw_list[1][:series_plotindex] + 1
+    # --------------------------------
+    # "SERIES RECIPES"
+    # --------------------------------
 
-        # 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)
-        idx = get_subplot_index(plt, sp)
+    # info(3)
+    # map(DD, kw_list)
 
-        # 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)
+    for kw in kw_list
+        sp::Subplot = kw[:subplot]
+        # idx = get_subplot_index(plt, sp)
 
-        # we update subplot args in case something like the color palatte is part of the recipe
-        _update_subplot_args(plt, sp, kw, idx)
+        # # 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,
@@ -390,38 +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
 
-    # # everything is processed, time to compute the layout bounding boxes
-    # _before_layout_calcs(plt)
-    # w, h = plt.attr[:size]
-    # plt.layout.bbox = BoundingBox(0mm, 0mm, w*px, h*px)
-    # update_child_bboxes!(plt.layout)
-    #
-    # # TODO just need to pass plt... and we should do all non-series updates here
-    # _update_plot_object(plt)
+    # --------------------------------
 
     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)
@@ -429,86 +248,39 @@ function prepare_output(plt::Plot)
 
     w, h = plt.attr[:size]
     plt.layout.bbox = BoundingBox(0mm, 0mm, w*px, h*px)
+
+    # One pass down and back up the tree to compute the minimum padding
+    # of the children on the perimeter.  This is an backend callback.
+    _update_min_padding!(plt.layout)
+    for sp in plt.inset_subplots
+        _update_min_padding!(sp)
+    end
+
+    # now another pass down, to update the bounding boxes
     update_child_bboxes!(plt.layout)
 
+    # update those bounding boxes of inset subplots
+    update_inset_bboxes!(plt)
+
+    # the backend callback, to reposition subplots, etc
     _update_plot_object(plt)
 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/plotattr.jl

@@ -0,0 +1,56 @@
+
+const _attribute_defaults =  Dict(:Series => _series_defaults,
+                        :Subplot => _subplot_defaults,
+                        :Plot => _plot_defaults,
+                        :Axis => _axis_defaults)
+
+attrtypes() = join(keys(_attribute_defaults), ", ")
+attributes(attrtype::Symbol) = sort(collect(keys(_attribute_defaults[attrtype])))
+
+function lookup_aliases(attrtype, attribute)
+    attribute = Symbol(attribute)
+    attribute = in(attribute, keys(_keyAliases)) ? _keyAliases[attribute] : attribute
+    in(attribute, keys(_attribute_defaults[attrtype])) && return attribute
+    error("There is no attribute named $attribute in $attrtype")
+end
+
+function plotattr()
+    println("Specify an attribute type to get a list of supported attributes. Options are $(attrtypes())")
+end
+
+function plotattr(attrtype::Symbol)
+    in(attrtype, keys(_attribute_defaults)) || error("Viable options are $(attrtypes())")
+    println("Defined $attrtype attributes are:\n$(join(attributes(attrtype), ", "))")
+end
+
+function plotattr(attribute::AbstractString)
+    attribute = Symbol(attribute)
+    attribute = in(attribute, keys(_keyAliases)) ? _keyAliases[attribute] : attribute
+    for (k, v) in _attribute_defaults
+        if in(attribute, keys(v))
+            return plotattr(k, "$attribute")
+        end
+    end
+    error("There is no attribute named $attribute")
+end
+
+function plotattr(attrtype::Symbol, attribute::AbstractString)
+    in(attrtype, keys(_attribute_defaults)) || ArgumentError("`attrtype` must match one of $(attrtypes())")
+
+    attribute = Symbol(lookup_aliases(attrtype, attribute))
+
+    desc = get(_arg_desc, attribute, "")
+    first_period_idx = findfirst(desc, '.')
+    typedesc = desc[1:first_period_idx-1]
+    desc = strip(desc[first_period_idx+1:end])
+    als = keys(filter((_,v)->v==attribute, _keyAliases)) |> collect |> sort
+    als = join(map(string,als), ", ")
+    def = _attribute_defaults[attrtype][attribute]
+
+
+    # Looks up the different elements and plots them
+    println("$attribute ", typedesc == "" ? "" : "{$typedesc}", "\n",
+        als == "" ? "" : "$als\n",
+        "\n$desc\n",
+        "$(attrtype) attribute, ", def == "" ? "" : " default: $def")
+end

src/precompile.jl

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

src/series.jl

@@ -0,0 +1,520 @@
+
+
+# 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{F} Union{F, Vector{F}, Matrix{F}}
+
+all3D(d::KW) = trueOrAllTrue(st -> st in (:contour, :contourf, :heatmap, :surface, :wireframe, :contour3d, :image), get(d, :seriestype, :none))
+
+# missing
+convertToAnyVector(v::Void, d::KW) = Any[nothing], nothing
+
+# fixed number of blank series
+convertToAnyVector(n::Integer, d::KW) = Any[zeros(0) for i in 1:n], nothing
+
+# numeric vector
+convertToAnyVector{T<:Number}(v::AVec{T}, d::KW) = Any[v], nothing
+
+# string vector
+convertToAnyVector{T<:AbstractString}(v::AVec{T}, d::KW) = Any[v], nothing
+
+function convertToAnyVector(v::AMat, d::KW)
+    if all3D(d)
+        Any[Surface(v)]
+    else
+        Any[v[:,i] for i in 1:size(v,2)]
+    end, nothing
+end
+
+# function
+convertToAnyVector(f::Function, d::KW) = Any[f], nothing
+
+# surface
+convertToAnyVector(s::Surface, d::KW) = Any[s], nothing
+
+# volume
+convertToAnyVector(v::Volume, d::KW) = Any[v], nothing
+
+# # vector of OHLC
+# convertToAnyVector(v::AVec{OHLC}, d::KW) = Any[v], nothing
+
+# # dates
+# convertToAnyVector{D<:Union{Date,DateTime}}(dts::AVec{D}, d::KW) = Any[dts], nothing
+
+# list of things (maybe other vectors, functions, or something else)
+function convertToAnyVector(v::AVec, d::KW)
+    if all(x -> typeof(x) <: Number, v)
+        # all real numbers wrap the whole vector as one item
+        Any[convert(Vector{Float64}, v)], nothing
+    else
+        # something else... treat each element as an item
+        vcat(Any[convertToAnyVector(vi, d)[1] for vi in v]...), nothing
+        # Any[vi for vi in v], nothing
+    end
+end
+
+convertToAnyVector(t::Tuple, d::KW) = Any[t], nothing
+
+
+function convertToAnyVector(args...)
+    error("In convertToAnyVector, could not handle the argument types: $(map(typeof, args[1:end-1]))")
+end
+
+# --------------------------------------------------------------------
+
+# TODO: can we avoid the copy here?  one error that crops up is that mapping functions over the same array
+#       result in that array being shared.  push!, etc will add too many items to that array
+
+compute_x(x::Void, y::Void, z)      = 1:size(z,1)
+compute_x(x::Void, y, z)            = 1:size(y,1)
+compute_x(x::Function, y, z)        = map(x, y)
+compute_x(x, y, z)                  = copy(x)
+
+# compute_y(x::Void, y::Function, z)  = error()
+compute_y(x::Void, y::Void, z)      = 1:size(z,2)
+compute_y(x, y::Function, z)        = map(y, x)
+compute_y(x, y, z)                  = copy(y)
+
+compute_z(x, y, z::Function)        = map(z, x, y)
+compute_z(x, y, z::AbstractMatrix)  = Surface(z)
+compute_z(x, y, z::Void)            = nothing
+compute_z(x, y, z)                  = copy(z)
+
+nobigs(v::AVec{BigFloat}) = map(Float64, v)
+nobigs(v::AVec{BigInt}) = map(Int64, v)
+nobigs(v) = v
+
+@noinline function compute_xyz(x, y, z)
+    x = compute_x(x,y,z)
+    y = compute_y(x,y,z)
+    z = compute_z(x,y,z)
+    nobigs(x), nobigs(y), nobigs(z)
+end
+
+# not allowed
+compute_xyz{F<:Function}(x::Void, y::FuncOrFuncs{F}, z)       = error("If you want to plot the function `$y`, you need to define the x values!")
+compute_xyz{F<:Function}(x::Void, y::Void, z::FuncOrFuncs{F}) = error("If you want to plot the function `$z`, you need to define x and y values!")
+compute_xyz(x::Void, y::Void, z::Void)        = error("x/y/z are all nothing!")
+
+# --------------------------------------------------------------------
+
+
+# we are going to build recipes to do the processing and splitting of the args
+
+# ensure we dispatch to the slicer
+immutable SliceIt end
+
+# the catch-all recipes
+@recipe function f(::Type{SliceIt}, x, y, z)
+
+    # handle data with formatting attached
+    if typeof(x) <: Formatted
+        xformatter := x.formatter
+        x = x.data
+    end
+    if typeof(y) <: Formatted
+        yformatter := y.formatter
+        y = y.data
+    end
+    if typeof(z) <: Formatted
+        zformatter := z.formatter
+        z = z.data
+    end
+
+    xs, _ = convertToAnyVector(x, d)
+    ys, _ = convertToAnyVector(y, d)
+    zs, _ = convertToAnyVector(z, d)
+
+    fr = pop!(d, :fillrange, nothing)
+    fillranges, _ = if typeof(fr) <: Number
+        ([fr],nothing)
+    else
+        convertToAnyVector(fr, d)
+    end
+    mf = length(fillranges)
+
+    # @show zs
+
+    mx = length(xs)
+    my = length(ys)
+    mz = length(zs)
+    if mx > 0 && my > 0 && mz > 0
+        for i in 1:max(mx, my, mz)
+            # add a new series
+            di = copy(d)
+            xi, yi, zi = xs[mod1(i,mx)], ys[mod1(i,my)], zs[mod1(i,mz)]
+            di[:x], di[:y], di[:z] = compute_xyz(xi, yi, zi)
+
+            # handle fillrange
+            fr = fillranges[mod1(i,mf)]
+            di[:fillrange] = isa(fr, Function) ? map(fr, di[:x]) : fr
+
+            push!(series_list, RecipeData(di, ()))
+        end
+    end
+    nothing  # don't add a series for the main block
+end
+
+# this is the default "type recipe"... just pass the object through
+@recipe f{T<:Any}(::Type{T}, v::T) = v
+
+# this should catch unhandled "series recipes" and error with a nice message
+@recipe f{V<:Val}(::Type{V}, x, y, z) = error("The backend must not support the series type $V, and there isn't a series recipe defined.")
+
+_apply_type_recipe(d, v) = RecipesBase.apply_recipe(d, typeof(v), v)[1].args[1]
+
+# Handle type recipes when the recipe is defined on the elements.
+# This sort of recipe should return a pair of functions... one to convert to number,
+# and one to format tick values.
+function _apply_type_recipe(d, v::AbstractArray)
+    args = RecipesBase.apply_recipe(d, typeof(v[1]), v[1])[1].args
+    if length(args) == 2 && typeof(args[1]) <: Function && typeof(args[2]) <: Function
+        numfunc, formatter = args
+        Formatted(map(numfunc, v), formatter)
+    else
+        v
+    end
+end
+
+# # special handling for Surface... need to properly unwrap and re-wrap
+# function _apply_type_recipe(d, v::Surface)
+#     T = eltype(v.surf)
+#     @show T
+#     if T <: Integer || T <: AbstractFloat
+#         v
+#     else
+#         ret = _apply_type_recipe(d, v.surf)
+#         if typeof(ret) <: Formatted
+#             Formatted(Surface(ret.data), ret.formatter)
+#         else
+#             v
+#         end
+#     end
+# end
+
+# don't do anything for ints or floats
+_apply_type_recipe{T<:Union{Integer,AbstractFloat}}(d, v::AbstractArray{T}) = v
+
+# handle "type recipes" by converting inputs, and then either re-calling or slicing
+@recipe function f(x, y, z)
+    did_replace = false
+    newx = _apply_type_recipe(d, x)
+    x === newx || (did_replace = true)
+    newy = _apply_type_recipe(d, y)
+    y === newy || (did_replace = true)
+    newz = _apply_type_recipe(d, z)
+    z === newz || (did_replace = true)
+    if did_replace
+        newx, newy, newz
+    else
+        SliceIt, x, y, z
+    end
+end
+@recipe function f(x, y)
+    did_replace = false
+    newx = _apply_type_recipe(d, x)
+    x === newx || (did_replace = true)
+    newy = _apply_type_recipe(d, y)
+    y === newy || (did_replace = true)
+    if did_replace
+        newx, newy
+    else
+        SliceIt, x, y, nothing
+    end
+end
+@recipe function f(y)
+    newy = _apply_type_recipe(d, y)
+    if y !== newy
+        newy
+    else
+        SliceIt, nothing, y, nothing
+    end
+end
+
+# if there's more than 3 inputs, it can't be passed directly to SliceIt
+# so we'll apply_type_recipe to all of them
+@recipe function f(v1, v2, v3, v4, vrest...)
+    did_replace = false
+    newargs = map(v -> begin
+        newv = _apply_type_recipe(d, v)
+        if newv !== v
+            did_replace = true
+        end
+        newv
+    end, (v1, v2, v3, v4, vrest...))
+    if !did_replace
+        error("Couldn't process recipe args: $(map(typeof, (v1, v2, v3, v4, vrest...)))")
+    end
+    newargs
+end
+
+
+# # --------------------------------------------------------------------
+# # 1 argument
+# # --------------------------------------------------------------------
+
+# helper function to ensure relevant attributes are wrapped by Surface
+function wrap_surfaces(d::KW)
+    if haskey(d, :fill_z)
+        v = d[:fill_z]
+        if !isa(v, Surface)
+            d[:fill_z] = Surface(v)
+        end
+    end
+end
+
+@recipe f(n::Integer) = is3d(get(d,:seriestype,:path)) ? (SliceIt, n, n, n) : (SliceIt, n, n, nothing)
+
+# return a surface if this is a 3d plot, otherwise let it be sliced up
+@recipe function f{T<:Union{Integer,AbstractFloat}}(mat::AMat{T})
+    if all3D(d)
+        n,m = size(mat)
+        wrap_surfaces(d)
+        SliceIt, 1:m, 1:n, Surface(mat)
+    else
+        SliceIt, nothing, mat, nothing
+    end
+end
+
+# if a matrix is wrapped by Formatted, do similar logic, but wrap data with Surface
+@recipe function f{T<:AbstractMatrix}(fmt::Formatted{T})
+    if all3D(d)
+        mat = fmt.data
+        n,m = size(mat)
+        wrap_surfaces(d)
+        SliceIt, 1:m, 1:n, Formatted(Surface(mat), fmt.formatter)
+    else
+        SliceIt, nothing, fmt, nothing
+    end
+end
+
+# assume this is a Volume, so construct one
+@recipe function f{T<:Number}(vol::AbstractArray{T,3}, args...)
+    seriestype := :volume
+    SliceIt, nothing, Volume(vol, args...), nothing
+end
+
+
+# # images - grays
+
+@recipe function f{T<:Gray}(mat::AMat{T})
+    if is_seriestype_supported(:image)
+        seriestype := :image
+        n, m = size(mat)
+        SliceIt, 1:m, 1:n, Surface(mat)
+    else
+        seriestype := :heatmap
+        yflip --> true
+        fillcolor --> ColorGradient([:black, :white])
+        SliceIt, 1:m, 1:n, Surface(convert(Matrix{Float64}, mat))
+    end
+end
+
+# # images - colors
+
+@recipe function f{T<:Colorant}(mat::AMat{T})
+    if is_seriestype_supported(:image)
+        seriestype := :image
+        n, m = size(mat)
+        SliceIt, 1:m, 1:n, Surface(mat)
+    else
+        seriestype := :heatmap
+        yflip --> true
+        z, d[:fillcolor] = replace_image_with_heatmap(mat)
+        SliceIt, 1:m, 1:n, Surface(z)
+    end
+end
+
+#
+# # plotting arbitrary shapes/polygons
+
+@recipe function f(shape::Shape)
+    seriestype --> :shape
+    coords(shape)
+end
+
+@recipe function f(shapes::AVec{Shape})
+    seriestype --> :shape
+    coords(shapes)
+end
+
+@recipe function f(shapes::AMat{Shape})
+    seriestype --> :shape
+    for j in 1:size(shapes,2)
+        @series coords(vec(shapes[:,j]))
+    end
+end
+
+
+
+# function without range... use the current range of the x-axis
+
+@recipe function f{F<:Function}(f::FuncOrFuncs{F})
+    plt = d[:plot_object]
+    xmin, xmax = try
+        axis_limits(plt[1][:xaxis])
+    catch
+        -5, 5
+    end
+    f, xmin, xmax
+end
+
+#
+# # --------------------------------------------------------------------
+# # 2 arguments
+# # --------------------------------------------------------------------
+#
+#
+# # if functions come first, just swap the order (not to be confused with parametric functions...
+# # as there would be more than one function passed in)
+
+@recipe function f{F<:Function}(f::FuncOrFuncs{F}, x)
+    F2 = typeof(x)
+    @assert !(F2 <: Function || (F2 <: AbstractArray && F2.parameters[1] <: Function))  # otherwise we'd hit infinite recursion here
+    x, f
+end
+
+#
+# # --------------------------------------------------------------------
+# # 3 arguments
+# # --------------------------------------------------------------------
+#
+#
+# # 3d line or scatter
+
+@recipe function f(x::AVec, y::AVec, z::AVec)
+    # st = get(d, :seriestype, :none)
+    # if st == :scatter
+    #     d[:seriestype] = :scatter3d
+    # elseif !is3d(st)
+    #     d[:seriestype] = :path3d
+    # end
+    SliceIt, x, y, z
+end
+
+@recipe function f(x::AMat, y::AMat, z::AMat)
+    # st = get(d, :seriestype, :none)
+    # if size(x) == size(y) == size(z)
+    #     if !is3d(st)
+    #         seriestype := :path3d
+    #     end
+    # end
+    wrap_surfaces(d)
+    SliceIt, x, y, z
+end
+
+#
+# # surface-like... function
+
+@recipe function f(x::AVec, y::AVec, zf::Function)
+    # x = X <: Number ? sort(x) : x
+    # y = Y <: Number ? sort(y) : y
+    wrap_surfaces(d)
+    SliceIt, x, y, Surface(zf, x, y)  # TODO: replace with SurfaceFunction when supported
+end
+
+#
+# # surface-like... matrix grid
+
+@recipe function f(x::AVec, y::AVec, z::AMat)
+    if !like_surface(get(d, :seriestype, :none))
+        d[:seriestype] = :contour
+    end
+    wrap_surfaces(d)
+    SliceIt, x, y, Surface(z)
+end
+
+#
+#
+# # --------------------------------------------------------------------
+# # Parametric functions
+# # --------------------------------------------------------------------
+
+#
+# # special handling... xmin/xmax with parametric function(s)
+@recipe function f(f::Function, xmin::Number, xmax::Number)
+    xs = adapted_grid(f, (xmin, xmax))
+    xs, f
+end
+@recipe function f{F<:Function}(fs::AbstractArray{F}, xmin::Number, xmax::Number)
+    xs = Any[adapted_grid(f, (xmin, xmax)) for f in fs]
+    xs, fs
+end
+@recipe f{F<:Function,G<:Function}(fx::FuncOrFuncs{F}, fy::FuncOrFuncs{G}, u::AVec)  = mapFuncOrFuncs(fx, u), mapFuncOrFuncs(fy, u)
+@recipe f{F<:Function,G<:Function}(fx::FuncOrFuncs{F}, fy::FuncOrFuncs{G}, umin::Number, umax::Number, n = 200) = fx, fy, linspace(umin, umax, n)
+
+#
+# # special handling... 3D parametric function(s)
+@recipe function f{F<:Function,G<:Function,H<:Function}(fx::FuncOrFuncs{F}, fy::FuncOrFuncs{G}, fz::FuncOrFuncs{H}, u::AVec)
+    mapFuncOrFuncs(fx, u), mapFuncOrFuncs(fy, u), mapFuncOrFuncs(fz, u)
+end
+@recipe function f{F<:Function,G<:Function,H<:Function}(fx::FuncOrFuncs{F}, fy::FuncOrFuncs{G}, fz::FuncOrFuncs{H}, umin::Number, umax::Number, numPoints = 200)
+    fx, fy, fz, linspace(umin, umax, numPoints)
+end
+
+#
+#
+# # --------------------------------------------------------------------
+# # Lists of tuples and FixedSizeArrays
+# # --------------------------------------------------------------------
+#
+# # if we get an unhandled tuple, just splat it in
+@recipe f(tup::Tuple) = tup
+
+#
+# # (x,y) tuples
+@recipe f{R1<:Number,R2<:Number}(xy::AVec{Tuple{R1,R2}}) = unzip(xy)
+@recipe f{R1<:Number,R2<:Number}(xy::Tuple{R1,R2})       = [xy[1]], [xy[2]]
+
+#
+# # (x,y,z) tuples
+@recipe f{R1<:Number,R2<:Number,R3<:Number}(xyz::AVec{Tuple{R1,R2,R3}}) = unzip(xyz)
+@recipe f{R1<:Number,R2<:Number,R3<:Number}(xyz::Tuple{R1,R2,R3})       = [xyz[1]], [xyz[2]], [xyz[3]]
+
+# these might be points+velocity, or OHLC or something else
+@recipe f{R1<:Number,R2<:Number,R3<:Number,R4<:Number}(xyuv::AVec{Tuple{R1,R2,R3,R4}}) = get(d,:seriestype,:path)==:ohlc ? OHLC[OHLC(t...) for t in xyuv] : unzip(xyuv)
+@recipe f{R1<:Number,R2<:Number,R3<:Number,R4<:Number}(xyuv::Tuple{R1,R2,R3,R4})       = [xyuv[1]], [xyuv[2]], [xyuv[3]], [xyuv[4]]
+
+
+#
+# # 2D FixedSizeArrays
+@recipe f{T<:Number}(xy::AVec{FixedSizeArrays.Vec{2,T}}) = unzip(xy)
+@recipe f{T<:Number}(xy::FixedSizeArrays.Vec{2,T})       = [xy[1]], [xy[2]]
+
+#
+# # 3D FixedSizeArrays
+@recipe f{T<:Number}(xyz::AVec{FixedSizeArrays.Vec{3,T}}) = unzip(xyz)
+@recipe f{T<:Number}(xyz::FixedSizeArrays.Vec{3,T})       = [xyz[1]], [xyz[2]], [xyz[3]]
+
+#
+# # --------------------------------------------------------------------
+# # handle grouping
+# # --------------------------------------------------------------------
+
+# @recipe function f(groupby::GroupBy, args...)
+#     for (i,glab) in enumerate(groupby.groupLabels)
+#         # create a new series, with the label of the group, and an idxfilter (to be applied in slice_and_dice)
+#         # TODO: use @series instead
+#         @show i, glab, groupby.groupIds[i]
+#         di = copy(d)
+#         get!(di, :label, string(glab))
+#         get!(di, :idxfilter, groupby.groupIds[i])
+#         push!(series_list, RecipeData(di, args))
+#     end
+#     nothing
+# end
+
+# split the group into 1 series per group, and set the label and idxfilter for each
+@recipe function f(groupby::GroupBy, args...)
+    for (i,glab) in enumerate(groupby.groupLabels)
+        @series begin
+            label     --> string(glab)
+            idxfilter --> groupby.groupIds[i]
+            args
+        end
+    end
+end

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/series_new.jl

@@ -1,392 +0,0 @@
-
-# we are going to build recipes to do the processing and splitting of the args
-
-
-function _add_defaults!(d::KW, plt::Plot, sp::Subplot, commandIndex::Int)
-    pkg = plt.backend
-    globalIndex = d[:series_plotindex]
-
-    # add default values to our dictionary, being careful not to delete what we just added!
-    for (k,v) in _series_defaults
-        slice_arg!(d, d, k, v, commandIndex, remove_pair = false)
-    end
-
-    # this is how many series belong to this subplot
-    plotIndex = count(series -> series.d[:subplot] === sp && series.d[:primary], plt.series_list)
-    if get(d, :primary, true)
-        plotIndex += 1
-    end
-
-    aliasesAndAutopick(d, :linestyle, _styleAliases, supportedStyles(pkg), plotIndex)
-    aliasesAndAutopick(d, :markershape, _markerAliases, supportedMarkers(pkg), plotIndex)
-
-    # update color
-    d[:seriescolor] = getSeriesRGBColor(d[:seriescolor], sp, plotIndex)
-
-    # update colors
-    for csym in (:linecolor, :markercolor, :fillcolor)
-        d[csym] = if d[csym] == :match
-            if has_black_border_for_default(d[:seriestype]) && csym == :linecolor
-                :black
-            else
-                d[:seriescolor]
-            end
-        else
-            getSeriesRGBColor(d[csym], sp, plotIndex)
-        end
-    end
-
-    # update markerstrokecolor
-    c = d[:markerstrokecolor]
-    c = if c == :match
-        sp[:foreground_color_subplot]
-    else
-        getSeriesRGBColor(c, sp, plotIndex)
-    end
-    d[:markerstrokecolor] = c
-
-    # update alphas
-    for asym in (:linealpha, :markeralpha, :markerstrokealpha, :fillalpha)
-        if d[asym] == nothing
-            d[asym] = d[:seriesalpha]
-        end
-    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] = :ellipse
-        end
-    end
-
-    # set label
-    label = d[:label]
-    label = (label == "AUTO" ? "y$globalIndex" : label)
-    d[:label] = label
-
-    _replace_linewidth(d)
-    d
-end
-
-# -------------------------------------------------------------------
-# -------------------------------------------------------------------
-
-# instead of process_inputs:
-
-# ensure we dispatch to the slicer
-immutable SliceIt end
-
-# the catch-all recipes
-@recipe function f(::Type{SliceIt}, x, y, z)
-    # @show "HERE", typeof((x,y,z))
-    xs, _ = convertToAnyVector(x, d)
-    ys, _ = convertToAnyVector(y, d)
-    zs, _ = convertToAnyVector(z, d)
-
-    fr = pop!(d, :fillrange, nothing)
-    fillranges, _ = if typeof(fr) <: Number
-        ([fr],nothing)
-    else
-        convertToAnyVector(fr, d)
-    end
-    mf = length(fillranges)
-
-    # @show zs
-
-    mx = length(xs)
-    my = length(ys)
-    mz = length(zs)
-    # ret = Any[]
-    for i in 1:max(mx, my, mz)
-        # add a new series
-        di = copy(d)
-        xi, yi, zi = xs[mod1(i,mx)], ys[mod1(i,my)], zs[mod1(i,mz)]
-        # @show i, typeof((xi, yi, zi))
-        di[:x], di[:y], di[:z] = compute_xyz(xi, yi, zi)
-        # @show i, typeof((di[:x], di[:y], di[:z]))
-
-        # handle fillrange
-        fr = fillranges[mod1(i,mf)]
-        di[:fillrange] = isa(fr, Function) ? map(fr, di[:x]) : fr
-
-        # @show i, di[:x], di[:y], di[:z]
-        push!(series_list, RecipeData(di, ()))
-    end
-    nothing  # don't add a series for the main block
-end
-
-# this is the default "type recipe"... just pass the object through
-@recipe f{T}(::Type{T}, v::T) = v
-
-_apply_type_recipe(d, v) = RecipesBase.apply_recipe(d, typeof(v), v)[1].args[1]
-
-# handle "type recipes" by converting inputs, and then either re-calling or slicing
-@recipe function f(x, y, z)
-    did_replace = false
-    newx = _apply_type_recipe(d, x)
-    x === newx || (did_replace = true)
-    newy = _apply_type_recipe(d, y)
-    y === newy || (did_replace = true)
-    newz = _apply_type_recipe(d, z)
-    z === newz || (did_replace = true)
-    if did_replace
-        newx, newy, newz
-    else
-        SliceIt, x, y, z
-    end
-end
-@recipe function f(x, y)
-    did_replace = false
-    newx = _apply_type_recipe(d, x)
-    x === newx || (did_replace = true)
-    newy = _apply_type_recipe(d, y)
-    y === newy || (did_replace = true)
-    if did_replace
-        newx, newy
-    else
-        SliceIt, x, y, nothing
-    end
-end
-@recipe function f(y)
-    newy = _apply_type_recipe(d, y)
-    if y !== newy
-        newy
-    else
-        SliceIt, nothing, y, nothing
-    end
-end
-# @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
-
-# return a surface if this is a 3d plot, otherwise let it be sliced up
-@recipe function f{T<:Number}(mat::AMat{T})
-    if all3D(d)
-        n,m = size(mat)
-        SliceIt, 1:m, 1:n, Surface(mat)
-    else
-        SliceIt, nothing, mat, nothing
-    end
-end
-
-
-# # images - grays
-
-@recipe function f{T<:Gray}(mat::AMat{T})
-    if nativeImagesSupported()
-        seriestype := :image
-        n, m = size(mat)
-        SliceIt, 1:m, 1:n, Surface(mat)
-    else
-        seriestype := :heatmap
-        yflip --> true
-        fillcolor --> ColorGradient([:black, :white])
-        SliceIt, 1:m, 1:n, Surface(convert(Matrix{Float64}, mat))
-    end
-end
-
-# # images - colors
-
-@recipe function f{T<:Colorant}(mat::AMat{T})
-    if nativeImagesSupported()
-        seriestype := :image
-        n, m = size(mat)
-        SliceIt, 1:m, 1:n, Surface(mat)
-    else
-        seriestype := :heatmap
-        yflip --> true
-        z, d[:fillcolor] = replace_image_with_heatmap(mat)
-        SliceIt, 1:m, 1:n, Surface(z)
-    end
-end
-
-#
-# # plotting arbitrary shapes/polygons
-
-@recipe function f(shape::Shape)
-    seriestype := :shape
-    shape_coords(shape)
-end
-
-@recipe function f(shapes::AVec{Shape})
-    seriestype := :shape
-    shape_coords(shapes)
-end
-
-@recipe function f(shapes::AMat{Shape})
-    for j in 1:size(shapes,2)
-        # create one series for each column
-        # @series shape_coords(vec(shapes[:,j]))
-        di = copy(d)
-        push!(series_list, RecipeData(di, shape_coords(vec(shapes[:,j]))))
-    end
-    nothing # don't create a series for the main block
-end
-
-#
-#
-# # function without range... use the current range of the x-axis
-
-@recipe function f(f::FuncOrFuncs)
-    plt = d[:plot_object]
-    f, xmin(plt), xmax(plt)
-end
-
-#
-# # --------------------------------------------------------------------
-# # 2 arguments
-# # --------------------------------------------------------------------
-#
-#
-# # if functions come first, just swap the order (not to be confused with parametric functions...
-# # as there would be more than one function passed in)
-
-@recipe function f(f::FuncOrFuncs, x)
-    @assert !(typeof(x) <: FuncOrFuncs)  # otherwise we'd hit infinite recursion here
-    x, f
-end
-
-#
-# # --------------------------------------------------------------------
-# # 3 arguments
-# # --------------------------------------------------------------------
-#
-#
-# # 3d line or scatter
-
-@recipe function f(x::AVec, y::AVec, z::AVec)
-    st = get(d, :seriestype, :none)
-    if st == :scatter
-        d[:seriestype] = :scatter3d
-    elseif !is3d(st)
-        d[:seriestype] = :path3d
-    end
-    SliceIt, x, y, z
-end
-
-@recipe function f(x::AMat, y::AMat, z::AMat)
-    st = get(d, :seriestype, :none)
-    if size(x) == size(y) == size(z)
-        if !is3d(st)
-            seriestype := :path3d
-        end
-    end
-    SliceIt, x, y, z
-end
-
-#
-# # surface-like... function
-
-@recipe function f(x::AVec, y::AVec, zf::Function)
-    # x = X <: Number ? sort(x) : x
-    # y = Y <: Number ? sort(y) : y
-    SliceIt, x, y, Surface(zf, x, y)  # TODO: replace with SurfaceFunction when supported
-end
-
-#
-# # surface-like... matrix grid
-
-@recipe function f(x::AVec, y::AVec, z::AMat)
-    if !like_surface(get(d, :seriestype, :none))
-        d[:seriestype] = :contour
-    end
-    SliceIt, x, y, Surface(z)
-end
-
-#
-#
-# # --------------------------------------------------------------------
-# # Parametric functions
-# # --------------------------------------------------------------------
-
-#
-# # special handling... xmin/xmax with parametric function(s)
-@recipe f(f::FuncOrFuncs, xmin::Number, xmax::Number) = linspace(xmin, xmax, 100), f
-@recipe f(fx::FuncOrFuncs, fy::FuncOrFuncs, u::AVec)  = mapFuncOrFuncs(fx, u), mapFuncOrFuncs(fy, u)
-@recipe f(fx::FuncOrFuncs, fy::FuncOrFuncs, umin::Number, umax::Number, n = 200) = fx, fy, linspace(umin, umax, n)
-
-#
-# # special handling... 3D parametric function(s)
-@recipe function f(fx::FuncOrFuncs, fy::FuncOrFuncs, fz::FuncOrFuncs, u::AVec)
-    mapFuncOrFuncs(fx, u), mapFuncOrFuncs(fy, u), mapFuncOrFuncs(fz, u)
-end
-@recipe function f(fx::FuncOrFuncs, fy::FuncOrFuncs, fz::FuncOrFuncs, umin::Number, umax::Number, numPointsn = 200)
-    fx, fy, fz, linspace(umin, umax, numPoints)
-end
-
-#
-#
-# # --------------------------------------------------------------------
-# # Lists of tuples and FixedSizeArrays
-# # --------------------------------------------------------------------
-#
-# # if we get an unhandled tuple, just splat it in
-@recipe f(tup::Tuple) = tup
-
-#
-# # (x,y) tuples
-@recipe f{R1<:Number,R2<:Number}(xy::AVec{Tuple{R1,R2}}) = unzip(xy)
-@recipe f{R1<:Number,R2<:Number}(xy::Tuple{R1,R2})       = [xy[1]], [xy[2]]
-
-#
-# # (x,y,z) tuples
-@recipe f{R1<:Number,R2<:Number,R3<:Number}(xyz::AVec{Tuple{R1,R2,R3}}) = unzip(xyz)
-@recipe f{R1<:Number,R2<:Number,R3<:Number}(xyz::Tuple{R1,R2,R3})       = [xyz[1]], [xyz[2]], [xyz[3]]
-
-# these might be points+velocity, or OHLC or something else
-@recipe f{R1<:Number,R2<:Number,R3<:Number,R4<:Number}(xyuv::AVec{Tuple{R1,R2,R3,R4}}) = get(d,:seriestype,:path)==:ohlc ? OHLC[OHLC(t...) for t in xyuv] : unzip(xyuv)
-@recipe f{R1<:Number,R2<:Number,R3<:Number,R4<:Number}(xyuv::Tuple{R1,R2,R3,R4})       = [xyuv[1]], [xyuv[2]], [xyuv[3]], [xyuv[4]]
-
-
-#
-# # 2D FixedSizeArrays
-@recipe f{T<:Number}(xy::AVec{FixedSizeArrays.Vec{2,T}}) = unzip(xy)
-@recipe f{T<:Number}(xy::FixedSizeArrays.Vec{2,T})       = [xy[1]], [xy[2]]
-
-#
-# # 3D FixedSizeArrays
-@recipe f{T<:Number}(xyz::AVec{FixedSizeArrays.Vec{3,T}}) = unzip(xyz)
-@recipe f{T<:Number}(xyz::FixedSizeArrays.Vec{3,T})       = [xyz[1]], [xyz[2]], [xyz[3]]
-
-#
-# # --------------------------------------------------------------------
-# # handle grouping
-# # --------------------------------------------------------------------
-
-# @recipe function f(groupby::GroupBy, args...)
-#     for (i,glab) in enumerate(groupby.groupLabels)
-#         # create a new series, with the label of the group, and an idxfilter (to be applied in slice_and_dice)
-#         # TODO: use @series instead
-#         @show i, glab, groupby.groupIds[i]
-#         di = copy(d)
-#         get!(di, :label, string(glab))
-#         get!(di, :idxfilter, groupby.groupIds[i])
-#         push!(series_list, RecipeData(di, args))
-#     end
-#     nothing
-# end
-
-# split the group into 1 series per group, and set the label and idxfilter for each
-@recipe function f(groupby::GroupBy, args...)
-    for (i,glab) in enumerate(groupby.groupLabels)
-        @series begin
-            label     --> string(glab)
-            idxfilter --> groupby.groupIds[i]
-            args
-        end
-    end
-end
-

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,17 +31,18 @@ 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[:label] == "" || series.d[:seriestype] in (
-        :hexbin,:histogram2d,:hline,:vline,
-        :contour,:contour3d,:surface,:wireframe,
-        :heatmap,:path3d,:scatter3d, :pie, :image
-    ))
+    series.d[:primary] && series.d[:label] != "" &&
+        !(series.d[:seriestype] in (
+            :hexbin,:bins2d,:histogram2d,:hline,:vline,
+            :contour,:contourf,:contour3d,:surface,:wireframe,
+            :heatmap, :pie, :image
+        ))
 end
 
 # ----------------------------------------------------------------------

src/themes.jl

@@ -1,65 +1,42 @@
 
-const _invisible = RGBA(0,0,0,0)
+function theme(s::Symbol; kw...)
+    # reset?
+    if s == :none || s == :default
+        PlotUtils.clibrary(:Plots)
+        PlotUtils.default_cgrad(default = :sequential, sequential = :inferno)
+        default(;
+            bg        = :white,
+            bglegend  = :match,
+            bginside  = :match,
+            bgoutside = :match,
+            fg        = :auto,
+            fglegend  = :match,
+            fggrid    = :match,
+            fgaxis    = :match,
+            fgtext    = :match,
+            fgborder  = :match,
+            fgguide   = :match,
+            palette   = :auto
+        )
+        return
+    end
 
-const _themes = KW(
-    :default => KW(
-        :bg         => :white,
-        :bglegend   => :match,
-        :bginside   => :match,
-        :bgoutside  => :match,
-        :fg         => :auto,
-        :fglegend   => :match,
-        :fggrid     => :match,
-        :fgaxis     => :match,
-        :fgtext     => :match,
-        :fgborder   => :match,
-        :fgguide    => :match,
+    # update the default gradient and other defaults
+    thm = PlotThemes._themes[s]
+    if thm.gradient != nothing
+        PlotUtils.clibrary(:misc)
+        PlotUtils.default_cgrad(default = :sequential, sequential = PlotThemes.gradient_name(s))
+    end
+    default(;
+        bg       = thm.bg_secondary,
+        bginside = thm.bg_primary,
+        fg       = thm.lines,
+        fgtext   = thm.text,
+        fgguide  = thm.text,
+        fglegend = thm.text,
+        palette  = thm.palette,
+        kw...
     )
-)
-
-function add_theme(sym::Symbol, theme::KW)
-    _themes[sym] = theme
 end
 
-# add a new theme, using an existing theme as the base
-function add_theme(sym::Symbol;
-                   base      = :default,  # start with this theme
-                   bg        = _themes[base][:bg],
-                   bglegend  = _themes[base][:bglegend],
-                   bginside  = _themes[base][:bginside],
-                   bgoutside = _themes[base][:bgoutside],
-                   fg        = _themes[base][:fg],
-                   fglegend  = _themes[base][:fglegend],
-                   fggrid    = _themes[base][:fggrid],
-                   fgaxis    = _themes[base][:fgaxis],
-                   fgtext    = _themes[base][:fgtext],
-                   fgborder  = _themes[base][:fgborder],
-                   fgguide   = _themes[base][:fgguide],
-                   kw...)
-    _themes[sym] = merge(KW(
-        :bg => bg,
-        :bglegend  => bglegend,
-        :bginside  => bginside,
-        :bgoutside => bgoutside,
-        :fg        => fg,
-        :fglegend  => fglegend,
-        :fggrid    => fggrid,
-        :fgaxis    => fgaxis,
-        :fgtext    => fgtext,
-        :fgborder  => fgborder,
-        :fgguide   => fgguide,
-    ), KW(kw))
-end
-
-add_theme(:ggplot2,
-    bglegend = _invisible,
-    bginside = :lightgray,
-    fg       = :white,
-    fglegend = _invisible,
-    fgtext   = :gray,
-    fgguide  = :black
-)
-
-function set_theme(sym::Symbol)
-    default(; _themes[sym]...)
-end
+@deprecate set_theme(s) theme(s)

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
@@ -73,20 +77,31 @@ type Plot{T<:AbstractBackend} <: AbstractPlot{T}
     subplots::Vector{Subplot}
     spmap::SubplotMap            # provide any label as a map to a subplot
     layout::AbstractLayout
+    inset_subplots::Vector{Subplot}  # list of inset subplots
     init::Bool
 end
 
 function Plot()
     Plot(backend(), 0, KW(), KW(), Series[], nothing,
-         Subplot[], SubplotMap(), EmptyLayout(), false)
+         Subplot[], SubplotMap(), EmptyLayout(),
+         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,30 +131,141 @@ function replace_image_with_heatmap{T<:Colorant}(z::Array{T})
 end
 
 function imageHack(d::KW)
-    :heatmap in supportedTypes() || 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
+    n::Int
+end
+function iter_segments(args...)
+    tup = Plots.wraptuple(args)
+    n = maximum(map(length, tup))
+    SegmentsIterator(tup, n)
+end
+
+# helpers to figure out if there are NaN values in a list of array types
+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)
+
+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)
+            # done... array end or found NaN
+            iend = i-1
+            break
+        end
+        i += 1
+    end
+
+    # find the next non-NaN, and set nextidx
+    while i <= itr.n
+        if !anynan(i, itr.args)
+            break
+        end
+        i += 1
+    end
+
+    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")
 
-get_mod(v::AVec, idx::Int) = v[mod1(idx, length(v))]
-get_mod(v::AMat, idx::Int) = size(v,1) == 1 ? v[1, mod1(idx, size(v,2))] : v[:, mod1(idx, size(v,2))]
-get_mod(v, idx::Int)       = v
+isnothing(x::Void) = true
+isnothing(x) = false
+
+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]
@@ -181,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...)
@@ -199,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
 
@@ -232,6 +340,27 @@ function heatmap_edges(v::AVec)
 end
 
 
+function calc_r_extrema(x, y)
+    xmin, xmax = extrema(x)
+    ymin, ymax = extrema(y)
+    r = 0.5 * min(xmax - xmin, ymax - ymin)
+    extrema(r)
+end
+
+function convert_to_polar(x, y, r_extrema = calc_r_extrema(x, y))
+    rmin, rmax = r_extrema
+    phi, r = x, y
+    r = 0.5 * (r - rmin) / (rmax - rmin)
+    n = max(length(phi), length(r))
+    x = zeros(n)
+    y = zeros(n)
+    for i in 1:n
+        x[i] = cycle(r,i) * cos(cycle(phi,i))
+        y[i] = cycle(r,i) * sin(cycle(phi,i))
+    end
+    x, y
+end
+
 function fakedata(sz...)
   y = zeros(sz...)
   for r in 2:size(y,1)
@@ -260,17 +389,19 @@ ismatrix(::Any)  = false
 isscalar(::Real) = true
 isscalar(::Any)  = false
 
+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
 
@@ -285,6 +416,30 @@ Base.merge(a::AbstractVector, b::AbstractVector) = sort(unique(vcat(a,b)))
 nanpush!(a::AbstractVector, b) = (push!(a, NaN); push!(a, b))
 nanappend!(a::AbstractVector, b) = (push!(a, NaN); append!(a, b))
 
+function nansplit(v::AVec)
+    vs = Vector{eltype(v)}[]
+    while true
+        idx = findfirst(isnan, v)
+        if idx <= 0
+            # no nans
+            push!(vs, v)
+            break
+        elseif idx > 1
+            push!(vs, v[1:idx-1])
+        end
+        v = v[idx+1:end]
+    end
+    vs
+end
+
+function nanvcat(vs::AVec)
+    v_out = zeros(0)
+    for v in vs
+        nanappend!(v_out, v)
+    end
+    v_out
+end
+
 # given an array of discrete values, turn it into an array of indices of the unique values
 # returns the array of indices (znew) and a vector of unique values (vals)
 function indices_and_unique_values(z::AbstractArray)
@@ -297,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
@@ -313,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
@@ -328,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)
@@ -338,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)
@@ -500,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], xy[1])
-    expand_extrema!(sp.attr[:yaxis], xy[2])
-    expand_extrema!(sp.attr[:zaxis], xy[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.0"
+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,21 +43,24 @@ 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
 
-    reffn = nothing
     newdir = joinpath(refdir, string(_current_plots_version))
     newfn = joinpath(newdir, fn)
+
+    # figure out which reference file we should compare to, by finding the highest versioned file
+    reffn = nothing
     for v in versions
-        try
-            tmpfn = joinpath(refdir, string(v), fn)
-            # @show "trying", tmpfn
-            f = open(tmpfn)
+        tmpfn = joinpath(refdir, string(v), fn)
+        if isfile(tmpfn)
             reffn = tmpfn
+            break
         end
     end
 
@@ -73,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=[6,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")