appveyor fix

Added suport for marker borders

.gitignore

@@ -1,3 +1,7 @@
 *.jl.cov
 *.jl.*.cov
 *.jl.mem
+.DS_Store
+examples/.ipynb_checkpoints/*
+examples/meetup/.ipynb_checkpoints/*
+deps/plotly-latest.min.js

.travis.yml

@@ -4,10 +4,57 @@ os:
   - linux
   - osx
 julia:
-  - 0.4
+  - release
+  - nightly
+matrix:
+  allow_failures:
+    - julia: nightly
+
+# # before install:
+# #   - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew update          ; fi
+# #   - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew install wkhtmltopdf; fi
+
+# ref: http://askubuntu.com/a/556672 for the wkhtmltopdf apt repository info
+
+sudo: required
+before_install:
+  - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then pwd ; fi
+  - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then ./test/install_wkhtmltoimage.sh ; fi
+#   - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then  sudo add-apt-repository -y ppa:pov/wkhtmltopdf  ; fi
+#   - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then  sudo apt-get -qq update                      ; fi
+#   - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then  sudo apt-get install -y wkhtmltopdf          ; fi
+#   - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then  wkhtmltopdf -V                               ; fi
+#   - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then  wkhtmltoimage -V                             ; fi
+#   echo 'exec xvfb-run -a -s "-screen 0 640x480x16" wkhtmltopdf "$@"' | sudo tee /usr/local/bin/wkhtmltopdf.sh >/dev/null
+# sudo chmod a+x /usr/local/bin/wkhtmltopdf.sh
+
+# # borrowed from Blink.jl's travis file
+# matrix:
+#   include:
+#     - os: linux
+#       julia: 0.4
+#       env: TESTCMD="xvfb-run julia"
+#     - os: osx
+#       julia: 0.4
+#       env: TESTCMD="julia"
+
+
+
 notifications:
-  email: false
+  email: true
 # uncomment the following lines to override the default test script
 script:
  - if [[ -a .git/shallow ]]; then git fetch --unshallow; fi
- - julia -e 'Pkg.clone(pwd()); Pkg.build("Plots"); Pkg.add("Gadfly"); Pkg.test("Plots"; coverage=true)'
+ - julia -e 'Pkg.clone(pwd()); Pkg.build("Plots")'
+ - julia test/travis_commands.jl
+ # - julia -e 'Pkg.clone("ImageMagick"); Pkg.build("ImageMagick")'
+ # - julia -e 'Pkg.clone("GR"); Pkg.build("GR")'
+ # # - julia -e 'Pkg.clone("https://github.com/tbreloff/ImageMagick.jl.git"); Pkg.checkout("ImageMagick","tb_write"); Pkg.build("ImageMagick")'
+ # - julia -e 'Pkg.clone("https://github.com/tbreloff/ExamplePlots.jl.git");'
+ # # - julia -e 'Pkg.clone("https://github.com/JunoLab/Blink.jl.git"); Pkg.build("Blink"); import Blink; Blink.AtomShell.install()'
+ # # - julia -e 'Pkg.clone("https://github.com/spencerlyon2/PlotlyJS.jl.git")'
+ # - julia -e 'ENV["PYTHON"] = ""; Pkg.add("PyPlot"); Pkg.build("PyPlot")'
+ #
+ # # - $TESTCMD -e 'Pkg.test("Plots"; coverage=false)'
+ # - julia -e 'Pkg.test("Plots"; coverage=false)'
+ # # - julia -e 'cd(Pkg.dir("Plots")); Pkg.add("Coverage"); using Coverage; Coveralls.submit(process_folder()); Codecov.submit(process_folder())'

NEWS.md

@@ -0,0 +1,232 @@
+
+# Plots.jl NEWS
+
+#### notes on release changes, ongoing development, and future planned work
+
+- All new development should target 0.7!
+
+---
+
+## 0.7 (current master/dev)
+
+#### 0.7.3
+
+- rebuild violin and boxplot recipes
+- "plot recipes"
+- `cgrad` method for easy color gradient creation
+- improvements to inset subplots
+- Segments and iter_segments for NaN-separated vectors
+- `bar` recipe now creates a `shape` series
+- writemime fix for Interact.jl
+- `link = :square` option
+- !!! set `shape` attributes with line/fill, NOT marker/markerstroke !!!
+- basic DPI support
+- moved chorddiagram to PlotRecipes
+- GR:
+	- use temp files for img output
+	- basic support for marker strokes and other marker fixes
+- PyPlot:
+	- Switch to recipes for bar, histogram, histogram2d
+- GLVisualize
+	- subplots
+	- path/scatter and path3d/scatter3d
+	- initial drawing of axes
+- many smaller fixes and improvements
+
+#### 0.7.2
+
+- line_z arg for multicolored line segments
+- pyplot
+	- line_z (2d and 3d)
+	- pushed all fig updates into display pipeline
+	- remove native sticks/hline/vline in favor of recipes
+- unicodeplots cleanup, ijulia fixes, ascii canvas
+- `curves` series type
+- `iter_segments` iterator
+- moved arcdiagram out and into PlotRecipes (thanks @diegozea)
+- several other fixes/checks
+
+#### 0.7.1
+
+- inset (floating) subplots
+- change: when setting subplot/axis args from user recipes, they should apply only to their own subplot
+- trim for violin/boxplot
+- scatter3d recipe
+- removed plotly.js in favor of build.jl download
+- improvements/fixes to pgfplots backend
+- improvements/fixes to plotly/plotlyjs backends
+	- titles are annotations and properly placed with title_position
+	- hover attribute
+	- shapes (almost)
+	- scattergl
+- minimum perimeter logic in layout calc... fixed misaligned subplots
+- new clims attribute
+- more options for test_examples
+- GR refactor
+	- added transparency
+	- moved axis/grid logic out of series loop
+	- generalized 3d and polar projections
+- renamed get_mod to Base.cycle
+- pyplot log scale fixes
+- PLOTS_DEFAULTS environment var processing
+- rename :ellipse to :circle, :ellipse is now an alias
+- supported args/types cleanup
+- seriestype dependency methods and `@deps` macro
+- bbox `h_anchor`/`v_anchor`
+- new axis arg: `:link` is a list of subplots to link axes with
+- cleanup/simplification of glvisualize backend
+
+
+#### 0.7.0
+
+- Check out [the summary](http://plots.readthedocs.io/en/latest/plots_v0.7/)
+- 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://plots.readthedocs.org/
+- 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

@@ -1,224 +1,33 @@
 # Plots
 
 [![Build Status](https://travis-ci.org/tbreloff/Plots.jl.svg?branch=master)](https://travis-ci.org/tbreloff/Plots.jl)
+[![Join the chat at https://gitter.im/tbreloff/Plots.jl](https://badges.gitter.im/tbreloff/Plots.jl.svg)](https://gitter.im/tbreloff/Plots.jl?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+<!-- [![Plots](http://pkg.julialang.org/badges/Plots_0.3.svg)](http://pkg.julialang.org/?pkg=Plots&ver=0.3) -->
+<!-- [![Plots](http://pkg.julialang.org/badges/Plots_0.4.svg)](http://pkg.julialang.org/?pkg=Plots&ver=0.4) -->
+<!-- [![Coverage Status](https://coveralls.io/repos/tbreloff/Plots.jl/badge.svg?branch=master)](https://coveralls.io/r/tbreloff/Plots.jl?branch=master) -->
+<!-- [![codecov.io](http://codecov.io/github/tbreloff/Plots.jl/coverage.svg?branch=master)](http://codecov.io/github/tbreloff/Plots.jl?branch=master) -->
 
-Plotting interface and wrapper for several plotting packages.
+#### Author: Thomas Breloff (@tbreloff)
 
-Please add wishlist items, bugs, or any other comments/questions to the issues list.
+Plots is a plotting API and toolset.  My goals with the package are:
 
-## Examples
+- **Powerful**.  Do more with less.  Complex visualizations become easy.
+- **Intuitive**.  Start generating plots without reading volumes of 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.
 
-- [Qwt.jl](docs/qwt_examples.md)
-- [Gadfly.jl](docs/gadfly_examples.md)
+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.
 
-## Installation
-
-First, clone the package, and get any plotting packages you need:
-
-```
-Pkg.clone("https://github.com/tbreloff/Plots.jl.git")
-Pkg.add("Gadfly")                                     # [optional]
-Pkg.clone("https://github.com/tbreloff/Qwt.jl.git")   # [optional] requires pyqt and pyqwt
-```
-
-## Use
-
-Load it in.  The underlying plotting backends are not imported until `plotter()` is called (which happens
-on your first call to `plot`).  This means that you don't need any backends to be installed when you call `using Plots`.
-For now, the default backend is Gadfly.
-
-```
+```julia
 using Plots
+@gif for i in linspace(0,2π,100)
+    X = Y = linspace(-5,5,40)
+    surface(X, Y, (x,y) -> sin(x+10sin(i))+cos(y))
+end
 ```
 
-Do a plot in Gadfly, then save a png:
-
-```
-plot(rand(10,2); marker = :rect)
-savepng(Plots.IMG_DIR * "gadfly1.png")
-```
-
-which saves:
-
-![gadfly_plt](img/gadfly1.png)
-
-
-Do a plot in Qwt, then save a png:
-
-```
-plotter!(:qwt)  # switches the backend to Qwt
-plot(rand(10,2); marker = :rect)
-savepng(Plots.IMG_DIR * "qwt1.png")
-```
-
-which saves:
-
-![qwt_plt](img/qwt1.png)
-
-
-
-## plot and plotter! interface (WIP)
-
-The main plot command.  Call `plotter!(:module)` to set the current plotting backend.
-Commands are converted into the relevant plotting commands for that package:
-
-```
-  plotter!(:gadfly)
-  plot(1:10)    # this effectively calls `y = 1:10; Gadfly.plot(x=1:length(y), y=y)`
-  plotter!(:qwt)
-  plot(1:10)    # this effectively calls `Qwt.plot(1:10)`
-```
-
-Use `plot` to create a new plot object, and `plot!` to add to an existing one:
-
-```
-  plot(args...; kw...)                  # creates a new plot window, and sets it to be the `currentPlot`
-  plot!(args...; kw...)                 # adds to the `currentPlot`
-  plot!(plotobj, args...; kw...)        # adds to the plot `plotobj`
-```
-
-Now that you know which plot object you're updating (new, current, or other), I'll leave it off for simplicity.
-Here are some various args to supply, and the implicit mapping (AVec == AbstractVector and AMat == AbstractMatrix):
-
-```
-  plot(y::AVec; kw...)                       # one line... x = 1:length(y)
-  plot(x::AVec, y::AVec; kw...)              # one line (will assert length(x) == length(y))
-  plot(y::AMat; kw...)                       # multiple lines (one per column of x), all sharing x = 1:size(y,1)
-  plot(x::AVec, y::AMat; kw...)              # multiple lines (one per column of x), all sharing x (will assert length(x) == size(y,1))
-  plot(x::AMat, y::AMat; kw...)              # multiple lines (one per column of x/y... will assert size(x) == size(y))
-  plot(x::AVec, f::Function; kw...)          # one line, y = f(x)
-  plot(x::AMat, f::Function; kw...)          # multiple lines, yᵢⱼ = f(xᵢⱼ)
-  plot(x::AVec, fs::AVec{Function}; kw...)   # multiple lines, yᵢⱼ = fⱼ(xᵢ)
-  plot(y::AVec{AVec}; kw...)                 # multiple lines, each with x = 1:length(y[i])
-  plot(x::AVec, y::AVec{AVec}; kw...)        # multiple lines, will assert length(x) == length(y[i])
-  plot(x::AVec{AVec}, y::AVec{AVec}; kw...)  # multiple lines, will assert length(x[i]) == length(y[i])
-  plot(n::Integer; kw...)                    # n lines, all empty (for updating plots)
-
-  # TODO: how do we handle NA values in dataframes?
-  plot(df::DataFrame; kw...)                 # one line per DataFrame column, labels == names(df)
-  plot(df::DataFrame, columns; kw...)        # one line per column, but on a subset of column names
-```
-
-[TODO] You can swap out `plot` for `subplot`.  Each line will go into a separate plot.  Use the layout keyword:
-
-```
-  y = rand(100,3)
-  subplot(y; layout=(2,2), kw...)           # creates 3 lines going into 3 separate plots, laid out on a 2x2 grid (last row is filled with plot #3)
-  subplot(y; layout=(1,3), kw...)           # again 3 plots, all in the same row
-  subplot(y; layout=[1,[2,3]])              # pass a nested Array to fully specify the layout.  here the first plot will take up the first row, 
-                                            # and the others will share the second row
-```
-
-Shorthands:
-
-```
-  scatter(args...; kw...)    = plot(args...; kw...,  linetype = :none, marker = :hexagon)
-  scatter!(args...; kw...)   = plot!(args...; kw..., linetype = :none, marker = :hexagon)
-  bar(args...; kw...)        = plot(args...; kw...,  linetype = :bar)
-  bar!(args...; kw...)       = plot!(args...; kw..., linetype = :bar)
-  histogram(args...; kw...)  = plot(args...; kw...,  linetype = :hist)
-  histogram!(args...; kw...) = plot!(args...; kw..., linetype = :hist)
-  heatmap(args...; kw...)    = plot(args...; kw...,  linetype = :heatmap)
-  heatmap!(args...; kw...)   = plot!(args...; kw..., linetype = :heatmap)
-```
-
-Some keyword arguments you can set:
-
-```
-  axis            # :left or :right
-  color           # can be a string ("red") or a symbol (:red) or a ColorsTypes.jl Colorant (RGB(1,0,0)) or :auto (which lets the package pick)
-  label           # string or symbol, applies to that line, may go in a legend
-  width           # width of a line
-  linetype        # :line, :step, :stepinverted, :sticks, :dots, :none, :heatmap, :hexbin, :hist, :bar
-  linestyle       # :solid, :dash, :dot, :dashdot, :dashdotdot
-  marker          # :none, :ellipse, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star1, :star2, :hexagon
-  markercolor     # same choices as `color`, or :match will set the color to be the same as `color`
-  markersize      # size of the marker
-  nbins           # number of bins for heatmap/hexbin and histograms
-  heatmap_c       # color cutoffs for Qwt heatmaps
-  fillto          # fillto value for area plots
-  title           # string or symbol, title of the plot
-  xlabel          # string or symbol, label on the bottom (x) axis
-  ylabel          # string or symbol, label on the left (y) axis
-  yrightlabel     # string or symbol, label on the right (y) axis
-  reg             # true or false, add a regression line for each line
-  size            # (Int,Int), resize the enclosing window
-  pos             # (Int,Int), move the enclosing window to this position
-  windowtitle     # string or symbol, set the title of the enclosing windowtitle
-  screen          # Integer, move enclosing window to this screen number (for multiscreen desktops)
-  show            # true or false, show the plot (in case you don't want the window to pop up right away)
-```
-
-If you don't include a keyword argument, these are the defaults:
-  
-```
-  axis = :left
-  color = :auto
-  label = automatically generated (y1, y2, ...., or y1 (R), y2 (R) for the right axis)
-  width = 1
-  linetype = :line
-  linestype = :solid
-  marker = :none
-  markercolor = :match
-  markersize = 3
-  nbins = 100
-  heatmap_c = (0.15, 0.5)
-  fillto = nothing
-  title = ""
-  xlabel = ""
-  ylabel = ""
-  yrightlabel = ""
-  reg = false
-  size = (800,600)
-  pos = (0,0)
-  windowtitle = ""
-  screen = 1
-  show = true
-```
-
-When plotting multiple lines, you can give every line the same trait by using the singular, or add an "s" to pluralize.
-  (yes I know it's not gramatically correct, but it's easy to use and implement)
-
-```
-  plot(rand(100,2); colors = [:red, RGB(.5,.5,0)], axiss = [:left, :right], width = 5)  # note the width=5 is applied to both lines
-```
-
-# TODO
-
-- [x] Plot vectors/matrices/functions
-- [ ] Plot DataFrames
-- [ ] Subplots
-- [ ] Histograms
-- [ ] 3D plotting
-- [ ] Scenes/Drawing
-- [ ] Graphs
-- [ ] Interactivity (GUIs)
-- [x] Gadfly.jl
-- [ ] PyPlot.jl
-- [ ] Winston.jl
-- [ ] Gaston.jl
-- [ ] GLPlot.jl
-- [x] Qwt.jl
-- [ ] Bokeh.jl
-- [ ] Plotly.jl
-- [ ] GoogleCharts.jl
-- [ ] Vega.jl
-- [ ] PLplot.jl
-- [ ] TextPlots.jl
-- [ ] ASCIIPlots.jl
-- [ ] Sparklines.jl
-- [ ] UnicodePlots.jl
-- [ ] Hinton.jl
-- [ ] ImageTerm.jl
-- [ ] GraphViz.jl
-- [ ] TikzGraphs.jl
-- [ ] GraphLayout.jl
-
-# Backends
-
-See the wiki at: https://github.com/JuliaPlot/juliaplot_docs/wiki
-
-# Author
-
-Thomas Breloff (@tbreloff)
+![waves](http://plots.readthedocs.io/en/latest/examples/img/waves.gif)
 
+View the [full documentation](http://plots.readthedocs.io).

REQUIRE

@@ -1,4 +1,8 @@
-julia 0.4-
+julia 0.4
 
+RecipesBase
 Colors
-FactCheck
+Reexport
+Compat
+FixedSizeArrays
+Measures

appveyor.yml

@@ -1,14 +1,11 @@
 environment:
   matrix:
-  - JULIAVERSION: "julialang/bin/winnt/x86/0.3/julia-0.3-latest-win32.exe"
-  - JULIAVERSION: "julialang/bin/winnt/x64/0.3/julia-0.3-latest-win64.exe"
-  - JULIAVERSION: "julianightlies/bin/winnt/x86/julia-latest-win32.exe"
-  - JULIAVERSION: "julianightlies/bin/winnt/x64/julia-latest-win64.exe"
-
-branches:
-  only:
-    - master
-    - /release-.*/
+# Releases
+  - JULIAVERSION: "stable/win32"
+  - JULIAVERSION: "stable/win64"
+# Nightlies
+  - JULIAVERSION: "download/win32"
+  - JULIAVERSION: "download/win64"
 
 notifications:
   - provider: Email
@@ -18,17 +15,15 @@ notifications:
 
 install:
 # 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://status.julialang.org/"+$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

docs/example_generation.jl

@@ -1,118 +0,0 @@
-
-module PlotExamples
-
-using Plots
-using Colors
-
-const DOCDIR = Pkg.dir("Plots") * "/docs"
-const IMGDIR = Pkg.dir("Plots") * "/img"
-
-doc"""
-Holds all data needed for a documentation example... header, description, and plotting expression (Expr)
-"""
-type PlotExample
-  header::String
-  desc::String
-  exprs::Vector{Expr}
-end
-
-
-# the examples we'll run for each
-const examples = PlotExample[
-  PlotExample("Lines",
-              "A simple line plot of the 3 columns.",
-              [:(plot(rand(100,3)))]),
-  PlotExample("Functions",
-              "Plot multiple functions",
-              [:(plot(0:0.01:4π, [sin,cos]))]),
-  PlotExample("Global",
-              "Change the guides/background without a separate call.",
-              [:(plot(rand(10); title="TITLE", xlabel="XLABEL", ylabel="YLABEL", background_color = RGB(0.5,0.5,0.5)))]),
-  PlotExample("Two-axis",
-              "Use the `axis` or `axiss` arguments.\n\nNote: This is only supported with Qwt right now",
-              [:(plot(Vector[randn(100), randn(100)*100]; axiss = [:left,:right]))]),
-  PlotExample("Vectors w/ pluralized args",
-              "Plot multiple series with different numbers of points.  Mix arguments that apply to all series (singular... see `marker`) with arguments unique to each series (pluralized... see `colors`).",
-              [:(plot(Vector[rand(10), rand(20)]; marker=:ellipse, markersize=8, colors=[:red,:blue]))]),
-  PlotExample("Build plot in pieces",
-              "Start with a base plot...",
-              [:(plot(rand(100)/3; reg=true, fillto=0))]),
-  PlotExample("",
-              "and add to it later.",
-              [:(scatter!(rand(100); markersize=6, color=:blue))]),
-  PlotExample("Heatmaps",
-              "",
-              [:(heatmap(randn(10000),randn(10000); nbins=200))]),
-  PlotExample("Lots of line types",
-              "Options: (:line, :step, :stepinverted, :sticks, :dots, :none, :heatmap, :hexbin, :hist, :bar)  \nNote: some may not work with all backends",
-              [:(plot(rand(20,4); linetypes=[:line, :step, :sticks, :dots]))]),
-  PlotExample("Bar",
-              "x is the midpoint of the bar. (todo: allow passing of edges instead of midpoints)",
-              [:(bar(randn(1000)))]),
-  PlotExample("Histogram",
-              "note: fillto isn't supported on all backends",
-              [:(histogram(randn(1000); nbins=50, fillto=20))]),
-  PlotExample("Subplots",
-              """
-                subplot and subplot! are distinct commands which create many plots and add series to them in a circular fashion.
-                You can define the layout with keyword params... either set the number of plots `n` (and optionally number of rows `nr` or 
-                number of columns `nc`), or you can set the layout directly with `layout`.  
-
-                Note: Gadfly is not very friendly here, and although you can create a plot and save a PNG, I haven't been able to actually display it.
-              """,
-              [:(subplot(randn(100,5); layout=[1,1,3], linetypes=[:line,:hist,:dots,:step,:bar], nbins=10, legend=false))]),
-  PlotExample("Adding to subplots",
-              "Note here the automatic grid layout, as well as the order in which new series are added to the plots.",
-              [:(subplot(randn(100,5); n=4))]),
-  PlotExample("",
-              "",
-              [:(subplot!(randn(100,3)))]),
-
-  
-]
-
-
-function generate_markdown(pkgname::Symbol)
-
-  # set up the plotter, and don't show the plots by default
-  plotter!(pkgname)
-  plotDefault!(:show, false)
-
-  # open the markdown file
-  md = open("$DOCDIR/$(pkgname)_examples.md", "w")
-
-  for (i,example) in enumerate(examples)
-
-    try
-
-      # run the code
-      map(eval, example.exprs)
-
-      # save the png
-      imgname = "$(pkgname)_example_$i.png"
-      savepng("$IMGDIR/$imgname")
-
-      # write out the header, description, code block, and image link
-      write(md, "### $(example.header)\n\n")
-      write(md, "$(example.desc)\n\n")
-      write(md, "```julia\n$(join(map(string, example.exprs), "\n"))\n```\n\n")
-      write(md, "![](../img/$imgname)\n\n")
-
-    catch ex
-      # TODO: put error info into markdown?
-      warn("Example $pkgname:$i failed with: $ex")
-    end
-
-    #
-  end
-
-  close(md)
-
-end
-
-# run it!
-map(generate_markdown, (:qwt, :gadfly))
-
-
-end # module
-

docs/gadfly_examples.md

@@ -1,148 +0,0 @@
-### Lines
-
-A simple line plot of the 3 columns.
-
-```julia
-plot(rand(100,3))
-```
-
-![](../img/gadfly_example_1.png)
-
-### Functions
-
-Plot multiple functions
-
-```julia
-plot(0:0.01:4π,[sin,cos])
-```
-
-![](../img/gadfly_example_2.png)
-
-### Global
-
-Change the guides/background without a separate call.
-
-```julia
-plot(rand(10); title="TITLE",xlabel="XLABEL",ylabel="YLABEL",background_color=RGB(0.5,0.5,0.5))
-```
-
-![](../img/gadfly_example_3.png)
-
-### Two-axis
-
-Use the `axis` or `axiss` arguments.
-
-Note: This is only supported with Qwt right now
-
-```julia
-plot(Vector[randn(100),randn(100) * 100]; axiss=[:left,:right])
-```
-
-![](../img/gadfly_example_4.png)
-
-### Vectors w/ pluralized args
-
-Plot multiple series with different numbers of points.  Mix arguments that apply to all series (singular... see `marker`) with arguments unique to each series (pluralized... see `colors`).
-
-```julia
-plot(Vector[rand(10),rand(20)]; marker=:ellipse,markersize=8,colors=[:red,:blue])
-```
-
-![](../img/gadfly_example_5.png)
-
-### Build plot in pieces
-
-Start with a base plot...
-
-```julia
-plot(rand(100) / 3; reg=true,fillto=0)
-```
-
-![](../img/gadfly_example_6.png)
-
-### 
-
-and add to it later.
-
-```julia
-scatter!(rand(100); markersize=6,color=:blue)
-```
-
-![](../img/gadfly_example_7.png)
-
-### Heatmaps
-
-
-
-```julia
-heatmap(randn(10000),randn(10000); nbins=200)
-```
-
-![](../img/gadfly_example_8.png)
-
-### Lots of line types
-
-Options: (:line, :step, :stepinverted, :sticks, :dots, :none, :heatmap, :hexbin, :hist, :bar)  
-Note: some may not work with all backends
-
-```julia
-plot(rand(20,4); linetypes=[:line,:step,:sticks,:dots])
-```
-
-![](../img/gadfly_example_9.png)
-
-### Bar
-
-x is the midpoint of the bar. (todo: allow passing of edges instead of midpoints)
-
-```julia
-bar(randn(1000))
-```
-
-![](../img/gadfly_example_10.png)
-
-### Histogram
-
-note: fillto isn't supported on all backends
-
-```julia
-histogram(randn(1000); nbins=50,fillto=20)
-```
-
-![](../img/gadfly_example_11.png)
-
-### Subplots
-
-  subplot and subplot! are distinct commands which create many plots and add series to them in a circular fashion.
-  You can define the layout with keyword params... either set the number of plots `n` (and optionally number of rows `nr` or 
-  number of columns `nc`), or you can set the layout directly with `layout`.  
-
-  Note: Gadfly is not very friendly here, and although you can create a plot and save a PNG, I haven't been able to actually display it.
-
-
-```julia
-subplot(randn(100,5); layout=[1,1,3],linetypes=[:line,:hist,:dots,:step,:bar],nbins=10,legend=false)
-```
-
-![](../img/gadfly_example_12.png)
-
-### Adding to subplots
-
-Note here the automatic grid layout, as well as the order in which new series are added to the plots.
-
-```julia
-subplot(randn(100,5); n=4)
-```
-
-![](../img/gadfly_example_13.png)
-
-### 
-
-
-
-```julia
-subplot!(randn(100,3))
-```
-
-![](../img/gadfly_example_14.png)
-

docs/qwt_examples.md

@@ -1,148 +0,0 @@
-### Lines
-
-A simple line plot of the 3 columns.
-
-```julia
-plot(rand(100,3))
-```
-
-![](../img/qwt_example_1.png)
-
-### Functions
-
-Plot multiple functions
-
-```julia
-plot(0:0.01:4π,[sin,cos])
-```
-
-![](../img/qwt_example_2.png)
-
-### Global
-
-Change the guides/background without a separate call.
-
-```julia
-plot(rand(10); title="TITLE",xlabel="XLABEL",ylabel="YLABEL",background_color=RGB(0.5,0.5,0.5))
-```
-
-![](../img/qwt_example_3.png)
-
-### Two-axis
-
-Use the `axis` or `axiss` arguments.
-
-Note: This is only supported with Qwt right now
-
-```julia
-plot(Vector[randn(100),randn(100) * 100]; axiss=[:left,:right])
-```
-
-![](../img/qwt_example_4.png)
-
-### Vectors w/ pluralized args
-
-Plot multiple series with different numbers of points.  Mix arguments that apply to all series (singular... see `marker`) with arguments unique to each series (pluralized... see `colors`).
-
-```julia
-plot(Vector[rand(10),rand(20)]; marker=:ellipse,markersize=8,colors=[:red,:blue])
-```
-
-![](../img/qwt_example_5.png)
-
-### Build plot in pieces
-
-Start with a base plot...
-
-```julia
-plot(rand(100) / 3; reg=true,fillto=0)
-```
-
-![](../img/qwt_example_6.png)
-
-### 
-
-and add to it later.
-
-```julia
-scatter!(rand(100); markersize=6,color=:blue)
-```
-
-![](../img/qwt_example_7.png)
-
-### Heatmaps
-
-
-
-```julia
-heatmap(randn(10000),randn(10000); nbins=200)
-```
-
-![](../img/qwt_example_8.png)
-
-### Lots of line types
-
-Options: (:line, :step, :stepinverted, :sticks, :dots, :none, :heatmap, :hexbin, :hist, :bar)  
-Note: some may not work with all backends
-
-```julia
-plot(rand(20,4); linetypes=[:line,:step,:sticks,:dots])
-```
-
-![](../img/qwt_example_9.png)
-
-### Bar
-
-x is the midpoint of the bar. (todo: allow passing of edges instead of midpoints)
-
-```julia
-bar(randn(1000))
-```
-
-![](../img/qwt_example_10.png)
-
-### Histogram
-
-note: fillto isn't supported on all backends
-
-```julia
-histogram(randn(1000); nbins=50,fillto=20)
-```
-
-![](../img/qwt_example_11.png)
-
-### Subplots
-
-  subplot and subplot! are distinct commands which create many plots and add series to them in a circular fashion.
-  You can define the layout with keyword params... either set the number of plots `n` (and optionally number of rows `nr` or 
-  number of columns `nc`), or you can set the layout directly with `layout`.  
-
-  Note: Gadfly is not very friendly here, and although you can create a plot and save a PNG, I haven't been able to actually display it.
-
-
-```julia
-subplot(randn(100,5); layout=[1,1,3],linetypes=[:line,:hist,:dots,:step,:bar],nbins=10,legend=false)
-```
-
-![](../img/qwt_example_12.png)
-
-### Adding to subplots
-
-Note here the automatic grid layout, as well as the order in which new series are added to the plots.
-
-```julia
-subplot(randn(100,5); n=4)
-```
-
-![](../img/qwt_example_13.png)
-
-### 
-
-
-
-```julia
-subplot!(randn(100,3))
-```
-
-![](../img/qwt_example_14.png)
-

pushtomaster.sh

@@ -0,0 +1,4 @@
+git checkout master
+git merge --ff-only dev
+git push origin master
+git checkout dev

src/Plots.jl

@@ -1,76 +1,263 @@
+
 __precompile__()
 
 module Plots
 
-using Colors
+using Compat
+using Reexport
+@reexport using Colors
+# using Requires
+using FixedSizeArrays
+@reexport using RecipesBase
+using Base.Meta
+# using PlotUtils
 
 export
-  plotter,
-  plot,
-  subplot,
+    AbstractPlot,
+    Plot,
+    Subplot,
+    AbstractLayout,
+    GridLayout,
+    grid,
+    EmptyLayout,
+    bbox,
+    plotarea,
+    @layout,
+    AVec,
+    AMat,
+    KW,
 
-  plotter!,
-  plot!,
-  subplot!,
+    wrap,
+    set_theme,
+    add_theme,
 
-  currentPlot,
-  plotDefault,
-  scatter,
-  bar,
-  histogram,
-  heatmap,
+    plot,
+    plot!,
 
-  currentPlot!,
-  plotDefault!,
-  scatter!,
-  bar!,
-  histogram!,
-  heatmap!,
+    current,
+    default,
+    with,
 
-  savepng
+    @userplot,
+    @shorthands,
+
+    pie,
+    pie!,
+    plot3d,
+    plot3d!,
+
+    title!,
+    xlabel!,
+    ylabel!,
+    xlims!,
+    ylims!,
+    zlims!,
+    xticks!,
+    yticks!,
+    annotate!,
+    xflip!,
+    yflip!,
+    xaxis!,
+    yaxis!,
+
+    savefig,
+    png,
+    gui,
+
+    backend,
+    backends,
+    backend_name,
+    aliases,
+    dataframes,
+
+    Shape,
+    text,
+    font,
+    Axis,
+    stroke,
+    brush,
+    Surface,
+    OHLC,
+    arrow,
+    Segments,
+
+    colorscheme,
+    ColorScheme,
+    ColorGradient,
+    ColorVector,
+    ColorWrapper,
+    ColorFunction,
+    ColorZFunction,
+    getColor,
+    getColorZ,
+
+    debugplots,
+
+    supported_args,
+    supported_types,
+    supported_styles,
+    supported_markers,
+    is_subplot_supported,
+
+    Animation,
+    frame,
+    gif,
+    @animate,
+    @gif,
+
+    spy,
+
+    test_examples,
+    iter_segments,
+
+    translate,
+    translate!,
+    rotate,
+    rotate!,
+    center,
+    P2,
+    P3,
+    BezierCurve,
+    curve_points,
+    directed_curve
 
 # ---------------------------------------------------------
 
-
-const IMG_DIR = Pkg.dir("Plots") * "/img/"
-
+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("qwt.jl")
-include("gadfly.jl")
-include("plotter.jl")
-
-# ---------------------------------------------------------
-
+include("colors.jl")
+include("components.jl")
+include("axes.jl")
+include("backends.jl")
 include("args.jl")
+include("themes.jl")
 include("plot.jl")
-include("subplot.jl")
+include("series_args.jl")
+include("series_new.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 = :none, marker = :hexagon)
-scatter!(args...; kw...)   = plot!(args...; kw..., linetype = :none, marker = :hexagon)
-bar(args...; kw...)        = plot(args...; kw...,  linetype = :bar)
-bar!(args...; kw...)       = plot!(args...; kw..., linetype = :bar)
-histogram(args...; kw...)  = plot(args...; kw...,  linetype = :hist)
-histogram!(args...; kw...) = plot!(args...; kw..., linetype = :hist)
-heatmap(args...; kw...)    = plot(args...; kw...,  linetype = :heatmap)
-heatmap!(args...; kw...)   = plot!(args...; kw..., linetype = :heatmap)
+# 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 contour3d
+@shorthands surface
+@shorthands wireframe
+@shorthands path3d
+@shorthands scatter3d
+@shorthands boxplot
+@shorthands violin
+@shorthands quiver
+@shorthands curves
+
+pie(args...; kw...)        = plot(args...; kw...,  seriestype = :pie, aspect_ratio = :equal, grid=false, xticks=nothing, yticks=nothing)
+pie!(args...; kw...)       = plot!(args...; kw..., seriestype = :pie, aspect_ratio = :equal, grid=false, xticks=nothing, yticks=nothing)
+plot3d(args...; kw...)     = plot(args...; kw...,  seriestype = :path3d)
+plot3d!(args...; kw...)    = plot!(args...; kw..., seriestype = :path3d)
+
+
+title!(s::AbstractString; kw...)                 = plot!(; title = s, kw...)
+xlabel!(s::AbstractString; kw...)                = plot!(; xlabel = s, kw...)
+ylabel!(s::AbstractString; kw...)                = plot!(; ylabel = s, kw...)
+xlims!{T<:Real,S<:Real}(lims::Tuple{T,S}; kw...) = plot!(; xlims = lims, kw...)
+ylims!{T<:Real,S<:Real}(lims::Tuple{T,S}; kw...) = plot!(; ylims = lims, kw...)
+zlims!{T<:Real,S<:Real}(lims::Tuple{T,S}; kw...) = plot!(; zlims = lims, kw...)
+xlims!(xmin::Real, xmax::Real; kw...)                     = plot!(; xlims = (xmin,xmax), kw...)
+ylims!(ymin::Real, ymax::Real; kw...)                     = plot!(; ylims = (ymin,ymax), kw...)
+zlims!(zmin::Real, zmax::Real; kw...)                     = plot!(; zlims = (zmin,zmax), kw...)
+xticks!{T<:Real}(v::AVec{T}; kw...)                       = plot!(; xticks = v, kw...)
+yticks!{T<:Real}(v::AVec{T}; kw...)                       = plot!(; yticks = v, kw...)
+xticks!{T<:Real,S<:AbstractString}(
+              ticks::AVec{T}, labels::AVec{S}; kw...)     = plot!(; xticks = (ticks,labels), kw...)
+yticks!{T<:Real,S<:AbstractString}(
+              ticks::AVec{T}, labels::AVec{S}; kw...)     = plot!(; yticks = (ticks,labels), kw...)
+annotate!(anns...; kw...)                                 = plot!(; annotation = anns, kw...)
+annotate!{T<:Tuple}(anns::AVec{T}; kw...)                 = plot!(; annotation = anns, kw...)
+xflip!(flip::Bool = true; kw...)                          = plot!(; xflip = flip, kw...)
+yflip!(flip::Bool = true; kw...)                          = plot!(; yflip = flip, kw...)
+xaxis!(args...; kw...)                                    = plot!(; xaxis = args, kw...)
+yaxis!(args...; kw...)                                    = plot!(; yaxis = args, kw...)
+
+title!(plt::Plot, s::AbstractString; kw...)                  = plot!(plt; title = s, kw...)
+xlabel!(plt::Plot, s::AbstractString; kw...)                 = plot!(plt; xlabel = s, kw...)
+ylabel!(plt::Plot, s::AbstractString; kw...)                 = plot!(plt; ylabel = s, kw...)
+xlims!{T<:Real,S<:Real}(plt::Plot, lims::Tuple{T,S}; kw...)  = plot!(plt; xlims = lims, kw...)
+ylims!{T<:Real,S<:Real}(plt::Plot, lims::Tuple{T,S}; kw...)  = plot!(plt; ylims = lims, kw...)
+zlims!{T<:Real,S<:Real}(plt::Plot, lims::Tuple{T,S}; kw...)  = plot!(plt; zlims = lims, kw...)
+xlims!(plt::Plot, xmin::Real, xmax::Real; kw...)                      = plot!(plt; xlims = (xmin,xmax), kw...)
+ylims!(plt::Plot, ymin::Real, ymax::Real; kw...)                      = plot!(plt; ylims = (ymin,ymax), kw...)
+zlims!(plt::Plot, zmin::Real, zmax::Real; kw...)                      = plot!(plt; zlims = (zmin,zmax), kw...)
+xticks!{T<:Real}(plt::Plot, ticks::AVec{T}; kw...)                    = plot!(plt; xticks = ticks, kw...)
+yticks!{T<:Real}(plt::Plot, ticks::AVec{T}; kw...)                    = plot!(plt; yticks = ticks, kw...)
+xticks!{T<:Real,S<:AbstractString}(plt::Plot,
+                          ticks::AVec{T}, labels::AVec{S}; kw...)     = plot!(plt; xticks = (ticks,labels), kw...)
+yticks!{T<:Real,S<:AbstractString}(plt::Plot,
+                          ticks::AVec{T}, labels::AVec{S}; kw...)     = plot!(plt; yticks = (ticks,labels), kw...)
+annotate!(plt::Plot, anns...; kw...)                                  = plot!(plt; annotation = anns, kw...)
+annotate!{T<:Tuple}(plt::Plot, anns::AVec{T}; kw...)                  = plot!(plt; annotation = anns, kw...)
+xflip!(plt::Plot, flip::Bool = true; kw...)                           = plot!(plt; xflip = flip, kw...)
+yflip!(plt::Plot, flip::Bool = true; kw...)                           = plot!(plt; yflip = flip, kw...)
+xaxis!(plt::Plot, args...; kw...)                                     = plot!(plt; xaxis = args, kw...)
+yaxis!(plt::Plot, args...; kw...)                                     = plot!(plt; yaxis = args, kw...)
+
 
 
 # ---------------------------------------------------------
 
+const CURRENT_BACKEND = CurrentBackend(:none)
 
-savepng(args...; kw...) = savepng(currentPlot(), args...; kw...)
-savepng(plt::PlottingObject, args...; kw...) = savepng(plt.plotter, plt, args...; kw...)
+function __init__()
+    setup_ijulia()
+    setup_atom()
 
+    if haskey(ENV, "PLOTS_DEFAULTS")
+        for (k,v) in eval(parse(ENV["PLOTS_DEFAULTS"]))
+            default(k, v)
+        end
+    end
+end
+
+# ---------------------------------------------------------
+
+# if VERSION >= v"0.4.0-dev+5512"
+#     include("precompile.jl")
+#     _precompile_()
+# end
 
 # ---------------------------------------------------------
 

src/animation.jl

@@ -0,0 +1,143 @@
+
+immutable Animation
+  dir::Compat.ASCIIString
+  frames::Vector{Compat.ASCIIString}
+end
+
+function Animation()
+  tmpdir = convert(Compat.ASCIIString, mktempdir())
+  Animation(tmpdir, Compat.ASCIIString[])
+end
+
+function frame{P<:AbstractPlot}(anim::Animation, plt::P=current())
+  i = length(anim.frames) + 1
+  filename = @sprintf("%06d.png", i)
+  png(plt, joinpath(anim.dir, filename))
+  push!(anim.frames, filename)
+end
+
+
+# -----------------------------------------------
+
+"Wraps the location of an animated gif so that it can be displayed"
+immutable AnimatedGif
+  filename::Compat.ASCIIString
+end
+
+function gif(anim::Animation, fn = (isijulia() ? "tmp.gif" : tempname()*".gif"); fps::Integer = 20)
+  fn = abspath(fn)
+
+  try
+
+    # high quality
+    speed = round(Int, 100 / fps)
+    file = joinpath(Pkg.dir("ImageMagick"), "deps","deps.jl")
+    if isfile(file) && !haskey(ENV, "MAGICK_CONFIGURE_PATH")
+        include(file)
+    end
+    # prefix = get(ENV, "MAGICK_CONFIGURE_PATH", "")
+    run(`convert -delay $speed -loop 0 $(joinpath(anim.dir, "*.png")) -alpha off $fn`)
+
+  catch err
+    warn("""Tried to create gif using convert (ImageMagick), but got error: $err
+    ImageMagick can be installed by executing `Pkg.add("ImageMagick")`
+    Will try ffmpeg, but it's lower quality...)""")
+
+    # low quality
+    run(`ffmpeg -v 0 -framerate $fps -i $(anim.dir)/%06d.png -y $fn`)
+    # run(`ffmpeg -v warning -i  "fps=$fps,scale=320:-1:flags=lanczos"`)
+  end
+
+  info("Saved animation to ", fn)
+  AnimatedGif(fn)
+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())>\" />")
+end
+
+
+# -----------------------------------------------
+
+function _animate(forloop::Expr, args...; callgif = false)
+  if forloop.head != :for
+    error("@animate macro expects a for-block. got: $(forloop.head)")
+  end
+
+  # add the call to frame to the end of each iteration
+  animsym = gensym("anim")
+  countersym = gensym("counter")
+  block = forloop.args[2]
+
+  # create filter
+  n = length(args)
+  filterexpr = if n == 0
+    # no filter... every iteration gets a frame
+    true
+
+  elseif args[1] == :every
+    # filter every `freq` frames (starting with the first frame)
+    @assert n == 2
+    freq = args[2]
+    @assert isa(freq, Integer) && freq > 0
+    :(mod1($countersym, $freq) == 1)
+
+  elseif args[1] == :when
+    # filter on custom expression
+    @assert n == 2
+    args[2]
+
+  else
+    error("Unsupported animate filter: $args")
+  end
+
+  push!(block.args, :(if $filterexpr; frame($animsym); end))
+  push!(block.args, :($countersym += 1))
+
+  # add a final call to `gif(anim)`?
+  retval = callgif ? :(gif($animsym)) : animsym
+
+  # full expression:
+  esc(quote
+    $animsym = Animation()  # init animation object
+    $countersym = 1         # init iteration counter
+    $forloop                # for loop, saving a frame after each iteration
+    $retval                 # return the animation object, or the gif
+  end)
+end
+
+"""
+Builds an `Animation` using one frame per loop iteration, then create an animated GIF.
+
+Example:
+
+```
+  p = plot(1)
+  @gif for x=0:0.1:5
+    push!(p, 1, sin(x))
+  end
+```
+"""
+macro gif(forloop::Expr, args...)
+  _animate(forloop, args...; callgif = true)
+end
+
+"""
+Collect one frame per for-block iteration and return an `Animation` object.
+
+Example:
+
+```
+  p = plot(1)
+  anim = @animate for x=0:0.1:5
+    push!(p, 1, sin(x))
+  end
+  gif(anim)
+```
+"""
+macro animate(forloop::Expr, args...)
+  _animate(forloop, args...)
+end

src/arg_desc.jl

@@ -0,0 +1,108 @@
+
+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",
+
+# 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 (width to height ratio of plot area).",
+: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.",
+
+# axis args
+:guide     				  => "String. Axis guide (label).",
+:lims      				  => "NTuple{2,Number}. Force axis limits.  Only finite values are used (you can set only the right limit with `xlims = (-Inf, 2)` for example).",
+:ticks     				  => "Vector of numbers (set the tick values), Tuple of (tickvalues, ticklabels), or `:auto`",
+:scale     				  => "Symbol. Scale of the axis: `:none`, `:ln`, `:log2`, `:log10`",
+:rotation  				  => "Number. Degrees rotation of tick labels.",
+:flip      				  => "Bool.  Should we flip (reverse) the axis?",
+:tickfont  				  => "Font. Font of axis tick labels.",
+:guidefont 				  => "Font. Font of axis guide (label).",
+: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).",
+
+)

src/axes.jl

@@ -0,0 +1,332 @@
+
+
+# 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
+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
+
+    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))
+
+# get discrete ticks, or not
+function get_ticks(axis::Axis)
+    ticks = axis[:ticks]
+    dvals = axis[:discrete_values]
+    if !isempty(dvals) && ticks == :auto
+        axis[:continuous_values], dvals
+    else
+        ticks
+    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
+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)
+    # first expand for the data
+    for letter in (:x, :y, :z)
+        data = d[letter]
+        axis = sp.attr[Symbol(letter, "axis")]
+        if eltype(data) <: Number
+            expand_extrema!(axis, data)
+        elseif isa(data, Surface) && eltype(data.surf) <: Number
+            expand_extrema!(axis, data)
+        elseif data != nothing
+            # TODO: need more here... gotta track the discrete reference value
+            #       as well as any coord offset (think of boxplot shape coords... they all
+            #       correspond to the same x-value)
+            # @show letter,eltype(data),typeof(data)
+            d[letter], d[Symbol(letter,"_discrete_indices")] = discrete_value!(axis, data)
+        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
+    vert = isvertical(d)
+    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
+        # @show data bw
+
+        axis = sp.attr[Symbol(dsym, :axis)]
+        expand_extrema!(axis, maximum(data) + 0.5maximum(bw))
+        expand_extrema!(axis, minimum(data) - 0.5minimum(bw))
+    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
+        for series in series_list(axis.sp)
+            if series.d[:seriestype] in (:scatter,) || series.d[:markershape] != :none
+                should_widen = true
+            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

src/backends.jl

@@ -0,0 +1,229 @@
+
+immutable NoBackend <: AbstractBackend end
+
+const _backendType = Dict{Symbol, DataType}(:none => NoBackend)
+const _backendSymbol = Dict{DataType, Symbol}(NoBackend => :none)
+const _backends = Symbol[]
+const _initialized_backends = Set{Symbol}()
+
+backends() = _backends
+backend_name() = CURRENT_BACKEND.sym
+_backend_instance(sym::Symbol) = haskey(_backendType, sym) ? _backendType[sym]() : error("Unsupported backend $sym")
+
+macro init_backend(s)
+    str = lowercase(string(s))
+    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)
+        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")
+
+# ---------------------------------------------------------
+
+# 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
+
+# Set the (left, top, right, bottom) minimum padding around the plot area
+# to fit ticks, tick labels, guides, colorbars, etc.
+function _update_min_padding!(sp::Subplot)
+    leftpad   = 10mm + sp[:left_margin]   + guide_padding(sp[:yaxis])
+    toppad    =  2mm + sp[:top_margin]    + title_padding(sp)
+    rightpad  =  3mm + sp[:right_margin]
+    bottompad =  5mm + sp[:bottom_margin] + guide_padding(sp[:xaxis])
+    # @show (leftpad, toppad, rightpad, bottompad)
+    sp.minpad = (leftpad, toppad, rightpad, bottompad)
+end
+
+_update_plot_object(plt::Plot) = nothing
+
+# ---------------------------------------------------------
+
+
+type CurrentBackend
+  sym::Symbol
+  pkg::AbstractBackend
+end
+CurrentBackend(sym::Symbol) = CurrentBackend(sym, _backend_instance(sym))
+
+# ---------------------------------------------------------
+
+function pickDefaultBackend()
+    env_default = get(ENV, "PLOTS_DEFAULT_BACKEND", "")
+    if env_default != ""
+        try
+            Pkg.installed(env_default)  # this will error if not installed
+            sym = Symbol(lowercase(env_default))
+            if haskey(_backendType, sym)
+                return backend(sym)
+            else
+                warn("You have set PLOTS_DEFAULT_BACKEND=$env_default but it is not a valid backend package.  Choose from:\n\t",
+                     join(sort(_backends), "\n\t"))
+            end
+        catch
+            warn("You have set PLOTS_DEFAULT_BACKEND=$env_default but it is not installed.")
+        end
+    end
+
+    # the ordering/inclusion of this package list is my semi-arbitrary guess at
+    # which one someone will want to use if they have the package installed...accounting for
+    # features, speed, and robustness
+    for pkgstr in ("PyPlot", "GR", "PlotlyJS", "Immerse", "Gadfly", "UnicodePlots")
+        if Pkg.installed(pkgstr) != nothing
+            return backend(Symbol(lowercase(pkgstr)))
+        end
+    end
+
+    # the default if nothing else is installed
+    backend(:plotly)
+end
+
+
+# ---------------------------------------------------------
+
+"""
+Returns the current plotting package name.  Initializes package on first call.
+"""
+function backend()
+
+  global CURRENT_BACKEND
+  if CURRENT_BACKEND.sym == :none
+    pickDefaultBackend()
+  end
+
+  sym = CURRENT_BACKEND.sym
+  if !(sym in _initialized_backends)
+
+    # initialize
+    println("[Plots.jl] Initializing backend: ", sym)
+
+    inst = _backend_instance(sym)
+    try
+      _initialize_backend(inst)
+    catch err
+      warn("Couldn't initialize $sym.  (might need to install it?)")
+      rethrow(err)
+    end
+
+    push!(_initialized_backends, sym)
+
+  end
+  CURRENT_BACKEND.pkg
+end
+
+"""
+Set the plot backend.
+"""
+function backend(pkg::AbstractBackend)
+    CURRENT_BACKEND.sym = backend_name(pkg)
+    warn_on_deprecated_backend(CURRENT_BACKEND.sym)
+    CURRENT_BACKEND.pkg = pkg
+end
+
+function backend(modname::Symbol)
+    warn_on_deprecated_backend(modname)
+    CURRENT_BACKEND.sym = modname
+    CURRENT_BACKEND.pkg = _backend_instance(modname)
+end
+
+const _deprecated_backends = [:qwt, :winston, :bokeh, :gadfly, :immerse]
+
+function warn_on_deprecated_backend(bsym::Symbol)
+    if bsym in _deprecated_backends
+        warn("Backend $bsym has been deprecated.  It may not work as originally intended.")
+    end
+end
+
+# ---------------------------------------------------------
+
+supported_types(::AbstractBackend) = []
+supported_styles(::AbstractBackend) = [:solid]
+supported_markers(::AbstractBackend) = [:none]
+supported_scales(::AbstractBackend) = [:identity]
+is_subplot_supported(::AbstractBackend) = false
+is_string_supported(::AbstractBackend) = false
+nativeImagesSupported(b::AbstractBackend) = :image in supported_types(b)
+
+supported_types() = supported_types(backend())
+supported_styles() = supported_styles(backend())
+supported_markers() = supported_markers(backend())
+supported_scales() = supported_scales(backend())
+is_subplot_supported() = is_subplot_supported(backend())
+is_string_supported() = is_string_supported(backend())
+nativeImagesSupported() = nativeImagesSupported(backend())
+
+# ---------------------------------------------------------
+
+# 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
+    v
+end

src/backends/bokeh.jl

@@ -0,0 +1,208 @@
+
+# https://github.com/bokeh/Bokeh.jl
+
+
+supported_args(::BokehBackend) = merge_with_base_supported([
+    # :annotations,
+    # :axis,
+    # :background_color,
+    :linecolor,
+    # :color_palette,
+    # :fillrange,
+    # :fillcolor,
+    # :fillalpha,
+    # :foreground_color,
+    :group,
+    # :label,
+    # :layout,
+    # :legend,
+    :seriescolor, :seriesalpha,
+    :linestyle,
+    :seriestype,
+    :linewidth,
+    # :linealpha,
+    :markershape,
+    :markercolor,
+    :markersize,
+    # :markeralpha,
+    # :markerstrokewidth,
+    # :markerstrokecolor,
+    # :markerstrokestyle,
+    # :n,
+    # :bins,
+    # :nc,
+    # :nr,
+    # :pos,
+    # :smooth,
+    # :show,
+    :size,
+    :title,
+    # :window_title,
+    :x,
+    # :xguide,
+    # :xlims,
+    # :xticks,
+    :y,
+    # :yguide,
+    # :ylims,
+    # :yrightlabel,
+    # :yticks,
+    # :xscale,
+    # :yscale,
+    # :xflip,
+    # :yflip,
+    # :z,
+    # :tickfont,
+    # :guidefont,
+    # :legendfont,
+    # :grid,
+    # :surface,
+    # :levels,
+  ])
+supported_types(::BokehBackend) = [:path, :scatter]
+supported_styles(::BokehBackend) = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
+supported_markers(::BokehBackend) = [:none, :auto, :circle, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5]
+supported_scales(::BokehBackend) = [:identity, :ln]
+is_subplot_supported(::BokehBackend) = false
+
+
+# --------------------------------------------------------------------------------------
+
+
+
+function _initialize_backend(::BokehBackend; kw...)
+  @eval begin
+    warn("Bokeh is no longer supported... many features will likely be broken.")
+    import Bokeh
+    export Bokeh
+  end
+end
+
+
+const _glyphtypes = KW(
+    :circle    => :Circle,
+    :rect       => :Square,
+    :diamond    => :Diamond,
+    :utriangle  => :Triangle,
+    :dtriangle  => :InvertedTriangle,
+    # :pentagon   =>
+    # :hexagon    =>
+    # :heptagon   =>
+    # :octagon    =>
+    :cross      => :Cross,
+    :xcross     => :X,
+    :star5      => :Asterisk,
+  )
+
+
+function bokeh_glyph_type(d::KW)
+  st = d[:seriestype]
+  mt = d[:markershape]
+  if st == :scatter && mt == :none
+    mt = :circle
+  end
+
+  # if we have a marker, use that
+  if st == :scatter || mt != :none
+    return _glyphtypes[mt]
+  end
+
+  # otherwise return a line
+  return :Line
+end
+
+function get_stroke_vector(linestyle::Symbol)
+  dash = 12
+  dot = 3
+  gap = 2
+  linestyle == :solid && return Int[]
+  linestyle == :dash && return Int[dash, gap]
+  linestyle == :dot && return Int[dot, gap]
+  linestyle == :dashdot && return Int[dash, gap, dot, gap]
+  linestyle == :dashdotdot && return Int[dash, gap, dot, gap, dot, gap]
+  error("unsupported linestyle: ", linestyle)
+end
+
+# ---------------------------------------------------------------------------
+
+# function _create_plot(pkg::BokehBackend, d::KW)
+function _create_backend_figure(plt::Plot{BokehBackend})
+  # TODO: create the window/canvas/context that is the plot within the backend (call it `o`)
+  # TODO: initialize the plot... title, xlabel, bgcolor, etc
+
+  datacolumns = Bokeh.BokehDataSet[]
+  tools = Bokeh.tools()
+  filename = tempname() * ".html"
+  title = plt.attr[:title]
+  w, h = plt.attr[:size]
+  xaxis_type = plt.attr[:xscale] == :log10 ? :log : :auto
+  yaxis_type = plt.attr[:yscale] == :log10 ? :log : :auto
+  # legend = plt.attr[:legend] ? xxxx : nothing
+  legend = nothing
+  extra_args = KW()  # TODO: we'll put extra settings (xlim, etc) here
+  Bokeh.Plot(datacolumns, tools, filename, title, w, h, xaxis_type, yaxis_type, legend) #, extra_args)
+
+  # Plot(bplt, pkg, 0, d, KW[])
+end
+
+
+# function _series_added(::BokehBackend, plt::Plot, d::KW)
+function _series_added(plt::Plot{BokehBackend}, series::Series)
+  bdata = Dict{Symbol, Vector}(:x => collect(series.d[:x]), :y => collect(series.d[:y]))
+
+  glyph = Bokeh.Bokehjs.Glyph(
+      glyphtype = bokeh_glyph_type(d),
+      linecolor = webcolor(d[:linecolor]),  # shape's stroke or line color
+      linewidth = d[:linewidth],          # shape's stroke width or line width
+      fillcolor = webcolor(d[:markercolor]),
+      size      = ceil(Int, d[:markersize] * 2.5),  # magic number 2.5 to keep in same scale as other backends
+      dash      = get_stroke_vector(d[:linestyle])
+    )
+
+  legend = nothing  # TODO
+  push!(plt.o.datacolumns, Bokeh.BokehDataSet(bdata, glyph, legend))
+
+  # push!(plt.seriesargs, d)
+  # plt
+end
+
+# ----------------------------------------------------------------
+
+# TODO: override this to update plot items (title, xlabel, etc) after creation
+function _update_plot_object(plt::Plot{BokehBackend}, d::KW)
+end
+
+# ----------------------------------------------------------------
+
+# accessors for x/y data
+
+# function getxy(plt::Plot{BokehBackend}, i::Int)
+#   series = plt.o.datacolumns[i].data
+#   series[:x], series[:y]
+# end
+#
+# function setxy!(plt::Plot{BokehBackend}, xy::Tuple{X,Y}, i::Integer)
+#   series = plt.o.datacolumns[i].data
+#   series[:x], series[:y] = xy
+#   plt
+# end
+
+
+
+# ----------------------------------------------------------------
+
+
+# ----------------------------------------------------------------
+
+function Base.writemime(io::IO, ::MIME"image/png", plt::AbstractPlot{BokehBackend})
+  # TODO: write a png to io
+  warn("mime png not implemented")
+end
+
+function Base.display(::PlotsDisplay, plt::Plot{BokehBackend})
+  Bokeh.showplot(plt.o)
+end
+
+# function Base.display(::PlotsDisplay, plt::Subplot{BokehBackend})
+#   # TODO: display/show the subplot
+# end

src/backends/gadfly.jl

@@ -0,0 +1,744 @@
+
+# https://github.com/dcjones/Gadfly.jl
+
+
+supported_args(::GadflyBackend) = merge_with_base_supported([
+    :annotations,
+    :background_color, :foreground_color, :color_palette,
+    :group, :label, :seriestype,
+    :seriescolor, :seriesalpha,
+    :linecolor, :linestyle, :linewidth, :linealpha,
+    :markershape, :markercolor, :markersize, :markeralpha,
+    :markerstrokewidth, :markerstrokecolor, :markerstrokealpha,
+    :fillrange, :fillcolor, :fillalpha,
+    :bins, :n, :nc, :nr, :layout, :smooth,
+    :title, :window_title, :show, :size,
+    :x, :xguide, :xlims, :xticks, :xscale, :xflip,
+    :y, :yguide, :ylims, :yticks, :yscale, :yflip,
+    :z,
+    :tickfont, :guidefont, :legendfont,
+    :grid, :legend, :colorbar,
+    :marker_z, :levels,
+    :xerror, :yerror,
+    :ribbon, :quiver,
+    :orientation,
+  ])
+supported_types(::GadflyBackend) = [
+        :path,
+        :scatter, :hexbin,
+        :bar,
+        :contour, :shape
+    ]
+supported_styles(::GadflyBackend) = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
+supported_markers(::GadflyBackend) = vcat(_allMarkers, Shape)
+supported_scales(::GadflyBackend) = [:identity, :ln, :log2, :log10, :asinh, :sqrt]
+is_subplot_supported(::GadflyBackend) = true
+
+
+# --------------------------------------------------------------------------------------
+
+function _initialize_backend(::GadflyBackend; kw...)
+    @eval begin
+        import Gadfly, Compose
+        export Gadfly, Compose
+        include(joinpath(Pkg.dir("Plots"), "src", "backends", "gadfly_shapes.jl"))
+    end
+end
+
+# ---------------------------------------------------------------------------
+
+# immutable MissingVec <: AbstractVector{Float64} end
+# Base.size(v::MissingVec) = (1,)
+# Base.getindex(v::MissingVec, i::Integer) = 0.0
+
+function createGadflyPlotObject(d::KW)
+    gplt = Gadfly.Plot()
+    gplt.mapping = Dict()
+    gplt.data_source = Gadfly.DataFrames.DataFrame()
+    # gplt.layers = gplt.layers[1:0]
+    gplt.layers = [Gadfly.layer(Gadfly.Geom.point(tag=:remove), x=zeros(1), y=zeros(1));] # x=MissingVec(), y=MissingVec());]
+    gplt.guides = Gadfly.GuideElement[Gadfly.Guide.xlabel(d[:xguide]),
+                                   Gadfly.Guide.ylabel(d[:yguide]),
+                                   Gadfly.Guide.title(d[:title])]
+    gplt
+end
+
+# ---------------------------------------------------------------------------
+
+
+function getLineGeom(d::KW)
+    st = d[:seriestype]
+    xbins, ybins = maketuple(d[:bins])
+    if st == :hexb
+        Gadfly.Geom.hexbin(xbincount = xbins, ybincount = ybins)
+    elseif st == :histogram2d
+        Gadfly.Geom.histogram2d(xbincount = xbins, ybincount = ybins)
+    elseif st == :histogram
+        Gadfly.Geom.histogram(bincount = xbins,
+                              orientation = isvertical(d) ? :vertical : :horizontal,
+                              position = d[:bar_position] == :stack ? :stack : :dodge)
+    elseif st == :path
+        Gadfly.Geom.path
+    elseif st in (:bar, :sticks)
+        Gadfly.Geom.bar
+    elseif st == :steppost
+        Gadfly.Geom.step
+    elseif st == :steppre
+        Gadfly.Geom.step(direction = :vh)
+    elseif st == :hline
+        Gadfly.Geom.hline
+    elseif st == :vline
+        Gadfly.Geom.vline
+    elseif st == :contour
+        Gadfly.Geom.contour(levels = d[:levels])
+    # elseif st == :shape
+    #     Gadfly.Geom.polygon(fill = true, preserve_order = true)
+    else
+        nothing
+    end
+end
+
+function get_extra_theme_args(d::KW, k::Symbol)
+    # gracefully handles old Gadfly versions
+    extra_theme_args = KW()
+    try
+        extra_theme_args[:line_style] = Gadfly.get_stroke_vector(d[k])
+    catch err
+        if string(err) == "UndefVarError(:get_stroke_vector)"
+            Base.warn_once("Gadfly.get_stroke_vector failed... do you have an old version of Gadfly?")
+        else
+            rethrow()
+        end
+    end
+    extra_theme_args
+end
+
+function getGadflyLineTheme(d::KW)
+    st = d[:seriestype]
+    lc = convertColor(getColor(d[:linecolor]), d[:linealpha])
+    fc = convertColor(getColor(d[:fillcolor]), d[:fillalpha])
+
+    Gadfly.Theme(;
+        default_color = (st in (:histogram,:histogram2d,:hexbin,:bar,:sticks) ? fc : lc),
+        line_width = (st == :sticks ? 1 : d[:linewidth]) * Gadfly.px,
+        # line_style = Gadfly.get_stroke_vector(d[:linestyle]),
+        lowlight_color = x->RGB(fc),  # fill/ribbon
+        lowlight_opacity = alpha(fc), # fill/ribbon
+        bar_highlight = RGB(lc),      # bars
+        get_extra_theme_args(d, :linestyle)...
+    )
+end
+
+# add a line as a new layer
+function addGadflyLine!(plt::Plot, numlayers::Int, d::KW, geoms...)
+    gplt = getGadflyContext(plt)
+    gfargs = vcat(geoms..., getGadflyLineTheme(d))
+    kwargs = KW()
+    st = d[:seriestype]
+
+    # add a fill?
+    if d[:fillrange] != nothing && st != :contour
+        fillmin, fillmax = map(makevec, maketuple(d[:fillrange]))
+        nmin, nmax = length(fillmin), length(fillmax)
+        kwargs[:ymin] = Float64[min(y, fillmin[mod1(i, nmin)], fillmax[mod1(i, nmax)]) for (i,y) in enumerate(d[:y])]
+        kwargs[:ymax] = Float64[max(y, fillmin[mod1(i, nmin)], fillmax[mod1(i, nmax)]) for (i,y) in enumerate(d[:y])]
+        push!(gfargs, Gadfly.Geom.ribbon)
+    end
+
+    if st in (:hline, :vline)
+        kwargs[st == :hline ? :yintercept : :xintercept] = d[:y]
+
+    else
+        if st == :sticks
+            w = 0.01 * mean(diff(d[:x]))
+            kwargs[:xmin] = d[:x] - w
+            kwargs[:xmax] = d[:x] + w
+        elseif st == :contour
+            kwargs[:z] = d[:z].surf
+            addGadflyContColorScale(plt, d[:linecolor])
+        end
+
+        kwargs[:x] = d[st == :histogram ? :y : :x]
+        kwargs[:y] = d[:y]
+
+    end
+
+    # # add the layer
+    Gadfly.layer(gfargs...; order=numlayers, kwargs...)
+end
+
+
+# ---------------------------------------------------------------------------
+
+get_shape(sym::Symbol) = _shapes[sym]
+get_shape(shape::Shape) = shape
+
+# extract the underlying ShapeGeometry object(s)
+getMarkerGeom(shapes::AVec) = gadflyshape(map(get_shape, shapes))
+getMarkerGeom(other) = gadflyshape(get_shape(other))
+
+# getMarkerGeom(shape::Shape) = gadflyshape(shape)
+# getMarkerGeom(shape::Symbol) = gadflyshape(_shapes[shape])
+# getMarkerGeom(shapes::AVec) = gadflyshape(map(gadflyshape, shapes)) # map(getMarkerGeom, shapes)
+function getMarkerGeom(d::KW)
+    if d[:seriestype] == :shape
+        Gadfly.Geom.polygon(fill = true, preserve_order = true)
+    else
+        getMarkerGeom(d[:markershape])
+    end
+end
+
+function getGadflyMarkerTheme(d::KW, attr::KW)
+    c = getColor(d[:markercolor])
+    α = d[:markeralpha]
+    if α != nothing
+        c = RGBA(RGB(c), α)
+    end
+
+    ms = d[:markersize]
+    ms = if typeof(ms) <: AVec
+        warn("Gadfly doesn't support variable marker sizes... using the average: $(mean(ms))")
+        mean(ms) * Gadfly.px
+    else
+        ms * Gadfly.px
+    end
+
+    Gadfly.Theme(;
+        default_color = c,
+        default_point_size = ms,
+        discrete_highlight_color = c -> RGB(getColor(d[:markerstrokecolor])),
+        highlight_width = d[:markerstrokewidth] * Gadfly.px,
+        line_width = d[:markerstrokewidth] * Gadfly.px,
+        # get_extra_theme_args(d, :markerstrokestyle)...
+    )
+end
+
+function addGadflyContColorScale(plt::Plot{GadflyBackend}, c)
+    plt.attr[:colorbar] == :none && return
+    if !isa(c, ColorGradient)
+        c = default_gradient()
+    end
+    push!(getGadflyContext(plt).scales, Gadfly.Scale.ContinuousColorScale(p -> RGB(getColorZ(c, p))))
+end
+
+function addGadflyMarker!(plt::Plot, numlayers::Int, d::KW, attr::KW, geoms...)
+    gfargs = vcat(geoms..., getGadflyMarkerTheme(d, attr), getMarkerGeom(d))
+    kwargs = KW()
+
+    # handle continuous color scales for the markers
+    zcolor = d[:marker_z]
+    if zcolor != nothing && typeof(zcolor) <: AVec
+        kwargs[:color] = zcolor
+        addGadflyContColorScale(plt, d[:markercolor])
+    end
+
+    Gadfly.layer(gfargs...; x = d[:x], y = d[:y], order=numlayers, kwargs...)
+end
+
+
+# ---------------------------------------------------------------------------
+
+function addToGadflyLegend(plt::Plot, d::KW)
+    if plt.attr[:legend] != :none && d[:label] != ""
+        gplt = getGadflyContext(plt)
+
+        # add the legend if needed
+        if all(g -> !isa(g, Gadfly.Guide.ManualColorKey), gplt.guides)
+            unshift!(gplt.guides, Gadfly.Guide.manual_color_key("", @compat(AbstractString)[], Color[]))
+        end
+
+        # now add the series to the legend
+        for guide in gplt.guides
+            if isa(guide, Gadfly.Guide.ManualColorKey)
+                # TODO: there's a BUG in gadfly if you pass in the same color more than once,
+                # since gadfly will call unique(colors), but doesn't also merge the rows that match
+                # Should ensure from this side that colors which are the same are merged together
+
+                c = getColor(d[d[:markershape] == :none ? :linecolor : :markercolor])
+                foundit = false
+
+                # extend the label if we found this color
+                for i in 1:length(guide.colors)
+                    if RGB(c) == guide.colors[i]
+                        guide.labels[i] *= ", " * d[:label]
+                        foundit = true
+                    end
+                end
+
+                # didn't find the color, so add a new entry into the legend
+                if !foundit
+                    push!(guide.labels, d[:label])
+                    push!(guide.colors, c)
+                end
+            end
+        end
+    end
+end
+
+getGadflySmoothing(smooth::Bool) = smooth ? [Gadfly.Geom.smooth(method=:lm)] : Any[]
+getGadflySmoothing(smooth::Real) = [Gadfly.Geom.smooth(method=:loess, smoothing=float(smooth))]
+
+
+function addGadflySeries!(plt::Plot, d::KW)
+    layers = Gadfly.Layer[]
+    gplt = getGadflyContext(plt)
+
+    # add a regression line?
+    # TODO: make more flexible
+    smooth = getGadflySmoothing(d[:smooth])
+
+    # lines
+    geom = getLineGeom(d)
+    if geom != nothing
+        prepend!(layers, addGadflyLine!(plt, length(gplt.layers), d, geom, smooth...))
+        smooth = Any[] # don't add a regression for markers too
+    end
+
+    # special handling for ohlc and scatter
+    st = d[:seriestype]
+    # if st == :ohlc
+    #     error("Haven't re-implemented after refactoring")
+    if st in (:histogram2d, :hexbin) && (isa(d[:fillcolor], ColorGradient) || isa(d[:fillcolor], ColorFunction))
+        push!(gplt.scales, Gadfly.Scale.ContinuousColorScale(p -> RGB(getColorZ(d[:fillcolor], p))))
+    elseif st == :scatter && d[:markershape] == :none
+        d[:markershape] = :circle
+    end
+
+    # markers
+    if d[:markershape] != :none || st == :shape
+        prepend!(layers, addGadflyMarker!(plt, length(gplt.layers), d, plt.attr, smooth...))
+    end
+
+    st in (:histogram2d, :hexbin, :contour) || addToGadflyLegend(plt, d)
+
+    # now save the layers that apply to this series
+    d[:gadflylayers] = layers
+    prepend!(gplt.layers, layers)
+end
+
+
+# ---------------------------------------------------------------------------
+
+# NOTE: I'm leaving this here and commented out just in case I want to implement again... it was hacky code to create multi-colored line segments
+
+#   # colorgroup
+#   z = d[:z]
+
+#   # handle line segments of different colors
+#   cscheme = d[:linecolor]
+#   if isa(cscheme, ColorVector)
+#     # create a color scale, and set the color group to the index of the color
+#     push!(gplt.scales, Gadfly.Scale.color_discrete_manual(cscheme.v...))
+
+#     # this is super weird, but... oh well... for some reason this creates n separate line segments...
+#     # create a list of vertices that go: [x1,x2,x2,x3,x3, ... ,xi,xi, ... xn,xn] (same for y)
+#     # then the vector passed to the "color" keyword should be a vector: [1,1,2,2,3,3,4,4, ..., i,i, ... , n,n]
+#     csindices = Int[mod1(i,length(cscheme.v)) for i in 1:length(d[:y])]
+#     cs = collect(repmat(csindices', 2, 1))[1:end-1]
+#     grp = collect(repmat((1:length(d[:y]))', 2, 1))[1:end-1]
+#     d[:x], d[:y] = map(createSegments, (d[:x], d[:y]))
+#     colorgroup = [(:linecolor, cs), (:group, grp)]
+
+
+# ---------------------------------------------------------------------------
+
+
+function addGadflyTicksGuide(gplt, ticks, isx::Bool)
+    ticks == :auto && return
+
+    # remove the ticks?
+    if ticks in (:none, false, nothing)
+        return addOrReplace(gplt.guides, isx ? Gadfly.Guide.xticks : Gadfly.Guide.yticks; label=false)
+    end
+
+    ttype = ticksType(ticks)
+
+    # just the values... put ticks here, but use standard labels
+    if ttype == :ticks
+        gtype = isx ? Gadfly.Guide.xticks : Gadfly.Guide.yticks
+        replaceType(gplt.guides, gtype(ticks = collect(ticks)))
+
+    # set the ticks and the labels
+    # Note: this is pretty convoluted, but I think it works.  We set the ticks using Gadfly.Guide,
+    #   and then set the label function (wraps a dict lookup) through a continuous Gadfly.Scale.
+    elseif ttype == :ticks_and_labels
+        gtype = isx ? Gadfly.Guide.xticks : Gadfly.Guide.yticks
+        replaceType(gplt.guides, gtype(ticks = collect(ticks[1])))
+
+        # # TODO add xtick_label function (given tick, return label??)
+        # # Scale.x_discrete(; labels=nothing, levels=nothing, order=nothing)
+        # filterGadflyScale(gplt, isx)
+        # gfunc = isx ? Gadfly.Scale.x_discrete : Gadfly.Scale.y_discrete
+        # labelmap = Dict(zip(ticks...))
+        # labelfunc = val -> labelmap[val]
+        # push!(gplt.scales, gfunc(levels = collect(ticks[1]), labels = labelfunc))
+
+        filterGadflyScale(gplt, isx)
+        gfunc = isx ? Gadfly.Scale.x_continuous : Gadfly.Scale.y_continuous
+        labelmap = Dict(zip(ticks...))
+        labelfunc = val -> labelmap[val]
+        push!(gplt.scales, gfunc(labels = labelfunc))
+
+    else
+        error("Invalid input for $(isx ? "xticks" : "yticks"): ", ticks)
+    end
+end
+
+continuousAndSameAxis(scale, isx::Bool) = isa(scale, Gadfly.Scale.ContinuousScale) && scale.vars[1] == (isx ? :x : :y)
+filterGadflyScale(gplt, isx::Bool) = filter!(scale -> !continuousAndSameAxis(scale, isx), gplt.scales)
+
+
+function getGadflyScaleFunction(d::KW, isx::Bool)
+    scalekey = isx ? :xscale : :yscale
+    hasScaleKey = haskey(d, scalekey)
+    if hasScaleKey
+        scale = d[scalekey]
+        scale == :ln && return isx ? Gadfly.Scale.x_log : Gadfly.Scale.y_log, hasScaleKey, log
+        scale == :log2 && return isx ? Gadfly.Scale.x_log2 : Gadfly.Scale.y_log2, hasScaleKey, log2
+        scale == :log10 && return isx ? Gadfly.Scale.x_log10 : Gadfly.Scale.y_log10, hasScaleKey, log10
+        scale == :asinh && return isx ? Gadfly.Scale.x_asinh : Gadfly.Scale.y_asinh, hasScaleKey, asinh
+        scale == :sqrt && return isx ? Gadfly.Scale.x_sqrt : Gadfly.Scale.y_sqrt, hasScaleKey, sqrt
+    end
+    isx ? Gadfly.Scale.x_continuous : Gadfly.Scale.y_continuous, hasScaleKey, identity
+end
+
+
+function addGadflyLimitsScale(gplt, d::KW, isx::Bool)
+    gfunc, hasScaleKey, func = getGadflyScaleFunction(d, isx)
+
+    # do we want to add min/max limits for the axis?
+    limsym = isx ? :xlims : :ylims
+    limargs = Any[]
+
+    # map :auto to nothing, otherwise add to limargs
+    lims = get(d, limsym, :auto)
+    if lims == :auto
+        lims = nothing
+    else
+        if limsType(lims) == :limits
+            push!(limargs, (:minvalue, min(lims...)))
+            push!(limargs, (:maxvalue, max(lims...)))
+        else
+            error("Invalid input for $(isx ? "xlims" : "ylims"): ", lims)
+        end
+    end
+
+    # replace any current scales with this one
+    if hasScaleKey || !isempty(limargs)
+        filterGadflyScale(gplt, isx)
+        push!(gplt.scales, gfunc(; limargs...))
+    end
+
+    lims, func
+end
+
+function updateGadflyAxisFlips(gplt, d::KW, xlims, ylims, xfunc, yfunc)
+    if isa(gplt.coord, Gadfly.Coord.Cartesian)
+        gplt.coord = Gadfly.Coord.cartesian(
+            gplt.coord.xvars,
+            gplt.coord.yvars;
+            xmin = xlims == nothing ? gplt.coord.xmin : xfunc(minimum(xlims)),
+            xmax = xlims == nothing ? gplt.coord.xmax : xfunc(maximum(xlims)),
+            ymin = ylims == nothing ? gplt.coord.ymin : yfunc(minimum(ylims)),
+            ymax = ylims == nothing ? gplt.coord.ymax : yfunc(maximum(ylims)),
+            xflip = get(d, :xflip, gplt.coord.xflip),
+            yflip = get(d, :yflip, gplt.coord.yflip),
+            fixed = gplt.coord.fixed,
+            aspect_ratio = gplt.coord.aspect_ratio,
+            raster = gplt.coord.raster
+        )
+    else
+        gplt.coord = Gadfly.Coord.Cartesian(
+            xflip = get(d, :xflip, false),
+            yflip = get(d, :yflip, false)
+        )
+    end
+end
+
+
+function findGuideAndSet(gplt, t::DataType, args...; kw...) #s::@compat(AbstractString))
+    for (i,guide) in enumerate(gplt.guides)
+        if isa(guide, t)
+            gplt.guides[i] = t(args...; kw...)
+        end
+    end
+end
+
+function updateGadflyGuides(plt::Plot, d::KW)
+    gplt = getGadflyContext(plt)
+    haskey(d, :title) && findGuideAndSet(gplt, Gadfly.Guide.title, string(d[:title]))
+    haskey(d, :xguide) && findGuideAndSet(gplt, Gadfly.Guide.xlabel, string(d[:xguide]))
+    haskey(d, :yguide) && findGuideAndSet(gplt, Gadfly.Guide.ylabel, string(d[:yguide]))
+
+    xlims, xfunc = addGadflyLimitsScale(gplt, d, true)
+    ylims, yfunc = addGadflyLimitsScale(gplt, d, false)
+
+    ticks = get(d, :xticks, :auto)
+    if ticks == :none
+        _remove_axis(plt, true)
+    else
+        addGadflyTicksGuide(gplt, ticks, true)
+    end
+    ticks = get(d, :yticks, :auto)
+    if ticks == :none
+        _remove_axis(plt, false)
+    else
+        addGadflyTicksGuide(gplt, ticks, false)
+    end
+
+    updateGadflyAxisFlips(gplt, d, xlims, ylims, xfunc, yfunc)
+end
+
+function updateGadflyPlotTheme(plt::Plot, d::KW)
+    kwargs = KW()
+
+    # colors
+    insidecolor, gridcolor, textcolor, guidecolor, legendcolor =
+        map(s -> getColor(d[s]), (
+            :background_color_inside,
+            :foreground_color_grid,
+            :foreground_color_text,
+            :foreground_color_guide,
+            :foreground_color_legend
+        ))
+
+    # # hide the legend?
+    leg = d[d[:legend] == :none ? :colorbar : :legend]
+    if leg != :best
+        kwargs[:key_position] = leg == :inside ? :right : leg
+    end
+
+    if !get(d, :grid, true)
+        kwargs[:grid_color] = gridcolor
+    end
+
+    # fonts
+    tfont, gfont, lfont = d[:tickfont], d[:guidefont], d[:legendfont]
+
+    getGadflyContext(plt).theme = Gadfly.Theme(;
+        background_color = insidecolor,
+        minor_label_color = textcolor,
+        minor_label_font = tfont.family,
+        minor_label_font_size = tfont.pointsize * Gadfly.pt,
+        major_label_color = guidecolor,
+        major_label_font = gfont.family,
+        major_label_font_size = gfont.pointsize * Gadfly.pt,
+        key_title_color = guidecolor,
+        key_title_font = gfont.family,
+        key_title_font_size = gfont.pointsize * Gadfly.pt,
+        key_label_color = legendcolor,
+        key_label_font = lfont.family,
+        key_label_font_size = lfont.pointsize * Gadfly.pt,
+        plot_padding = 1 * Gadfly.mm,
+        kwargs...
+    )
+end
+
+# ----------------------------------------------------------------
+
+
+function createGadflyAnnotationObject(x, y, val::@compat(AbstractString))
+    Gadfly.Guide.annotation(Compose.compose(
+                              Compose.context(),
+                              Compose.text(x, y, val)
+                            ))
+end
+
+function createGadflyAnnotationObject(x, y, txt::PlotText)
+    halign = (txt.font.halign == :hcenter ? Compose.hcenter : (txt.font.halign == :left ? Compose.hleft : Compose.hright))
+    valign = (txt.font.valign == :vcenter ? Compose.vcenter : (txt.font.valign == :top ? Compose.vtop : Compose.vbottom))
+    rotations = (txt.font.rotation == 0.0 ? [] : [Compose.Rotation(txt.font.rotation, Compose.Point(Compose.x_measure(x), Compose.y_measure(y)))])
+    Gadfly.Guide.annotation(Compose.compose(
+                              Compose.context(),
+                              Compose.text(x, y, txt.str, halign, valign, rotations...),
+                              Compose.font(string(txt.font.family)),
+                              Compose.fontsize(txt.font.pointsize * Gadfly.pt),
+                              Compose.stroke(txt.font.color),
+                              Compose.fill(txt.font.color)
+                            ))
+end
+
+function _add_annotations{X,Y,V}(plt::Plot{GadflyBackend}, anns::AVec{@compat(Tuple{X,Y,V})})
+    for ann in anns
+        push!(plt.o.guides, createGadflyAnnotationObject(ann...))
+    end
+end
+
+
+# ---------------------------------------------------------------------------
+
+# create a blank Gadfly.Plot object
+# function _create_plot(pkg::GadflyBackend, d::KW)
+#     gplt = createGadflyPlotObject(d)
+#     Plot(gplt, pkg, 0, d, KW[])
+# end
+function _create_backend_figure(plt::Plot{GadflyBackend})
+    createGadflyPlotObject(plt.attr)
+end
+
+
+# plot one data series
+# function _series_added(::GadflyBackend, plt::Plot, d::KW)
+function _series_added(plt::Plot{GadflyBackend}, series::Series)
+    # first clear out the temporary layer
+    gplt = getGadflyContext(plt)
+    if gplt.layers[1].geom.tag == :remove
+        gplt.layers = gplt.layers[2:end]
+    end
+
+    addGadflySeries!(plt, series.d)
+    # push!(plt.seriesargs, d)
+    # plt
+end
+
+
+
+function _update_plot_object(plt::Plot{GadflyBackend}, d::KW)
+    updateGadflyGuides(plt, d)
+    updateGadflyPlotTheme(plt, d)
+end
+
+
+# ----------------------------------------------------------------
+
+# accessors for x/y data
+
+# TODO: need to save all the layer indices which apply to this series
+function getGadflyMappings(plt::Plot, i::Integer)
+    @assert i > 0 && i <= plt.n
+    mappings = [l.mapping for l in plt.seriesargs[i][:gadflylayers]]
+end
+
+function getxy(plt::Plot{GadflyBackend}, i::Integer)
+    mapping = getGadflyMappings(plt, i)[1]
+    mapping[:x], mapping[:y]
+end
+
+function setxy!{X,Y}(plt::Plot{GadflyBackend}, xy::Tuple{X,Y}, i::Integer)
+    for mapping in getGadflyMappings(plt, i)
+        mapping[:x], mapping[:y] = xy
+    end
+    plt
+end
+
+# ----------------------------------------------------------------
+
+
+# # create the underlying object (each backend will do this differently)
+# function _create_subplot(subplt::Subplot{GadflyBackend}, isbefore::Bool)
+#     isbefore && return false # wait until after plotting to create the subplots
+#     subplt.o = nothing
+#     true
+# end
+
+
+function _remove_axis(plt::Plot{GadflyBackend}, isx::Bool)
+    gplt = getGadflyContext(plt)
+    addOrReplace(gplt.guides, isx ? Gadfly.Guide.xticks : Gadfly.Guide.yticks; label=false)
+    addOrReplace(gplt.guides, isx ? Gadfly.Guide.xlabel : Gadfly.Guide.ylabel, "")
+end
+
+function _expand_limits(lims, plt::Plot{GadflyBackend}, isx::Bool)
+    for l in getGadflyContext(plt).layers
+        _expand_limits(lims, l.mapping[isx ? :x : :y])
+    end
+end
+
+
+# ----------------------------------------------------------------
+
+
+getGadflyContext(plt::Plot{GadflyBackend}) = plt.o
+# getGadflyContext(subplt::Subplot{GadflyBackend}) = buildGadflySubplotContext(subplt)
+
+# # create my Compose.Context grid by hstacking and vstacking the Gadfly.Plot objects
+# function buildGadflySubplotContext(subplt::Subplot)
+#     rows = Any[]
+#     row = Any[]
+#     for (i,(r,c)) in enumerate(subplt.layout)
+#
+#         # add the Plot object to the row
+#         push!(row, getGadflyContext(subplt.plts[i]))
+#
+#         # add the row
+#         if c == ncols(subplt.layout, r)
+#             push!(rows, Gadfly.hstack(row...))
+#             row = Any[]
+#         end
+#     end
+#
+#     # stack the rows
+#     Gadfly.vstack(rows...)
+# end
+
+setGadflyDisplaySize(w,h) = Compose.set_default_graphic_size(w * Compose.px, h * Compose.px)
+setGadflyDisplaySize(plt::Plot) = setGadflyDisplaySize(plt.attr[:size]...)
+# setGadflyDisplaySize(subplt::Subplot) = setGadflyDisplaySize(getattr(subplt, 1)[:size]...)
+# -------------------------------------------------------------------------
+
+
+function dowritemime{P<:Union{GadflyBackend,ImmerseBackend}}(io::IO, func, plt::AbstractPlot{P})
+    gplt = getGadflyContext(plt)
+    setGadflyDisplaySize(plt)
+    Gadfly.draw(func(io, Compose.default_graphic_width, Compose.default_graphic_height), gplt)
+end
+
+getGadflyWriteFunc(::MIME"image/png") = Gadfly.PNG
+getGadflyWriteFunc(::MIME"image/svg+xml") = Gadfly.SVG
+# getGadflyWriteFunc(::MIME"text/html") = Gadfly.SVGJS
+getGadflyWriteFunc(::MIME"application/pdf") = Gadfly.PDF
+getGadflyWriteFunc(::MIME"application/postscript") = Gadfly.PS
+getGadflyWriteFunc(::MIME"application/x-tex") = Gadfly.PGF
+getGadflyWriteFunc(m::MIME) = error("Unsupported in Gadfly/Immerse: ", m)
+
+for mime in (MIME"image/png", MIME"image/svg+xml", MIME"application/pdf", MIME"application/postscript", MIME"application/x-tex")
+    @eval function Base.writemime{P<:Union{GadflyBackend,ImmerseBackend}}(io::IO, ::$mime, plt::AbstractPlot{P})
+        func = getGadflyWriteFunc($mime())
+        dowritemime(io, func, plt)
+    end
+end
+
+
+
+function Base.display(::PlotsDisplay, plt::Plot{GadflyBackend})
+    setGadflyDisplaySize(plt.attr[:size]...)
+    display(plt.o)
+end
+
+
+# function Base.display(::PlotsDisplay, subplt::Subplot{GadflyBackend})
+#     setGadflyDisplaySize(getattr(subplt,1)[:size]...)
+#     ctx = buildGadflySubplotContext(subplt)
+#
+#     # taken from Gadfly since I couldn't figure out how to do it directly
+#
+#     filename = string(Gadfly.tempname(), ".html")
+#     output = open(filename, "w")
+#
+#     plot_output = IOBuffer()
+#     Gadfly.draw(Gadfly.SVGJS(plot_output, Compose.default_graphic_width,
+#              Compose.default_graphic_height, false), ctx)
+#     plotsvg = takebuf_string(plot_output)
+#
+#     write(output,
+#       """
+#       <!DOCTYPE html>
+#       <html>
+#         <head>
+#           <title>Gadfly Plot</title>
+#           <meta charset="utf-8">
+#         </head>
+#           <body>
+#           <script charset="utf-8">
+#               $(readall(Compose.snapsvgjs))
+#           </script>
+#           <script charset="utf-8">
+#               $(readall(Gadfly.gadflyjs))
+#           </script>
+#           $(plotsvg)
+#         </body>
+#       </html>
+#       """)
+#     close(output)
+#     Gadfly.open_file(filename)
+# end

src/backends/gadfly_shapes.jl

@@ -0,0 +1,93 @@
+
+
+# Geometry which displays arbitrary shapes at given (x, y) positions.
+# note: vertices is a list of shapes
+immutable ShapeGeometry <: Gadfly.GeometryElement
+    vertices::AbstractVector #{Tuple{Float64,Float64}}
+    tag::Symbol
+
+    function ShapeGeometry(shape; tag::Symbol=Gadfly.Geom.empty_tag)
+        new(shape, tag)
+    end
+end
+
+# TODO: add for PR
+# const shape = ShapeGeometry
+
+
+function Gadfly.element_aesthetics(::ShapeGeometry)
+    [:x, :y, :size, :color]
+end
+
+
+# Generate a form for a shape geometry.
+#
+# Args:
+#   geom: shape geometry.
+#   theme: the plot's theme.
+#   aes: aesthetics.
+#
+# Returns:
+#   A compose Form.
+#
+function Gadfly.render(geom::ShapeGeometry, theme::Gadfly.Theme, aes::Gadfly.Aesthetics)
+
+    # TODO: add for PR
+    # Gadfly.assert_aesthetics_defined("Geom.shape", aes, :x, :y)
+    # Gadfly.assert_aesthetics_equal_length("Geom.shape", aes,
+    #                                       element_aesthetics(geom)...)
+
+    default_aes = Gadfly.Aesthetics()
+    default_aes.color = Gadfly.DataFrames.PooledDataArray(RGBA{Float32}[theme.default_color])
+    default_aes.size = Compose.Measure[theme.default_point_size]
+    aes = Gadfly.inherit(aes, default_aes)
+
+    lw_hover_scale = 10
+    lw_ratio = theme.line_width / aes.size[1]
+
+    aes_x, aes_y = Gadfly.concretize(aes.x, aes.y)
+
+    ctx = Compose.compose!(
+        Compose.context(),
+        make_polygon(geom, aes.x, aes.y, aes.size),
+        Compose.fill(aes.color),
+        Compose.linewidth(theme.highlight_width))
+
+    if aes.color_key_continuous != nothing && aes.color_key_continuous
+        Compose.compose!(ctx,
+            Compose.stroke(map(theme.continuous_highlight_color, aes.color)))
+    else
+        Compose.compose!(ctx,
+            Compose.stroke(map(theme.discrete_highlight_color, aes.color)),
+            Compose.svgclass([Gadfly.svg_color_class_from_label(Gadfly.escape_id(aes.color_label([c])[1]))
+                      for c in aes.color]))
+    end
+
+    return Compose.compose!(Compose.context(order=4), Compose.svgclass("geometry"), ctx)
+end
+
+function gadflyshape(sv::Shape)
+  ShapeGeometry(Any[vertices(sv)])
+end
+
+function gadflyshape(sv::AVec{Shape})
+    ShapeGeometry(Any[vertices(s) for s in sv])
+end
+
+
+# create a Compose context given a ShapeGeometry and the xs/ys/sizes
+function make_polygon(geom::ShapeGeometry, xs::AbstractArray, ys::AbstractArray, rs::AbstractArray)
+  n = max(length(xs), length(ys), length(rs))
+  T = Tuple{Compose.Measure, Compose.Measure}
+  polys = Array(Vector{T}, n)
+  for i in 1:n
+    x = Compose.x_measure(xs[mod1(i, length(xs))])
+    y = Compose.y_measure(ys[mod1(i, length(ys))])
+    r = rs[mod1(i, length(rs))]
+    polys[i] = T[(x + r * sx, y + r * sy) for (sx,sy) in cycle(geom.vertices, i)]
+  end
+  Gadfly.polygon(polys, geom.tag)
+end
+
+
+# ---------------------------------------------------------------------------------------------

src/backends/glvisualize.jl

@@ -0,0 +1,298 @@
+
+
+# [WEBSITE]
+
+supported_args(::GLVisualizeBackend) = merge_with_base_supported([
+    # :annotations,
+    # :background_color_legend, :background_color_inside, :background_color_outside,
+    # :foreground_color_grid, :foreground_color_legend, :foreground_color_title,
+    # :foreground_color_axis, :foreground_color_border, :foreground_color_guide, :foreground_color_text,
+    # :label,
+    # :linecolor, :linestyle, :linewidth, :linealpha,
+    # :markershape, :markercolor, :markersize, :markeralpha,
+    # :markerstrokewidth, :markerstrokecolor, :markerstrokealpha,
+    # :fillrange, :fillcolor, :fillalpha,
+    # :bins, :bar_width, :bar_edges, :bar_position,
+    # :title, :title_location, :titlefont,
+    # :window_title,
+    # :guide, :lims, :ticks, :scale, :flip, :rotation,
+    # :tickfont, :guidefont, :legendfont,
+    # :grid, :legend, :colorbar,
+    # :marker_z, :levels,
+    # :ribbon, :quiver, :arrow,
+    # :orientation,
+    # :overwrite_figure,
+    # :polar,
+    # :normalize, :weights,
+    # :contours, :aspect_ratio,
+    # :match_dimensions,
+    # :clims,
+    # :inset_subplots,
+  ])
+supported_types(::GLVisualizeBackend) = [:surface, :scatter, :scatter3d, :path, :path3d]
+supported_styles(::GLVisualizeBackend) = [:auto, :solid]
+supported_markers(::GLVisualizeBackend) = vcat([:none, :auto, :circle], collect(keys(_gl_marker_map)))
+supported_scales(::GLVisualizeBackend) = [:identity]
+is_subplot_supported(::GLVisualizeBackend) = true
+
+# --------------------------------------------------------------------------------------
+
+
+function _initialize_backend(::GLVisualizeBackend; kw...)
+    @eval begin
+        import GLVisualize, GeometryTypes, GLAbstraction, GLWindow
+        import GeometryTypes: Point2f0, Point3f0, Vec2f0, Vec3f0
+        export GLVisualize
+
+        # TODO: remove this when PlotUtils is registered
+        import PlotUtils
+    end
+end
+
+# ---------------------------------------------------------------------------
+
+# initialize the figure/window
+function _create_backend_figure(plt::Plot{GLVisualizeBackend})
+    # init a screen
+    screen = if isdefined(GLVisualize, :ROOT_SCREEN)
+        GLVisualize.ROOT_SCREEN
+    else
+        s = GLVisualize.glscreen()
+        @async GLVisualize.renderloop(s)
+        s
+    end
+    empty!(screen)
+    screen
+end
+
+# ---------------------------------------------------------------------------
+
+# size as a percentage of the window size
+function gl_relative_size(plt::Plot{GLVisualizeBackend}, msize::Number)
+    winsz = min(plt[:size]...)
+    Float32(msize / winsz)
+end
+
+const _gl_marker_map = KW(
+  :rect => '■',
+  :star5 => '★',
+  :diamond => '◆',
+  :hexagon => '⬢',
+  :cross => '✚',
+  :xcross => '❌',
+  :utriangle => '▲',
+  :dtriangle => '▼',
+  :pentagon => '⬟',
+  :octagon => '⯄',
+  :star4 => '✦',
+  :star6 => '✶',
+  :star8 => '✷',
+  :vline => '┃',
+  :hline => '━',
+)
+
+
+# create a marker/shape type
+function gl_marker(shape::Symbol, msize::Number, _3d::Bool)
+    GeometryTypes.HyperSphere((_3d ? Point3f0 : Point2f0)(0), msize)
+end
+
+gl_color(c::RGBA{Float32}) = c
+
+# convert to RGBA
+function gl_color(c, a=nothing)
+    c = convertColor(c, a)
+    RGBA{Float32}(getColor(c))
+end
+
+function gl_viewport(bb, rect)
+    l, b, bw, bh = bb
+    rw, rh = rect.w, rect.h
+    GLVisualize.SimpleRectangle(
+        round(Int, rect.x + rw * l),
+        round(Int, rect.y + rh * b),
+        round(Int, rw * bw),
+        round(Int, rh * bh)
+    )
+end
+
+gl_make_points(x, y) = Point2f0[Point2f0(x[i], y[i]) for i=1:length(x)]
+gl_make_points(x, y, z) = Point3f0[Point3f0(x[i], y[i], z[i]) for i=1:length(x)]
+
+function gl_draw_lines_2d(x, y, color, linewidth, sp_screen)
+    color = gl_color(color)
+    thickness = Float32(linewidth)
+    for rng in iter_segments(x, y)
+        n = length(rng)
+        n < 2 && continue
+        viz = GLVisualize.visualize(
+            gl_make_points(x[rng], y[rng]),
+            n==2 ? :linesegment : :lines,
+            color=color,
+            thickness = Float32(linewidth)
+        )
+        GLVisualize.view(viz, sp_screen, camera=:orthographic_pixel)
+    end
+end
+
+function gl_draw_lines_3d(x, y, z, color, linewidth, sp_screen)
+    color = gl_color(color)
+    thickness = Float32(linewidth)
+    for rng in iter_segments(x, y, z)
+        n = length(rng)
+        n < 2 && continue
+        viz = GLVisualize.visualize(
+            gl_make_points(x[rng], y[rng], z[rng]),
+            n==2 ? :linesegment : :lines,
+            color=color,
+            thickness = Float32(linewidth)
+        )
+        GLVisualize.view(viz, sp_screen, camera=:perspective)
+    end
+end
+
+function gl_annotate(sp::Subplot{GLVisualizeBackend}, x, y, txt::PlotText)
+end
+
+function gl_draw_axes_2d(sp::Subplot{GLVisualizeBackend})
+    sp_screen = sp.o
+    xaxis = sp[:xaxis]
+    xmin, xmax = axis_limits(xaxis)
+    yaxis = sp[:yaxis]
+    ymin, ymax = axis_limits(yaxis)
+
+    # x axis
+    xsegs, ysegs = Segments(), Segments()
+    ticksz = 0.03*(ymax-ymin)
+    push!(xsegs, [xmin,xmax]); push!(ysegs, [ymin,ymin])
+    for tick in PlotUtils.optimize_ticks(xmin, xmax)[1]
+        push!(xsegs, [tick,tick]); push!(ysegs, [ymin,ymin+ticksz])
+        # TODO: add the ticklabel
+    end
+    gl_draw_lines_2d(xsegs.pts, ysegs.pts, xaxis[:foreground_color_border], 1, sp_screen)
+
+    # y axis
+    xsegs, ysegs = Segments(), Segments()
+    push!(xsegs, [xmin,xmin]); push!(ysegs, [ymin,ymax])
+    for tick in PlotUtils.optimize_ticks(xmin, xmax)[1]
+        push!(xsegs, [xmin,xmin+ticksz]); push!(ysegs, [tick,tick])
+        # TODO: add the ticklabel
+    end
+    gl_draw_lines_2d(xsegs.pts, ysegs.pts, yaxis[:foreground_color_border], 1, sp_screen)
+end
+
+# ---------------------------------------------------------------------------
+
+# draw everything
+function gl_display(plt::Plot{GLVisualizeBackend})
+    screen = plt.o
+    sw, sh = plt[:size]
+    sw, sh = sw*px, sh*px
+    for (name, sp) in plt.spmap
+
+        _3d = is3d(sp)
+        camera = _3d ? :perspective : :orthographic_pixel
+        # camera = :perspective
+
+        # initialize the sub-screen for this subplot
+        # note: we create a lift function to update the size on resize
+        rel_bbox = bbox_to_pcts(bbox(sp), sw, sh)
+        f = rect -> gl_viewport(rel_bbox, rect)
+        sp_screen = GLVisualize.Screen(
+            screen,
+            name = name,
+            area = GLVisualize.const_lift(f, screen.area)
+        )
+
+        sp.o = sp_screen
+        if !is3d(sp)
+            gl_draw_axes_2d(sp)
+        end
+
+        # loop over the series and add them to the subplot
+        for series in series_list(sp)
+            d = series.d
+            st = d[:seriestype]
+            x, y = map(Float32, d[:x]), map(Float32, d[:y])
+            msize = gl_relative_size(plt, d[:markersize])
+
+            viz = if st == :surface
+                # TODO: can pass just the ranges and surface
+                ismatrix(x) || (x = repmat(x', length(y), 1))
+                ismatrix(y) || (y = repmat(y, 1, length(x)))
+                z = transpose_z(d, map(Float32, d[:z].surf), false)
+                viz = GLVisualize.visualize((x, y, z), :surface)
+                GLVisualize.view(viz, sp_screen, camera = :perspective)
+
+            else
+                # paths and scatters
+
+                _3d && (z = map(Float32, d[:z]))
+
+                # paths?
+                lw = d[:linewidth]
+                if lw > 0
+                    c = gl_color(d[:linecolor], d[:linealpha])
+                    if _3d
+                        gl_draw_lines_3d(x, y, z, c, lw, sp_screen)
+                    else
+                        gl_draw_lines_2d(x, y, c, lw, sp_screen)
+                    end
+                end
+                
+                # markers?
+                if st in (:scatter, :scatter3d) || d[:markershape] != :none
+                    extrakw = KW()
+                    c = gl_color(d[:markercolor], d[:markeralpha])
+
+                    # get the marker
+                    shape = d[:markershape] 
+                    shape = get(_gl_marker_map, shape, shape)
+                    marker = if isa(shape, Char)
+                        # extrakw[:scale] = Vec2f0(_3d ? 0.6*d[:markersize] : msize)
+                        extrakw[:scale] = Vec2f0(msize)
+                        shape
+                    else
+                        gl_marker(d[:markershape], msize, _3d)
+                    end
+
+                    if !_3d
+                        extrakw[:billboard] = true
+                    end
+
+                    points = _3d ? gl_make_points(x,y,z) : gl_make_points(x,y)
+                    viz = GLVisualize.visualize(
+                        (marker, points);
+                        color = c,
+                        extrakw...
+                    )
+                    GLVisualize.view(viz, sp_screen, camera = camera)
+
+                    # TODO: might need to switch to these forms later?
+                    # GLVisualize.visualize((marker ,(x, y, z)))
+                    #GLVisualize.visualize((marker , map(Point3f0, zip(x, y, z),
+                    # billboard=true
+                    #))
+                end
+            end
+        end
+        GLAbstraction.center!(sp_screen, camera)
+    end
+
+    # TODO: render one frame at a time?  (no renderloop)
+    # GLWindow.render_frame(screen)
+end
+
+
+# ----------------------------------------------------------------
+
+function _update_plot_object(plt::Plot{GLVisualizeBackend})
+    gl_display(plt)
+end
+
+# function _writemime(io::IO, ::MIME"image/png", plt::AbstractPlot{GLVisualizeBackend})
+#     # TODO: write a png to io
+# end
+
+function _display(plt::Plot{GLVisualizeBackend})
+end

src/backends/gr.jl

@@ -0,0 +1,915 @@
+
+# https://github.com/jheinen/GR.jl
+
+# significant contributions by @jheinen
+
+supported_args(::GRBackend) = merge_with_base_supported([
+    :annotations,
+    :background_color_legend, :background_color_inside, :background_color_outside,
+    :foreground_color_legend, :foreground_color_grid, :foreground_color_axis,
+    :foreground_color_text, :foreground_color_border,
+    :label,
+    :seriescolor, :seriesalpha,
+    :linecolor, :linestyle, :linewidth, :linealpha,
+    :markershape, :markercolor, :markersize, :markeralpha,
+    :markerstrokewidth, :markerstrokecolor, :markerstrokealpha,
+    :fillrange, :fillcolor, :fillalpha,
+    :bins,
+    :layout,
+    :title, :window_title,
+    :guide, :lims, :ticks, :scale, :flip,
+    :tickfont, :guidefont, :legendfont,
+    :grid, :legend, :colorbar,
+    :marker_z, :levels,
+    :ribbon, :quiver,
+    :orientation,
+    :overwrite_figure,
+    :polar,
+    :aspect_ratio,
+    :normalize, :weights,
+    :inset_subplots,
+])
+supported_types(::GRBackend) = [
+    :path, :scatter,
+    :heatmap, :pie, :image,
+    :contour, :path3d, :scatter3d, :surface, :wireframe,
+    :shape
+]
+supported_styles(::GRBackend) = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
+supported_markers(::GRBackend) = vcat(_allMarkers, Shape)
+supported_scales(::GRBackend) = [:identity, :log10]
+is_subplot_supported(::GRBackend) = true
+
+
+function _initialize_backend(::GRBackend; kw...)
+    @eval begin
+        import GR
+        export GR
+    end
+end
+
+# --------------------------------------------------------------------------------------
+
+const gr_linetype = KW(
+    :auto => 1,
+    :solid => 1,
+    :dash => 2,
+    :dot => 3,
+    :dashdot => 4,
+    :dashdotdot => -1
+)
+
+const gr_markertype = KW(
+    :auto => 1,
+    :none => -1,
+    :circle => -1,
+    :rect => -7,
+    :diamond => -13,
+    :utriangle => -3,
+    :dtriangle => -5,
+    :pentagon => -21,
+    :hexagon => -22,
+    :heptagon => -23,
+    :octagon => -24,
+    :cross => 2,
+    :xcross => 5,
+    :star4 => -25,
+    :star5 => -26,
+    :star6 => -27,
+    :star7 => -28,
+    :star8 => -29,
+    :vline => -30,
+    :hline => -31
+)
+
+const gr_halign = KW(
+    :left => 1,
+    :hcenter => 2,
+    :right => 3
+)
+
+const gr_valign = KW(
+    :top => 1,
+    :vcenter => 3,
+    :bottom => 5
+)
+
+const gr_font_family = Dict(
+    "times" => 1,
+    "helvetica" => 5,
+    "courier" => 9,
+    "bookman" => 14,
+    "newcenturyschlbk" => 18,
+    "avantgarde" => 22,
+    "palatino" => 26
+)
+
+# --------------------------------------------------------------------------------------
+
+function gr_getcolorind(v, a =nothing)
+    c = getColor(v)
+    idx = convert(Int, GR.inqcolorfromrgb(c.r, c.g, c.b))
+    GR.settransparency(float(a==nothing ? alpha(c) : a))
+    idx
+end
+
+gr_set_linecolor(c, a=nothing) = GR.setlinecolorind(gr_getcolorind(c, a))
+gr_set_fillcolor(c, a=nothing) = GR.setfillcolorind(gr_getcolorind(c, a))
+gr_set_markercolor(c, a=nothing) = GR.setmarkercolorind(gr_getcolorind(c, a))
+gr_set_textcolor(c, a=nothing) = GR.settextcolorind(gr_getcolorind(c, a))
+
+# --------------------------------------------------------------------------------------
+
+
+# draw line segments, splitting x/y into contiguous/finite segments
+# note: this can be used for shapes by passing func `GR.fillarea`
+function gr_polyline(x, y, func = GR.polyline)
+    iend = 0
+    n = length(x)
+    while iend < n-1
+        # set istart to the first index that is finite
+        istart = -1
+        for j = iend+1:n
+            if isfinite(x[j]) && isfinite(y[j])
+                istart = j
+                break
+            end
+        end
+
+        if istart > 0
+            # iend is the last finite index
+            iend = -1
+            for j = istart+1:n
+                if isfinite(x[j]) && isfinite(y[j])
+                    iend = j
+                else
+                    break
+                end
+            end
+        end
+
+        # if we found a start and end, draw the line segment, otherwise we're done
+        if istart > 0 && iend > 0
+            func(x[istart:iend], y[istart:iend])
+        else
+            break
+        end
+    end
+end
+
+
+function gr_polaraxes(rmin, rmax)
+    GR.savestate()
+    GR.setlinetype(GR.LINETYPE_SOLID)
+    GR.setlinecolorind(88)
+    tick = 0.5 * GR.tick(rmin, rmax)
+    n = round(Int, (rmax - rmin) / tick + 0.5)
+    for i in 0:n
+        r = float(i) / n
+        if i % 2 == 0
+            GR.setlinecolorind(88)
+            if i > 0
+                GR.drawarc(-r, r, -r, r, 0, 359)
+            end
+            GR.settextalign(GR.TEXT_HALIGN_LEFT, GR.TEXT_VALIGN_HALF)
+            x, y = GR.wctondc(0.05, r)
+            GR.text(x, y, string(signif(rmin + i * tick, 12)))
+        else
+            GR.setlinecolorind(90)
+            GR.drawarc(-r, r, -r, r, 0, 359)
+        end
+    end
+    for alpha in 0:45:315
+        a = alpha + 90
+        sinf = sin(a * pi / 180)
+        cosf = cos(a * pi / 180)
+        GR.polyline([sinf, 0], [cosf, 0])
+        GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_HALF)
+        x, y = GR.wctondc(1.1 * sinf, 1.1 * cosf)
+        GR.textext(x, y, string(alpha, "^o"))
+    end
+    GR.restorestate()
+end
+
+
+# using the axis extrema and limit overrides, return the min/max value for this axis
+gr_x_axislims(sp::Subplot) = axis_limits(sp[:xaxis])
+gr_y_axislims(sp::Subplot) = axis_limits(sp[:yaxis])
+gr_z_axislims(sp::Subplot) = axis_limits(sp[:zaxis])
+gr_xy_axislims(sp::Subplot) = gr_x_axislims(sp)..., gr_y_axislims(sp)...
+
+function gr_lims(axis::Axis, adjust::Bool, expand = nothing)
+    if expand != nothing
+        expand_extrema!(axis, expand)
+    end
+    lims = axis_limits(axis)
+    if adjust
+        GR.adjustrange(lims...)
+    else
+        lims
+    end
+end
+
+
+function gr_fill_viewport(vp::AVec{Float64}, c)
+    GR.savestate()
+    GR.selntran(0)
+    GR.setfillintstyle(GR.INTSTYLE_SOLID)
+    gr_set_fillcolor(c)
+    GR.fillrect(vp...)
+    GR.selntran(1)
+    GR.restorestate()
+end
+
+
+normalize_zvals(zv::Void) = zv
+function normalize_zvals(zv::AVec)
+    vmin, vmax = extrema(zv)
+    if vmin == vmax
+        zeros(length(zv))
+    else
+        (zv - vmin) ./ (vmax - vmin)
+    end
+end
+
+# ---------------------------------------------------------
+
+# draw ONE Shape
+function gr_draw_marker(xi, yi, msize, shape::Shape)
+    sx, sy = shape_coords(shape)
+    GR.selntran(0)
+    xi, yi = GR.wctondc(xi, yi)
+    GR.fillarea(xi + sx * 0.0015msize,
+                yi + sy * 0.0015msize)
+    GR.selntran(1)
+end
+
+# draw ONE symbol marker
+function gr_draw_marker(xi, yi, msize::Number, shape::Symbol)
+    GR.setmarkertype(gr_markertype[shape])
+    GR.setmarkersize(0.3msize)
+    GR.polymarker([xi], [yi])
+end
+
+
+# draw the markers, one at a time
+function gr_draw_markers(d::KW, x, y, msize, mz)
+    shape = d[:markershape]
+    if shape != :none
+        for i=1:length(x)
+            msi = cycle(msize, i)
+            cfunc = isa(shape, Shape) ? gr_set_fillcolor : gr_set_markercolor
+            cfuncind = isa(shape, Shape) ? GR.setfillcolorind : GR.setmarkercolorind
+
+            # draw a filled in shape, slightly bigger, to estimate a stroke
+            cfunc(d[:markerstrokecolor], d[:markerstrokealpha])
+            gr_draw_marker(x[i], y[i], msi*1.2, shape, )
+
+            # draw the shape
+            if mz == nothing
+                cfunc(d[:markercolor], d[:markeralpha])
+            else
+                # pick a color from the pre-loaded gradient
+                ci = round(Int, 1000 + cycle(mz, i) * 255)
+                cfuncind(ci)
+            end
+            gr_draw_marker(x[i], y[i], msi, shape)
+        end
+    end
+end
+
+function gr_draw_markers(series::Series, x, y)
+    isempty(x) && return
+    d = series.d
+    mz = normalize_zvals(d[:marker_z])
+    GR.setfillintstyle(GR.INTSTYLE_SOLID)
+    gr_draw_markers(d, x, y, d[:markersize], mz)
+    if mz != nothing
+        gr_colorbar(d[:subplot])
+    end
+end
+
+# ---------------------------------------------------------
+
+function gr_set_line(w, style, c, a)
+    GR.setlinetype(gr_linetype[style])
+    GR.setlinewidth(w)
+    gr_set_linecolor(c, a)
+end
+
+
+
+function gr_set_fill(c, a)
+    gr_set_fillcolor(c, a)
+    GR.setfillintstyle(GR.INTSTYLE_SOLID)
+end
+
+# this stores the conversion from a font pointsize to "percentage of window height" (which is what GR uses)
+const _gr_point_mult = zeros(1)
+
+# set the font attributes... assumes _gr_point_mult has been populated already
+function gr_set_font(f::Font)
+    family = lowercase(f.family)
+    GR.setcharheight(_gr_point_mult[1] * f.pointsize)
+    GR.setcharup(sin(f.rotation), cos(f.rotation))
+    if haskey(gr_font_family, family)
+        GR.settextfontprec(100 + gr_font_family[family], GR.TEXT_PRECISION_STRING)
+    end
+    gr_set_textcolor(f.color)
+    GR.settextalign(gr_halign[f.halign], gr_valign[f.valign])
+end
+
+# --------------------------------------------------------------------------------------
+# viewport plot area
+
+# this stays constant for a given subplot while displaying that subplot.
+# values are [xmin, xmax, ymin, ymax].  they range [0,1].
+const viewport_plotarea = zeros(4)
+
+function gr_viewport_from_bbox(bb::BoundingBox, w, h, viewport_canvas)
+    viewport = zeros(4)
+    viewport[1] = viewport_canvas[2] * (left(bb) / w)
+    viewport[2] = viewport_canvas[2] * (right(bb) / w)
+    viewport[3] = viewport_canvas[4] * (1.0 - bottom(bb) / h)
+    viewport[4] = viewport_canvas[4] * (1.0 - top(bb) / h)
+    viewport
+end
+
+# change so we're focused on the viewport area
+function gr_set_viewport_cmap(sp::Subplot)
+    GR.setviewport(
+        viewport_plotarea[2] + (is3d(sp) ? 0.04 : 0.02),
+        viewport_plotarea[2] + (is3d(sp) ? 0.07 : 0.05),
+        viewport_plotarea[3],
+        viewport_plotarea[4]
+    )
+end
+
+# reset the viewport to the plot area
+function gr_set_viewport_plotarea()
+    GR.setviewport(
+        viewport_plotarea[1],
+        viewport_plotarea[2],
+        viewport_plotarea[3],
+        viewport_plotarea[4]
+    )
+end
+
+function gr_set_viewport_polar()
+    xmin, xmax, ymin, ymax = viewport_plotarea
+    ymax -= 0.05 * (xmax - xmin)
+    xcenter = 0.5 * (xmin + xmax)
+    ycenter = 0.5 * (ymin + ymax)
+    r = 0.5 * min(xmax - xmin, ymax - ymin)
+    GR.setviewport(xcenter -r, xcenter + r, ycenter - r, ycenter + r)
+    GR.setwindow(-1, 1, -1, 1)
+    r
+end
+
+# add the colorbar
+function gr_colorbar(sp::Subplot)
+    if sp[:colorbar] != :none
+        gr_set_viewport_cmap(sp)
+        GR.colormap()
+        gr_set_viewport_plotarea()
+    end
+end
+
+gr_view_xcenter() = 0.5 * (viewport_plotarea[1] + viewport_plotarea[2])
+gr_view_ycenter() = 0.5 * (viewport_plotarea[3] + viewport_plotarea[4])
+gr_view_xdiff() = viewport_plotarea[2] - viewport_plotarea[1]
+gr_view_ydiff() = viewport_plotarea[4] - viewport_plotarea[3]
+
+
+# --------------------------------------------------------------------------------------
+
+
+function gr_set_gradient(c, a)
+    grad = isa(c, ColorGradient) ? c : default_gradient()
+    grad = ColorGradient(grad, alpha=a)
+    for (i,z) in enumerate(linspace(0, 1, 256))
+        c = getColorZ(grad, z)
+        GR.setcolorrep(999+i, red(c), green(c), blue(c))
+    end
+    grad
+end
+
+# this is our new display func... set up the viewport_canvas, compute bounding boxes, and display each subplot
+function gr_display(plt::Plot)
+    GR.clearws()
+
+    # collect some monitor/display sizes in meters and pixels
+    display_width_meters, display_height_meters, display_width_px, display_height_px = GR.inqdspsize()
+    display_width_ratio = display_width_meters / display_width_px
+    display_height_ratio = display_height_meters / display_height_px
+
+    # compute the viewport_canvas, normalized to the larger dimension
+    viewport_canvas = Float64[0,1,0,1]
+    w, h = plt[:size]
+    if w > h
+        ratio = float(h) / w
+        msize = display_width_ratio * w
+        GR.setwsviewport(0, msize, 0, msize * ratio)
+        GR.setwswindow(0, 1, 0, ratio)
+        viewport_canvas[3] *= ratio
+        viewport_canvas[4] *= ratio
+    else
+        ratio = float(w) / h
+        msize = display_height_ratio * h
+        GR.setwsviewport(0, msize * ratio, 0, msize)
+        GR.setwswindow(0, ratio, 0, 1)
+        viewport_canvas[1] *= ratio
+        viewport_canvas[2] *= ratio
+    end
+
+    # fill in the viewport_canvas background
+    gr_fill_viewport(viewport_canvas, plt[:background_color_outside])
+
+    # update point mult
+    px_per_pt = px / pt
+    _gr_point_mult[1] = px_per_pt / h
+
+    # subplots:
+    for sp in plt.subplots
+        gr_display(sp, w*px, h*px, viewport_canvas)
+    end
+
+    GR.updatews()
+end
+
+
+function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
+    # the viewports for this subplot
+    viewport_subplot = gr_viewport_from_bbox(bbox(sp), w, h, viewport_canvas)
+    viewport_plotarea[:] = gr_viewport_from_bbox(plotarea(sp), w, h, viewport_canvas)
+
+    # fill in the plot area background
+    bg = getColor(sp[:background_color_inside])
+    gr_fill_viewport(viewport_plotarea, bg)
+
+    # reduced from before... set some flags based on the series in this subplot
+    # TODO: can these be generic flags?
+    outside_ticks = false
+    cmap = false
+    draw_axes = true
+    # axes_2d = true
+    for series in series_list(sp)
+        st = series.d[:seriestype]
+        if st in (:contour, :surface, :heatmap) || series.d[:marker_z] != nothing
+            cmap = true
+        end
+        if st == :pie
+            draw_axes = false
+        end
+        if st == :heatmap
+            outside_ticks = true
+        end
+    end
+
+    if cmap && sp[:colorbar] != :none
+        # note: add extra midpadding on the right for the colorbar
+        viewport_plotarea[2] -= 0.1
+    end
+
+    # set our plot area view
+    gr_set_viewport_plotarea()
+
+    # these are the Axis objects, which hold scale, lims, etc
+    xaxis = sp[:xaxis]
+    yaxis = sp[:yaxis]
+    zaxis = sp[:zaxis]
+
+    # get data limits and set the scale flags and window
+    data_lims = gr_xy_axislims(sp)
+    xmin, xmax, ymin, ymax = data_lims
+    scale = 0
+    xtick, ytick = 1, 1
+    if xmax > xmin && ymax > ymin
+        # NOTE: for log axes, the major_x and major_y - if non-zero (omit labels) - control the minor grid lines (1 = draw 9 minor grid lines, 2 = no minor grid lines)
+        # NOTE: for log axes, the x_tick and y_tick - if non-zero (omit axes) - only affect the output appearance (1 = nomal, 2 = scientiic notation)
+        xaxis[:scale] == :log10 && (scale |= GR.OPTION_X_LOG)
+        yaxis[:scale] == :log10 && (scale |= GR.OPTION_Y_LOG)
+        xaxis[:flip]            && (scale |= GR.OPTION_FLIP_X)
+        yaxis[:flip]            && (scale |= GR.OPTION_FLIP_Y)
+        if scale & GR.OPTION_X_LOG == 0
+            majorx = 1 #5
+            xtick = GR.tick(xmin, xmax) / majorx
+        else
+            # log axis
+            xtick = 2  # scientific notation
+            majorx = 2 # no minor grid lines
+        end
+        if scale & GR.OPTION_Y_LOG == 0
+            majory = 1 #5
+            ytick = GR.tick(ymin, ymax) / majory
+        else
+            # log axis
+            ytick = 2  # scientific notation
+            majory = 2 # no minor grid lines
+        end
+
+        # NOTE: setwindow sets the "data coordinate" limits of the current "viewport"
+        GR.setwindow(xmin, xmax, ymin, ymax)
+        GR.setscale(scale)
+    end
+
+    # draw the axes
+    gr_set_font(xaxis[:tickfont])
+    gr_set_textcolor(xaxis[:foreground_color_text])
+    GR.setlinewidth(1)
+
+    if is3d(sp)
+        zmin, zmax = gr_lims(zaxis, true)
+        GR.setspace(zmin, zmax, 40, 70)
+        xtick = GR.tick(xmin, xmax) / 2
+        ytick = GR.tick(ymin, ymax) / 2
+        ztick = GR.tick(zmin, zmax) / 2
+        ticksize = 0.01 * (viewport_plotarea[2] - viewport_plotarea[1])
+
+        # GR.setlinetype(GR.LINETYPE_DOTTED)
+        if sp[:grid]
+            GR.grid3d(xtick, 0, ztick, xmin, ymin, zmin, 2, 0, 2)
+            GR.grid3d(0, ytick, 0, xmax, ymin, zmin, 0, 2, 0)
+        end
+        GR.axes3d(xtick, 0, ztick, xmin, ymin, zmin, 2, 0, 2, -ticksize)
+        GR.axes3d(0, ytick, 0, xmax, ymin, zmin, 0, 2, 0, ticksize)
+
+    elseif ispolar(sp)
+        r = gr_set_viewport_polar()
+        rmin, rmax = GR.adjustrange(minimum(r), maximum(r))
+        gr_polaraxes(rmin, rmax)
+
+    elseif draw_axes
+        # draw the grid lines
+        # TODO: control line style/width
+        # GR.setlinetype(GR.LINETYPE_DOTTED)
+        if sp[:grid]
+            gr_set_linecolor(sp[:foreground_color_grid])
+            GR.grid(xtick, ytick, 0, 0, majorx, majory)
+        end
+
+        window_diag = sqrt(gr_view_xdiff()^2 + gr_view_ydiff()^2)
+        ticksize = 0.0075 * window_diag
+        if outside_ticks
+            ticksize = -ticksize
+        end
+        # TODO: this should be done for each axis separately
+        gr_set_linecolor(xaxis[:foreground_color_axis])
+
+        x1, x2 = xaxis[:flip] ? (xmax,xmin) : (xmin,xmax)
+        y1, y2 = yaxis[:flip] ? (ymax,ymin) : (ymin,ymax)
+        GR.axes(xtick, ytick, x1, y1, 1, 1, ticksize)
+        GR.axes(xtick, ytick, x2, y2, -1, -1, -ticksize)
+    end
+    # end
+
+    # add the guides
+    GR.savestate()
+    if sp[:title] != ""
+        gr_set_font(sp[:titlefont])
+        GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_TOP)
+        gr_set_textcolor(sp[:foreground_color_title])
+        GR.text(gr_view_xcenter(), viewport_subplot[4], sp[:title])
+    end
+
+    if xaxis[:guide] != ""
+        gr_set_font(xaxis[:guidefont])
+        GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_BOTTOM)
+        gr_set_textcolor(xaxis[:foreground_color_guide])
+        GR.text(gr_view_xcenter(), viewport_subplot[3], xaxis[:guide])
+    end
+
+    if yaxis[:guide] != ""
+        gr_set_font(yaxis[:guidefont])
+        GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_TOP)
+        GR.setcharup(-1, 0)
+        gr_set_textcolor(yaxis[:foreground_color_guide])
+        GR.text(viewport_subplot[1], gr_view_ycenter(), yaxis[:guide])
+    end
+    GR.restorestate()
+
+    # TODO: can we remove?
+    gr_set_font(xaxis[:tickfont])
+    GR.setcolormap(1000 + GR.COLORMAP_COOLWARM)
+
+    for (idx, series) in enumerate(series_list(sp))
+        d = series.d
+        st = d[:seriestype]
+
+        # update the current stored gradient
+        if st in (:contour, :surface, :wireframe, :heatmap)
+            gr_set_gradient(d[:fillcolor], d[:fillalpha])
+        elseif d[:marker_z] != nothing
+            d[:markercolor] = gr_set_gradient(d[:markercolor], d[:markeralpha])
+        end
+
+        GR.savestate()
+
+        # update the bounding window
+        if ispolar(sp)
+            gr_set_viewport_polar()
+        else
+            xmin, xmax, ymin, ymax = data_lims
+            if xmax > xmin && ymax > ymin
+                GR.setwindow(xmin, xmax, ymin, ymax)
+            end
+        end
+
+        x, y, z = d[:x], d[:y], d[:z]
+        frng = d[:fillrange]
+
+        # recompute data
+        if st in (:contour, :surface, :wireframe)
+            z = vec(transpose_z(d, z.surf, false))
+        elseif ispolar(sp)
+            if frng != nothing
+                _, frng = convert_to_polar(x, frng, (rmin, rmax))
+            end
+            x, y = convert_to_polar(x, y, (rmin, rmax))
+        end
+
+        if st in (:path, :scatter)
+            if length(x) > 1
+
+                # do area fill
+                if frng != nothing
+                    gr_set_fillcolor(d[:fillcolor], d[:fillalpha])
+                    GR.setfillintstyle(GR.INTSTYLE_SOLID)
+                    frng = isa(frng, Number) ? Float64[frng] : frng
+                    nx, ny, nf = length(x), length(y), length(frng)
+                    n = max(nx, ny)
+                    fx, fy = zeros(2n), zeros(2n)
+                    for i=1:n
+                        fx[i] = fx[end-i+1] = cycle(x,i)
+                        fy[i] = cycle(y,i)
+                        fy[end-i+1] = cycle(frng,i)
+                    end
+                    GR.fillarea(fx, fy)
+                end
+
+                # draw the line(s)
+                if st == :path
+                    gr_set_line(d[:linewidth], d[:linestyle], d[:linecolor], d[:linealpha])
+                    gr_polyline(x, y)
+                end
+            end
+
+            if d[:markershape] != :none
+                gr_draw_markers(series, x, y)
+            end
+
+        elseif st == :contour
+            zmin, zmax = gr_lims(zaxis, false)
+            if typeof(d[:levels]) <: Array
+                h = d[:levels]
+            else
+                h = linspace(zmin, zmax, d[:levels])
+            end
+            GR.setspace(zmin, zmax, 0, 90)
+            if d[:fillrange] != nothing
+                GR.surface(x, y, z, GR.OPTION_CELL_ARRAY)
+            else
+                GR.contour(x, y, h, z, 1000)
+            end
+            
+            # create the colorbar of contour levels
+            if sp[:colorbar] != :none
+                gr_set_viewport_cmap(sp)
+                l = round(Int32, 1000 + (h - minimum(h)) / (maximum(h) - minimum(h)) * 255)
+                GR.setwindow(xmin, xmax, zmin, zmax)
+                GR.cellarray(xmin, xmax, zmax, zmin, 1, length(l), l)
+                ztick = 0.5 * GR.tick(zmin, zmax)
+                GR.axes(0, ztick, xmax, zmin, 0, 1, 0.005)
+                gr_set_viewport_plotarea()
+            end
+
+        elseif st in [:surface, :wireframe]
+            if st == :surface
+                GR.gr3.surface(x, y, z, GR.OPTION_COLORED_MESH)
+            else
+                GR.setfillcolorind(0)
+                GR.surface(x, y, z, GR.OPTION_FILLED_MESH)
+            end
+            cmap && gr_colorbar(sp)
+
+        elseif st == :heatmap
+            z = vec(transpose_z(d, z.surf, false))
+            zmin, zmax = gr_lims(zaxis, true)
+            GR.setspace(zmin, zmax, 0, 90)
+            GR.surface(x, y, z, GR.OPTION_COLORED_MESH)
+            cmap && gr_colorbar(sp)
+
+        elseif st in (:path3d, :scatter3d)
+            # draw path
+            if st == :path3d
+                if length(x) > 1
+                    gr_set_line(d[:linewidth], d[:linestyle], d[:linecolor], d[:linealpha])
+                    GR.polyline3d(x, y, z)
+                end
+            end
+
+            # draw markers
+            if st == :scatter3d || d[:markershape] != :none
+                x2, y2 = unzip(map(GR.wc3towc, x, y, z))
+                gr_draw_markers(series, x2, y2)
+            end
+
+        # TODO: replace with pie recipe
+        elseif st == :pie
+            GR.selntran(0)
+            GR.setfillintstyle(GR.INTSTYLE_SOLID)
+            xmin, xmax, ymin, ymax = viewport_plotarea
+            ymax -= 0.05 * (xmax - xmin)
+            xcenter = 0.5 * (xmin + xmax)
+            ycenter = 0.5 * (ymin + ymax)
+            if xmax - xmin > ymax - ymin
+                r = 0.5 * (ymax - ymin)
+                xmin, xmax = xcenter - r, xcenter + r
+            else
+                r = 0.5 * (xmax - xmin)
+                ymin, ymax = ycenter - r, ycenter + r
+            end
+            labels = pie_labels(sp, series)
+            slices = d[:y]
+            numslices = length(slices)
+            total = sum(slices)
+            a1 = 0
+            x = zeros(3)
+            y = zeros(3)
+            for i in 1:numslices
+                a2 = round(Int, a1 + (slices[i] / total) * 360.0)
+                GR.setfillcolorind(980 + (i-1) % 20)
+                GR.fillarc(xmin, xmax, ymin, ymax, a1, a2)
+                alpha = 0.5 * (a1 + a2)
+                cosf = r * cos(alpha * pi / 180)
+                sinf = r * sin(alpha * pi / 180)
+                x[1] = xcenter + cosf
+                y[1] = ycenter + sinf
+                x[2] = x[1] + 0.1 * cosf
+                y[2] = y[1] + 0.1 * sinf
+                y[3] = y[2]
+                if 90 <= alpha < 270
+                    x[3] = x[2] - 0.05
+                    GR.settextalign(GR.TEXT_HALIGN_RIGHT, GR.TEXT_VALIGN_HALF)
+                    GR.text(x[3] - 0.01, y[3], string(labels[i]))
+                else
+                    x[3] = x[2] + 0.05
+                    GR.settextalign(GR.TEXT_HALIGN_LEFT, GR.TEXT_VALIGN_HALF)
+                    GR.text(x[3] + 0.01, y[3], string(labels[i]))
+                end
+                gr_polyline(x, y)
+                a1 = a2
+            end
+            GR.selntran(1)
+
+        elseif st == :shape
+            # draw the interior
+            gr_set_fill(d[:fillcolor], d[:fillalpha])
+            gr_polyline(d[:x], d[:y], GR.fillarea)
+
+            # draw the shapes
+            gr_set_line(d[:linewidth], :solid, d[:linecolor], d[:linealpha])
+            gr_polyline(d[:x], d[:y])
+
+
+        elseif st == :image
+            img = d[:z].surf
+            w, h = size(img)
+            if eltype(img) <: Colors.AbstractGray
+                grey = round(UInt8, float(img) * 255)
+                rgba = map(c -> UInt32( 0xff000000 + Int(c)<<16 + Int(c)<<8 + Int(c) ), grey)
+            else
+                rgba = map(c -> UInt32( round(Int, alpha(c) * 255) << 24 +
+                                        round(Int,  blue(c) * 255) << 16 +
+                                        round(Int, green(c) * 255) << 8  +
+                                        round(Int,   red(c) * 255) ), img)
+            end
+            GR.drawimage(xmin, xmax, ymax, ymin, w, h, rgba)
+        end
+
+        GR.restorestate()
+    end
+
+
+    # add the legend
+    if sp[:legend] != :none
+        GR.savestate()
+        GR.selntran(0)
+        GR.setscale(0)
+        gr_set_font(sp[:legendfont])
+        w = 0
+        i = 0
+        n = 0
+        for series in series_list(sp)
+            should_add_to_legend(series) || continue
+            n += 1
+            if typeof(series.d[:label]) <: Array
+                i += 1
+                lab = series.d[:label][i]
+            else
+                lab = series.d[:label]
+            end
+            tbx, tby = GR.inqtext(0, 0, lab)
+            w = max(w, tbx[3] - tbx[1])
+        end
+        if w > 0
+            xpos = viewport_plotarea[2] - 0.05 - w
+            ypos = viewport_plotarea[4] - 0.06
+            dy = _gr_point_mult[1] * sp[:legendfont].pointsize * 1.75
+            GR.setfillintstyle(GR.INTSTYLE_SOLID)
+            gr_set_fillcolor(sp[:background_color_legend])
+            GR.fillrect(xpos - 0.08, xpos + w + 0.02, ypos + dy, ypos - dy * n)
+            GR.setlinetype(1)
+            GR.setlinewidth(1)
+            GR.drawrect(xpos - 0.08, xpos + w + 0.02, ypos + dy, ypos - dy * n)
+            i = 0
+            for series in series_list(sp)
+                should_add_to_legend(series) || continue
+                d = series.d
+                st = d[:seriestype]
+                gr_set_line(d[:linewidth], d[:linestyle], d[:linecolor], d[:linealpha])
+                if st == :path
+                    GR.polyline([xpos - 0.07, xpos - 0.01], [ypos, ypos])
+                elseif st == :shape
+                    gr_set_fill(d[:fillcolor], d[:fillalpha])
+                    l, r = xpos-0.07, xpos-0.01
+                    b, t = ypos-0.4dy, ypos+0.4dy
+                    x = [l, r, r, l, l]
+                    y = [b, b, t, t, b]
+                    gr_polyline(x, y, GR.fillarea)
+                    gr_polyline(x, y)
+                end
+
+                gr_draw_markers(d, xpos-[0.06,0.02], [ypos,ypos], 10, nothing)
+                # shape = d[:markershape]
+                # if shape != :none #st == :scatter || d[:markershape] != :none
+                #     msize = 10
+                #     for xoff in [0.06,0.02]
+                #         gr_set_markercolor(d[:markerstrokecolor], d[:markerstrokealpha])
+                #         gr_draw_marker(xpos-xoff, ypos, msize*1.1, shape)
+                #         gr_set_markercolor(d[:markercolor], d[:markeralpha])
+                #         gr_draw_marker(xpos-xoff, ypos, msize, shape)
+                #     end
+                #     # gr_setmarkershape(d)
+                #     # if st == :path
+                #     #     gr_polymarker(d, [xpos - 0.06, xpos - 0.02], [ypos, ypos])
+                #     # else
+                #     #     gr_polymarker(d, [xpos - 0.06, xpos - 0.04, xpos - 0.02], [ypos, ypos, ypos])
+                #     # end
+                # end
+                if typeof(d[:label]) <: Array
+                    i += 1
+                    lab = d[:label][i]
+                else
+                    lab = d[:label]
+                end
+                GR.settextalign(GR.TEXT_HALIGN_LEFT, GR.TEXT_VALIGN_HALF)
+                gr_set_textcolor(sp[:foreground_color_legend])
+                GR.text(xpos, ypos, lab)
+                ypos -= dy
+            end
+        end
+        GR.selntran(1)
+        GR.restorestate()
+    end
+
+    # add annotations
+    GR.savestate()
+    for ann in sp[:annotations]
+        x, y, val = ann
+        x, y = GR.wctondc(x, y)
+        gr_set_font(val.font)
+        GR.text(x, y, val.str)
+    end
+    GR.restorestate()
+end
+
+
+# ----------------------------------------------------------------
+
+const _gr_mimeformats = Dict(
+    "application/pdf"         => "pdf",
+    "image/png"               => "png",
+    "application/postscript"  => "ps",
+    "image/svg+xml"           => "svg",
+)
+
+
+for (mime, fmt) in _gr_mimeformats
+    @eval function _writemime(io::IO, ::MIME{Symbol($mime)}, plt::Plot{GRBackend})
+        GR.emergencyclosegks()
+        wstype = haskey(ENV, "GKS_WSTYPE") ? ENV["GKS_WSTYPE"] : "0"
+        filepath = tempname() * "." * $fmt
+        ENV["GKS_WSTYPE"] = $fmt
+        ENV["GKS_FILEPATH"] = filepath
+        gr_display(plt)
+        GR.emergencyclosegks()
+        write(io, readall(filepath))
+        ENV["GKS_WSTYPE"] = wstype
+        rm(filepath)
+    end
+end
+
+function _display(plt::Plot{GRBackend})
+    gr_display(plt)
+end

src/backends/immerse.jl

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

src/backends/pgfplots.jl

@@ -0,0 +1,321 @@
+# https://github.com/sisl/PGFPlots.jl
+
+# significant contributions by: @pkofod
+
+supported_args(::PGFPlotsBackend) = merge_with_base_supported([
+    # :annotations,
+    # :background_color_legend,
+    :background_color_inside,
+    # :background_color_outside,
+    # :foreground_color_legend, :foreground_color_grid, :foreground_color_axis,
+    #     :foreground_color_text, :foreground_color_border,
+    :label,
+    :seriescolor, :seriesalpha,
+    :linecolor, :linestyle, :linewidth, :linealpha,
+    :markershape, :markercolor, :markersize, :markeralpha,
+    :markerstrokewidth, :markerstrokecolor, :markerstrokealpha, :markerstrokestyle,
+    :fillrange, :fillcolor, :fillalpha,
+    :bins,
+    # :bar_width, :bar_edges,
+    :title,
+    # :window_title,
+    :guide, :lims, :ticks, :scale, :flip, :rotation,
+    :tickfont, :guidefont, :legendfont,
+    :grid, :legend,
+    # :colorbar,
+    # :marker_z, :levels,
+    # :ribbon, :quiver, :arrow,
+    # :orientation,
+    # :overwrite_figure,
+    # :polar,
+    # :normalize, :weights, :contours,
+    :aspect_ratio,
+    # :match_dimensions,
+  ])
+supported_types(::PGFPlotsBackend) = [:path, :path3d, :scatter, :steppre, :stepmid, :steppost, :histogram2d, :ysticks, :xsticks, :contour]
+supported_styles(::PGFPlotsBackend) = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
+supported_markers(::PGFPlotsBackend) = [:none, :auto, :circle, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5, :pentagon] #vcat(_allMarkers, Shape)
+supported_scales(::PGFPlotsBackend) = [:identity, :ln, :log2, :log10]
+is_subplot_supported(::PGFPlotsBackend) = false
+
+
+# --------------------------------------------------------------------------------------
+
+
+function _initialize_backend(::PGFPlotsBackend; kw...)
+    @eval begin
+        import PGFPlots
+        export PGFPlots
+    end
+end
+
+
+# --------------------------------------------------------------------------------------
+
+const _pgfplots_linestyles = KW(
+    :solid => "solid",
+    :dash => "dashed",
+    :dot => "dotted",
+    :dashdot => "dashdotted",
+    :dashdotdot => "dashdotdotted",
+)
+
+const _pgfplots_markers = KW(
+    :none => "none",
+    :cross => "+",
+    :xcross => "x",
+    :utriangle => "triangle*",
+    :dtriangle => "triangle*",
+    :circle => "*",
+    :rect => "square*",
+    :star5 => "star",
+    :star6 => "asterisk",
+    :diamond => "diamond*",
+    :pentagon => "pentagon*",
+)
+
+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, a = nothing)
+    c = getColor(c)
+    cstr = @sprintf("{rgb,1:red,%.8f;green,%.8f;blue,%.8f}", red(c), green(c), blue(c))
+    a = float(a == nothing ? alpha(c) : a)
+    cstr, a
+end
+
+function pgf_fillstyle(d::KW)
+    cstr,a = pgf_color(d[:fillcolor], d[:fillalpha])
+    "fill = $cstr, fill opacity=$a"
+end
+
+function pgf_linestyle(d::KW)
+    cstr,a = pgf_color(d[:linecolor], d[:linealpha])
+    """
+    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], d[:markeralpha])
+    cstr_stroke, a_stroke = pgf_color(d[:markerstrokecolor], d[:markerstrokealpha])
+    """
+    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
+
+    # add to legend?
+    if sp[:legend] != :none && should_add_to_legend(series)
+        kw[:legendentry] = d[:label]
+    end
+
+    # 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
+
+    # PGFPlots can't handle non-Vector?
+    args = map(a -> if typeof(a) <: AbstractVector && typeof(a) != Vector
+            collect(a)
+        else
+            a
+        end, args)
+    # for (i,a) in enumerate(args)
+    #     if typeof(a) <: AbstractVector && typeof(a) != Vector
+    #         args[i] = collect(a)
+    #     end
+    # end
+
+    # include additional style, then add to the kw
+    if haskey(_pgf_series_extrastyle, st)
+        push!(style, _pgf_series_extrastyle[st])
+    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 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
+
+    # limits
+    # TODO: support zlims
+    if letter != :z
+        lims = axis_limits(axis)
+        kw[Symbol(letter,:min)] = lims[1]
+        kw[Symbol(letter,:max)] = lims[2]
+    end
+
+    # return the style list and KW args
+    style, kw
+end
+
+# ----------------------------------------------------------------
+
+
+function _make_pgf_plot!(plt::Plot)
+    plt.o = PGFPlots.Axis[]
+    for sp in plt.subplots
+        # first build the PGFPlots.Axis object
+        style = ["unbounded coords=jump"]
+        kw = KW()
+
+        # add to style/kw for each axis
+        for letter in (:x, :y, :z)
+            if letter != :z || is3d(sp)
+                axisstyle, axiskw = pgf_axis(sp, letter)
+                merge!(kw, axiskw)
+            end
+        end
+
+        # 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,
+            width = $(width(bb).value)mm,
+            height = $(height(bb).value)mm,
+            axis background/.style={fill=$(pgf_color(sp[:background_color_inside])[1])}
+        """)
+
+        if sp[:title] != ""
+            push!(style, "title = $(sp[:title])")
+        end
+
+        sp[:grid] && push!(style, "grid = major")
+        if sp[:aspect_ratio] in (1, :equal)
+            kw[:axisEqual] = "true"
+        end
+
+        legpos = sp[:legend]
+        if haskey(_pgfplots_legend_pos, legpos)
+            kw[:legendPos] = _pgfplots_legend_pos[legpos]
+        end
+
+        o = PGFPlots.Axis(; style = style, kw...)
+
+        # 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
+
+
+function _writemime(io::IO, mime::MIME"image/svg+xml", plt::Plot{PGFPlotsBackend})
+    _make_pgf_plot!(plt)
+    writemime(io, mime, plt.o)
+end
+
+function _writemime(io::IO, mime::MIME"application/pdf", plt::Plot{PGFPlotsBackend})
+    _make_pgf_plot!(plt)
+
+    # 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 _display(plt::Plot{PGFPlotsBackend})
+    # prepare the object
+    _make_pgf_plot!(plt)
+    pgfplt = PGFPlots.plot(plt.o)
+
+    # save an svg
+    fn = string(tempname(), ".svg")
+    PGFPlots.save(PGFPlots.SVG(fn), pgfplt)
+
+    # show it
+    open_browser_window(fn)
+
+    # cleanup
+    PGFPlots.cleanup(plt.o)
+end

src/backends/plotly.jl

@@ -0,0 +1,560 @@
+
+# https://plot.ly/javascript/getting-started
+
+supported_args(::PlotlyBackend) = merge_with_base_supported([
+    :annotations,
+    :background_color_legend, :background_color_inside, :background_color_outside,
+    :foreground_color_legend, :foreground_color_guide,
+    # :foreground_color_grid, :foreground_color_axis,
+    :foreground_color_text, :foreground_color_border,
+    :foreground_color_title,
+    :label,
+    :seriescolor, :seriesalpha,
+    :linecolor, :linestyle, :linewidth, :linealpha,
+    :markershape, :markercolor, :markersize, :markeralpha,
+    :markerstrokewidth, :markerstrokecolor, :markerstrokealpha, :markerstrokestyle,
+    :fillrange, :fillcolor, :fillalpha,
+    :bins,
+    :title, :title_location, :titlefont,
+    :window_title,
+    :guide, :lims, :ticks, :scale, :flip, :rotation,
+    :tickfont, :guidefont, :legendfont,
+    :grid, :legend, :colorbar,
+    :marker_z, :levels,
+    :ribbon, :quiver,
+    :orientation,
+    # :overwrite_figure,
+    :polar,
+    :normalize, :weights,
+    # :contours, :aspect_ratio,
+    :hover,
+    :inset_subplots,
+  ])
+
+supported_types(::PlotlyBackend) = [
+    :path, :scatter, :bar, :pie, :heatmap,
+    :contour, :surface, :path3d, :scatter3d, :shape, :scattergl,
+]
+supported_styles(::PlotlyBackend) = [:auto, :solid, :dash, :dot, :dashdot]
+supported_markers(::PlotlyBackend) = [
+    :none, :auto, :circle, :rect, :diamond, :utriangle, :dtriangle,
+    :cross, :xcross, :pentagon, :hexagon, :octagon, :vline, :hline
+]
+supported_scales(::PlotlyBackend) = [:identity, :log10]
+is_subplot_supported(::PlotlyBackend) = true
+is_string_supported(::PlotlyBackend) = true
+
+
+# --------------------------------------------------------------------------------------
+
+function _initialize_backend(::PlotlyBackend; kw...)
+  @eval begin
+    import JSON
+    JSON._print(io::IO, state::JSON.State, dt::Union{Date,DateTime}) = print(io, '"', dt, '"')
+
+    _js_path = Pkg.dir("Plots", "deps", "plotly-latest.min.js")
+    _js_code = open(@compat(readstring), _js_path, "r")
+
+    # borrowed from https://github.com/plotly/plotly.py/blob/2594076e29584ede2d09f2aa40a8a195b3f3fc66/plotly/offline/offline.py#L64-L71 c/o @spencerlyon2
+    _js_script = """
+        <script type='text/javascript'>
+            define('plotly', function(require, exports, module) {
+                $(_js_code)
+            });
+            require(['plotly'], function(Plotly) {
+                window.Plotly = Plotly;
+            });
+        </script>
+    """
+
+    # if we're in IJulia call setupnotebook to load js and css
+    if isijulia()
+        display("text/html", _js_script)
+    end
+
+    # if isatom()
+    #     import Atom
+    #     Atom.@msg evaljs(_js_code)
+    # end
+
+  end
+  # TODO: other initialization
+end
+
+
+# ----------------------------------------------------------------
+
+function plotly_font(font::Font, color = font.color)
+    KW(
+        :family => font.family,
+        :size   => round(Int, font.pointsize*1.4),
+        :color  => webcolor(color),
+    )
+end
+
+function plotly_annotation_dict(x, y, val; xref="paper", yref="paper")
+    KW(
+        :text => val,
+        :xref => xref,
+        :x => x,
+        :yref => xref,
+        :y => y,
+        :showarrow => false,
+    )
+end
+
+function plotly_annotation_dict(x, y, ptxt::PlotText; xref="paper", yref="paper")
+    merge(plotly_annotation_dict(x, y, ptxt.str; xref=xref, yref=yref), KW(
+        :font => plotly_font(ptxt.font),
+        :xanchor => ptxt.font.halign == :hcenter ? :center : ptxt.font.halign,
+        :yanchor => ptxt.font.valign == :vcenter ? :middle : ptxt.font.valign,
+        :rotation => ptxt.font.rotation,
+    ))
+end
+
+# function get_annotation_dict_for_arrow(d::KW, xyprev::Tuple, xy::Tuple, a::Arrow)
+#     xdiff = xyprev[1] - xy[1]
+#     ydiff = xyprev[2] - xy[2]
+#     dist = sqrt(xdiff^2 + ydiff^2)
+#     KW(
+#         :showarrow => true,
+#         :x => xy[1],
+#         :y => xy[2],
+#         # :ax => xyprev[1] - xy[1],
+#         # :ay => xy[2] - xyprev[2],
+#         # :ax => 0,
+#         # :ay => -40,
+#         :ax => 10xdiff / dist,
+#         :ay => -10ydiff / dist,
+#         :arrowcolor => webcolor(d[:linecolor], d[:linealpha]),
+#         :xref => "x",
+#         :yref => "y",
+#         :arrowsize => 10a.headwidth,
+#         # :arrowwidth => a.headlength,
+#         :arrowwidth => 0.1,
+#     )
+# end
+
+function plotly_scale(scale::Symbol)
+    if scale == :log10
+        "log"
+    else
+        "-"
+    end
+end
+
+
+# this method gets the start/end in percentage of the canvas for this axis direction
+function plotly_domain(sp::Subplot, letter)
+    figw, figh = sp.plt[:size]
+    pcts = bbox_to_pcts(sp.plotarea, figw*px, figh*px)
+    i1,i2 = (letter == :x ? (1,3) : (2,4))
+    [pcts[i1], pcts[i1]+pcts[i2]]
+end
+
+
+function plotly_axis(axis::Axis, sp::Subplot)
+    letter = axis[:letter]
+    ax = KW(
+        :title      => axis[:guide],
+        :showgrid   => sp[:grid],
+        :zeroline   => false,
+    )
+
+    if letter in (:x,:y)
+        ax[:domain] = plotly_domain(sp, letter)
+        ax[:anchor] = "$(letter==:x ? :y : :x)$(plotly_subplot_index(sp))"
+    end
+
+    rot = axis[:rotation]
+    if rot != 0
+        ax[:tickangle] = rot
+    end
+
+    if !(axis[:ticks] in (nothing, :none))
+        ax[:titlefont] = plotly_font(axis[:guidefont], axis[:foreground_color_guide])
+        ax[:type] = plotly_scale(axis[:scale])
+        ax[:tickfont] = plotly_font(axis[:tickfont], axis[:foreground_color_text])
+        ax[:tickcolor] = webcolor(axis[:foreground_color_border])
+        ax[:linecolor] = webcolor(axis[:foreground_color_border])
+
+        # lims
+        lims = axis[:lims]
+        if lims != :auto && limsType(lims) == :limits
+            ax[:range] = lims
+        end
+
+        # flip
+        if axis[:flip]
+            ax[:autorange] = "reversed"
+        end
+
+        # ticks
+        ticks = axis[:ticks]
+        if ticks != :auto
+            ttype = ticksType(ticks)
+            if ttype == :ticks
+                ax[:tickmode] = "array"
+                ax[:tickvals] = ticks
+            elseif ttype == :ticks_and_labels
+                ax[:tickmode] = "array"
+                ax[:tickvals], ax[:ticktext] = ticks
+            end
+        end
+    else
+        ax[:showticklabels] = false
+        ax[:showgrid] = false
+    end
+
+    ax
+end
+
+function plotly_layout(plt::Plot)
+    d_out = KW()
+
+    w, h = plt[:size]
+    d_out[:width], d_out[:height] = w, h
+    d_out[:paper_bgcolor] = webcolor(plt[:background_color_outside])
+    d_out[:margin] = KW(:l=>0, :b=>0, :r=>0, :t=>20)
+
+    d_out[:annotations] = KW[]
+
+    for sp in plt.subplots
+        spidx = plotly_subplot_index(sp)
+
+        # add an annotation for the title... positioned horizontally relative to plotarea,
+        # but vertically just below the top of the subplot bounding box
+        if sp[:title] != ""
+            bb = plotarea(sp)
+            tpos = sp[:title_location]
+            xmm = if tpos == :left
+                left(bb)
+            elseif tpos == :right
+                right(bb)
+            else
+                0.5 * (left(bb) + right(bb))
+            end
+            titlex, titley = xy_mm_to_pcts(xmm, top(bbox(sp)), w*px, h*px)
+            titlefont = font(sp[:titlefont], :top, sp[:foreground_color_title])
+            push!(d_out[:annotations], plotly_annotation_dict(titlex, titley, text(sp[:title], titlefont)))
+        end
+
+        d_out[:plot_bgcolor] = webcolor(sp[:background_color_inside])
+
+        # TODO: x/y axis tick values/labels
+
+        # if any(is3d, seriesargs)
+        if is3d(sp)
+            d_out[:scene] = KW(
+                Symbol("xaxis$spidx") => plotly_axis(sp[:xaxis], sp),
+                Symbol("yaxis$spidx") => plotly_axis(sp[:yaxis], sp),
+                Symbol("zaxis$spidx") => plotly_axis(sp[:zaxis], sp),
+            )
+        else
+            d_out[Symbol("xaxis$spidx")] = plotly_axis(sp[:xaxis], sp)
+            d_out[Symbol("yaxis$spidx")] = plotly_axis(sp[:yaxis], sp)
+        end
+
+        # legend
+        d_out[:showlegend] = sp[:legend] != :none
+        if sp[:legend] != :none
+            d_out[:legend] = KW(
+                :bgcolor  => webcolor(sp[:background_color_legend]),
+                :bordercolor => webcolor(sp[:foreground_color_legend]),
+                :font     => plotly_font(sp[:legendfont], sp[:foreground_color_legend]),
+            )
+        end
+
+        # annotations
+        append!(d_out[:annotations], KW[plotly_annotation_dict(ann...; xref = "x$spidx", yref = "y$spidx") for ann in sp[:annotations]])
+
+        # # arrows
+        # for sargs in seriesargs
+        #     a = sargs[:arrow]
+        #     if sargs[:seriestype] in (:path, :line) && typeof(a) <: Arrow
+        #         add_arrows(sargs[:x], sargs[:y]) do xyprev, xy
+        #             push!(d_out[:annotations], get_annotation_dict_for_arrow(sargs, xyprev, xy, a))
+        #         end
+        #     end
+        # end
+
+        if ispolar(sp)
+            d_out[:direction] = "counterclockwise"
+        end
+
+        d_out
+    end
+
+    # turn off hover if nothing's using it
+    if all(series -> series.d[:hover] in (false,:none), plt.series_list)
+        d_out[:hovermode] = "none"
+    end
+
+    d_out
+end
+
+function plotly_layout_json(plt::Plot)
+    JSON.json(plotly_layout(plt))
+end
+
+
+function plotly_colorscale(grad::ColorGradient, alpha = nothing)
+    [[grad.values[i], webcolor(grad.colors[i], alpha)] for i in 1:length(grad.colors)]
+end
+plotly_colorscale(c, alpha = nothing) = plotly_colorscale(default_gradient(), alpha)
+
+const _plotly_markers = KW(
+    :rect       => "square",
+    :xcross     => "x",
+    :utriangle  => "triangle-up",
+    :dtriangle  => "triangle-down",
+    :star5      => "star-triangle-up",
+    :vline      => "line-ns",
+    :hline      => "line-ew",
+)
+
+function plotly_subplot_index(sp::Subplot)
+    spidx = sp[:subplot_index]
+    spidx == 1 ? "" : spidx
+end
+
+
+# the Shape contructor will automatically close the shape. since we need it closed,
+# we split by NaNs and then construct/destruct the shapes to get the closed coords
+function plotly_close_shapes(x, y)
+    xs, ys = nansplit(x), nansplit(y)
+    for i=1:length(xs)
+        shape = Shape(xs[i], ys[i])
+        xs[i], ys[i] = shape_coords(shape)
+    end
+    nanvcat(xs), nanvcat(ys)
+end
+
+# get a dictionary representing the series params (d is the Plots-dict, d_out is the Plotly-dict)
+function plotly_series(plt::Plot, series::Series)
+    d = series.d
+    sp = d[:subplot]
+    d_out = KW()
+
+    # these are the axes that the series should be mapped to
+    spidx = plotly_subplot_index(sp)
+    d_out[:xaxis] = "x$spidx"
+    d_out[:yaxis] = "y$spidx"
+    d_out[:showlegend] = should_add_to_legend(series)
+
+    x, y = collect(d[:x]), collect(d[:y])
+    d_out[:name] = d[:label]
+    st = d[:seriestype]
+    isscatter = st in (:scatter, :scatter3d, :scattergl)
+    hasmarker = isscatter || d[:markershape] != :none
+    # hasline = !isscatter
+    hasline = st in (:path, :path3d)
+
+    # set the "type"
+    if st in (:path, :scatter, :scattergl)
+        d_out[:type] = st==:scattergl ? "scattergl" : "scatter"
+        d_out[:mode] = if hasmarker
+            hasline ? "lines+markers" : "markers"
+        else
+            hasline ? "lines" : "none"
+        end
+        if d[:fillrange] == true || d[:fillrange] == 0
+            d_out[:fill] = "tozeroy"
+            d_out[:fillcolor] = webcolor(d[:fillcolor], d[:fillalpha])
+        elseif !(d[:fillrange] in (false, nothing))
+            warn("fillrange ignored... plotly only supports filling to zero. fillrange: $(d[:fillrange])")
+        end
+        d_out[:x], d_out[:y] = x, y
+
+    elseif st == :shape
+        # to draw polygons, we actually draw lines with fill
+        d_out[:type] = "scatter"
+        d_out[:mode] = "lines"
+        d_out[:x], d_out[:y] = plotly_close_shapes(x, y)
+        # @show map(length, (x,y,d_out[:x],d_out[:y]))
+        # @show d_out[:x] d_out[:y]
+        d_out[:fill] = "tozeroy"
+        d_out[:fillcolor] = webcolor(d[:fillcolor], d[:fillalpha])
+        if d[:markerstrokewidth] > 0
+            d_out[:line] = KW(
+                :color => webcolor(d[:linecolor], d[:linealpha]),
+                :width => d[:linewidth],
+                :dash => string(d[:linestyle]),
+            )
+        end
+
+
+
+    elseif st == :bar
+        d_out[:type] = "bar"
+        d_out[:x], d_out[:y] = x, y
+        d_out[:orientation] = isvertical(d) ? "v" : "h"
+
+    # elseif st == :histogram2d
+    #     d_out[:type] = "histogram2d"
+    #     d_out[:x], d_out[:y] = x, y
+    #     if isa(d[:bins], Tuple)
+    #         xbins, ybins = d[:bins]
+    #     else
+    #         xbins = ybins = d[:bins]
+    #     end
+    #     d_out[:nbinsx] = xbins
+    #     d_out[:nbinsy] = ybins
+    #     d_out[:colorscale] = plotly_colorscale(d[:fillcolor], d[:fillalpha])
+
+    # elseif st in (:histogram, :density)
+    #     d_out[:type] = "histogram"
+    #     isvert = isvertical(d)
+    #     d_out[isvert ? :x : :y] = y
+    #     d_out[isvert ? :nbinsx : :nbinsy] = d[:bins]
+    #     if st == :density
+    #         d_out[:histogramnorm] = "probability density"
+    #     end
+
+    elseif st == :heatmap
+        d_out[:type] = "heatmap"
+        d_out[:x], d_out[:y], d_out[:z] = d[:x], d[:y], transpose_z(d, d[:z].surf, false)
+        d_out[:colorscale] = plotly_colorscale(d[:fillcolor], d[:fillalpha])
+
+    elseif st == :contour
+        d_out[:type] = "contour"
+        d_out[:x], d_out[:y], d_out[:z] = d[:x], d[:y], transpose_z(d, d[:z].surf, false)
+        # d_out[:showscale] = d[:colorbar] != :none
+        d_out[:ncontours] = d[:levels]
+        d_out[:contours] = KW(:coloring => d[:fillrange] != nothing ? "fill" : "lines")
+        d_out[:colorscale] = plotly_colorscale(d[:linecolor], d[:linealpha])
+
+    elseif st in (:surface, :wireframe)
+        d_out[:type] = "surface"
+        d_out[:x], d_out[:y], d_out[:z] = d[:x], d[:y], transpose_z(d, d[:z].surf, false)
+        d_out[:colorscale] = plotly_colorscale(d[:fillcolor], d[:fillalpha])
+
+    elseif st == :pie
+        d_out[:type] = "pie"
+        d_out[:labels] = pie_labels(sp, series)
+        d_out[:values] = y
+        d_out[:hoverinfo] = "label+percent+name"
+
+    elseif st in (:path3d, :scatter3d)
+        d_out[:type] = "scatter3d"
+        d_out[:mode] = if hasmarker
+            hasline ? "lines+markers" : "markers"
+        else
+            hasline ? "lines" : "none"
+        end
+        d_out[:x], d_out[:y] = x, y
+        d_out[:z] = collect(d[:z])
+
+    else
+        warn("Plotly: seriestype $st isn't supported.")
+        return KW()
+    end
+
+    # add "marker"
+    if hasmarker
+        d_out[:marker] = KW(
+            :symbol => get(_plotly_markers, d[:markershape], string(d[:markershape])),
+            :opacity => d[:markeralpha],
+            :size => 2 * d[:markersize],
+            :color => webcolor(d[:markercolor], d[:markeralpha]),
+            :line => KW(
+                :color => webcolor(d[:markerstrokecolor], d[:markerstrokealpha]),
+                :width => d[:markerstrokewidth],
+            ),
+        )
+
+        # gotta hack this (for now?) since plotly can't handle rgba values inside the gradient
+        if d[:marker_z] != nothing
+            # d_out[:marker][:color] = d[:marker_z]
+            # d_out[:marker][:colorscale] = plotly_colorscale(d[:markercolor], d[:markeralpha])
+            # d_out[:showscale] = true
+            grad = ColorGradient(d[:markercolor], alpha=d[:markeralpha])
+            zmin, zmax = extrema(d[:marker_z])
+            d_out[:marker][:color] = [webcolor(getColorZ(grad, (zi - zmin) / (zmax - zmin))) for zi in d[:marker_z]]
+        end
+    end
+
+    # add "line"
+    if hasline
+        d_out[:line] = KW(
+            :color => webcolor(d[:linecolor], d[:linealpha]),
+            :width => d[:linewidth],
+            :shape => if st == :steppre
+                "vh"
+            elseif st == :steppost
+                "hv"
+            else
+                "linear"
+            end,
+            :dash => string(d[:linestyle]),
+            # :dash => "solid",
+        )
+    end
+
+    # convert polar plots x/y to theta/radius
+    if ispolar(d[:subplot])
+        d_out[:t] = rad2deg(pop!(d_out, :x))
+        d_out[:r] = pop!(d_out, :y)
+    end
+
+    # hover text
+    hover = d[:hover]
+    if hover in (:none, false)
+        d_out[:hoverinfo] = "none"
+    elseif hover != nothing
+        d_out[:hoverinfo] = "text"
+        d_out[:text] = hover
+    end
+
+    d_out
+end
+
+# get a list of dictionaries, each representing the series params
+function plotly_series_json(plt::Plot)
+    JSON.json(map(series -> plotly_series(plt, series), plt.series_list))
+end
+
+# ----------------------------------------------------------------
+
+function html_head(plt::Plot{PlotlyBackend})
+    "<script src=\"$(Pkg.dir("Plots","deps","plotly-latest.min.js"))\"></script>"
+end
+
+function html_body(plt::Plot{PlotlyBackend}, style = nothing)
+    if style == nothing
+        w, h = plt[:size]
+        style = "width:$(w)px;height:$(h)px;"
+    end
+    uuid = Base.Random.uuid4()
+    html = """
+        <div id=\"$(uuid)\" style=\"$(style)\"></div>
+        <script>
+        PLOT = document.getElementById('$(uuid)');
+        Plotly.plot(PLOT, $(plotly_series_json(plt)), $(plotly_layout_json(plt)));
+        </script>
+    """
+    html
+end
+
+function js_body(plt::Plot{PlotlyBackend}, uuid)
+    js = """
+          PLOT = document.getElementById('$(uuid)');
+          Plotly.plot(PLOT, $(plotly_series_json(plt)), $(plotly_layout_json(plt)));
+    """
+end
+
+
+# ----------------------------------------------------------------
+
+
+function _writemime(io::IO, ::MIME"image/png", plt::Plot{PlotlyBackend})
+    writemime_png_from_html(io, plt)
+end
+
+function _writemime(io::IO, ::MIME"image/svg+xml", plt::Plot{PlotlyBackend})
+    write(io, html_head(plt) * html_body(plt))
+end
+
+function _display(plt::Plot{PlotlyBackend})
+    standalone_html_window(plt)
+end

src/backends/plotlyjs.jl

@@ -0,0 +1,76 @@
+
+# https://github.com/spencerlyon2/PlotlyJS.jl
+
+supported_args(::PlotlyJSBackend) = supported_args(PlotlyBackend())
+supported_types(::PlotlyJSBackend) = supported_types(PlotlyBackend())
+supported_styles(::PlotlyJSBackend) = supported_styles(PlotlyBackend())
+supported_markers(::PlotlyJSBackend) = supported_markers(PlotlyBackend())
+supported_scales(::PlotlyJSBackend) = supported_scales(PlotlyBackend())
+is_subplot_supported(::PlotlyJSBackend) = true
+is_string_supported(::PlotlyJSBackend) = true
+
+# --------------------------------------------------------------------------------------
+
+function _initialize_backend(::PlotlyJSBackend; kw...)
+    @eval begin
+        import PlotlyJS
+        export PlotlyJS
+    end
+
+    # # override IJulia inline display
+    # if isijulia()
+    #     IJulia.display_dict(plt::AbstractPlot{PlotlyJSBackend}) = IJulia.display_dict(plt.o)
+    # end
+end
+
+# ---------------------------------------------------------------------------
+
+
+function _create_backend_figure(plt::Plot{PlotlyJSBackend})
+    PlotlyJS.plot()
+end
+
+
+function _series_added(plt::Plot{PlotlyJSBackend}, series::Series)
+    syncplot = plt.o
+    pdict = plotly_series(plt, series)
+    typ = pop!(pdict, :type)
+    gt = PlotlyJS.GenericTrace(typ; pdict...)
+    PlotlyJS.addtraces!(syncplot, gt)
+end
+
+function _series_updated(plt::Plot{PlotlyJSBackend}, series::Series)
+    xsym, ysym = (ispolar(series) ? (:t,:r) : (:x,:y))
+    PlotlyJS.restyle!(
+        plt.o,
+        findfirst(plt.series_list, series),
+        KW(xsym => (series.d[:x],), ysym => (series.d[:y],))
+    )
+end
+
+
+# ----------------------------------------------------------------
+
+function _update_plot_object(plt::Plot{PlotlyJSBackend})
+    pdict = plotly_layout(plt)
+    syncplot = plt.o
+    w,h = plt[:size]
+    PlotlyJS.relayout!(syncplot, pdict, width = w, height = h)
+end
+
+
+# ----------------------------------------------------------------
+
+function _writemime(io::IO, ::MIME"image/svg+xml", plt::Plot{PlotlyJSBackend})
+    writemime(io, MIME("text/html"), plt.o)
+end
+
+function _writemime(io::IO, ::MIME"image/png", plt::Plot{PlotlyJSBackend})
+    tmpfn = tempname() * ".png"
+    PlotlyJS.savefig(plt.o, tmpfn)
+    write(io, read(open(tmpfn)))
+end
+
+function _display(plt::Plot{PlotlyJSBackend})
+    display(plt.o)
+end

src/backends/qwt.jl

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

src/backends/template.jl

@@ -0,0 +1,75 @@
+
+# TODO: find/replace all [PkgName] with CamelCase
+
+# [ADD BACKEND WEBSITE]
+
+function _initialize_backend(::[PkgName]Backend; kw...)
+    @eval begin
+        import [PkgName]
+        export [PkgName]
+        # todo: other initialization that needs to be eval-ed
+    end
+    # todo: other initialization
+end
+
+# ---------------------------------------------------------------------------
+
+# Create the window/figure for this backend.
+function _create_backend_figure(plt::Plot{[PkgName]Backend})
+    nothing
+end
+
+# # this is called early in the pipeline, use it to make the plot current or something
+# function _prepare_plot_object(plt::Plot{[PkgName]Backend})
+# end
+
+# 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
+
+
+# ----------------------------------------------------------------
+
+# Override this to update plot items (title, xlabel, etc), and add annotations (d[:annotations])
+function _update_plot_object(plt::Plot{[PkgName]Backend})
+end
+
+# ----------------------------------------------------------------
+
+# 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 _writemime(io::IO, ::MIME"image/png", plt::Plot{[PkgName]Backend})
+end
+
+# Display/show the plot (open a GUI window, or browser page, for example).
+function _display(plt::Plot{[PkgName]Backend})
+end

src/backends/unicodeplots.jl

@@ -0,0 +1,163 @@
+
+# https://github.com/Evizero/UnicodePlots.jl
+
+supported_args(::UnicodePlotsBackend) = merge_with_base_supported([
+    :label,
+    :legend,
+    :seriescolor,
+    :seriesalpha,
+    :linestyle,
+    :markershape,
+    :bins,
+    :title,
+    :guide, :lims,
+  ])
+supported_types(::UnicodePlotsBackend) = [
+    :path, :scatter,
+    :histogram2d
+]
+supported_styles(::UnicodePlotsBackend) = [:auto, :solid]
+supported_markers(::UnicodePlotsBackend) = [:none, :auto, :circle]
+supported_scales(::UnicodePlotsBackend) = [:identity]
+is_subplot_supported(::UnicodePlotsBackend) = true
+
+
+# don't warn on unsupported... there's just too many warnings!!
+warnOnUnsupported_args(pkg::UnicodePlotsBackend, d::KW) = nothing
+
+# --------------------------------------------------------------------------------------
+
+function _initialize_backend(::UnicodePlotsBackend; kw...)
+    @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)
+    plt.o = []
+
+    for sp in plt.subplots
+        xaxis = sp[:xaxis]
+        yaxis = sp[:yaxis]
+        xlim =  axis_limits(xaxis)
+        ylim =  axis_limits(yaxis)
+
+        # 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
+        width, height = plt[:size]
+        canvas_type = isijulia() ? UnicodePlots.AsciiCanvas : UnicodePlots.BrailleCanvas
+        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
+end
+
+
+# add a single series
+function addUnicodeSeries!(o, d::KW, addlegend::Bool, xlim, ylim)
+    # get the function, or special handling for step/bar/hist
+    st = d[:seriestype]
+    if st == :histogram2d
+        UnicodePlots.densityplot!(o, d[:x], d[:y])
+        return
+    end
+
+    if st == :path
+        func = UnicodePlots.lineplot!
+    elseif st == :scatter || d[:markershape] != :none
+        func = UnicodePlots.scatterplot!
+    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] : ""
+
+    # 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)
+end
+
+# -------------------------------
+
+# since this is such a hack, it's only callable using `png`... should error during normal `writemime`
+function png(plt::AbstractPlot{UnicodePlotsBackend}, fn::AbstractString)
+    fn = addExtension(fn, "png")
+
+    # make some whitespace and show the plot
+    println("\n\n\n\n\n\n")
+    gui(plt)
+
+    # @osx_only begin
+    @compat @static if is_apple()
+        # BEGIN HACK
+
+        # 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)")
+end
+
+# -------------------------------
+
+# we don't do very much for subplots... just stack them vertically
+
+function _update_plot_object(plt::Plot{UnicodePlotsBackend})
+  w, h = plt[:size]
+  plt.attr[:size] = div(w, 10), div(h, 20)
+  plt.attr[:color_palette] = [RGB(0,0,0)]
+  rebuildUnicodePlot!(plt)
+end
+
+function _writemime(io::IO, ::MIME"text/plain", plt::Plot{UnicodePlotsBackend})
+  map(show, plt.o)
+  nothing
+end
+
+
+function _display(plt::Plot{UnicodePlotsBackend})
+  map(show, plt.o)
+  nothing
+end
+

src/backends/web.jl

@@ -0,0 +1,66 @@
+
+# NOTE:  backend should implement `html_body` and `html_head`
+
+# CREDIT: parts of this implementation were inspired by @joshday's PlotlyLocal.jl
+
+
+function standalone_html(plt::AbstractPlot; title::AbstractString = get(plt.attr, :window_title, "Plots.jl"))
+    """
+    <!DOCTYPE html>
+    <html>
+        <head>
+            <title>$title</title>
+            $(html_head(plt))
+        </head>
+        <body>
+            $(html_body(plt))
+        </body>
+    </html>
+    """
+end
+
+function open_browser_window(filename::AbstractString)
+    @compat @static if is_apple()
+        return run(`open $(filename)`)
+    end
+    @compat @static if is_linux()
+        return run(`xdg-open $(filename)`)
+    end
+    @compat @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.attr[:window_title])
+    filename = string(tempname(), ".html")
+    output = open(filename, "w")
+    write(output, html)
+    close(output)
+    filename
+end
+
+function standalone_html_window(plt::AbstractPlot)
+    filename = write_temp_html(plt)
+    open_browser_window(filename)
+end
+
+# uses wkhtmltopdf/wkhtmltoimage: http://wkhtmltopdf.org/downloads.html
+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)
+    # 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.attr[:size]
+    html_to_png(html_fn, png_fn, w, h)
+
+    # now read that file data into io
+    pngdata = readall(png_fn)
+    write(io, pngdata)
+end

src/backends/winston.jl

@@ -0,0 +1,272 @@
+
+# https://github.com/nolta/Winston.jl
+
+# credit goes to https://github.com/jverzani for contributing to the first draft of this backend implementation
+
+supported_args(::WinstonBackend) = merge_with_base_supported([
+    :annotations,
+    :linecolor,
+    :fillrange,
+    :fillcolor,
+    :label,
+    :legend,
+    :seriescolor, :seriesalpha,
+    :linestyle,
+    :linewidth,
+    :markershape,
+    :markercolor,
+    :markersize,
+    :bins,
+    :title,
+    :window_title,
+    :guide, :lims, :scale,
+  ])
+supported_types(::WinstonBackend) = [:path, :scatter, :bar]
+supported_styles(::WinstonBackend) = [:auto, :solid, :dash, :dot, :dashdot]
+supported_markers(::WinstonBackend) = [:none, :auto, :rect, :circle, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5]
+supported_scales(::WinstonBackend) = [:identity, :log10]
+is_subplot_supported(::WinstonBackend) = false
+
+
+# --------------------------------------------------------------------------------------
+
+
+function _initialize_backend(::WinstonBackend; kw...)
+  @eval begin
+    # ENV["WINSTON_OUTPUT"] = "gtk"
+    warn("Winston is no longer supported... many features will likely be broken.")
+    import Winston, Gtk
+    export Winston, Gtk
+  end
+end
+
+# ---------------------------------------------------------------------------
+
+
+## dictionaries for conversion of Plots.jl names to Winston ones.
+@compat const winston_linestyle =  KW(:solid=>"solid",
+                                :dash=>"dash",
+                                :dot=>"dotted",
+                                :dashdot=>"dotdashed"
+                               )
+
+@compat const winston_marker = KW(:none=>".",
+                            :rect => "square",
+                            :circle=>"circle",
+                            :diamond=>"diamond",
+                            :utriangle=>"triangle",
+                            :dtriangle=>"down-triangle",
+                            :cross => "plus",
+                            :xcross => "cross",
+                            :star5 => "asterisk"
+                           )
+
+function _before_update(plt::Plot{WinstonBackend})
+  Winston.ghf(plt.o)
+end
+
+# ---------------------------------------------------------------------------
+
+function _create_backend_figure(plt::Plot{WinstonBackend})
+    Winston.FramedPlot(
+        title = plt.attr[:title],
+        xlabel = plt.attr[:xguide],
+        ylabel = plt.attr[:yguide]
+    )
+end
+
+copy_remove(d::KW, s::Symbol) = delete!(copy(d), s)
+
+function addRegressionLineWinston(d::KW, wplt)
+  xs, ys = regressionXY(d[:x], d[:y])
+  Winston.add(wplt, Winston.Curve(xs, ys, kind="dotted"))
+end
+
+function getWinstonItems(plt::Plot)
+  if isa(plt.o, Winston.FramedPlot)
+    wplt = plt.o
+    window, canvas = nothing, nothing
+  else
+    window, canvas, wplt = plt.o
+  end
+  window, canvas, wplt
+end
+
+function _series_added(plt::Plot{WinstonBackend}, series::Series)
+    d = series.d
+  window, canvas, wplt = getWinstonItems(plt)
+
+  # until we call it normally, do the hack
+  if d[:seriestype] == :bar
+    d = barHack(;d...)
+  end
+
+
+  e = KW()
+  e[:color] = getColor(d[:linecolor])
+  e[:linewidth] = d[:linewidth]
+  e[:kind] = winston_linestyle[d[:linestyle]]
+  e[:symbolkind] = winston_marker[d[:markershape]]
+  # markercolor     # same choices as `color`, or :match will set the color to be the same as `color`
+  e[:symbolsize] = d[:markersize] / 5
+
+  # pos             # (Int,Int), move the enclosing window to this position
+  # screen          # Integer, move enclosing window to this screen number (for multiscreen desktops)
+
+
+
+  ## lintype :path, :step, :stepinverted, :sticks, :dots, :none, :histogram2d, :hexbin, :histogram, :bar
+  if d[:seriestype] == :none
+    Winston.add(wplt, Winston.Points(d[:x], d[:y]; copy_remove(e, :kind)..., color=getColor(d[:markercolor])))
+
+  elseif d[:seriestype] == :path
+    x, y = d[:x], d[:y]
+    Winston.add(wplt, Winston.Curve(x, y; e...))
+
+    fillrange = d[:fillrange]
+    if fillrange != nothing
+      if isa(fillrange, AbstractVector)
+        y2 = fillrange
+      else
+        y2 = Float64[fillrange for yi in y]
+      end
+      Winston.add(wplt, Winston.FillBetween(x, y, x, y2, fillcolor=getColor(d[:fillcolor])))
+    end
+
+  elseif d[:seriestype] == :scatter
+    if d[:markershape] == :none
+      d[:markershape] = :circle
+    end
+
+  # elseif d[:seriestype] == :step
+  #     fn = Winston.XXX
+
+  # elseif d[:seriestype] == :stepinverted
+  #     fn = Winston.XXX
+
+  elseif d[:seriestype] == :sticks
+      Winston.add(wplt, Winston.Stems(d[:x], d[:y]; e...))
+
+  # elseif d[:seriestype] == :dots
+  #     fn = Winston.XXX
+
+  # elseif d[:seriestype] == :histogram2d
+  #     fn = Winston.XXX
+
+  # elseif d[:seriestype] == :hexbin
+  #     fn = Winston.XXX
+
+  elseif d[:seriestype] == :histogram
+      hst = hist(d[:y], d[:bins])
+      Winston.add(wplt, Winston.Histogram(hst...; copy_remove(e, :bins)...))
+
+  # elseif d[:seriestype] == :bar
+  #     # fn = Winston.XXX
+
+  else
+    error("seriestype $(d[:seriestype]) not supported by Winston.")
+
+  end
+
+
+  # markershape
+  if d[:markershape] != :none
+    Winston.add(wplt, Winston.Points(d[:x], d[:y]; copy_remove(e, :kind)..., color=getColor(d[:markercolor])))
+  end
+
+
+  # optionally add a regression line
+  d[:smooth] && d[:seriestype] != :histogram && addRegressionLineWinston(d, wplt)
+
+  # push!(plt.seriesargs, d)
+  # plt
+end
+
+
+# ----------------------------------------------------------------
+
+@compat const _winstonNames = KW(
+    :xlims => :xrange,
+    :ylims => :yrange,
+    :xscale => :xlog,
+    :yscale => :ylog,
+  )
+
+function _update_plot_object(plt::Plot{WinstonBackend}, d::KW)
+  window, canvas, wplt = getWinstonItems(plt)
+  for k in (:xguide, :yguide, :title, :xlims, :ylims)
+    if haskey(d, k)
+      Winston.setattr(wplt, string(get(_winstonNames, k, k)), d[k])
+    end
+  end
+
+  for k in (:xscale, :yscale)
+    if haskey(d, k)
+      islogscale = d[k] == :log10
+      Winston.setattr(wplt, (k == :xscale ? :xlog : :ylog), islogscale)
+    end
+  end
+
+end
+
+
+
+# ----------------------------------------------------------------
+
+function createWinstonAnnotationObject(plt::Plot{WinstonBackend}, x, y, val::@compat(AbstractString))
+  Winston.text(x, y, val)
+end
+
+function _add_annotations{X,Y,V}(plt::Plot{WinstonBackend}, anns::AVec{@compat(Tuple{X,Y,V})})
+  for ann in anns
+    createWinstonAnnotationObject(plt, ann...)
+  end
+end
+
+
+# ----------------------------------------------------------------
+
+# function _create_subplot(subplt::Subplot{WinstonBackend}, isbefore::Bool)
+#   # TODO: build the underlying Subplot object.  this is where you might layout the panes within a GUI window, for example
+# end
+
+# ----------------------------------------------------------------
+
+function addWinstonLegend(plt::Plot, wplt)
+  if plt.attr[:legend] != :none
+    Winston.legend(wplt, [sd[:label] for sd in plt.seriesargs])
+  end
+end
+
+function Base.writemime(io::IO, ::MIME"image/png", plt::AbstractPlot{WinstonBackend})
+  window, canvas, wplt = getWinstonItems(plt)
+  addWinstonLegend(plt, wplt)
+  writemime(io, "image/png", wplt)
+end
+
+
+function Base.display(::PlotsDisplay, plt::Plot{WinstonBackend})
+
+  window, canvas, wplt = getWinstonItems(plt)
+
+  if window == nothing
+    if Winston.output_surface != :gtk
+      error("Gtk is the only supported display for Winston in Plots.  Set `output_surface = gtk` in src/Winston.ini")
+    end
+    # initialize window
+    w,h = plt.attr[:size]
+    canvas = Gtk.GtkCanvasLeaf()
+    window = Gtk.GtkWindowLeaf(canvas, plt.attr[:window_title], w, h)
+    plt.o = (window, canvas, wplt)
+  end
+
+  addWinstonLegend(plt, wplt)
+
+  Winston.display(canvas, wplt)
+  Gtk.showall(window)
+end
+
+
+# function Base.display(::PlotsDisplay, subplt::Subplot{WinstonBackend})
+#   # TODO: display/show the Subplot object
+# end

src/colors.jl

@@ -0,0 +1,413 @@
+
+abstract ColorScheme
+
+Base.getindex(scheme::ColorScheme, i::Integer) = getColor(scheme, i)
+
+export
+    cgrad
+
+cgrad() = default_gradient()
+
+function cgrad(arg, values = nothing; alpha = nothing, scale = :identity)
+    colors = ColorGradient(arg, alpha=alpha).colors
+    values = if values != nothing
+        values
+    elseif scale in (:log, :log10)
+        log10(linspace(1,10,30))
+    elseif scale == :log2
+        log2(linspace(1,2,30))
+    elseif scale == :ln
+        log(linspace(1,pi,30))
+    elseif scale in (:exp, :exp10)
+        (exp10(linspace(0,1,30)) - 1) / 9
+    else
+        linspace(0, 1, length(colors))
+    end
+    ColorGradient(colors, values)
+end
+
+# --------------------------------------------------------------
+
+getColor(scheme::ColorScheme) = getColor(scheme, 1)
+getColorVector(scheme::ColorScheme) = [getColor(scheme)]
+
+colorscheme(scheme::ColorScheme) = scheme
+colorscheme(s::Symbol; kw...) = haskey(_gradients, s) ? ColorGradient(s; kw...) : ColorWrapper(convertColor(s); kw...)
+colorscheme{T<:Real}(s::Symbol, vals::AVec{T}; kw...) = ColorGradient(s, vals; kw...)
+colorscheme(cs::AVec, vs::AVec; kw...) = ColorGradient(cs, vs; kw...)
+colorscheme{T<:Colorant}(cs::AVec{T}; kw...) = ColorGradient(cs; kw...)
+colorscheme(f::Function; kw...) = ColorFunction(f; kw...)
+colorscheme(v::AVec; kw...) = ColorVector(v; kw...)
+colorscheme(m::AMat; kw...) = size(m,1) == 1 ? map(c->colorscheme(c; kw...), m) : [colorscheme(m[:,i]; kw...) for i in 1:size(m,2)]'
+colorscheme(c::Colorant; kw...) = ColorWrapper(c; kw...)
+
+
+# --------------------------------------------------------------
+
+
+convertColor(c::AbstractString) = parse(Colorant, c)
+convertColor(c::Symbol) = parse(Colorant, string(c))
+convertColor(c::Colorant) = c
+convertColor(cvec::AbstractVector) = map(convertColor, cvec)
+convertColor(c::ColorScheme) = c
+convertColor(v::Void) = RGBA(0,0,0,0)
+convertColor(b::Bool) = b ? RGBA(0,0,0,1) : RGBA(0,0,0,0)
+
+function convertColor(c, α::Real)
+  c = convertColor(c)
+  RGBA(RGB(c), α)
+end
+convertColor(cs::AVec, α::Real) = map(c -> convertColor(c, α), cs)
+convertColor(c, α::@compat(Void)) = convertColor(c)
+
+# backup... try to convert
+getColor(c) = convertColor(c)
+
+# --------------------------------------------------------------
+
+function darken(c, v=0.1)
+    rgba = convert(RGBA, c)
+    r = max(0, min(rgba.r - v, 1))
+    g = max(0, min(rgba.g - v, 1))
+    b = max(0, min(rgba.b - v, 1))
+    RGBA(r,g,b,rgba.alpha)
+end
+function lighten(c, v=0.3)
+    darken(c, -v)
+end
+
+# --------------------------------------------------------------
+
+const _rainbowColors = [colorant"blue", colorant"purple", colorant"green", colorant"orange", colorant"red"]
+const _testColors = [colorant"darkblue", colorant"blueviolet",  colorant"darkcyan",colorant"green",
+                     darken(colorant"yellow",0.3), colorant"orange", darken(colorant"red",0.2)]
+
+const _gradients = KW(
+    :blues        => [colorant"lightblue", colorant"darkblue"],
+    :reds         => [colorant"lightpink", colorant"darkred"],
+    :greens       => [colorant"lightgreen", colorant"darkgreen"],
+    :redsblues    => [colorant"darkred", RGB(0.8,0.85,0.8), colorant"darkblue"],
+    :bluesreds    => [colorant"darkblue", RGB(0.8,0.85,0.8), colorant"darkred"],
+    :heat         => [colorant"lightyellow", colorant"orange", colorant"darkred"],
+    :grays        => [RGB(.95,.95,.95),RGB(.05,.05,.05)],
+    :rainbow      => _rainbowColors,
+    :lightrainbow => map(lighten, _rainbowColors),
+    :darkrainbow  => map(darken, _rainbowColors),
+    :darktest     => _testColors,
+    :lighttest    => map(c -> lighten(c, 0.3), _testColors),
+  )
+
+function register_gradient_colors{C<:Colorant}(name::Symbol, colors::AVec{C})
+    _gradients[name] = colors
+end
+
+include("color_gradients.jl")
+
+default_gradient() = ColorGradient(:inferno)
+
+# --------------------------------------------------------------
+
+"Continuous gradient between values.  Wraps a list of bounding colors and the values they represent."
+immutable ColorGradient <: ColorScheme
+  colors::Vector
+  values::Vector
+
+  function ColorGradient{S<:Real}(cs::AVec, vals::AVec{S} = linspace(0, 1, length(cs)); alpha = nothing)
+    if length(cs) == length(vals)
+      return new(convertColor(cs,alpha), collect(vals))
+    end
+
+    # # otherwise interpolate evenly between the minval and maxval
+    # minval, maxval = minimum(vals), maximum(vals)
+    # vs = Float64[interpolate(minval, maxval, w) for w in linspace(0, 1, length(cs))]
+    # new(convertColor(cs,alpha), vs)
+
+    # interpolate the colors for each value
+    vals = merge(linspace(0, 1, length(cs)), vals)
+    grad = ColorGradient(cs)
+    cs = [getColorZ(grad, z) for z in linspace(0, 1, length(vals))]
+    new(convertColor(cs, alpha), vals)
+  end
+end
+
+
+
+Base.getindex(cs::ColorGradient, i::Integer) = getColor(cs, i)
+Base.getindex(cs::ColorGradient, z::Number) = getColorZ(cs, z)
+
+
+# create a gradient from a symbol (blues, reds, etc) and vector of boundary values
+function ColorGradient{T<:Real}(s::Symbol, vals::AVec{T} = 0:0; kw...)
+  haskey(_gradients, s) || error("Invalid gradient symbol.  Choose from: ", sort(collect(keys(_gradients))))
+  cs = _gradients[s]
+  if vals == 0:0
+    vals = linspace(0, 1, length(cs))
+  end
+  ColorGradient(cs, vals; kw...)
+end
+
+# function ColorGradient{T<:Real}(cs::AVec, vals::AVec{T} = linspace(0, 1, length(cs)); kw...)
+#   ColorGradient(map(convertColor, cs), vals; kw...)
+# end
+
+function ColorGradient(grad::ColorGradient; alpha = nothing)
+  ColorGradient(convertColor(grad.colors, alpha), grad.values)
+end
+
+# anything else just gets the default gradient
+function ColorGradient(cw; alpha=nothing)
+    ColorGradient(default_gradient(), alpha=alpha)
+end
+
+getColor(gradient::ColorGradient, idx::Int) = gradient.colors[mod1(idx, length(gradient.colors))]
+
+function getColorZ(gradient::ColorGradient, z::Real)
+  cs = gradient.colors
+  vs = gradient.values
+  n = length(cs)
+  @assert n > 0 && n == length(vs)
+
+  # can we just return the first color?
+  if z <= vs[1] || n == 1
+    return cs[1]
+  end
+
+  # find the bounding colors and interpolate
+  for i in 2:n
+    if z <= vs[i]
+      return interpolate_rgb(cs[i-1], cs[i], (z - vs[i-1]) / (vs[i] - vs[i-1]))
+    end
+  end
+
+  # if we get here, return the last color
+  cs[end]
+end
+
+getColorVector(gradient::ColorGradient) = gradient.colors
+
+# for 0.3
+Colors.RGBA(c::Colorant) = RGBA(red(c), green(c), blue(c), alpha(c))
+Colors.RGB(c::Colorant) = RGB(red(c), green(c), blue(c))
+
+function interpolate_rgb(c1::Colorant, c2::Colorant, w::Real)
+  rgb1 = RGBA(c1)
+  rgb2 = RGBA(c2)
+  r = interpolate(rgb1.r, rgb2.r, w)
+  g = interpolate(rgb1.g, rgb2.g, w)
+  b = interpolate(rgb1.b, rgb2.b, w)
+  a = interpolate(rgb1.alpha, rgb2.alpha, w)
+  RGBA(r, g, b, a)
+end
+
+
+function interpolate(v1::Real, v2::Real, w::Real)
+  (1-w) * v1 + w * v2
+end
+
+# --------------------------------------------------------------
+
+"Wraps a function, taking an index and returning a Colorant"
+immutable ColorFunction <: ColorScheme
+  f::Function
+end
+
+getColor(scheme::ColorFunction, idx::Int) = scheme.f(idx)
+
+# --------------------------------------------------------------
+
+"Wraps a function, taking an z-value and returning a Colorant"
+immutable ColorZFunction <: ColorScheme
+  f::Function
+end
+
+getColorZ(scheme::ColorFunction, z::Real) = scheme.f(z)
+
+# --------------------------------------------------------------
+
+"Wraps a vector of colors... may be vector of Symbol/String/Colorant"
+immutable ColorVector <: ColorScheme
+  v::Vector{Colorant}
+  ColorVector(v::AVec; alpha = nothing) = new(convertColor(v,alpha))
+end
+
+getColor(scheme::ColorVector, idx::Int) = convertColor(scheme.v[mod1(idx, length(scheme.v))])
+getColorVector(scheme::ColorVector) = scheme.v
+
+
+# --------------------------------------------------------------
+
+"Wraps a single color"
+immutable ColorWrapper <: ColorScheme
+  c::RGBA
+  ColorWrapper(c::Colorant; alpha = nothing) = new(convertColor(c, alpha))
+end
+
+ColorWrapper(s::Symbol; alpha = nothing) = ColorWrapper(convertColor(parse(Colorant, s), alpha))
+
+getColor(scheme::ColorWrapper, idx::Int) = scheme.c
+getColorZ(scheme::ColorWrapper, z::Real) = scheme.c
+
+# --------------------------------------------------------------
+
+
+isbackgrounddark(bgcolor::Color) = Lab(bgcolor).l < 0.5
+
+# move closer to lighter/darker depending on background value
+function adjustAway(val, bgval, vmin=0., vmax=100.)
+  if bgval < 0.5 * (vmax+vmin)
+    tmp = max(val, bgval)
+    return 0.5 * (tmp + max(tmp, vmax))
+  else
+    tmp = min(val, bgval)
+    return 0.5 * (tmp + min(tmp, vmin))
+  end
+end
+
+# borrowed from http://stackoverflow.com/a/1855903:
+lightnessLevel(c::Colorant) = 0.299 * red(c) + 0.587 * green(c) + 0.114 * blue(c)
+
+isdark(c::Colorant) = lightnessLevel(c) < 0.5
+islight(c::Colorant) = !isdark(c)
+
+function convertHexToRGB(h::Unsigned)
+  mask = 0x0000FF
+  RGB([(x & mask) / 0xFF for x in  (h >> 16, h >> 8, h)]...)
+end
+
+# note: I found this list of hex values in a comment by Tatarize here: http://stackoverflow.com/a/12224359
+const _masterColorList = [
+    0xFFFFFF, 0x000000, 0x0000FF, 0x00FF00, 0xFF0000, 0x01FFFE, 0xFFA6FE, 0xFFDB66, 0x006401, 0x010067,
+    0x95003A, 0x007DB5, 0xFF00F6, 0xFFEEE8, 0x774D00, 0x90FB92, 0x0076FF, 0xD5FF00, 0xFF937E, 0x6A826C,
+    0xFF029D, 0xFE8900, 0x7A4782, 0x7E2DD2, 0x85A900, 0xFF0056, 0xA42400, 0x00AE7E, 0x683D3B, 0xBDC6FF,
+    0x263400, 0xBDD393, 0x00B917, 0x9E008E, 0x001544, 0xC28C9F, 0xFF74A3, 0x01D0FF, 0x004754, 0xE56FFE,
+    0x788231, 0x0E4CA1, 0x91D0CB, 0xBE9970, 0x968AE8, 0xBB8800, 0x43002C, 0xDEFF74, 0x00FFC6, 0xFFE502,
+    0x620E00, 0x008F9C, 0x98FF52, 0x7544B1, 0xB500FF, 0x00FF78, 0xFF6E41, 0x005F39, 0x6B6882, 0x5FAD4E,
+    0xA75740, 0xA5FFD2, 0xFFB167, 0x009BFF, 0xE85EBE
+  ]
+const _allColors = map(convertHexToRGB, _masterColorList)
+const _darkColors = filter(isdark, _allColors)
+const _lightColors = filter(islight, _allColors)
+const _sortedColorsForDarkBackground = vcat(_lightColors, reverse(_darkColors[2:end]))
+const _sortedColorsForLightBackground = vcat(_darkColors, reverse(_lightColors[2:end]))
+
+const _defaultNumColors = 17
+
+# --------------------------------------------------------------
+
+# Methods to automatically generate gradients for color selection based on
+# background color and a short list of seed colors
+
+# here are some magic constants that could be changed if you really want
+const _lightness_darkbg = [80.0]
+const _lightness_lightbg = [60.0]
+const _lch_c_const = [60]
+
+function adjust_lch(color, l, c)
+    lch = convert(LCHab, color)
+    convert(RGB, LCHab(l, c, lch.h))
+end
+
+function lightness_from_background(bgcolor)
+  bglight = convert(LCHab, bgcolor).l
+  bglight < 50.0 ? _lightness_darkbg[1] : _lightness_lightbg[1]
+end
+
+function gradient_from_list(cs)
+    zvalues = Plots.get_zvalues(length(cs))
+    indices = sortperm(zvalues)
+    sorted_colors = map(RGBA, cs[indices])
+    sorted_zvalues = zvalues[indices]
+    ColorGradient(sorted_colors, sorted_zvalues)
+end
+
+function generate_colorgradient(bgcolor = colorant"white";
+                               color_bases = color_bases=[colorant"steelblue",colorant"orangered"],
+                               lightness = lightness_from_background(bgcolor),
+                               chroma = _lch_c_const[1],
+                               n = _defaultNumColors)
+  seed_colors = vcat(bgcolor, map(c -> adjust_lch(c, lightness, chroma), color_bases))
+  colors = distinguishable_colors(n,
+      seed_colors,
+      lchoices=Float64[lightness],
+      cchoices=Float64[chroma],
+      hchoices=linspace(0, 340, 20)
+    )[2:end]
+  gradient_from_list(colors)
+end
+
+function get_color_palette(palette, bgcolor::Union{Colorant,ColorWrapper}, numcolors::Integer)
+  grad = if palette == :auto
+    generate_colorgradient(bgcolor)
+  else
+    ColorGradient(palette)
+  end
+  zrng = get_zvalues(numcolors)
+  RGBA[getColorZ(grad, z) for z in zrng]
+end
+
+function get_color_palette{C<:Colorant}(palette::Vector{C},
+            bgcolor::Union{Colorant,ColorWrapper}, numcolors::Integer)
+  palette
+end
+
+# ----------------------------------------------------------------------------------
+
+
+function getpctrange(n::Int)
+    n > 0 || error()
+    n == 1 && return zeros(1)
+    zs = [0.0, 1.0]
+    for i in 3:n
+        sorted = sort(zs)
+        diffs = diff(sorted)
+        widestj = 0
+        widest = 0.0
+        for (j,d) in enumerate(diffs)
+            if d > widest
+                widest = d
+                widestj = j
+            end
+        end
+        push!(zs, sorted[widestj] + 0.5 * diffs[widestj])
+    end
+    zs
+end
+
+function get_zvalues(n::Int)
+    offsets = getpctrange(ceil(Int,n/4)+1)/4
+    offsets = vcat(offsets[1], offsets[3:end])
+    zvalues = Float64[]
+    for offset in offsets
+        append!(zvalues, offset + [0.0, 0.5, 0.25, 0.75])
+    end
+    vcat(zvalues[1], 1.0, zvalues[2:n-1])
+end
+
+# ----------------------------------------------------------------------------------
+
+
+make255(x) = round(Int, 255 * x)
+
+function webcolor(c::Color)
+    @sprintf("rgb(%d, %d, %d)", [make255(f(c)) for f in [red,green,blue]]...)
+end
+function webcolor(c::TransparentColor)
+    @sprintf("rgba(%d, %d, %d, %1.3f)", [make255(f(c)) for f in [red,green,blue]]..., alpha(c))
+end
+webcolor(cs::ColorScheme) = webcolor(getColor(cs))
+webcolor(c) = webcolor(convertColor(c))
+webcolor(c, α) = webcolor(convertColor(getColor(c), α))
+
+# ----------------------------------------------------------------------------------
+
+
+# converts a symbol or string into a colorant (Colors.RGB), and assigns a color automatically
+function getSeriesRGBColor(c, sp::Subplot, n::Int)
+
+  if c == :auto
+    c = autopick(sp[:color_palette], n)
+  end
+
+  # c should now be a subtype of ColorScheme
+  colorscheme(c)
+end

src/components.jl

@@ -0,0 +1,522 @@
+
+
+typealias P2 FixedSizeArrays.Vec{2,Float64}
+typealias P3 FixedSizeArrays.Vec{3,Float64}
+
+nanpush!(a::AbstractVector{P2}, b) = (push!(a, P2(NaN,NaN)); push!(a, b))
+nanappend!(a::AbstractVector{P2}, b) = (push!(a, P2(NaN,NaN)); append!(a, b))
+nanpush!(a::AbstractVector{P3}, b) = (push!(a, P3(NaN,NaN,NaN)); push!(a, b))
+nanappend!(a::AbstractVector{P3}, b) = (push!(a, P3(NaN,NaN,NaN)); append!(a, b))
+compute_angle(v::P2) = (angle = atan2(v[2], v[1]); angle < 0 ? 2π - angle : angle)
+
+# -------------------------------------------------------------
+
+immutable Shape
+    x::Vector{Float64}
+    y::Vector{Float64}
+    function Shape(x::AVec, y::AVec)
+        if x[1] != x[end] || y[1] != y[end]
+            new(vcat(x, x[1]), vcat(y, y[1]))
+        else
+            new(x, y)
+        end
+    end
+end
+Shape(verts::AVec) = Shape(unzip(verts)...)
+
+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)
+    shape.x, shape.y
+end
+
+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 = map(copy, shape_coords(shapes[1]))
+    for shape in shapes[2:end]
+        nanappend!(x, shape.x)
+        nanappend!(y, shape.y)
+    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)]
+end
+
+"interleave 2 vectors into each other (like a zipper's teeth)"
+function weave(x,y; ordering = Vector[x,y])
+  ret = eltype(x)[]
+  done = false
+  while !done
+    for o in ordering
+      try
+          push!(ret, shift!(o))
+      end
+    end
+    done = isempty(x) && isempty(y)
+  end
+  ret
+end
+
+
+"create a star by weaving together points from an outer and inner circle.  `n` is the number of arms"
+function makestar(n; offset = -0.5, radius = 1.0)
+    z1 = offset * π
+    z2 = z1 + π / (n)
+    outercircle = partialcircle(z1, z1 + 2π, n+1, radius)
+    innercircle = partialcircle(z2, z2 + 2π, n+1, 0.4radius)
+    Shape(weave(outercircle, innercircle)[1:end-2])
+end
+
+"create a shape by picking points around the unit circle.  `n` is the number of point/sides, `offset` is the starting angle"
+function makeshape(n; offset = -0.5, radius = 1.0)
+    z = offset * π
+    Shape(partialcircle(z, z + 2π, n+1, radius)[1:end-1])
+end
+
+
+function makecross(; offset = -0.5, radius = 1.0)
+    z2 = offset * π
+    z1 = z2 - π/8
+    outercircle = partialcircle(z1, z1 + 2π, 9, radius)
+    innercircle = partialcircle(z2, z2 + 2π, 5, 0.5radius)
+    Shape(weave(outercircle, innercircle,
+                ordering=Vector[outercircle,innercircle,outercircle])[1:end-2])
+end
+
+
+from_polar(angle, dist) = P2(dist*cos(angle), dist*sin(angle))
+
+function makearrowhead(angle; h = 2.0, w = 0.4)
+    tip = from_polar(angle, h)
+    Shape(P2[(0,0), from_polar(angle - 0.5π, w) - tip,
+        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,
+]
+
+const _shapes = KW(
+    :circle    => makeshape(20),
+    :rect       => makeshape(4, offset=-0.25),
+    :diamond    => makeshape(4),
+    :utriangle  => makeshape(3),
+    :dtriangle  => makeshape(3, offset=0.5),
+    :pentagon   => makeshape(5),
+    :hexagon    => makeshape(6),
+    :heptagon   => makeshape(7),
+    :octagon    => makeshape(8),
+    :cross      => makecross(offset=-0.25),
+    :xcross     => makecross(),
+    :vline      => Shape([(0,1),(0,-1)]),
+    :hline      => Shape([(1,0),(-1,0)]),
+  )
+
+for n in [4,5,6,7,8]
+  _shapes[Symbol("star$n")] = makestar(n)
+end
+
+# -----------------------------------------------------------------------
+
+
+# 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)
+    cx, cy = c
+    for i=1:length(sx)
+        sx[i] = (sx[i] - cx) * x + cx
+        sy[i] = (sy[i] - cy) * y + cy
+    end
+    shape
+end
+
+function Base.scale(shape::Shape, x::Real, y::Real = x, c = center(shape))
+    shapecopy = deepcopy(shape)
+    scale!(shape, x, y, c)
+end
+
+function translate!(shape::Shape, x::Real, y::Real = x)
+    sx, sy = shape_coords(shape)
+    for i=1:length(sx)
+        sx[i] += x
+        sy[i] += y
+    end
+    shape
+end
+
+function translate(shape::Shape, x::Real, y::Real = x)
+    shapecopy = deepcopy(shape)
+    translate!(shape, x, y)
+end
+
+function rotate_x(x::Real, y::Real, Θ::Real, centerx::Real, centery::Real)
+    (x - centerx) * cos(Θ) - (y - centery) * sin(Θ) + centerx
+end
+
+function rotate_y(x::Real, y::Real, Θ::Real, centerx::Real, centery::Real)
+    (y - centery) * cos(Θ) + (x - centerx) * sin(Θ) + centery
+end
+
+function rotate(x::Real, y::Real, θ::Real, c = center(shape))
+    cx, cy = c
+    rotate_x(x, y, Θ, cx, cy), rotate_y(x, y, Θ, cx, cy)
+end
+
+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)
+    end
+    shape
+end
+
+function rotate(shape::Shape, Θ::Real, c = center(shape))
+    shapecopy = deepcopy(shape)
+    rotate!(shapecopy, Θ, c)
+end
+
+# -----------------------------------------------------------------------
+
+
+immutable Font
+  family::AbstractString
+  pointsize::Int
+  halign::Symbol
+  valign::Symbol
+  rotation::Float64
+  color::Colorant
+end
+
+"Create a Font from a list of unordered features"
+function font(args...)
+
+  # defaults
+  family = "Helvetica"
+  pointsize = 14
+  halign = :hcenter
+  valign = :vcenter
+  rotation = 0.0
+  color = colorant"black"
+
+  for arg in args
+    T = typeof(arg)
+
+    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)
+      halign = arg
+    elseif arg in (:vcenter, :top, :bottom)
+      valign = arg
+    elseif T <: Colorant
+      color = arg
+    elseif T <: Symbol || T <: AbstractString
+      try
+        color = parse(Colorant, string(arg))
+      catch
+        family = string(arg)
+      end
+    elseif typeof(arg) <: Integer
+      pointsize = arg
+    elseif typeof(arg) <: Real
+      rotation = convert(Float64, arg)
+    else
+      warn("Unused font arg: $arg ($(typeof(arg)))")
+    end
+  end
+
+  Font(family, pointsize, halign, valign, rotation, color)
+end
+
+"Wrap a string with font info"
+immutable PlotText
+  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
+  width
+  color
+  alpha
+  style
+end
+
+function stroke(args...; alpha = nothing)
+  width = nothing
+  color = nothing
+  style = nothing
+
+  for arg in args
+    T = typeof(arg)
+
+    # if arg in _allStyles
+    if allStyles(arg)
+      style = arg
+    elseif T <: Colorant
+      color = arg
+    elseif T <: Symbol || T <: AbstractString
+      try
+        color = parse(Colorant, string(arg))
+      end
+    elseif allAlphas(arg)
+      alpha = arg
+    elseif allReals(arg)
+      width = arg
+    else
+      warn("Unused stroke arg: $arg ($(typeof(arg)))")
+    end
+  end
+
+  Stroke(width, color, alpha, style)
+end
+
+
+immutable Brush
+  size  # fillrange, markersize, or any other sizey attribute
+  color
+  alpha
+end
+
+function brush(args...; alpha = nothing)
+  size = nothing
+  color = nothing
+
+  for arg in args
+    T = typeof(arg)
+
+    if T <: Colorant
+      color = arg
+    elseif T <: Symbol || T <: AbstractString
+      try
+        color = parse(Colorant, string(arg))
+      end
+    elseif allAlphas(arg)
+      alpha = arg
+    elseif allReals(arg)
+      size = arg
+    else
+      warn("Unused brush arg: $arg ($(typeof(arg)))")
+    end
+  end
+
+  Brush(size, color, alpha)
+end
+
+# -----------------------------------------------------------------------
+
+"type which represents z-values for colors and sizes (and anything else that might come up)"
+immutable ZValues
+  values::Vector{Float64}
+  zrange::Tuple{Float64,Float64}
+end
+
+function zvalues{T<:Real}(values::AVec{T}, zrange::Tuple{T,T} = (minimum(values), maximum(values)))
+  ZValues(collect(float(values)), map(Float64, zrange))
+end
+
+# -----------------------------------------------------------------------
+
+abstract AbstractSurface
+
+"represents a contour or surface mesh"
+immutable Surface{M<:AMat} <: AbstractSurface
+  surf::M
+end
+
+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.eltype(surf::Surface) = eltype(surf.surf)
+
+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
+
+# -----------------------------------------------------------------------
+
+# 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
+
+
+# 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
+
+
+# -----------------------------------------------------------------------
+
+type BezierCurve{T <: FixedSizeArrays.Vec}
+  control_points::Vector{T}
+end
+
+@compat function (bc::BezierCurve)(t::Real)
+  p = zero(P2)
+  n = length(bc.control_points)-1
+  for i in 0:n
+      p += bc.control_points[i+1] * binomial(n, i) * (1-t)^(n-i) * t^i
+  end
+  p
+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/contours.jl

@@ -0,0 +1,63 @@
+
+
+# TODO:
+"""
+- load Contours.jl similar to DataFrames
+- method to build grid from x/y/z vectors
+- method to wrap contours creation
+- method to plot contours as custom shapes (TODO: create Stroke and Fill types and add markerstroke/markerfill args)
+
+"""
+
+
+
+# # ----------------------------------------------------------
+# # ----------------------------------------------------------
+
+
+# immutable Vertex
+#   x::Float64
+#   y::Float64
+#   z::Float64
+# end
+
+# immutable Edge
+#   v::Vertex
+#   u::Vertex
+# end
+
+# # ----------------------------------------------------------
+
+# # one rectangle's z-values and the center vertex
+# # z is ordered: topleft, topright, bottomright, bottomleft
+# immutable GridRect
+#   z::Vector{Float64}
+#   center::Vertex
+#   data::Vector{Vertex}
+# end
+
+
+
+# type Grid
+#   xs::Vector{Float64}
+#   ys::Vector{Float64}
+#   rects::Matrix{GridRect}
+# end
+
+# function splitDataEvenly(v::AbstractVector{Float64}, n::Int)
+#   vs = sort(v)
+  
+# end
+
+# # the goal here is to create the vertical and horizontal partitions
+# # which define the grid, so that the data is somewhat evenly split
+# function bucketData(x, y, z)
+
+# end
+
+
+# function buildGrid(x, y, z)
+#   # create 
+# end
+
+

src/examples.jl

@@ -0,0 +1,349 @@
+"""
+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 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 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)]
+    # [:(begin
+    #     x = 1:0.3:20
+    #     y = x
+    #     f(x,y) = sin(x)+cos(y)
+    #     contour(x, y, f, fill=true)
+    # 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, [:+ :h :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/gadfly.jl

@@ -1,134 +0,0 @@
-
-# https://github.com/dcjones/Gadfly.jl
-
-immutable GadflyPackage <: PlottingPackage end
-
-
-# create a blank Gadfly.Plot object
-function plot(pkg::GadflyPackage; kw...)
-  @eval import DataFrames
-
-  plt = Gadfly.Plot()
-  plt.mapping = Dict()
-  plt.data_source = DataFrames.DataFrame()
-  plt.layers = plt.layers[1:0]
-  
-  # add the title, axis labels, and theme
-  d = Dict(kw)
-
-  plt.guides = Gadfly.GuideElement[Gadfly.Guide.xlabel(d[:xlabel]),
-                                   Gadfly.Guide.ylabel(d[:ylabel]),
-                                   Gadfly.Guide.title(d[:title])]
-
-  # add the legend?
-  if d[:legend]
-    unshift!(plt.guides, Gadfly.Guide.manual_color_key("", AbstractString[], Color[]))
-  end
-
-  plt.theme = Gadfly.Theme(background_color = (haskey(d, :background_color) ? d[:background_color] : colorant"white"))
-  
-  Plot(plt, pkg, 0)
-end
-
-function getGeomFromLineType(linetype::Symbol, nbins::Int)
-  linetype == :line && return Gadfly.Geom.line
-  linetype == :dots && return Gadfly.Geom.point
-  linetype == :bar && return Gadfly.Geom.bar
-  linetype == :step && return Gadfly.Geom.step
-  linetype == :hist && return Gadfly.Geom.histogram(bincount=nbins)
-  linetype == :none && return Gadfly.Geom.point  # change this? are we usually pairing no line with scatterplots?
-  linetype == :sticks && return Gadfly.Geom.bar
-  error("linetype $linetype not currently supported with Gadfly")
-end
-
-function getGeoms(linetype::Symbol, marker::Symbol, nbins::Int)
-  geoms = []
-
-  # handle heatmaps (hexbins) specially
-  if linetype in (:heatmap,:hexbin)
-    push!(geoms, Gadfly.Geom.hexbin(xbincount=nbins, ybincount=nbins))
-  else
-
-    # for other linetypes, get the correct Geom
-    push!(geoms, getGeomFromLineType(linetype, nbins))
-
-    # for any marker, add Geom.point
-    if marker != :none
-      push!(geoms, Gadfly.Geom.point)
-    end
-  end
-
-  geoms
-end
-
-
-# plot one data series
-function plot!(::GadflyPackage, plt::Plot; kw...)
-  d = Dict(kw)
-
-  gfargs = []
-
-  # add the Geoms
-  append!(gfargs, getGeoms(d[:linetype], d[:marker], d[:nbins]))
-
-  # set color, line width, and point size
-  theme = Gadfly.Theme(default_color = d[:color],
-                       line_width = d[:width] * Gadfly.px,
-                       default_point_size = d[:markersize] * Gadfly.px)
-  push!(gfargs, theme)
-
-  # add a regression line?
-  if d[:reg]
-    push!(gfargs, Gadfly.Geom.smooth(method=:lm))
-  end
-
-  # for histograms, set x=y
-  x = d[d[:linetype] == :hist ? :y : :x]
-
-  # add to the legend
-  if length(plt.o.guides) > 0 && isa(plt.o.guides[1], Gadfly.Guide.ManualColorKey)
-    push!(plt.o.guides[1].labels, d[:label])
-    push!(plt.o.guides[1].colors, d[:color])
-  end
-
-  if d[:axis] != :left
-    warn("Gadly only supports one y axis")
-  end
-
-  # add the layer to the Gadfly.Plot
-  prepend!(plt.o.layers, Gadfly.layer(unique(gfargs)...; x = x, y = d[:y]))
-  plt
-end
-
-function Base.display(::GadflyPackage, plt::Plot)
-  display(plt.o)
-end
-
-# -------------------------------
-
-function savepng(::GadflyPackage, plt::PlottingObject, fn::String;
-                                    w = 6 * Gadfly.inch,
-                                    h = 4 * Gadfly.inch)
-  Gadfly.draw(Gadfly.PNG(fn, w, h), plt.o)
-end
-
-
-# -------------------------------
-
-# # create the underlying object (each backend will do this differently)
-# o = buildSubplotObject(plts, pkg, layout)
-
-function buildSubplotObject!(::GadflyPackage, subplt::Subplot)
-  i = 0
-  rows = []
-  for rowcnt in subplt.layout.rowcounts
-    push!(rows, Gadfly.hstack([plt.o for plt in subplt.plts[(1:rowcnt) + i]]...))
-    i += rowcnt
-  end
-  subplt.o = Gadfly.vstack(rows...)
-end
-
-
-function Base.display(::GadflyPackage, subplt::Subplot)
-  display(subplt.o)
-end

src/layouts.jl

@@ -0,0 +1,711 @@
+
+# NOTE: (0,0) is the top-left !!!
+
+# allow pixels and percentages
+const px = AbsoluteLength(0.254)
+const pct = Length{:pct, Float64}(1.0)
+
+to_pixels(m::AbsoluteLength) = m.value / 0.254
+
+const _cbar_width = 5mm
+
+@compat Base.:.*(m::Measure, n::Number) = m * n
+@compat Base.:.*(n::Number, m::Measure) = m * n
+@compat Base.:-(m::Measure, a::AbstractArray) = map(ai -> m - ai, a)
+@compat Base.:-(a::AbstractArray, m::Measure) = map(ai -> ai - m, a)
+Base.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
+# @compat Base.:+(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value * (1 + m2.value))
+# @compat Base.:+(m1::Length{:pct}, m2::AbsoluteLength) = AbsoluteLength(m2.value * (1 + m1.value))
+# @compat Base.:-(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value * (1 - m2.value))
+# @compat Base.:-(m1::Length{:pct}, m2::AbsoluteLength) = AbsoluteLength(m2.value * (m1.value - 1))
+
+@compat Base.:*(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value * m2.value)
+@compat Base.:*(m1::Length{:pct}, m2::AbsoluteLength) = AbsoluteLength(m2.value * m1.value)
+@compat Base.:/(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value / m2.value)
+@compat Base.:/(m1::Length{:pct}, m2::AbsoluteLength) = AbsoluteLength(m2.value / m1.value)
+
+
+Base.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))
+
+# @compat Base.:*{T,N}(m1::Length{T,N}, m2::Length{T,N}) = Length{T,N}(m1.value * m2.value)
+ispositive(m::Measure) = m.value > 0
+
+# union together bounding boxes
+@compat function Base.:+(bb1::BoundingBox, bb2::BoundingBox)
+    # 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 in (:left, :right)
+            orighor = oarg
+        elseif oarg in (:top, :bottom)
+            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
+    else
+        1w - x - width 
+    end
+    top = if v_anchor == :top
+        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
+
+# 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
+
+grid(args...; kw...) = GridLayout(args...; kw...)
+
+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))
+    fill!(grid, EmptyLayout(layout))
+    layout
+end
+
+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
+
+leftpad(layout::GridLayout)   = layout.minpad[1]
+toppad(layout::GridLayout)    = layout.minpad[2]
+rightpad(layout::GridLayout)  = layout.minpad[3]
+bottompad(layout::GridLayout) = layout.minpad[4]
+
+
+# here's how this works... first we recursively "update the minimum padding" (which 
+# means to calculate the minimum size needed from the edge of the subplot to plot area)
+# for the whole layout tree.  then we can compute the "padding borders" of this
+# layout as the biggest padding of the children on the perimeter.  then we need to
+# recursively pass those borders back down the tree, one side at a time, but ONLY
+# to those perimeter children.
+
+# leftpad, toppad, rightpad, bottompad
+function _update_min_padding!(layout::GridLayout)
+    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
+
+
+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
+            tot += vi
+        end
+    end
+    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
+
+    # 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)
+
+    # # create a matrix for each minimum padding direction
+    # _update_min_padding!(layout)
+
+    minpad_left   = map(leftpad,   layout.grid)
+    minpad_top    = map(toppad,    layout.grid)
+    minpad_right  = map(rightpad,  layout.grid)
+    minpad_bottom = map(bottompad, layout.grid)
+    # @show minpad_left minpad_top minpad_right minpad_bottom
+
+    # get the max horizontal (left and right) padding over columns,
+    # and max vertical (bottom and top) padding over rows
+    # TODO: add extra padding here
+    pad_left   = maximum(minpad_left,   1)
+    pad_top    = maximum(minpad_top,    2)
+    pad_right  = maximum(minpad_right,  1)
+    pad_bottom = maximum(minpad_bottom, 2)
+    # @show pad_left pad_top pad_right pad_bottom
+
+    # make sure the perimeter match the parent
+    pad_left[1]     = max(pad_left[1], minimum_perimeter[1])
+    pad_top[1]      = max(pad_top[1], minimum_perimeter[2])
+    pad_right[end]  = max(pad_right[end], minimum_perimeter[3])
+    pad_bottom[end] = max(pad_bottom[end], minimum_perimeter[4])
+
+    # scale this up to the total padding in each direction
+    total_pad_horizontal = sum(pad_left + pad_right)
+    total_pad_vertical   = sum(pad_top + pad_bottom)
+    # @show total_pad_horizontal total_pad_vertical
+
+    # now we can compute the total plot area in each direction
+    total_plotarea_horizontal = width(layout)  - total_pad_horizontal
+    total_plotarea_vertical   = height(layout) - total_pad_vertical
+    # @show total_plotarea_horizontal total_plotarea_vertical
+
+    # recompute widths/heights
+    layout.widths = recompute_lengths(layout.widths)
+    layout.heights = recompute_lengths(layout.heights)
+    # @show layout.widths layout.heights
+
+    # normalize widths/heights so they sum to 1
+    # denom_w = sum(layout.widths)
+    # denom_h = sum(layout.heights)
+    # @show layout.widths layout.heights denom_w, denom_h
+
+    # we have all the data we need... lets compute the plot areas and set the bounding boxes
+    for r=1:nr, c=1:nc
+        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
+
+# 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])
+        # @show bbox(sp.parent) sp[:relative_bbox] p_area
+        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
+
+# ----------------------------------------------------------------------
+
+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
+        nc = ceil(Int, numplts / nr)
+    end
+    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_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
+            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
+            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?)
+        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)
+    s = expr.args[1]
+    kw = KW()
+    for (i,arg) in enumerate(expr.args[2:end])
+        add_layout_pct!(kw, arg, i, length(expr.args)-1)
+    end
+    # @show kw
+    :(EmptyLayout(label = $(QuoteNode(s)), width = $(get(kw, :w, QuoteNode(:auto))), height = $(get(kw, :h, QuoteNode(:auto)))))
+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
+function link_axes!(axes::Axis...)
+    a1 = axes[1]
+    for i=2:length(axes)
+        a2 = axes[i]
+        for k in (:extrema, :discrete_values, :continuous_values, :discrete_map)
+            a2[k] = a1[k]
+        end
+    end
+end
+
+# for some vector or matrix of layouts, filter only the Subplots and link those axes
+function link_axes!(a::AbstractArray{AbstractLayout}, axissym::Symbol)
+    subplots = filter(l -> isa(l, Subplot), a)
+    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

src/output.jl

@@ -0,0 +1,270 @@
+
+
+defaultOutputFormat(plt::Plot) = "png"
+
+function png(plt::Plot, fn::AbstractString)
+  fn = addExtension(fn, "png")
+  io = open(fn, "w")
+  writemime(io, MIME("image/png"), plt)
+  close(io)
+end
+png(fn::AbstractString) = png(current(), fn)
+
+function svg(plt::Plot, fn::AbstractString)
+  fn = addExtension(fn, "svg")
+  io = open(fn, "w")
+  writemime(io, MIME("image/svg+xml"), plt)
+  close(io)
+end
+svg(fn::AbstractString) = svg(current(), fn)
+
+
+function pdf(plt::Plot, fn::AbstractString)
+  fn = addExtension(fn, "pdf")
+  io = open(fn, "w")
+  writemime(io, MIME("application/pdf"), plt)
+  close(io)
+end
+pdf(fn::AbstractString) = pdf(current(), fn)
+
+
+function ps(plt::Plot, fn::AbstractString)
+  fn = addExtension(fn, "ps")
+  io = open(fn, "w")
+  writemime(io, MIME("application/postscript"), plt)
+  close(io)
+end
+ps(fn::AbstractString) = ps(current(), fn)
+
+
+function tex(plt::Plot, fn::AbstractString)
+  fn = addExtension(fn, "tex")
+  io = open(fn, "w")
+  writemime(io, MIME("application/x-tex"), plt)
+  close(io)
+end
+tex(fn::AbstractString) = tex(current(), fn)
+
+
+# ----------------------------------------------------------------
+
+
+@compat const _savemap = Dict(
+    "png" => png,
+    "svg" => svg,
+    "pdf" => pdf,
+    "ps"  => ps,
+    "tex" => tex,
+  )
+
+function getExtension(fn::AbstractString)
+  pieces = split(fn, ".")
+  length(pieces) > 1 || error("Can't extract file extension: ", fn)
+  ext = pieces[end]
+  haskey(_savemap, ext) || error("Invalid file extension: ", fn)
+  ext
+end
+
+function addExtension(fn::AbstractString, ext::AbstractString)
+  try
+    oldext = getExtension(fn)
+    if oldext == ext
+      return fn
+    else
+      return "$fn.$ext"
+    end
+  catch
+    return "$fn.$ext"
+  end
+end
+
+function savefig(plt::Plot, fn::AbstractString)
+
+  # get the extension
+  local ext
+  try
+    ext = getExtension(fn)
+  catch
+    # if we couldn't extract the extension, add the default
+    ext = defaultOutputFormat(plt)
+    fn = addExtension(fn, ext)
+  end
+
+  # save it
+  func = get(_savemap, ext) do
+    error("Unsupported extension $ext with filename ", fn)
+  end
+  func(plt, fn)
+end
+savefig(fn::AbstractString) = savefig(current(), fn)
+
+
+# ---------------------------------------------------------
+
+gui(plt::Plot = current()) = display(PlotsDisplay(), 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,
+)
+
+# a backup for html... passes to svg or png depending on the html_output_format arg
+function Base.writemime(io::IO, ::MIME"text/html", plt::Plot)
+    output_type = Symbol(plt.attr[:html_output_format])
+    if output_type == :auto
+        output_type = get(_best_html_output_type, backend_name(plt.backend), :svg)
+    end
+    if output_type == :png
+        # info("writing png to html output")
+        print(io, "<img src=\"data:image/png;base64,", base64encode(writemime, MIME("image/png"), plt), "\" />")
+    elseif output_type == :svg
+        # info("writing svg to html output")
+        writemime(io, MIME("image/svg+xml"), plt)
+    elseif output_type == :txt
+        writemime(io, MIME("text/plain"), plt)
+    else
+        error("only png or svg allowed. got: $output_type")
+    end
+end
+
+# for writing to io streams... first prepare, then callback
+for mime in keys(_mimeformats)
+    @eval function _writemime(io::IO, m, plt::Plot)
+        warn("_writemime is not defined for this backend. m=", string(m))
+    end
+    @eval function _display(plt::Plot)
+        warn("_display is not defined for this backend.")
+    end
+    @eval function Base.writemime(io::IO, m::MIME{Symbol($mime)}, plt::Plot)
+        prepare_output(plt)
+        _writemime(io, m, plt)
+    end
+end
+
+
+# ---------------------------------------------------------
+# A backup, if no PNG generation is defined, is to try to make a PDF and use FileIO to convert
+
+if is_installed("FileIO")
+    @eval begin
+        import FileIO
+        function _writemime(io::IO, ::MIME"image/png", plt::Plot)
+            fn = tempname()
+
+            # first save a pdf file
+            pdf(plt, fn)
+
+            # load that pdf into a FileIO Stream
+            s = FileIO.load(fn * ".pdf")
+
+            # save a png
+            pngfn = fn * ".png"
+            FileIO.save(pngfn, s)
+
+            # now write from the file
+            write(io, readall(open(pngfn)))
+        end
+    end
+end
+
+
+
+
+
+# function html_output_format(fmt)
+#     if fmt == "png"
+#         @eval function Base.writemime(io::IO, ::MIME"text/html", plt::Plot)
+#             print(io, "<img src=\"data:image/png;base64,", base64(writemime, MIME("image/png"), plt), "\" />")
+#         end
+#     elseif fmt == "svg"
+#         @eval function Base.writemime(io::IO, ::MIME"text/html", plt::Plot)
+#             writemime(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 = Compat.ASCIIString["text/html"]
+
+function setup_ijulia()
+    # override IJulia inline display
+    if isijulia()
+        @eval begin
+            import IJulia
+            export set_ijulia_output
+            function set_ijulia_output(mimestr::AbstractString)
+                # info("Setting IJulia output format to $mimestr")
+                global _ijulia_output
+                _ijulia_output[1] = mimestr
+            end
+            function IJulia.display_dict(plt::Plot)
+                global _ijulia_output
+                Dict{Compat.ASCIIString, ByteString}(_ijulia_output[1] => sprint(writemime, _ijulia_output[1], plt))
+            end
+
+            # default text/plain passes to html... handles Interact issues
+            function Base.writemime(io::IO, m::MIME"text/plain", plt::Plot)
+                writemime(io, MIME("text/html"), plt)
+            end
+        end
+        set_ijulia_output("text/html")
+    end
+end
+
+# ---------------------------------------------------------
+# Atom PlotPane
+# ---------------------------------------------------------
+
+function setup_atom()
+    # @require Atom begin
+    if isatom() && get(ENV, "PLOTS_USE_ATOM_PLOTPANE", false) in (true, 1, "1", "true", "yes")
+        # @eval import Atom, Media
+        @eval import Atom
+
+        # connects the render function
+        for T in (GadflyBackend,ImmerseBackend,PyPlotBackend,GRBackend)
+            Atom.Media.media(Plot{T}, Atom.Media.Plot)
+        end
+        # Atom.Media.media{T <: Union{GadflyBackend,ImmerseBackend,PyPlotBackend,GRBackend}}(Plot{T}, Atom.Media.Plot)
+
+        # Atom.displaysize(::Plot) = (535, 379)
+        # Atom.displaytitle(plt::Plot) = "Plots.jl (backend: $(backend(plt)))"
+
+        # this is like "display"... sends an html div with the plot to the PlotPane
+        function Atom.Media.render(pane::Atom.PlotPane, plt::Plot)
+            Atom.Media.render(pane, Atom.div(Atom.d(), Atom.HTML(stringmime(MIME("text/html"), plt))))
+        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
+    end
+end

src/plotter.jl

@@ -1,64 +0,0 @@
-
-
-plot(pkg::PlottingPackage; kw...) = error("plot($pkg; kw...) is not implemented")
-plot!(pkg::PlottingPackage, plt::Plot; kw...) = error("plot!($pkg, plt; kw...) is not implemented")
-Base.display(pkg::PlottingPackage, plt::Plot) = error("display($pkg, plt) is not implemented")
-
-# ---------------------------------------------------------
-
-
-const AVAILABLE_PACKAGES = [:qwt, :gadfly]
-const INITIALIZED_PACKAGES = Set{Symbol}()
-
-type CurrentPackage
-  sym::Symbol
-  pkg::PlottingPackage
-end
-# const CURRENT_PACKAGE = CurrentPackage(:qwt, QwtPackage())
-const CURRENT_PACKAGE = CurrentPackage(:gadfly, GadflyPackage())
-
-
-doc"""
-Returns the current plotting package name.  Initializes package on first call.
-"""
-function plotter()
-
-  currentPackageSymbol = CURRENT_PACKAGE.sym
-  if !(currentPackageSymbol in INITIALIZED_PACKAGES)
-
-    # initialize
-    print("[Plots.jl] Initializing package: $CURRENT_PACKAGE... ")
-    if currentPackageSymbol == :qwt
-      @eval import Qwt
-    elseif currentPackageSymbol == :gadfly
-      @eval import Gadfly
-    else
-      error("Unknown plotter $currentPackageSymbol.  Choose from: $AVAILABLE_PACKAGES")
-    end
-    push!(INITIALIZED_PACKAGES, currentPackageSymbol)
-    println("done.")
-
-  end
-  CURRENT_PACKAGE.pkg
-end
-
-doc"""
-Set the plot backend.  Choose from:  :qwt, :gadfly
-"""
-function plotter!(modname)
-  
-  # set the PlottingPackage
-  if modname == :qwt
-    CURRENT_PACKAGE.pkg = QwtPackage()
-  elseif modname == :gadfly
-    CURRENT_PACKAGE.pkg = GadflyPackage()
-  else
-    error("Unknown plotter $modname.  Choose from: $AVAILABLE_PACKAGES")
-  end
-
-  # update the symbol
-  CURRENT_PACKAGE.sym = modname
-
-  # return the package
-  CURRENT_PACKAGE.pkg
-end

src/precompile.jl

@@ -0,0 +1,468 @@
+function _precompile_()
+    ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
+    precompile(Plots.py_add_series, (Plots.Plot{Plots.PyPlotBackend}, Plots.Series,))
+    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Array{Float64, 1},))
+    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Base.StepRange{Int64, Int64},))
+    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Function,))
+    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Array{Plots.OHLC, 1},))
+    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Array{Float64, 1},))
+    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Base.LinSpace{Float64},))
+    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, DataFrames.DataFrame,))
+    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Array{Int64, 1},))
+    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Array{Union{UTF8String, ASCIIString}, 1},))
+    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Array{Function, 1},))
+    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Array{ASCIIString, 1},))
+    precompile(Plots._plot!, (Plots.Plot{Plots.UnicodePlotsBackend}, Base.Dict{Symbol, Any},))
+    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Base.FloatRange{Float64},))
+    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any},))
+    precompile(Plots._plot!, (Plots.Plot{Plots.UnicodePlotsBackend}, Base.Dict{Symbol, Any}, Array{Float64, 1},))
+    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Array{Float64, 2},))
+    precompile(Plots._add_defaults!, (Base.Dict{Symbol, Any}, Plots.Plot{Plots.UnicodePlotsBackend}, Plots.Subplot{Plots.UnicodePlotsBackend}, Int64,))
+    precompile(Plots._before_layout_calcs, (Plots.Plot{Plots.PyPlotBackend},))
+    precompile(Plots._apply_series_recipe, (Plots.Plot{Plots.UnicodePlotsBackend}, Base.Dict{Symbol, Any},))
+    precompile(Plots._add_defaults!, (Base.Dict{Symbol, Any}, Plots.Plot{Plots.PyPlotBackend}, Plots.Subplot{Plots.PyPlotBackend}, Int64,))
+    precompile(Plots._apply_series_recipe, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any},))
+    precompile(Plots.setup_ijulia, ())
+    precompile(Plots.call, (Type{Plots.Plot{Plots.UnicodePlotsBackend}}, Plots.UnicodePlotsBackend, Int64, Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Array{Plots.Series, 1}, Void, Array{Plots.Subplot, 1}, Base.Dict{Any, Plots.Subplot}, Plots.EmptyLayout, Array{Plots.Subplot, 1}, Bool,))
+    precompile(Plots.expand_extrema!, (Plots.Subplot{Plots.UnicodePlotsBackend}, Base.Dict{Symbol, Any},))
+    precompile(Plots.create_grid_vcat, (Expr,))
+    precompile(Plots.expand_extrema!, (Plots.Subplot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any},))
+    precompile(Plots.update_child_bboxes!, (Plots.GridLayout, Array{Measures.Length{:mm, Float64}, 1},))
+    precompile(Plots.preprocessArgs!, (Base.Dict{Symbol, Any},))
+    precompile(Plots.call, (Type{Plots.Plot{Plots.PyPlotBackend}}, Plots.PyPlotBackend, Int64, Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Array{Plots.Series, 1}, Void, Array{Plots.Subplot, 1}, Base.Dict{Any, Plots.Subplot}, Plots.EmptyLayout, Array{Plots.Subplot, 1}, Bool,))
+    precompile(Plots.fix_xy_lengths!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any},))
+    precompile(Plots._update_min_padding!, (Plots.Subplot{Plots.PyPlotBackend},))
+    precompile(Plots.warnOnUnsupported_args, (Plots.PyPlotBackend, Base.Dict{Symbol, Any},))
+    precompile(Plots.build_layout, (Plots.GridLayout, Int64,))
+    precompile(Plots.build_layout, (Plots.GridLayout, Int64, Array{Plots.Plot, 1},))
+    precompile(Plots.warnOnUnsupported, (Plots.UnicodePlotsBackend, Base.Dict{Symbol, Any},))
+    precompile(Plots.link_axes!, (Plots.GridLayout, Symbol,))
+    precompile(Plots.warnOnUnsupported, (Plots.PyPlotBackend, Base.Dict{Symbol, Any},))
+    precompile(Plots._update_plot_args, (Plots.Plot{Plots.UnicodePlotsBackend}, Base.Dict{Symbol, Any},))
+    precompile(Plots.font, (Int64,))
+    precompile(Plots.recompute_lengths, (Array{Measures.Measure, 1},))
+    precompile(Plots._update_plot_object, (Plots.Plot{Plots.PyPlotBackend},))
+    precompile(Plots.font, (Symbol,))
+    precompile(Plots.create_grid, (Expr,))
+    precompile(Plots.slice_arg!, (Array{Any, 1}, Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Symbol, Void, Int64,))
+    precompile(Plots.pickDefaultBackend, ())
+    precompile(Plots.default_should_widen, (Plots.Axis,))
+    precompile(Plots.setup_atom, ())
+    precompile(Plots.slice_arg!, (Array{Any, 1}, Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Symbol, Symbol, Int64,))
+    precompile(Plots.my_hist_2d, (Array{Any, 1}, Array{Float64, 1}, Array{Float64, 1}, Int64,))
+    precompile(Plots.slice_arg!, (Array{Any, 1}, Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Symbol, ASCIIString, Int64,))
+    precompile(Plots.create_grid_curly, (Expr,))
+    precompile(Plots.slice_arg!, (Array{Any, 1}, Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Symbol, Bool, Int64,))
+    precompile(Plots.slice_arg!, (Array{Any, 1}, Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Symbol, Int64, Int64,))
+    precompile(Plots.my_hist, (Array{Any, 1}, Array{Float64, 1}, Int64,))
+    precompile(Plots.getpctrange, (Int64,))
+    precompile(Plots.call, (Type{Plots.ColorGradient}, Array{Symbol, 1},))
+    precompile(Plots.default, (Symbol,))
+    precompile(Plots.process_axis_arg!, (Base.Dict{Symbol, Any}, Symbol, Symbol,))
+    precompile(Plots.pie_labels, (Plots.Subplot{Plots.PyPlotBackend}, Plots.Series,))
+    precompile(Plots.slice_arg!, (Array{Any, 1}, Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Symbol, Measures.Length{:mm, Float64}, Int64,))
+    precompile(Plots.py_path, (Array{Float64, 1}, Array{Float64, 1},))
+    precompile(Plots._update_min_padding!, (Plots.GridLayout,))
+    precompile(Plots.warnOnUnsupported_scales, (Plots.UnicodePlotsBackend, Base.Dict{Symbol, Any},))
+    precompile(Plots.slice_arg!, (Array{Any, 1}, Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Symbol, Plots.Font, Int64,))
+    precompile(Plots.process_axis_arg!, (Base.Dict{Symbol, Any}, Tuple{Int64, Int64}, Symbol,))
+    precompile(Plots.slice_arg!, (Array{Any, 1}, Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Symbol, Array{Any, 1}, Int64,))
+    precompile(Plots.default, (Symbol, Tuple{Int64, Int64},))
+    precompile(Plots.warnOnUnsupported_scales, (Plots.PyPlotBackend, Base.Dict{Symbol, Any},))
+    precompile(Plots.axis_limits, (Plots.Axis, Bool,))
+    precompile(Plots.default, (Symbol, Bool,))
+    precompile(Plots.getColorZ, (Plots.ColorGradient, Float64,))
+    precompile(Plots._update_plot_args, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any},))
+    precompile(Plots.call, (Type{Plots.Surface}, Function, Base.FloatRange{Float64}, Base.FloatRange{Float64},))
+    precompile(Plots.font, (Symbol,))
+    precompile(Plots.process_axis_arg!, (Base.Dict{Symbol, Any}, Base.StepRange{Int64, Int64}, Symbol,))
+    precompile(Plots.call, (Array{Any, 1}, Type{Plots.Subplot}, Plots.UnicodePlotsBackend,))
+    precompile(Plots.extractGroupArgs, (Array{ASCIIString, 1}, Array{Float64, 1},))
+    precompile(Plots._update_subplot_args, (Array{Any, 1}, Plots.Plot{Plots.UnicodePlotsBackend}, Plots.Subplot{Plots.UnicodePlotsBackend}, Base.Dict{Symbol, Any}, Int64,))
+    precompile(Plots.call, (Array{Any, 1}, Type{Plots.Subplot}, Plots.PyPlotBackend,))
+    precompile(Plots._update_subplot_args, (Array{Any, 1}, Plots.Plot{Plots.PyPlotBackend}, Plots.Subplot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Int64,))
+    precompile(Plots.extractGroupArgs, (Array{Union{UTF8String, ASCIIString}, 1},))
+    precompile(Plots.bbox_to_pcts, (Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}, Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}, Bool,))
+    precompile(Plots.plot, (Array{Any, 1}, Array{Float64, 1},))
+    precompile(Plots.py_marker, (Plots.Shape,))
+    precompile(Plots.getindex, (Plots.Subplot{Plots.UnicodePlotsBackend}, Symbol,))
+    precompile(Plots.getindex, (Plots.Subplot{Plots.PyPlotBackend}, Symbol,))
+    precompile(Plots.discrete_value!, (Plots.Axis, Array{Union{UTF8String, ASCIIString}, 1},))
+    precompile(Plots.prepare_output, (Plots.Plot{Plots.PyPlotBackend},))
+    precompile(Plots.update_inset_bboxes!, (Plots.Plot{Plots.PyPlotBackend},))
+    precompile(Plots.add_layout_pct!, (Base.Dict{Symbol, Any}, Expr, Int64, Int64,))
+    precompile(Plots.process_axis_arg!, (Base.Dict{Symbol, Any}, ASCIIString, Symbol,))
+    precompile(Plots.call, (Type{Plots.Shape}, Array{Float64, 1}, Array{Float64, 1},))
+    precompile(Plots.plot, (Array{Any, 1}, Base.LinSpace{Float64}, Array{Float64, 2},))
+    precompile(Plots.call, (Array{Any, 1}, Type{Plots.EmptyLayout}, Plots.RootLayout,))
+    precompile(Plots.plot, (Array{Any, 1}, Function, Function,))
+    precompile(Plots.should_add_to_legend, (Plots.Series,))
+    precompile(Plots.plot, (Array{Any, 1}, DataFrames.DataFrame, Symbol,))
+    precompile(Plots.plot, (Array{Any, 1}, Array{Plots.OHLC, 1},))
+    precompile(Plots.convertToAnyVector, (Array{Float64, 2}, Base.Dict{Symbol, Any},))
+    precompile(Plots.plot, (Array{Any, 1}, Array{Float64, 1}, Array{Float64, 1},))
+    precompile(Plots.plot, (Array{Any, 1}, Array{ASCIIString, 1}, Array{Float64, 1},))
+    precompile(Plots.plot!, (Array{Any, 1}, Plots.Plot{Plots.PyPlotBackend}, Array{Float64, 1},))
+    precompile(Plots.processLineArg, (Base.Dict{Symbol, Any}, Symbol,))
+    precompile(Plots.aliasesAndAutopick, (Base.Dict{Symbol, Any}, Symbol, Base.Dict{Symbol, Any}, Array{Symbol, 1}, Int64,))
+    precompile(Plots.plot!, (Array{Any, 1}, Plots.Plot{Plots.PyPlotBackend}, Array{Int64, 1},))
+    precompile(Plots.pie, (Array{Any, 1}, Array{ASCIIString, 1},))
+    precompile(Plots.aliasesAndAutopick, (Base.Dict{Symbol, Any}, Symbol, Base.Dict{Symbol, Any}, Array{Any, 1}, Int64,))
+    precompile(Plots.merge_with_base_supported, (Array{Symbol, 1},))
+    precompile(Plots.histogram2d, (Array{Any, 1}, Array{Float64, 1},))
+    precompile(Plots.plot, (Array{Any, 1}, Base.StepRange{Int64, Int64}, Array{Float64, 2},))
+    precompile(Plots.plot, (Array{Any, 1}, Base.LinSpace{Float64}, Array{Float64, 1},))
+    precompile(Plots.plot, (Array{Any, 1}, Array{Float64, 1}, Array{Float64, 1},))
+    precompile(Plots.font, ())
+    precompile(Plots.plot, (Array{Any, 1}, Base.FloatRange{Float64}, Array{Float64, 1},))
+    precompile(Plots.plot, (Array{Any, 1}, Base.FloatRange{Float64}, Base.FloatRange{Float64},))
+    precompile(Plots.plot, (Array{Any, 1}, Array{Function, 1}, Array{Float64, 1},))
+    precompile(Plots.scatter, (Array{Any, 1}, Base.LinSpace{Float64},))
+    precompile(Plots.plot!, (Array{Any, 1}, Plots.Plot{Plots.PyPlotBackend}, Base.LinSpace{Float64},))
+    precompile(Plots.plot!, (Array{Any, 1}, Base.LinSpace{Float64}, Array{Float64, 1},))
+    precompile(Plots.get_zvalues, (Int64,))
+    precompile(Plots.plot, (Array{Any, 1}, Array{Union{UTF8String, ASCIIString}, 1}, Array{Union{UTF8String, ASCIIString}, 1},))
+    precompile(Plots.histogram, (Array{Any, 1}, Array{Float64, 1},))
+    precompile(Plots.hline!, (Array{Any, 1}, Array{Float64, 2},))
+    precompile(Plots.layout_args, (Base.Dict{Symbol, Any}, Int64,))
+    precompile(Plots.heatmap, (Array{Any, 1}, Array{Union{UTF8String, ASCIIString}, 1},))
+    precompile(Plots._replace_linewidth, (Base.Dict{Symbol, Any},))
+    precompile(Plots.plot!, (Array{Any, 1}, Array{Float64, 1}, Array{Float64, 1},))
+    precompile(Plots.plot!, (Array{Any, 1}, Plots.Plot{Plots.PyPlotBackend}, Array{Float64, 2},))
+    precompile(Plots.py_markercolor, (Base.Dict{Symbol, Any},))
+    precompile(Plots.unzip, (Array{Tuple{Float64, Float64}, 1},))
+    precompile(Plots.link_axes!, (Array{Plots.AbstractLayout, 2}, Symbol,))
+    precompile(Plots.plot!, (Array{Any, 1}, Plots.Plot{Plots.PyPlotBackend}, Array{Float64, 1},))
+    precompile(Plots.contour, (Array{Any, 1}, Base.FloatRange{Float64},))
+    precompile(Plots.scatter, (Array{Any, 1}, DataFrames.DataFrame,))
+    precompile(Plots.scatter!, (Array{Any, 1}, Base.LinSpace{Float64},))
+    precompile(Plots.scatter!, (Array{Any, 1}, Array{Float64, 1},))
+    precompile(Plots.getxy, (Plots.Plot{Plots.PyPlotBackend}, Int64,))
+    precompile(Plots.plot, (Array{Any, 1}, Array{Float64, 2},))
+    precompile(Plots.get_xy, (Array{Plots.OHLC, 1}, Base.UnitRange{Int64},))
+    precompile(Plots.convertToAnyVector, (Array{Function, 1}, Base.Dict{Symbol, Any},))
+    precompile(Plots.py_add_annotations, (Plots.Subplot{Plots.PyPlotBackend}, Int64, Float64, Plots.PlotText,))
+    precompile(Plots.plot!, (Array{Any, 1}, Array{Float64, 1},))
+    precompile(Plots.get_color_palette, (Symbol, ColorTypes.RGB{Float64}, Int64,))
+    precompile(Plots.py_add_annotations, (Plots.Subplot{Plots.PyPlotBackend}, Float64, Float64, Plots.PlotText,))
+    precompile(Plots.py_colormap, (Plots.ColorGradient, Float64,))
+    precompile(Plots.processMarkerArg, (Base.Dict{Symbol, Any}, Plots.Stroke,))
+    precompile(Plots.call, (Type{Plots.ColorVector}, Array{Symbol, 1},))
+    precompile(Plots.py_colormap, (Plots.ColorGradient, Void,))
+    precompile(Plots.py_fillcolor, (Base.Dict{Symbol, Any},))
+    precompile(Plots.processLineArg, (Base.Dict{Symbol, Any}, Float64,))
+    precompile(Plots.plot!, (Array{Any, 1}, Array{Float64, 2},))
+    precompile(Plots.processMarkerArg, (Base.Dict{Symbol, Any}, Symbol,))
+    precompile(Plots.call, (Type{Plots.Plot},))
+    precompile(Plots.call, (Type{Plots.ColorGradient}, Array{ColorTypes.RGBA{Float64}, 1},))
+    precompile(Plots.plot!, (Array{Any, 1}, Array{Int64, 1},))
+    precompile(Plots.getExtension, (UTF8String,))
+    precompile(Plots.call, (Array{Any, 1}, Type{Plots.EmptyLayout},))
+    precompile(Plots.update!, (Array{Any, 1}, Plots.Axis,))
+    precompile(Plots.frame, (Plots.Animation, Plots.Plot{Plots.PyPlotBackend},))
+    precompile(Plots.processMarkerArg, (Base.Dict{Symbol, Any}, Int64,))
+    precompile(Plots.link_axes!, (Array{Plots.AbstractLayout, 1}, Symbol,))
+    precompile(Plots.call, (Type{Plots.ColorGradient}, Array{ColorTypes.RGB{Float64}, 1},))
+    precompile(Plots.fakedata, (Int64,))
+    precompile(Plots.plot!, (Array{Any, 1}, Plots.Plot{Plots.PyPlotBackend},))
+    precompile(Plots.py_compute_axis_minval, (Plots.Axis,))
+    precompile(Plots.processLineArg, (Base.Dict{Symbol, Any}, Int64,))
+    precompile(Plots.command_idx, (Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any},))
+    precompile(Plots.getindex, (Plots.Axis, Symbol,))
+    precompile(Plots.__init__, ())
+    precompile(Plots.isvertical, (Base.Dict{Symbol, Any},))
+    precompile(Plots.getExtension, (ASCIIString,))
+    precompile(Plots.py_marker, (Symbol,))
+    precompile(Plots.py_init_subplot, (Plots.Plot{Plots.PyPlotBackend}, Plots.Subplot{Plots.PyPlotBackend},))
+    precompile(Plots.processMarkerArg, (Base.Dict{Symbol, Any}, ColorTypes.RGBA{Float64},))
+    precompile(Plots.bucket_index, (Float64, Base.LinSpace{Float64},))
+    precompile(Plots.default, (Array{Any, 1},))
+    precompile(Plots.filter_data!, (Base.Dict{Symbol, Any}, Array{Int64, 1},))
+    precompile(Plots.call, (Type{Plots.ColorGradient}, Array{Symbol, 1}, Base.LinSpace{Float64},))
+    precompile(Plots.slice_arg, (Array{Symbol, 2}, Int64,))
+    precompile(Plots.getindex, (Plots.Plot{Plots.UnicodePlotsBackend}, Symbol,))
+    precompile(Plots.plot!, (Array{Any, 1},))
+    precompile(Plots.push!, (Plots.Plot{Plots.PyPlotBackend}, Array{Float64, 1}, Array{Float64, 1},))
+    precompile(Plots.processMarkerArg, (Base.Dict{Symbol, Any}, Float64,))
+    precompile(Plots.expand_extrema!, (Plots.Axis, Base.FloatRange{Float64},))
+    precompile(Plots.getindex, (Plots.Plot{Plots.PyPlotBackend}, Symbol,))
+    precompile(Plots.handle_dfs, (DataFrames.DataFrame, Base.Dict{Symbol, Any}, ASCIIString, Symbol,))
+    precompile(Plots.filter_data, (Base.UnitRange{Int64}, Array{Int64, 1},))
+    precompile(Plots.call, (Type{Plots.ColorWrapper}, ColorTypes.RGBA{Float64},))
+    precompile(Plots.processMarkerArg, (Base.Dict{Symbol, Any}, Array{Symbol, 2},))
+    precompile(Plots.processLineArg, (Base.Dict{Symbol, Any}, Array{Symbol, 2},))
+    precompile(Plots.color_or_nothing!, (Base.Dict{Symbol, Any}, Symbol,))
+    precompile(Plots.processMarkerArg, (Base.Dict{Symbol, Any}, Plots.Shape,))
+    precompile(Plots.py_fillcolormap, (Base.Dict{Symbol, Any},))
+    precompile(Plots.transpose_z, (Base.Dict{Symbol, Any}, Array{Float64, 2}, Bool,))
+    precompile(Plots.py_linecolor, (Base.Dict{Symbol, Any},))
+    precompile(Plots.call, (Type{Plots.OHLC}, Float64, Float64, Float64, Float64,))
+    precompile(Plots.setxy!, (Plots.Plot{Plots.PyPlotBackend}, Tuple{Array{Float64, 1}, Array{Float64, 1}}, Int64,))
+    precompile(Plots.push!, (Plots.Segments, Float64, Float64, Float64, Float64,))
+    precompile(Plots.handle_group, (DataFrames.DataFrame, Base.Dict{Symbol, Any},))
+    precompile(Plots.lightness_from_background, (ColorTypes.RGB{Float64},))
+    precompile(Plots.expand_extrema!, (Plots.Axis, Base.LinSpace{Float64},))
+    precompile(Plots.py_bbox, (Array{Any, 1},))
+    precompile(Plots.py_markerstrokecolor, (Base.Dict{Symbol, Any},))
+    precompile(Plots.arrow, ())
+    precompile(Plots.convert, (Type{Array{Float64, 1}}, Base.StepRange{Int64, Int64},))
+    precompile(Plots.expand_extrema!, (Plots.Axis, Array{Float64, 1},))
+    precompile(Plots.convertLegendValue, (Symbol,))
+    precompile(Plots.slice_arg, (Array{Measures.Length{:mm, Float64}, 2}, Int64,))
+    precompile(Plots.calc_num_subplots, (Plots.GridLayout,))
+    precompile(Plots.processFillArg, (Base.Dict{Symbol, Any}, Int64,))
+    precompile(Plots.slice_arg, (Array{Plots.ColorWrapper, 2}, Int64,))
+    precompile(Plots.slice_arg, (Array{ASCIIString, 2}, Int64,))
+    precompile(Plots.filter_data, (Array{Float64, 1}, Array{Int64, 1},))
+    precompile(Plots.py_linecolormap, (Base.Dict{Symbol, Any},))
+    precompile(Plots.discrete_value!, (Plots.Axis, ASCIIString,))
+    precompile(Plots.allShapes, (ColorTypes.RGBA{Float64},))
+    precompile(Plots.expand_extrema!, (Plots.Axis, Array{Int64, 1},))
+    precompile(Plots.py_color_fix, (Tuple{Float64, Float64, Float64, Float64}, Base.LinSpace{Float64},))
+    precompile(Plots.discrete_value!, (Plots.Axis, Symbol,))
+    precompile(Plots.push!, (Plots.Segments, Float64, Int64, Int64, Float64,))
+    precompile(Plots.expand_extrema!, (Plots.Axis, Plots.Surface{Array{Float64, 2}},))
+    precompile(Plots.heatmap_edges, (Array{Float64, 1},))
+    precompile(Plots.expand_extrema!, (Plots.Axis, Base.StepRange{Int64, Int64},))
+    precompile(Plots.handleColors!, (Base.Dict{Symbol, Any}, Plots.Shape, Symbol,))
+    precompile(Plots.py_color, (Plots.ColorWrapper, Float64,))
+    precompile(Plots.call, (Type{Plots.GridLayout}, Int64, Int64,))
+    precompile(Plots.handleColors!, (Base.Dict{Symbol, Any}, ColorTypes.RGBA{Float64}, Symbol,))
+    precompile(Plots.handleColors!, (Base.Dict{Symbol, Any}, Bool, Symbol,))
+    precompile(Plots.hvline_limits, (Plots.Axis,))
+    precompile(Plots.current, ())
+    precompile(Plots.handleColors!, (Base.Dict{Symbol, Any}, Float64, Symbol,))
+    precompile(Plots.compute_gridsize, (Int64, Int64, Int64,))
+    precompile(Plots.py_color, (ColorTypes.RGB{Float64}, Void,))
+    precompile(Plots.interpolate_rgb, (ColorTypes.RGBA{Float64}, ColorTypes.RGBA{Float64}, Float64,))
+    precompile(Plots.expand_extrema!, (Plots.Axis, Base.UnitRange{Int64},))
+    precompile(Plots.allShapes, (Float64,))
+    precompile(Plots.warn_on_deprecated_backend, (Symbol,))
+    precompile(Plots.py_color_fix, (Tuple{Float64, Float64, Float64, Float64}, Array{Int64, 1},))
+    precompile(Plots.setindex!, (Plots.GridLayout, Plots.EmptyLayout, Int64, Int64,))
+    precompile(Plots.expand_extrema!, (Plots.Axis, Tuple{Int64, Int64},))
+    precompile(Plots.allShapes, (Int64,))
+    precompile(Plots.py_markercolormap, (Base.Dict{Symbol, Any},))
+    precompile(Plots.interpolate_rgb, (ColorTypes.RGB{Float64}, ColorTypes.RGB{Float64}, Float64,))
+    precompile(Plots.get_ticks, (Plots.Axis,))
+    precompile(Plots.backend, ())
+    precompile(Plots.get_xy, (Plots.OHLC{Float64}, Int64, Float64,))
+    precompile(Plots.allShapes, (Plots.Stroke,))
+    precompile(Plots.replaceAliases!, (Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any},))
+    precompile(Plots._create_backend_figure, (Plots.Plot{Plots.PyPlotBackend},))
+    precompile(Plots.png, (Plots.Plot{Plots.PyPlotBackend}, UTF8String,))
+    precompile(Plots.processFillArg, (Base.Dict{Symbol, Any}, Symbol,))
+    precompile(Plots.allShapes, (Plots.Shape,))
+    precompile(Plots.handleColors!, (Base.Dict{Symbol, Any}, Plots.Stroke, Symbol,))
+    precompile(Plots.py_color_fix, (Tuple{Float64, Float64, Float64, Float64}, Array{Float64, 1},))
+    precompile(Plots.plot, (Array{Float64, 1},))
+    precompile(Plots.rowsize, (Expr,))
+    precompile(Plots.get_axis, (Plots.Subplot{Plots.PyPlotBackend}, Symbol,))
+    precompile(Plots.png, (Plots.Plot{Plots.PyPlotBackend}, ASCIIString,))
+    precompile(Plots.expand_extrema!, (Plots.Axis, Tuple{Float64, Float64},))
+    precompile(Plots._markershape_supported, (Plots.PyPlotBackend, Plots.Shape,))
+    precompile(Plots.processFillArg, (Base.Dict{Symbol, Any}, Bool,))
+    precompile(Plots.supported_types, (Plots.PyPlotBackend,))
+    precompile(Plots.get_axis, (Plots.Subplot{Plots.UnicodePlotsBackend}, Symbol,))
+    precompile(Plots.setindex!, (Plots.GridLayout, Plots.GridLayout, Int64, Int64,))
+    precompile(Plots.plot, ())
+    precompile(Plots.py_color_fix, (Tuple{Float64, Float64, Float64, Float64}, Base.FloatRange{Float64},))
+    precompile(Plots._markershape_supported, (Plots.PyPlotBackend, Symbol,))
+    precompile(Plots.ok, (Float64, Float64, Int64,))
+    precompile(Plots.allShapes, (Symbol,))
+    precompile(Plots._initialize_backend, (Plots.PyPlotBackend,))
+    precompile(Plots.plot, (Plots.Plot{Plots.PyPlotBackend}, Plots.Plot{Plots.PyPlotBackend},))
+    precompile(Plots.bar, (Array{Float64, 1},))
+    precompile(Plots.call, (Type{Plots.ColorGradient}, Array{ColorTypes.RGBA{Float64}, 1}, Base.LinSpace{Float64},))
+    precompile(Plots.handleColors!, (Base.Dict{Symbol, Any}, Int64, Symbol,))
+    precompile(Plots.nanappend!, (Array{Float64, 1}, Array{Float64, 1},))
+    precompile(Plots.autopick, (Array{ColorTypes.RGBA, 1}, Int64,))
+    precompile(Plots.compute_xyz, (Void, Array{Int64, 1}, Void,))
+    precompile(Plots._add_markershape, (Base.Dict{Symbol, Any},))
+    precompile(Plots._backend_instance, (Symbol,))
+    precompile(Plots.py_color, (ColorTypes.RGBA{Float64}, Float64,))
+    precompile(Plots.update_child_bboxes!, (Plots.GridLayout,))
+    precompile(Plots._replace_markershape, (Symbol,))
+    precompile(Plots.has_black_border_for_default, (Symbol,))
+    precompile(Plots._filter_input_data!, (Base.Dict{Symbol, Any},))
+    precompile(Plots.compute_xyz, (Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64},))
+    precompile(Plots.text, (ASCIIString, Int64, Symbol,))
+    precompile(Plots.allShapes, (Array{Symbol, 2},))
+    precompile(Plots.py_color_fix, (Tuple{Float64, Float64, Float64, Float64}, Base.UnitRange{Int64},))
+    precompile(Plots.replaceAlias!, (Base.Dict{Symbol, Any}, Symbol, Base.Dict{Symbol, Any},))
+    precompile(Plots.compute_xyz, (Array{ASCIIString, 1}, Array{Float64, 1}, Void,))
+    precompile(Plots.layout_args, (Int64,))
+    precompile(Plots.text, (ASCIIString, Symbol, Int64,))
+    precompile(Plots.compute_xyz, (Base.FloatRange{Float64}, Base.FloatRange{Float64}, Plots.Surface{Array{Float64, 2}},))
+    precompile(Plots.all3D, (Base.Dict{Symbol, Any},))
+    precompile(Plots.cycle, (Array{Plots.Subplot, 1}, Int64,))
+    precompile(Plots.compute_xyz, (Base.StepRange{Int64, Int64}, Array{Float64, 1}, Void,))
+    precompile(Plots.plotarea!, (Plots.Subplot{Plots.PyPlotBackend}, Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}},))
+    precompile(Plots.like_surface, (Symbol,))
+    precompile(Plots.build_layout, (Base.Dict{Symbol, Any},))
+    precompile(Plots.compute_xyz, (Array{Union{UTF8String, ASCIIString}, 1}, Array{Union{UTF8String, ASCIIString}, 1}, Plots.Surface{Array{Float64, 2}},))
+    precompile(Plots.py_linestyle, (Symbol, Symbol,))
+    precompile(Plots.plot!, (Array{Float64, 2},))
+    precompile(Plots.plot!, (Plots.Plot{Plots.PyPlotBackend}, Array{Float64, 2},))
+    precompile(Plots.call, (Type{Plots.ColorGradient}, Array{ColorTypes.RGB{Float64}, 1}, Base.LinSpace{Float64},))
+    precompile(Plots.py_color, (ColorTypes.RGBA{Float64}, Void,))
+    precompile(Plots.yaxis!, (ASCIIString, Symbol,))
+    precompile(Plots.compute_xyz, (Base.LinSpace{Float64}, Array{Float64, 1}, Void,))
+    precompile(Plots.isijulia, ())
+    precompile(Plots.addExtension, (UTF8String, ASCIIString,))
+    precompile(Plots.call, (Type{Plots.ColorGradient}, Array{ColorTypes.RGBA{Float64}, 1}, Array{Float64, 1},))
+    precompile(Plots.expand_extrema!, (Plots.Subplot{Plots.PyPlotBackend}, Float64, Float64, Float64, Float64,))
+    precompile(Plots.plotarea!, (Plots.GridLayout, Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}},))
+    precompile(Plots.layout_args, (Base.Dict{Symbol, Any},))
+    precompile(Plots.compute_xyz, (Base.FloatRange{Float64}, Array{Float64, 1}, Void,))
+    precompile(Plots.addExtension, (ASCIIString, ASCIIString,))
+    precompile(Plots.handleColors!, (Base.Dict{Symbol, Any}, Symbol, Symbol,))
+    precompile(Plots._initialize_backend, (Plots.PlotlyBackend,))
+    precompile(Plots.push!, (Plots.Plot{Plots.PyPlotBackend}, Int64, Float64, Float64,))
+    precompile(Plots.bbox!, (Plots.Subplot{Plots.PyPlotBackend}, Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}},))
+    precompile(Plots.vline!, (Array{Int64, 1},))
+    precompile(Plots.supported_markers, (Plots.PyPlotBackend,))
+    precompile(Plots.bbox!, (Plots.GridLayout, Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}},))
+    precompile(Plots.stroke, (Int64,))
+    precompile(Plots.compute_xyz, (Array{Float64, 1}, Array{Float64, 1}, Void,))
+    precompile(Plots.right, (Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}},))
+    precompile(Plots.extractGroupArgs, (Symbol, DataFrames.DataFrame, Symbol,))
+    precompile(Plots.generate_colorgradient, (ColorTypes.RGB{Float64},))
+    precompile(Plots.expand_extrema!, (Plots.Extrema, Bool,))
+    precompile(Plots.py_colormap, (Plots.ColorWrapper, Void,))
+    precompile(Plots.expand_extrema!, (Plots.Extrema, Float64,))
+    precompile(Plots.contour, (Base.FloatRange{Float64},))
+    precompile(Plots.bottom, (Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}},))
+    precompile(Plots.text, (ASCIIString, Symbol,))
+    precompile(Plots.create_grid, (Symbol,))
+    precompile(Plots.expand_extrema!, (Plots.Axis, Bool,))
+    precompile(Plots.handleColors!, (Base.Dict{Symbol, Any}, Array{Symbol, 2}, Symbol,))
+    precompile(Plots.convertToAnyVector, (Void, Base.Dict{Symbol, Any},))
+    precompile(Plots.py_dpi_scale, (Plots.Plot{Plots.PyPlotBackend}, Int64,))
+    precompile(Plots.png, (ASCIIString,))
+    precompile(Plots.supported_scales, (Plots.PyPlotBackend,))
+    precompile(Plots.convertColor, (ColorTypes.RGBA{Float64}, Float64,))
+    precompile(Plots.extendSeriesData, (Array{Float64, 1}, Float64,))
+    precompile(Plots.compute_xyz, (Void, Array{Float64, 1}, Void,))
+    precompile(Plots.py_color, (Symbol,))
+    precompile(Plots.expand_extrema!, (Plots.Extrema, Int64,))
+    precompile(Plots.supported_styles, (Plots.PyPlotBackend,))
+    precompile(Plots._initialize_backend, (Plots.UnicodePlotsBackend,))
+    precompile(Plots._initialize_backend, (Plots.GRBackend,))
+    precompile(Plots.is3d, (Symbol,))
+    precompile(Plots.supported_types, (Plots.UnicodePlotsBackend,))
+    precompile(Plots.compute_xyz, (Array{Float64, 1}, Function, Void,))
+    precompile(Plots.py_color, (Symbol, Void,))
+    precompile(Plots.trueOrAllTrue, (Function, Array{Symbol, 2},))
+    precompile(Plots.typemin, (Measures.Length{:mm, Float64},))
+    precompile(Plots.expand_extrema!, (Plots.Axis, Float64,))
+    precompile(Plots.get_subplot_index, (Plots.Plot{Plots.UnicodePlotsBackend}, Plots.Subplot{Plots.UnicodePlotsBackend},))
+    precompile(Plots.leftpad, (Plots.GridLayout,))
+    precompile(Plots._update_subplot_args, (Plots.Plot{Plots.UnicodePlotsBackend}, Plots.Subplot{Plots.UnicodePlotsBackend}, Base.Dict{Symbol, Any}, Int64,))
+    precompile(Plots.centers, (Base.LinSpace{Float64},))
+    precompile(Plots.expand_extrema!, (Plots.Axis, Int64,))
+    precompile(Plots.text, (ASCIIString,))
+    precompile(Plots.convertColor, (ColorTypes.RGB{Float64},))
+    precompile(Plots.py_color, (Plots.ColorWrapper, Void,))
+    precompile(Plots.py_color, (Plots.ColorWrapper,))
+    precompile(Plots.trueOrAllTrue, (Function, Int64,))
+    precompile(Plots.convertColor, (ColorTypes.RGBA{Float64},))
+    precompile(Plots.extrema, (Plots.Axis,))
+    precompile(Plots.top, (Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}},))
+    precompile(Plots.convertColor, (Symbol,))
+    precompile(Plots.size, (Plots.Surface{Array{Float64, 2}},))
+    precompile(Plots.isdark, (ColorTypes.RGB{Float64},))
+    precompile(Plots.rowsize, (Symbol,))
+    precompile(Plots.series_list, (Plots.Subplot{Plots.PyPlotBackend},))
+    precompile(Plots.convertToAnyVector, (Array{Float64, 1}, Base.Dict{Symbol, Any},))
+    precompile(Plots.update!, (Plots.Axis,))
+    precompile(Plots.push!, (Plots.Plot{Plots.PyPlotBackend}, Float64, Array{Float64, 1},))
+    precompile(Plots.wraptuple, (Bool,))
+    precompile(Plots.call, (Type{Plots.Shape}, Array{Tuple{Float64, Float64}, 1},))
+    precompile(Plots.slice_arg, (Base.StepRange{Int64, Int64}, Int64,))
+    precompile(Plots.sticks_fillfrom, (Void, Int64,))
+    precompile(Plots.left, (Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}},))
+    precompile(Plots.gr, ())
+    precompile(Plots.leftpad, (Plots.Subplot{Plots.PyPlotBackend},))
+    precompile(Plots.supported_markers, ())
+    precompile(Plots.colorscheme, (Symbol,))
+    precompile(Plots.convertColor, (ColorTypes.RGB{Float64}, Void,))
+    precompile(Plots.isscalar, (Int64,))
+    precompile(Plots.wraptuple, (Int64,))
+    precompile(Plots.call, (Type{Plots.Plot}, Plots.UnicodePlotsBackend, Int64, Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Array{Plots.Series, 1}, Void, Array{Plots.Subplot, 1}, Base.Dict{Any, Plots.Subplot}, Plots.EmptyLayout, Array{Plots.Subplot, 1}, Bool,))
+    precompile(Plots.supported_styles, ())
+    precompile(Plots.frame, (Plots.Animation,))
+    precompile(Plots.toppad, (Plots.Subplot{Plots.PyPlotBackend},))
+    precompile(Plots.link_axes!, (Plots.Subplot{Plots.UnicodePlotsBackend}, Symbol,))
+    precompile(Plots.convertLegendValue, (Bool,))
+    precompile(Plots.convertColor, (ColorTypes.RGBA{Float64}, Void,))
+    precompile(Plots.plotly, ())
+    precompile(Plots.ispositive, (Measures.Length{:mm, Float64},))
+    precompile(Plots.rightpad, (Plots.Subplot{Plots.PyPlotBackend},))
+    precompile(Plots.call, (Type{Plots.GroupBy}, Array{ASCIIString, 1}, Array{Array{Int64, 1}, 1},))
+    precompile(Plots.px2inch, (Int64,))
+    precompile(Plots.slice_arg, (Tuple{Int64, Int64}, Int64,))
+    precompile(Plots.call, (Type{Plots.UnicodePlotsBackend},))
+    precompile(Plots.trueOrAllTrue, (Function, Symbol,))
+    precompile(Plots.bottompad, (Plots.Subplot{Plots.PyPlotBackend},))
+    precompile(Plots.annotate!, (Array{Tuple{Int64, Float64, Plots.PlotText}, 1},))
+    precompile(Plots.get_subplot_index, (Plots.Plot{Plots.PyPlotBackend}, Plots.Subplot{Plots.PyPlotBackend},))
+    precompile(Plots.call, (Type{Plots.Plot}, Plots.PyPlotBackend, Int64, Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Array{Plots.Series, 1}, Void, Array{Plots.Subplot, 1}, Base.Dict{Any, Plots.Subplot}, Plots.EmptyLayout, Array{Plots.Subplot, 1}, Bool,))
+    precompile(Plots.title!, (ASCIIString,))
+    precompile(Plots.slice_arg, (Bool, Int64,))
+    precompile(Plots.wraptuple, (Float64,))
+    precompile(Plots.bottompad, (Plots.GridLayout,))
+    precompile(Plots.py_stepstyle, (Symbol,))
+    precompile(Plots.link_axes!, (Plots.Subplot{Plots.PyPlotBackend}, Symbol,))
+    precompile(Plots.call, (Type{Plots.GRBackend},))
+    precompile(Plots.unicodeplots, ())
+    precompile(Plots.rightpad, (Plots.GridLayout,))
+    precompile(Plots.call, (Type{Plots.PlotlyBackend},))
+    precompile(Plots.py_color, (ColorTypes.RGBA{Float64},))
+    precompile(Plots.toppad, (Plots.GridLayout,))
+    precompile(Plots.calc_edges, (Array{Float64, 1}, Int64,))
+    precompile(Plots.colorscheme, (ColorTypes.RGBA{Float64},))
+    precompile(Plots.slice_arg, (Int64, Int64,))
+    precompile(Plots.pyplot, ())
+    precompile(Plots._update_subplot_args, (Plots.Plot{Plots.PyPlotBackend}, Plots.Subplot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Int64,))
+    precompile(Plots._series_added, (Plots.Plot{Plots.PyPlotBackend}, Plots.Series,))
+    precompile(Plots.get_color_palette, (Array{ColorTypes.RGBA, 1}, ColorTypes.RGB{Float64}, Int64,))
+    precompile(Plots._initialize_subplot, (Plots.Plot{Plots.UnicodePlotsBackend}, Plots.Subplot{Plots.UnicodePlotsBackend},))
+    precompile(Plots.slice_arg, (Void, Int64,))
+    precompile(Plots.cycle, (Int64, Int64,))
+    precompile(Plots._initialize_subplot, (Plots.Plot{Plots.PyPlotBackend}, Plots.Subplot{Plots.PyPlotBackend},))
+    precompile(Plots.call, (Type{Plots.PyPlotBackend},))
+    precompile(Plots.update_child_bboxes!, (Plots.Subplot{Plots.PyPlotBackend}, Array{Measures.Length{:mm, Float64}, 1},))
+    precompile(Plots.filter_data, (Void, Array{Int64, 1},))
+    precompile(Plots.slice_arg, (Symbol, Int64,))
+    precompile(Plots.slice_arg, (ASCIIString, Int64,))
+    precompile(Plots.layout_args, (Plots.GridLayout,))
+    precompile(Plots.wraptuple, (Tuple{},))
+    precompile(Plots.calc_num_subplots, (Plots.EmptyLayout,))
+    precompile(Plots.wraptuple, (Tuple{Symbol, Float64, Plots.Stroke},))
+    precompile(Plots.wraptuple, (Tuple{ASCIIString, Tuple{Int64, Int64}, Base.StepRange{Int64, Int64}, Symbol},))
+    precompile(Plots.wraptuple, (Tuple{Int64, Symbol, Float64, Array{Symbol, 2}},))
+    precompile(Plots.wraptuple, (Tuple{Int64, Array{Symbol, 2}},))
+    precompile(Plots.wraptuple, (Tuple{ASCIIString, Symbol},))
+    precompile(Plots._replace_markershape, (Array{Symbol, 2},))
+    precompile(Plots.wraptuple, (Tuple{Symbol, Int64},))
+    precompile(Plots.wraptuple, (Tuple{Array{Symbol, 2}, Int64},))
+    precompile(Plots.wraptuple, (Tuple{Int64, Symbol, Symbol},))
+    precompile(Plots.wraptuple, (Tuple{Int64, Float64, Symbol, Plots.Stroke},))
+    precompile(Plots.wraptuple, (Tuple{Float64, Array{Symbol, 2}, Int64},))
+    precompile(Plots.py_color, (ColorTypes.RGB{Float64},))
+    precompile(Plots.wraptuple, (Tuple{Int64, Float64, Symbol},))
+    precompile(Plots.tovec, (Array{Float64, 1},))
+    precompile(Plots.get_subplot, (Plots.Plot{Plots.PyPlotBackend}, Plots.Subplot{Plots.PyPlotBackend},))
+    precompile(Plots.eltype, (Plots.Surface{Array{Float64, 2}},))
+    precompile(Plots.nobigs, (Array{Float64, 1},))
+    precompile(Plots.get_subplot, (Plots.Plot{Plots.UnicodePlotsBackend}, Plots.Subplot{Plots.UnicodePlotsBackend},))
+    precompile(Plots.annotations, (Array{Any, 1},))
+    precompile(Plots.wraptuple, (Tuple{Int64, Symbol},))
+    precompile(Plots.colorscheme, (Plots.ColorWrapper,))
+    precompile(Plots.colorscheme, (Plots.ColorGradient,))
+    precompile(Plots.text, (Plots.PlotText,))
+    precompile(Plots._replace_markershape, (Plots.Shape,))
+    precompile(Plots.wraptuple, (Tuple{Array{Symbol, 2}, Int64, Float64, Plots.Stroke},))
+    precompile(Plots.wraptuple, (Tuple{Plots.Shape, Int64, ColorTypes.RGBA{Float64}},))
+end

src/qwt.jl

@@ -1,67 +0,0 @@
-
-# https://github.com/tbreloff/Qwt.jl
-
-immutable QwtPackage <: PlottingPackage end
-
-# -------------------------------
-
-function adjustQwtKeywords(iscreating::Bool; kw...)
-  d = Dict(kw)
-  d[:heatmap_n] = d[:nbins]
-
-  if d[:linetype] == :hexbin
-    d[:linetype] = :heatmap
-  elseif d[:linetype] == :dots
-    d[:linetype] = :none
-    d[:marker] = :hexagon
-  elseif !iscreating && d[:linetype] == :bar
-    return barHack(; kw...)
-  elseif !iscreating && d[:linetype] == :hist
-    return barHack(; histogramHack(; kw...)...)
-  end
-  d
-end
-
-function plot(pkg::QwtPackage; kw...)
-  kw = adjustQwtKeywords(true; kw...)
-  plt = Plot(Qwt.plot(zeros(0,0); kw..., show=false), pkg, 0)
-  plt
-end
-
-function plot!(::QwtPackage, plt::Plot; kw...)
-  kw = adjustQwtKeywords(false; kw...)
-  Qwt.oplot(plt.o; kw...)
-end
-
-function Base.display(::QwtPackage, plt::Plot)
-  Qwt.refresh(plt.o)
-  Qwt.showwidget(plt.o)
-end
-
-# -------------------------------
-
-savepng(::QwtPackage, plt::PlottingObject, fn::String, args...) = Qwt.savepng(plt.o, fn)
-
-# -------------------------------
-
-# # create the underlying object (each backend will do this differently)
-# o = buildSubplotObject(plts, pkg, layout)
-
-function buildSubplotObject!(::QwtPackage, subplt::Subplot)
-  i = 0
-  rows = []
-  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...)
-end
-
-
-function Base.display(::QwtPackage, subplt::Subplot)
-  for plt in subplt.plts
-    Qwt.refresh(plt.o)
-  end
-  Qwt.showwidget(subplt.o)
-end
-

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

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

src/subplot.jl

@@ -1,124 +0,0 @@
-
-
-# create a layout directly
-SubplotLayout(rowcounts::AbstractVector{Int}) = SubplotLayout(sum(rowcounts), rowcounts)
-
-# create a layout given counts... nr/nc == -1 implies we figure out a good number automatically
-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)
-    else
-      nr = ceil(Int, numplts / nc)
-    end
-  else
-    nc = ceil(Int, numplts / nr)
-  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
-
-  SubplotLayout(numplts, rowcounts)
-end
-
-
-Base.length(layout::SubplotLayout) = layout.numplts
-
-
-# ------------------------------------------------------------
-
-
-Base.string(subplt::Subplot) = "Subplot{$(subplt.plotter) 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))
-
-getplot(subplt::Subplot) = subplt.plts[mod1(subplt.n, subplt.p)]
-
-# ------------------------------------------------------------
-
-
-doc"""
-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)
-```
-"""
-function subplot(args...; kw...)
-  d = Dict(kw)
-
-  # figure out the layout
-  if haskey(d, :layout)
-    layout = SubplotLayout(d[:layout])
-  else
-    if !haskey(d, :n)
-      error("You must specify either layout or n when creating a subplot: ", d)
-    end
-    layout = SubplotLayout(d[:n], get(d, :nr, -1), get(d, :nc, -1))
-  end
-
-  # initialize the individual plots
-  pkg = plotter()
-  kw0 = getPlotKeywordArgs(kw, 1, 0)
-  plts = Plot[plot(pkg; kw0..., show=false) for i in 1:length(layout)]
-
-  # create the object and do the plotting
-  subplt = Subplot(nothing, plts, pkg, length(layout), 0, layout)
-  subplot!(subplt, args...; kw...)
-
-  subplt
-end
-
-doc"""
-Adds to a subplot.
-"""
-
-# current subplot
-function subplot!(args...; kw...)
-  subplot!(currentPlot(), 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...)
-  kwList = createKWargsList(subplt, args...; kw...)
-  for (i,d) in enumerate(kwList)
-    subplt.n += 1
-    plt = getplot(subplt)  # get the Plot object where this series will be drawn
-    plot!(plt; d...)
-  end
-
-  # create the underlying object (each backend will do this differently)
-  buildSubplotObject!(subplt.plotter, subplt)
-
-  # set this to be current
-  currentPlot!(subplt)
-
-  # do we want to show it?
-  d = Dict(kw)
-  if haskey(d, :show) && d[:show]
-    draw(subplt)
-  end
-
-  subplt
-end
-
-

src/subplots.jl

@@ -0,0 +1,47 @@
+
+
+function Subplot{T<:AbstractBackend}(::T; parent = RootLayout())
+    Subplot{T}(
+        parent,
+        (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) = idx
+get_subplot_index(plt::Plot, sp::Subplot) = findfirst(_ -> _ === sp, plt.subplots)
+
+series_list(sp::Subplot) = filter(series -> series.d[:subplot] === sp, sp.plt.series_list)
+
+function should_add_to_legend(series::Series)
+    series.d[:primary] && series.d[:label] != "" &&
+        !(series.d[:seriestype] in (
+            :hexbin,:histogram2d,:hline,:vline,
+            :contour,:contour3d,:surface,:wireframe,
+            :heatmap, :pie, :image
+        ))
+end
+
+# ----------------------------------------------------------------------

src/themes.jl

@@ -0,0 +1,65 @@
+
+const _invisible = RGBA(0,0,0,0)
+
+const _themes = KW(
+    :default => KW(
+        :bg         => :white,
+        :bglegend   => :match,
+        :bginside   => :match,
+        :bgoutside  => :match,
+        :fg         => :auto,
+        :fglegend   => :match,
+        :fggrid     => :match,
+        :fgaxis     => :match,
+        :fgtext     => :match,
+        :fgborder   => :match,
+        :fgguide    => :match,
+    )
+)
+
+function add_theme(sym::Symbol, theme::KW)
+    _themes[sym] = theme
+end
+
+# add a new theme, using an existing theme as the base
+function add_theme(sym::Symbol;
+                   base      = :default,  # start with this theme
+                   bg        = _themes[base][:bg],
+                   bglegend  = _themes[base][:bglegend],
+                   bginside  = _themes[base][:bginside],
+                   bgoutside = _themes[base][:bgoutside],
+                   fg        = _themes[base][:fg],
+                   fglegend  = _themes[base][:fglegend],
+                   fggrid    = _themes[base][:fggrid],
+                   fgaxis    = _themes[base][:fgaxis],
+                   fgtext    = _themes[base][:fgtext],
+                   fgborder  = _themes[base][:fgborder],
+                   fgguide   = _themes[base][:fgguide],
+                   kw...)
+    _themes[sym] = merge(KW(
+        :bg => bg,
+        :bglegend  => bglegend,
+        :bginside  => bginside,
+        :bgoutside => bgoutside,
+        :fg        => fg,
+        :fglegend  => fglegend,
+        :fggrid    => fggrid,
+        :fgaxis    => fgaxis,
+        :fgtext    => fgtext,
+        :fgborder  => fgborder,
+        :fgguide   => fgguide,
+    ), KW(kw))
+end
+
+add_theme(:ggplot2,
+    bglegend = _invisible,
+    bginside = :lightgray,
+    fg       = :white,
+    fglegend = _invisible,
+    fgtext   = :gray,
+    fgguide  = :black
+)
+
+function set_theme(sym::Symbol)
+    default(; _themes[sym]...)
+end

src/types.jl

@@ -1,28 +1,94 @@
 
+# 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}
 
-abstract PlottingObject
-abstract PlottingPackage
+immutable PlotsDisplay <: Display end
 
-type Plot <: PlottingObject
-  o  # the underlying object
-  plotter::PlottingPackage
-  n::Int # number of series
+abstract AbstractBackend
+abstract AbstractPlot{T<:AbstractBackend}
+abstract AbstractLayout
+
+# -----------------------------------------------------------
+
+immutable InputWrapper{T}
+    obj::T
+end
+wrap{T}(obj::T) = InputWrapper{T}(obj)
+Base.isempty(wrapper::InputWrapper) = false
+
+
+# -----------------------------------------------------------
+
+# a single subplot
+type Subplot{T<:AbstractBackend} <: AbstractLayout
+    parent::AbstractLayout
+    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
 
+# -----------------------------------------------------------
 
-type SubplotLayout
-  numplts::Int
-  rowcounts::AbstractVector{Int}
+# simple wrapper around a KW so we can hold all attributes pertaining to the axis in one place
+type Axis
+    sp::Subplot
+    d::KW
 end
 
+type Extrema
+    emin::Float64
+    emax::Float64
+end
+Extrema() = Extrema(Inf, -Inf)
 
-type Subplot <: PlottingObject
-  o                           # the underlying object
-  plts::Vector{Plot}          # the individual plots
-  plotter::PlottingPackage
-  p::Int                      # number of plots
-  n::Int                      # number of series
-  layout::SubplotLayout
-end
+# -----------------------------------------------------------
+
+typealias SubplotMap Dict{Any, Subplot}
+
+# -----------------------------------------------------------
+
+type Series
+    d::KW
+end
+
+attr(series::Series, k::Symbol) = series.d[k]
+attr!(series::Series, v, k::Symbol) = (series.d[k] = v)
+
+# -----------------------------------------------------------
+
+type Plot{T<:AbstractBackend} <: AbstractPlot{T}
+    backend::T                   # the backend type
+    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
+
+# TODO: make a decision... should plt[1] return the first subplot or the first series??
+# Base.getindex(plt::Plot, i::Integer) = plt.subplots[i]
+Base.getindex(plt::Plot, s::Symbol) = plt.spmap[s]
+Base.getindex(plt::Plot, r::Integer, c::Integer) = plt.layout[r,c]
+attr(plt::Plot, k::Symbol) = plt.attr[k]
+attr!(plt::Plot, v, k::Symbol) = (plt.attr[k] = v)
+
+
+# -----------------------------------------------------------------------

src/utils.jl

@@ -1,7 +1,7 @@
 
 calcMidpoints(edges::AbstractVector) = Float64[0.5 * (edges[i] + edges[i+1]) for i in 1:length(edges)-1]
 
-doc"Make histogram-like bins of data"
+"Make histogram-like bins of data"
 function binData(data, nbins)
   lo, hi = extrema(data)
   edges = collect(linspace(lo, hi, nbins+1))
@@ -14,31 +14,31 @@ function binData(data, nbins)
   edges, midpoints, buckets, counts
 end
 
-doc"""
+"""
 A hacky replacement for a histogram when the backend doesn't support histograms directly.
 Convert it into a bar chart with the appropriate x/y values.
 """
 function histogramHack(; kw...)
-  d = Dict(kw)
+  d = KW(kw)
 
   # we assume that the y kwarg is set with the data to be binned, and nbins is also defined
-  edges, midpoints, buckets, counts = binData(d[:y], d[:nbins])
+  edges, midpoints, buckets, counts = binData(d[:y], d[:bins])
   d[:x] = midpoints
   d[:y] = float(counts)
-  d[:linetype] = :bar
-  d[:fillto] = d[:fillto] == nothing ? 0.0 : d[:fillto]
+  d[:seriestype] = :bar
+  d[:fillrange] = d[:fillrange] == nothing ? 0.0 : d[:fillrange]
   d
 end
 
-doc"""
+"""
 A hacky replacement for a bar graph when the backend doesn't support bars directly.
-Convert it into a line chart with fillto set.
+Convert it into a line chart with fillrange set.
 """
 function barHack(; kw...)
-  d = Dict(kw)
+  d = KW(kw)
   midpoints = d[:x]
   heights = d[:y]
-  fillto = d[:fillto] == nothing ? 0.0 : d[:fillto]
+  fillrange = d[:fillrange] == nothing ? 0.0 : d[:fillrange]
 
   # estimate the edges
   dists = diff(midpoints) * 0.5
@@ -59,13 +59,715 @@ function barHack(; kw...)
   for i in 1:length(heights)
     e1, e2 = edges[i:i+1]
     append!(x, [e1, e1, e2, e2])
-    append!(y, [fillto, heights[i], heights[i], fillto])
+    append!(y, [fillrange, heights[i], heights[i], fillrange])
   end
 
   d[:x] = x
   d[:y] = y
-  d[:linetype] = :line
-  d[:fillto] = fillto
+  d[:seriestype] = :path
+  d[:fillrange] = fillrange
   d
 end
 
+
+"""
+A hacky replacement for a sticks graph when the backend doesn't support sticks directly.
+Convert it into a line chart that traces the sticks, and a scatter that sets markers at the points.
+"""
+function sticksHack(; kw...)
+  dLine = KW(kw)
+  dScatter = copy(dLine)
+
+  # these are the line vertices
+  x = Float64[]
+  y = Float64[]
+  fillrange = dLine[:fillrange] == nothing ? 0.0 : dLine[:fillrange]
+
+  # calculate the vertices
+  yScatter = dScatter[:y]
+  for (i,xi) in enumerate(dScatter[:x])
+    yi = yScatter[i]
+    for j in 1:3 push!(x, xi) end
+    append!(y, [fillrange, yScatter[i], fillrange])
+  end
+
+  # change the line args
+  dLine[:x] = x
+  dLine[:y] = y
+  dLine[:seriestype] = :path
+  dLine[:markershape] = :none
+  dLine[:fillrange] = nothing
+
+  # change the scatter args
+  dScatter[:seriestype] = :none
+
+  dLine, dScatter
+end
+
+function regressionXY(x, y)
+  # regress
+  β, α = convert(Matrix{Float64}, [x ones(length(x))]) \ convert(Vector{Float64}, y)
+
+  # make a line segment
+  regx = [minimum(x), maximum(x)]
+  regy = β * regx + α
+  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)
+    :heatmap in supported_types() || error("Neither :image or :heatmap are supported!")
+    d[:seriestype] = :heatmap
+    d[:z], d[:fillcolor] = replace_image_with_heatmap(d[:z].surf)
+end
+# ---------------------------------------------------------------
+
+
+type Segments
+    pts::Vector{Float64}
+end
+
+Segments() = Segments(zeros(0))
+
+function Base.push!(segments::Segments, vs...)
+    push!(segments.pts, NaN)
+    for v in vs
+        push!(segments.pts, v)
+    end
+    segments
+end
+
+function Base.push!(segments::Segments, vs::AVec)
+    push!(segments.pts, NaN)
+    for v in vs
+        push!(segments.pts, v)
+    end
+    segments
+end
+
+
+# -----------------------------------------------------
+# helper to manage NaN-separated segments
+
+type SegmentsIterator
+    args::Tuple
+    nextidx::Int
+    n::Int
+end
+function iter_segments(args...)
+    tup = Plots.wraptuple(args)
+    n = maximum(map(length, tup))
+    SegmentsIterator(tup, 0, n)
+end
+
+# helpers to figure out if there are NaN values in a list of array types
+anynan(i::Int, args...) = any(a -> !isfinite(cycle(a,i)), args)
+anynan(istart::Int, iend::Int, args...) = any(i -> anynan(i, args...), istart:iend)
+allnan(istart::Int, iend::Int, args...) = all(i -> anynan(i, args...), istart:iend)
+
+Base.start(itr::SegmentsIterator) = (itr.nextidx = 1) #resets
+Base.done(itr::SegmentsIterator, unused::Int) = itr.nextidx > itr.n
+function Base.next(itr::SegmentsIterator, unused::Int)
+    i = istart = iend = itr.nextidx
+
+    # 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 itr.nextidx
+    while i <= itr.n
+        if !anynan(i, itr.args...)
+            break
+        end
+        i += 1
+    end
+
+    itr.nextidx = i
+    istart:iend, 0
+end
+
+# ------------------------------------------------------------------------------------
+
+
+nop() = nothing
+notimpl() = error("This has not been implemented yet")
+
+Base.cycle(wrapper::InputWrapper, idx::Int) = wrapper.obj
+Base.cycle(wrapper::InputWrapper, idx::AVec{Int}) = wrapper.obj
+
+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, idx::AVec{Int})       = v
+
+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
+
+mapFuncOrFuncs(f::Function, u::AVec)        = map(f, u)
+mapFuncOrFuncs(fs::AVec{Function}, u::AVec) = [map(f, u) for f in fs]
+
+unzip{X,Y}(xy::AVec{Tuple{X,Y}})              = [t[1] for t in xy], [t[2] for t in xy]
+unzip{X,Y,Z}(xyz::AVec{Tuple{X,Y,Z}})         = [t[1] for t in xyz], [t[2] for t in xyz], [t[3] for t in xyz]
+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[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
+    e1, e2 = extrema(x)
+    lims[1] = min(lims[1], e1)
+    lims[2] = max(lims[2], e2)
+  # catch err
+  #   warn(err)
+  end
+  nothing
+end
+
+
+# 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...)
+    for (i,vi) in enumerate(v)
+        if isa(vi, t)
+            v[i] = t(args...; kw...)
+            return
+        end
+    end
+    push!(v, t(args...; kw...))
+    return
+end
+
+function replaceType(vec, val)
+  filter!(x -> !isa(x, typeof(val)), vec)
+  push!(vec, val)
+end
+
+function replaceAlias!(d::KW, k::Symbol, aliases::KW)
+  if haskey(aliases, k)
+    d[aliases[k]] = pop!(d, k)
+  end
+end
+
+function replaceAliases!(d::KW, aliases::KW)
+  ks = collect(keys(d))
+  for k in ks
+      replaceAlias!(d, k, aliases)
+    # if haskey(aliases, k)
+    #   d[aliases[k]] = d[k]
+    #   delete!(d, k)
+    # end
+  end
+end
+
+createSegments(z) = collect(repmat(z',2,1))[2:end]
+
+Base.first(c::Colorant) = c
+Base.first(x::Symbol) = x
+
+
+sortedkeys(d::Dict) = sort(collect(keys(d)))
+
+"create an (n+1) list of the outsides of heatmap rectangles"
+function heatmap_edges(v::AVec)
+  vmin, vmax = extrema(v)
+  extra = 0.5 * (vmax-vmin) / (length(v)-1)
+  vcat(vmin-extra, 0.5 * (v[1:end-1] + v[2:end]), vmax+extra)
+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 * vec(y[r-1,:]) + randn(size(y,2))
+  end
+  y
+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
+isvector(::Any)  = false
+ismatrix(::AMat) = true
+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)
+
+
+# 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(ticks)                                        = :invalid
+
+limsType{T<:Real,S<:Real}(lims::@compat(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)
+
+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]
+
+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)
+    vals = sort(unique(z))
+    vmap = Dict([(v,i) for (i,v) in enumerate(vals)])
+    newz = map(zi -> vmap[zi], z)
+    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::KW, z, transpose_on_match::Bool = true)
+    if d[:match_dimensions] == transpose_on_match
+        z'
+    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
+
+# ---------------------------------------------------------------
+
+wraptuple(x::@compat(Tuple)) = x
+wraptuple(x) = (x,)
+
+trueOrAllTrue(f::Function, x::AbstractArray) = all(f, x)
+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) ||
+                        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)
+allReals(arg)       = trueOrAllTrue(a -> typeof(a) <: Real, arg)
+allFunctions(arg)   = trueOrAllTrue(a -> isa(a, Function), arg)
+
+# ---------------------------------------------------------------
+# ---------------------------------------------------------------
+
+
+"""
+Allows temporary setting of backend and defaults for Plots. Settings apply only for the `do` block.  Example:
+```
+with(:gadfly, size=(400,400), type=:histogram) do
+  plot(rand(10))
+  plot(rand(10))
+end
+```
+"""
+function with(f::Function, args...; kw...)
+    newdefs = KW(kw)
+
+    if :canvas in args
+        newdefs[:xticks] = nothing
+        newdefs[:yticks] = nothing
+        newdefs[:grid] = false
+        newdefs[:legend] = false
+    end
+
+  # dict to store old and new keyword args for anything that changes
+  olddefs = KW()
+  for k in keys(newdefs)
+    olddefs[k] = default(k)
+  end
+
+  # save the backend
+  if CURRENT_BACKEND.sym == :none
+    pickDefaultBackend()
+  end
+  oldbackend = CURRENT_BACKEND.sym
+
+  for arg in args
+
+    # change backend?
+    if arg in backends()
+      backend(arg)
+    end
+
+    # # TODO: generalize this strategy to allow args as much as possible
+    # #       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 = :seriestype
+    # if arg in _allTypes
+    #   olddefs[k] = default(k)
+    #   newdefs[k] = arg
+    # elseif haskey(_typeAliases, arg)
+    #   olddefs[k] = default(k)
+    #   newdefs[k] = _typeAliases[arg]
+    # end
+
+    k = :legend
+    if arg in (k, :leg)
+      olddefs[k] = default(k)
+      newdefs[k] = true
+    end
+
+    k = :grid
+    if arg == k
+      olddefs[k] = default(k)
+      newdefs[k] = true
+    end
+  end
+
+  # display(olddefs)
+  # display(newdefs)
+
+  # now set all those defaults
+  default(; newdefs...)
+
+  # call the function
+  ret = f()
+
+  # put the defaults back
+  default(; olddefs...)
+
+  # revert the backend
+  if CURRENT_BACKEND.sym != oldbackend
+    backend(oldbackend)
+  end
+
+  # return the result of the function
+  ret
+end
+
+# ---------------------------------------------------------------
+# ---------------------------------------------------------------
+
+type DebugMode
+  on::Bool
+end
+const _debugMode = DebugMode(false)
+
+function debugplots(on = true)
+  _debugMode.on = on
+end
+
+debugshow(x) = show(x)
+debugshow(x::AbstractArray) = print(summary(x))
+
+function dumpdict(d::KW, prefix = "", alwaysshow = false)
+  _debugMode.on || alwaysshow || return
+  println()
+  if prefix != ""
+    println(prefix, ":")
+  end
+  for k in sort(collect(keys(d)))
+    @printf("%14s: ", k)
+    debugshow(d[k])
+    println()
+  end
+  println()
+end
+DD(d::KW, prefix = "") = dumpdict(d, prefix, true)
+
+
+function dumpcallstack()
+  error()  # well... you wanted the stacktrace, didn't you?!?
+end
+
+# ---------------------------------------------------------------
+# ---------------------------------------------------------------
+# used in updating an existing series
+
+extendSeriesByOne(v::UnitRange{Int}, n::Int = 1) = isempty(v) ? (1:n) : (minimum(v):maximum(v)+n)
+extendSeriesByOne(v::AVec, n::Integer = 1)       = isempty(v) ? (1:n) : vcat(v, (1:n) + maximum(v))
+extendSeriesData{T}(v::Range{T}, z::Real)        = extendSeriesData(float(collect(v)), z)
+extendSeriesData{T}(v::Range{T}, z::AVec)        = extendSeriesData(float(collect(v)), z)
+extendSeriesData{T}(v::AVec{T}, z::Real)         = (push!(v, convert(T, z)); v)
+extendSeriesData{T}(v::AVec{T}, z::AVec)         = (append!(v, convert(Vector{T}, z)); v)
+
+
+# -------------------------------------------------------
+# NOTE: backends should implement the following methods to get/set the x/y/z data objects
+
+tovec(v::AbstractVector) = v
+tovec(v::Void) = zeros(0)
+
+function getxy(plt::Plot, i::Integer)
+    d = plt.series_list[i].d
+    tovec(d[:x]), tovec(d[:y])
+end
+function getxyz(plt::Plot, i::Integer)
+    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)
+    series = plt.series_list[i]
+    series.d[:x], series.d[:y] = xy
+    sp = series.d[:subplot]
+    expand_extrema!(sp.attr[:xaxis], xy[1])
+    expand_extrema!(sp.attr[:yaxis], xy[2])
+    _series_updated(plt, series)
+end
+function setxyz!{X,Y,Z}(plt::Plot, xyz::Tuple{X,Y,Z}, i::Integer)
+    series = plt.series_list[i]
+    series.d[:x], series.d[:y], series.d[:z] = xyz
+    sp = series.d[:subplot]
+    expand_extrema!(sp.attr[:xaxis], xyz[1])
+    expand_extrema!(sp.attr[:yaxis], xyz[2])
+    expand_extrema!(sp.attr[:zaxis], xyz[3])
+    _series_updated(plt, series)
+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)
+
+# -------------------------------------------------------
+# push/append for one series
+
+# push value to first series
+Base.push!(plt::Plot, y::Real) = push!(plt, 1, y)
+Base.push!(plt::Plot, x::Real, y::Real) = push!(plt, 1, x, y)
+Base.push!(plt::Plot, x::Real, y::Real, z::Real) = push!(plt, 1, x, y, z)
+
+# y only
+function Base.push!(plt::Plot, i::Integer, y::Real)
+    xdata, ydata = getxy(plt, i)
+    setxy!(plt, (extendSeriesByOne(xdata), extendSeriesData(ydata, y)), i)
+    plt
+end
+function Base.append!(plt::Plot, i::Integer, y::AVec)
+    xdata, ydata = plt[i]
+    if !isa(xdata, UnitRange{Int})
+        error("Expected x is a UnitRange since you're trying to push a y value only")
+    end
+    plt[i] = (extendSeriesByOne(xdata, length(y)), extendSeriesData(ydata, y))
+    plt
+end
+
+# x and y
+function Base.push!(plt::Plot, i::Integer, x::Real, y::Real)
+    xdata, ydata = getxy(plt, i)
+    setxy!(plt, (extendSeriesData(xdata, x), extendSeriesData(ydata, y)), i)
+    plt
+end
+function Base.append!(plt::Plot, i::Integer, x::AVec, y::AVec)
+    @assert length(x) == length(y)
+    xdata, ydata = getxy(plt, i)
+    setxy!(plt, (extendSeriesData(xdata, x), extendSeriesData(ydata, y)), i)
+    plt
+end
+
+# x, y, and z
+function Base.push!(plt::Plot, i::Integer, x::Real, y::Real, z::Real)
+    # @show i, x, y, z
+    xdata, ydata, zdata = getxyz(plt, i)
+    # @show xdata, ydata, zdata
+    setxyz!(plt, (extendSeriesData(xdata, x), extendSeriesData(ydata, y), extendSeriesData(zdata, z)), i)
+    plt
+end
+function Base.append!(plt::Plot, i::Integer, x::AVec, y::AVec, z::AVec)
+    @assert length(x) == length(y) == length(z)
+    xdata, ydata, zdata = getxyz(plt, i)
+    setxyz!(plt, (extendSeriesData(xdata, x), extendSeriesData(ydata, y), extendSeriesData(zdata, z)), i)
+    plt
+end
+
+# tuples
+Base.push!{X,Y}(plt::Plot, xy::Tuple{X,Y})                  = push!(plt, 1, xy...)
+Base.push!{X,Y,Z}(plt::Plot, xyz::Tuple{X,Y,Z})             = push!(plt, 1, xyz...)
+Base.push!{X,Y}(plt::Plot, i::Integer, xy::Tuple{X,Y})      = push!(plt, i, xy...)
+Base.push!{X,Y,Z}(plt::Plot, i::Integer, xyz::Tuple{X,Y,Z}) = push!(plt, i, xyz...)
+
+# -------------------------------------------------------
+# push/append for all series
+
+# push y[i] to the ith series
+function Base.push!(plt::Plot, y::AVec)
+    ny = length(y)
+    for i in 1:plt.n
+        push!(plt, i, y[mod1(i,ny)])
+    end
+    plt
+end
+
+# push y[i] to the ith series
+# same x for each series
+function Base.push!(plt::Plot, x::Real, y::AVec)
+    push!(plt, [x], y)
+end
+
+# push (x[i], y[i]) to the ith series
+function Base.push!(plt::Plot, x::AVec, y::AVec)
+    nx = length(x)
+    ny = length(y)
+    for i in 1:plt.n
+        push!(plt, i, x[mod1(i,nx)], y[mod1(i,ny)])
+    end
+    plt
+end
+
+# push (x[i], y[i], z[i]) to the ith series
+function Base.push!(plt::Plot, x::AVec, y::AVec, z::AVec)
+    nx = length(x)
+    ny = length(y)
+    nz = length(z)
+    for i in 1:plt.n
+        push!(plt, i, x[mod1(i,nx)], y[mod1(i,ny)], z[mod1(i,nz)])
+    end
+    plt
+end
+
+
+
+
+# ---------------------------------------------------------------
+
+
+# Some conversion functions
+# note: I borrowed these conversion constants from Compose.jl's Measure
+
+const PX_PER_INCH   = 100
+const DPI           = PX_PER_INCH
+const MM_PER_INCH   = 25.4
+const MM_PER_PX     = MM_PER_INCH / PX_PER_INCH
+
+inch2px(inches::Real)   = float(inches * PX_PER_INCH)
+px2inch(px::Real)       = float(px / PX_PER_INCH)
+inch2mm(inches::Real)   = float(inches * MM_PER_INCH)
+mm2inch(mm::Real)       = float(mm / MM_PER_INCH)
+px2mm(px::Real)         = float(px * MM_PER_PX)
+mm2px(mm::Real)         = float(px / MM_PER_PX)
+
+
+"Smallest x in plot"
+xmin(plt::Plot) = minimum([minimum(series.d[:x]) for series in plt.series_list])
+"Largest x in plot"
+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

@@ -0,0 +1,16 @@
+julia 0.4
+
+RecipesBase
+Colors
+Reexport
+Measures
+FactCheck
+Images
+PyPlot
+@osx QuartzImageIO
+GR
+DataFrames
+RDatasets
+VisualRegressionTests
+UnicodePlots
+Glob

test/imgcomp.jl

@@ -0,0 +1,102 @@
+
+using VisualRegressionTests
+# using ExamplePlots
+
+import DataFrames, RDatasets
+
+# don't let pyplot use a gui... it'll crash
+# note: Agg will set gui -> :none in PyPlot
+ENV["MPLBACKEND"] = "Agg"
+try
+  @eval import PyPlot
+  info("Matplotlib version: $(PyPlot.matplotlib[:__version__])")
+end
+
+
+using Plots, FactCheck
+using Glob
+
+default(size=(500,300))
+
+
+# TODO: use julia's Condition type and the wait() and notify() functions to initialize a Window, then wait() on a condition that
+#       is referenced in a button press callback (the button clicked callback will call notify() on that condition)
+
+const _current_plots_version = v"0.7.4"
+
+
+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()
+
+    # 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"
+
+    # firgure out version info
+    G = glob(relpath(refdir) * "/*")
+    # @show refdir fn G
+    versions = map(fn -> VersionNumber(split(fn,"/")[end]), G)
+    versions = reverse(sort(versions))
+    versions = filter(v -> v <= _current_plots_version, versions)
+    # @show refdir fn versions
+
+    newdir = joinpath(refdir, string(_current_plots_version))
+    newfn = joinpath(newdir, fn)
+
+    # figure out which reference file we should compare to, by finding the highest versioned file
+    reffn = nothing
+    for v in versions
+        tmpfn = joinpath(refdir, string(v), fn)
+        if isfile(tmpfn)
+            reffn = tmpfn
+            break
+        end
+    end
+
+    # 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;
+                                skip = [],      # skip these examples (int index)
+                                only = nothing, # limit to these examples (int index)
+                                debug = false,  # print debug information?
+                                sigma = [1,1],  # number of pixels to "blur"
+                                eps = 1e-2)     # acceptable error (percent)
+  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
+    end
+  end
+end

test/install_wkhtmltoimage.sh

@@ -0,0 +1,22 @@
+#!/bin/sh
+set -ex
+
+# sudo add-apt-repository -y ppa:pov/wkhtmltopdf
+sudo apt-get -qq update
+# sudo apt-get install -y wkhtmltopdf
+
+sudo apt-get install -y xfonts-75dpi
+wget http://download.gna.org/wkhtmltopdf/0.12/0.12.2/wkhtmltox-0.12.2_linux-trusty-amd64.deb
+sudo dpkg -i wkhtmltox-0.12.2_linux-trusty-amd64.deb
+wkhtmltoimage http://www.google.com test.png
+ls
+
+wkhtmltopdf -V
+wkhtmltoimage -V
+
+# echo 'exec xvfb-run -a -s "-screen 0 640x480x16" wkhtmltoimage "$@"' | sudo tee /usr/local/bin/wkhtmltoimage.sh >/dev/null
+# sudo chmod a+x /usr/local/bin/wkhtmltoimage.sh
+
+# export DISPLAY=:99.0
+# sh -e /etc/init.d/xvfb start
+# sleep 3 # give xvfb some time to start

test/runtests.jl

@@ -1,78 +1,91 @@
 module PlotsTests
 
-using Plots
-using FactCheck
+include("imgcomp.jl")
 
 # don't actually show the plots
-plotDefault!(:show, false)
+srand(1234)
+default(show=false, reuse=true)
+img_eps = 5e-2
 
+# facts("Gadfly") do
+#     @fact gadfly() --> Plots.GadflyBackend()
+#     @fact backend() --> Plots.GadflyBackend()
+#
+#     @fact typeof(plot(1:10)) --> Plots.Plot{Plots.GadflyBackend}
+#     @fact plot(Int[1,2,3], rand(3)) --> not(nothing)
+#     @fact plot(sort(rand(10)), rand(Int, 10, 3)) --> not(nothing)
+#     @fact plot!(rand(10,3), rand(10,3)) --> not(nothing)
+#
+#     image_comparison_facts(:gadfly, skip=[4,6,23,24,27], eps=img_eps)
+# end
 
-# note: we wrap in a try block so that the tests only run if we have the backend installed
-try
-  Pkg.installed("Gadfly")
-  facts("Gadfly") do
-    @fact plotter!(:gadfly) --> Plots.GadflyPackage()
-    @fact plotter() --> Plots.GadflyPackage()
-    @fact typeof(plot(1:10)) --> Plot
+facts("PyPlot") do
+    @fact pyplot() --> Plots.PyPlotBackend()
+    @fact backend() --> Plots.PyPlotBackend()
 
-
-    # plot(x::AVec, y::AVec; kw...)              # one line (will assert length(x) == length(y))
-    @fact plot(Int[1,2,3], rand(3)) --> not(nothing)
-    @fact_throws plot(1:5, 1:4)
-
-    # plot(x::AVec, y::AMat; kw...)              # multiple lines (one per column of x), all sharing x (will assert length(x) == size(y,1))
-    @fact plot(sort(rand(10)), rand(Int, 10, 3)) --> not(nothing)
-    @fact_throws(plot!(rand(10), rand(9,2)))
-
-    # plot(x::AMat, y::AMat; kw...)              # multiple lines (one per column of x/y... will assert size(x) == size(y))
-    @fact plot!(rand(10,3), rand(10,3)) --> not(nothing)
-    @fact_throws plot!(rand(10,3), rand(10,2))
-
-
-    # plot(x::AVec, y::AVec{AVec}; kw...)        # multiple lines, will assert length(x) == length(y[i])
-
-
-    # plot(x::AVec{AVec}, y::AVec{AVec}; kw...)  # multiple lines, will assert length(x[i]) == length(y[i])
-    # plot(n::Integer; kw...)                    # n lines, all empty (for updating plots)
-  end
+    image_comparison_facts(:pyplot, skip=[30], eps=img_eps)
 end
 
-# note: we wrap in a try block so that the tests only run if we have the backend installed
-try
-  Pkg.installed("Qwt")
-  facts("Qwt") do
-    @fact plotter!(:qwt) --> Plots.QwtPackage()
-    @fact plotter() --> Plots.QwtPackage()
-    @fact typeof(plot(1:10)) --> Plot
+facts("GR") do
+    @fact gr() --> Plots.GRBackend()
+    @fact backend() --> Plots.GRBackend()
 
-    # plot(y::AVec; kw...)                       # one line... x = 1:length(y)
-    @fact plot(1:10) --> not(nothing)
-    @fact length(currentPlot().o.lines) --> 1
-
-    # plot(x::AVec, f::Function; kw...)          # one line, y = f(x)
-    @fact plot(1:10, sin) --> not(nothing)
-    @fact currentPlot().o.lines[1].y --> sin(collect(1:10))
-
-    # plot(x::AMat, f::Function; kw...)          # multiple lines, yᵢⱼ = f(xᵢⱼ)
-    @fact plot(rand(10,2), sin) --> not(nothing)
-    @fact length(currentPlot().o.lines) --> 2
-
-    # plot(y::AMat; kw...)                       # multiple lines (one per column of x), all sharing x = 1:size(y,1)
-    @fact plot!(rand(10,2)) --> not(nothing)
-    @fact length(currentPlot().o.lines) --> 4
-
-    # plot(x::AVec, fs::AVec{Function}; kw...)   # multiple lines, yᵢⱼ = fⱼ(xᵢ)
-    @fact plot(1:10, Function[sin,cos]) --> not(nothing)
-    @fact currentPlot().o.lines[1].y --> sin(collect(1:10))
-    @fact currentPlot().o.lines[2].y --> cos(collect(1:10))
-
-    # plot(y::AVec{AVec}; kw...)                 # multiple lines, each with x = 1:length(y[i])
-    @fact plot([11:20 ; rand(10)]) --> not(nothing)
-    @fact currentPlot().o.lines[1].x[4] --> 4
-    @fact currentPlot().o.lines[1].y[4] --> 14
-  end
+    @linux_only image_comparison_facts(:gr, skip=[], eps=img_eps)
 end
 
+facts("Plotly") do
+    @fact plotly() --> Plots.PlotlyBackend()
+    @fact backend() --> Plots.PlotlyBackend()
+
+    # # until png generation is reliable on OSX, just test on linux
+    # @linux_only image_comparison_facts(:plotly, only=[1,3,4,7,8,9,10,11,12,14,15,20,22,23,27], eps=img_eps)
+end
+
+
+# facts("Immerse") do
+#     @fact immerse() --> Plots.ImmerseBackend()
+#     @fact backend() --> Plots.ImmerseBackend()
+#
+#     # as long as we can plot anything without error, it should be the same as Gadfly
+#     image_comparison_facts(:immerse, only=[1], eps=img_eps)
+# end
+
+
+# facts("PlotlyJS") do
+#     @fact plotlyjs() --> Plots.PlotlyJSBackend()
+#     @fact backend() --> Plots.PlotlyJSBackend()
+#
+#     # as long as we can plot anything without error, it should be the same as Plotly
+#     image_comparison_facts(:plotlyjs, only=[1], eps=img_eps)
+# end
+
+
+facts("UnicodePlots") do
+    @fact unicodeplots() --> Plots.UnicodePlotsBackend()
+    @fact backend() --> Plots.UnicodePlotsBackend()
+
+    # lets just make sure it runs without error
+    @fact isa(plot(rand(10)), Plot) --> true
+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
+
+
+
 
 FactCheck.exitstatus()
 end # module

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(Pkg.dir("Plots", "test","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 = Pkg.dir("Plots")
+run(`cp /tmp/precompile/precompile_Plots.jl $pdir/src/precompile.jl`)

test/test_plottypes.jl

@@ -1,21 +0,0 @@
-
-
-function testplot_line1()
-  plot(rand(100,3))
-end
-
-function testplot_fn1()
-  plot(0:0.01:4π, [sin,cos])
-end
-
-function testplot_guides1()
-  plot(rand(10); title="TITLE", xlabel="XLABEL", ylabel="YLABEL", background_color=:red)
-end
-
-function testplot_points1()
-  plot(Vector[rand(10), rand(20)]; marker=:ellipse, markersize=8)
-end
-
-function testplot_points2()
-  plot(Vector[rand(10), rand(20)]; marker=:ellipse, markersize=8, markercolors=[:red,:blue])
-end

test/travis_commands.jl

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