gr extrema fix; themes gradient_name fix

gr: changed heatmap code

.gitignore

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

.travis.yml

@@ -4,9 +4,11 @@ os:
   - linux
   - osx
 julia:
-  - 0.4
-  #- nightly
-
+  - 0.5
+  - nightly
+matrix:
+  allow_failures:
+    - julia: nightly
 
 # # before install:
 # #   - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew update          ; fi

NEWS.md

@@ -0,0 +1,406 @@
+
+# Plots.jl NEWS
+
+#### notes on release changes, ongoing development, and future planned work
+
+- All new development should target 0.9!
+- Minor version 0.8 is the last one to support Julia 0.4!!
+	- Critical bugfixes only
+    - `backports` branch is for Julia 0.4
+
+---
+
+## 0.9 (current master/dev)
+
+#### 0.9.5
+
+- added dependency on PlotThemes
+- set_theme --> theme
+- remove Compat from REQUIRE
+- warning for DataFrames without StatPlots
+- closeall exported and implemented for gr/pyplot
+- fix DateTime recipe
+- reset theme with theme(:none)
+- fix link_axes! for nested subplots
+- fix plotly lims for log scale
+
+#### 0.9.4
+
+- optimizations surrounding Subplot.series_list
+- better Atom support, support plotlyjs
+- gr:
+    - gks_wstype defaults and gr_set_output
+    - heatmap uses GR.drawimage
+- histogram2d puts NaN for zeros
+- improved support of NaN in heatmaps
+- rebuilt spy recipes to output scatters with marker_z set
+- deprecate png support in plotly... point to plotlyjs
+- fixes:
+    - axis widen with lims set
+    - reset_extrema, setxyz
+    - bar plot widen
+    - better tick padding
+    - consistent tick rotation
+    - consistent aspect_ratio
+    - pyplot dpi
+    - plotly horizontal bars
+    - handle series attributes when combining subplots
+    - gr images transposed
+    - converted Date/DateTime to new type recipe approach for arrays
+- issues closed include: #505 #513 #479 #523 #526 #529
+
+#### 0.9.3
+
+- support pdf and eps in plotlyjs backend
+- allow curly after grid: `@layout [a b; grid(4,4){0.8h}]`
+- add_backend redesign
+
+#### 0.9.2
+
+- glvisualize backend (@SimonDanisch)
+    - too much to list! ready for alpha testing
+- Volume and volume seriestype
+- Atom: support for PlotPane and proper gui display
+- gr:
+    - clims
+    - aspect ratio
+- pgfplots:
+    - fixes for ticks, axes, and more
+- pyplot:
+    - font families
+    - colorbar guide
+    - pixel marker
+- unicodeplots
+    - basic support for shapes
+- improved add_backend
+- refactor of is_supported methods
+- element-wise type recipes (see https://github.com/tbreloff/Plots.jl/issues/460#issuecomment-248428908)
+- several other fixes/improvements
+
+#### 0.9.1
+
+- Pkg.dir --> dirname (@tkelman)
+- `axis = nothing` magic
+- fixes:
+    - clim for line_z
+    - sticks default range for log scale
+    - rotate method
+    - pyplot heatmap
+    - spurious scale warnings
+    - gr image/alpha
+    - plotly.js path
+    - orientation extrema
+    - bar, reset orientation
+- switch transpose_z to use permutedims
+- skinny x/+ markers
+- ticks in pgfplots
+- eps in savefig (@anriseth)
+- add_backend convenience
+- type recipes for Date/DateTime (@maximsch2)
+- mirror attribute and twinx convenience
+- Axis.sp --> Axis.sps
+- recipe postprocessing for allowing aliases and magic args in recipe bodies
+
+
+
+#### 0.9.0
+
+- fixes to cycle
+- add back single function recipe: `plot!(cos)`
+- new axis formatter attribute... accepts functions to convert numbers to strings
+- fix for inset plots
+- GR:
+	- fillrange fix
+	- annotations fix
+	- force double buffering in display
+
+---
+
+## 0.8
+
+#### 0.8.2 (backported bug fixes for julia 0.4)
+
+- plotly ticks fix
+- unicodeplots size fix
+- remove mkdir call in tests
+
+#### 0.8.1
+
+- manual drawing of axes/ticks/labels
+- get_ticks uses optimize_ticks and Showoff
+- changed PLOTS_DEFAULTS to be a global variable, not ENV key
+- parameterized Segments for pushing tuples
+- fix to axis extrema for Bool/nothing
+- GR:
+	- manually draw 2D axes... fixes several issues and missing features
+	- fontsize fix
+- PGFPlots: pass axis syle
+
+#### 0.8.0
+
+- added dependency on PlotUtils
+- BREAKING: removed DataFrames support (now in StatPlots.jl)
+- BREAKING: removed boxplot/violin/density recipes (now in StatPlots.jl)
+- GR:
+    - inline iterm2 support
+    - trisurface support
+    - heatmap fix
+- PyPlot:
+    - ijulia display fix
+- GLVisualize:
+    - first try with shapes
+- iter_segments improvements
+- bar_width support
+- horizontal bars
+- improve tick display
+- better shape handling in pyplot, plotly
+- improved padding calcs
+- internal reorg of _plots method, add pipeline.jl
+
+---
+
+## 0.7
+
+#### 0.7.5
+
+- GR: LaTeX support
+- Changed docs url to juliaplots.github.io
+- added `contourf` seriestype
+- allow `plt[1]` to return first Subplot
+- allow `sp[1]` to return the first Series of the Subplot
+- `series[k]` now passes through to `series.d[k]`
+- allow calling `plot!(sp, ...)` to update a target Subplot
+- PyPlot: zorder fix
+- new DataFrames logic/recipe: more flexible/robust and allow Symbols for:
+	- `(:fillrange, :line_z, :marker_z, :markersize, :ribbon, :weights, :xerror, :yerror)`
+- new `display_type` and `extra_kwargs` plot attributes
+- surface fix
+
+#### 0.7.4
+
+- added snooped precompiles, but left commented out
+- GR fixes: markersize, shapes, legends
+- fixes to recipes
+- turned on Appveyor
+
+#### 0.7.3
+
+- rebuild violin and boxplot recipes
+- "plot recipes"
+- `cgrad` method for easy color gradient creation
+- improvements to inset subplots
+- Segments and iter_segments for NaN-separated vectors
+- `bar` recipe now creates a `shape` series
+- writemime fix for Interact.jl
+- `link = :square` option
+- !!! set `shape` attributes with line/fill, NOT marker/markerstroke !!!
+- basic DPI support
+- moved chorddiagram to PlotRecipes
+- GR:
+	- use temp files for img output
+	- basic support for marker strokes and other marker fixes
+- PyPlot:
+	- Switch to recipes for bar, histogram, histogram2d
+- GLVisualize
+	- subplots
+	- path/scatter and path3d/scatter3d
+	- initial drawing of axes
+- many smaller fixes and improvements
+
+#### 0.7.2
+
+- line_z arg for multicolored line segments
+- pyplot
+	- line_z (2d and 3d)
+	- pushed all fig updates into display pipeline
+	- remove native sticks/hline/vline in favor of recipes
+- unicodeplots cleanup, ijulia fixes, ascii canvas
+- `curves` series type
+- `iter_segments` iterator
+- moved arcdiagram out and into PlotRecipes (thanks @diegozea)
+- several other fixes/checks
+
+#### 0.7.1
+
+- inset (floating) subplots
+- change: when setting subplot/axis args from user recipes, they should apply only to their own subplot
+- trim for violin/boxplot
+- scatter3d recipe
+- removed plotly.js in favor of build.jl download
+- improvements/fixes to pgfplots backend
+- improvements/fixes to plotly/plotlyjs backends
+	- titles are annotations and properly placed with title_position
+	- hover attribute
+	- shapes (almost)
+	- scattergl
+- minimum perimeter logic in layout calc... fixed misaligned subplots
+- new clims attribute
+- more options for test_examples
+- GR refactor
+	- added transparency
+	- moved axis/grid logic out of series loop
+	- generalized 3d and polar projections
+- renamed get_mod to Base.cycle
+- pyplot log scale fixes
+- PLOTS_DEFAULTS environment var processing
+- rename :ellipse to :circle, :ellipse is now an alias
+- supported args/types cleanup
+- seriestype dependency methods and `@deps` macro
+- bbox `h_anchor`/`v_anchor`
+- new axis arg: `:link` is a list of subplots to link axes with
+- cleanup/simplification of glvisualize backend
+
+
+#### 0.7.0
+
+- Check out [the summary](http://juliaplots.github.io/plots_v0.7/)
+- Revamped and simplified internals
+- [Recipes, recipes, recipes](https://github.com/JuliaPlots/RecipesBase.jl/issues/6)
+- [Layouts and Subplots](https://github.com/tbreloff/Plots.jl/issues/60)
+- DataFrames is loaded automatically when installed
+- Overhaul to GroupBy mechanic (now offloads to a recipe)
+- Replaced much of the argument processing with recipes
+- Added series recipes, and began to strip down un-needed backend code.  Some recipes:
+	- line, step, sticks, bar, histogram, histogram2d, boxplot, violin, quiver, errorbars, density, ohlc
+- Added `@shorthands` and `@userplot` macros for recipe convenience
+- Better handling of errorbars and ribbons
+- New Axis type
+	- Tracks extrema and discrete values
+	- New `link_axes` functionality
+- `linetype` has been renamed `seriestype` (the alias is reversed)
+- Many fixes and huge cleanup in GR
+- Brand new subplot layout mechanics:
+	- `@layout` macro
+	- AbstractLayout, Subplot, GridLayout, and everything related
+	- Added dependency on Measures.jl
+	- Computations of axis/guide sizes and precise positioning
+- Refactored and compartmentalized default dictionaries for attributes
+- Deprecated Gadfly and Immerse backends
+- Added `series_annotations` attribute (previously that functionality was merged with `annotations`, which are not series-specific)
+- Removed `axis` attribute... currently not supporting twin (right) y axes
+- Check for `ENV["PLOTS_USE_ATOM_PLOTPANE"]` and default to false
+- Improved backend interface to reduce redundant code.  Template updated.
+- Added `html_output_format`, primarily for choosing between png and svg output in IJulia.
+- Partial support of Julia v0.5
+- Switched testing to dump reference images to JuliaPlots/PlotReferenceImages.jl
+- Moved docs-specific code to new JuliaPlots/PlotDocs.jl
+- Moved example list from ExamplePlots into Plots.
+- Added several examples and improved others.
+- Many other smaller changes and bug fixes.
+
+
+---
+
+## Version 0.6
+
+#### 0.6.2
+
+- `linewidth` fixes
+- `markershape` fix
+- converted center calc to centroid for shapes
+- new dependency on [RecipesBase](https://github.com/JuliaPlots/RecipesBase.jl)
+- REQUIRE upper limit for RecipesBase: 0.0.1
+- GR fixes/improvements (@jheinen)
+  - support `zlims`, `bins`
+  - allow Plots colormaps
+  - other bug fixes
+  - native image support
+- PGFPlots fixes/improvements (@pkofod)
+- DataFrames are handled by recipes
+- Plotly: zaxis, tick rotation, 3d axis fix
+- Improvements in handling discrete data
+- Support for image display
+- `arrow` keyword and support for adding arrows to paths
+- changed quiver recipe to use arrows
+- Bug fixes for boxplots, heatmaps, and more
+
+#### 0.6.1
+
+- `rotation` keyword
+- improved supported graphs
+- subplot bug fix
+
+#### 0.6.0
+
+- `apply_series_recipe` framework for built-in recipes
+- [boxplot/violin recipes](https://github.com/tbreloff/ExamplePlots.jl/blob/master/notebooks/boxplot.ipynb)
+- [errorbar/ribbon recipes](https://github.com/tbreloff/ExamplePlots.jl/blob/master/notebooks/errorbars.ipynb)
+- [quiver recipe](https://github.com/tbreloff/ExamplePlots.jl/blob/master/notebooks/quiver.ipynb)
+- `polar` coordinates
+- better support for shapes and custom polygons (see [batman](https://github.com/tbreloff/ExamplePlots.jl/blob/master/notebooks/batman.ipynb))
+- z-axis keywords
+- 3D indexing overhaul: `push!`, `append!` support
+- matplotlib colormap constants (`:inferno` is the new default colormap for Plots)
+- `typealias KW Dict{Symbol,Any}` used in place of splatting in many places
+- png generation for plotly backend using wkhtmltoimage
+- `normalize` and `weights` keywords
+- background/foreground subcategories for fine-tuning of looks
+- `add_theme`/`set_theme` and ggplot2 theme (see [this issue](https://github.com/tbreloff/Plots.jl/issues/201))
+- `PLOTS_DEFAULT_BACKEND` environment variable
+- `barh` linetype
+- support for non-gridded surfaces with pyplot's trisurface
+- pyplot surface zcolor
+- internal refactor of supported.jl
+- `wrap` method to bypass input processing
+- `translate`, `scale` and `rotate` methods for coordinates and shapes
+- and many more minor fixes and improvements
+
+---
+
+## Version 0.5
+
+#### 0.5.4
+
+- old heatmaps have been renamed to hist2d, and true heatmaps implemented (see https://github.com/tbreloff/Plots.jl/issues/147)
+- lots of reorganization and redesign of the internals
+- lots of renaming to keep to conventions: AbstractPlot, AbstractBackend, etc
+- initial redesign of layouts
+- integration with Atom PlotPane
+- arc diagram and chord diagram (thanks to @diegozea: see https://github.com/tbreloff/Plots.jl/issues/163)
+- work on GR, GLVisualize, and PGFPlots backends (thanks @jheinen @dlfivefifty @pkofod)
+- improvements to Plotly setup (thanks @spencerlyon2)
+- overhaul to series creation logic and groupby mechanic
+- replace Dict with `typealias KW Dict{Symbol,Any}` in many places, also replacing keyword arg splatting
+- new `shape` linetype for plotting polygons in plot-coordinates (see https://github.com/tbreloff/ExamplePlots.jl/blob/master/notebooks/batman.ipynb)
+- many other fixes
+
+#### 0.5.3
+
+- `@gif` macro with `every`/`when` syntax
+- bezier curves and other graph drawing helpers
+- added FixedSizeArrays dependency with relevant functionality
+- merged lots of improvements to GR (thanks @jheinen)
+- `overwrite_figure`/`reuse` arg for reusing the same figure window
+- deprecated Qwt, Winston, and Bokeh backends
+- improved handling of 3D inputs (call `z=rand(10,10); surface(z)` for example)
+- fix IJulia display issue
+- lots of progress on PlotlyJS backend
+- and many other changes and fixes...
+
+#### 0.5.2
+
+- Added [GR.jl](https://github.com/jheinen/GR.jl) as a backend (unfinished but functional) All credit to @jheinen
+- Set defaults within backend calls (i.e. `gadfly(legend=false)`)
+- `abline!`; also extrema allows plotting functions without giving x (i.e. `plot(cos, 0, 10); plot!(sin)`) @pkofod @joshday
+- Integration with [PlotlyJS.jl](https://github.com/spencerlyon2/PlotlyJS.jl) for using Plotly inside a Blink window @spencerlyon2
+- The Plotly backend has been split into my built-in version (`plotly()`) and @spencerlyon2's backend (`plotlyjs()`)
+- Revamped backend setup code for easily adding new backends
+- New docs (WIP) at http://juliaplots.github.io/
+- Overhaul to `:legend` keyword (see https://github.com/tbreloff/Plots.jl/issues/135)
+- New dependency on Requires, allows auto-loading of DataFrames support
+- Support for plotting lists of Tuples and FixedSizeArrays
+- new `@animate` macro for super simple animations (see https://github.com/tbreloff/Plots.jl/issues/111#issuecomment-181515616)
+- allow Function for `:fillrange` and `zcolor` arguments (for example: `scatter(sin, 0:10, marker=15, fill=(cos,0.4), zcolor=sin)`)
+- allow vectors of PlotText without x/y coords (for example: `scatter(rand(10), m=20, ann=map(text, 1:10))`)
+- Lots and lots of fixes
+
+#### 0.5.1
+
+#### 0.5.0
+
+- `with` function for temporary defaults
+- contours
+- basic 3D plotting
+- preliminary support for Bokeh
+- `stroke` and `brush` for more fine-tuned control over visuals
+- smarter "magic" arguments: `line`, `marker`

README.md

@@ -12,24 +12,11 @@
 Plots is a plotting API and toolset.  My goals with the package are:
 
 - **Powerful**.  Do more with less.  Complex visualizations become easy.
-- **Intuitive**.  Start generating plots without reading volumes of documentation.  Commands should "just work".
+- **Intuitive**.  Stop reading so much documentation.  Commands should "just work".
 - **Concise**.  Less code means fewer mistakes and more efficient development/analysis.
 - **Flexible**.  Produce your favorite plots from your favorite package, but quicker and simpler.
-- **Consistent**.  Don't commit to one graphics package.  Use the same code and access the strengths of all [backends](http://plots.readthedocs.io/en/latest/backends/).
-- **Lightweight**.  Very few dependencies, since backends are loaded and initialized dynamically.
+- **Consistent**.  Don't commit to one graphics package, use the same code everywhere.
+- **Lightweight**.  Very few dependencies.
+- **Smart**. Attempts to figure out what you **want** it to do... not just what you **tell** it.
 
-Use the [preprocessing pipeline](http://plots.readthedocs.io/en/latest/pipeline/) in Plots to fully describe your visualization before it calls the backend code.  This maintains modularity and allows for efficient separation of front end code, algorithms, and backend graphics.  New graphical backends can be added with minimal effort.
-
-```julia
-using Plots
-pyplot(reuse=true)
-
-@gif for i in linspace(0,2π,100)
-    X = Y = linspace(-5,5,40)
-    surface(X, Y, (x,y) -> sin(x+10sin(i))+cos(y))
-end
-```
-
-![waves](http://plots.readthedocs.io/en/latest/examples/img/waves.gif)
-
-View the [full documentation](http://plots.readthedocs.io).
+View the [full documentation](http://juliaplots.github.io).

REQUIRE

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

appveyor.yml

@@ -1,15 +1,10 @@
 environment:
   matrix:
-  - JULIAVERSION: "julialang/bin/winnt/x86/0.3/julia-0.3-latest-win32.exe"
-  - JULIAVERSION: "julialang/bin/winnt/x64/0.3/julia-0.3-latest-win64.exe"
+  - JULIAVERSION: "julialang/bin/winnt/x86/0.5/julia-0.5-latest-win32.exe"
+  - JULIAVERSION: "julialang/bin/winnt/x64/0.5/julia-0.5-latest-win64.exe"
   - JULIAVERSION: "julianightlies/bin/winnt/x86/julia-latest-win32.exe"
   - JULIAVERSION: "julianightlies/bin/winnt/x64/julia-latest-win64.exe"
 
-branches:
-  only:
-    - master
-    - /release-.*/
-
 notifications:
   - provider: Email
     on_build_success: false
@@ -17,18 +12,21 @@ notifications:
     on_build_status_changed: false
 
 install:
+# If there's a newer build queued for the same PR, cancel this one
+  - ps: if ($env:APPVEYOR_PULL_REQUEST_NUMBER -and $env:APPVEYOR_BUILD_NUMBER -ne ((Invoke-RestMethod `
+        https://ci.appveyor.com/api/projects/$env:APPVEYOR_ACCOUNT_NAME/$env:APPVEYOR_PROJECT_SLUG/history?recordsNumber=50).builds | `
+        Where-Object pullRequestId -eq $env:APPVEYOR_PULL_REQUEST_NUMBER)[0].buildNumber) { `
+        throw "There are newer queued builds for this pull request, failing early." }
 # Download most recent Julia Windows binary
-  - ps: (new-object net.webclient).DownloadFile(
-        $("http://s3.amazonaws.com/"+$env:JULIAVERSION),
-        "C:\projects\julia-binary.exe")
+  - ps: (new-object net.webclient).DownloadFile($("http://s3.amazonaws.com/"+$env:JULIAVERSION), "C:\projects\julia-binary.exe")
 # Run installer silently, output to C:\projects\julia
   - C:\projects\julia-binary.exe /S /D=C:\projects\julia
 
 build_script:
 # Need to convert from shallow to complete for Pkg.clone to work
   - IF EXIST .git\shallow (git fetch --unshallow)
-  - C:\projects\julia\bin\julia -e "versioninfo();
-      Pkg.clone(pwd(), \"Plots\"); Pkg.build(\"Plots\")"
+  - C:\projects\julia\bin\julia -e "versioninfo(); Pkg.clone(pwd(), \"Plots\"); Pkg.build(\"Plots\")"
 
 test_script:
-  - C:\projects\julia\bin\julia --check-bounds=yes -e "Pkg.test(\"Plots\")"
+  # - C:\projects\julia\bin\julia -e "Pkg.test(\"Plots\")"
+  - C:\projects\julia\bin\julia -e "include(Pkg.dir(\"Plots\", \"test\", \"travis_commands.jl\"))"

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,86 +1,50 @@
 
- __precompile__()
+__precompile__()
 
 module Plots
 
-using Compat
 using Reexport
-@reexport using Colors
-using Requires
 using FixedSizeArrays
+@reexport using RecipesBase
+using Base.Meta
+@reexport using PlotUtils
+@reexport using PlotThemes
+import Showoff
 
 export
     AbstractPlot,
     Plot,
     Subplot,
-    SubplotLayout,
+    AbstractLayout,
     GridLayout,
-    RowsLayout,
-    FlexLayout,
+    grid,
+    EmptyLayout,
+    bbox,
+    plotarea,
+    @layout,
     AVec,
     AMat,
     KW,
 
     wrap,
-    set_theme,
-    add_theme,
+    theme,
 
     plot,
     plot!,
-    subplot,
-    subplot!,
+    update!,
 
     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!,
@@ -96,42 +60,33 @@ export
     xaxis!,
     yaxis!,
 
+    xlims,
+    ylims,
+    zlims,
+
     savefig,
     png,
     gui,
+    closeall,
 
     backend,
     backends,
     backend_name,
+    backend_object,
+    add_backend,
     aliases,
-    dataframes,
 
     Shape,
     text,
     font,
+    Axis,
     stroke,
     brush,
     Surface,
     OHLC,
-
-    colorscheme,
-    ColorScheme,
-    ColorGradient,
-    ColorVector,
-    ColorWrapper,
-    ColorFunction,
-    ColorZFunction,
-    getColor,
-    getColorZ,
-
-    debugplots,
-
-    supportedArgs,
-    supportedAxes,
-    supportedTypes,
-    supportedStyles,
-    supportedMarkers,
-    subplotSupported,
+    arrow,
+    Segments,
+    Formatted,
 
     Animation,
     frame,
@@ -139,10 +94,9 @@ export
     @animate,
     @gif,
 
-    PlotRecipe,
-    spy,
-    arcdiagram,
-    chorddiagram,
+    test_examples,
+    iter_segments,
+    coords,
 
     translate,
     translate!,
@@ -157,69 +111,72 @@ export
 
 # ---------------------------------------------------------
 
+import Measures
+import Measures: Length, AbsoluteLength, Measure, BoundingBox, mm, cm, inch, pt, width, height, w, h
+typealias BBox Measures.Absolute2DBox
+export BBox, BoundingBox, mm, cm, inch, pt, px, pct, w, h
+
+# ---------------------------------------------------------
+
 include("types.jl")
 include("utils.jl")
-include("colors.jl")
 include("components.jl")
-include("backends.jl")
+include("axes.jl")
 include("args.jl")
+include("backends.jl")
+include("themes.jl")
 include("plot.jl")
-include("series_args.jl")
-include("subplot.jl")
+include("pipeline.jl")
+include("series.jl")
 include("layouts.jl")
+include("subplots.jl")
 include("recipes.jl")
 include("animation.jl")
 include("output.jl")
+include("examples.jl")
+include("arg_desc.jl")
 
 
 # ---------------------------------------------------------
 
-scatter(args...; kw...)    = plot(args...; kw...,  linetype = :scatter)
-scatter!(args...; kw...)   = plot!(args...; kw..., linetype = :scatter)
-bar(args...; kw...)        = plot(args...; kw...,  linetype = :bar)
-bar!(args...; kw...)       = plot!(args...; kw..., linetype = :bar)
-barh(args...; kw...)        = plot(args...; kw...,  linetype = :barh, orientation = :h)
-barh!(args...; kw...)       = plot!(args...; kw..., linetype = :barh, orientation = :h)
-histogram(args...; kw...)  = plot(args...; kw...,  linetype = :hist)
-histogram!(args...; kw...) = plot!(args...; kw..., linetype = :hist)
-histogram2d(args...; kw...)  = plot(args...; kw...,  linetype = :hist2d)
-histogram2d!(args...; kw...) = plot!(args...; kw..., linetype = :hist2d)
-density(args...; kw...)    = plot(args...; kw...,  linetype = :density)
-density!(args...; kw...)   = plot!(args...; kw..., linetype = :density)
-heatmap(args...; kw...)    = plot(args...; kw...,  linetype = :heatmap)
-heatmap!(args...; kw...)   = plot!(args...; kw..., linetype = :heatmap)
-hexbin(args...; kw...)     = plot(args...; kw...,  linetype = :hexbin)
-hexbin!(args...; kw...)    = plot!(args...; kw..., linetype = :hexbin)
-sticks(args...; kw...)     = plot(args...; kw...,  linetype = :sticks, marker = :ellipse)
-sticks!(args...; kw...)    = plot!(args...; kw..., linetype = :sticks, marker = :ellipse)
-hline(args...; kw...)      = plot(args...; kw...,  linetype = :hline)
-hline!(args...; kw...)     = plot!(args...; kw..., linetype = :hline)
-vline(args...; kw...)      = plot(args...; kw...,  linetype = :vline)
-vline!(args...; kw...)     = plot!(args...; kw..., linetype = :vline)
-ohlc(args...; kw...)       = plot(args...; kw...,  linetype = :ohlc)
-ohlc!(args...; kw...)      = plot!(args...; kw..., linetype = :ohlc)
-pie(args...; kw...)        = plot(args...; kw...,  linetype = :pie, aspect_ratio = :equal, grid=false, xticks=nothing, yticks=nothing)
-pie!(args...; kw...)       = plot!(args...; kw..., linetype = :pie, aspect_ratio = :equal, grid=false, xticks=nothing, yticks=nothing)
-contour(args...; kw...)    = plot(args...; kw...,  linetype = :contour)
-contour!(args...; kw...)   = plot!(args...; kw..., linetype = :contour)
-contour3d(args...; kw...)  = plot(args...; kw...,  linetype = :contour3d)
-contour3d!(args...; kw...) = plot!(args...; kw..., linetype = :contour3d)
-surface(args...; kw...)    = plot(args...; kw...,  linetype = :surface)
-surface!(args...; kw...)   = plot!(args...; kw..., linetype = :surface)
-wireframe(args...; kw...)  = plot(args...; kw...,  linetype = :wireframe)
-wireframe!(args...; kw...) = plot!(args...; kw..., linetype = :wireframe)
-path3d(args...; kw...)     = plot(args...; kw...,  linetype = :path3d)
-path3d!(args...; kw...)    = plot!(args...; kw..., linetype = :path3d)
-plot3d(args...; kw...)     = plot(args...; kw...,  linetype = :path3d)
-plot3d!(args...; kw...)    = plot!(args...; kw..., linetype = :path3d)
-scatter3d(args...; kw...)  = plot(args...; kw...,  linetype = :scatter3d)
-scatter3d!(args...; kw...) = plot!(args...; kw..., linetype = :scatter3d)
-boxplot(args...; kw...)    = plot(args...; kw...,  linetype = :box)
-boxplot!(args...; kw...)   = plot!(args...; kw..., linetype = :box)
-violin(args...; kw...)     = plot(args...; kw...,  linetype = :violin)
-violin!(args...; kw...)    = plot!(args...; kw..., linetype = :violin)
-quiver(args...; kw...)     = plot(args...; kw...,  linetype = :quiver)
-quiver!(args...; kw...)    = plot!(args...; kw..., linetype = :quiver)
+# define and export shorthand plotting method definitions
+macro shorthands(funcname::Symbol)
+    funcname2 = Symbol(funcname, "!")
+    esc(quote
+        export $funcname, $funcname2
+        $funcname(args...; kw...) = plot(args...; kw..., seriestype = $(quot(funcname)))
+        $funcname2(args...; kw...) = plot!(args...; kw..., seriestype = $(quot(funcname)))
+    end)
+end
+
+@shorthands scatter
+@shorthands bar
+@shorthands barh
+@shorthands histogram
+@shorthands histogram2d
+@shorthands density
+@shorthands heatmap
+@shorthands hexbin
+@shorthands sticks
+@shorthands hline
+@shorthands vline
+@shorthands ohlc
+@shorthands contour
+@shorthands contourf
+@shorthands contour3d
+@shorthands surface
+@shorthands wireframe
+@shorthands path3d
+@shorthands scatter3d
+@shorthands boxplot
+@shorthands violin
+@shorthands quiver
+@shorthands curves
+
+pie(args...; kw...)        = plot(args...; kw...,  seriestype = :pie, aspect_ratio = :equal, grid=false, xticks=nothing, yticks=nothing)
+pie!(args...; kw...)       = plot!(args...; kw..., seriestype = :pie, aspect_ratio = :equal, grid=false, xticks=nothing, yticks=nothing)
+plot3d(args...; kw...)     = plot(args...; kw...,  seriestype = :path3d)
+plot3d!(args...; kw...)    = plot!(args...; kw..., seriestype = :path3d)
 
 
 title!(s::AbstractString; kw...)                 = plot!(; title = s, kw...)
@@ -273,15 +230,14 @@ yaxis!(plt::Plot, args...; kw...)                                     = plot!(pl
 const CURRENT_BACKEND = CurrentBackend(:none)
 
 function __init__()
+    setup_ijulia()
+    setup_atom()
 
-  # override IJulia inline display
-  if isijulia()
-    @eval import IJulia
-    IJulia.display_dict(plt::AbstractPlot) = Dict{ASCIIString, ByteString}("text/html" => sprint(writemime, "text/html", plt))
-  end
-
-  setup_dataframes()
-  setup_atom()
+    if isdefined(Main, :PLOTS_DEFAULTS)
+        for (k,v) in Main.PLOTS_DEFAULTS
+            default(k, v)
+        end
+    end
 end
 
 # ---------------------------------------------------------

src/animation.jl

@@ -1,12 +1,12 @@
 
 immutable Animation
-  dir::ASCIIString
-  frames::Vector{ASCIIString}
+  dir::String
+  frames::Vector{String}
 end
 
 function Animation()
-  tmpdir = convert(ASCIIString, mktempdir())
-  Animation(tmpdir, ASCIIString[])
+  tmpdir = convert(String, mktempdir())
+  Animation(tmpdir, String[])
 end
 
 function frame{P<:AbstractPlot}(anim::Animation, plt::P=current())
@@ -21,23 +21,30 @@ end
 
 "Wraps the location of an animated gif so that it can be displayed"
 immutable AnimatedGif
-  filename::ASCIIString
+  filename::String
 end
 
-function gif(anim::Animation, fn::@compat(AbstractString) = "tmp.gif"; fps::Integer = 20)
+function gif(anim::Animation, fn = (isijulia() ? "tmp.gif" : tempname()*".gif"); fps::Integer = 20, loop::Integer = 0)
   fn = abspath(fn)
 
   try
 
     # high quality
     speed = round(Int, 100 / fps)
-    run(`convert -delay $speed -loop 0 $(anim.dir)/*.png -alpha off $fn`)
+    file = joinpath(Pkg.dir("ImageMagick"), "deps","deps.jl")
+    if isfile(file) && !haskey(ENV, "MAGICK_CONFIGURE_PATH")
+        include(file)
+    end
+    # prefix = get(ENV, "MAGICK_CONFIGURE_PATH", "")
+    run(`convert -delay $speed -loop $loop $(joinpath(anim.dir, "*.png")) -alpha off $fn`)
 
   catch err
-    warn("Tried to create gif using convert (ImageMagick), but got error: $err\nWill try ffmpeg, but it's lower quality...)")
+    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 0 -framerate $fps -loop $loop -i $(anim.dir)/%06d.png -y $fn`)
     # run(`ffmpeg -v warning -i  "fps=$fps,scale=320:-1:flags=lanczos"`)
   end
 
@@ -48,8 +55,8 @@ 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)
+    write(io, "<img src=\"$(relpath(agif.filename))?$(rand())>\" />")
 end
 
 

src/arg_desc.jl

@@ -0,0 +1,113 @@
+
+const _arg_desc = KW(
+
+# series args
+:label 				=> "String type. The label for a series, which appears in a legend.  If empty, no legend entry is added.",
+:seriescolor 		=> "Color Type. The base color for this series.  `:auto` (the default) will select a color from the subplot's `color_palette`, based on the order it was added to the subplot",
+:seriesalpha 		=> "Number in [0,1]. The alpha/opacity override for the series.  `nothing` (the default) means it will take the alpha value of the color.",
+:seriestype 		=> "Symbol. This is the identifier of the type of visualization for this series. Choose from $(_allTypes) or any series recipes which are defined.",
+:linestyle 			=> "Symbol. Style of the line (for path and bar stroke).  Choose from $(_allStyles)",
+:linewidth         	=> "Number. Width of the line (in pixels)",
+:linecolor         	=> "Color Type. Color of the line (for path and bar stroke).  `:match` will take the value from `:seriescolor`, (though histogram/bar types use `:black` as a default).",
+:linealpha         	=> "Number in [0,1]. The alpha/opacity override for the line.  `nothing` (the default) means it will take the alpha value of linecolor.",
+:fillrange         	=> "Number or AbstractVector.  Fills area from this to y for line-types, sets the base for bar/stick types, and similar for other types.",
+:fillcolor         	=> "Color Type. Color of the filled area of path or bar types.  `:match` will take the value from `:seriescolor`.",
+:fillalpha         	=> "Number in [0,1]. The alpha/opacity override for the fill area.  `nothing` (the default) means it will take the alpha value of fillcolor.",
+:markershape       	=> "Symbol, Shape, or AbstractVector. Choose from $(_allMarkers).",
+:markercolor       	=> "Color Type. Color of the interior of the marker or shape. `:match` will take the value from `:seriescolor`.",
+:markeralpha       	=> "Number in [0,1]. The alpha/opacity override for the marker interior.  `nothing` (the default) means it will take the alpha value of markercolor.",
+:markersize        	=> "Number or AbstractVector. Size (radius pixels) of the markers.",
+:markerstrokestyle 	=> "Symbol. Style of the marker stroke (border).  Choose from $(_allStyles)",
+:markerstrokewidth 	=> "Number. Width of the marker stroke (border. in pixels)",
+:markerstrokecolor 	=> "Color Type. Color of the marker stroke (border).  `:match` will take the value from `:seriescolor`.",
+:markerstrokealpha 	=> "Number in [0,1]. The alpha/opacity override for the marker stroke (border).  `nothing` (the default) means it will take the alpha value of markerstrokecolor.",
+:bins              	=> "Integer, NTuple{2,Integer}, AbstractVector. For histogram-types, defines the number of bins, or the edges, of the histogram.",
+:smooth            	=> "Bool.  Add a regression line?",
+:group             	=> "AbstractVector. Data is split into a separate series, one for each unique value in `group`.",
+:x                 	=> "Various. Input data. First Dimension",
+:y                 	=> "Various. Input data. Second Dimension",
+:z                 	=> "Various. Input data. Third Dimension. May be wrapped by a `Surface` for surface and heatmap types.",
+:marker_z          	=> "AbstractVector, Function `f(x,y,z) -> z_value`, or nothing. z-values for each series data point, which correspond to the color to be used from a markercolor gradient.",
+:line_z          	=> "AbstractVector, Function `f(x,y,z) -> z_value`, or nothing. z-values for each series line segment, which correspond to the color to be used from a linecolor gradient.  Note that for N points, only the first N-1 values are used (one per line-segment).",
+:levels            	=> "Integer, NTuple{2,Integer}. Number of levels (or x-levels/y-levels) for a contour type.",
+:orientation       	=> "Symbol.  Horizontal or vertical orientation for bar types.  Values `:h`, `:hor`, `:horizontal` correspond to horizontal (sideways, anchored to y-axis), and `:v`, `:vert`, and `:vertical` correspond to vertical (the default).",
+:bar_position      	=> "Symbol.  Choose from `:overlay` (default), `:stack`.  (warning: May not be implemented fully)",
+:bar_width         	=> "nothing or Number. Width of bars in data coordinates. When nothing, chooses based on x (or y when `orientation = :h`).",
+:bar_edges         	=> "Bool.  Align bars to edges (true), or centers (the default)?",
+:xerror            	=> "AbstractVector or 2-Tuple of Vectors. x (horizontal) error relative to x-value.  If 2-tuple of vectors, the first vector corresponds to the left error (and the second to the right)",
+:yerror            	=> "AbstractVector or 2-Tuple of Vectors. y (vertical) error relative to y-value.  If 2-tuple of vectors, the first vector corresponds to the bottom error (and the second to the top)",
+:ribbon            	=> "Number or AbstractVector.  Creates a fillrange around the data points.",
+:quiver            	=> "AbstractVector or 2-Tuple of vectors.  The directional vectors U,V which specify velocity/gradient vectors for a quiver plot.",
+:arrow             	=> "nothing (no arrows), Bool (if true, default arrows), Arrow object, or arg(s) that could be style or head length/widths.  Defines arrowheads that should be displayed at the end of path line segments (just before a NaN and the last non-NaN point).  Used in quiverplot, streamplot, or similar.",
+:normalize         	=> "Bool. Should normalize histogram types?  Trying for area == 1.",
+: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)",
+:background_color         => "Color Type.  Base color for all backgrounds.",
+:background_color_outside => "Color Type or `:match` (matches `:background_color`).  Color outside the plot area(s)",
+:foreground_color         => "Color Type.  Base color for all foregrounds.",
+:size                     => "NTuple{2,Int}. (width_px, height_px) of the whole Plot",
+:pos                      => "NTuple{2,Int}. (left_px, top_px) position of the GUI window (note: currently unimplemented)",
+:window_title             => "String. Title of the window.",
+:show                     => "Bool.  Should this command open/refresh a GUI/display?  This allows displaying in scripts or functions without explicitly calling `display`",
+:layout                   => "Integer (number of subplots), NTuple{2,Integer} (grid dimensions), AbstractLayout (for example `grid(2,2)`), or the return from the `@layout` macro.  This builds the layout of subplots.",
+:link                     => "Symbol.  How/whether to link axis limits between subplots. Values: `:none`, `:x` (x axes are linked by columns), `:y` (y axes are linked by rows), `:both` (x and y are linked), `:all` (every subplot is linked together regardless of layout position).",
+:overwrite_figure         => "Bool.  Should we reuse the same GUI window/figure when plotting (true) or open a new one (false).",
+:html_output_format       => "Symbol.  When writing html output, what is the format?  `:png` and `:svg` are currently supported.",
+: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.",
+:title_location           => "Symbol. Position of subplot title. Values: `:left`, `:center`, `:right`",
+:titlefont                => "Font. Font of subplot title.",
+:background_color_subplot => "Color Type or `:match` (matches `:background_color`).  Base background color of the subplot.",
+:background_color_legend  => "Color Type or `:match` (matches `:background_color_subplot`).  Background color of the legend.",
+:background_color_inside  => "Color Type or `:match` (matches `:background_color_subplot`).  Background color inside the plot area (under the grid).",
+:foreground_color_subplot => "Color Type or `:match` (matches `:foreground_color`).  Base foreground color of the subplot.",
+:foreground_color_legend  => "Color Type or `:match` (matches `:foreground_color_subplot`).  Foreground color of the legend.",
+:foreground_color_grid    => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of grid lines.",
+:foreground_color_title   => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of subplot title.",
+:color_palette            => "Vector of colors (cycle through) or color gradient (generate list from gradient) or `:auto` (generate a color list using `Colors.distiguishable_colors` and custom seed colors chosen to contrast with the background).  The color palette is a color list from which series colors are automatically chosen.",
+:legend                   => "Bool (show the legend?) or Symbol (legend position).  Symbol values: `:none`, `:best`, `:right`, `:left`, `:top`, `:bottom`, `:inside`, `:legend`, `:topright`, `:topleft`, `:bottomleft`, `:bottomright` (note: only some may be supported in each backend)",
+: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. 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).",
+:lims      				  => "NTuple{2,Number}. Force axis limits.  Only finite values are used (you can set only the right limit with `xlims = (-Inf, 2)` for example).",
+:ticks     				  => "Vector of numbers (set the tick values), Tuple of (tickvalues, ticklabels), or `:auto`",
+:scale     				  => "Symbol. Scale of the axis: `:none`, `:ln`, `:log2`, `:log10`",
+:rotation  				  => "Number. Degrees rotation of tick labels.",
+:flip      				  => "Bool.  Should we flip (reverse) the axis?",
+: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

@@ -0,0 +1,500 @@
+
+
+# xaxis(args...; kw...) = Axis(:x, args...; kw...)
+# yaxis(args...; kw...) = Axis(:y, args...; kw...)
+# zaxis(args...; kw...) = Axis(:z, args...; kw...)
+
+# -------------------------------------------------------------------------
+
+function Axis(sp::Subplot, letter::Symbol, args...; kw...)
+    # init with values from _plot_defaults
+    d = KW(
+        :letter => letter,
+        # :extrema => (Inf, -Inf),
+        :extrema => Extrema(),
+        :discrete_map => Dict(),   # map discrete values to discrete indices
+        :continuous_values => zeros(0),
+        :use_minor => false,
+        :show => true,  # show or hide the axis? (useful for linked subplots)
+    )
+
+    # get defaults from letter version, unless match
+    for (k,v) in _axis_defaults
+        lk = Symbol(letter, k)
+        lv = _axis_defaults_byletter[lk]
+        d[k] = (lv == :match ? v : lv)
+    end
+
+    # merge!(d, _axis_defaults)
+    d[:discrete_values] = []
+
+    # update the defaults
+    update!(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 = "")
+    T = typeof(arg)
+    arg = get(_scaleAliases, arg, arg)
+
+    if typeof(arg) <: Font
+        d[Symbol(letter,:tickfont)] = arg
+        d[Symbol(letter,:guidefont)] = arg
+
+    elseif arg in _allScales
+        d[Symbol(letter,:scale)] = arg
+
+    elseif arg in (:flip, :invert, :inverted)
+        d[Symbol(letter,:flip)] = true
+
+    elseif T <: AbstractString
+        d[Symbol(letter,:guide)] = arg
+
+    # xlims/ylims
+    elseif (T <: Tuple || T <: AVec) && length(arg) == 2
+        sym = typeof(arg[1]) <: Number ? :lims : :ticks
+        d[Symbol(letter,sym)] = arg
+
+    # xticks/yticks
+    elseif T <: AVec
+        d[Symbol(letter,:ticks)] = arg
+
+    elseif arg == nothing
+        d[Symbol(letter,:ticks)] = []
+
+    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")
+
+    end
+end
+
+# update an Axis object with magic args and keywords
+function update!(axis::Axis, args...; kw...)
+    # first process args
+    d = axis.d
+    for arg in args
+        process_axis_arg!(d, arg)
+    end
+
+    # then override for any keywords... only those keywords that already exists in d
+    for (k,v) in kw
+        if haskey(d, k)
+            if k == :discrete_values
+                # add these discrete values to the axis
+                for vi in v
+                    discrete_value!(axis, vi)
+                end
+            else
+                d[k] = v
+            end
+        end
+    end
+
+    # replace scale aliases
+    if haskey(_scaleAliases, d[:scale])
+        d[:scale] = _scaleAliases[d[:scale]]
+    end
+
+    axis
+end
+
+# -------------------------------------------------------------------------
+
+Base.show(io::IO, axis::Axis) = dumpdict(axis.d, "Axis", true)
+# Base.getindex(axis::Axis, k::Symbol) = getindex(axis.d, k)
+Base.setindex!(axis::Axis, v, ks::Symbol...) = setindex!(axis.d, v, ks...)
+Base.haskey(axis::Axis, k::Symbol) = haskey(axis.d, k)
+Base.extrema(axis::Axis) = (ex = axis[:extrema]; (ex.emin, ex.emax))
+
+
+const _scale_funcs = Dict{Symbol,Function}(
+    :log10 => log10,
+    :log2 => log2,
+    :ln => log,
+)
+const _inv_scale_funcs = Dict{Symbol,Function}(
+    :log10 => exp10,
+    :log2 => exp2,
+    :ln => exp,
+)
+
+# const _label_func = Dict{Symbol,Function}(
+#     :log10 => x -> "10^$x",
+#     :log2 => x -> "2^$x",
+#     :ln => x -> "e^$x",
+# )
+
+const _label_func = Dict{Symbol,Function}(
+    :log10 => x -> "10^$x",
+    :log2 => x -> "2^$x",
+    :ln => x -> "e^$x",
+)
+
+
+scalefunc(scale::Symbol) = x -> get(_scale_funcs, scale, identity)(Float64(x))
+invscalefunc(scale::Symbol) = x -> get(_inv_scale_funcs, scale, identity)(Float64(x))
+labelfunc(scale::Symbol, backend::AbstractBackend) = get(_label_func, scale, string)
+
+function optimal_ticks_and_labels(axis::Axis, ticks = nothing)
+    amin,amax = axis_limits(axis)
+
+    # scale the limits
+    scale = axis[:scale]
+    sf = scalefunc(scale)
+
+    # get a list of well-laid-out ticks
+    scaled_ticks = if ticks == nothing
+        optimize_ticks(
+            sf(amin),
+            sf(amax);
+            k_min = 5, # minimum number of ticks
+            k_max = 8, # maximum number of ticks
+        )[1]
+    else
+        map(sf, filter(t -> amin <= t <= amax, ticks))
+    end
+    unscaled_ticks = map(invscalefunc(scale), scaled_ticks)
+
+    labels = if any(isfinite, unscaled_ticks)
+        formatter = axis[:formatter]
+        if formatter == :auto
+            # the default behavior is to make strings of the scaled values and then apply the labelfunc
+            map(labelfunc(scale, backend()), Showoff.showoff(scaled_ticks, :plain))
+        elseif formatter == :scientific
+            Showoff.showoff(unscaled_ticks, :scientific)
+        else
+            # there was an override for the formatter... use that on the unscaled ticks
+            map(formatter, unscaled_ticks)
+        end
+    else
+        # no finite ticks to show...
+        String[]
+    end
+
+    # @show unscaled_ticks labels
+    # labels = Showoff.showoff(unscaled_ticks, scale == :log10 ? :scientific : :auto)
+    unscaled_ticks, labels
+end
+
+# return (continuous_values, discrete_values) for the ticks on this axis
+function get_ticks(axis::Axis)
+    ticks = axis[:ticks]
+    ticks in (nothing, false) && return nothing
+
+    dvals = axis[:discrete_values]
+    cv, dv = if !isempty(dvals) && ticks == :auto
+        # discrete ticks...
+        axis[:continuous_values], dvals
+    elseif ticks == :auto
+        # compute optimal ticks and labels
+        optimal_ticks_and_labels(axis)
+    elseif typeof(ticks) <: AVec
+        # override ticks, but get the labels
+        optimal_ticks_and_labels(axis, ticks)
+    elseif typeof(ticks) <: NTuple{2}
+        # assuming we're passed (ticks, labels)
+        ticks
+    else
+        error("Unknown ticks type in get_ticks: $(typeof(ticks))")
+    end
+    # @show ticks dvals cv dv
+
+    # TODO: better/smarter cutoff values for sampling ticks
+    if length(cv) > 30
+        rng = Int[round(Int,i) for i in linspace(1, length(cv), 15)]
+        cv[rng], dv[rng]
+    else
+        cv, dv
+    end
+end
+
+# -------------------------------------------------------------------------
+
+
+function reset_extrema!(sp::Subplot)
+    for asym in (:x,:y,:z)
+        sp[Symbol(asym,:axis)][:extrema] = Extrema()
+    end
+    for series in sp.series_list
+        expand_extrema!(sp, series.d)
+    end
+end
+
+
+function expand_extrema!(ex::Extrema, v::Number)
+    ex.emin = min(v, ex.emin)
+    ex.emax = max(v, ex.emax)
+    ex
+end
+
+function expand_extrema!(axis::Axis, v::Number)
+    expand_extrema!(axis[:extrema], v)
+end
+
+# these shouldn't impact the extrema
+expand_extrema!(axis::Axis, ::Void) = axis[:extrema]
+expand_extrema!(axis::Axis, ::Bool) = axis[:extrema]
+
+
+function expand_extrema!{MIN<:Number,MAX<:Number}(axis::Axis, v::Tuple{MIN,MAX})
+    ex = axis[:extrema]
+    ex.emin = min(v[1], ex.emin)
+    ex.emax = max(v[2], ex.emax)
+    ex
+end
+function expand_extrema!{N<:Number}(axis::Axis, v::AVec{N})
+    ex = axis[:extrema]
+    for vi in v
+        expand_extrema!(ex, vi)
+    end
+    ex
+end
+
+
+function expand_extrema!(sp::Subplot, d::KW)
+    vert = isvertical(d)
+
+    # first expand for the data
+    for letter in (:x, :y, :z)
+        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)
+            d[letter], d[Symbol(letter,"_discrete_indices")] = discrete_value!(axis, data)
+            expand_extrema!(axis, d[letter])
+        end
+    end
+
+    # # expand for fillrange/bar_width
+    # fillaxis, baraxis = sp.attr[:yaxis], sp.attr[:xaxis]
+    # if isvertical(d)
+    #     fillaxis, baraxis = baraxis, fillaxis
+    # end
+
+    # expand for fillrange
+    fr = d[:fillrange]
+    if fr == nothing && d[:seriestype] == :bar
+        fr = 0.0
+    end
+    if fr != nothing
+        axis = sp.attr[vert ? :yaxis : :xaxis]
+        if typeof(fr) <: Tuple
+            for fri in fr
+                expand_extrema!(axis, fri)
+            end
+        else
+            expand_extrema!(axis, fr)
+        end
+    end
+
+    # expand for bar_width
+    if d[:seriestype] == :bar
+        dsym = vert ? :x : :y
+        data = d[dsym]
+
+        bw = d[:bar_width]
+        if bw == nothing
+            bw = d[:bar_width] = mean(diff(data))
+        end
+        axis = sp.attr[Symbol(dsym, :axis)]
+        expand_extrema!(axis, maximum(data) + 0.5maximum(bw))
+        expand_extrema!(axis, minimum(data) - 0.5minimum(bw))
+    end
+
+end
+
+function expand_extrema!(sp::Subplot, xmin, xmax, ymin, ymax)
+    expand_extrema!(sp[:xaxis], (xmin, xmax))
+    expand_extrema!(sp[:yaxis], (ymin, ymax))
+end
+
+# -------------------------------------------------------------------------
+
+# push the limits out slightly
+function widen(lmin, lmax)
+    span = lmax - lmin
+    # eps = max(1e-16, min(1e-2span, 1e-10))
+    eps = max(1e-16, 0.03span)
+    lmin-eps, lmax+eps
+end
+
+# figure out if widening is a good idea.  if there's a scale set it's too tricky,
+# so lazy out and don't widen
+function default_should_widen(axis::Axis)
+    should_widen = false
+    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
+end
+
+# using the axis extrema and limit overrides, return the min/max value for this axis
+function axis_limits(axis::Axis, should_widen::Bool = default_should_widen(axis))
+    ex = axis[:extrema]
+    amin, amax = ex.emin, ex.emax
+    lims = axis[:lims]
+    if (isa(lims, Tuple) || isa(lims, AVec)) && length(lims) == 2
+        if isfinite(lims[1])
+            amin = lims[1]
+        end
+        if isfinite(lims[2])
+            amax = lims[2]
+        end
+    end
+    if amax <= amin && isfinite(amin)
+        amax = amin + 1.0
+    end
+    if should_widen
+        widen(amin, amax)
+    else
+        amin, amax
+    end
+end
+
+# -------------------------------------------------------------------------
+
+# these methods track the discrete (categorical) values which correspond to axis continuous values (cv)
+# whenever we have discrete values, we automatically set the ticks to match.
+# we return (continuous_value, discrete_index)
+function discrete_value!(axis::Axis, dv)
+    cv_idx = get(axis[:discrete_map], dv, -1)
+    # @show axis[:discrete_map], axis[:discrete_values], dv
+    if cv_idx == -1
+        ex = axis[:extrema]
+        cv = max(0.5, ex.emax + 1.0)
+        expand_extrema!(axis, cv)
+        push!(axis[:discrete_values], dv)
+        push!(axis[:continuous_values], cv)
+        cv_idx = length(axis[:discrete_values])
+        axis[:discrete_map][dv] = cv_idx
+        cv, cv_idx
+    else
+        cv = axis[:continuous_values][cv_idx]
+        cv, cv_idx
+    end
+end
+
+# continuous value... just pass back with axis negative index
+function discrete_value!(axis::Axis, cv::Number)
+    cv, -1
+end
+
+# add the discrete value for each item.  return the continuous values and the indices
+function discrete_value!(axis::Axis, v::AVec)
+    n = length(v)
+    cvec = zeros(n)
+    discrete_indices = zeros(Int, n)
+    for i=1:n
+        cvec[i], discrete_indices[i] = discrete_value!(axis, v[i])
+    end
+    cvec, discrete_indices
+end
+
+# add the discrete value for each item.  return the continuous values and the indices
+function discrete_value!(axis::Axis, v::AMat)
+    n,m = size(v)
+    cmat = zeros(n,m)
+    discrete_indices = zeros(Int, n, m)
+    for i=1:n, j=1:m
+        cmat[i,j], discrete_indices[i,j] = discrete_value!(axis, v[i,j])
+    end
+    cmat, discrete_indices
+end
+
+function discrete_value!(axis::Axis, v::Surface)
+    map(Surface, discrete_value!(axis, v.surf))
+end
+
+# -------------------------------------------------------------------------
+
+function pie_labels(sp::Subplot, series::Series)
+    d = series.d
+    if haskey(d,:x_discrete_indices)
+        dvals = sp.attr[:xaxis].d[:discrete_values]
+        [dvals[idx] for idx in d[:x_discrete_indices]]
+    else
+        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

@@ -12,45 +12,90 @@ _backend_instance(sym::Symbol) = haskey(_backendType, sym) ? _backendType[sym]()
 
 macro init_backend(s)
     str = lowercase(string(s))
-    sym = symbol(str)
-    T = symbol(string(s) * "Backend")
+    sym = Symbol(str)
+    T = Symbol(string(s) * "Backend")
     esc(quote
         immutable $T <: AbstractBackend end
         export $sym
-        $sym(; kw...) = (default(; kw...); backend(symbol($str)))
-        backend_name(::$T) = symbol($str)
-        push!(_backends, symbol($str))
-        _backendType[symbol($str)] = $T
-        _backendSymbol[$T] = symbol($str)
+        $sym(; kw...) = (default(; kw...); backend(Symbol($str)))
+        backend_name(::$T) = Symbol($str)
+        push!(_backends, Symbol($str))
+        _backendType[Symbol($str)] = $T
+        _backendSymbol[$T] = Symbol($str)
         include("backends/" * $str * ".jl")
     end)
 end
 
-@init_backend Immerse
-@init_backend Gadfly
-@init_backend PyPlot
-@init_backend Qwt
-@init_backend UnicodePlots
-@init_backend Winston
-@init_backend Bokeh
-@init_backend Plotly
-@init_backend PlotlyJS
-@init_backend GR
-@init_backend GLVisualize
-@init_backend PGFPlots
-
 include("backends/web.jl")
 # include("backends/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))")
 
-plot(pkg::AbstractBackend; kw...)                       = error("plot($pkg; kw...) is not implemented")
-plot!(pkg::AbstractBackend, plt::Plot; kw...)           = error("plot!($pkg, plt; kw...) is not implemented")
-_update_plot(pkg::AbstractBackend, plt::Plot, d::KW)  = error("_update_plot($pkg, plt, d) is not implemented")
-_update_plot_pos_size{P<:AbstractBackend}(plt::AbstractPlot{P}, d::KW) = nothing
-subplot(pkg::AbstractBackend; kw...)                    = error("subplot($pkg; kw...) is not implemented")
-subplot!(pkg::AbstractBackend, subplt::Subplot; kw...)  = error("subplot!($pkg, subplt; kw...) is not implemented")
+# don't do anything as a default
+_create_backend_figure(plt::Plot) = nothing
+_prepare_plot_object(plt::Plot) = nothing
+_initialize_subplot(plt::Plot, sp::Subplot) = nothing
+
+_series_added(plt::Plot, series::Series) = nothing
+_series_updated(plt::Plot, series::Series) = nothing
+
+_before_layout_calcs(plt::Plot) = nothing
+
+title_padding(sp::Subplot) = sp[:title] == "" ? 0mm : sp[:titlefont].pointsize * pt
+guide_padding(axis::Axis) = axis[:guide] == "" ? 0mm : axis[:guidefont].pointsize * pt
+
+# 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
+        ptsz = axis[:tickfont].pointsize * pt
+
+        # we need to compute the size of the ticks generically
+        # this means computing the bounding box and then getting the width/height
+        longest_label = maximum(length(lab) for lab in labs)
+        labelwidth = 0.8longest_label * ptsz
+
+        # generalize by "rotating" y labels
+        rot = axis[:rotation] + (axis[:letter] == :y ? 90 : 0)
+
+        # 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
+    end
+end
+
+# Set the (left, top, right, bottom) minimum padding around the plot area
+# to fit ticks, tick labels, guides, colorbars, etc.
+function _update_min_padding!(sp::Subplot)
+    # TODO: something different when `is3d(sp) == true`
+    leftpad   = tick_padding(sp[: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
+
+_update_plot_object(plt::Plot) = nothing
 
 # ---------------------------------------------------------
 
@@ -68,7 +113,7 @@ function pickDefaultBackend()
     if env_default != ""
         try
             Pkg.installed(env_default)  # this will error if not installed
-            sym = symbol(lowercase(env_default))
+            sym = Symbol(lowercase(env_default))
             if haskey(_backendType, sym)
                 return backend(sym)
             else
@@ -85,7 +130,7 @@ function pickDefaultBackend()
     # features, speed, and robustness
     for pkgstr in ("PyPlot", "GR", "PlotlyJS", "Immerse", "Gadfly", "UnicodePlots")
         if Pkg.installed(pkgstr) != nothing
-            return backend(symbol(lowercase(pkgstr)))
+            return backend(Symbol(lowercase(pkgstr)))
         end
     end
 
@@ -109,14 +154,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
 
@@ -130,31 +176,110 @@ end
 Set the plot backend.
 """
 function backend(pkg::AbstractBackend)
-  CURRENT_BACKEND.sym = backend_name(pkg)
-  CURRENT_BACKEND.pkg = pkg
+    CURRENT_BACKEND.sym = backend_name(pkg)
+    warn_on_deprecated_backend(CURRENT_BACKEND.sym)
+    CURRENT_BACKEND.pkg = pkg
+    backend()
 end
 
 function backend(modname::Symbol)
-  CURRENT_BACKEND.sym = modname
-  CURRENT_BACKEND.pkg = _backend_instance(modname)
+    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]
+
+function warn_on_deprecated_backend(bsym::Symbol)
+    if bsym in _deprecated_backends
+        warn("Backend $bsym has been deprecated.  It may not work as originally intended.")
+    end
+end
 
-supportedAxes(::AbstractBackend) = [:left]
-supportedTypes(::AbstractBackend) = []
-supportedStyles(::AbstractBackend) = [:solid]
-supportedMarkers(::AbstractBackend) = [:none]
-supportedScales(::AbstractBackend) = [:identity]
-subplotSupported(::AbstractBackend) = false
-stringsSupported(::AbstractBackend) = false
 
-supportedAxes() = supportedAxes(backend())
-supportedTypes() = supportedTypes(backend())
-supportedStyles() = supportedStyles(backend())
-supportedMarkers() = supportedMarkers(backend())
-supportedScales() = supportedScales(backend())
-subplotSupported() = subplotSupported(backend())
-stringsSupported() = stringsSupported(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
+
+# ---------------------------------------------------------
+
+# 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/immerse.jl

@@ -1,180 +0,0 @@
-
-# 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
-
-# --------------------------------------------------------------------------------------
-
-function _initialize_backend(::ImmerseBackend; kw...)
-  @eval begin
-    import Immerse, Gadfly, Compose, Gtk
-    export Immerse, Gadfly, Compose, Gtk
-    include(joinpath(Pkg.dir("Plots"), "src", "backends", "gadfly_shapes.jl"))
-  end
-end
-
-function createImmerseFigure(d::KW)
-  w,h = d[:size]
-  figidx = Immerse.figure(; name = d[:windowtitle], width = w, height = h)
-  Immerse.Figure(figidx)
-end
-
-# ----------------------------------------------------------------
-
-
-# create a blank Gadfly.Plot object
-function _create_plot(pkg::ImmerseBackend, d::KW)
-  # create the underlying Gadfly.Plot object
-  gplt = createGadflyPlotObject(d)
-
-  # save both the Immerse.Figure and the Gadfly.Plot
-  Plot((nothing,gplt), pkg, 0, d, KW[])
-end
-
-
-# plot one data series
-function _add_series(::ImmerseBackend, plt::Plot, d::KW)
-  addGadflySeries!(plt, d)
-  push!(plt.seriesargs, d)
-  plt
-end
-
-
-function _update_plot(plt::Plot{ImmerseBackend}, d::KW)
-  updateGadflyGuides(plt, d)
-  updateGadflyPlotTheme(plt, d)
-end
-
-
-
-# ----------------------------------------------------------------
-
-function _add_annotations{X,Y,V}(plt::Plot{ImmerseBackend}, anns::AVec{@compat(Tuple{X,Y,V})})
-  for ann in anns
-    push!(getGadflyContext(plt).guides, createGadflyAnnotationObject(ann...))
-  end
-end
-
-# ----------------------------------------------------------------
-
-# accessors for x/y data
-
-function getxy(plt::Plot{ImmerseBackend}, i::Integer)
-  mapping = getGadflyMappings(plt, i)[1]
-  mapping[:x], mapping[:y]
-end
-
-function setxy!{X,Y}(plt::Plot{ImmerseBackend}, xy::Tuple{X,Y}, i::Integer)
-  for mapping in getGadflyMappings(plt, i)
-    mapping[:x], mapping[:y] = xy
-  end
-  plt
-end
-
-
-# ----------------------------------------------------------------
-
-
-function _create_subplot(subplt::Subplot{ImmerseBackend}, isbefore::Bool)
-  return false
-  # isbefore && return false
-end
-
-function showSubplotObject(subplt::Subplot{ImmerseBackend})
-  # create the Gtk window with vertical box vsep
-  d = getplotargs(subplt,1)
-  w,h = d[:size]
-  vsep = Gtk.GtkBoxLeaf(:v)
-  win = Gtk.GtkWindowLeaf(vsep, d[:windowtitle], w, h)
-
-  figindices = []
-  row = Gtk.GtkBoxLeaf(:h)
-  push!(vsep, row)
-  for (i,(r,c)) in enumerate(subplt.layout)
-    plt = subplt.plts[i]
-
-    # get the components... box is the main plot GtkBox, and canvas is the GtkCanvas where it's plotted
-    box, toolbar, canvas = Immerse.createPlotGuiComponents()
-
-    # add the plot's box to the row
-    push!(row, box)
-
-    # create the figure and store the index returned for destruction later
-    figidx = Immerse.figure(canvas)
-    push!(figindices, figidx)
-
-    fig = Immerse.figure(figidx)
-    plt.o = (fig, plt.o[2])
-
-    # add the row
-    if c == ncols(subplt.layout, r)
-      row = Gtk.GtkBoxLeaf(:h)
-      push!(vsep, row)
-    end
-
-  end
-
-  # destructor... clean up plots
-  Gtk.on_signal_destroy((x...) -> ([Immerse.dropfig(Immerse._display,i) for i in figindices]; subplt.o = nothing), win)
-
-  subplt.o = win
-  true
-end
-
-
-function _remove_axis(plt::Plot{ImmerseBackend}, isx::Bool)
-  gplt = getGadflyContext(plt)
-  addOrReplace(gplt.guides, isx ? Gadfly.Guide.xticks : Gadfly.Guide.yticks; label=false)
-  addOrReplace(gplt.guides, isx ? Gadfly.Guide.xlabel : Gadfly.Guide.ylabel, "")
-end
-
-function _expand_limits(lims, plt::Plot{ImmerseBackend}, isx::Bool)
-  for l in getGadflyContext(plt).layers
-    _expand_limits(lims, l.mapping[isx ? :x : :y])
-  end
-end
-
-
-# ----------------------------------------------------------------
-
-getGadflyContext(plt::Plot{ImmerseBackend}) = plt.o[2]
-getGadflyContext(subplt::Subplot{ImmerseBackend}) = buildGadflySubplotContext(subplt)
-
-
-function Base.display(::PlotsDisplay, plt::Plot{ImmerseBackend})
-
-  fig, gplt = plt.o
-  if fig == nothing
-    fig = createImmerseFigure(plt.plotargs)
-    Gtk.on_signal_destroy((x...) -> (Immerse.dropfig(Immerse._display, fig.figno); plt.o = (nothing,gplt)), fig.canvas)
-    plt.o = (fig, gplt)
-  end
-
-  Immerse.figure(fig.figno; displayfig = false)
-  display(gplt)
-end
-
-
-function Base.display(::PlotsDisplay, subplt::Subplot{ImmerseBackend})
-
-  # if we haven't created the window yet, do it
-  if subplt.o == nothing
-    showSubplotObject(subplt)
-  end
-
-  # display the plots by creating a fresh Immerse.Figure object from the GtkCanvas and Gadfly.Plot
-  for plt in subplt.plts
-    fig, gplt = plt.o
-    Immerse.figure(fig.figno; displayfig = false)
-    display(gplt)
-  end
-
-  # o is the window... show it
-  showall(subplt.o)
-end

src/backends/pgfplots.jl

@@ -1,354 +1,336 @@
 # https://github.com/sisl/PGFPlots.jl
 
-supportedArgs(::PGFPlotsBackend) = [
-    # :annotation,
-    # :axis,
-     :background_color,
-    # :color_palette,
-    # :fillrange,
-     :fillcolor,
-     :fillalpha,
-    # :foreground_color,
-    # :group,
-    # :label,
-    # :layout,
-    # :legend,
-     :seriescolor, :seriesalpha,
-     :linecolor,
-     :linestyle,
-     :linetype,
-     :linewidth,
-     :linealpha,
-     :markershape,
-     :markercolor,
-     :markersize,
-     :markeralpha,
-    # :markerstrokewidth,
-     :markerstrokecolor,
-     :markerstrokestyle,
-    # :n,
-    # :bins,
-    # :nc,
-    # :nr,
-    # :pos,
-    # :smooth,
-    # :show,
-    # :size,
-     :title,
-    # :windowtitle,
-     :x,
-     :xlabel,
-     :xlims,
-    # :xticks,
-     :y,
-     :ylabel,
-     :ylims,
-    # :yrightlabel,
-    # :yticks,
-     :xscale,
-     :yscale,
-     :xflip,
-     :yflip,
-     :z,
-     :zscale,
-    # :tickfont,
-    # :guidefont,
-    # :legendfont,
-     :grid,
-    # :surface
-    # :levels,
-  ]
-supportedAxes(::PGFPlotsBackend) = [:auto, :left]
-supportedTypes(::PGFPlotsBackend) = [:path, :path3d, :scatter, :line, :steppre, :stepmid, :steppost, :hist, :bar, :hist2d, :sticks, :ysticks, :xsticks, :contour] #  :hexbin, :hline, :vline,]
-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, :log, :ln, :log2, :log10] # :asinh, :sqrt]
-subplotSupported(::PGFPlotsBackend) = false
+# significant contributions by: @pkofod
+
+const _pgfplots_attr = merge_with_base_supported([
+    # :annotations,
+    # :background_color_legend,
+    :background_color_inside,
+    # :background_color_outside,
+    # :foreground_color_legend, :foreground_color_grid, :foreground_color_axis,
+    #     :foreground_color_text, :foreground_color_border,
+    :label,
+    :seriescolor, :seriesalpha,
+    :linecolor, :linestyle, :linewidth, :linealpha,
+    :markershape, :markercolor, :markersize, :markeralpha,
+    :markerstrokewidth, :markerstrokecolor, :markerstrokealpha, :markerstrokestyle,
+    :fillrange, :fillcolor, :fillalpha,
+    :bins,
+    # :bar_width, :bar_edges,
+    :title,
+    # :window_title,
+    :guide, :lims, :ticks, :scale, :flip, :rotation,
+    :tickfont, :guidefont, :legendfont,
+    :grid, :legend,
+    # :colorbar,
+    # :marker_z, :levels,
+    # :ribbon, :quiver, :arrow,
+    # :orientation,
+    # :overwrite_figure,
+    # :polar,
+    # :normalize, :weights, :contours,
+    :aspect_ratio,
+    # :match_dimensions,
+  ])
+const _pgfplots_seriestype = [:path, :path3d, :scatter, :steppre, :stepmid, :steppost, :histogram2d, :ysticks, :xsticks, :contour]
+const _pgfplots_style = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
+const _pgfplots_marker = [:none, :auto, :circle, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5, :pentagon] #vcat(_allMarkers, Shape)
+const _pgfplots_scale = [:identity, :ln, :log2, :log10]
 
 
 # --------------------------------------------------------------------------------------
 
+function add_backend_string(::PGFPlotsBackend)
+    """
+    Pkg.add("PGFPlots")
+    Pkg.build("PGFPlots")
+    """
+end
 
 function _initialize_backend(::PGFPlotsBackend; kw...)
-  @eval begin
-    import PGFPlots
-    export PGFPlots
-    # TODO: other initialization that needs to be eval-ed
-  end
-  # TODO: other initialization
+    @eval begin
+        import PGFPlots
+        export PGFPlots
+    end
 end
+
+
+# --------------------------------------------------------------------------------------
+
 const _pgfplots_linestyles = KW(
     :solid => "solid",
     :dash => "dashed",
     :dot => "dotted",
     :dashdot => "dashdotted",
-    :dashdotdot => "dashdotdotted"
+    :dashdotdot => "dashdotdotted",
 )
 
 const _pgfplots_markers = KW(
-    :none => "mark = none,",
-    :cross => "mark = +,",
-    :xcross => "mark = x,",
-    :utriangle => "mark = triangle*,",
-    :dtriangle => "mark = triangle*,",
-    :ellipse => "mark = o*,",
-    :rect => "mark = square*,",
-    :star5 => "mark = star,",
-    :star6 => "mark = asterisk,",
-    :diamond => "mark = diamond*,",
-    :pentagon => "mark = pentagon*,"
+    :none => "none",
+    :cross => "+",
+    :xcross => "x",
+    :+ => "+",
+    :x => "x",
+    :utriangle => "triangle*",
+    :dtriangle => "triangle*",
+    :circle => "*",
+    :rect => "square*",
+    :star5 => "star",
+    :star6 => "asterisk",
+    :diamond => "diamond*",
+    :pentagon => "pentagon*",
 )
 
-function _pgfplots_get_color(kwargs, symb)
-    c = typeof(kwargs[symb]) == Symbol ? convertColor(kwargs[symb]) : kwargs[symb].c
-    "{rgb,1:red,$(float(c.r));green,$(float(c.g));blue,$(float(c.b))}"
+const _pgfplots_legend_pos = KW(
+    :bottomleft => "south west",
+    :bottomright => "south east",
+    :topright => "north east",
+    :topleft => "north west",
+)
+
+
+const _pgf_series_extrastyle = KW(
+    :steppre => "const plot mark right",
+    :stepmid => "const plot mark mid",
+    :steppost => "const plot",
+    :sticks => "ycomb",
+    :ysticks => "ycomb",
+    :xsticks => "xcomb",
+)
+
+# --------------------------------------------------------------------------------------
+
+# takes in color,alpha, and returns color and alpha appropriate for pgf style
+function pgf_color(c)
+    cstr = @sprintf("{rgb,1:red,%.8f;green,%.8f;blue,%.8f}", red(c), green(c), blue(c))
+    cstr, alpha(c)
 end
 
-function _pgfplots_get_linestyle!(kwargs, plt)
-    ls = plt[:linestyle]
-    if haskey(_pgfplots_linestyles, ls)
-        kwargs[:style] *= _pgfplots_linestyles[ls]*","
+function pgf_fillstyle(d::KW)
+    cstr,a = pgf_color(d[:fillcolor])
+    "fill = $cstr, fill opacity=$a"
+end
+
+function pgf_linestyle(d::KW)
+    cstr,a = pgf_color(d[:linecolor])
+    """
+    color = $cstr,
+    draw opacity=$a,
+    line width=$(d[:linewidth]),
+    $(get(_pgfplots_linestyles, d[:linestyle], "solid"))"""
+end
+
+function pgf_marker(d::KW)
+    shape = d[:markershape]
+    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]),
+    mark options = {
+        color = $cstr_stroke, draw opacity = $a_stroke,
+        fill = $cstr, fill opacity = $a,
+        line width = $(d[:markerstrokewidth]),
+        rotate = $(shape == :dtriangle ? 180 : 0),
+        $(get(_pgfplots_linestyles, d[:markerstrokestyle], "solid"))
+    }"""
+end
+
+# --------------------------------------------------------------------------------------
+
+function pgf_series(sp::Subplot, series::Series)
+    d = series.d
+    st = d[:seriestype]
+    style = []
+    kw = KW()
+
+    push!(style, pgf_linestyle(d))
+    push!(style, pgf_marker(d))
+
+    if d[:fillrange] != nothing
+        push!(style, pgf_fillstyle(d))
     end
 
-    kwargs[:style] *= "line width = $(plt[:linewidth]) pt"*","
-end
-
-
-function _pgfplots_get_marker!(kwargs, plt)
-    # Control marker shape
-    mark = plt[:markershape]
-    kwargs[:style] *= _pgfplots_markers[mark]
-
-    # Control marker size
-    kwargs[:style] *= "mark size = $(plt[:markersize]/2),"
-
-    # Control marker colors and alphas
-    α = plt[:markeralpha] == nothing ? 1.0 : plt[:markeralpha]
-    kwargs[:style] *= "mark options = {color=$(_pgfplots_get_color(plt, :markerstrokecolor)),"
-    kwargs[:style] *= mark == :dtriangle ? "rotate=180," : ""
-    kwargs[:style] *= "fill=$(_pgfplots_get_color(plt, :markercolor)),"
-    kwargs[:style] *= "fill opacity = $α,"
-    markstrokestyle = plt[:markerstrokestyle]
-    if haskey(_pgfplots_linestyles, markstrokestyle)
-        kwargs[:style] *= _pgfplots_linestyles[markstrokestyle]
+    # add to legend?
+    if sp[:legend] != :none && should_add_to_legend(series)
+        kw[:legendentry] = d[:label]
+    else
+        push!(style, "forget plot")
     end
-    kwargs[:style] *= "},"
-end
 
-function _pgfplots_get_series_color!(kwargs, plt)
-    α = plt[:seriesalpha] == nothing ? 1.0 : plt[:seriesalpha]
-    kwargs[:style] *= "color=$(_pgfplots_get_color(plt, :seriescolor)),"
-    kwargs[:style] *= "draw opacity = $α,"
-end
-
-function _pgfplots_get_line_color!(kwargs, plt)
-    α = plt[:linealpha] == nothing ? 1.0 : plt[:linealpha]
-    kwargs[:style] *= "color=$(_pgfplots_get_color(plt, :linecolor)),"
-    kwargs[:style] *= "draw opacity = $α,"
-end
-
-function _pgfplots_get_fill_color!(kwargs, plt)
-    α = plt[:fillalpha] == nothing ? 1.0 : plt[:fillalpha]
-    kwargs[:style] *= "fill=$(_pgfplots_get_color(plt, :fillcolor)),"
-    kwargs[:style] *= "fill opacity = $α,"
-end
-
-function _pgfplots_get_plot_kwargs(plt)
-    kwargs = KW()
-    kwargs[:style] = ""
-    _pgfplots_get_linestyle!(kwargs, plt)
-    _pgfplots_get_marker!(kwargs, plt)
-    _pgfplots_get_series_color!(kwargs, plt)
-    kwargs
-end
-
-function _pgfplots_axis(plt_series)
-    line_type = plt_series[:linetype]
-    plt_kwargs = _pgfplots_get_plot_kwargs(plt_series)
-        if line_type == :path
-        PGFPlots.Linear(plt_series[:x], plt_series[:y]; plt_kwargs...)
-    elseif line_type == :path3d
-        PGFPlots.Linear3(plt_series[:x], plt_series[:y], plt_series[:z]; plt_kwargs...)
-    elseif line_type == :scatter
-        PGFPlots.Scatter(plt_series[:x], plt_series[:y]; plt_kwargs...)
-    elseif line_type == :steppre
-        plt_kwargs[:style] *= "const plot mark right,"
-        PGFPlots.Linear(plt_series[:x], plt_series[:y]; plt_kwargs...)
-    elseif line_type == :stepmid
-        plt_kwargs[:style] *= "const plot mark mid,"
-        PGFPlots.Linear(plt_series[:x], plt_series[:y]; plt_kwargs...)
-    elseif line_type == :steppost
-        plt_kwargs[:style] *= "const plot,"
-        PGFPlots.Linear(plt_series[:x], plt_series[:y]; plt_kwargs...)
-    elseif line_type == :hist
-        #TODO patch this in PGFPlots.jl instead; the problem is that PGFPlots will
-        # save _all_ data points in the figure which can be quite heavy
-        plt_hist = hist(plt_series[:y])
-        plt_kwargs[:style] *= "ybar interval,"
-        _pgfplots_get_line_color!(plt_kwargs, plt_series)
-        _pgfplots_get_fill_color!(plt_kwargs, plt_series)
-        PGFPlots.Linear(plt_hist[1][1:end-1]+plt_hist[1].step/2, plt_hist[2]; plt_kwargs...)
-    elseif line_type == :hist2d
-        PGFPlots.Histogram2(plt_series[:x], plt_series[:y])
-    elseif line_type == :bar
-        plt_kwargs[:style] *= "ybar,"
-        _pgfplots_get_line_color!(plt_kwargs, plt_series)
-        _pgfplots_get_fill_color!(plt_kwargs, plt_series)
-        PGFPlots.Linear(plt_series[:x], plt_series[:y]; plt_kwargs...)
-    elseif line_type == :sticks || line_type == :ysticks
-        plt_kwargs[:style] *= "ycomb"
-        PGFPlots.Linear(plt_series[:x], plt_series[:y]; plt_kwargs...)
-    elseif line_type == :xsticks
-        plt_kwargs[:style] *= "xcomb"
-        PGFPlots.Linear(plt_series[:x], plt_series[:y]; plt_kwargs...)
-    elseif line_type == :contour
-        PGFPlots.Contour(plt_series[:z].surf, plt_series[:x], plt_series[:y])
+    # function args
+    args = if st  == :contour
+        d[:z].surf, d[:x], d[:y]
+    elseif is3d(st)
+        d[:x], d[:y], d[:z]
+    else
+        d[:x], d[:y]
     end
-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
 
-function _create_plot(pkg::PGFPlotsBackend, 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
-  Plot(nothing, pkg, 0, d, KW[])
+    # include additional style, then add to the kw
+    if haskey(_pgf_series_extrastyle, st)
+        push!(style, _pgf_series_extrastyle[st])
+    end
+    kw[:style] = join(style, ',')
+
+    # build/return the series object
+    func = if st == :path3d
+        PGFPlots.Linear3
+    elseif st == :scatter
+        PGFPlots.Scatter
+    elseif st == :histogram2d
+        PGFPlots.Histogram2
+    elseif st == :contour
+        PGFPlots.Contour
+    else
+        PGFPlots.Linear
+    end
+    func(args...; kw...)
 end
 
 
-function _add_series(::PGFPlotsBackend, plt::Plot, d::KW)
-  # TODO: add one series to the underlying package
-  push!(plt.seriesargs, d)
-  plt
-end
+# ----------------------------------------------------------------
 
-function _add_annotations{X,Y,V}(plt::Plot{PGFPlotsBackend}, anns::AVec{@compat(Tuple{X,Y,V})})
-  # set or add to the annotation_list
-  if haskey(plt.plotargs, :annotation_list)
-    append!(plt.plotargs[:annotation_list], anns)
-  else
-    plt.plotargs[:annotation_list] = anns
-  end
+function pgf_axis(sp::Subplot, letter)
+    axis = sp[Symbol(letter,:axis)]
+    style = []
+    kw = KW()
+
+    # axis guide
+    kw[Symbol(letter,:label)] = axis[:guide]
+
+    # flip/reverse?
+    axis[:flip] && push!(style, "$letter dir=reverse")
+
+    # scale
+    scale = axis[:scale]
+    if scale in (:log2, :ln, :log10)
+        kw[Symbol(letter,:mode)] = "log"
+        scale == :ln || push!(style, "log basis $letter=$(scale == :log2 ? 2 : 10)")
+    end
+
+    # ticks on or off
+    if axis[:ticks] in (nothing, false)
+        push!(style, "$(letter)majorticks=false")
+    end
+
+    # limits
+    # 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
 end
 
 # ----------------------------------------------------------------
 
-function _before_update_plot(plt::Plot{PGFPlotsBackend})
-end
 
-# TODO: override this to update plot items (title, xlabel, etc) after creation
-function _update_plot(plt::Plot{PGFPlotsBackend}, d::KW)
-end
+function _update_plot_object(plt::Plot{PGFPlotsBackend})
+    plt.o = PGFPlots.Axis[]
+    for sp in plt.subplots
+        # first build the PGFPlots.Axis object
+        style = ["unbounded coords=jump"]
+        kw = KW()
 
-function _update_plot_pos_size(plt::AbstractPlot{PGFPlotsBackend}, d::KW)
-end
-
-# ----------------------------------------------------------------
-
-# accessors for x/y data
-
-# function getxy(plt::Plot{PGFPlotsBackend}, i::Int)
-#   d = plt.seriesargs[i]
-#   d[:x], d[:y]
-# end
-#
-# function setxy!{X,Y}(plt::Plot{PGFPlotsBackend}, xy::Tuple{X,Y}, i::Integer)
-#   d = plt.seriesargs[i]
-#   d[:x], d[:y] = xy
-#   plt
-# end
-
-# ----------------------------------------------------------------
-
-function _create_subplot(subplt::Subplot{PGFPlotsBackend}, isbefore::Bool)
-  # TODO: build the underlying Subplot object.  this is where you might layout the panes within a GUI window, for example
-  true
-end
-
-function _expand_limits(lims, plt::Plot{PGFPlotsBackend}, isx::Bool)
-  # TODO: call expand limits for each plot data
-end
-
-function _remove_axis(plt::Plot{PGFPlotsBackend}, isx::Bool)
-  # TODO: if plot is inner subplot, might need to remove ticks or axis labels
-end
-
-# ----------------------------------------------------------------
-
-function _pgfplots_get_axis_kwargs(d)
-    axisargs = KW()
-    for arg in (:xlabel, :ylabel, :zlabel, :title)
-        axisargs[arg] = d[arg]
-    end
-    axisargs[:style] = ""
-    axisargs[:style] *= d[:xflip] == true ? "x dir=reverse," : ""
-    axisargs[:style] *= d[:yflip] == true ? "y dir=reverse," : ""
-    if d[:xscale] in (:log, :log2, :ln, :log10)
-        axisargs[:xmode] = "log"
-        if d[:xscale] == :log2
-            axisargs[:style] *= "log basis x=2,"
-        elseif d[:xscale] in (:log, :log10)
-            axisargs[:style] *= "log basis x=10,"
+        # add to style/kw for each axis
+        for letter in (:x, :y, :z)
+            if letter != :z || is3d(sp)
+                axisstyle, axiskw = pgf_axis(sp, letter)
+                append!(style, axisstyle)
+                merge!(kw, axiskw)
+            end
         end
-    end
-    if d[:yscale] in (:log, :log2, :ln, :log10)
-        axisargs[:ymode] = "log"
-        if d[:yscale] == :log2
-            axisargs[:style] *= "log basis y=2,"
-        elseif d[:yscale] in (:log, :log10)
-            axisargs[:style] *= "log basis x=10,"
+
+        # bounding box values are in mm
+        # note: bb origin is top-left, pgf is bottom-left
+        bb = bbox(sp)
+        push!(style, """
+            xshift = $(left(bb).value)mm,
+            yshift = $((height(bb) - (bottom(bb))).value)mm,
+            axis background/.style={fill=$(pgf_color(sp[:background_color_inside])[1])}
+        """)
+        kw[:width] = "$(width(bb).value)mm"
+        kw[:height] = "$(height(bb).value)mm"
+
+        if sp[:title] != ""
+            kw[:title] = "$(sp[:title])"
         end
-    end
-    if d[:zscale] in (:log, :log2, :ln, :log10)
-        axisargs[:zmode] = "log"
-        if d[:zscale] == :log2
-            axisargs[:style] *= "log basis z=2,"
-        elseif d[:zscale] in (:log, :log10)
-            axisargs[:style] *= "log basis x=10,"
+
+        sp[:grid] && push!(style, "grid = major")
+        if sp[:aspect_ratio] in (1, :equal)
+            kw[:axisEqual] = "true"
         end
-    end
 
-    # Control background color
-    axisargs[:style] *= "axis background/.style={fill=$(_pgfplots_get_color(d, :background_color))},"
-    # Control x/y-limits
-    if d[:xlims] !== :auto
-        axisargs[:xmin] = d[:xlims][1]
-        axisargs[:xmax] = d[:xlims][2]
-    end
-    if d[:ylims] !== :auto
-        axisargs[:ymin] = d[:ylims][1]
-        axisargs[:ymax] = d[:ylims][2]
-    end
-    if d[:grid] == true
-        axisargs[:style] *= "grid = major"
-    elseif d[:grid] == false
+        legpos = sp[:legend]
+        if haskey(_pgfplots_legend_pos, legpos)
+            kw[:legendPos] = _pgfplots_legend_pos[legpos]
+        end
 
-    end
+        o = PGFPlots.Axis(; style = style, kw...)
 
-    axisargs
+        # add the series object to the PGFPlots.Axis
+        for series in series_list(sp)
+            push!(o, pgf_series(sp, series))
+        end
+
+        # add the PGFPlots.Axis to the list
+        push!(plt.o, o)
+    end
 end
 
-# ----------------------------------------------------------------
 
-#################  This is the important method to implement!!! #################
-function _make_pgf_plot(plt::Plot{PGFPlotsBackend})
-    os = [_pgfplots_axis(plt_series) for plt_series in plt.seriesargs]
-    axisargs  =_pgfplots_get_axis_kwargs(plt.plotargs)
-    plt.o = PGFPlots.Axis([os...]; axisargs...)
+function _show(io::IO, mime::MIME"image/svg+xml", plt::Plot{PGFPlotsBackend})
+    show(io, mime, plt.o)
 end
 
-function Base.writemime(io::IO, mime::MIME"image/svg+xml", plt::AbstractPlot{PGFPlotsBackend})
-  plt.o = _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, readall(open(fn)))
+
+    # cleanup
+    PGFPlots.cleanup(plt.o)
 end
 
-# function Base.writemime(io::IO, ::MIME"text/html", plt::AbstractPlot{PGFPlotsBackend})
-# end
+function _display(plt::Plot{PGFPlotsBackend})
+    # prepare the object
+    pgfplt = PGFPlots.plot(plt.o)
 
-function Base.display(::PlotsDisplay, plt::AbstractPlot{PGFPlotsBackend})
-  plt.o = _make_pgf_plot(plt)
-  display(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
-
-# function Base.display(::PlotsDisplay, plt::Subplot{PGFPlotsBackend})
-#   # TODO: display/show the subplot
-# end

src/backends/plotlyjs.jl

@@ -1,206 +1,99 @@
 
 # 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,
-    :linetype,
-    :linewidth,
-    :linealpha,
-    :markershape,
-    :markercolor,
-    :markersize,
-    :markeralpha,
-    :markerstrokewidth,
-    :markerstrokecolor,
-    :markerstrokestyle,
-    :n,
-    :bins,
-    :nc,
-    :nr,
-    # :pos,
-    # :smooth,
-    :show,
-    :size,
-    :title,
-    :windowtitle,
-    :x,
-    :xlabel,
-    :xlims,
-    :xticks,
-    :y,
-    :ylabel,
-    :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,
-                                   :hist2d, :hist, :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[])
+function _create_backend_figure(plt::Plot{PlotlyJSBackend})
+    PlotlyJS.plot()
 end
 
 
-function _add_series(::PlotlyJSBackend, plt::Plot, d::KW)
+function _series_added(plt::Plot{PlotlyJSBackend}, series::Series)
     syncplot = plt.o
-
-    # add to the data array
-    pdict = plotly_series(d, plt.plotargs)
-    typ = pop!(pdict, :type)
-    gt = PlotlyJS.GenericTrace(typ; pdict...)
-    PlotlyJS.addtraces!(syncplot, gt)
-
-    push!(plt.seriesargs, d)
-    plt
-end
-
-
-# ---------------------------------------------------------------------------
-
-
-function _add_annotations{X,Y,V}(plt::Plot{PlotlyJSBackend}, anns::AVec{@compat(Tuple{X,Y,V})})
-    # set or add to the annotation_list
-    if !haskey(plt.plotargs, :annotation_list)
-        plt.plotargs[:annotation_list] = Any[]
+    pdicts = plotly_series(plt, series)
+    for pdict in pdicts
+        typ = pop!(pdict, :type)
+        gt = PlotlyJS.GenericTrace(typ; pdict...)
+        PlotlyJS.addtraces!(syncplot, gt)
     end
-    append!(plt.plotargs[:annotation_list], anns)
 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] = (transpose_z(series, series[:z].surf, false),)
+    end
+    PlotlyJS.restyle!(
+        plt.o,
+        findfirst(plt.series_list, series),
+        kw
+    )
+end
+
+
 # ----------------------------------------------------------------
 
-function _before_update_plot(plt::Plot{PlotlyJSBackend})
-end
-
-# TODO: override this to update plot items (title, xlabel, etc) after creation
-function _update_plot(plt::Plot{PlotlyJSBackend}, d::KW)
-    pdict = plotly_layout(d)
+function _update_plot_object(plt::Plot{PlotlyJSBackend})
+    pdict = plotly_layout(plt)
     syncplot = plt.o
-    w,h = d[:size]
+    w,h = plt[:size]
     PlotlyJS.relayout!(syncplot, pdict, width = w, height = h)
 end
 
 
-function _update_plot_pos_size(plt::AbstractPlot{PlotlyJSBackend}, d::KW)
-end
-
 # ----------------------------------------------------------------
 
-# accessors for x/y data
-
-# 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.plotargs, :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
+function _show(io::IO, ::MIME"image/svg+xml", plt::Plot{PlotlyJSBackend})
+    show(io, MIME("text/html"), plt.o)
 end
 
-# ----------------------------------------------------------------
-
-function _create_subplot(subplt::Subplot{PlotlyJSBackend}, isbefore::Bool)
-  # TODO: build the underlying Subplot object.  this is where you might layout the panes within a GUI window, for example
-  true
+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 _expand_limits(lims, plt::Plot{PlotlyJSBackend}, isx::Bool)
-  # TODO: call expand limits for each plot data
-end
-
-function _remove_axis(plt::Plot{PlotlyJSBackend}, isx::Bool)
-  # TODO: if plot is inner subplot, might need to remove ticks or axis labels
-end
-
-# ----------------------------------------------------------------
-
-# function Base.writemime(io::IO, m::MIME"text/html", plt::AbstractPlot{PlotlyJSBackend})
-#     Base.writemime(io, m, plt.o)
-# end
-
-# function Base.writemime(io::IO, ::MIME"image/png", plt::AbstractPlot{PlotlyJSBackend})
-#     println("here!")
-#     writemime_png_from_html(io, plt)
-# end
-
-function Base.display(::PlotsDisplay, plt::Plot{PlotlyJSBackend})
+function _display(plt::Plot{PlotlyJSBackend})
     display(plt.o)
 end
-
-function Base.display(::PlotsDisplay, plt::Subplot{PlotlyJSBackend})
-    error()
-end

src/backends/supported.jl

@@ -1,698 +0,0 @@
-#
-# supportedAxes(::AbstractBackend) = [:left]
-# supportedTypes(::AbstractBackend) = []
-# supportedStyles(::AbstractBackend) = [:solid]
-# supportedMarkers(::AbstractBackend) = [:none]
-# supportedScales(::AbstractBackend) = [:identity]
-# subplotSupported(::AbstractBackend) = false
-# stringsSupported(::AbstractBackend) = false
-#
-# supportedAxes() = supportedAxes(backend())
-# supportedTypes() = supportedTypes(backend())
-# supportedStyles() = supportedStyles(backend())
-# supportedMarkers() = supportedMarkers(backend())
-# supportedScales() = supportedScales(backend())
-# subplotSupported() = subplotSupported(backend())
-# stringsSupported() = stringsSupported(backend())
-
-
-# --------------------------------------------------------------------------------------
-#
-#
-# supportedArgs(::GadflyBackend) = [
-#     :annotation,
-#     :background_color, :foreground_color, :color_palette,
-#     :group,
-#     :label,
-#     :linetype,
-#     :seriescolor, :seriesalpha,
-#     :linecolor, :linestyle, :linewidth, :linealpha,
-#     :markershape, :markercolor, :markersize, :markeralpha,
-#     :markerstrokewidth, :markerstrokecolor, :markerstrokealpha,
-#     :fillrange, :fillcolor, :fillalpha,
-#     :bins,
-#     :n, :nc, :nr, :layout,
-#     :smooth,
-#     :title, :windowtitle, :show, :size,
-#     :x, :xlabel, :xlims, :xticks, :xscale, :xflip,
-#     :y, :ylabel, :ylims, :yticks, :yscale, :yflip,
-#     # :z, :zlabel, :zlims, :zticks, :zscale, :zflip,
-#     :z,
-#     :tickfont, :guidefont, :legendfont,
-#     :grid, :legend, :colorbar,
-#     :marker_z, :levels,
-#     :xerror, :yerror,
-#     :ribbon, :quiver,
-#     :orientation,
-#   ]
-# supportedAxes(::GadflyBackend) = [:auto, :left]
-# supportedTypes(::GadflyBackend) = [
-#         :none, :line, :path, :steppre, :steppost, :sticks,
-#         :scatter, :hist2d, :hexbin, :hist,
-#         :bar, :box, :violin, :quiver,
-#         :hline, :vline, :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
-#
-#
-# # --------------------------------------------------------------------------------------
-
-#
-# 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
-#
-# # --------------------------------------------------------------------------------------
-
-#
-#
-# supportedArgs(::PyPlotBackend) = [
-#     :annotation,
-#     :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,
-#     :label,
-#     :linetype,
-#     :seriescolor, :seriesalpha,
-#     :linecolor, :linestyle, :linewidth, :linealpha,
-#     :markershape, :markercolor, :markersize, :markeralpha,
-#     :markerstrokewidth, :markerstrokecolor, :markerstrokealpha,
-#     :fillrange, :fillcolor, :fillalpha,
-#     :bins,
-#     :n, :nc, :nr, :layout,
-#     :smooth,
-#     :title, :windowtitle, :show, :size,
-#     :x, :xlabel, :xlims, :xticks, :xscale, :xflip,
-#     :y, :ylabel, :ylims, :yticks, :yscale, :yflip,
-#     :axis, :yrightlabel,
-#     :z, :zlabel, :zlims, :zticks, :zscale, :zflip,
-#     :z,
-#     :tickfont, :guidefont, :legendfont,
-#     :grid, :legend, :colorbar,
-#     :marker_z, :levels,
-#     :xerror, :yerror,
-#     :ribbon, :quiver,
-#     :orientation,
-#     :overwrite_figure,
-#     :polar,
-#     :normalize, :weights, :contours, :aspect_ratio
-#   ]
-# supportedAxes(::PyPlotBackend) = _allAxes
-# supportedTypes(::PyPlotBackend) = [
-#         :none, :line, :path, :steppre, :steppost, :shape,
-#         :scatter, :hist2d, :hexbin, :hist, :density,
-#         :bar, :sticks, :box, :violin, :quiver,
-#         :hline, :vline, :heatmap, :pie,
-#         :contour, :contour3d, :path3d, :scatter3d, :surface, :wireframe
-#     ]
-# supportedStyles(::PyPlotBackend) = [:auto, :solid, :dash, :dot, :dashdot]
-# supportedMarkers(::PyPlotBackend) = vcat(_allMarkers, Shape)
-# supportedScales(::PyPlotBackend) = [:identity, :ln, :log2, :log10]
-# subplotSupported(::PyPlotBackend) = true
-#
-#
-# # --------------------------------------------------------------------------------------
-
-#
-#
-# supportedArgs(::GRBackend) = [
-#     :annotation,
-#     :background_color, :foreground_color, :color_palette,
-#     :group,
-#     :label,
-#     :linetype,
-#     :seriescolor, :seriesalpha,
-#     :linecolor, :linestyle, :linewidth, :linealpha,
-#     :markershape, :markercolor, :markersize, :markeralpha,
-#     :markerstrokewidth, :markerstrokecolor, :markerstrokealpha,
-#     :fillrange, :fillcolor, :fillalpha,
-#     :bins,
-#     :n, :nc, :nr, :layout,
-#     :smooth,
-#     :title, :windowtitle, :show, :size,
-#     :x, :xlabel, :xlims, :xticks, :xscale, :xflip,
-#     :y, :ylabel, :ylims, :yticks, :yscale, :yflip,
-#     :axis, :yrightlabel,
-#     :z, :zlabel, :zlims, :zticks, :zscale, :zflip,
-#     :z,
-#     :tickfont, :guidefont, :legendfont,
-#     :grid, :legend, :colorbar,
-#     :marker_z, :levels,
-#     :xerror, :yerror,
-#     :ribbon, :quiver,
-#     :orientation,
-#     :overwrite_figure,
-#     :polar,
-#   ]
-# supportedAxes(::GRBackend) = _allAxes
-# supportedTypes(::GRBackend) = [:none, :line, :path, :steppre, :steppost, :sticks,
-#                                :scatter, :hist2d, :hexbin, :hist, :density, :bar,
-#                                :hline, :vline, :contour, :heatmap, :path3d, :scatter3d, :surface,
-#                                :wireframe, :ohlc, :pie]
-# supportedStyles(::GRBackend) = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
-# supportedMarkers(::GRBackend) = vcat(_allMarkers, Shape)
-# supportedScales(::GRBackend) = [:identity, :log10]
-# subplotSupported(::GRBackend) = true
-#
-#
-# # --------------------------------------------------------------------------------------
-
-#
-#
-# supportedArgs(::QwtBackend) = [
-#     :annotation,
-#     :axis,
-#     :background_color,
-#     :linecolor,
-#     :color_palette,
-#     :fillrange,
-#     :fillcolor,
-#     :foreground_color,
-#     :group,
-#     :label,
-#     :layout,
-#     :legend,
-#     :seriescolor, :seriesalpha,
-#     :linestyle,
-#     :linetype,
-#     :linewidth,
-#     :markershape,
-#     :markercolor,
-#     :markersize,
-#     :n,
-#     :bins,
-#     :nc,
-#     :nr,
-#     :pos,
-#     :smooth,
-#     :show,
-#     :size,
-#     :title,
-#     :windowtitle,
-#     :x,
-#     :xlabel,
-#     :xlims,
-#     :xticks,
-#     :y,
-#     :ylabel,
-#     :ylims,
-#     :yrightlabel,
-#     :yticks,
-#     :xscale,
-#     :yscale,
-#   ]
-# supportedTypes(::QwtBackend) = [:none, :line, :path, :steppre, :steppost, :sticks, :scatter, :hist2d, :hexbin, :hist, :bar, :hline, :vline]
-# supportedMarkers(::QwtBackend) = [:none, :auto, :rect, :ellipse, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5, :star8, :hexagon]
-# supportedScales(::QwtBackend) = [:identity, :log10]
-# subplotSupported(::QwtBackend) = true
-#
-#
-# # --------------------------------------------------------------------------------------
-
-#
-# supportedArgs(::UnicodePlotsBackend) = [
-#     # :annotation,
-#     # :args,
-#     # :axis,
-#     # :background_color,
-#     # :linecolor,
-#     # :fill,
-#     # :foreground_color,
-#     :group,
-#     # :heatmap_c,
-#     # :kwargs,
-#     :label,
-#     # :layout,
-#     :legend,
-#     :seriescolor, :seriesalpha,
-#     :linestyle,
-#     :linetype,
-#     # :linewidth,
-#     :markershape,
-#     # :markercolor,
-#     # :markersize,
-#     # :markerstrokewidth,
-#     # :markerstrokecolor,
-#     # :markerstrokestyle,
-#     # :n,
-#     :bins,
-#     # :nc,
-#     # :nr,
-#     # :pos,
-#     # :reg,
-#     # :ribbon,
-#     :show,
-#     :size,
-#     :title,
-#     :windowtitle,
-#     :x,
-#     :xlabel,
-#     :xlims,
-#     # :xticks,
-#     :y,
-#     :ylabel,
-#     :ylims,
-#     # :yrightlabel,
-#     # :yticks,
-#     # :xscale,
-#     # :yscale,
-#     # :xflip,
-#     # :yflip,
-#     # :z,
-#   ]
-# supportedAxes(::UnicodePlotsBackend) = [:auto, :left]
-# supportedTypes(::UnicodePlotsBackend) = [:none, :line, :path, :steppre, :steppost, :sticks, :scatter, :hist2d, :hexbin, :hist, :bar, :hline, :vline]
-# supportedStyles(::UnicodePlotsBackend) = [:auto, :solid]
-# supportedMarkers(::UnicodePlotsBackend) = [:none, :auto, :ellipse]
-# supportedScales(::UnicodePlotsBackend) = [:identity]
-# subplotSupported(::UnicodePlotsBackend) = true
-#
-#
-#
-#
-# # --------------------------------------------------------------------------------------
-
-#
-# supportedArgs(::WinstonBackend) = [
-#     :annotation,
-#     # :args,
-#     # :axis,
-#     # :background_color,
-#     :linecolor,
-#     :color_palette,
-#     :fillrange,
-#     :fillcolor,
-#     # :foreground_color,
-#     :group,
-#     # :heatmap_c,
-#     # :kwargs,
-#     :label,
-#     # :layout,
-#     :legend,
-#     :seriescolor, :seriesalpha,
-#     :linestyle,
-#     :linetype,
-#     :linewidth,
-#     :markershape,
-#     :markercolor,
-#     :markersize,
-#     # :markerstrokewidth,
-#     # :markerstrokecolor,
-#     # :markerstrokestyle,
-#     # :n,
-#     :bins,
-#     # :nc,
-#     # :nr,
-#     # :pos,
-#     :smooth,
-#     # :ribbon,
-#     :show,
-#     :size,
-#     :title,
-#     :windowtitle,
-#     :x,
-#     :xlabel,
-#     :xlims,
-#     # :xticks,
-#     :y,
-#     :ylabel,
-#     :ylims,
-#     # :yrightlabel,
-#     # :yticks,
-#     :xscale,
-#     :yscale,
-#     # :xflip,
-#     # :yflip,
-#     # :z,
-#   ]
-# supportedAxes(::WinstonBackend) = [:auto, :left]
-# supportedTypes(::WinstonBackend) = [:none, :line, :path, :sticks, :scatter, :hist, :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
-#
-#
-# # --------------------------------------------------------------------------------------
-
-#
-#
-# supportedArgs(::BokehBackend) = [
-#     # :annotation,
-#     # :axis,
-#     # :background_color,
-#     :linecolor,
-#     # :color_palette,
-#     # :fillrange,
-#     # :fillcolor,
-#     # :fillalpha,
-#     # :foreground_color,
-#     :group,
-#     # :label,
-#     # :layout,
-#     # :legend,
-#     :seriescolor, :seriesalpha,
-#     :linestyle,
-#     :linetype,
-#     :linewidth,
-#     # :linealpha,
-#     :markershape,
-#     :markercolor,
-#     :markersize,
-#     # :markeralpha,
-#     # :markerstrokewidth,
-#     # :markerstrokecolor,
-#     # :markerstrokestyle,
-#     # :n,
-#     # :bins,
-#     # :nc,
-#     # :nr,
-#     # :pos,
-#     # :smooth,
-#     # :show,
-#     :size,
-#     :title,
-#     # :windowtitle,
-#     :x,
-#     # :xlabel,
-#     # :xlims,
-#     # :xticks,
-#     :y,
-#     # :ylabel,
-#     # :ylims,
-#     # :yrightlabel,
-#     # :yticks,
-#     # :xscale,
-#     # :yscale,
-#     # :xflip,
-#     # :yflip,
-#     # :z,
-#     # :tickfont,
-#     # :guidefont,
-#     # :legendfont,
-#     # :grid,
-#     # :surface,
-#     # :levels,
-#   ]
-# supportedAxes(::BokehBackend) = [:auto, :left]
-# supportedTypes(::BokehBackend) = [:none, :path, :scatter] #,:steppre, :steppost, :sticks, :hist2d, :hexbin, :hist, :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
-#
-#
-# # --------------------------------------------------------------------------------------
-#
-# supportedArgs(::PlotlyBackend) = [
-#     :annotation,
-#     # :axis,
-#     :background_color,
-#     :color_palette,
-#     :fillrange,
-#     :fillcolor,
-#     :fillalpha,
-#     :foreground_color,
-#     :group,
-#     :label,
-#     :layout,
-#     :legend,
-#     :seriescolor, :seriesalpha,
-#     :linecolor,
-#     :linestyle,
-#     :linetype,
-#     :linewidth,
-#     :linealpha,
-#     :markershape,
-#     :markercolor,
-#     :markersize,
-#     :markeralpha,
-#     :markerstrokewidth,
-#     :markerstrokecolor,
-#     :markerstrokestyle,
-#     :n,
-#     :bins,
-#     :nc,
-#     :nr,
-#     # :pos,
-#     # :smooth,
-#     :show,
-#     :size,
-#     :title,
-#     :windowtitle,
-#     :x,
-#     :xlabel,
-#     :xlims,
-#     :xticks,
-#     :y,
-#     :ylabel,
-#     :ylims,
-#     # :yrightlabel,
-#     :yticks,
-#     :xscale,
-#     :yscale,
-#     :xflip,
-#     :yflip,
-#     :z,
-#     :marker_z,
-#     :tickfont,
-#     :guidefont,
-#     :legendfont,
-#     :grid,
-#     :levels,
-#     :xerror,
-#     :yerror,
-#     :ribbon,
-#     :quiver,
-#     :orientation,
-#     :polar,
-#   ]
-# supportedAxes(::PlotlyBackend) = [:auto, :left]
-# supportedTypes(::PlotlyBackend) = [:none, :line, :path, :scatter, :steppre, :steppost,
-#                                    :hist2d, :hist, :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
-#
-#
-# # --------------------------------------------------------------------------------------
-#
-# supportedArgs(::PlotlyJSBackend) = [
-#     :annotation,
-#     # :axis,
-#     :background_color,
-#     :color_palette,
-#     :fillrange,
-#     :fillcolor,
-#     :fillalpha,
-#     :foreground_color,
-#     :group,
-#     :label,
-#     :layout,
-#     :legend,
-#     :seriescolor, :seriesalpha,
-#     :linecolor,
-#     :linestyle,
-#     :linetype,
-#     :linewidth,
-#     :linealpha,
-#     :markershape,
-#     :markercolor,
-#     :markersize,
-#     :markeralpha,
-#     :markerstrokewidth,
-#     :markerstrokecolor,
-#     :markerstrokestyle,
-#     :n,
-#     :bins,
-#     :nc,
-#     :nr,
-#     # :pos,
-#     # :smooth,
-#     :show,
-#     :size,
-#     :title,
-#     :windowtitle,
-#     :x,
-#     :xlabel,
-#     :xlims,
-#     :xticks,
-#     :y,
-#     :ylabel,
-#     :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,
-#                                    :hist2d, :hist, :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
-#
-# # --------------------------------------------------------------------------------------
-#
-# supportedArgs(::GLVisualizeBackend) = [
-#     # :annotation,
-#     # :axis,
-#     # :background_color,
-#     # :color_palette,
-#     # :fillrange,
-#     # :fillcolor,
-#     # :fillalpha,
-#     # :foreground_color,
-#     # :group,
-#     # :label,
-#     # :layout,
-#     # :legend,
-#     # :linecolor,
-#     # :linestyle,
-#      :linetype
-#     #  :seriescolor, :seriesalpha,
-#     # :linewidth,
-#     # :linealpha,
-#     # :markershape,
-#     # :markercolor,
-#     # :markersize,
-#     # :markeralpha,
-#     # :markerstrokewidth,
-#     # :markerstrokecolor,
-#     # :markerstrokestyle,
-#     # :n,
-#     # :bins,
-#     # :nc,
-#     # :nr,
-#     # :pos,
-#     # :smooth,
-#     # :show,
-#     # :size,
-#     # :title,
-#     # :windowtitle,
-#     # :x,
-#     # :xlabel,
-#     # :xlims,
-#     # :xticks,
-#     # :y,
-#     # :ylabel,
-#     # :ylims,
-#     # :yrightlabel,
-#     # :yticks,
-#     # :xscale,
-#     # :yscale,
-#     # :xflip,
-#     # :yflip,
-#     # :z,
-#     # :tickfont,
-#     # :guidefont,
-#     # :legendfont,
-#     # :grid,
-#     # :surface
-#     # :levels,
-#   ]
-# supportedAxes(::GLVisualizeBackend) = [:auto, :left]
-# supportedTypes(::GLVisualizeBackend) = [:surface] #, :path, :scatter ,:steppre, :steppost, :sticks, :heatmap, :hexbin, :hist, :bar, :hline, :vline, :contour]
-# supportedStyles(::GLVisualizeBackend) = [:auto, :solid] #, :dash, :dot, :dashdot, :dashdotdot]
-# supportedMarkers(::GLVisualizeBackend) = [:none, :auto, :ellipse] #, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5] #vcat(_allMarkers, Shape)
-# supportedScales(::GLVisualizeBackend) = [:identity] #, :log, :log2, :log10, :asinh, :sqrt]
-# subplotSupported(::GLVisualizeBackend) = false
-# 
-# # --------------------------------------------------------------------------------------
-#
-# supportedArgs(::PGFPlotsBackend) = [
-#     # :annotation,
-#     # :axis,
-#      :background_color,
-#     # :color_palette,
-#     # :fillrange,
-#      :fillcolor,
-#      :fillalpha,
-#     # :foreground_color,
-#     # :group,
-#     # :label,
-#     # :layout,
-#     # :legend,
-#      :seriescolor, :seriesalpha,
-#      :linecolor,
-#      :linestyle,
-#      :linetype,
-#      :linewidth,
-#      :linealpha,
-#      :markershape,
-#      :markercolor,
-#      :markersize,
-#      :markeralpha,
-#     # :markerstrokewidth,
-#      :markerstrokecolor,
-#      :markerstrokestyle,
-#     # :n,
-#     # :bins,
-#     # :nc,
-#     # :nr,
-#     # :pos,
-#     # :smooth,
-#     # :show,
-#     # :size,
-#      :title,
-#     # :windowtitle,
-#      :x,
-#      :xlabel,
-#      :xlims,
-#     # :xticks,
-#      :y,
-#      :ylabel,
-#      :ylims,
-#     # :yrightlabel,
-#     # :yticks,
-#      :xscale,
-#      :yscale,
-#      :xflip,
-#      :yflip,
-#      :z,
-#      :zscale,
-#     # :tickfont,
-#     # :guidefont,
-#     # :legendfont,
-#      :grid,
-#     # :surface
-#     # :levels,
-#   ]
-# supportedAxes(::PGFPlotsBackend) = [:auto, :left]
-# supportedTypes(::PGFPlotsBackend) = [:path, :path3d, :scatter, :line, :steppre, :stepmid, :steppost, :hist, :bar, :hist2d, :sticks, :ysticks, :xsticks, :contour] #  :hexbin, :hline, :vline,]
-# 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, :log, :ln, :log2, :log10] # :asinh, :sqrt]
-# subplotSupported(::PGFPlotsBackend) = false

src/backends/template.jl

@@ -1,87 +1,75 @@
 
-# TODO: find/replace all [PkgName] with CamelCase, all [pkgname] with lowercase
+# TODO: find/replace all [PkgName] with CamelCase
 
-# [WEBSITE]
+# [ADD BACKEND WEBSITE]
 
-function _initialize_backend(::[PkgName]AbstractBackend; kw...)
-  @eval begin
-    import [PkgName]
-    export [PkgName]
-    # TODO: other initialization that needs to be eval-ed
-  end
-  # TODO: other initialization
+function _initialize_backend(::[PkgName]Backend; kw...)
+    @eval begin
+        import [PkgName]
+        export [PkgName]
+        # todo: other initialization that needs to be eval-ed
+    end
+    # todo: other initialization
 end
 
 # ---------------------------------------------------------------------------
 
-function _create_plot(pkg::[PkgName]AbstractBackend, 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
-  Plot(nothing, pkg, 0, d, KW[])
+# Create the window/figure for this backend.
+function _create_backend_figure(plt::Plot{[PkgName]Backend})
+    nothing
 end
 
-
-function _add_series(::[PkgName]AbstractBackend, plt::Plot, d::KW)
-  # TODO: add one series to the underlying package
-  push!(plt.seriesargs, d)
-  plt
-end
-
-function _add_annotations{X,Y,V}(plt::Plot{[PkgName]AbstractBackend}, anns::AVec{@compat(Tuple{X,Y,V})})
-  for ann in anns
-    # TODO: add the annotation to the plot
-  end
-end
-
-# ----------------------------------------------------------------
-
-function _before_update_plot(plt::Plot{[PkgName]AbstractBackend})
-end
-
-# TODO: override this to update plot items (title, xlabel, etc) after creation
-function _update_plot(plt::Plot{[PkgName]AbstractBackend}, d::KW)
-end
-
-function _update_plot_pos_size(plt::AbstractPlot{[PkgName]AbstractBackend}, d::KW)
-end
-
-# ----------------------------------------------------------------
-
-# accessors for x/y data
-
-# function getxy(plt::Plot{[PkgName]AbstractBackend}, i::Int)
-#   # TODO: return a tuple of (x, y) vectors
-# end
-#
-# function setxy!{X,Y}(plt::Plot{[PkgName]AbstractBackend}, xy::Tuple{X,Y}, i::Integer)
-#   # TODO: set the plot data from the (x,y) tuple
-#   plt
+# # this is called early in the pipeline, use it to make the plot current or something
+# function _prepare_plot_object(plt::Plot{[PkgName]Backend})
 # end
 
+# Set up the subplot within the backend object.
+function _initialize_subplot(plt::Plot{[PkgName]Backend}, sp::Subplot{[PkgName]Backend})
+end
+
+# ---------------------------------------------------------------------------
+
+# Add one series to the underlying backend object.
+function _series_added(plt::Plot{[PkgName]Backend}, series::Series)
+end
+
+# When series data is added/changed, this callback can do dynamic updates to the backend object.
+# note: if the backend rebuilds the plot from scratch on display, then you might not do anything here.
+function _series_updated(plt::Plot{[PkgName]Backend}, series::Series)
+end
+
+# ---------------------------------------------------------------------------
+
+# called just before updating layout bounding boxes... in case you need to prep
+# for the calcs
+function _before_layout_calcs(plt::Plot{[PkgName]Backend})
+end
+
+# Set the (left, top, right, bottom) minimum padding around the plot area
+# to fit ticks, tick labels, guides, colorbars, etc.
+function _update_min_padding!(sp::Subplot{[PkgName]Backend})
+    sp.minpad = (20mm, 5mm, 2mm, 10mm)
+end
+
+
 # ----------------------------------------------------------------
 
-function _create_subplot(subplt::Subplot{[PkgName]AbstractBackend}, isbefore::Bool)
-  # TODO: build the underlying Subplot object.  this is where you might layout the panes within a GUI window, for example
-end
-
-function _expand_limits(lims, plt::Plot{[PkgName]AbstractBackend}, isx::Bool)
-  # TODO: call expand limits for each plot data
-end
-
-function _remove_axis(plt::Plot{[PkgName]AbstractBackend}, isx::Bool)
-  # TODO: if plot is inner subplot, might need to remove ticks or axis labels
+# Override this to update plot items (title, xlabel, etc), and add annotations (d[:annotations])
+function _update_plot_object(plt::Plot{[PkgName]Backend})
 end
 
 # ----------------------------------------------------------------
 
-function Base.writemime(io::IO, ::MIME"image/png", plt::AbstractPlot{[PkgName]AbstractBackend})
-  # TODO: write a png to io
+# Write a png to io.  You could define methods for:
+    # "application/eps"         => "eps",
+    # "image/eps"               => "eps",
+    # "application/pdf"         => "pdf",
+    # "image/png"               => "png",
+    # "application/postscript"  => "ps",
+    # "image/svg+xml"           => "svg"
+function _show(io::IO, ::MIME"image/png", plt::Plot{[PkgName]Backend})
 end
 
-function Base.display(::PlotsDisplay, plt::Plot{[PkgName]AbstractBackend})
-  # TODO: display/show the plot
-end
-
-function Base.display(::PlotsDisplay, plt::Subplot{[PkgName]AbstractBackend})
-  # TODO: display/show the subplot
+# Display/show the plot (open a GUI window, or browser page, for example).
+function _display(plt::Plot{[PkgName]Backend})
 end

src/backends/unicodeplots.jl

@@ -1,263 +1,197 @@
 
 # https://github.com/Evizero/UnicodePlots.jl
 
-supportedArgs(::UnicodePlotsBackend) = [
-    # :annotation,
-    # :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,
-    :linetype,
-    # :linewidth,
     :markershape,
-    # :markercolor,
-    # :markersize,
-    # :markerstrokewidth,
-    # :markerstrokecolor,
-    # :markerstrokestyle,
-    # :n,
     :bins,
-    # :nc,
-    # :nr,
-    # :pos,
-    # :reg,
-    # :ribbon,
-    :show,
-    :size,
     :title,
-    :windowtitle,
-    :x,
-    :xlabel,
-    :xlims,
-    # :xticks,
-    :y,
-    :ylabel,
-    :ylims,
-    # :yrightlabel,
-    # :yticks,
-    # :xscale,
-    # :yscale,
-    # :xflip,
-    # :yflip,
-    # :z,
-  ]
-supportedAxes(::UnicodePlotsBackend) = [:auto, :left]
-supportedTypes(::UnicodePlotsBackend) = [:none, :line, :path, :steppre, :steppost, :sticks, :scatter, :hist2d, :hexbin, :hist, :bar, :hline, :vline]
-supportedStyles(::UnicodePlotsBackend) = [:auto, :solid]
-supportedMarkers(::UnicodePlotsBackend) = [:none, :auto, :ellipse]
-supportedScales(::UnicodePlotsBackend) = [:identity]
-subplotSupported(::UnicodePlotsBackend) = true
-
+    :guide, :lims,
+  ])
+const _unicodeplots_seriestype = [
+    :path, :scatter,
+    # :bar,
+    :shape,
+    :histogram2d,
+    :spy
+]
+const _unicodeplots_style = [:auto, :solid]
+const _unicodeplots_marker = [:none, :auto, :circle]
+const _unicodeplots_scale = [:identity]
 
 
+# don't warn on unsupported... there's just too many warnings!!
+warnOnUnsupported_args(::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
 
 # -------------------------------
 
 
 # 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 = []
 
-  # figure out the plotting area xlim = [xmin, xmax] and ylim = [ymin, ymax]
-  sargs = plt.seriesargs
-  iargs = plt.plotargs
+    for sp in plt.subplots
+        xaxis = sp[:xaxis]
+        yaxis = sp[:yaxis]
+        xlim =  axis_limits(xaxis)
+        ylim =  axis_limits(yaxis)
 
-  # get the x/y limits
-  if get(iargs, :xlims, :auto) == :auto
-    xlim = [Inf, -Inf]
-    for d in sargs
-      _expand_limits(xlim, d[:x])
+        # make vectors
+        xlim = [xlim[1], xlim[2]]
+        ylim = [ylim[1], ylim[2]]
+
+        # we set x/y to have a single point, since we need to create the plot with some data.
+        # since this point is at the bottom left corner of the plot, it shouldn't actually be shown
+        x = Float64[xlim[1]]
+        y = Float64[ylim[1]]
+
+        # create a plot window with xlim/ylim set, but the X/Y vectors are outside the bounds
+        canvas_type = isijulia() ? UnicodePlots.AsciiCanvas : UnicodePlots.BrailleCanvas
+
+        # special handling for spy
+        if length(sp.series_list) == 1
+            series = sp.series_list[1]
+            if series[:seriestype] == :spy
+                push!(plt.o, UnicodePlots.spy(
+                    series[:z].surf,
+                    width = width,
+                    height = height,
+                    title = sp[:title],
+                    canvas = canvas_type
+                ))
+                continue
+            end
+        end
+
+        # # make it a bar canvas if plotting bar
+        # if any(series -> series[:seriestype] == :bar, series_list(sp))
+        #     canvas_type = UnicodePlots.BarplotGraphics
+        # end
+
+        o = UnicodePlots.Plot(x, y, canvas_type;
+            width = width,
+            height = height,
+            title = sp[:title],
+            xlim = xlim,
+            ylim = ylim,
+            border = isijulia() ? :ascii : :solid
+        )
+
+        # set the axis labels
+        UnicodePlots.xlabel!(o, xaxis[:guide])
+        UnicodePlots.ylabel!(o, yaxis[:guide])
+
+        # now use the ! functions to add to the plot
+        for series in series_list(sp)
+            addUnicodeSeries!(o, series.d, sp[:legend] != :none, xlim, ylim)
+        end
+
+        # save the object
+        push!(plt.o, o)
     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[:xlabel])
-  UnicodePlots.ylabel!(o, iargs[:ylabel])
-
-  # 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
-  lt = d[:linetype]
-
-  # handle hline/vline separately
-  if lt in (:hline,:vline)
-    for yi in d[:y]
-      if lt == :hline
-        UnicodePlots.lineplot!(o, xlim, [yi,yi])
-      else
-        UnicodePlots.lineplot!(o, [yi,yi], ylim)
-      end
+    # get the function, or special handling for step/bar/hist
+    st = d[:seriestype]
+    if st == :histogram2d
+        UnicodePlots.densityplot!(o, d[:x], d[:y])
+        return
     end
-    return
-  end
 
-  stepstyle = :post
-  if lt == :path
-    func = UnicodePlots.lineplot!
-  elseif lt == :scatter || d[:markershape] != :none
-    func = UnicodePlots.scatterplot!
-  elseif lt == :steppost
-    func = UnicodePlots.stairs!
-  elseif lt == :steppre
-    func = UnicodePlots.stairs!
-    stepstyle = :pre
-  else
-    error("Linestyle $lt 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)
-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)]
+    # add the series
+    x, y = Plots.unzip(collect(filter(xy->isfinite(xy[1])&&isfinite(xy[2]), zip(x,y))))
+    func(o, x, y; color = color, name = label)
 end
 
 # -------------------------------
 
+# since this is such a hack, it's only callable using `png`... should error during normal `show`
+function png(plt::AbstractPlot{UnicodePlotsBackend}, fn::AbstractString)
+    fn = addExtension(fn, "png")
 
-function _create_plot(pkg::UnicodePlotsBackend, d::KW)
-  plt = Plot(nothing, pkg, 0, d, KW[])
+    # make some whitespace and show the plot
+    println("\n\n\n\n\n\n")
+    gui(plt)
 
-  # do we want to give a new default size?
-  if !haskey(plt.plotargs, :size) || plt.plotargs[:size] == _plotDefaults[:size]
-    plt.plotargs[:size] = (60,20)
-  end
+    # @osx_only begin
+    @static if is_apple()
+        # BEGIN HACK
 
-  plt
-end
+        # wait while the plot gets drawn
+        sleep(0.5)
 
-function _add_series(::UnicodePlotsBackend, plt::Plot, d::KW)
-  if d[:linetype] in (:sticks, :bar)
-    d = barHack(; d...)
-  elseif d[:linetype] == :hist
-    d = barHack(; histogramHack(; d...)...)
-  end
-  push!(plt.seriesargs, d)
-  plt
-end
+        # 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`)
 
-
-function _update_plot(plt::Plot{UnicodePlotsBackend}, d::KW)
-  for k in (:title, :xlabel, :ylabel, :xlims, :ylims)
-    if haskey(d, k)
-      plt.plotargs[k] = d[k]
+        # END HACK (phew)
+        return
     end
-  end
-end
 
-
-# -------------------------------
-
-# since this is such a hack, it's only callable using `png`... should error during normal `writemime`
-function png(plt::AbstractPlot{UnicodePlotsBackend}, fn::@compat(AbstractString))
-  fn = addExtension(fn, "png")
-
-  # make some whitespace and show the plot
-  println("\n\n\n\n\n\n")
-  gui(plt)
-
-  @osx_only begin
-    # BEGIN HACK
-
-    # wait while the plot gets drawn
-    sleep(0.5)
-
-    # use osx screen capture when my terminal is maximized and cursor starts at the bottom (I know, right?)
-    # TODO: compute size of plot to adjust these numbers (or maybe implement something good??)
-    run(`screencapture -R50,600,700,420 $fn`)
-
-    # END HACK (phew)
-    return
-  end
-
-  error("Can only savepng on osx with UnicodePlots (though even then I wouldn't do it)")
+    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
+function unicodeplots_rebuild(plt::Plot{UnicodePlotsBackend})
+    w, h = plt[:size]
+    plt.attr[:color_palette] = [RGB(0,0,0)]
+    rebuildUnicodePlot!(plt, div(w, 10), div(h, 20))
+end
+
+function _show(io::IO, ::MIME"text/plain", plt::Plot{UnicodePlotsBackend})
+    unicodeplots_rebuild(plt)
+    map(show, plt.o)
+    nothing
 end
 
 
-function Base.display(::PlotsDisplay, plt::Plot{UnicodePlotsBackend})
-  rebuildUnicodePlot!(plt)
-  show(plt.o)
-end
-
-
-
-function Base.display(::PlotsDisplay, subplt::Subplot{UnicodePlotsBackend})
-  for plt in subplt.plts
-    gui(plt)
-  end
+function _display(plt::Plot{UnicodePlotsBackend})
+    unicodeplots_rebuild(plt)
+    map(show, plt.o)
+    nothing
 end

src/backends/web.jl

@@ -4,7 +4,7 @@
 # CREDIT: parts of this implementation were inspired by @joshday's PlotlyLocal.jl
 
 
-function standalone_html(plt::AbstractPlot; title::AbstractString = get(plt.plotargs, :window_title, "Plots.jl"))
+function standalone_html(plt::AbstractPlot; title::AbstractString = get(plt.attr, :window_title, "Plots.jl"))
     """
     <!DOCTYPE html>
     <html>
@@ -20,14 +20,20 @@ function standalone_html(plt::AbstractPlot; title::AbstractString = get(plt.plot
 end
 
 function open_browser_window(filename::AbstractString)
-    @osx_only   return run(`open $(filename)`)
-    @linux_only return run(`xdg-open $(filename)`)
-    @windows_only return run(`$(ENV["COMSPEC"]) /c start $(filename)`)
+    @static if is_apple()
+        return run(`open $(filename)`)
+    end
+    @static if is_linux()
+        return run(`xdg-open $(filename)`)
+    end
+    @static if is_windows()
+        return run(`$(ENV["COMSPEC"]) /c start $(filename)`)
+    end
     warn("Unknown OS... cannot open browser window.")
 end
 
 function write_temp_html(plt::AbstractPlot)
-    html = standalone_html(plt; title = plt.plotargs[:title])
+    html = standalone_html(plt; title = plt.attr[:window_title])
     filename = string(tempname(), ".html")
     output = open(filename, "w")
     write(output, html)
@@ -45,13 +51,13 @@ 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)
 
     # convert that html file to a temporary png file using wkhtmltoimage
     png_fn = tempname() * ".png"
-    w, h = plt.plotargs[:size]
+    w, h = plt.attr[:size]
     html_to_png(html_fn, png_fn, w, h)
 
     # now read that file data into io

src/components.jl

@@ -12,23 +12,24 @@ compute_angle(v::P2) = (angle = atan2(v[2], v[1]); angle < 0 ? 2π - angle : ang
 # -------------------------------------------------------------
 
 immutable Shape
-  # vertices::AVec
-  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(x, y) = Shape(collect(zip(x, y)))
 Shape(verts::AVec) = Shape(unzip(verts)...)
 
-# get_xs(shape::Shape) = Float64[v[1] for v in shape.vertices]
-# get_ys(shape::Shape) = Float64[v[2] for v in shape.vertices]
 get_xs(shape::Shape) = shape.x
 get_ys(shape::Shape) = shape.y
 vertices(shape::Shape) = collect(zip(shape.x, shape.y))
 
 
 function shape_coords(shape::Shape)
-    # unzip(shape.vertices)
     shape.x, shape.y
 end
 
@@ -36,21 +37,17 @@ function shape_coords(shapes::AVec{Shape})
     length(shapes) == 0 && return zeros(0), zeros(0)
     xs = map(get_xs, shapes)
     ys = map(get_ys, shapes)
-    # x, y = shapes[1].x, shapes[1].y #unzip(shapes[1].vertices)
     x, y = map(copy, shape_coords(shapes[1]))
     for shape in shapes[2:end]
-        # tmpx, tmpy = unzip(shape.vertices)
         nanappend!(x, shape.x)
         nanappend!(y, shape.y)
-        # x = vcat(x, NaN, tmpx)
-        # y = vcat(y, NaN, tmpy)
     end
     x, y
 end
 
 "get an array of tuples of points on a circle with radius `r`"
 function partialcircle(start_θ, end_θ, n = 20, r=1)
-  @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)"
@@ -62,9 +59,6 @@ function weave(x,y; ordering = Vector[x,y])
       try
           push!(ret, shift!(o))
       end
-      # try
-      #     push!(ret, shift!(y))
-      # end
     end
     done = isempty(x) && isempty(y)
   end
@@ -106,8 +100,31 @@ 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,
+  :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),
@@ -123,12 +140,30 @@ const _shapes = KW(
   )
 
 for n in [4,5,6,7,8]
-  _shapes[symbol("star$n")] = makestar(n)
+  _shapes[Symbol("star$n")] = makestar(n)
 end
 
 # -----------------------------------------------------------------------
 
-center(shape::Shape) = (mean(shape.x), mean(shape.y))
+
+# uses the centroid calculation from https://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
+function center(shape::Shape)
+    x, y = shape_coords(shape)
+    n = length(x)
+    A, Cx, Cy = 0.0, 0.0, 0.0
+    for i=1:n
+        ip1 = i==n ? 1 : i+1
+        A += x[i] * y[ip1] - x[ip1] * y[i]
+    end
+    A *= 0.5
+    for i=1:n
+        ip1 = i==n ? 1 : i+1
+        m = (x[i] * y[ip1] - x[ip1] * y[i])
+        Cx += (x[i] + x[ip1]) * m
+        Cy += (y[i] + y[ip1]) * m
+    end
+    Cx / 6A, Cy / 6A
+end
 
 function Base.scale!(shape::Shape, x::Real, y::Real = x, c = center(shape))
     sx, sy = shape_coords(shape)
@@ -176,8 +211,9 @@ function rotate!(shape::Shape, Θ::Real, c = center(shape))
     x, y = shape_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
@@ -213,7 +249,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)
@@ -222,7 +265,7 @@ function font(args...)
       valign = arg
     elseif T <: Colorant
       color = arg
-    elseif T <: @compat Union{Symbol,AbstractString}
+    elseif T <: Symbol || T <: AbstractString
       try
         color = parse(Colorant, string(arg))
       catch
@@ -242,15 +285,25 @@ end
 
 "Wrap a string with font info"
 immutable PlotText
-  str::@compat(AbstractString)
+  str::AbstractString
   font::Font
 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]
+
+
+# -----------------------------------------------------------------------
+
 # -----------------------------------------------------------------------
 
 immutable Stroke
@@ -261,10 +314,6 @@ immutable Stroke
 end
 
 function stroke(args...; alpha = nothing)
-  # defaults
-  # width = 1
-  # color = colorant"black"
-  # style = :solid
   width = nothing
   color = nothing
   style = nothing
@@ -277,14 +326,12 @@ function stroke(args...; alpha = nothing)
       style = arg
     elseif T <: Colorant
       color = arg
-    elseif T <: @compat Union{Symbol,AbstractString}
+    elseif T <: Symbol || T <: AbstractString
       try
         color = parse(Colorant, string(arg))
       end
-    # elseif trueOrAllTrue(a -> typeof(a) <: Real && a > 0 && a < 1, arg)
     elseif allAlphas(arg)
       alpha = arg
-    # elseif typeof(arg) <: Real
     elseif allReals(arg)
       width = arg
     else
@@ -303,9 +350,6 @@ immutable Brush
 end
 
 function brush(args...; alpha = nothing)
-  # defaults
-  # sz = 1
-  # color = colorant"black"
   size = nothing
   color = nothing
 
@@ -314,14 +358,12 @@ function brush(args...; alpha = nothing)
 
     if T <: Colorant
       color = arg
-    elseif T <: @compat Union{Symbol,AbstractString}
+    elseif T <: Symbol || T <: AbstractString
       try
         color = parse(Colorant, string(arg))
       end
-    # elseif trueOrAllTrue(a -> typeof(a) <: Real && a > 0 && a < 1, arg)
     elseif allAlphas(arg)
       alpha = arg
-    # elseif typeof(arg) <: Real
     elseif allReals(arg)
       size = arg
     else
@@ -350,89 +392,170 @@ abstract AbstractSurface
 
 "represents a contour or surface mesh"
 immutable Surface{M<:AMat} <: AbstractSurface
-  # x::AVec
-  # y::AVec
   surf::M
 end
 
-Surface(f::Function, x, y) = Surface(Float64[f(xi,yi) for xi in x, yi in y])
+Surface(f::Function, x, y) = Surface(Float64[f(xi,yi) for yi in y, xi in x])
 
 Base.Array(surf::Surface) = surf.surf
 
 for f in (:length, :size)
   @eval Base.$f(surf::Surface, args...) = $f(surf.surf, args...)
 end
-Base.copy(surf::Surface) = Surface(copy(surf.surf))
+Base.copy(surf::Surface) = Surface{typeof(surf.surf)}(copy(surf.surf))
+Base.eltype{T}(surf::Surface{T}) = eltype(T)
 
+function expand_extrema!(a::Axis, surf::Surface)
+    ex = a[:extrema]
+    for vi in surf.surf
+        expand_extrema!(ex, vi)
+    end
+    ex
+end
 
 "For the case of representing a surface as a function of x/y... can possibly avoid allocations."
 immutable SurfaceFunction <: AbstractSurface
     f::Function
 end
 
+
 # -----------------------------------------------------------------------
 
-type OHLC{T<:Real}
-  open::T
-  high::T
-  low::T
-  close::T
+# # 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
+    headlength::Float64
+    headwidth::Float64
+end
+
+function arrow(args...)
+    style = :simple
+    headlength = 0.3
+    headwidth = 0.3
+    setlength = false
+    for arg in args
+        T = typeof(arg)
+        if T == Symbol
+            style = arg
+        elseif T <: Number
+            # first we apply to both, but if there's more, then only change width after the first number
+            headwidth = Float64(arg)
+            if !setlength
+                headlength = headwidth
+            end
+            setlength = true
+        elseif T <: Tuple && length(arg) == 2
+            headlength, headwidth = Float64(arg[1]), Float64(arg[2])
+        else
+            warn("Skipped arrow arg $arg")
+        end
+    end
+    Arrow(style, headlength, headwidth)
 end
 
 
-# @require FixedSizeArrays begin
-
-  type BezierCurve{T <: FixedSizeArrays.Vec}
-      control_points::Vector{T}
-  end
-
-  function Base.call(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))
-
-  # 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
-      []
+# allow for do-block notation which gets called on every valid start/end pair which
+# we need to draw an arrow
+function add_arrows(func::Function, x::AVec, y::AVec)
+    for i=2:length(x)
+        xyprev = (x[i-1], y[i-1])
+        xy = (x[i], y[i])
+        if ok(xyprev) && ok(xy)
+            if i==length(x) || !ok(x[i+1], y[i+1])
+                # add the arrow from xyprev to xy
+                func(xyprev, xy)
+            end
+        end
     end
+end
 
-    BezierCurve([p, upper_control, inside_control_points..., lower_control, q])
+# -----------------------------------------------------------------------
+
+"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}
+end
+
+function (bc::BezierCurve)(t::Real)
+  p = zero(P2)
+  n = length(bc.control_points)-1
+  for i in 0:n
+      p += bc.control_points[i+1] * binomial(n, i) * (1-t)^(n-i) * t^i
   end
+  p
+end
 
-# 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))
+
+# 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
+  []
+end
+
+BezierCurve([p, upper_control, inside_control_points..., lower_control, q])
+end

src/deprecated/backends/bokeh.jl

@@ -2,8 +2,8 @@
 # https://github.com/bokeh/Bokeh.jl
 
 
-supportedArgs(::BokehBackend) = [
-    # :annotation,
+supported_attrs(::BokehBackend) = merge_with_base_supported([
+    # :annotations,
     # :axis,
     # :background_color,
     :linecolor,
@@ -18,7 +18,7 @@ supportedArgs(::BokehBackend) = [
     # :legend,
     :seriescolor, :seriesalpha,
     :linestyle,
-    :linetype,
+    :seriestype,
     :linewidth,
     # :linealpha,
     :markershape,
@@ -37,13 +37,13 @@ supportedArgs(::BokehBackend) = [
     # :show,
     :size,
     :title,
-    # :windowtitle,
+    # :window_title,
     :x,
-    # :xlabel,
+    # :xguide,
     # :xlims,
     # :xticks,
     :y,
-    # :ylabel,
+    # :yguide,
     # :ylims,
     # :yrightlabel,
     # :yticks,
@@ -58,13 +58,12 @@ supportedArgs(::BokehBackend) = [
     # :grid,
     # :surface,
     # :levels,
-  ]
-supportedAxes(::BokehBackend) = [:auto, :left]
-supportedTypes(::BokehBackend) = [:none, :path, :scatter] #,:steppre, :steppost, :sticks, :hist2d, :hexbin, :hist, :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
 
 
 # --------------------------------------------------------------------------------------
@@ -79,16 +78,9 @@ function _initialize_backend(::BokehBackend; kw...)
   end
 end
 
-# make255(x) = round(Int, 255 * x)
-
-# function bokehcolor(c::Colorant)
-#   @sprintf("rgba(%d, %d, %d, %1.3f)", [make255(f(c)) for f in [red,green,blue]]..., alpha(c))
-# end
-# bokehcolor(cs::ColorScheme) = bokehcolor(getColor(cs))
-
 
 const _glyphtypes = KW(
-    :ellipse    => :Circle,
+    :circle    => :Circle,
     :rect       => :Square,
     :diamond    => :Diamond,
     :utriangle  => :Triangle,
@@ -104,14 +96,14 @@ const _glyphtypes = KW(
 
 
 function bokeh_glyph_type(d::KW)
-  lt = d[:linetype]
+  st = d[:seriestype]
   mt = d[:markershape]
-  if lt == :scatter && mt == :none
-    mt = :ellipse
+  if st == :scatter && mt == :none
+    mt = :circle
   end
 
   # if we have a marker, use that
-  if lt == :scatter || mt != :none
+  if st == :scatter || mt != :none
     return _glyphtypes[mt]
   end
 
@@ -133,28 +125,30 @@ end
 
 # ---------------------------------------------------------------------------
 
-function _create_plot(pkg::BokehBackend, d::KW)
+# function _create_plot(pkg::BokehBackend, d::KW)
+function _create_backend_figure(plt::Plot{BokehBackend})
   # TODO: create the window/canvas/context that is the plot within the backend (call it `o`)
   # TODO: initialize the plot... title, xlabel, bgcolor, etc
 
   datacolumns = Bokeh.BokehDataSet[]
   tools = Bokeh.tools()
   filename = tempname() * ".html"
-  title = d[:title]
-  w, h = d[:size]
-  xaxis_type = d[:xscale] == :log10 ? :log : :auto
-  yaxis_type = d[:yscale] == :log10 ? :log : :auto
-  # legend = d[:legend] ? xxxx : nothing
+  title = plt.attr[:title]
+  w, h = plt.attr[:size]
+  xaxis_type = plt.attr[:xscale] == :log10 ? :log : :auto
+  yaxis_type = plt.attr[:yscale] == :log10 ? :log : :auto
+  # legend = plt.attr[:legend] ? xxxx : nothing
   legend = nothing
   extra_args = KW()  # TODO: we'll put extra settings (xlim, etc) here
-  bplt = Bokeh.Plot(datacolumns, tools, filename, title, w, h, xaxis_type, yaxis_type, legend) #, extra_args)
+  Bokeh.Plot(datacolumns, tools, filename, title, w, h, xaxis_type, yaxis_type, legend) #, extra_args)
 
-  Plot(bplt, pkg, 0, d, KW[])
+  # Plot(bplt, pkg, 0, d, KW[])
 end
 
 
-function _add_series(::BokehBackend, plt::Plot, d::KW)
-  bdata = Dict{Symbol, Vector}(:x => collect(d[:x]), :y => collect(d[:y]))
+# function _series_added(::BokehBackend, plt::Plot, d::KW)
+function _series_added(plt::Plot{BokehBackend}, series::Series)
+  bdata = Dict{Symbol, Vector}(:x => collect(series.d[:x]), :y => collect(series.d[:y]))
 
   glyph = Bokeh.Bokehjs.Glyph(
       glyphtype = bokeh_glyph_type(d),
@@ -168,17 +162,14 @@ function _add_series(::BokehBackend, plt::Plot, d::KW)
   legend = nothing  # TODO
   push!(plt.o.datacolumns, Bokeh.BokehDataSet(bdata, glyph, legend))
 
-  push!(plt.seriesargs, d)
-  plt
+  # push!(plt.seriesargs, d)
+  # plt
 end
 
 # ----------------------------------------------------------------
 
 # TODO: override this to update plot items (title, xlabel, etc) after creation
-function _update_plot(plt::Plot{BokehBackend}, d::KW)
-end
-
-function _update_plot_pos_size(plt::AbstractPlot{BokehBackend}, d::KW)
+function _update_plot_object(plt::Plot{BokehBackend}, d::KW)
 end
 
 # ----------------------------------------------------------------
@@ -197,33 +188,13 @@ end
 # end
 
 
-# ----------------------------------------------------------------
-
-function _add_annotations{X,Y,V}(plt::Plot{BokehBackend}, anns::AVec{@compat(Tuple{X,Y,V})})
-  for ann in anns
-    # TODO: add the annotation to the plot
-  end
-end
 
 # ----------------------------------------------------------------
 
-function _create_subplot(subplt::Subplot{BokehBackend}, isbefore::Bool)
-  # TODO: build the underlying Subplot object.  this is where you might layout the panes within a GUI window, for example
-
-end
-
-
-function _expand_limits(lims, plt::Plot{BokehBackend}, isx::Bool)
-  # TODO: call expand limits for each plot data
-end
-
-function _remove_axis(plt::Plot{BokehBackend}, isx::Bool)
-  # TODO: if plot is inner subplot, might need to remove ticks or axis labels
-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
@@ -232,6 +203,6 @@ function Base.display(::PlotsDisplay, plt::Plot{BokehBackend})
   Bokeh.showplot(plt.o)
 end
 
-function Base.display(::PlotsDisplay, plt::Subplot{BokehBackend})
-  # TODO: display/show the subplot
-end
+# function Base.display(::PlotsDisplay, plt::Subplot{BokehBackend})
+#   # TODO: display/show the subplot
+# end

src/deprecated/backends/gadfly.jl

@@ -2,20 +2,19 @@
 # https://github.com/dcjones/Gadfly.jl
 
 
-supportedArgs(::GadflyBackend) = [
-    :annotation,
+supported_attrs(::GadflyBackend) = merge_with_base_supported([
+    :annotations,
     :background_color, :foreground_color, :color_palette,
-    :group, :label, :linetype,
+    :group, :label, :seriestype,
     :seriescolor, :seriesalpha,
     :linecolor, :linestyle, :linewidth, :linealpha,
     :markershape, :markercolor, :markersize, :markeralpha,
     :markerstrokewidth, :markerstrokecolor, :markerstrokealpha,
     :fillrange, :fillcolor, :fillalpha,
     :bins, :n, :nc, :nr, :layout, :smooth,
-    :title, :windowtitle, :show, :size,
-    :x, :xlabel, :xlims, :xticks, :xscale, :xflip,
-    :y, :ylabel, :ylims, :yticks, :yscale, :yflip,
-    # :z, :zlabel, :zlims, :zticks, :zscale, :zflip,
+    :title, :window_title, :show, :size,
+    :x, :xguide, :xlims, :xticks, :xscale, :xflip,
+    :y, :yguide, :ylims, :yticks, :yscale, :yflip,
     :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, :hist2d, :hexbin, :hist,
-        :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
 
@@ -59,8 +57,8 @@ function createGadflyPlotObject(d::KW)
     gplt.data_source = Gadfly.DataFrames.DataFrame()
     # gplt.layers = gplt.layers[1:0]
     gplt.layers = [Gadfly.layer(Gadfly.Geom.point(tag=:remove), x=zeros(1), y=zeros(1));] # x=MissingVec(), y=MissingVec());]
-    gplt.guides = Gadfly.GuideElement[Gadfly.Guide.xlabel(d[:xlabel]),
-                                   Gadfly.Guide.ylabel(d[:ylabel]),
+    gplt.guides = Gadfly.GuideElement[Gadfly.Guide.xlabel(d[:xguide]),
+                                   Gadfly.Guide.ylabel(d[:yguide]),
                                    Gadfly.Guide.title(d[:title])]
     gplt
 end
@@ -69,31 +67,31 @@ end
 
 
 function getLineGeom(d::KW)
-    lt = d[:linetype]
+    st = d[:seriestype]
     xbins, ybins = maketuple(d[:bins])
-    if lt == :hexb
+    if st == :hexb
         Gadfly.Geom.hexbin(xbincount = xbins, ybincount = ybins)
-    elseif lt == :hist2d
+    elseif st == :histogram2d
         Gadfly.Geom.histogram2d(xbincount = xbins, ybincount = ybins)
-    elseif lt == :hist
+    elseif st == :histogram
         Gadfly.Geom.histogram(bincount = xbins,
                               orientation = isvertical(d) ? :vertical : :horizontal,
                               position = d[:bar_position] == :stack ? :stack : :dodge)
-    elseif lt == :path
+    elseif st == :path
         Gadfly.Geom.path
-    elseif lt in (:bar, :sticks)
+    elseif st in (:bar, :sticks)
         Gadfly.Geom.bar
-    elseif lt == :steppost
+    elseif st == :steppost
         Gadfly.Geom.step
-    elseif lt == :steppre
+    elseif st == :steppre
         Gadfly.Geom.step(direction = :vh)
-    elseif lt == :hline
+    elseif st == :hline
         Gadfly.Geom.hline
-    elseif lt == :vline
+    elseif st == :vline
         Gadfly.Geom.vline
-    elseif lt == :contour
+    elseif st == :contour
         Gadfly.Geom.contour(levels = d[:levels])
-    # elseif lt == :shape
+    # elseif st == :shape
     #     Gadfly.Geom.polygon(fill = true, preserve_order = true)
     else
         nothing
@@ -116,13 +114,13 @@ function get_extra_theme_args(d::KW, k::Symbol)
 end
 
 function getGadflyLineTheme(d::KW)
-    lt = d[:linetype]
+    st = d[:seriestype]
     lc = convertColor(getColor(d[:linecolor]), d[:linealpha])
     fc = convertColor(getColor(d[:fillcolor]), d[:fillalpha])
 
     Gadfly.Theme(;
-        default_color = (lt in (:hist,:hist2d,:hexbin,:bar,:sticks) ? fc : lc),
-        line_width = (lt == :sticks ? 1 : d[:linewidth]) * Gadfly.px,
+        default_color = (st in (:histogram,:histogram2d,:hexbin,:bar,:sticks) ? fc : lc),
+        line_width = (st == :sticks ? 1 : d[:linewidth]) * Gadfly.px,
         # line_style = Gadfly.get_stroke_vector(d[:linestyle]),
         lowlight_color = x->RGB(fc),  # fill/ribbon
         lowlight_opacity = alpha(fc), # fill/ribbon
@@ -136,10 +134,10 @@ function addGadflyLine!(plt::Plot, numlayers::Int, d::KW, geoms...)
     gplt = getGadflyContext(plt)
     gfargs = vcat(geoms..., getGadflyLineTheme(d))
     kwargs = KW()
-    lt = d[:linetype]
+    st = d[:seriestype]
 
     # add a fill?
-    if d[:fillrange] != nothing && lt != :contour
+    if d[:fillrange] != nothing && st != :contour
         fillmin, fillmax = map(makevec, maketuple(d[:fillrange]))
         nmin, nmax = length(fillmin), length(fillmax)
         kwargs[:ymin] = Float64[min(y, fillmin[mod1(i, nmin)], fillmax[mod1(i, nmax)]) for (i,y) in enumerate(d[:y])]
@@ -147,20 +145,20 @@ function addGadflyLine!(plt::Plot, numlayers::Int, d::KW, geoms...)
         push!(gfargs, Gadfly.Geom.ribbon)
     end
 
-    if lt in (:hline, :vline)
-        kwargs[lt == :hline ? :yintercept : :xintercept] = d[:y]
+    if st in (:hline, :vline)
+        kwargs[st == :hline ? :yintercept : :xintercept] = d[:y]
 
     else
-        if lt == :sticks
+        if st == :sticks
             w = 0.01 * mean(diff(d[:x]))
             kwargs[:xmin] = d[:x] - w
             kwargs[:xmax] = d[:x] + w
-        elseif lt == :contour
+        elseif st == :contour
             kwargs[:z] = d[:z].surf
             addGadflyContColorScale(plt, d[:linecolor])
         end
 
-        kwargs[:x] = d[lt == :hist ? :y : :x]
+        kwargs[:x] = d[st == :histogram ? :y : :x]
         kwargs[:y] = d[:y]
 
     end
@@ -183,14 +181,14 @@ getMarkerGeom(other) = gadflyshape(get_shape(other))
 # getMarkerGeom(shape::Symbol) = gadflyshape(_shapes[shape])
 # getMarkerGeom(shapes::AVec) = gadflyshape(map(gadflyshape, shapes)) # map(getMarkerGeom, shapes)
 function getMarkerGeom(d::KW)
-    if d[:linetype] == :shape
+    if d[:seriestype] == :shape
         Gadfly.Geom.polygon(fill = true, preserve_order = true)
     else
         getMarkerGeom(d[:markershape])
     end
 end
 
-function getGadflyMarkerTheme(d::KW, plotargs::KW)
+function getGadflyMarkerTheme(d::KW, attr::KW)
     c = getColor(d[:markercolor])
     α = d[:markeralpha]
     if α != nothing
@@ -216,15 +214,15 @@ function getGadflyMarkerTheme(d::KW, plotargs::KW)
 end
 
 function addGadflyContColorScale(plt::Plot{GadflyBackend}, c)
-    plt.plotargs[:colorbar] == :none && return
+    plt.attr[:colorbar] == :none && return
     if !isa(c, ColorGradient)
         c = default_gradient()
     end
     push!(getGadflyContext(plt).scales, Gadfly.Scale.ContinuousColorScale(p -> RGB(getColorZ(c, p))))
 end
 
-function addGadflyMarker!(plt::Plot, numlayers::Int, d::KW, plotargs::KW, geoms...)
-    gfargs = vcat(geoms..., getGadflyMarkerTheme(d, plotargs), getMarkerGeom(d))
+function addGadflyMarker!(plt::Plot, numlayers::Int, d::KW, attr::KW, geoms...)
+    gfargs = vcat(geoms..., getGadflyMarkerTheme(d, attr), getMarkerGeom(d))
     kwargs = KW()
 
     # handle continuous color scales for the markers
@@ -241,12 +239,12 @@ end
 # ---------------------------------------------------------------------------
 
 function addToGadflyLegend(plt::Plot, d::KW)
-    if plt.plotargs[:legend] != :none && d[:label] != ""
+    if plt.attr[:legend] != :none && d[:label] != ""
         gplt = getGadflyContext(plt)
 
         # add the legend if needed
         if all(g -> !isa(g, Gadfly.Guide.ManualColorKey), gplt.guides)
-            unshift!(gplt.guides, Gadfly.Guide.manual_color_key("", @compat(AbstractString)[], Color[]))
+            unshift!(gplt.guides, Gadfly.Guide.manual_color_key("", AbstractString[], Color[]))
         end
 
         # now add the series to the legend
@@ -297,21 +295,21 @@ function addGadflySeries!(plt::Plot, d::KW)
     end
 
     # special handling for ohlc and scatter
-    lt = d[:linetype]
-    if lt == :ohlc
-        error("Haven't re-implemented after refactoring")
-    elseif lt in (:hist2d, :hexbin) && (isa(d[:fillcolor], ColorGradient) || isa(d[:fillcolor], ColorFunction))
+    st = d[:seriestype]
+    # if st == :ohlc
+    #     error("Haven't re-implemented after refactoring")
+    if st in (:histogram2d, :hexbin) && (isa(d[:fillcolor], ColorGradient) || isa(d[:fillcolor], ColorFunction))
         push!(gplt.scales, Gadfly.Scale.ContinuousColorScale(p -> RGB(getColorZ(d[:fillcolor], p))))
-    elseif lt == :scatter && d[:markershape] == :none
-        d[:markershape] = :ellipse
+    elseif st == :scatter && d[:markershape] == :none
+        d[:markershape] = :circle
     end
 
     # markers
-    if d[:markershape] != :none || lt == :shape
-        prepend!(layers, addGadflyMarker!(plt, length(gplt.layers), d, plt.plotargs, smooth...))
+    if d[:markershape] != :none || st == :shape
+        prepend!(layers, addGadflyMarker!(plt, length(gplt.layers), d, plt.attr, smooth...))
     end
 
-    lt in (:hist2d, :hexbin, :contour) || addToGadflyLegend(plt, d)
+    st in (:histogram2d, :hexbin, :contour) || addToGadflyLegend(plt, d)
 
     # now save the layers that apply to this series
     d[:gadflylayers] = layers
@@ -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...)
@@ -469,8 +467,8 @@ end
 function updateGadflyGuides(plt::Plot, d::KW)
     gplt = getGadflyContext(plt)
     haskey(d, :title) && findGuideAndSet(gplt, Gadfly.Guide.title, string(d[:title]))
-    haskey(d, :xlabel) && findGuideAndSet(gplt, Gadfly.Guide.xlabel, string(d[:xlabel]))
-    haskey(d, :ylabel) && findGuideAndSet(gplt, Gadfly.Guide.ylabel, string(d[:ylabel]))
+    haskey(d, :xguide) && findGuideAndSet(gplt, Gadfly.Guide.xlabel, string(d[:xguide]))
+    haskey(d, :yguide) && findGuideAndSet(gplt, Gadfly.Guide.ylabel, string(d[:yguide]))
 
     xlims, xfunc = addGadflyLimitsScale(gplt, d, true)
     ylims, yfunc = addGadflyLimitsScale(gplt, d, false)
@@ -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
@@ -570,28 +568,32 @@ end
 # ---------------------------------------------------------------------------
 
 # create a blank Gadfly.Plot object
-function _create_plot(pkg::GadflyBackend, d::KW)
-    gplt = createGadflyPlotObject(d)
-    Plot(gplt, pkg, 0, d, KW[])
+# function _create_plot(pkg::GadflyBackend, d::KW)
+#     gplt = createGadflyPlotObject(d)
+#     Plot(gplt, pkg, 0, d, KW[])
+# end
+function _create_backend_figure(plt::Plot{GadflyBackend})
+    createGadflyPlotObject(plt.attr)
 end
 
 
 # plot one data series
-function _add_series(::GadflyBackend, plt::Plot, d::KW)
+# function _series_added(::GadflyBackend, plt::Plot, d::KW)
+function _series_added(plt::Plot{GadflyBackend}, series::Series)
     # first clear out the temporary layer
     gplt = getGadflyContext(plt)
     if gplt.layers[1].geom.tag == :remove
         gplt.layers = gplt.layers[2:end]
     end
 
-    addGadflySeries!(plt, d)
-    push!(plt.seriesargs, d)
-    plt
+    addGadflySeries!(plt, series.d)
+    # push!(plt.seriesargs, d)
+    # plt
 end
 
 
 
-function _update_plot(plt::Plot{GadflyBackend}, d::KW)
+function _update_plot_object(plt::Plot{GadflyBackend}, d::KW)
     updateGadflyGuides(plt, d)
     updateGadflyPlotTheme(plt, d)
 end
@@ -622,12 +624,12 @@ end
 # ----------------------------------------------------------------
 
 
-# create the underlying object (each backend will do this differently)
-function _create_subplot(subplt::Subplot{GadflyBackend}, isbefore::Bool)
-    isbefore && return false # wait until after plotting to create the subplots
-    subplt.o = nothing
-    true
-end
+# # create the underlying object (each backend will do this differently)
+# function _create_subplot(subplt::Subplot{GadflyBackend}, isbefore::Bool)
+#     isbefore && return false # wait until after plotting to create the subplots
+#     subplt.o = nothing
+#     true
+# end
 
 
 function _remove_axis(plt::Plot{GadflyBackend}, isx::Bool)
@@ -647,35 +649,35 @@ end
 
 
 getGadflyContext(plt::Plot{GadflyBackend}) = plt.o
-getGadflyContext(subplt::Subplot{GadflyBackend}) = buildGadflySubplotContext(subplt)
+# getGadflyContext(subplt::Subplot{GadflyBackend}) = buildGadflySubplotContext(subplt)
 
-# create my Compose.Context grid by hstacking and vstacking the Gadfly.Plot objects
-function buildGadflySubplotContext(subplt::Subplot)
-    rows = Any[]
-    row = Any[]
-    for (i,(r,c)) in enumerate(subplt.layout)
-
-        # add the Plot object to the row
-        push!(row, getGadflyContext(subplt.plts[i]))
-
-        # add the row
-        if c == ncols(subplt.layout, r)
-            push!(rows, Gadfly.hstack(row...))
-            row = Any[]
-        end
-    end
-
-    # stack the rows
-    Gadfly.vstack(rows...)
-end
+# # create my Compose.Context grid by hstacking and vstacking the Gadfly.Plot objects
+# function buildGadflySubplotContext(subplt::Subplot)
+#     rows = Any[]
+#     row = Any[]
+#     for (i,(r,c)) in enumerate(subplt.layout)
+#
+#         # add the Plot object to the row
+#         push!(row, getGadflyContext(subplt.plts[i]))
+#
+#         # add the row
+#         if c == ncols(subplt.layout, r)
+#             push!(rows, Gadfly.hstack(row...))
+#             row = Any[]
+#         end
+#     end
+#
+#     # stack the rows
+#     Gadfly.vstack(rows...)
+# end
 
 setGadflyDisplaySize(w,h) = Compose.set_default_graphic_size(w * Compose.px, h * Compose.px)
-setGadflyDisplaySize(plt::Plot) = setGadflyDisplaySize(plt.plotargs[:size]...)
-setGadflyDisplaySize(subplt::Subplot) = setGadflyDisplaySize(getplotargs(subplt, 1)[:size]...)
+setGadflyDisplaySize(plt::Plot) = setGadflyDisplaySize(plt.attr[:size]...)
+# setGadflyDisplaySize(subplt::Subplot) = setGadflyDisplaySize(getattr(subplt, 1)[:size]...)
 # -------------------------------------------------------------------------
 
 
-function dowritemime{P<:Union{GadflyBackend,ImmerseBackend}}(io::IO, func, plt::AbstractPlot{P})
+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)
@@ -690,53 +692,53 @@ 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
 
 
 
 function Base.display(::PlotsDisplay, plt::Plot{GadflyBackend})
-    setGadflyDisplaySize(plt.plotargs[:size]...)
+    setGadflyDisplaySize(plt.attr[:size]...)
     display(plt.o)
 end
 
 
-function Base.display(::PlotsDisplay, subplt::Subplot{GadflyBackend})
-    setGadflyDisplaySize(getplotargs(subplt,1)[:size]...)
-    ctx = buildGadflySubplotContext(subplt)
-
-    # taken from Gadfly since I couldn't figure out how to do it directly
-
-    filename = string(Gadfly.tempname(), ".html")
-    output = open(filename, "w")
-
-    plot_output = IOBuffer()
-    Gadfly.draw(Gadfly.SVGJS(plot_output, Compose.default_graphic_width,
-             Compose.default_graphic_height, false), ctx)
-    plotsvg = takebuf_string(plot_output)
-
-    write(output,
-      """
-      <!DOCTYPE html>
-      <html>
-        <head>
-          <title>Gadfly Plot</title>
-          <meta charset="utf-8">
-        </head>
-          <body>
-          <script charset="utf-8">
-              $(readall(Compose.snapsvgjs))
-          </script>
-          <script charset="utf-8">
-              $(readall(Gadfly.gadflyjs))
-          </script>
-          $(plotsvg)
-        </body>
-      </html>
-      """)
-    close(output)
-    Gadfly.open_file(filename)
-end
+# function Base.display(::PlotsDisplay, subplt::Subplot{GadflyBackend})
+#     setGadflyDisplaySize(getattr(subplt,1)[:size]...)
+#     ctx = buildGadflySubplotContext(subplt)
+#
+#     # taken from Gadfly since I couldn't figure out how to do it directly
+#
+#     filename = string(Gadfly.tempname(), ".html")
+#     output = open(filename, "w")
+#
+#     plot_output = IOBuffer()
+#     Gadfly.draw(Gadfly.SVGJS(plot_output, Compose.default_graphic_width,
+#              Compose.default_graphic_height, false), ctx)
+#     plotsvg = takebuf_string(plot_output)
+#
+#     write(output,
+#       """
+#       <!DOCTYPE html>
+#       <html>
+#         <head>
+#           <title>Gadfly Plot</title>
+#           <meta charset="utf-8">
+#         </head>
+#           <body>
+#           <script charset="utf-8">
+#               $(readall(Compose.snapsvgjs))
+#           </script>
+#           <script charset="utf-8">
+#               $(readall(Gadfly.gadflyjs))
+#           </script>
+#           $(plotsvg)
+#         </body>
+#       </html>
+#       """)
+#     close(output)
+#     Gadfly.open_file(filename)
+# end

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

@@ -0,0 +1,186 @@
+
+# https://github.com/JuliaGraphics/Immerse.jl
+
+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
+
+# --------------------------------------------------------------------------------------
+
+function _initialize_backend(::ImmerseBackend; kw...)
+  @eval begin
+    import Immerse, Gadfly, Compose, Gtk
+    export Immerse, Gadfly, Compose, Gtk
+    include(joinpath(dirname(@__FILE__), "gadfly_shapes.jl"))
+  end
+end
+
+function createImmerseFigure(d::KW)
+  w,h = d[:size]
+  figidx = Immerse.figure(; name = d[:window_title], width = w, height = h)
+  Immerse.Figure(figidx)
+end
+
+# ----------------------------------------------------------------
+
+
+# create a blank Gadfly.Plot object
+# function _create_plot(pkg::ImmerseBackend, d::KW)
+#   # create the underlying Gadfly.Plot object
+#   gplt = createGadflyPlotObject(d)
+#
+#   # save both the Immerse.Figure and the Gadfly.Plot
+#   Plot((nothing,gplt), pkg, 0, d, KW[])
+# end
+function _create_backend_figure(plt::Plot{ImmerseBackend})
+    (nothing, createGadflyPlotObject(plt.attr))
+end
+
+
+# # plot one data series
+# function _series_added(::ImmerseBackend, plt::Plot, d::KW)
+#   addGadflySeries!(plt, d)
+#   push!(plt.seriesargs, d)
+#   plt
+# end
+
+function _series_added(plt::Plot{ImmerseBackend}, series::Series)
+    addGadflySeries!(plt, series.d)
+end
+
+
+function _update_plot_object(plt::Plot{ImmerseBackend}, d::KW)
+  updateGadflyGuides(plt, d)
+  updateGadflyPlotTheme(plt, d)
+end
+
+
+
+# ----------------------------------------------------------------
+
+function _add_annotations{X,Y,V}(plt::Plot{ImmerseBackend}, anns::AVec{Tuple{X,Y,V}})
+  for ann in anns
+    push!(getGadflyContext(plt).guides, createGadflyAnnotationObject(ann...))
+  end
+end
+
+# ----------------------------------------------------------------
+
+# accessors for x/y data
+
+function getxy(plt::Plot{ImmerseBackend}, i::Integer)
+  mapping = getGadflyMappings(plt, i)[1]
+  mapping[:x], mapping[:y]
+end
+
+function setxy!{X,Y}(plt::Plot{ImmerseBackend}, xy::Tuple{X,Y}, i::Integer)
+  for mapping in getGadflyMappings(plt, i)
+    mapping[:x], mapping[:y] = xy
+  end
+  plt
+end
+
+
+# ----------------------------------------------------------------
+
+
+# function _create_subplot(subplt::Subplot{ImmerseBackend}, isbefore::Bool)
+#   return false
+#   # isbefore && return false
+# end
+#
+# function showSubplotObject(subplt::Subplot{ImmerseBackend})
+#   # create the Gtk window with vertical box vsep
+#   d = getattr(subplt,1)
+#   w,h = d[:size]
+#   vsep = Gtk.GtkBoxLeaf(:v)
+#   win = Gtk.GtkWindowLeaf(vsep, d[:window_title], w, h)
+#
+#   figindices = []
+#   row = Gtk.GtkBoxLeaf(:h)
+#   push!(vsep, row)
+#   for (i,(r,c)) in enumerate(subplt.layout)
+#     plt = subplt.plts[i]
+#
+#     # get the components... box is the main plot GtkBox, and canvas is the GtkCanvas where it's plotted
+#     box, toolbar, canvas = Immerse.createPlotGuiComponents()
+#
+#     # add the plot's box to the row
+#     push!(row, box)
+#
+#     # create the figure and store the index returned for destruction later
+#     figidx = Immerse.figure(canvas)
+#     push!(figindices, figidx)
+#
+#     fig = Immerse.figure(figidx)
+#     plt.o = (fig, plt.o[2])
+#
+#     # add the row
+#     if c == ncols(subplt.layout, r)
+#       row = Gtk.GtkBoxLeaf(:h)
+#       push!(vsep, row)
+#     end
+#
+#   end
+#
+#   # destructor... clean up plots
+#   Gtk.on_signal_destroy((x...) -> ([Immerse.dropfig(Immerse._display,i) for i in figindices]; subplt.o = nothing), win)
+#
+#   subplt.o = win
+#   true
+# end
+
+
+function _remove_axis(plt::Plot{ImmerseBackend}, isx::Bool)
+  gplt = getGadflyContext(plt)
+  addOrReplace(gplt.guides, isx ? Gadfly.Guide.xticks : Gadfly.Guide.yticks; label=false)
+  addOrReplace(gplt.guides, isx ? Gadfly.Guide.xlabel : Gadfly.Guide.ylabel, "")
+end
+
+function _expand_limits(lims, plt::Plot{ImmerseBackend}, isx::Bool)
+  for l in getGadflyContext(plt).layers
+    _expand_limits(lims, l.mapping[isx ? :x : :y])
+  end
+end
+
+
+# ----------------------------------------------------------------
+
+getGadflyContext(plt::Plot{ImmerseBackend}) = plt.o[2]
+# getGadflyContext(subplt::Subplot{ImmerseBackend}) = buildGadflySubplotContext(subplt)
+
+
+function Base.display(::PlotsDisplay, plt::Plot{ImmerseBackend})
+
+  fig, gplt = plt.o
+  if fig == nothing
+    fig = createImmerseFigure(plt.attr)
+    Gtk.on_signal_destroy((x...) -> (Immerse.dropfig(Immerse._display, fig.figno); plt.o = (nothing,gplt)), fig.canvas)
+    plt.o = (fig, gplt)
+  end
+
+  Immerse.figure(fig.figno; displayfig = false)
+  display(gplt)
+end
+
+
+# function Base.display(::PlotsDisplay, subplt::Subplot{ImmerseBackend})
+#
+#   # if we haven't created the window yet, do it
+#   if subplt.o == nothing
+#     showSubplotObject(subplt)
+#   end
+#
+#   # display the plots by creating a fresh Immerse.Figure object from the GtkCanvas and Gadfly.Plot
+#   for plt in subplt.plts
+#     fig, gplt = plt.o
+#     Immerse.figure(fig.figno; displayfig = false)
+#     display(gplt)
+#   end
+#
+#   # o is the window... show it
+#   showall(subplt.o)
+# end

src/deprecated/backends/qwt.jl

@@ -2,52 +2,29 @@
 # https://github.com/tbreloff/Qwt.jl
 
 
-supportedArgs(::QwtBackend) = [
-    :annotation,
-    :axis,
-    :background_color,
+supported_attrs(::QwtBackend) = merge_with_base_supported([
+    :annotations,
     :linecolor,
-    :color_palette,
     :fillrange,
     :fillcolor,
-    :foreground_color,
-    :group,
     :label,
-    :layout,
     :legend,
     :seriescolor, :seriesalpha,
     :linestyle,
-    :linetype,
     :linewidth,
     :markershape,
     :markercolor,
     :markersize,
-    :n,
     :bins,
-    :nc,
-    :nr,
     :pos,
-    :smooth,
-    :show,
-    :size,
     :title,
-    :windowtitle,
-    :x,
-    :xlabel,
-    :xlims,
-    :xticks,
-    :y,
-    :ylabel,
-    :ylims,
-    :yrightlabel,
-    :yticks,
-    :xscale,
-    :yscale,
-  ]
-supportedTypes(::QwtBackend) = [:none, :line, :path, :steppre, :steppost, :sticks, :scatter, :hist2d, :hexbin, :hist, :bar, :hline, :vline]
-supportedMarkers(::QwtBackend) = [:none, :auto, :rect, :ellipse, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5, :star8, :hexagon]
-supportedScales(::QwtBackend) = [:identity, :log10]
-subplotSupported(::QwtBackend) = true
+    :window_title,
+    :guide, :lims, :ticks, :scale,
+  ])
+supported_types(::QwtBackend) = [:path, :scatter, :hexbin, :bar]
+supported_markers(::QwtBackend) = [:none, :auto, :rect, :circle, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5, :star8, :hexagon]
+supported_scales(::QwtBackend) = [:identity, :log10]
+is_subplot_supported(::QwtBackend) = true
 
 
 # --------------------------------------------------------------------------------------
@@ -62,7 +39,7 @@ end
 
 # -------------------------------
 
-@compat const _qwtAliases = KW(
+const _qwtAliases = KW(
     :bins => :heatmap_n,
     :fillrange => :fillto,
     :linewidth => :width,
@@ -91,29 +68,29 @@ end
 
 function adjustQwtKeywords(plt::Plot{QwtBackend}, iscreating::Bool; kw...)
   d = KW(kw)
-  lt = d[:linetype]
-  if lt == :scatter
-    d[:linetype] = :none
+  st = d[:seriestype]
+  if st == :scatter
+    d[:seriestype] = :none
     if d[:markershape] == :none
-      d[:markershape] = :ellipse
+      d[:markershape] = :circle
     end
 
-  elseif lt in (:hline, :vline)
+  elseif st in (:hline, :vline)
     addLineMarker(plt, d)
-    d[:linetype] = :none
-    d[:markershape] = :ellipse
+    d[:seriestype] = :none
+    d[:markershape] = :circle
     d[:markersize] = 1
-    if lt == :vline
+    if st == :vline
       d[:x], d[:y] = d[:y], d[:x]
     end
 
-  elseif !iscreating && lt == :bar
+  elseif !iscreating && st == :bar
     d = barHack(; kw...)
-  elseif !iscreating && lt == :hist
+  elseif !iscreating && st == :histogram
     d = barHack(; histogramHack(; kw...)...)
   end
 
-  replaceQwtAliases(d, :linetype)
+  replaceQwtAliases(d, :seriestype)
   replaceQwtAliases(d, :markershape)
 
   for k in keys(d)
@@ -128,21 +105,23 @@ function adjustQwtKeywords(plt::Plot{QwtBackend}, iscreating::Bool; kw...)
   d
 end
 
-function _create_plot(pkg::QwtBackend, d::KW)
-  fixcolors(d)
-  dumpdict(d,"\n\n!!! plot")
-  o = Qwt.plot(zeros(0,0); d..., show=false)
-  plt = Plot(o, pkg, 0, d, KW[])
-  plt
+# function _create_plot(pkg::QwtBackend, d::KW)
+function _create_backend_figure(plt::Plot{QwtBackend})
+  fixcolors(plt.attr)
+  dumpdict(plt.attr,"\n\n!!! plot")
+  o = Qwt.plot(zeros(0,0); plt.attr..., show=false)
+  # plt = Plot(o, pkg, 0, d, KW[])
+  # plt
 end
 
-function _add_series(::QwtBackend, plt::Plot, d::KW)
-  d = adjustQwtKeywords(plt, false; d...)
+# function _series_added(::QwtBackend, plt::Plot, d::KW)
+function _series_added(plt::Plot{QwtBackend}, series::Series)
+  d = adjustQwtKeywords(plt, false; series.d...)
   fixcolors(d)
   dumpdict(d,"\n\n!!! plot!")
   Qwt.oplot(plt.o; d...)
-  push!(plt.seriesargs, d)
-  plt
+  # push!(plt.seriesargs, d)
+  # plt
 end
 
 
@@ -154,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
@@ -182,16 +161,16 @@ 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
 
 
-function _update_plot(plt::Plot{QwtBackend}, d::KW)
+function _update_plot_object(plt::Plot{QwtBackend}, d::KW)
   haskey(d, :title) && Qwt.title(plt.o, d[:title])
-  haskey(d, :xlabel) && Qwt.xlabel(plt.o, d[:xlabel])
-  haskey(d, :ylabel) && Qwt.ylabel(plt.o, d[:ylabel])
+  haskey(d, :xguide) && Qwt.xlabel(plt.o, d[:xguide])
+  haskey(d, :yguide) && Qwt.ylabel(plt.o, d[:yguide])
   updateLimsAndTicks(plt, d, true)
   updateLimsAndTicks(plt, d, false)
 end
@@ -208,7 +187,7 @@ end
 function addLineMarker(plt::Plot{QwtBackend}, d::KW)
   for yi in d[:y]
     marker = Qwt.QWT.QwtPlotMarker()
-    ishorizontal = (d[:linetype] == :hline)
+    ishorizontal = (d[:seriestype] == :hline)
     marker[:setLineStyle](ishorizontal ? 1 : 2)
     marker[ishorizontal ? :setYValue : :setXValue](yi)
     qcolor = Qwt.convertRGBToQColor(getColor(d[:linecolor]))
@@ -232,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
@@ -263,32 +242,30 @@ end
 
 # -------------------------------
 
-# savepng(::QwtBackend, plt::AbstractPlot, fn::@compat(AbstractString), args...) = Qwt.savepng(plt.o, fn)
-
 # -------------------------------
 
-# create the underlying object (each backend will do this differently)
-function _create_subplot(subplt::Subplot{QwtBackend}, isbefore::Bool)
-  isbefore && return false
-  i = 0
-  rows = Any[]
-  row = Any[]
-  for (i,(r,c)) in enumerate(subplt.layout)
-    push!(row, subplt.plts[i].o)
-    if c == ncols(subplt.layout, r)
-      push!(rows, Qwt.hsplitter(row...))
-      row = Any[]
-    end
-  end
-  # for rowcnt in subplt.layout.rowcounts
-  #   push!(rows, Qwt.hsplitter([plt.o for plt in subplt.plts[(1:rowcnt) + i]]...))
-  #   i += rowcnt
-  # end
-  subplt.o = Qwt.vsplitter(rows...)
-  # Qwt.resizewidget(subplt.o, getplotargs(subplt,1)[:size]...)
-  # Qwt.moveToLastScreen(subplt.o)  # hack so it goes to my center monitor... sorry
-  true
-end
+# # create the underlying object (each backend will do this differently)
+# function _create_subplot(subplt::Subplot{QwtBackend}, isbefore::Bool)
+#   isbefore && return false
+#   i = 0
+#   rows = Any[]
+#   row = Any[]
+#   for (i,(r,c)) in enumerate(subplt.layout)
+#     push!(row, subplt.plts[i].o)
+#     if c == ncols(subplt.layout, r)
+#       push!(rows, Qwt.hsplitter(row...))
+#       row = Any[]
+#     end
+#   end
+#   # for rowcnt in subplt.layout.rowcounts
+#   #   push!(rows, Qwt.hsplitter([plt.o for plt in subplt.plts[(1:rowcnt) + i]]...))
+#   #   i += rowcnt
+#   # end
+#   subplt.o = Qwt.vsplitter(rows...)
+#   # Qwt.resizewidget(subplt.o, getattr(subplt,1)[:size]...)
+#   # Qwt.moveToLastScreen(subplt.o)  # hack so it goes to my center monitor... sorry
+#   true
+# end
 
 function _expand_limits(lims, plt::Plot{QwtBackend}, isx::Bool)
   for series in plt.o.lines
@@ -303,19 +280,19 @@ 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})
-  for plt in subplt.plts
-    Qwt.refresh(plt.o)
-  end
-  Qwt.savepng(subplt.o, "/tmp/dfskjdhfkh.png")
-  write(io, readall("/tmp/dfskjdhfkh.png"))
-end
+# function Base.show(io::IO, ::MIME"image/png", subplt::Subplot{QwtBackend})
+#   for plt in subplt.plts
+#     Qwt.refresh(plt.o)
+#   end
+#   Qwt.savepng(subplt.o, "/tmp/dfskjdhfkh.png")
+#   write(io, readall("/tmp/dfskjdhfkh.png"))
+# end
 
 
 function Base.display(::PlotsDisplay, plt::Plot{QwtBackend})
@@ -323,9 +300,9 @@ function Base.display(::PlotsDisplay, plt::Plot{QwtBackend})
   Qwt.showwidget(plt.o)
 end
 
-function Base.display(::PlotsDisplay, subplt::Subplot{QwtBackend})
-  for plt in subplt.plts
-    Qwt.refresh(plt.o)
-  end
-  Qwt.showwidget(subplt.o)
-end
+# function Base.display(::PlotsDisplay, subplt::Subplot{QwtBackend})
+#   for plt in subplt.plts
+#     Qwt.refresh(plt.o)
+#   end
+#   Qwt.showwidget(subplt.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) = [
-    :annotation,
-    # :args,
-    # :axis,
-    # :background_color,
+supported_attrs(::WinstonBackend) = merge_with_base_supported([
+    :annotations,
     :linecolor,
-    :color_palette,
     :fillrange,
     :fillcolor,
-    # :foreground_color,
-    :group,
-    # :heatmap_c,
-    # :kwargs,
     :label,
-    # :layout,
     :legend,
     :seriescolor, :seriesalpha,
     :linestyle,
-    :linetype,
     :linewidth,
     :markershape,
     :markercolor,
     :markersize,
-    # :markerstrokewidth,
-    # :markerstrokecolor,
-    # :markerstrokestyle,
-    # :n,
     :bins,
-    # :nc,
-    # :nr,
-    # :pos,
-    :smooth,
-    # :ribbon,
-    :show,
-    :size,
     :title,
-    :windowtitle,
-    :x,
-    :xlabel,
-    :xlims,
-    # :xticks,
-    :y,
-    :ylabel,
-    :ylims,
-    # :yrightlabel,
-    # :yticks,
-    :xscale,
-    :yscale,
-    # :xflip,
-    # :yflip,
-    # :z,
-  ]
-supportedAxes(::WinstonBackend) = [:auto, :left]
-supportedTypes(::WinstonBackend) = [:none, :line, :path, :sticks, :scatter, :hist, :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
+    :window_title,
+    :guide, :lims, :scale,
+  ])
+supported_types(::WinstonBackend) = [:path, :scatter, :bar]
+supported_styles(::WinstonBackend) = [:auto, :solid, :dash, :dot, :dashdot]
+supported_markers(::WinstonBackend) = [:none, :auto, :rect, :circle, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5]
+supported_scales(::WinstonBackend) = [:identity, :log10]
+is_subplot_supported(::WinstonBackend) = false
 
 
 # --------------------------------------------------------------------------------------
@@ -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",
@@ -96,17 +61,18 @@ end
                             :star5 => "asterisk"
                            )
 
-function _before_add_series(plt::Plot{WinstonBackend})
+function _before_update(plt::Plot{WinstonBackend})
   Winston.ghf(plt.o)
 end
 
 # ---------------------------------------------------------------------------
 
-
-function _create_plot(pkg::WinstonBackend, d::KW)
-  wplt = Winston.FramedPlot(title = d[:title], xlabel = d[:xlabel], ylabel = d[:ylabel])
-
-  Plot(wplt, pkg, 0, d, KW[])
+function _create_backend_figure(plt::Plot{WinstonBackend})
+    Winston.FramedPlot(
+        title = plt.attr[:title],
+        xlabel = plt.attr[:xguide],
+        ylabel = plt.attr[:yguide]
+    )
 end
 
 copy_remove(d::KW, s::Symbol) = delete!(copy(d), s)
@@ -126,11 +92,12 @@ function getWinstonItems(plt::Plot)
   window, canvas, wplt
 end
 
-function _add_series(::WinstonBackend, plt::Plot, d::KW)
+function _series_added(plt::Plot{WinstonBackend}, series::Series)
+    d = series.d
   window, canvas, wplt = getWinstonItems(plt)
 
   # until we call it normally, do the hack
-  if d[:linetype] == :bar
+  if d[:seriestype] == :bar
     d = barHack(;d...)
   end
 
@@ -148,11 +115,11 @@ function _add_series(::WinstonBackend, plt::Plot, d::KW)
 
 
 
-  ## lintype :path, :step, :stepinverted, :sticks, :dots, :none, :hist2d, :hexbin, :hist, :bar
-  if d[:linetype] == :none
+  ## lintype :path, :step, :stepinverted, :sticks, :dots, :none, :histogram2d, :hexbin, :histogram, :bar
+  if d[:seriestype] == :none
     Winston.add(wplt, Winston.Points(d[:x], d[:y]; copy_remove(e, :kind)..., color=getColor(d[:markercolor])))
 
-  elseif d[:linetype] == :path
+  elseif d[:seriestype] == :path
     x, y = d[:x], d[:y]
     Winston.add(wplt, Winston.Curve(x, y; e...))
 
@@ -166,38 +133,38 @@ function _add_series(::WinstonBackend, plt::Plot, d::KW)
       Winston.add(wplt, Winston.FillBetween(x, y, x, y2, fillcolor=getColor(d[:fillcolor])))
     end
 
-  elseif d[:linetype] == :scatter
+  elseif d[:seriestype] == :scatter
     if d[:markershape] == :none
-      d[:markershape] = :ellipse
+      d[:markershape] = :circle
     end
 
-  # elseif d[:linetype] == :step
+  # elseif d[:seriestype] == :step
   #     fn = Winston.XXX
 
-  # elseif d[:linetype] == :stepinverted
+  # elseif d[:seriestype] == :stepinverted
   #     fn = Winston.XXX
 
-  elseif d[:linetype] == :sticks
+  elseif d[:seriestype] == :sticks
       Winston.add(wplt, Winston.Stems(d[:x], d[:y]; e...))
 
-  # elseif d[:linetype] == :dots
+  # elseif d[:seriestype] == :dots
   #     fn = Winston.XXX
 
-  # elseif d[:linetype] == :hist2d
+  # elseif d[:seriestype] == :histogram2d
   #     fn = Winston.XXX
 
-  # elseif d[:linetype] == :hexbin
+  # elseif d[:seriestype] == :hexbin
   #     fn = Winston.XXX
 
-  elseif d[:linetype] == :hist
+  elseif d[:seriestype] == :histogram
       hst = hist(d[:y], d[:bins])
       Winston.add(wplt, Winston.Histogram(hst...; copy_remove(e, :bins)...))
 
-  # elseif d[:linetype] == :bar
+  # elseif d[:seriestype] == :bar
   #     # fn = Winston.XXX
 
   else
-    error("linetype $(d[:linetype]) not supported by Winston.")
+    error("seriestype $(d[:seriestype]) not supported by Winston.")
 
   end
 
@@ -209,25 +176,25 @@ function _add_series(::WinstonBackend, plt::Plot, d::KW)
 
 
   # optionally add a regression line
-  d[:smooth] && d[:linetype] != :hist && addRegressionLineWinston(d, wplt)
+  d[:smooth] && d[:seriestype] != :histogram && addRegressionLineWinston(d, wplt)
 
-  push!(plt.seriesargs, d)
-  plt
+  # push!(plt.seriesargs, d)
+  # plt
 end
 
 
 # ----------------------------------------------------------------
 
-@compat const _winstonNames = KW(
+const _winstonNames = KW(
     :xlims => :xrange,
     :ylims => :yrange,
     :xscale => :xlog,
     :yscale => :ylog,
   )
 
-function _update_plot(plt::Plot{WinstonBackend}, d::KW)
+function _update_plot_object(plt::Plot{WinstonBackend}, d::KW)
   window, canvas, wplt = getWinstonItems(plt)
-  for k in (:xlabel, :ylabel, :title, :xlims, :ylims)
+  for k in (:xguide, :yguide, :title, :xlims, :ylims)
     if haskey(d, k)
       Winston.setattr(wplt, string(get(_winstonNames, k, k)), d[k])
     end
@@ -246,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
@@ -259,22 +226,22 @@ end
 
 # ----------------------------------------------------------------
 
-function _create_subplot(subplt::Subplot{WinstonBackend}, isbefore::Bool)
-  # TODO: build the underlying Subplot object.  this is where you might layout the panes within a GUI window, for example
-end
+# function _create_subplot(subplt::Subplot{WinstonBackend}, isbefore::Bool)
+#   # TODO: build the underlying Subplot object.  this is where you might layout the panes within a GUI window, for example
+# end
 
 # ----------------------------------------------------------------
 
 function addWinstonLegend(plt::Plot, wplt)
-  if plt.plotargs[:legend] != :none
+  if plt.attr[:legend] != :none
     Winston.legend(wplt, [sd[:label] for sd in plt.seriesargs])
   end
 end
 
-function Base.writemime(io::IO, ::MIME"image/png", plt::AbstractPlot{WinstonBackend})
+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
 
 
@@ -287,9 +254,9 @@ function Base.display(::PlotsDisplay, plt::Plot{WinstonBackend})
       error("Gtk is the only supported display for Winston in Plots.  Set `output_surface = gtk` in src/Winston.ini")
     end
     # initialize window
-    w,h = plt.plotargs[:size]
+    w,h = plt.attr[:size]
     canvas = Gtk.GtkCanvasLeaf()
-    window = Gtk.GtkWindowLeaf(canvas, plt.plotargs[:windowtitle], w, h)
+    window = Gtk.GtkWindowLeaf(canvas, plt.attr[:window_title], w, h)
     plt.o = (window, canvas, wplt)
   end
 
@@ -300,6 +267,6 @@ function Base.display(::PlotsDisplay, plt::Plot{WinstonBackend})
 end
 
 
-function Base.display(::PlotsDisplay, subplt::Subplot{WinstonBackend})
-  # TODO: display/show the Subplot object
-end
+# function Base.display(::PlotsDisplay, subplt::Subplot{WinstonBackend})
+#   # TODO: display/show the Subplot object
+# 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...)
@@ -18,17 +46,20 @@ colorscheme(c::Colorant; kw...) = ColorWrapper(c; kw...)
 # --------------------------------------------------------------
 
 
-convertColor(c::@compat(Union{AbstractString, Symbol})) = parse(Colorant, string(c))
+convertColor(c::AbstractString) = parse(Colorant, c)
+convertColor(c::Symbol) = parse(Colorant, string(c))
 convertColor(c::Colorant) = c
 convertColor(cvec::AbstractVector) = map(convertColor, cvec)
 convertColor(c::ColorScheme) = c
+convertColor(v::Void) = RGBA(0,0,0,0)
+convertColor(b::Bool) = b ? RGBA(0,0,0,1) : RGBA(0,0,0,0)
 
 function convertColor(c, α::Real)
   c = convertColor(c)
-  RGBA(RGB(c), α)
+  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)
@@ -48,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)]
 
@@ -100,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))))
@@ -118,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)
@@ -179,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)
 
 # --------------------------------------------------------------
 
@@ -205,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
 
 # --------------------------------------------------------------
 
@@ -294,7 +337,7 @@ function generate_colorgradient(bgcolor = colorant"white";
   gradient_from_list(colors)
 end
 
-function get_color_palette(palette, bgcolor::@compat(Union{Colorant,ColorWrapper}), numcolors::Integer)
+function get_color_palette(palette, bgcolor::Union{Colorant,ColorWrapper}, numcolors::Integer)
   grad = if palette == :auto
     generate_colorgradient(bgcolor)
   else
@@ -304,7 +347,8 @@ function get_color_palette(palette, bgcolor::@compat(Union{Colorant,ColorWrapper
   RGBA[getColorZ(grad, z) for z in zrng]
 end
 
-function get_color_palette(palette::Vector{RGBA}, bgcolor::@compat(Union{Colorant,ColorWrapper}), numcolors::Integer)
+function get_color_palette{C<:Colorant}(palette::Vector{C},
+            bgcolor::Union{Colorant,ColorWrapper}, numcolors::Integer)
   palette
 end
 
@@ -347,10 +391,10 @@ end
 make255(x) = round(Int, 255 * x)
 
 function webcolor(c::Color)
-  @sprintf("rgb(%d, %d, %d)", [make255(f(c)) for f in [red,green,blue]]...)
+    @sprintf("rgb(%d, %d, %d)", [make255(f(c)) for f in [red,green,blue]]...)
 end
 function webcolor(c::TransparentColor)
-  @sprintf("rgba(%d, %d, %d, %1.3f)", [make255(f(c)) for f in [red,green,blue]]..., alpha(c))
+    @sprintf("rgba(%d, %d, %d, %1.3f)", [make255(f(c)) for f in [red,green,blue]]..., alpha(c))
 end
 webcolor(cs::ColorScheme) = webcolor(getColor(cs))
 webcolor(c) = webcolor(convertColor(c))
@@ -358,63 +402,12 @@ webcolor(c, α) = webcolor(convertColor(getColor(c), α))
 
 # ----------------------------------------------------------------------------------
 
-# TODO: allow the setting of the algorithm, either by passing a symbol (:colordiff, :fixed, etc) or a function?
-
-function handlePlotColors(::AbstractBackend, d::KW)
-    if :background_color in supportedArgs()
-        bgcolor = convertColor(d[:background_color])
-    else
-        bgcolor = _plotDefaults[:background_color]
-        if d[:background_color] != _plotDefaults[:background_color]
-            warn("Cannot set background_color with backend $(backend())")
-        end
-    end
-
-
-    d[:color_palette] = get_color_palette(get(d, :color_palette, :auto), bgcolor, 100)
-
-
-    # set the foreground color (text, ticks, gridlines) to be white or black depending
-    # on how dark the background is.
-    fgcolor = get(d, :foreground_color, :auto)
-    fgcolor = if fgcolor == :auto
-        isdark(bgcolor) ? colorant"white" : colorant"black"
-    else
-        convertColor(fgcolor)
-    end
-
-    # bg/fg color
-    d[:background_color] = colorscheme(bgcolor)
-    d[:foreground_color] = colorscheme(fgcolor)
-
-    # update sub-background colors
-    for bgtype in ("legend", "inside", "outside")
-        bgsym = symbol("background_color_" * bgtype)
-        if d[bgsym] == :match
-            d[bgsym] = d[:background_color]
-        elseif d[bgsym] == nothing
-            d[bgsym] = colorscheme(RGBA(0,0,0,0))
-        end
-    end
-
-    # update sub-foreground colors
-    for fgtype in ("legend", "grid", "axis", "text", "border", "guide")
-        fgsym = symbol("foreground_color_" * fgtype)
-        if d[fgsym] == :match
-            d[fgsym] = d[:foreground_color]
-        elseif d[fgsym] == nothing
-            d[fgsym] = colorscheme(RGBA(0,0,0,0))
-        end
-    end
-
-
-end
 
 # converts a symbol or string into a colorant (Colors.RGB), and assigns a color automatically
-function getSeriesRGBColor(c, plotargs::KW, n::Int)
+function getSeriesRGBColor(c, sp::Subplot, n::Int)
 
   if c == :auto
-    c = autopick(plotargs[:color_palette], n)
+    c = autopick(sp[:color_palette], n)
   end
 
   # c should now be a subtype of ColorScheme

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

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

src/layouts.jl

@@ -1,178 +1,766 @@
 
+# NOTE: (0,0) is the top-left !!!
+
+# allow pixels and percentages
+const px = AbsoluteLength(0.254)
+const pct = Length{:pct, Float64}(1.0)
+
+to_pixels(m::AbsoluteLength) = m.value / 0.254
+
+const _cbar_width = 5mm
+
+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
+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
+# Base.:+(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value * (1 + m2.value))
+# Base.:+(m1::Length{:pct}, m2::AbsoluteLength) = AbsoluteLength(m2.value * (1 + m1.value))
+# Base.:-(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value * (1 - m2.value))
+# Base.:-(m1::Length{:pct}, m2::AbsoluteLength) = AbsoluteLength(m2.value * (m1.value - 1))
+
+Base.:*(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value * m2.value)
+Base.:*(m1::Length{:pct}, m2::AbsoluteLength) = AbsoluteLength(m2.value * m1.value)
+Base.:/(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value / m2.value)
+Base.:/(m1::Length{:pct}, m2::AbsoluteLength) = AbsoluteLength(m2.value / m1.value)
+
+
+Base.zero(::Type{typeof(pct)}) = 0pct
+Base.one(::Type{typeof(pct)}) = 1pct
+Base.typemin(::typeof(pct)) = 0pct
+Base.typemax(::typeof(pct)) = 1pct
+
+const defaultbox = BoundingBox(0mm, 0mm, 0mm, 0mm)
+
+left(bbox::BoundingBox) = bbox.x0[1]
+top(bbox::BoundingBox) = bbox.x0[2]
+right(bbox::BoundingBox) = left(bbox) + width(bbox)
+bottom(bbox::BoundingBox) = top(bbox) + height(bbox)
+Base.size(bbox::BoundingBox) = (width(bbox), height(bbox))
+
+# Base.:*{T,N}(m1::Length{T,N}, m2::Length{T,N}) = Length{T,N}(m1.value * m2.value)
+ispositive(m::Measure) = m.value > 0
+
+# union together bounding boxes
+function Base.:+(bb1::BoundingBox, bb2::BoundingBox)
+    # empty boxes don't change the union
+    ispositive(width(bb1))  || return bb2
+    ispositive(height(bb1)) || return bb2
+    ispositive(width(bb2))  || return bb1
+    ispositive(height(bb2)) || return bb1
+
+    l = min(left(bb1), left(bb2))
+    t = min(top(bb1), top(bb2))
+    r = max(right(bb1), right(bb2))
+    b = max(bottom(bb1), bottom(bb2))
+    BoundingBox(l, t, r-l, b-t)
+end
+
+# this creates a bounding box in the parent's scope, where the child bounding box
+# is relative to the parent
+function crop(parent::BoundingBox, child::BoundingBox)
+    l = left(parent) + left(child)
+    t = top(parent) + top(child)
+    w = width(child)
+    h = height(child)
+    BoundingBox(l, t, w, h)
+end
+
+# convert x,y coordinates from absolute coords to percentages...
+# returns x_pct, y_pct
+function xy_mm_to_pcts(x::AbsoluteLength, y::AbsoluteLength, figw, figh, flipy = true)
+    xmm, ymm = x.value, y.value
+    if flipy
+        ymm = figh.value - ymm  # flip y when origin in bottom-left
+    end
+    xmm / figw.value, ymm / figh.value
+end
+
+# convert a bounding box from absolute coords to percentages...
+# returns an array of percentages of figure size: [left, bottom, width, height]
+function bbox_to_pcts(bb::BoundingBox, figw, figh, flipy = true)
+    mms = Float64[f(bb).value for f in (left,bottom,width,height)]
+    if flipy
+        mms[2] = figh.value - mms[2]  # flip y when origin in bottom-left
+    end
+    mms ./ Float64[figw.value, figh.value, figw.value, figh.value]
+end
+
+function Base.show(io::IO, bbox::BoundingBox)
+    print(io, "BBox{l,t,r,b,w,h = $(left(bbox)),$(top(bbox)), $(right(bbox)),$(bottom(bbox)), $(width(bbox)),$(height(bbox))}")
+end
+
+# -----------------------------------------------------------
+# 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)
+
+# layouts are recursive, tree-like structures, and most will have a parent field
+Base.parent(layout::AbstractLayout) = layout.parent
+parent_bbox(layout::AbstractLayout) = bbox(parent(layout))
+
+# padding_w(layout::AbstractLayout) = left_padding(layout) + right_padding(layout)
+# padding_h(layout::AbstractLayout) = bottom_padding(layout) + top_padding(layout)
+# padding(layout::AbstractLayout) = (padding_w(layout), padding_h(layout))
+
+update_position!(layout::AbstractLayout) = nothing
+update_child_bboxes!(layout::AbstractLayout, minimum_perimeter = [0mm,0mm,0mm,0mm]) = 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))
+
+# 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)
+attr!(layout::AbstractLayout, v, k::Symbol) = (layout.attr[k] = v)
+hasattr(layout::AbstractLayout, k::Symbol) = haskey(layout.attr, k)
+
+leftpad(layout::AbstractLayout)   = 0mm
+toppad(layout::AbstractLayout)    = 0mm
+rightpad(layout::AbstractLayout)  = 0mm
+bottompad(layout::AbstractLayout) = 0mm
+
+# -----------------------------------------------------------
+# RootLayout
+
+# this is the parent of the top-level layout
+immutable RootLayout <: AbstractLayout end
+
+Base.parent(::RootLayout) = nothing
+parent_bbox(::RootLayout) = defaultbox
+bbox(::RootLayout) = defaultbox
+
+# -----------------------------------------------------------
+# EmptyLayout
+
+# contains blank space
+type EmptyLayout <: AbstractLayout
+    parent::AbstractLayout
+    bbox::BoundingBox
+    attr::KW  # store label, width, and height for initialization
+    # label  # this is the label that the subplot will take (since we create a layout before initialization)
+end
+EmptyLayout(parent = RootLayout(); kw...) = EmptyLayout(parent, defaultbox, KW(kw))
+
+Base.size(layout::EmptyLayout) = (0,0)
+Base.length(layout::EmptyLayout) = 0
+Base.getindex(layout::EmptyLayout, r::Int, c::Int) = nothing
+
+_update_min_padding!(layout::EmptyLayout) = nothing
+
 # -----------------------------------------------------------
 # GridLayout
-# -----------------------------------------------------------
 
-"Simple grid, indices are row-major."
-immutable GridLayout <: SubplotLayout
-    nr::Int
-    nc::Int
+# nested, gridded layout with optional size percentages
+type GridLayout <: AbstractLayout
+    parent::AbstractLayout
+    minpad::Tuple # leftpad, toppad, rightpad, bottompad
+    bbox::BoundingBox
+    grid::Matrix{AbstractLayout} # Nested layouts. Each position is a AbstractLayout, which allows for arbitrary recursion
+    widths::Vector{Measure}
+    heights::Vector{Measure}
+    attr::KW
 end
 
-Base.length(layout::GridLayout) = layout.nr * layout.nc
-Base.start(layout::GridLayout) = 1
-Base.done(layout::GridLayout, state) = state > length(layout)
-function Base.next(layout::GridLayout, state)
-  r = div(state-1, layout.nc) + 1
-  c = mod1(state, layout.nc)
-  (r,c), state + 1
-end
+grid(args...; kw...) = GridLayout(args...; kw...)
 
-nrows(layout::GridLayout) = layout.nr
-ncols(layout::GridLayout) = layout.nc
-ncols(layout::GridLayout, row::Int) = layout.nc
-
-# get the plot index given row and column
-Base.getindex(layout::GridLayout, r::Int, c::Int) = (r-1) * layout.nc + c
-
-# -----------------------------------------------------------
-# RowsLayout
-# -----------------------------------------------------------
-
-"Number of plots per row"
-immutable RowsLayout <: SubplotLayout
-    numplts::Int
-    rowcounts::AbstractVector{Int}
-end
-
-Base.length(layout::RowsLayout) = layout.numplts
-Base.start(layout::RowsLayout) = 1
-Base.done(layout::RowsLayout, state) = state > length(layout)
-function Base.next(layout::RowsLayout, state)
-  r = 1
-  c = 0
-  for i = 1:state
-    c += 1
-    if c > layout.rowcounts[r]
-      r += 1
-      c = 1
+function GridLayout(dims...;
+                    parent = RootLayout(),
+                    widths = zeros(dims[2]),
+                    heights = zeros(dims[1]),
+                    kw...)
+    grid = Matrix{AbstractLayout}(dims...)
+    layout = GridLayout(
+        parent,
+        (20mm, 5mm, 2mm, 10mm),
+        defaultbox,
+        grid,
+        Measure[w*pct for w in widths],
+        Measure[h*pct for h in heights],
+        # convert(Vector{Float64}, widths),
+        # convert(Vector{Float64}, heights),
+        KW(kw))
+    for i in eachindex(grid)
+        grid[i] = EmptyLayout(layout)
     end
-  end
-  (r,c), state + 1
+    layout
 end
 
-nrows(layout::RowsLayout) = length(layout.rowcounts)
-ncols(layout::RowsLayout, row::Int) = row < 1 ? 0 : (row > nrows(layout) ? 0 : layout.rowcounts[row])
-
-# get the plot index given row and column
-Base.getindex(layout::RowsLayout, r::Int, c::Int) = sum(layout.rowcounts[1:r-1]) + c
-
-# -----------------------------------------------------------
-# FlexLayout
-# -----------------------------------------------------------
-
-"Flexible, nested layout with optional size percentages."
-immutable FlexLayout <: SubplotLayout
-    n::Int
-    grid::Matrix # Nested layouts. Each position
-                 # can be a plot index or another FlexLayout
-    widths::Vector{Float64}
-    heights::Vector{Float64}
+Base.size(layout::GridLayout) = size(layout.grid)
+Base.length(layout::GridLayout) = length(layout.grid)
+Base.getindex(layout::GridLayout, r::Int, c::Int) = layout.grid[r,c]
+function Base.setindex!(layout::GridLayout, v, r::Int, c::Int)
+    layout.grid[r,c] = v
 end
 
-typealias IntOrFlex Union{Int,FlexLayout}
+leftpad(layout::GridLayout)   = layout.minpad[1]
+toppad(layout::GridLayout)    = layout.minpad[2]
+rightpad(layout::GridLayout)  = layout.minpad[3]
+bottompad(layout::GridLayout) = layout.minpad[4]
 
-Base.length(layout::FlexLayout) = layout.n
-Base.start(layout::FlexLayout) = 1
-Base.done(layout::FlexLayout, state) = state > length(layout)
-function Base.next(layout::FlexLayout, state)
-    # TODO: change this method to return more info
-    # TODO: might consider multiple iterator types.. some backends might have an easier time row-by-row for example
-    error()
-    r = 1
-    c = 0
-    for i = 1:state
-        c += 1
-        if c > layout.rowcounts[r]
-            r += 1
-            c = 1
-        end
-    end
-    (r,c), state + 1
+
+# here's how this works... first we recursively "update the minimum padding" (which
+# means to calculate the minimum size needed from the edge of the subplot to plot area)
+# for the whole layout tree.  then we can compute the "padding borders" of this
+# layout as the biggest padding of the children on the perimeter.  then we need to
+# recursively pass those borders back down the tree, one side at a time, but ONLY
+# to those perimeter children.
+
+# leftpad, toppad, rightpad, bottompad
+function _update_min_padding!(layout::GridLayout)
+    map(_update_min_padding!, layout.grid)
+    layout.minpad = (
+        maximum(map(leftpad,   layout.grid[:,1])),
+        maximum(map(toppad,    layout.grid[1,:])),
+        maximum(map(rightpad,  layout.grid[:,end])),
+        maximum(map(bottompad, layout.grid[end,:]))
+    )
 end
 
-nrows(layout::FlexLayout)           = size(layout.grid, 1)
-ncols(layout::FlexLayout, row::Int) = size(layout.grid, 2)
 
-# get the plot index given row and column
-Base.getindex(layout::FlexLayout, r::Int, c::Int) = layout.grid[r,c]
-
-# -----------------------------------------------------------
-
-# we're taking in a nested structure of some kind... parse it out and build a FlexLayout
-function subplotlayout(mat::AbstractVecOrMat; widths = nothing, heights = nothing)
-    n = 0
-    nr, nc = size(mat)
-    grid = Array(IntOrFlex, nr, nc)
-    for i=1:nr, j=1:nc
-        v = mat[i,j]
-
-        if isa(v, Integer)
-            grid[i,j] = Int(v)
-            n += 1
-
-        elseif isa(v, Tuple)
-            warn("need to handle tuples somehow... (idx, sizepct)")
-            grid[i,j] = nothing
-
-        elseif v == nothing
-            grid[i,j] = nothing
-
-        elseif isa(v, AbstractVecOrMat)
-            grid[i,j] = layout(v)
-            n += grid[i,j].n
+function update_position!(layout::GridLayout)
+    map(update_position!, layout.grid)
+end
 
+# some lengths are fixed... we have to split up the free space among the list v
+function recompute_lengths(v)
+    # dump(v)
+    tot = 0pct
+    cnt = 0
+    for vi in v
+        if vi == 0pct
+            cnt += 1
         else
-            error("How do we process? $v")
+            tot += vi
         end
     end
-
-    if widths == nothing
-        widths = ones(nc) ./ nc
-    end
-    if heights == nothing
-        heights = ones(nr) ./ nr
+    leftover = 1.0pct - tot
+    if cnt > 1 && leftover.value <= 0
+        error("Not enough length left over in layout!  v = $v, cnt = $cnt, leftover = $leftover")
     end
 
-    FlexLayout(n, grid, widths, heights)
+    # now fill in the blanks
+    Measure[(vi == 0pct ? leftover / cnt : vi) for vi in v]
 end
 
+# recursively compute the bounding boxes for the layout and plotarea (relative to canvas!)
+function update_child_bboxes!(layout::GridLayout, minimum_perimeter = [0mm,0mm,0mm,0mm])
+    nr, nc = size(layout)
 
-function subplotlayout(sz::Tuple{Int,Int})
-  GridLayout(sz...)
+    # # 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)
+
+    # get the max horizontal (left and right) padding over columns,
+    # and max vertical (bottom and top) padding over rows
+    # TODO: add extra padding here
+    pad_left   = maximum(minpad_left,   1)
+    pad_top    = maximum(minpad_top,    2)
+    pad_right  = maximum(minpad_right,  1)
+    pad_bottom = maximum(minpad_bottom, 2)
+
+    # make sure the perimeter match the parent
+    pad_left[1]     = max(pad_left[1], minimum_perimeter[1])
+    pad_top[1]      = max(pad_top[1], minimum_perimeter[2])
+    pad_right[end]  = max(pad_right[end], minimum_perimeter[3])
+    pad_bottom[end] = max(pad_bottom[end], minimum_perimeter[4])
+
+    # scale this up to the total padding in each direction
+    total_pad_horizontal = sum(pad_left + pad_right)
+    total_pad_vertical   = sum(pad_top + pad_bottom)
+
+    # now we can compute the total plot area in each direction
+    total_plotarea_horizontal = width(layout)  - total_pad_horizontal
+    total_plotarea_vertical   = height(layout) - total_pad_vertical
+
+    # recompute widths/heights
+    layout.widths = recompute_lengths(layout.widths)
+    layout.heights = recompute_lengths(layout.heights)
+
+    # normalize widths/heights so they sum to 1
+    # denom_w = sum(layout.widths)
+    # denom_h = sum(layout.heights)
+
+    # we have all the data we need... lets compute the plot areas and set the bounding boxes
+    for r=1:nr, c=1:nc
+        child = layout[r,c]
+
+        # get the top-left corner of this child... the first one is top-left of the parent (i.e. layout)
+        child_left = (c == 1 ? left(layout.bbox) : right(layout[r, c-1].bbox))
+        child_top  = (r == 1 ? top(layout.bbox) : bottom(layout[r-1, c].bbox))
+
+        # compute plot area
+        plotarea_left   = child_left + pad_left[c]
+        plotarea_top    = child_top + pad_top[r]
+        plotarea_width  = total_plotarea_horizontal * layout.widths[c]
+        plotarea_height = total_plotarea_vertical * layout.heights[r]
+        plotarea!(child, BoundingBox(plotarea_left, plotarea_top, plotarea_width, plotarea_height))
+
+        # compute child bbox
+        child_width  = pad_left[c] + plotarea_width + pad_right[c]
+        child_height = pad_top[r] + plotarea_height + pad_bottom[r]
+        bbox!(child, BoundingBox(child_left, child_top, child_width, child_height))
+
+        # this is the minimum perimeter as decided by this child's parent, so that
+        # all children on this border have the same value
+        min_child_perimeter = [
+            c == 1  ? layout.minpad[1] : 0mm,
+            r == 1  ? layout.minpad[2] : 0mm,
+            c == nc ? layout.minpad[3] : 0mm,
+            r == nr ? layout.minpad[4] : 0mm
+        ]
+
+        # recursively update the child's children
+        update_child_bboxes!(child, min_child_perimeter)
+    end
 end
 
-function subplotlayout(rowcounts::AVec{Int})
-  RowsLayout(sum(rowcounts), rowcounts)
+# 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
 
-function subplotlayout(numplts::Int, nr::Int, nc::Int)
+# ----------------------------------------------------------------------
 
-  # figure out how many rows/columns we need
-  if nr == -1
-    if nc == -1
-      nr = round(Int, sqrt(numplts))
-      nc = ceil(Int, numplts / nr)
+calc_num_subplots(layout::AbstractLayout) = 1
+function calc_num_subplots(layout::GridLayout)
+    tot = 0
+    for l in layout.grid
+        tot += calc_num_subplots(l)
+    end
+    tot
+end
+
+function compute_gridsize(numplts::Int, nr::Int, nc::Int)
+    # figure out how many rows/columns we need
+    if nr < 1
+        if nc < 1
+            nr = round(Int, sqrt(numplts))
+            nc = ceil(Int, numplts / nr)
+        else
+            nr = ceil(Int, numplts / nc)
+        end
     else
-      nr = ceil(Int, numplts / nc)
+        nc = ceil(Int, numplts / nr)
     end
-  else
-    nc = ceil(Int, numplts / nr)
-  end
-
-  # if it's a perfect rectangle, just create a grid
-  if numplts == nr * nc
-    return GridLayout(nr, nc)
-  end
-
-  # create the rowcounts vector
-  i = 0
-  rowcounts = Int[]
-  for r in 1:nr
-    cnt = min(nc, numplts - i)
-    push!(rowcounts, cnt)
-    i += cnt
-  end
-
-  RowsLayout(numplts, rowcounts)
+    nr, nc
 end
+
+# ----------------------------------------------------------------------
+# constructors
+
+# pass the layout arg through
+function layout_args(d::KW)
+    layout_args(get(d, :layout, default(:layout)))
+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) != n_override ($(n_override)).  You're probably trying to force existing plots into a layout that doesn't fit them.")
+    end
+    layout, n
+end
+
+function layout_args(n::Integer)
+    nr, nc = compute_gridsize(n, -1, -1)
+    GridLayout(nr, nc), n
+end
+
+function layout_args{I<:Integer}(sztup::NTuple{2,I})
+    nr, nc = sztup
+    GridLayout(nr, nc), nr*nc
+end
+
+function layout_args{I<:Integer}(sztup::NTuple{3,I})
+    n, nr, nc = sztup
+    nr, nc = compute_gridsize(n, nr, nc)
+    GridLayout(nr, nc), n
+end
+
+# compute number of subplots
+function layout_args(layout::GridLayout)
+    # recursively get the size of the grid
+    n = calc_num_subplots(layout)
+    layout, n
+end
+
+layout_args(huh) = error("unhandled layout type $(typeof(huh)): $huh")
+
+
+# ----------------------------------------------------------------------
+
+
+function build_layout(args...)
+    layout, n = layout_args(args...)
+    build_layout(layout, n)
+end
+
+# # just a single subplot
+# function build_layout(sp::Subplot, n::Integer)
+#     sp, Subplot[sp], 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[]
+    spmap = SubplotMap()
+    i = 0
+    for r=1:nr, c=1:nc
+        l = layout[r,c]
+        if isa(l, EmptyLayout) && !get(l.attr, :blank, false)
+            sp = Subplot(backend(), parent=layout)
+            layout[r,c] = sp
+            push!(subplots, sp)
+            spmap[attr(l,:label,gensym())] = sp
+            if get(l.attr, :width, :auto) != :auto
+                layout.widths[c] = attr(l,:width)
+            end
+            if get(l.attr, :height, :auto) != :auto
+                layout.heights[r] = attr(l,:height)
+            end
+            i += 1
+        elseif isa(l, GridLayout)
+            # sub-grid
+            if get(l.attr, :width, :auto) != :auto
+                layout.widths[c] = attr(l,:width)
+            end
+            if get(l.attr, :height, :auto) != :auto
+                layout.heights[r] = attr(l,:height)
+            end
+            l, sps, m = build_layout(l, n-i)
+            append!(subplots, sps)
+            merge!(spmap, m)
+            i += length(sps)
+        elseif isa(l, Subplot)
+            error("Subplot exists. Cannot re-use existing layout.  Please make a new one.")
+        end
+        i >= n && break  # only add n subplots
+    end
+
+    layout, subplots, spmap
+end
+
+# build a layout from a list of existing Plot objects
+# TODO... much of the logic overlaps with the method above... can we merge?
+function build_layout(layout::GridLayout, numsp::Integer, plts::AVec{Plot})
+    nr, nc = size(layout)
+    subplots = Subplot[]
+    spmap = SubplotMap()
+    i = 0
+    for r=1:nr, c=1:nc
+        l = layout[r,c]
+        if isa(l, EmptyLayout) && !get(l.attr, :blank, false)
+            plt = shift!(plts)  # grab the first plot out of the list
+            layout[r,c] = plt.layout
+            append!(subplots, plt.subplots)
+            merge!(spmap, plt.spmap)
+            if get(l.attr, :width, :auto) != :auto
+                layout.widths[c] = attr(l,:width)
+            end
+            if get(l.attr, :height, :auto) != :auto
+                layout.heights[r] = attr(l,:height)
+            end
+            i += length(plt.subplots)
+        elseif isa(l, GridLayout)
+            # sub-grid
+            if get(l.attr, :width, :auto) != :auto
+                layout.widths[c] = attr(l,:width)
+            end
+            if get(l.attr, :height, :auto) != :auto
+                layout.heights[r] = attr(l,:height)
+            end
+            l, sps, m = build_layout(l, numsp-i, plts)
+            append!(subplots, sps)
+            merge!(spmap, m)
+            i += length(sps)
+        end
+        i >= numsp && break  # only add n subplots
+    end
+    layout, subplots, spmap
+end
+
+
+# ----------------------------------------------------------------------
+# @layout macro
+
+function add_layout_pct!(kw::KW, v::Expr, idx::Integer, nidx::Integer)
+    # dump(v)
+    # something like {0.2w}?
+    if v.head == :call && v.args[1] == :*
+        num = v.args[2]
+        if length(v.args) == 3 && isa(num, Number)
+            units = v.args[3]
+            if units == :h
+                return kw[:h] = num*pct
+            elseif units == :w
+                return kw[:w] = num*pct
+            elseif units in (:pct, :px, :mm, :cm, :inch)
+                idx == 1 && (kw[:w] = v)
+                (idx == 2 || nidx == 1) && (kw[:h] = v)
+                # return kw[idx == 1 ? :w : :h] = v
+            end
+        end
+    end
+    error("Couldn't match layout curly (idx=$idx): $v")
+end
+
+function add_layout_pct!(kw::KW, v::Number, idx::Integer)
+    # kw[idx == 1 ? :w : :h] = v*pct
+    idx == 1 && (kw[:w] = v*pct)
+    (idx == 2 || nidx == 1) && (kw[:h] = v*pct)
+end
+
+isrow(v) = isa(v, Expr) && v.head in (:hcat,:row)
+iscol(v) = isa(v, Expr) && v.head == :vcat
+rowsize(v) = isrow(v) ? length(v.args) : 1
+
+
+function create_grid(expr::Expr)
+    if iscol(expr)
+        create_grid_vcat(expr)
+    elseif isrow(expr)
+        :(let cell = GridLayout(1, $(length(expr.args)))
+            $([:(cell[1,$i] = $(create_grid(v))) for (i,v) in enumerate(expr.args)]...)
+            cell
+        end)
+
+    elseif expr.head == :curly
+        create_grid_curly(expr)
+    else
+        # if it's something else, just return that (might be an existing layout?)
+        esc(expr)
+    end
+end
+
+function create_grid_vcat(expr::Expr)
+    rowsizes = map(rowsize, expr.args)
+    rmin, rmax = extrema(rowsizes)
+    if rmin > 0 && rmin == rmax
+        # we have a grid... build the whole thing
+        # note: rmin is the number of columns
+        nr = length(expr.args)
+        nc = rmin
+        body = Expr(:block)
+        for r=1:nr
+            arg = expr.args[r]
+            if isrow(arg)
+                for (c,item) in enumerate(arg.args)
+                    push!(body.args, :(cell[$r,$c] = $(create_grid(item))))
+                end
+            else
+                push!(body.args, :(cell[$r,1] = $(create_grid(arg))))
+            end
+        end
+        :(let cell = GridLayout($nr, $nc)
+            $body
+            cell
+        end)
+    else
+        # otherwise just build one row at a time
+        :(let cell = GridLayout($(length(expr.args)), 1)
+            $([:(cell[$i,1] = $(create_grid(v))) for (i,v) in enumerate(expr.args)]...)
+            cell
+        end)
+    end
+end
+
+function create_grid_curly(expr::Expr)
+    kw = KW()
+    for (i,arg) in enumerate(expr.args[2:end])
+        add_layout_pct!(kw, arg, i, length(expr.args)-1)
+    end
+    s = expr.args[1]
+    if isa(s, Expr) && s.head == :call && s.args[1] == :grid
+        create_grid(:(grid($(s.args[2:end]...), width = $(get(kw, :w, QuoteNode(:auto))), height = $(get(kw, :h, QuoteNode(:auto))))))
+    elseif isa(s, Symbol)
+        :(EmptyLayout(label = $(QuoteNode(s)), width = $(get(kw, :w, QuoteNode(:auto))), height = $(get(kw, :h, QuoteNode(:auto)))))
+    else
+        error("Unknown use of curly brackets: $expr")
+    end
+end
+
+function create_grid(s::Symbol)
+    :(EmptyLayout(label = $(QuoteNode(s)), blank = $(s == :_)))
+end
+
+macro layout(mat::Expr)
+    create_grid(mat)
+end
+
+
+# -------------------------------------------------------------------------
+
+# make all reference the same axis extrema/values.
+# merge subplot lists.
+function link_axes!(axes::Axis...)
+    a1 = axes[1]
+    for i=2:length(axes)
+        a2 = axes[i]
+        expand_extrema!(a1, extrema(a2))
+        for k in (:extrema, :discrete_values, :continuous_values, :discrete_map)
+            a2[k] = a1[k]
+        end
+
+        # make a2's subplot list refer to a1's and add any missing values
+        sps2 = a2.sps
+        for sp in sps2
+            sp in a1.sps || push!(a1.sps, sp)
+        end
+        a2.sps = a1.sps
+    end
+end
+
+# figure out which subplots to link
+function link_subplots(a::AbstractArray{AbstractLayout}, axissym::Symbol)
+    subplots = []
+    for l in a
+        if isa(l, Subplot)
+            push!(subplots, l)
+        elseif isa(l, GridLayout) && size(l) == (1,1)
+            push!(subplots, l[1,1])
+        end
+    end
+    subplots
+end
+
+# for some vector or matrix of layouts, filter only the Subplots and link those axes
+function link_axes!(a::AbstractArray{AbstractLayout}, axissym::Symbol)
+    subplots = link_subplots(a, axissym)
+    axes = [sp.attr[axissym] for sp in subplots]
+    if length(axes) > 0
+        link_axes!(axes...)
+    end
+end
+
+# don't do anything for most layout types
+function link_axes!(l::AbstractLayout, link::Symbol)
+end
+
+# process a GridLayout, recursively linking axes according to the link symbol
+function link_axes!(layout::GridLayout, link::Symbol)
+    nr, nc = size(layout)
+    if link in (:x, :both)
+        for c=1:nc
+            link_axes!(layout.grid[:,c], :xaxis)
+        end
+    end
+    if link in (:y, :both)
+        for r=1:nr
+            link_axes!(layout.grid[r,:], :yaxis)
+        end
+    end
+    if link == :square
+        sps = filter(l -> isa(l, Subplot), layout.grid)
+        if !isempty(sps)
+            base_axis = sps[1][:xaxis]
+            for sp in sps
+                link_axes!(base_axis, sp[:xaxis])
+                link_axes!(base_axis, sp[:yaxis])
+            end
+        end
+    end
+    if link == :all
+        link_axes!(layout.grid, :xaxis)
+        link_axes!(layout.grid, :yaxis)
+    end
+    for l in layout.grid
+        link_axes!(l, link)
+    end
+end
+
+# -------------------------------------------------------------------------
+
+"Adds a new, empty subplot overlayed on top of `sp`, with a mirrored y-axis and linked x-axis."
+function twinx(sp::Subplot)
+    sp[:right_margin] = max(sp[:right_margin], 30px)
+    plot!(sp.plt, inset = (sp[:subplot_index], bbox(0,0,1,1)))
+    twinsp = sp.plt.subplots[end]
+    twinsp[:yaxis][:mirror] = true
+    twinsp[:background_color_inside] = RGBA{Float64}(0,0,0,0)
+    link_axes!(sp[:xaxis], twinsp[:xaxis])
+    twinsp
+end
+
+twinx(plt::Plot = current()) = twinx(plt[1])

src/output.jl

@@ -1,63 +1,71 @@
 
 
-defaultOutputFormat(plt::AbstractPlot) = "png"
+defaultOutputFormat(plt::Plot) = "png"
 
-function png(plt::AbstractPlot, fn::@compat(AbstractString))
+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::@compat(AbstractString)) = png(current(), fn)
+png(fn::AbstractString) = png(current(), fn)
 
-function svg(plt::AbstractPlot, fn::@compat(AbstractString))
+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::@compat(AbstractString)) = svg(current(), fn)
+svg(fn::AbstractString) = svg(current(), fn)
 
 
-function pdf(plt::AbstractPlot, fn::@compat(AbstractString))
+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::@compat(AbstractString)) = pdf(current(), fn)
+pdf(fn::AbstractString) = pdf(current(), fn)
 
 
-function ps(plt::AbstractPlot, fn::@compat(AbstractString))
+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::@compat(AbstractString)) = ps(current(), fn)
+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::AbstractPlot, fn::@compat(AbstractString))
+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::@compat(AbstractString)) = tex(current(), fn)
+tex(fn::AbstractString) = tex(current(), fn)
 
 
 # ----------------------------------------------------------------
 
 
-@compat const _savemap = Dict(
+const _savemap = Dict(
     "png" => png,
     "svg" => svg,
     "pdf" => pdf,
     "ps"  => ps,
+    "eps" => eps,
     "tex" => tex,
   )
 
-function getExtension(fn::@compat(AbstractString))
+function getExtension(fn::AbstractString)
   pieces = split(fn, ".")
   length(pieces) > 1 || error("Can't extract file extension: ", fn)
   ext = pieces[end]
@@ -65,7 +73,7 @@ function getExtension(fn::@compat(AbstractString))
   ext
 end
 
-function addExtension(fn::@compat(AbstractString), ext::@compat(AbstractString))
+function addExtension(fn::AbstractString, ext::AbstractString)
   try
     oldext = getExtension(fn)
     if oldext == ext
@@ -78,7 +86,7 @@ function addExtension(fn::@compat(AbstractString), ext::@compat(AbstractString))
   end
 end
 
-function savefig(plt::AbstractPlot, fn::@compat(AbstractString))
+function savefig(plt::Plot, fn::AbstractString)
 
   # get the extension
   local ext
@@ -96,56 +104,198 @@ function savefig(plt::AbstractPlot, fn::@compat(AbstractString))
   end
   func(plt, fn)
 end
-savefig(fn::@compat(AbstractString)) = savefig(current(), fn)
-
-
-# savepng(args...; kw...) = savepng(current(), args...; kw...)
-# savepng(plt::AbstractPlot, fn::@compat(AbstractString); kw...) = (io = open(fn, "w"); writemime(io, MIME("image/png"), plt); close(io))
-
-
+savefig(fn::AbstractString) = savefig(current(), fn)
 
 
 # ---------------------------------------------------------
 
-gui(plt::AbstractPlot = current()) = display(PlotsDisplay(), plt)
+gui(plt::Plot = current()) = display(PlotsDisplay(), plt)
 
-
-# override the REPL display to open a gui window
-Base.display(::Base.REPL.REPLDisplay, ::MIME"text/plain", plt::AbstractPlot) = gui(plt)
-
-# a backup for html... passes to svg
-function Base.writemime(io::IO, ::MIME"text/html", plt::AbstractPlot)
-  writemime(io, MIME("image/svg+xml"), plt)
+function Base.display(::PlotsDisplay, plt::Plot)
+    prepare_output(plt)
+    _display(plt)
 end
 
+# override the REPL display to open a gui window
+Base.display(::Base.REPL.REPLDisplay, ::MIME"text/plain", plt::Plot) = gui(plt)
+
+# ---------------------------------------------------------
+
+const _mimeformats = Dict(
+    "application/eps"         => "eps",
+    "image/eps"               => "eps",
+    "application/pdf"         => "pdf",
+    "image/png"               => "png",
+    "application/postscript"  => "ps",
+    "image/svg+xml"           => "svg",
+    "text/plain"              => "txt",
+)
+
+const _best_html_output_type = KW(
+    :pyplot => :png,
+    :unicodeplots => :txt,
+    :glvisualize => :png
+)
+
+# a backup for html... passes to svg or png depending on the html_output_format arg
+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(show, MIME("image/png"), plt), "\" />")
+    elseif output_type == :svg
+        # info("writing svg to html output")
+        show(io, MIME("image/svg+xml"), plt)
+    elseif output_type == :txt
+        show(io, MIME("text/plain"), plt)
+    else
+        error("only png or svg allowed. got: $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.show{B}(io::IO, m::MIME{Symbol($mime)}, plt::Plot{B})
+        prepare_output(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.show(io::IO, ::MIME"text/html", plt::Plot)
+#             print(io, "<img src=\"data:image/png;base64,", base64(show, MIME("image/png"), plt), "\" />")
+#         end
+#     elseif fmt == "svg"
+#         @eval function Base.show(io::IO, ::MIME"text/html", plt::Plot)
+#             show(io, MIME("image/svg+xml"), plt)
+#         end
+#     else
+#         error("only png or svg allowed. got: $fmt")
+#     end
+# end
+#
+# html_output_format("svg")
+
+# ---------------------------------------------------------
+# IJulia
+# ---------------------------------------------------------
+
+const _ijulia_output = String["text/html"]
+
+function setup_ijulia()
+    # override IJulia inline display
+    if isijulia()
+        @eval begin
+            import IJulia
+            export set_ijulia_output
+            function set_ijulia_output(mimestr::AbstractString)
+                # info("Setting IJulia output format to $mimestr")
+                global _ijulia_output
+                _ijulia_output[1] = mimestr
+            end
+            function IJulia.display_dict(plt::Plot)
+                global _ijulia_output
+                Dict{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")
+    end
+end
 
 # ---------------------------------------------------------
 # Atom PlotPane
 # ---------------------------------------------------------
 
 function setup_atom()
-    # @require Atom begin
     if isatom()
-        # @eval import Atom, Media
-        @eval import Atom
+        @eval import Atom, Media
+        Media.media(Plot, Media.Plot)
 
-        # connects the render function
-        for T in (GadflyBackend,ImmerseBackend,PyPlotBackend,GRBackend)
-            Atom.Media.media(AbstractPlot{T}, Atom.Media.Plot)
-        end
-        # Atom.Media.media{T <: Union{GadflyBackend,ImmerseBackend,PyPlotBackend,GRBackend}}(Plot{T}, Atom.Media.Plot)
-
-        # Atom.displaysize(::AbstractPlot) = (535, 379)
-        # Atom.displaytitle(plt::AbstractPlot) = "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::AbstractPlot)
-            Atom.Media.render(pane, Atom.div(Atom.d(), Atom.HTML(stringmime(MIME("text/html"), plt))))
+        # default text/plain so it doesn't complain
+        function Base.show{B}(io::IO, ::MIME"text/plain", plt::Plot{B})
+            print(io, "Plot{$B}()")
         end
 
+        function Media.render(e::Atom.Editor, plt::Plot)
+            Media.render(e, nothing)
+        end
 
-        # function Atom.Media.render(pane::Atom.PlotPane, plt::Plot{PlotlyBackend})
-        #     html = Media.render(pane, Atom.div(Atom.d(), Atom.HTML(stringmime(MIME("text/html"), plt))))
-        # end
+        if get(ENV, "PLOTS_USE_ATOM_PLOTPANE", true) in (true, 1, "1", "true", "yes")
+            # this is like "display"... sends an html div with the plot to the PlotPane
+            function Media.render(pane::Atom.PlotPane, plt::Plot)
+                # temporarily overwrite size to be Atom.plotsize
+                sz = plt[:size]
+                plt[:size] = Juno.plotsize()
+                Media.render(pane, Atom.div(".fill", Atom.HTML(stringmime(MIME("text/html"), plt))))
+                plt[:size] = sz
+            end
+        else
+            #
+            function Media.render(pane::Atom.PlotPane, plt::Plot)
+                display(Plots.PlotsDisplay(), plt)
+                s = "PlotPane turned off.  Unset ENV[\"PLOTS_USE_ATOM_PLOTPANE\"] and restart Julia to enable it."
+                Media.render(pane, Atom.div(Atom.HTML(s)))
+            end
+        end
+
+        # special handling for plotly... use PlotsDisplay
+        function Media.render(pane::Atom.PlotPane, plt::Plot{PlotlyBackend})
+            display(Plots.PlotsDisplay(), plt)
+            s = "PlotPane turned off.  The plotly and plotlyjs backends cannot render in the PlotPane due to javascript issues."
+            Media.render(pane, Atom.div(Atom.HTML(s)))
+        end
+
+        # special handling for PlotlyJS to pass through to that render method
+        function Media.render(pane::Atom.PlotPane, plt::Plot{PlotlyJSBackend})
+            Plots.prepare_output(plt)
+            Media.render(pane, plt.o)
+        end
     end
 end

src/pipeline.jl

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

src/plot.jl

@@ -22,7 +22,7 @@ Base.print(io::IO, plt::Plot) = print(io, string(plt))
 Base.show(io::IO, plt::Plot) = print(io, string(plt))
 
 getplot(plt::Plot) = plt
-getplotargs(plt::Plot, idx::Int = 1) = plt.plotargs
+getattr(plt::Plot, idx::Int = 1) = plt.attr
 convertSeriesIndex(plt::Plot, n::Int) = n
 
 # ---------------------------------------------------------
@@ -43,17 +43,93 @@ When you pass in matrices, it splits by columns.  See the documentation for more
 
 # this creates a new plot with args/kw and sets it to be the current plot
 function plot(args...; kw...)
-    pkg = backend()
     d = KW(kw)
     preprocessArgs!(d)
-    dumpdict(d, "After plot preprocessing")
 
-    plotargs = merge(d, getPlotArgs(pkg, d, 1))
-    dumpdict(plotargs, "Plot args")
-    plt = _create_plot(pkg, plotargs)  # create a new, blank plot
+    # create an empty Plot then process
+    plt = Plot()
+    # plt.user_attr = d
+    _plot!(plt, d, args)
+end
 
-    delete!(d, :background_color)
-    plot!(plt, args...; d...)  # add to it
+# build a new plot from existing plots
+# note: we split into plt1 and plts_tail so we can dispatch correctly
+function plot(plt1::Plot, plts_tail::Plot...; kw...)
+    d = KW(kw)
+    preprocessArgs!(d)
+
+    # build our plot vector from the args
+    n = length(plts_tail) + 1
+    plts = Array(Plot, n)
+    plts[1] = plt1
+    for (i,plt) in enumerate(plts_tail)
+        plts[i+1] = plt
+    end
+
+    # compute the layout
+    layout = layout_args(d, n)[1]
+    num_sp = sum([length(p.subplots) for p in plts])
+
+    # create a new plot object, with subplot list/map made of existing subplots.
+    # note: we create a new backend figure for this new plot object
+    # note: all subplots and series "belong" to this new plot...
+    plt = Plot()
+
+    # TODO: build the user_attr dict by creating "Any matrices" for the args of each subplot
+
+    # TODO: replace this with proper processing from a merged user_attr KW
+    # update plot args, first with existing plots, then override with d
+    for p in plts
+        _update_plot_args(plt, p.attr)
+        plt.n += p.n
+    end
+    _update_plot_args(plt, d)
+
+    # pass new plot to the backend
+    plt.o = _create_backend_figure(plt)
+    plt.init = true
+
+    series_attr = KW()
+    for (k,v) in d
+        if haskey(_series_defaults, k)
+            series_attr[k] = pop!(d,k)
+        end
+    end
+
+    # create the layout and initialize the subplots
+    plt.layout, plt.subplots, plt.spmap = build_layout(layout, num_sp, copy(plts))
+    cmdidx = 1
+    for (idx, sp) in enumerate(plt.subplots)
+        _initialize_subplot(plt, sp)
+        serieslist = series_list(sp)
+        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
+    plt
 end
 
 
@@ -73,206 +149,139 @@ end
 function plot!(plt::Plot, args...; kw...)
     d = KW(kw)
     preprocessArgs!(d)
+    # merge!(plt.user_attr, d)
+    _plot!(plt, d, args)
+end
 
-    # for plotting recipes, swap out the args and update the parameter dictionary
-    args = _apply_recipe(d, args...; kw...)
+# -------------------------------------------------------------------------------
 
-    dumpdict(d, "After plot! preprocessing")
-    warnOnUnsupportedArgs(plt.backend, d)
+# 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::Tuple)
+    d[:plot_object] = plt
 
-    # just in case the backend needs to set up the plot (make it current or something)
-    _before_add_series(plt)
-
-    # # grouping
-    groupby = if haskey(d, :group)
-        extractGroupArgs(d[:group], args...)
-    else
-        nothing
+    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
 
-    # merge plot args
-    if !haskey(d, :subplot)
-        for k in keys(_plotDefaults)
-            if haskey(d, k)
-                plt.plotargs[k] = d[k]
-            end
-        end
-        # merge!(plt.plotargs, d)
-        handlePlotColors(plt.backend, plt.plotargs)
+    # --------------------------------
+    # "USER RECIPES"
+    # --------------------------------
+
+    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[]
+    while !isempty(still_to_process)
+        next_kw = shift!(still_to_process)
+        _process_plotrecipe(plt, next_kw, kw_list, still_to_process)
     end
 
-    _add_series(plt, d, groupby, args...)
-    _add_annotations(plt, d)
+    # info(2)
+    # map(DD, kw_list)
 
-    warnOnUnsupportedScales(plt.backend, d)
+    # --------------------------------
+    # 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 !!!
 
-    # add title, axis labels, ticks, etc
-    if !haskey(d, :subplot)
-        # merge!(plt.plotargs, d)
-        # handlePlotColors(plt.backend, plt.plotargs)
-        dumpdict(plt.plotargs, "Updating plot items")
-        _update_plot(plt, plt.plotargs)
+    # --------------------------------
+    # "SERIES RECIPES"
+    # --------------------------------
+
+    # info(3)
+    # map(DD, kw_list)
+
+    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, true)
+
+        # set default values, select from attribute cycles, and generally set the final attributes
+        _add_defaults!(kw, plt, sp, command_idx(kw_list,kw))
+
+        # now we have a fully specified series, with colors chosen.   we must recursively handle
+        # series recipes, which dispatch on seriestype.  If a backend does not natively support a seriestype,
+        # we check for a recipe that will convert that series type into one made up of lower-level components.
+        # For example, a histogram is just a bar plot with binned data, a bar plot is really a filled step plot,
+        # and a step plot is really just a path.  So any backend that supports drawing a path will implicitly
+        # be able to support step, bar, and histogram plots (and any recipes that use those components).
+        _process_seriesrecipe(plt, kw)
     end
 
-    _update_plot_pos_size(plt, d)
+    # --------------------------------
 
     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]
-        gui()
+    # do we want to force display?
+    if plt[:show]
+        gui(plt)
     end
 
     plt
 end
 
-# handle the grouping
-function _add_series(plt::Plot, d::KW, groupby::GroupBy, args...)
-    starting_n = plt.n
-    for (i, glab) in enumerate(groupby.groupLabels)
-        tmpd = copy(d)
-        tmpd[:numUncounted] = plt.n - starting_n
-        _add_series(plt, tmpd, nothing, args...;
-                    idxfilter = groupby.groupIds[i],
-                    grouplabel = string(glab))
+
+# we're getting ready to display/output.  prep for layout calcs, then update
+# the plot object after
+function prepare_output(plt::Plot)
+    _before_layout_calcs(plt)
+
+    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
 
-filter_data(v::AVec, idxfilter::AVec{Int}) = v[idxfilter]
-filter_data(v, idxfilter) = v
-
-function filter_data!(d::KW, idxfilter)
-    for s in (:x, :y, :z)
-        d[s] = filter_data(get(d, s, nothing), idxfilter)
-    end
-end
-
-# no grouping
-function _add_series(plt::Plot, d::KW, ::Void, args...;
-                     idxfilter = nothing,
-                     grouplabel = "")
-
-    # get the list of dictionaries, one per series
-    dumpdict(d, "before process_inputs")
-    process_inputs(plt, d, args...)
-    dumpdict(d, "after process_inputs")
-
-    if idxfilter != nothing
-        # add the group name as the label if there isn't one passed in
-        get!(d, :label, grouplabel)
-        # filter the data
-        filter_data!(d, idxfilter)
-    end
-
-    seriesArgList, xmeta, ymeta = build_series_args(plt, d) #, idxfilter)
-    # seriesArgList, xmeta, ymeta = build_series_args(plt, groupargs..., args...; d...)
-
-    # if we were able to extract guide information from the series inputs, then update the plot
-    # @show xmeta, ymeta
-    updateDictWithMeta(d, plt.plotargs, xmeta, true)
-    updateDictWithMeta(d, plt.plotargs, ymeta, false)
-
-    # now we can plot the series
-    for (i,di) in enumerate(seriesArgList)
-        plt.n += 1
-
-        if !stringsSupported() && di[:linetype] != :pie
-            setTicksFromStringVector(d, di, :x, :xticks)
-            setTicksFromStringVector(d, di, :y, :yticks)
-            setTicksFromStringVector(d, di, :z, :zticks)
-        end
-
-        # remove plot args
-        for k in keys(_plotDefaults)
-            delete!(di, k)
-        end
-
-        # merge in plotarg_overrides
-        plotarg_overrides = pop!(di, :plotarg_overrides, nothing)
-        if plotarg_overrides != nothing
-            merge!(plt.plotargs, plotarg_overrides)
-        end
-        # dumpdict(plt.plotargs, "pargs", true)
-
-        dumpdict(di, "Series $i")
-
-        _add_series(plt.backend, plt, di)
-    end
+function backend_object(plt::Plot)
+    prepare_output(plt)
+    plt.o
 end
 
 # --------------------------------------------------------------------
+# plot to a Subplot
 
-# if x or y are a vector of strings, we should create a list of unique strings,
-# and map x/y to be the index of the string... then set the x/y tick labels
-function setTicksFromStringVector(d::KW, di::KW, sym::Symbol, ticksym::Symbol)
-    # if the x or y values are strings, set ticks to the unique values, and x/y to the indices of the ticks
-
-    v = di[sym]
-    isa(v, AbstractArray) || return
-
-    T = eltype(v)
-    if T <: @compat(AbstractString) || (!isempty(T.types) && all(x -> x <: @compat(AbstractString), T.types))
-        ticks = unique(di[sym])
-        di[sym] = Int[findnext(ticks, v, 1) for v in di[sym]]
-
-        if !haskey(d, ticksym) || d[ticksym] == :auto
-            d[ticksym] = (collect(1:length(ticks)), UTF8String[t for t in ticks])
-        end
-    end
-end
-
-# --------------------------------------------------------------------
-
-_before_add_series(plt::Plot) = nothing
-
-# --------------------------------------------------------------------
-
-# should we update the x/y label given the meta info during input slicing?
-function updateDictWithMeta(d::KW, plotargs::KW, meta::Symbol, isx::Bool)
-    lsym = isx ? :xlabel : :ylabel
-    if plotargs[lsym] == default(lsym)
-        d[lsym] = string(meta)
-    end
-end
-updateDictWithMeta(d::KW, plotargs::KW, meta, isx::Bool) = nothing
-
-# --------------------------------------------------------------------
-
-annotations(::@compat(Void)) = []
-annotations{X,Y,V}(v::AVec{@compat(Tuple{X,Y,V})}) = v
-annotations{X,Y,V}(t::@compat(Tuple{X,Y,V})) = [t]
-annotations(v::AVec{PlotText}) = v
-annotations(v::AVec) = map(PlotText, v)
-annotations(anns) = error("Expecting a tuple (or vector of tuples) for annotations: ",
-                       "(x, y, annotation)\n    got: $(typeof(anns))")
-
-function _add_annotations(plt::Plot, d::KW)
-    anns = annotations(get(d, :annotation, nothing))
-    if !isempty(anns)
-
-        # if we just have a list of PlotText objects, then create (x,y,text) tuples
-        if typeof(anns) <: AVec{PlotText}
-            x, y = plt[plt.n]
-            anns = Tuple{Float64,Float64,PlotText}[(x[i], y[i], t) for (i,t) in enumerate(anns)]
-        end
-
-        _add_annotations(plt, anns)
-    end
-end
-
-
-# --------------------------------------------------------------------
-
-function Base.copy(plt::Plot)
-    backend(plt.backend)
-    plt2 = plot(; plt.plotargs...)
-    for sargs in plt.seriesargs
-        sargs = filter((k,v) -> haskey(_seriesDefaults,k), sargs)
-        plot!(plt2; sargs...)
-    end
-    plt2
+function plot(sp::Subplot, args...; kw...)
+    plt = sp.plt
+    plot(plt, args...; kw..., subplot = findfirst(plt.subplots, sp))
+end
+function plot!(sp::Subplot, args...; kw...)
+    plt = sp.plt
+    plot!(plt, args...; kw..., subplot = findfirst(plt.subplots, sp))
 end
 
 # --------------------------------------------------------------------

src/precompile.jl

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

src/series.jl

@@ -0,0 +1,493 @@
+
+
+# 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 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::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(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!")
+
+# --------------------------------------------------------------------
+
+
+# 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
+# # --------------------------------------------------------------------
+
+@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)
+        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)
+        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
+    shape_coords(shape)
+end
+
+@recipe function f(shapes::AVec{Shape})
+    seriestype --> :shape
+    shape_coords(shapes)
+end
+
+@recipe function f(shapes::AMat{Shape})
+    seriestype --> :shape
+    for j in 1:size(shapes,2)
+        @series shape_coords(vec(shapes[:,j]))
+    end
+end
+
+
+
+# function without range... use the current range of the x-axis
+
+@recipe function f(f::FuncOrFuncs)
+    plt = d[:plot_object]
+    xmin,xmax = axis_limits(plt[1][:xaxis])
+    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::FuncOrFuncs, x)
+    @assert !(typeof(x) <: FuncOrFuncs)  # otherwise we'd hit infinite recursion here
+    x, f
+end
+
+#
+# # --------------------------------------------------------------------
+# # 3 arguments
+# # --------------------------------------------------------------------
+#
+#
+# # 3d line or scatter
+
+@recipe function f(x::AVec, y::AVec, z::AVec)
+    # st = get(d, :seriestype, :none)
+    # if st == :scatter
+    #     d[:seriestype] = :scatter3d
+    # elseif !is3d(st)
+    #     d[:seriestype] = :path3d
+    # end
+    SliceIt, x, y, z
+end
+
+@recipe function f(x::AMat, y::AMat, z::AMat)
+    # st = get(d, :seriestype, :none)
+    # if size(x) == size(y) == size(z)
+    #     if !is3d(st)
+    #         seriestype := :path3d
+    #     end
+    # end
+    SliceIt, x, y, z
+end
+
+#
+# # surface-like... function
+
+@recipe function f(x::AVec, y::AVec, zf::Function)
+    # x = X <: Number ? sort(x) : x
+    # y = Y <: Number ? sort(y) : y
+    SliceIt, x, y, Surface(zf, x, y)  # TODO: replace with SurfaceFunction when supported
+end
+
+#
+# # surface-like... matrix grid
+
+@recipe function f(x::AVec, y::AVec, z::AMat)
+    if !like_surface(get(d, :seriestype, :none))
+        d[:seriestype] = :contour
+    end
+    SliceIt, x, y, Surface(z)
+end
+
+#
+#
+# # --------------------------------------------------------------------
+# # Parametric functions
+# # --------------------------------------------------------------------
+
+#
+# # special handling... xmin/xmax with parametric function(s)
+@recipe f(f::FuncOrFuncs, xmin::Number, xmax::Number) = linspace(xmin, xmax, 100), f
+@recipe f(fx::FuncOrFuncs, fy::FuncOrFuncs, u::AVec)  = mapFuncOrFuncs(fx, u), mapFuncOrFuncs(fy, u)
+@recipe f(fx::FuncOrFuncs, fy::FuncOrFuncs, umin::Number, umax::Number, n = 200) = fx, fy, linspace(umin, umax, n)
+
+#
+# # special handling... 3D parametric function(s)
+@recipe function f(fx::FuncOrFuncs, fy::FuncOrFuncs, fz::FuncOrFuncs, u::AVec)
+    mapFuncOrFuncs(fx, u), mapFuncOrFuncs(fy, u), mapFuncOrFuncs(fz, u)
+end
+@recipe function f(fx::FuncOrFuncs, fy::FuncOrFuncs, fz::FuncOrFuncs, umin::Number, umax::Number, numPoints = 200)
+    fx, fy, fz, linspace(umin, umax, numPoints)
+end
+
+#
+#
+# # --------------------------------------------------------------------
+# # Lists of tuples and FixedSizeArrays
+# # --------------------------------------------------------------------
+#
+# # if we get an unhandled tuple, just splat it in
+@recipe f(tup::Tuple) = tup
+
+#
+# # (x,y) tuples
+@recipe f{R1<:Number,R2<:Number}(xy::AVec{Tuple{R1,R2}}) = unzip(xy)
+@recipe f{R1<:Number,R2<:Number}(xy::Tuple{R1,R2})       = [xy[1]], [xy[2]]
+
+#
+# # (x,y,z) tuples
+@recipe f{R1<:Number,R2<:Number,R3<:Number}(xyz::AVec{Tuple{R1,R2,R3}}) = unzip(xyz)
+@recipe f{R1<:Number,R2<:Number,R3<:Number}(xyz::Tuple{R1,R2,R3})       = [xyz[1]], [xyz[2]], [xyz[3]]
+
+# these might be points+velocity, or OHLC or something else
+@recipe f{R1<:Number,R2<:Number,R3<:Number,R4<:Number}(xyuv::AVec{Tuple{R1,R2,R3,R4}}) = get(d,:seriestype,:path)==:ohlc ? OHLC[OHLC(t...) for t in xyuv] : unzip(xyuv)
+@recipe f{R1<:Number,R2<:Number,R3<:Number,R4<:Number}(xyuv::Tuple{R1,R2,R3,R4})       = [xyuv[1]], [xyuv[2]], [xyuv[3]], [xyuv[4]]
+
+
+#
+# # 2D FixedSizeArrays
+@recipe f{T<:Number}(xy::AVec{FixedSizeArrays.Vec{2,T}}) = unzip(xy)
+@recipe f{T<:Number}(xy::FixedSizeArrays.Vec{2,T})       = [xy[1]], [xy[2]]
+
+#
+# # 3D FixedSizeArrays
+@recipe f{T<:Number}(xyz::AVec{FixedSizeArrays.Vec{3,T}}) = unzip(xyz)
+@recipe f{T<:Number}(xyz::FixedSizeArrays.Vec{3,T})       = [xyz[1]], [xyz[2]], [xyz[3]]
+
+#
+# # --------------------------------------------------------------------
+# # handle grouping
+# # --------------------------------------------------------------------
+
+# @recipe function f(groupby::GroupBy, args...)
+#     for (i,glab) in enumerate(groupby.groupLabels)
+#         # create a new series, with the label of the group, and an idxfilter (to be applied in slice_and_dice)
+#         # TODO: use @series instead
+#         @show i, glab, groupby.groupIds[i]
+#         di = copy(d)
+#         get!(di, :label, string(glab))
+#         get!(di, :idxfilter, groupby.groupIds[i])
+#         push!(series_list, RecipeData(di, args))
+#     end
+#     nothing
+# end
+
+# split the group into 1 series per group, and set the label and idxfilter for each
+@recipe function f(groupby::GroupBy, args...)
+    for (i,glab) in enumerate(groupby.groupLabels)
+        @series begin
+            label     --> string(glab)
+            idxfilter --> groupby.groupIds[i]
+            args
+        end
+    end
+end

src/series_args.jl

@@ -1,467 +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(lt -> lt in (:contour, :heatmap, :surface, :wireframe, :contour3d), get(d, :linetype, :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
-
-
-# --------------------------------------------------------------------
-
-# 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)
-
-@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)
-    x, y, 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, getplotargs(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)])
-        lt = d[:linetype]
-
-        # for linetype `line`, need to sort by x values
-        if lt == :line
-            # order by x
-            indices = sortperm(d[:x])
-            d[:x] = d[:x][indices]
-            d[:y] = d[:y][indices]
-            d[:linetype] = :path
-        end
-
-        # special handling for missing x in box plot... all the same category
-        if lt == :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
-        if lt == :quiver
-            d[:linetype] = lt = :path
-            d[:linewidth] = 0
-        end
-        if get(d, :quiver, nothing) != nothing
-            append!(ret, apply_series_recipe(copy(d), Val{:quiver}))
-        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 linetype
-        kwlist = apply_series_recipe(d, Val{lt})
-        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
-
-
-# plotting arbitrary shapes/polygons
-function process_inputs(plt::AbstractPlot, d::KW, shape::Shape)
-    d[:x], d[:y] = shape_coords(shape)
-    d[:linetype] = :shape
-end
-function process_inputs(plt::AbstractPlot, d::KW, shapes::AVec{Shape})
-    d[:x], d[:y] = shape_coords(shapes)
-    d[:linetype] = :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[:linetype] = :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 linetype
-    lt = get(d, :linetype, :none)
-    if lt == :scatter
-        d[:linetype] = :scatter3d
-    elseif !(lt in _3dTypes)
-        d[:linetype] = :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, :linetype, :none))
-        d[:linetype] = :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, :linetype, :none))
-        d[:linetype] = :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.plotargs, :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
-
-        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/subplot.jl

@@ -1,331 +0,0 @@
-
-# ------------------------------------------------------------
-
-Base.string(subplt::Subplot) = "Subplot{$(subplt.backend) p=$(subplt.p) n=$(subplt.n)}"
-Base.print(io::IO, subplt::Subplot) = print(io, string(subplt))
-Base.show(io::IO, subplt::Subplot) = print(io, string(subplt))
-
-function Base.copy(subplt::Subplot)
-  subplot(subplt.plts, subplt.layout, subplt.plotargs)
-end
-
-Base.getindex(subplt::Subplot, args...) = subplt.plts[subplt.layout[args...]]
-
-# --------------------------------------------------------------------
-
-getplot(subplt::Subplot, idx::Int = subplt.n) = subplt.plts[mod1(idx, subplt.p)]
-getplotargs(subplt::Subplot, idx::Int) = getplot(subplt, idx).plotargs
-convertSeriesIndex(subplt::Subplot, n::Int) = ceil(Int, n / subplt.p)
-
-# ------------------------------------------------------------
-
-function validateSubplotSupported()
-  if !subplotSupported()
-    error(CURRENT_BACKEND.sym, " does not support the subplot/subplot! commands at this time.  Try one of: ", join(filter(pkg->subplotSupported(_backend_instance(pkg)), backends()),", "))
-  end
-end
-
-"""
-Create a series of plots:
-```
-  y = rand(100,3)
-  subplot(y; n = 3)             # create an automatic grid, and let it figure out the nr/nc... will put plots 1 and 2 on the first row, and plot 3 by itself on the 2nd row
-  subplot(y; n = 3, nr = 1)     # create an automatic grid, but fix the number of rows to 1 (so there are n columns)
-  subplot(y; n = 3, nc = 1)     # create an automatic grid, but fix the number of columns to 1 (so there are n rows)
-  subplot(y; layout = [1, 2])   # explicit layout by row... plot #1 goes by itself in the first row, plots 2 and 3 split the 2nd row (note the n kw is unnecessary)
-  subplot(plts, n; nr = -1, nc = -1)  # build a layout from existing plots
-  subplot(plts, layout)               # build a layout from existing plots
-```
-"""
-function subplot(args...; kw...)
-  validateSubplotSupported()
-  d = KW(kw)
-  preprocessArgs!(d)
-
-  # for plotting recipes, swap out the args and update the parameter dictionary
-  args = _apply_recipe(d, args...; kw..., issubplot=true)
-
-  # figure out the layout
-  layoutarg = get(d, :layout, nothing)
-  if layoutarg != nothing
-    layout = subplotlayout(layoutarg)
-  else
-    n = get(d, :n, -1)
-    if n < 0
-      error("You must specify either layout or n when creating a subplot: ", d)
-    end
-    layout = subplotlayout(n, get(d, :nr, -1), get(d, :nc, -1))
-  end
-
-  # initialize the individual plots
-  pkg = backend()
-  plts = Plot{typeof(pkg)}[]
-  for i in 1:length(layout)
-    di = getPlotArgs(pkg, d, i)
-    di[:subplot] = true
-    dumpdict(di, "Plot args (subplot $i)")
-    push!(plts, _create_plot(pkg, di))
-  end
-
-  # create the object and do the plotting
-  subplt = Subplot(nothing, plts, pkg, length(layout), 0, layout, d, false, false, false, (r,c) -> (nothing,nothing))
-  subplot!(subplt, args...; d...)
-
-  subplt
-end
-
-# ------------------------------------------------------------------------------------------------
-
-# NOTE: for the subplot calls building from existing plots, we need the first plot to be separate to ensure dispatch calls this instead of the more general subplot(args...; kw...)
-
-# grid layout
-function subplot{P}(plt1::Plot{P}, plts::Plot{P}...; kw...)
-  d = KW(kw)
-  layout = if haskey(d, :layout)
-      subplotlayout(d[:layout])
-  else
-      subplotlayout(length(plts)+1, get(d, :nr, -1), get(d, :nc, -1))
-  end
-  # layout = subplotlayout(length(plts)+1, get(d, :nr, -1), get(d, :nc, -1))
-  subplot(vcat(plt1, plts...), layout, d)
-end
-
-# explicit layout
-function subplot{P,I<:Integer}(pltsPerRow::AVec{I}, plt1::Plot{P}, plts::Plot{P}...; kw...)
-  layout = subplotlayout(pltsPerRow)
-  subplot(vcat(plt1, plts...), layout, KW(kw))
-end
-
-# this will be called internally
-function subplot{P<:AbstractBackend}(plts::AVec{Plot{P}}, layout::SubplotLayout, d::KW)
-  validateSubplotSupported()
-  p = length(layout)
-  n = sum([plt.n for plt in plts])
-  subplt = Subplot(nothing, collect(plts), P(), p, n, layout, KW(), false, false, false, (r,c) -> (nothing,nothing))
-
-  _preprocess_subplot(subplt, d)
-  _postprocess_subplot(subplt, d)
-
-  subplt
-end
-
-# TODO: hcat/vcat subplots and plots together arbitrarily
-
-# ------------------------------------------------------------------------------------------------
-
-
-function _preprocess_subplot(subplt::Subplot, d::KW, args = ())
-  validateSubplotSupported()
-  preprocessArgs!(d)
-
-  # for plotting recipes, swap out the args and update the parameter dictionary
-  args = _apply_recipe(d, args...; d..., issubplot=true)
-
-  dumpdict(d, "After subplot! preprocessing")
-
-  # get the full plotargs, overriding any new settings
-  # TODO: subplt.plotargs should probably be merged sooner and actually used
-  #       for color selection, etc.  (i.e. if we overwrite the subplot palettes to [:heat :rainbow])
-  #       then we need to overwrite plt[1].plotargs[:color_palette] to :heat before it's actually used
-  #       for color selection!
-
-  # first merge the new args into the subplot's plotargs. then process the plot args and merge
-  # those into the plot's plotargs.  (example... `palette = [:blues :reds]` goes into subplt.plotargs,
-  # then the ColorGradient for :blues/:reds is merged into plot 1/2 plotargs, which is then used for color selection)
-  for i in 1:length(subplt.layout)
-    subplt.plts[i].plotargs = getPlotArgs(backend(), merge(subplt.plts[i].plotargs, d), i)
-  end
-  merge!(subplt.plotargs, d)
-
-  # process links.  TODO: extract to separate function
-  for s in (:linkx, :linky, :linkfunc)
-    if haskey(d, s)
-      setfield!(subplt, s, d[s])
-      delete!(d, s)
-    end
-  end
-
-  args
-end
-
-function _postprocess_subplot(subplt::Subplot, d::KW)
-  # init (after plot creation)
-  if !subplt.initialized
-    subplt.initialized = _create_subplot(subplt, false)
-  end
-
-  # add title, axis labels, ticks, etc
-  for (i,plt) in enumerate(subplt.plts)
-    di = plt.plotargs
-    dumpdict(di, "Updating sp $i")
-    _update_plot(plt, di)
-  end
-
-  _update_plot_pos_size(subplt, d)
-
-  # handle links
-  subplt.linkx && link_axis(subplt, true)
-  subplt.linky && link_axis(subplt, false)
-
-  # set this to be current
-  current(subplt)
-end
-
-# ------------------------------------------------------------------------------------------------
-
-"""
-Adds to a subplot.
-"""
-
-# current subplot
-function subplot!(args...; kw...)
-  validateSubplotSupported()
-  subplot!(current(), args...; kw...)
-end
-
-
-# not allowed:
-function subplot!(plt::Plot, args...; kw...)
-  error("Can't call subplot! on a Plot!")
-end
-
-
-# # this adds to a specific subplot... most plot commands will flow through here
-function subplot!(subplt::Subplot, args...; kw...)
-  # validateSubplotSupported()
-
-  d = KW(kw)
-  args = _preprocess_subplot(subplt, d, args)
-
-  # create the underlying object (each backend will do this differently)
-  # note: we call it once before doing the individual plots, and once after
-  #       this is because some backends need to set up the subplots and then plot,
-  #       and others need to do it the other way around
-  if !subplt.initialized
-    subplt.initialized = _create_subplot(subplt, true)
-  end
-
-  groupby = if haskey(d, :group)
-      extractGroupArgs(d[:group], args...)
-  else
-      nothing
-  end
-
-  _add_series_subplot(subplt, d, groupby, args...)
-  _postprocess_subplot(subplt, d)
-
-  # show it automatically?
-  if haskey(d, :show) && d[:show]
-    gui()
-  end
-
-  subplt
-end
-
-
-# not allowed:
-function plot!(subplt::Subplot, args...; kw...)
-  error("Can't call plot! on a Subplot!")
-end
-
-# given a fully processed KW, add the series to the Plot
-function _add_series_subplot(plt::Plot, d::KW)
-  setTicksFromStringVector(d, d, :x, :xticks)
-  setTicksFromStringVector(d, d, :y, :yticks)
-
-  # this is the actual call to the backend
-  _add_series(plt.backend, plt, d)
-
-  _add_annotations(plt, d)
-  warnOnUnsupportedScales(plt.backend, d)
-end
-
-
-# handle the grouping... add a series for each group
-function _add_series_subplot(subplt::Subplot, d::KW, groupby::GroupBy, args...)
-    starting_n = subplt.n
-    for (i, glab) in enumerate(groupby.groupLabels)
-        tmpd = copy(d)
-        tmpd[:numUncounted] = subplt.n - starting_n
-        _add_series_subplot(subplt, tmpd, nothing, args...;
-                    idxfilter = groupby.groupIds[i],
-                    grouplabel = string(glab))
-    end
-end
-
-# process, filter, and add to the correct plot
-function _add_series_subplot(subplt::Subplot, d::KW, ::Void, args...;
-                             idxfilter = nothing,
-                             grouplabel = "")
-    process_inputs(subplt, d, args...)
-
-    if idxfilter != nothing
-        # add the group name as the label if there isn't one passed in
-        get!(d, :label, grouplabel)
-        # filter the data
-        filter_data!(d, idxfilter)
-    end
-
-    kwList, xmeta, ymeta = build_series_args(subplt, d)
-
-    # TODO: something useful with meta info?
-
-    for (i,di) in enumerate(kwList)
-
-      subplt.n += 1
-      plt = getplot(subplt)
-      plt.n += 1
-
-      # cleanup the dictionary that we pass into the plot! command
-      di[:show] = false
-      di[:subplot] = true
-      for k in (:title, :xlabel, :xticks, :xlims, :xscale, :xflip,
-                        :ylabel, :yticks, :ylims, :yscale, :yflip)
-        delete!(di, k)
-      end
-      dumpdict(di, "subplot! kwList $i")
-      dumpdict(plt.plotargs, "plt.plotargs before plotting")
-
-      _add_series_subplot(plt, di)
-    end
-end
-
-# --------------------------------------------------------------------
-
-# handle "linking" the subplot axes together
-# each backend should implement the _remove_axis and _expand_limits methods
-function link_axis(subplt::Subplot, isx::Bool)
-
-  # collect the list of plots and the expanded limits for those plots that should be linked on this axis
-  includedPlots = Any[]
-  # lims = [Inf, -Inf]
-  lims = Dict{Int,Any}()  # maps column to xlim
-  for (i,(r,c)) in enumerate(subplt.layout)
-
-    # shouldlink will be a bool or nothing.  if nothing, then use linkx/y (which is true if we get to this code)
-    shouldlink = subplt.linkfunc(r,c)[isx ? 1 : 2]
-    if shouldlink == nothing || shouldlink
-      plt = subplt.plts[i]
-
-      # if we don't have this
-      k = isx ? c : r
-      if (firstone = !haskey(lims, k))
-        lims[k] = [Inf, -Inf]
-      end
-
-      isinner = (isx && r < nrows(subplt.layout)) || (!isx && !firstone)
-      push!(includedPlots, (plt, isinner, k))
-
-      _expand_limits(lims[k], plt, isx)
-    end
-
-  end
-
-  # do the axis adjustments
-  for (plt, isinner, k) in includedPlots
-    if isinner
-      _remove_axis(plt, isx)
-    end
-    (isx ? xlims! : ylims!)(plt, lims[k]...)
-  end
-end

src/subplots.jl

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

src/themes.jl

@@ -0,0 +1,40 @@
+
+function theme(s::Symbol; kw...)
+    # reset?
+    if s == :none || s == :default
+        PlotUtils._default_gradient[] = :inferno
+        default(;
+            bg        = :white,
+            bglegend  = :match,
+            bginside  = :match,
+            bgoutside = :match,
+            fg        = :auto,
+            fglegend  = :match,
+            fggrid    = :match,
+            fgaxis    = :match,
+            fgtext    = :match,
+            fgborder  = :match,
+            fgguide   = :match,
+            palette   = :auto
+        )
+        return
+    end
+
+    # update the default gradient and other defaults
+    thm = PlotThemes._themes[s]
+    if thm.gradient != nothing
+        PlotUtils._default_gradient[] = PlotThemes.gradient_name(s)
+    end
+    default(;
+        bg       = thm.bg_secondary,
+        bginside = thm.bg_primary,
+        fg       = thm.lines,
+        fgtext   = thm.text,
+        fgguide  = thm.text,
+        fglegend = thm.text,
+        palette  = thm.palette,
+        kw...
+    )
+end
+
+@deprecate set_theme(s) theme(s)

src/types.jl

@@ -1,55 +1,99 @@
 
+# TODO: I declare lots of types here because of the lacking ability to do forward declarations in current Julia
+# I should move these to the relevant files when something like "extern" is implemented
+
 typealias AVec AbstractVector
 typealias AMat AbstractMatrix
+typealias KW Dict{Symbol,Any}
 
 immutable PlotsDisplay <: Display end
 
 abstract AbstractBackend
 abstract AbstractPlot{T<:AbstractBackend}
+abstract AbstractLayout
 
-typealias KW Dict{Symbol,Any}
+# -----------------------------------------------------------
 
 immutable InputWrapper{T}
     obj::T
 end
-
 wrap{T}(obj::T) = InputWrapper{T}(obj)
 Base.isempty(wrapper::InputWrapper) = false
 
-# -----------------------------------------------------------
-# Plot
+
 # -----------------------------------------------------------
 
-type Plot{T<:AbstractBackend} <: AbstractPlot{T}
-    o                        # the backend's plot object
-    backend::T               # the backend type
-    n::Int                   # number of series
-    plotargs::KW             # arguments for the whole plot
-    seriesargs::Vector{KW}   # arguments for each series
+type Series
+    d::KW
 end
 
-# -----------------------------------------------------------
-# Layout
-# -----------------------------------------------------------
-
-abstract SubplotLayout
+attr(series::Series, k::Symbol) = series.d[k]
+attr!(series::Series, v, k::Symbol) = (series.d[k] = v)
 
 # -----------------------------------------------------------
-# Subplot
+
+# 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
+    attr::KW  # args specific to this subplot
+    o  # can store backend-specific data... like a pyplot ax
+    plt  # the enclosing Plot object (can't give it a type because of no forward declarations)
+end
+
+Base.show(io::IO, sp::Subplot) = print(io, "Subplot{$(sp[:subplot_index])}")
+
 # -----------------------------------------------------------
 
-type Subplot{T<:AbstractBackend, L<:SubplotLayout} <: AbstractPlot{T}
-    o                           # the underlying object
-    plts::Vector{Plot{T}}       # the individual plots
-    backend::T
-    p::Int                      # number of plots
-    n::Int                      # number of series
-    layout::L
-    plotargs::KW
-    initialized::Bool
-    linkx::Bool
-    linky::Bool
-    linkfunc::Function # maps (row,column) -> (BoolOrNothing, BoolOrNothing)... if xlink/ylink are nothing, then use subplt.linkx/y
+# simple wrapper around a KW so we can hold all attributes pertaining to the axis in one place
+type Axis
+    sps::Vector{Subplot}
+    d::KW
+end
+
+type Extrema
+    emin::Float64
+    emax::Float64
+end
+Extrema() = Extrema(Inf, -Inf)
+
+# -----------------------------------------------------------
+
+typealias SubplotMap Dict{Any, Subplot}
+
+# -----------------------------------------------------------
+
+
+type Plot{T<:AbstractBackend} <: AbstractPlot{T}
+    backend::T                   # the backend type
+    n::Int                       # number of series
+    attr::KW                     # arguments for the whole plot
+    user_attr::KW                # raw arg inputs (after aliases).  these are used as the input dict in `_plot!`
+    series_list::Vector{Series}  # arguments for each series
+    o                            # the backend's plot object
+    subplots::Vector{Subplot}
+    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(),
+         Subplot[], false)
 end
 
 # -----------------------------------------------------------------------
+
+Base.getindex(plt::Plot, i::Integer) = plt.subplots[i]
+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(sp::Subplot, i::Integer) = series_list(sp)[i]
+
+# -----------------------------------------------------------------------

src/utils.jl

@@ -25,7 +25,7 @@ function histogramHack(; kw...)
   edges, midpoints, buckets, counts = binData(d[:y], d[:bins])
   d[:x] = midpoints
   d[:y] = float(counts)
-  d[:linetype] = :bar
+  d[:seriestype] = :bar
   d[:fillrange] = d[:fillrange] == nothing ? 0.0 : d[:fillrange]
   d
 end
@@ -64,7 +64,7 @@ function barHack(; kw...)
 
   d[:x] = x
   d[:y] = y
-  d[:linetype] = :path
+  d[:seriestype] = :path
   d[:fillrange] = fillrange
   d
 end
@@ -94,12 +94,12 @@ function sticksHack(; kw...)
   # change the line args
   dLine[:x] = x
   dLine[:y] = y
-  dLine[:linetype] = :path
+  dLine[:seriestype] = :path
   dLine[:markershape] = :none
   dLine[:fillrange] = nothing
 
   # change the scatter args
-  dScatter[:linetype] = :none
+  dScatter[:seriestype] = :none
 
   dLine, dScatter
 end
@@ -114,34 +114,163 @@ function regressionXY(x, y)
   regx, regy
 end
 
+function replace_image_with_heatmap{T<:Colorant}(z::Array{T})
+    @show T, size(z)
+    n, m = size(z)
+    # idx = 0
+    colors = ColorGradient(vec(z))
+    newz = reshape(linspace(0, 1, n*m), n, m)
+    newz, colors
+    # newz = zeros(n, m)
+    # for i=1:n, j=1:m
+    #     push!(colors, T(z[i,j]...))
+    #     newz[i,j] = idx / (n*m-1)
+    #     idx += 1
+    # end
+    # newz, ColorGradient(colors)
+end
+
+function imageHack(d::KW)
+    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
+
 # ------------------------------------------------------------------------------------
 
 
 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
+Base.cycle(wrapper::InputWrapper, idx::Int) = wrapper.obj
+Base.cycle(wrapper::InputWrapper, idx::AVec{Int}) = wrapper.obj
+
+Base.cycle(v::AVec, idx::Int) = v[mod1(idx, length(v))]
+Base.cycle(v::AMat, idx::Int) = size(v,1) == 1 ? v[1, mod1(idx, size(v,2))] : v[:, mod1(idx, size(v,2))]
+Base.cycle(v, idx::Int)       = v
+
+Base.cycle(v::AVec, indices::AVec{Int}) = map(i -> cycle(v,i), indices)
+Base.cycle(v::AMat, indices::AVec{Int}) = map(i -> cycle(v,i), indices)
+Base.cycle(v, indices::AVec{Int})       = fill(v, length(indices))
+
+Base.cycle(grad::ColorGradient, idx::Int) = cycle(grad.colors, idx)
+Base.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]
 
-unzip{T,S}(xy::AVec{Tuple{T,S}})              = [x[1] for x in xy], [y[2] for y in xy]
-unzip{T,S,R}(xyz::AVec{Tuple{T,S,R}})         = [x[1] for x in xyz], [y[2] for y in xyz], [z[3] for z in xyz]
-unzip{T}(xy::AVec{FixedSizeArrays.Vec{2,T}})  = T[x[1] for x in xy], T[y[2] for y in xy]
+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]
+unzip{X,Y,U,V}(xyuv::AVec{Tuple{X,Y,U,V}})    = [t[1] for t in xyuv], [t[2] for t in xyuv], [t[3] for t in xyuv], [t[4] for t in xyuv]
+
+unzip{T}(xy::AVec{FixedSizeArrays.Vec{2,T}})  = T[t[1] for t in xy], T[t[2] for t in xy]
 unzip{T}(xy::FixedSizeArrays.Vec{2,T})        = T[xy[1]], T[xy[2]]
-unzip{T}(xyz::AVec{FixedSizeArrays.Vec{3,T}}) = T[x[1] for x in xyz], T[y[2] for y in xyz], T[z[3] for z in xyz]
+
+unzip{T}(xyz::AVec{FixedSizeArrays.Vec{3,T}}) = T[t[1] for t in xyz], T[t[2] for t in xyz], T[t[3] for t in xyz]
 unzip{T}(xyz::FixedSizeArrays.Vec{3,T})       = T[xyz[1]], T[xyz[2]], T[xyz[3]]
 
+unzip{T}(xyuv::AVec{FixedSizeArrays.Vec{4,T}}) = T[t[1] for t in xyuv], T[t[2] for t in xyuv], T[t[3] for t in xyuv], T[t[4] for t in xyuv]
+unzip{T}(xyuv::FixedSizeArrays.Vec{4,T})       = T[xyuv[1]], T[xyuv[2]], T[xyuv[3]], T[xyuv[4]]
+
 # given 2-element lims and a vector of data x, widen lims to account for the extrema of x
 function _expand_limits(lims, x)
   try
@@ -154,6 +283,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...)
@@ -172,13 +302,16 @@ function replaceType(vec, val)
   push!(vec, val)
 end
 
-function replaceAliases!(d::KW, 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::Dict{Symbol,Symbol})
   ks = collect(keys(d))
   for k in ks
-    if haskey(aliases, k)
-      d[aliases[k]] = d[k]
-      delete!(d, k)
-    end
+      replaceAlias!(d, k, aliases)
   end
 end
 
@@ -198,10 +331,31 @@ 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)
-    y[r,:] = 0.95 * y[r-1,:] + randn(size(y,2))'
+    y[r,:] = 0.95 * vec(y[r-1,:]) + randn(size(y,2))
   end
   y
 end
@@ -209,6 +363,14 @@ end
 isijulia() = isdefined(Main, :IJulia) && Main.IJulia.inited
 isatom() = isdefined(Main, :Atom) && Main.Atom.isconnected()
 
+function is_installed(pkgstr::AbstractString)
+    try
+        Pkg.installed(pkgstr) === nothing ? false: true
+    catch
+        false
+    end
+end
+
 istuple(::Tuple) = true
 istuple(::Any)   = false
 isvector(::AVec) = true
@@ -218,22 +380,24 @@ 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
 
-axis_symbol(letter, postfix) = symbol(letter * postfix)
-axis_symbols(letter, postfix...) = map(s -> axis_symbol(letter, s), postfix)
+# axis_Symbol(letter, postfix) = Symbol(letter * postfix)
+# axis_symbols(letter, postfix...) = map(s -> axis_Symbol(letter, s), postfix)
 
 Base.convert{T<:Real}(::Type{Vector{T}}, rng::Range{T})         = T[x for x in rng]
 Base.convert{T<:Real,S<:Real}(::Type{Vector{T}}, rng::Range{S}) = T[x for x in rng]
@@ -243,6 +407,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)
@@ -252,9 +440,57 @@ function indices_and_unique_values(z::AbstractArray)
     newz, vals
 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, z, transpose_on_match::Bool = true)
+    if d[:match_dimensions] == transpose_on_match
+        # z'
+        permutedims(z, [2,1])
+    else
+        z
+    end
+end
+
+function ok(x::Number, y::Number, z::Number = 0)
+    isfinite(x) && isfinite(y) && isfinite(z)
+end
+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)))
+        frs[i] = yi + ri
+    end
+    frs
+end
+
+# turn a ribbon into a fillrange
+function make_fillrange_from_ribbon(kw::KW)
+    y, rib = kw[:y], kw[:ribbon]
+    rib = wraptuple(rib)
+    rib1, rib2 = -first(rib), last(rib)
+    kw[:ribbon] = nothing
+    kw[: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
+wraptuple(x::Tuple) = x
 wraptuple(x) = (x,)
 
 trueOrAllTrue(f::Function, x::AbstractArray) = all(f, x)
@@ -262,7 +498,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)
@@ -276,7 +512,7 @@ allFunctions(arg)   = trueOrAllTrue(a -> isa(a, Function), arg)
 """
 Allows temporary setting of backend and defaults for Plots. Settings apply only for the `do` block.  Example:
 ```
-with(:gadfly, size=(400,400), type=:hist) do
+with(:gadfly, size=(400,400), type=:histogram) do
   plot(rand(10))
   plot(rand(10))
 end
@@ -315,7 +551,7 @@ function with(f::Function, args...; kw...)
     # #       as in:  with(:gadfly, :scatter, :legend, :grid) do; ...; end
     # # TODO: can we generalize this enough to also do something similar in the plot commands??
 
-    # k = :linetype
+    # k = :seriestype
     # if arg in _allTypes
     #   olddefs[k] = default(k)
     #   newdefs[k] = arg
@@ -386,6 +622,7 @@ function dumpdict(d::KW, prefix = "", alwaysshow = false)
   end
   println()
 end
+DD(d::KW, prefix = "") = dumpdict(d, prefix, true)
 
 
 function dumpcallstack()
@@ -411,30 +648,98 @@ tovec(v::AbstractVector) = v
 tovec(v::Void) = zeros(0)
 
 function getxy(plt::Plot, i::Integer)
-    d = plt.seriesargs[i]
+    d = plt.series_list[i].d
     tovec(d[:x]), tovec(d[:y])
 end
 function getxyz(plt::Plot, i::Integer)
-    d = plt.seriesargs[i]
+    d = plt.series_list[i].d
     tovec(d[:x]), tovec(d[:y]), tovec(d[:z])
 end
 
 function setxy!{X,Y}(plt::Plot, xy::Tuple{X,Y}, i::Integer)
-    d = plt.seriesargs[i]
-    d[:x], d[:y] = xy
+    series = plt.series_list[i]
+    series.d[:x], series.d[:y] = xy
+    sp = series.d[:subplot]
+    reset_extrema!(sp)
+    _series_updated(plt, series)
 end
 function setxyz!{X,Y,Z}(plt::Plot, xyz::Tuple{X,Y,Z}, i::Integer)
-    d = plt.seriesargs[i]
-    d[:x], d[:y], d[:z] = xyz
+    series = plt.series_list[i]
+    series.d[:x], series.d[:y], series.d[:z] = xyz
+    sp = series.d[:subplot]
+    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 update!(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 update")
+        end
+    end
+    _series_updated(series[:subplot].plt, series)
+    series
+end
+
+function update!(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 update")
+        end
+    end
+    sp
+end
 
 # -------------------------------------------------------
 # push/append for one series
@@ -535,44 +840,6 @@ end
 
 
 
-# ---------------------------------------------------------------
-# ---------------------------------------------------------------
-# graphs detailing the features that each backend supports
-
-function supportGraph(allvals, func)
-    vals = reverse(sort(allvals))
-    bs = sort(backends())
-    x = ASCIIString[]
-    y = ASCIIString[]
-    for val in vals
-        for b in bs
-            supported = func(Plots._backend_instance(b))
-            if val in supported
-                push!(x, string(b))
-                push!(y, string(val))
-            end
-        end
-    end
-    n = length(vals)
-    scatter(x, y, m=:rect, ms=10, size=(300,100+18*n), leg=false)
-end
-
-supportGraphArgs()    = supportGraph(_allArgs, supportedArgs)
-supportGraphTypes()   = supportGraph(_allTypes, supportedTypes)
-supportGraphStyles()  = supportGraph(_allStyles, supportedStyles)
-supportGraphMarkers() = supportGraph(_allMarkers, supportedMarkers)
-supportGraphScales()  = supportGraph(_allScales, supportedScales)
-supportGraphAxes()    = supportGraph(_allAxes, supportedAxes)
-
-function dumpSupportGraphs()
-    for func in (supportGraphArgs, supportGraphTypes, supportGraphStyles,
-               supportGraphMarkers, supportGraphScales, supportGraphAxes)
-        plt = func()
-        png(joinpath(Pkg.dir("ExamplePlots"), "docs", "examples", "img", "supported", "$(string(func))"))
-    end
-end
-
-# ---------------------------------------------------------------
 # ---------------------------------------------------------------
 
 
@@ -593,9 +860,9 @@ mm2px(mm::Real)         = float(px / MM_PER_PX)
 
 
 "Smallest x in plot"
-xmin(plt::Plot) = minimum([minimum(d[:x]) for d in plt.seriesargs])
+xmin(plt::Plot) = minimum([minimum(series.d[:x]) for series in plt.series_list])
 "Largest x in plot"
-xmax(plt::Plot) = maximum([maximum(d[:x]) for d in plt.seriesargs])
+xmax(plt::Plot) = maximum([maximum(series.d[:x]) for series in plt.series_list])
 
 "Extrema of x-values in plot"
 Base.extrema(plt::Plot) = (xmin(plt), xmax(plt))

test/REQUIRE

@@ -1,16 +1,10 @@
-julia 0.4
-
-Colors
-Reexport
-Requires
+StatPlots
 FactCheck
-Cairo
-Gadfly
 Images
-PyPlot
+ImageMagick
 @osx QuartzImageIO
 GR
-DataFrames
 RDatasets
 VisualRegressionTests
 UnicodePlots
+Glob

test/imgcomp.jl

@@ -1,6 +1,6 @@
 
 using VisualRegressionTests
-using ExamplePlots
+# using ExamplePlots
 
 import DataFrames, RDatasets
 
@@ -13,7 +13,10 @@ try
 end
 
 
-using Plots, FactCheck
+using Plots
+using StatPlots
+using FactCheck
+using Glob
 
 default(size=(500,300))
 
@@ -21,37 +24,70 @@ 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.9.6"
+
+
 function image_comparison_tests(pkg::Symbol, idx::Int; debug = false, popup = isinteractive(), sigma = [1,1], eps = 1e-2)
+    Plots._debugMode.on = debug
+    example = Plots._examples[idx]
+    info("Testing plot: $pkg:$idx:$(example.header)")
+    backend(pkg)
+    backend()
 
-  # first
-  Plots._debugMode.on = debug
-  example = ExamplePlots._examples[idx]
-  info("Testing plot: $pkg:$idx:$(example.header)")
-  backend(pkg)
-  backend()
+    # ensure consistent results
+    srand(1234)
 
-  # ensure consistent results
-  srand(1234)
+    # reference image directory setup
+    # refdir = joinpath(Pkg.dir("ExamplePlots"), "test", "refimg", string(pkg))
+    refdir = Pkg.dir("PlotReferenceImages", "Plots", string(pkg))
+    fn = "ref$idx.png"
 
-  # reference image directory setup
-  refdir = joinpath(Pkg.dir("ExamplePlots"), "test", "refimg", string(pkg))
+    # firgure out version info
+    G = glob(joinpath(relpath(refdir), "*"))
+    # @show refdir fn 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
 
-  # test function
-  func = (fn, idx) -> begin
-    map(eval, example.exprs)
-    png(fn)
-  end
+    newdir = joinpath(refdir, string(_current_plots_version))
+    newfn = joinpath(newdir, fn)
 
-  try
-    run(`mkdir -p $refdir`)
-  catch err
-    display(err)
-  end
-  reffn = joinpath(refdir, "ref$idx.png")
+    # figure out which reference file we should compare to, by finding the highest versioned file
+    reffn = nothing
+    for v in versions
+        tmpfn = joinpath(refdir, string(v), fn)
+        if isfile(tmpfn)
+            reffn = tmpfn
+            break
+        end
+    end
 
-  # the test
-  vtest = VisualTest(func, reffn, idx)
-  test_images(vtest, popup=popup, sigma=sigma, eps=eps)
+    # now we have the fn (if any)... do the comparison
+    # @show reffn
+    if reffn == nothing
+        reffn = newfn
+    end
+    # @show reffn
+    # return
+
+    # test function
+    func = (fn, idx) -> begin
+        map(eval, example.exprs)
+        png(fn)
+    end
+
+    # try
+    #     run(`mkdir -p $newdir`)
+    # catch err
+    #     display(err)
+    # end
+    # # reffn = joinpath(refdir, "ref$idx.png")
+
+    # the test
+    vtest = VisualTest(func, reffn, idx)
+    test_images(vtest, popup=popup, sigma=sigma, eps=eps, newfn = newfn)
 end
 
 function image_comparison_facts(pkg::Symbol;
@@ -60,7 +96,7 @@ function image_comparison_facts(pkg::Symbol;
                                 debug = false,  # print debug information?
                                 sigma = [1,1],  # number of pixels to "blur"
                                 eps = 1e-2)     # acceptable error (percent)
-  for i in 1:length(ExamplePlots._examples)
+  for i in 1:length(Plots._examples)
     i in skip && continue
     if only == nothing || i in only
       @fact image_comparison_tests(pkg, i, debug=debug, sigma=sigma, eps=eps) |> success --> true

test/runtests.jl

@@ -5,32 +5,34 @@ include("imgcomp.jl")
 # don't actually show the plots
 srand(1234)
 default(show=false, reuse=true)
-img_eps = 5e-2
+img_eps = isinteractive() ? 1e-2 : 10e-2
 
-facts("Gadfly") do
-    @fact gadfly() --> Plots.GadflyBackend()
-    @fact backend() --> Plots.GadflyBackend()
-
-    @fact typeof(plot(1:10)) --> Plots.Plot{Plots.GadflyBackend}
-    @fact plot(Int[1,2,3], rand(3)) --> not(nothing)
-    @fact plot(sort(rand(10)), rand(Int, 10, 3)) --> not(nothing)
-    @fact plot!(rand(10,3), rand(10,3)) --> not(nothing)
-
-    image_comparison_facts(:gadfly, skip=[4,6,19,23,24,27], eps=img_eps)
-end
+# facts("Gadfly") do
+#     @fact gadfly() --> Plots.GadflyBackend()
+#     @fact backend() --> Plots.GadflyBackend()
+#
+#     @fact typeof(plot(1:10)) --> Plots.Plot{Plots.GadflyBackend}
+#     @fact plot(Int[1,2,3], rand(3)) --> not(nothing)
+#     @fact plot(sort(rand(10)), rand(Int, 10, 3)) --> not(nothing)
+#     @fact plot!(rand(10,3), rand(10,3)) --> not(nothing)
+#
+#     image_comparison_facts(:gadfly, skip=[4,6,23,24,27], eps=img_eps)
+# end
 
 facts("PyPlot") do
     @fact pyplot() --> Plots.PyPlotBackend()
     @fact backend() --> Plots.PyPlotBackend()
 
-    image_comparison_facts(:pyplot, skip=[19], eps=img_eps)
+    image_comparison_facts(:pyplot, skip=[25,30], eps=img_eps)
 end
 
 facts("GR") do
     @fact gr() --> Plots.GRBackend()
     @fact backend() --> Plots.GRBackend()
 
-    @linux_only image_comparison_facts(:gr, skip=[24], 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
 
 
@@ -70,6 +72,59 @@ end
 
 
 
+facts("Axes") do
+    p = plot()
+    axis = p.subplots[1][:xaxis]
+    @fact typeof(axis) --> Axis
+    @fact Plots.discrete_value!(axis, "HI") --> (0.5, 1)
+    @fact Plots.discrete_value!(axis, :yo) --> (1.5, 2)
+    @fact extrema(axis) --> (0.5,1.5)
+    @fact axis[:discrete_map] --> Dict{Any,Any}(:yo  => 2, "HI" => 1)
+
+    Plots.discrete_value!(axis, ["x$i" for i=1:5])
+    Plots.discrete_value!(axis, ["x$i" for i=0:2])
+    @fact extrema(axis) --> (0.5, 7.5)
+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,13 +1,15 @@
-# 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/PlotReferenceImages.jl.git")
 
-Pkg.clone("https://github.com/tbreloff/ExamplePlots.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")
@@ -15,6 +17,10 @@ Pkg.clone("https://github.com/tbreloff/ExamplePlots.jl.git");
 # Blink.AtomShell.install()
 # Pkg.clone("https://github.com/spencerlyon2/PlotlyJS.jl.git")
 
+# Pkg.checkout("RecipesBase")
+# Pkg.clone("VisualRegressionTests")
+
+# need this to use Conda
 ENV["PYTHON"] = ""
 Pkg.add("PyPlot")
 Pkg.build("PyPlot")