handle vector of PlotText as annotations

fix change in checking if plotly_blink window is active

.gitignore

@@ -1,3 +1,6 @@
 *.jl.cov
 *.jl.*.cov
 *.jl.mem
+.DS_Store
+examples/.ipynb_checkpoints/*
+examples/meetup/.ipynb_checkpoints/*

.travis.yml

@@ -5,9 +5,19 @@ os:
   - osx
 julia:
   - 0.4
+  #- nightly
 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 -e 'Pkg.clone("https://github.com/tbreloff/Images.jl.git"); Pkg.checkout("Images","tom_imgcompare");'
+ # - julia -e 'Pkg.clone("Images"); Pkg.build("Images")'
+ # - julia -e 'Pkg.clone("ImageMagick"); Pkg.build("ImageMagick")'
+ - julia -e 'Pkg.clone("https://github.com/tbreloff/VisualRegressionTests.jl.git");'
+ - julia -e 'Pkg.clone("https://github.com/tbreloff/ExamplePlots.jl.git");'
+ - julia -e 'Pkg.clone("Cairo"); Pkg.build("Cairo")'
+ - julia -e 'ENV["PYTHON"] = ""; Pkg.clone("PyPlot"); Pkg.build("PyPlot")'
+ - 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())'

README.md

@@ -1,224 +1,21 @@
 # Plots
 
 [![Build Status](https://travis-ci.org/tbreloff/Plots.jl.svg?branch=master)](https://travis-ci.org/tbreloff/Plots.jl)
+[![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
+- **Intuitive**.  Start generating complex 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.
+- **Lightweight**.  Very few dependencies, since backends are loaded and initialized dynamically.
 
-- [Qwt.jl](docs/qwt_examples.md)
-- [Gadfly.jl](docs/gadfly_examples.md)
-
-## 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.
-
-```
-using Plots
-```
-
-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)
+Use the preprocessing 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.
 
+View the [full documentation](http://plots.readthedocs.org).

REQUIRE

@@ -1,4 +1,6 @@
-julia 0.4-
+julia 0.4
 
 Colors
-FactCheck
+Reexport
+Compat
+Requires

deprecated/docs/example_generation.jl

@@ -0,0 +1,419 @@
+
+module PlotExamples
+
+using Plots
+using Colors
+using Compat
+
+const DOCDIR = Pkg.dir("Plots") * "/docs"
+const IMGDIR = Pkg.dir("Plots") * "/img"
+
+"""
+Holds all data needed for a documentation example... header, description, and plotting expression (Expr)
+"""
+type PlotExample
+  header::@compat(AbstractString)
+  desc::@compat(AbstractString)
+  exprs::Vector{Expr}
+end
+
+
+
+# the examples we'll run for each
+const examples = PlotExample[
+  PlotExample("Lines",
+              "A simple line plot of the columns.",
+              [
+                :(plot(Plots.fakedata(50,5), w=3))
+              ]),
+  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.",
+              [
+                :(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)
+              ]),
+  PlotExample("Parametric plots",
+              "Plot function pair (x(u), y(u)).",
+              [
+                :(plot(sin, x->sin(2x), 0, 2π, line=4, leg=false, fill=(0,:orange)))
+              ]),
+  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.",
+              [
+                :(y = rand(100)),
+                :(plot(0:10:100,rand(11,4),lab="lines",w=3, palette=:grays, fill=(0.5,:auto))),
+                :(scatter!(y, zcolor=abs(y-.5), m=(:heat,0.8,stroke(1,:green)), ms=10*abs(y-0.5)+4, lab="grad"))
+              ]),
+  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!`",
+              [
+                :(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))
+              ]),
+  PlotExample("Two-axis",
+              "Use the `axis` arguments.\n\nNote: Currently only supported with Qwt and PyPlot",
+              [
+                :(plot(Vector[randn(100), randn(100)*100], axis = [:l :r], ylabel="LEFT", yrightlabel="RIGHT", xlabel="X", title="TITLE"))
+              ]),
+  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.",
+              [
+                :(ys = Vector[rand(10), rand(20)]),
+                :(plot(ys, line=(:dot,4,[:black :orange]), marker=([:hex :d],12,0.8,stroke(3,:gray))))
+              ]),
+  PlotExample("Build plot in pieces",
+              "Start with a base plot...",
+              [
+                :(plot(rand(100)/3, reg=true, fill=(0,:green)))
+              ]),
+  PlotExample("",
+              "and add to it later.",
+              [
+                :(scatter!(rand(100), markersize=6, c=:orange))
+              ]),
+  PlotExample("Heatmaps",
+              "",
+              [
+                :(heatmap(randn(10000),randn(10000), nbins=20))
+              ]),
+  PlotExample("Line types",
+              "",
+              [
+                :(types = intersect(supportedTypes(), [:line, :path, :steppre, :steppost, :sticks, :scatter])'),
+                :(n = length(types)),
+                :(x = Vector[sort(rand(20)) for i in 1:n]),
+                :(y = rand(20,n)),
+                :(plot(x, y, line=(types,3), lab=map(string,types), ms=15))
+              ]),
+  PlotExample("Line styles",
+              "",
+              [
+                :(styles = setdiff(supportedStyles(), [:auto])'),
+                :(plot(cumsum(randn(20,length(styles)),1), style=:auto, label=map(string,styles), w=5))
+              ]),
+  PlotExample("Marker types",
+              "",
+              [
+                :(markers = setdiff(supportedMarkers(), [:none,:auto,Shape])'),
+                :(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))
+              ]),
+  PlotExample("Bar",
+              "x is the midpoint of the bar. (todo: allow passing of edges instead of midpoints)",
+              [
+                :(bar(randn(999)))
+              ]),
+  PlotExample("Histogram",
+              "",
+              [
+                :(histogram(randn(1000), nbins=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`.
+              """,
+              [
+                :(subplot(randn(100,5), layout=[1,1,3], t=[:line :hist :scatter :step :bar], nbins=10, leg=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(Plots.fakedata(100,10), n=4, palette=[:grays :blues :heat :lightrainbow], bg=[:orange :pink :darkblue :black]))
+              ]),
+  PlotExample("",
+              "",
+              [
+                :(subplot!(Plots.fakedata(100,10)))
+              ]),
+  PlotExample("Open/High/Low/Close",
+              "Create an OHLC chart.  Pass in a vector of OHLC objects as your `y` argument.  Adjust the tick width with arg `markersize`.",
+              [
+                :(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; markersize=8))
+              ]),
+  PlotExample("Annotations",
+              "Currently only text annotations are supported.  Pass in a tuple or vector-of-tuples: (x,y,text).  `annotate!(ann)` is shorthand for `plot!(; annotation=ann)`",
+              [
+                :(y = rand(10)),
+                :(plot(y, ann=(3,y[3],text("this is #3",:left)))),
+                :(annotate!([(5,y[5],text("this is #5",16,:red,:center)),
+                             (10,y[10],text("this is #10",:right,20,"courier"))]))
+              ]),
+  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.",
+              [
+                :(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)])
+                :(plot(0.1:0.2:0.9, 0.7rand(5)+0.15,
+                       l=(3,:dash,:lightblue), 
+                       m=(Shape(verts),30,RGBA(0,0,0,0.2)),
+                       bg=:pink, fg=:darkblue,
+                       xlim = (0,1), ylim=(0,1), leg=false))
+              ]),
+
+  PlotExample("Contours",
+              "",
+              [
+                :(x = 1:0.3:20),
+                :(y = x),
+                :(f(x,y) = sin(x)+cos(y)),
+                :(contour(x, y, f, fill=true))
+              ]),
+
+  PlotExample("Pie",
+              "",
+              [
+                :(x = ["Nerds", "Hackers", "Scientists"]),
+                :(y = [0.4, 0.35, 0.25]),
+                :(pie(x, y, title="The Julia Community", l=0.5))
+              ]),
+
+  PlotExample("3D",
+              "",
+              [
+                :(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, w=5)),
+                :(plot!(zeros(n),zeros(n),1:n, w=10))
+              ])
+        
+]
+
+
+function createStringOfMarkDownCodeValues(arr, prefix = "")
+  string("`", prefix, join(sort(map(string, arr)), "`, `$prefix"), "`")
+end
+createStringOfMarkDownSymbols(arr) = isempty(arr) ? "" : createStringOfMarkDownCodeValues(arr, ":")
+
+
+function generate_markdown(pkgname::Symbol)
+
+  # set up the backend, and don't show the plots by default
+  pkg = backend(pkgname)
+  # default(:show, false)
+
+  # mkdir if necessary
+  try
+    mkdir("$IMGDIR/$pkgname")
+  end
+
+  # open the markdown file
+  md = open("$DOCDIR/$(pkgname)_examples.md", "w")
+
+  write(md, "## Examples for backend: $pkgname\n\n")
+
+  write(md, "### Initialize\n\n```julia\nusing Plots\n$(pkgname)()\n```\n\n")
+
+
+  for (i,example) in enumerate(examples)
+
+    try
+
+      # we want to always produce consistent results
+      srand(1234)
+
+      # run the code
+      map(eval, example.exprs)
+
+      # # save the png
+      # imgname = "$(pkgname)_example_$i.png"
+
+      # NOTE: uncomment this to overwrite the images as well
+      if i == 2
+        imgname = "$(pkgname)_example_$i.gif"
+        gif(anim, "$IMGDIR/$pkgname/$imgname", fps=15)
+      else
+        imgname = "$(pkgname)_example_$i.png"
+        png("$IMGDIR/$pkgname/$imgname")
+      end
+
+      # 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/$pkgname/$imgname)\n\n")
+
+    catch ex
+      # TODO: put error info into markdown?
+      warn("Example $pkgname:$i failed with: $ex")
+    end
+
+    #
+  end
+
+  write(md, "- Supported arguments: $(createStringOfMarkDownCodeValues(supportedArgs(pkg)))\n")
+  write(md, "- Supported values for axis: $(createStringOfMarkDownSymbols(supportedAxes(pkg)))\n")
+  write(md, "- Supported values for linetype: $(createStringOfMarkDownSymbols(supportedTypes(pkg)))\n")
+  write(md, "- Supported values for linestyle: $(createStringOfMarkDownSymbols(supportedStyles(pkg)))\n")
+  write(md, "- Supported values for marker: $(createStringOfMarkDownSymbols(supportedMarkers(pkg)))\n")
+  write(md, "- Is `subplot`/`subplot!` supported? $(subplotSupported(pkg) ? "Yes" : "No")\n\n")
+
+  write(md, "(Automatically generated: $(now()))")
+  close(md)
+
+end
+
+
+# make and display one plot
+function test_examples(pkgname::Symbol, idx::Int; debug = true)
+  Plots._debugMode.on = debug
+  println("Testing plot: $pkgname:$idx:$(examples[idx].header)")
+  backend(pkgname)
+  backend()
+  map(eval, examples[idx].exprs)
+  plt = current()
+  gui(plt)
+  plt
+end
+
+# generate all plots and create a dict mapping idx --> plt
+function test_examples(pkgname::Symbol; debug = false)
+  Plots._debugMode.on = debug
+  plts = Dict()
+  for i in 1:length(examples)
+    # if examples[i].header == "Subplots" && !subplotSupported()
+    #   break
+    # end
+
+    try
+      plt = test_examples(pkgname, i, debug=debug)
+      plts[i] = plt
+    catch ex
+      # TODO: put error info into markdown?
+      warn("Example $pkgname:$i:$(examples[i].header) failed with: $ex")
+    end
+  end
+  plts
+end
+
+# 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, :scatter, :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
+# fill          # fill 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)
+
+
+
+@compat const _ltdesc = Dict(
+    :none       => "No line",
+    :line       => "Lines with sorted x-axis",
+    :path       => "Lines",
+    :steppre    => "Step plot (vertical then horizontal)",
+    :steppost   => "Step plot (horizontal then vertical)",
+    :sticks     => "Vertical lines",
+    :scatter    => "Points, no lines",
+    :heatmap    => "Colored regions by density",
+    :hexbin     => "Similar to heatmap",
+    :hist       => "Histogram (doesn't use x)",
+    :bar        => "Bar plot (centered on x values)",
+    :hline      => "Horizontal line (doesn't use x)",
+    :vline      => "Vertical line (doesn't use x)",
+    :ohlc       => "Open/High/Low/Close chart (expects y is AbstractVector{Plots.OHLC})",
+    :contour    => "Contour lines (uses z)",
+    :path3d     => "3D path (uses z)",
+    :scatter3d  => "3D scatter plot (uses z)",
+  )
+
+function buildReadme()
+  readme = readall("$DOCDIR/readme_template.md")
+
+  # build keyword arg table
+  table = "Keyword | Default | Type | Aliases \n---- | ---- | ---- | ----\n"
+  allseries = merge(Plots._seriesDefaults, @compat(Dict(:line=>nothing, :marker=>nothing, :fill=>nothing)))
+  allplots = merge(Plots._plotDefaults, @compat(Dict(:xaxis=>nothing, :yaxis=>nothing)))
+  alldefs = merge(allseries, allplots)
+  for k in Plots.sortedkeys(alldefs)
+  # for d in (Plots._seriesDefaults, Plots._plotDefaults)
+  #   for k in Plots.sortedkeys(d)
+    aliasstr = createStringOfMarkDownSymbols(aliases(Plots._keyAliases, k))
+    table = string(table, "`:$k` | `$(alldefs[k])` | $(haskey(allseries,k) ? "Series" : "Plot") | $aliasstr  \n")
+    # end
+  end
+  readme = replace(readme, "[[KEYWORD_ARGS_TABLE]]", table)
+
+  # build linetypes table
+  table = "Type | Desc | Aliases\n---- | ---- | ----\n"
+  for lt in Plots._allTypes
+    aliasstr = createStringOfMarkDownSymbols(aliases(Plots._typeAliases, lt))
+    table = string(table, "`:$lt` | $(_ltdesc[lt]) | $aliasstr  \n")
+  end
+  readme = replace(readme, "[[LINETYPES_TABLE]]", table)
+
+  # build linestyles table
+  table = "Type | Aliases\n---- | ----\n"
+  for s in Plots._allStyles
+    aliasstr = createStringOfMarkDownSymbols(aliases(Plots._styleAliases, s))
+    table = string(table, "`:$s` | $aliasstr  \n")
+  end
+  readme = replace(readme, "[[LINESTYLES_TABLE]]", table)
+
+  # build markers table
+  table = "Type | Aliases\n---- | ----\n"
+  for s in Plots._allMarkers
+    aliasstr = createStringOfMarkDownSymbols(aliases(Plots._markerAliases, s))
+    table = string(table, "`:$s` | $aliasstr  \n")
+  end
+  readme = replace(readme, "[[MARKERS_TABLE]]", table)
+
+  readme_fn = Pkg.dir("Plots") * "/README.md"
+  f = open(readme_fn, "w")
+  write(f, readme)
+  close(f)
+
+  gadfly()
+  Plots.dumpSupportGraphs()
+end
+
+default(size=(500,300))
+
+# run it!
+# note: generate separately so it's easy to comment out
+# @osx_only generate_markdown(:unicodeplots)
+# generate_markdown(:qwt)
+# generate_markdown(:gadfly)
+# generate_markdown(:pyplot)
+# generate_markdown(:immerse)
+# generate_markdown(:winston)
+
+
+end # module
+

deprecated/docs/readme_template.md

@@ -0,0 +1,305 @@
+# Plots
+
+[![Build Status](https://travis-ci.org/tbreloff/Plots.jl.svg?branch=master)](https://travis-ci.org/tbreloff/Plots.jl)
+[![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) -->
+
+#### Author: Thomas Breloff (@tbreloff)
+
+Plots is a plotting API and toolset.  My goals with the package are:
+
+- **Intuitive**.  Start generating complex 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.
+- **Lightweight**.  Very few dependencies, since backends are loaded and initialized dynamically.
+
+Use the preprocessing 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.
+
+Check out the [summary graphs](img/supported/supported.md) for the features that each backend supports.
+
+Please add wishlist items, bugs, or any other comments/questions to the issues list.
+
+## Examples for each implemented backend:
+
+- [Gadfly.jl/Immerse.jl](https://github.com/tbreloff/ExamplePlots.jl/tree/master/docs/gadfly_examples.md)
+- [PyPlot.jl](https://github.com/tbreloff/ExamplePlots.jl/tree/master/docs/pyplot_examples.md)
+- [UnicodePlots.jl](https://github.com/tbreloff/ExamplePlots.jl/tree/master/docs/unicodeplots_examples.md)
+- [Qwt.jl](https://github.com/tbreloff/ExamplePlots.jl/tree/master/docs/qwt_examples.md)
+
+Also check out the many [IJulia notebooks](http://nbviewer.ipython.org/github/tbreloff/ExamplePlots.jl/tree/master/examples/) with many examples.
+
+## Installation
+
+First, add the package
+
+```julia
+Pkg.add("Plots")
+
+# if you want the latest features:
+Pkg.checkout("Plots")
+
+# or for the bleeding edge:
+Pkg.checkout("Plots", "dev")
+```
+
+then get any plotting packages you need (obviously, you should get at least one backend).
+
+```julia
+Pkg.add("Gadfly")
+Pkg.add("Immerse")
+Pkg.add("PyPlot")
+Pkg.add("UnicodePlots")
+Pkg.add("Qwt")
+Pkg.add("Bokeh")
+```
+
+## Use
+
+Load it in.  The underlying plotting backends are not imported until `backend()` is called (which happens
+on your first call to `plot` or `subplot`).  This means that you don't need any backends to be installed when you call `using Plots`.
+
+Plots will try to figure out a good default backend for you automatically based on what backends are installed.
+
+```julia
+using Plots
+```
+
+Do a plot in Gadfly (inspired by [this example](http://gadflyjl.org/geom_point.html)), then save a png:
+
+```julia
+gadfly()        # switch to Gadfly as a backend
+dataframes()    # turn on support for DataFrames inputs
+
+# load some data
+using RDatasets
+iris = dataset("datasets", "iris");
+
+# This will bring up a browser window with the plot. Add a semicolon at the end to skip display. 
+scatter(iris, :SepalLength, :SepalWidth, group=:Species, m=([:+ :d :s], 12), smooth=0.99, bg=:black)
+
+# save a png (equivalent to png("gadfly1.png") and savefig("gadfly1.png"))
+png("gadfly1")
+```
+
+![gadfly_plt](img/gadfly1.png)
+
+## API
+
+Call `backend(backend::Symbol)` or the shorthands (`gadfly()`, `qwt()`, `unicodeplots()`, etc) to set the current plotting backend.
+Subsequent commands are converted into the relevant plotting commands for that package:
+
+```julia
+gadfly()
+plot(1:10)    # this effectively calls `y = 1:10; Gadfly.plot(x=1:length(y), y=y)`
+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:
+
+```julia
+plot(args...; kw...)                  # creates a new plot window, and sets it to be the `current`
+plot!(args...; kw...)                 # adds to the `current`
+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.
+There are many ways to pass in data to the plot functions... some examples:
+
+- Vector-like (subtypes of AbstractArray{T,1})
+- Matrix-like (subtypes of AbstractArray{T,2})
+- Vectors of Vectors
+- Functions
+- Vectors of Functions
+- DataFrames with column symbols (initialize with `dataframes()`)
+
+In general, you can pass in a `y` only, or an `x` and `y`, both of whatever type(s) you want, and Plots will slice up the data as needed.
+For matrices, data is split by columns.  For functions, data is mapped.  For DataFrames, a Symbol/Symbols in place of x/y will map to
+the relevant column(s).
+
+Here are some example usages... remember you can always use `plot!` to update an existing plot, and that, unless specified, you will update the `current()`.
+
+```julia
+plot()                                    # empty plot object
+plot(4)                                   # initialize with 4 empty series
+plot(rand(10))                            # plot 1 series... x = 1:10
+plot(rand(10,5))                          # plot 5 series... x = 1:10
+plot(rand(10), rand(10))                  # plot 1 series
+plot(rand(10,5), rand(10))                # plot 5 series... y is the same for all
+plot(sin, rand(10))                       # y = sin(x)
+plot(rand(10), sin)                       # same... y = sin(x)
+plot([sin,cos], 0:0.1:π)                  # plot 2 series, sin(x) and cos(x)
+plot([sin,cos], 0, π)                     # plot sin and cos on the range [0, π]
+plot(1:10, Any[rand(10), sin])            # plot 2 series, y = rand(10) for the first, y = sin(x) for the second... x = 1:10 for both
+plot(dataset("Ecdat", "Airline"), :Cost)  # plot from a DataFrame (call `dataframes()` first to import DataFrames and initialize)
+```
+
+All plot methods accept a number of keyword arguments (see the tables below), which follow some rules:
+- Many arguments have aliases which are replaced during preprocessing.  `c` is the same as `color`, `m` is the same as `marker`, etc.  You can choose how verbose you'd like to be.  (see the tables below)
+- There are some special arguments (`xaxis`, `yaxis`, `line`, `marker`, `fill` and the aliases `l`, `m`, `f`) which magically set many related things at once.  (see the __Tip__ below)
+- If the argument is a "matrix-type", then each column will map to a series, cycling through columns if there are fewer columns than series.  Anything else will apply the argument value to every series.
+- Many arguments accept many different types... for example the `color` (also `markercolor`, `fillcolor`, etc) argument will accept strings or symbols with a color name, or any `Colors.Colorant`, or a `ColorScheme`, or a symbol representing a `ColorGradient`, or an AbstractVector of colors/symbols/etc...
+
+You can update certain plot settings after plot creation (not supported on all backends):
+
+```julia
+plot!(title = "New Title", xlabel = "New xlabel", ylabel = "New ylabel")
+plot!(xlims = (0, 5.5), ylims = (-2.2, 6), xticks = 0:0.5:10, yticks = [0,1,5,10])
+
+# using shorthands:
+xaxis!("mylabel", :log10, :flip)
+```
+
+With `subplot`, create multiple plots at once, with flexible layout options:
+
+```julia
+y = rand(100,3)
+subplot(y; n = 3)             # create an automatic grid, and let it figure out the shape
+subplot(y; n = 3, nr = 1)     # create an automatic grid, but fix the number of rows
+subplot(y; n = 3, nc = 1)     # create an automatic grid, but fix the number of columns
+subplot(y; layout = [1, 2])   # explicit layout.  Lists the number of plots in each row
+```
+
+__Tip__: You can call `subplot!(args...; kw...)` to add to an existing subplot.
+
+__Tip__: Calling `subplot!` on a `Plot` object, or `plot!` on a `Subplot` object will throw an error.
+
+Shorthands:
+
+```julia
+scatter(args...; kw...)    = plot(args...; kw...,  linetype = :scatter)
+scatter!(args...; kw...)   = plot!(args...; kw..., linetype = :scatter)
+bar(args...; kw...)        = plot(args...; kw...,  linetype = :bar)
+bar!(args...; kw...)       = plot!(args...; kw..., linetype = :bar)
+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)
+sticks(args...; kw...)     = plot(args...; kw...,  linetype = :sticks, marker = :ellipse)
+sticks!(args...; kw...)    = plot!(args...; kw..., linetype = :sticks, marker = :ellipse)
+hline(args...; kw...)      = plot(args...; kw...,  linetype = :hline)
+hline!(args...; kw...)     = plot!(args...; kw..., linetype = :hline)
+vline(args...; kw...)      = plot(args...; kw...,  linetype = :vline)
+vline!(args...; kw...)     = plot!(args...; kw..., linetype = :vline)
+ohlc(args...; kw...)       = plot(args...; kw...,  linetype = :ohlc)
+ohlc!(args...; kw...)      = plot!(args...; kw..., linetype = :ohlc)
+
+title!(s::AbstractString)                 = plot!(title = s)
+xlabel!(s::AbstractString)                = plot!(xlabel = s)
+ylabel!(s::AbstractString)                = plot!(ylabel = s)
+xlims!{T<:Real,S<:Real}(lims::Tuple{T,S}) = plot!(xlims = lims)
+ylims!{T<:Real,S<:Real}(lims::Tuple{T,S}) = plot!(ylims = lims)
+xticks!{T<:Real}(v::AVec{T})              = plot!(xticks = v)
+yticks!{T<:Real}(v::AVec{T})              = plot!(yticks = v)
+xflip!(flip::Bool = true)                 = plot!(xflip = flip)
+yflip!(flip::Bool = true)                 = plot!(yflip = flip)
+xaxis!(args...)                           = plot!(xaxis = args)
+yaxis!(args...)                           = plot!(yaxis = args)
+annotate!(anns)                           = plot!(annotation = anns)
+```
+
+### Keyword arguments:
+
+[[KEYWORD_ARGS_TABLE]]
+
+### Plot types:
+
+[[LINETYPES_TABLE]]
+
+### Line styles:
+
+[[LINESTYLES_TABLE]]
+
+### Markers:
+
+[[MARKERS_TABLE]]
+
+__Tip__: With supported backends, you can pass a `Plots.Shape` object for the `marker`/`markershape` arguments.  `Shape` takes a vector of 2-tuples in the constructor, defining the points of the polygon's shape in a unit-scaled coordinate space.  To make a square, for example, you could do `Shape([(1,1),(1,-1),(-1,-1),(-1,1)])`
+
+__Tip__: You can see the default value for a given argument with `default(arg::Symbol)`, and set the default value with `default(arg::Symbol, value)` or `default(; kw...)`.  For example set the default window size and whether we should show a legend with `default(size=(600,400), leg=false)`.
+
+__Tip__: There are some helper arguments you can set:  `xaxis`, `yaxis`, `line`, `marker`, `fill`.  These go through special preprocessing to extract values into individual arguments.  The order doesn't matter, and if you pass a single value it's equivalent to wrapping it in a Tuple.  Examples:
+
+```
+plot(y, xaxis = ("mylabel", :log, :flip, (-1,1)))   # this sets the `xlabel`, `xscale`, `xflip`, and `xlims` arguments automatically
+plot(y, line = (:bar, :blue, :dot, 10))             # this sets the `linetype`, `color`, `linestyle`, and `linewidth` arguments automatically
+plot(y, marker = (:rect, :red, 10))                 # this sets the `markershape`, `markercolor`, and `markersize` arguments automatically
+plot(y, fill = (:green, 10))                        # this sets the `fillcolor` and `fillrange` arguments automatically
+                                                    # Note: `fillrange` can be:
+                                                              a number (fill to horizontal line)
+                                                              a vector of numbers (different for each data point)
+                                                              a tuple of vectors (fill a band)
+```
+
+__Tip__: When plotting multiple lines, you can set all series to use the same value, or pass in a matrix to cycle through values.  Example:
+
+```julia
+plot(rand(100,4); color = [:red RGB(0,0,1)],     # (Matrix) lines 1 and 3 are red, lines 2 and 4 are blue
+                  axis = :auto,                  # lines 1 and 3 are on the left axis, lines 2 and 4 are on the right
+                  markershape = [:rect, :star]   # (Vector) ALL lines are passed the vector [:rect, :star1]
+                  width = 5)                     # all lines have a width of 5
+```
+
+__Tip__: Not all features are supported for each backend, but you can see what's supported by calling the functions: `supportedArgs()`, `supportedAxes()`, `supportedTypes()`, `supportedStyles()`, `supportedMarkers()`, `subplotSupported()`
+
+__Tip__: Call `gui()` to display the plot in a window.  Interactivity depends on backend.  Plotting at the REPL (without semicolon) implicitly calls `gui()`.
+
+### Animations
+
+Animations are created in 3 steps (see example #2):
+- Initialize an `Animation` object.
+- Save each frame of the animation with `frame(anim)`.
+- Convert the frames to an animated gif with `gif(anim, filename, fps=15)`
+
+
+## TODO features:
+
+- [x] Plot vectors/matrices/functions
+- [x] Plot DataFrames
+- [x] Histograms
+- [x] Grouping
+- [x] Annotations
+- [x] Scales
+- [x] Categorical Inputs (strings, etc... for hist, bar? or can split one series into multiple?)
+- [x] Custom markers
+- [x] Animations
+- [x] Subplots
+- [ ] Contours
+- [ ] Boxplots
+- [ ] 3D plotting
+- [ ] Scenes/Drawing
+- [ ] Graphs
+- [ ] Interactivity (GUIs)
+
+## TODO backends:
+
+- [x] Gadfly.jl
+- [x] Immerse.jl
+- [x] PyPlot.jl
+- [x] UnicodePlots.jl
+- [x] Qwt.jl
+- [x] Winston.jl (deprecated)
+- [ ] GLPlot.jl
+- [ ] Bokeh.jl
+- [ ] Vega.jl
+- [ ] Gaston.jl
+- [ ] Plotly.jl
+- [ ] GoogleCharts.jl
+- [ ] PLplot.jl
+- [ ] TextPlots.jl
+- [ ] ASCIIPlots.jl
+- [ ] Sparklines.jl
+- [ ] Hinton.jl
+- [ ] ImageTerm.jl
+- [ ] GraphViz.jl
+- [ ] TikzGraphs.jl
+- [ ] GraphLayout.jl
+
+## More information on backends (both supported and unsupported)
+
+See the wiki at: https://github.com/JuliaPlot/juliaplot_docs/wiki
+
+

deprecated/img/supported/supported.md

@@ -0,0 +1,23 @@
+## Supported keyword arguments
+
+![args](Plots.supportGraphArgs.png)
+
+## Supported plot types
+
+![types](Plots.supportGraphTypes.png)
+
+## Supported markers
+
+![markers](Plots.supportGraphMarkers.png)
+
+## Supported line styles
+
+![styles](Plots.supportGraphStyles.png)
+
+## Supported scales
+
+![scales](Plots.supportGraphScales.png)
+
+## Supported axes
+
+![axes](Plots.supportGraphAxes.png)

deprecated/plotter.jl

@@ -0,0 +1,333 @@
+
+
+immutable GadflyPackage       <: PlottingPackage end
+immutable ImmersePackage      <: PlottingPackage end
+immutable PyPlotPackage       <: PlottingPackage end
+immutable QwtPackage          <: PlottingPackage end
+immutable UnicodePlotsPackage <: PlottingPackage end
+immutable WinstonPackage      <: PlottingPackage end
+immutable BokehPackage        <: PlottingPackage end
+immutable PlotlyPackage       <: PlottingPackage end
+immutable GRPackage           <: PlottingPackage end
+immutable GLVisualizePackage  <: PlottingPackage end
+immutable NoPackage           <: PlottingPackage end
+
+typealias GadflyOrImmerse @compat(Union{GadflyPackage, ImmersePackage})
+
+export
+  gadfly,
+  immerse,
+  pyplot,
+  qwt,
+  unicodeplots,
+  bokeh,
+  plotly,
+  gr,
+  glvisualize
+  # winston
+
+gadfly(; kw...)        = (default(; kw...); backend(:gadfly))
+immerse(; kw...)       = (default(; kw...); backend(:immerse))
+pyplot(; kw...)        = (default(; kw...); backend(:pyplot))
+qwt(; kw...)           = (default(; kw...); backend(:qwt))
+unicodeplots(; kw...)  = (default(; kw...); backend(:unicodeplots))
+bokeh(; kw...)         = (default(; kw...); backend(:bokeh))
+plotly(; kw...)        = (default(; kw...); backend(:plotly))
+gr(; kw...)            = (default(; kw...); backend(:gr))
+glvisualize(; kw...)   = (default(; kw...); backend(:glvisualize))
+# winston(; kw...)       = (default(; kw...); backend(:winston))
+
+backend_name(::GadflyPackage)       = :gadfly
+backend_name(::ImmersePackage)      = :immerse
+backend_name(::PyPlotPackage)       = :pyplot
+backend_name(::UnicodePlotsPackage) = :unicodeplots
+backend_name(::QwtPackage)          = :qwt
+backend_name(::BokehPackage)        = :bokeh
+backend_name(::PlotlyPackage)       = :plotly
+backend_name(::GRPackage)           = :gr
+backend_name(::GLVisualizePackage)  = :glvisualize
+backend_name(::NoPackage)           = :none
+
+include("backends/supported.jl")
+
+include("backends/qwt.jl")
+include("backends/gadfly.jl")
+include("backends/unicodeplots.jl")
+include("backends/pyplot.jl")
+include("backends/immerse.jl")
+include("backends/winston.jl")
+
+include("backends/web.jl")
+include("backends/bokeh.jl")
+include("backends/plotly.jl")
+include("backends/gr.jl")
+
+include("backends/glvisualize.jl")
+
+
+# ---------------------------------------------------------
+
+
+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")
+_update_plot(pkg::PlottingPackage, plt::Plot, d::Dict) = error("_update_plot($pkg, plt, d) is not implemented")
+# Base.display(pkg::PlottingPackage, plt::Plot) = error("display($pkg, plt) is not implemented")
+
+_update_plot_pos_size{P<:PlottingPackage}(plt::PlottingObject{P}, d::Dict) = nothing #error("_update_plot_pos_size(plt,d) is not implemented for $P")
+
+subplot(pkg::PlottingPackage; kw...) = error("subplot($pkg; kw...) is not implemented")
+subplot!(pkg::PlottingPackage, subplt::Subplot; kw...) = error("subplot!($pkg, subplt; kw...) is not implemented")
+# Base.display(pkg::PlottingPackage, subplt::Subplot) = error("display($pkg, subplt) is not implemented")
+
+# ---------------------------------------------------------
+
+
+const BACKENDS = [:qwt, :gadfly, :unicodeplots, :pyplot, :immerse, :bokeh, :plotly, :gr]
+const _initialized_backends = Set{Symbol}()
+backends() = BACKENDS
+
+
+function _backend_instance(sym::Symbol)
+  sym == :qwt && return QwtPackage()
+  sym == :gadfly && return GadflyPackage()
+  sym == :unicodeplots && return UnicodePlotsPackage()
+  sym == :pyplot && return PyPlotPackage()
+  sym == :immerse && return ImmersePackage()
+  sym == :winston && return WinstonPackage()
+  sym == :bokeh && return BokehPackage()
+  sym == :plotly && return PlotlyPackage()
+  sym == :gr && return GRPackage()
+  sym == :glvisualize && return GLVisualizePackage()
+  sym == :none && return NoPackage()
+  error("Unsupported backend $sym")
+end
+
+
+type CurrentBackend
+  sym::Symbol
+  pkg::PlottingPackage
+end
+CurrentBackend(sym::Symbol) = CurrentBackend(sym, _backend_instance(sym))
+
+# ---------------------------------------------------------
+
+function pickDefaultBackend()
+  for pkgstr in ("PyPlot", "Immerse", "Qwt", "Gadfly", "GR", "UnicodePlots", "Bokeh", "GLVisualize")
+    if Pkg.installed(pkgstr) != nothing
+      return backend(symbol(lowercase(pkgstr)))
+    end
+  end
+  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
+
+  currentBackendSymbol = CURRENT_BACKEND.sym
+  if !(currentBackendSymbol in _initialized_backends)
+
+    # initialize
+    println("[Plots.jl] Initializing backend: ", CURRENT_BACKEND.sym)
+    if currentBackendSymbol == :qwt
+      try
+        @eval import Qwt
+        @eval export Qwt
+      catch err
+        warn("Couldn't import Qwt.  Install it with: Pkg.clone(\"https://github.com/tbreloff/Qwt.jl.git\")\n  (Note: also requires pyqt and pyqwt).")
+        rethrow(err)
+      end
+
+    elseif currentBackendSymbol == :gadfly
+      try
+        @eval import Gadfly, Compose
+        @eval export Gadfly, Compose
+        @eval include(joinpath(Pkg.dir("Plots"), "src", "backends", "gadfly_shapes.jl"))
+      catch err
+        warn("Couldn't import Gadfly.  Install it with: Pkg.add(\"Gadfly\").")
+        rethrow(err)
+      end
+
+    elseif currentBackendSymbol == :unicodeplots
+      try
+        @eval import UnicodePlots
+        @eval export UnicodePlots
+      catch err
+        warn("Couldn't import UnicodePlots.  Install it with: Pkg.add(\"UnicodePlots\").")
+        rethrow(err)
+      end
+
+    elseif currentBackendSymbol == :pyplot
+      try
+        @eval import PyPlot
+        @eval export PyPlot
+        @eval const pycolors = PyPlot.pywrap(PyPlot.pyimport("matplotlib.colors"))
+        @eval const pypath = PyPlot.pywrap(PyPlot.pyimport("matplotlib.path"))
+        @eval const mplot3d = PyPlot.pywrap(PyPlot.pyimport("mpl_toolkits.mplot3d"))
+        # @eval const pycolorbar = PyPlot.pywrap(PyPlot.pyimport("matplotlib.colorbar"))
+        if !isa(Base.Multimedia.displays[end], Base.REPL.REPLDisplay)
+          PyPlot.ioff()  # stops wierd behavior of displaying incomplete graphs in IJulia
+
+          # # TODO: how the hell can I use PyQt4??
+          # "pyqt4"=>:qt_pyqt4
+          # PyPlot.backend[1] = "pyqt4"
+          # PyPlot.gui[1] = :qt_pyqt4
+          # PyPlot.switch_backend("Qt4Agg")
+
+          # only turn on the gui if we want it
+          if PyPlot.gui != :none
+            PyPlot.pygui(true)
+          end
+
+        end
+      catch err
+        warn("Couldn't import PyPlot.  Install it with: Pkg.add(\"PyPlot\").")
+        rethrow(err)
+      end
+
+    elseif currentBackendSymbol == :immerse
+      try
+        @eval import Immerse, Gadfly, Compose, Gtk
+        @eval export Immerse, Gadfly, Compose, Gtk
+        @eval include(joinpath(Pkg.dir("Plots"), "src", "backends", "gadfly_shapes.jl"))
+      catch err
+        # error("Couldn't import Immerse.  Install it with: Pkg.add(\"Immerse\").\n   Error: ", err)
+        warn("Couldn't import Immerse.  Install it with: Pkg.add(\"Immerse\").")
+        rethrow(err)
+      end
+
+    elseif currentBackendSymbol == :bokeh
+      try
+        @eval import Bokeh
+        @eval export Bokeh
+      catch err
+        warn("Couldn't import Bokeh.  Install it with: Pkg.add(\"Bokeh\").")
+        rethrow(err)
+      end
+
+    elseif currentBackendSymbol == :plotly
+      try
+        @eval begin
+          import JSON
+          JSON._print(io::IO, state::JSON.State, dt::Union{Date,DateTime}) = print(io, '"', dt, '"')
+
+          ############################
+          # borrowed from https://github.com/spencerlyon2/Plotlyjs.jl/blob/master/src/display.jl
+          _js_path = joinpath(Pkg.dir("Plots"), "deps", "plotly-latest.min.js")
+
+          # if we're in IJulia call setupnotebook to load js and css
+          if isijulia()
+              # the first script is some hack I needed to do in order for the notebook
+              # to not complain about Plotly being undefined
+              display("text/html", """
+                  <script type="text/javascript">
+                      require=requirejs=define=undefined;
+                  </script>
+                  <script type="text/javascript">
+                      $(open(readall, _js_path, "r"))
+                  </script>
+               """)
+              # display("text/html", "<p>Plotly javascript loaded.</p>")
+          end
+          # end borrowing (thanks :)
+          ###########################
+
+          try
+            include(joinpath(Pkg.dir("Plots"), "src", "backends", "plotly_blink.jl"))
+          catch err
+            warn("Error including PlotlyJS: $err\n  Note: Will fall back to built-in display.")
+          end
+
+        end
+      catch err
+        warn("Couldn't setup Plotly")
+        rethrow(err)
+      end
+
+    elseif currentBackendSymbol == :gr
+      try
+        @eval import GR
+      catch err
+        warn("Couldn't import GR.  Install it with: Pkg.add(\"GR\").")
+      end
+
+    elseif currentBackendSymbol == :glvisualize
+      try
+        @eval import GLVisualize
+        @eval export GLVisualize
+      catch err
+        warn("Couldn't setup GLVisualize")
+        rethrow(err)
+      end
+
+    elseif currentBackendSymbol == :winston
+      warn("Winston support is deprecated and broken.  Try another backend: $BACKENDS")
+      try
+        @eval ENV["WINSTON_OUTPUT"] = "gtk"
+        @eval import Winston, Gtk
+        @eval export Winston, Gtk
+      catch err
+        warn("Couldn't import Winston.  Install it with: Pkg.add(\"Winston\").")
+        rethrow(err)
+      end
+
+    else
+      error("Unknown backend $currentBackendSymbol.  Choose from: $BACKENDS")
+    end
+    push!(_initialized_backends, currentBackendSymbol)
+
+  end
+  CURRENT_BACKEND.pkg
+end
+
+"""
+Set the plot backend.  Choose from:  :qwt, :gadfly, :unicodeplots, :immerse, :pyplot
+"""
+function backend(pkg::PlottingPackage)
+  CURRENT_BACKEND.sym = backend_name(pkg)
+  CURRENT_BACKEND.pkg = pkg
+end
+
+function backend(modname)
+
+  # set the PlottingPackage
+  if modname == :qwt
+    CURRENT_BACKEND.pkg = QwtPackage()
+  elseif modname == :gadfly
+    CURRENT_BACKEND.pkg = GadflyPackage()
+  elseif modname == :unicodeplots
+    CURRENT_BACKEND.pkg = UnicodePlotsPackage()
+  elseif modname == :pyplot
+    CURRENT_BACKEND.pkg = PyPlotPackage()
+  elseif modname == :immerse
+    CURRENT_BACKEND.pkg = ImmersePackage()
+  elseif modname == :winston
+    CURRENT_BACKEND.pkg = WinstonPackage()
+  elseif modname == :bokeh
+    CURRENT_BACKEND.pkg = BokehPackage()
+  elseif modname == :plotly
+    CURRENT_BACKEND.pkg = PlotlyPackage()
+  elseif modname == :gr
+    CURRENT_BACKEND.pkg = GRPackage()
+  elseif modname == :glvisualize
+    CURRENT_BACKEND.pkg = GLVisualizePackage()
+  else
+    error("Unknown backend $modname.  Choose from: $BACKENDS")
+  end
+
+  # update the symbol
+  CURRENT_BACKEND.sym = modname
+  # println("[Plots.jl] Switched to backend: ", modname)
+
+  # return the package
+  CURRENT_BACKEND.pkg
+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,258 @@
-__precompile__()
+
+ __precompile__()
 
 module Plots
 
-using Colors
+using Compat
+using Reexport
+@reexport using Colors
+using Requires
 
 export
-  plotter,
-  plot,
-  subplot,
+  Plot,
+  Subplot,
+  SubplotLayout,
+  GridLayout,
+  FlexLayout,
+  AVec,
+  AMat,
 
-  plotter!,
+  plot,
   plot!,
+  subplot,
   subplot!,
 
-  currentPlot,
-  plotDefault,
+  current,
+  default,
+  with,
+  
   scatter,
-  bar,
-  histogram,
-  heatmap,
-
-  currentPlot!,
-  plotDefault!,
   scatter!,
+  bar,
   bar!,
+  histogram,
   histogram!,
+  density,
+  density!,
+  heatmap,
   heatmap!,
+  hexbin,
+  hexbin!,
+  sticks,
+  sticks!,
+  hline,
+  hline!,
+  vline,
+  vline!,
+  ohlc,
+  ohlc!,
+  pie,
+  pie!,
+  contour,
+  contour!,
+  surface,
+  surface!,
+  wireframe,
+  wireframe!,
+  path3d,
+  path3d!,
+  plot3d,
+  plot3d!,
+  scatter3d,
+  scatter3d!,
+  abline!,
 
-  savepng
+  title!,
+  xlabel!,
+  ylabel!,
+  xlims!,
+  ylims!,
+  xticks!,
+  yticks!,
+  annotate!,
+  xflip!,
+  yflip!,
+  xaxis!,
+  yaxis!,
 
-# ---------------------------------------------------------
+  savefig,
+  png,
+  gui,
 
+  backend,
+  backends,
+  backend_name,
+  aliases,
+  dataframes,
 
-const IMG_DIR = Pkg.dir("Plots") * "/img/"
+  Shape,
+  text,
+  font,
+  stroke,
+  brush,
+  Surface,
+  OHLC,
+
+  colorscheme,
+  ColorScheme,
+  ColorGradient,
+  ColorVector,
+  ColorWrapper,
+  ColorFunction,
+  ColorZFunction,
+  getColor,
+  getColorZ,
+
+  debugplots,
+
+  supportedArgs,
+  supportedAxes,
+  supportedTypes,
+  supportedStyles,
+  supportedMarkers,
+  subplotSupported,
+
+  Animation,
+  frame,
+  gif,
+  @animate,
+
+  # recipes
+  PlotRecipe,
+  # EllipseRecipe,
+  # spy,
+  corrplot
 
 
 # ---------------------------------------------------------
 
 include("types.jl")
 include("utils.jl")
-
-# ---------------------------------------------------------
-
-include("qwt.jl")
-include("gadfly.jl")
-include("plotter.jl")
-
-# ---------------------------------------------------------
-
+include("colors.jl")
+include("components.jl")
+include("plotter2.jl")
 include("args.jl")
 include("plot.jl")
 include("subplot.jl")
+include("recipes.jl")
+include("animation.jl")
+include("output.jl")
 
 
 # ---------------------------------------------------------
 
-scatter(args...; kw...)    = plot(args...; kw...,  linetype = :none, marker = :hexagon)
-scatter!(args...; kw...)   = plot!(args...; kw..., linetype = :none, marker = :hexagon)
+scatter(args...; kw...)    = plot(args...; kw...,  linetype = :scatter)
+scatter!(args...; kw...)   = plot!(args...; kw..., linetype = :scatter)
 bar(args...; kw...)        = plot(args...; kw...,  linetype = :bar)
 bar!(args...; kw...)       = plot!(args...; kw..., linetype = :bar)
 histogram(args...; kw...)  = plot(args...; kw...,  linetype = :hist)
 histogram!(args...; kw...) = plot!(args...; kw..., linetype = :hist)
+density(args...; kw...)    = plot(args...; kw...,  linetype = :density)
+density!(args...; kw...)   = plot!(args...; kw..., linetype = :density)
 heatmap(args...; kw...)    = plot(args...; kw...,  linetype = :heatmap)
 heatmap!(args...; kw...)   = plot!(args...; kw..., linetype = :heatmap)
+hexbin(args...; kw...)     = plot(args...; kw...,  linetype = :hexbin)
+hexbin!(args...; kw...)    = plot!(args...; kw..., linetype = :hexbin)
+sticks(args...; kw...)     = plot(args...; kw...,  linetype = :sticks, marker = :ellipse)
+sticks!(args...; kw...)    = plot!(args...; kw..., linetype = :sticks, marker = :ellipse)
+hline(args...; kw...)      = plot(args...; kw...,  linetype = :hline)
+hline!(args...; kw...)     = plot!(args...; kw..., linetype = :hline)
+vline(args...; kw...)      = plot(args...; kw...,  linetype = :vline)
+vline!(args...; kw...)     = plot!(args...; kw..., linetype = :vline)
+ohlc(args...; kw...)       = plot(args...; kw...,  linetype = :ohlc)
+ohlc!(args...; kw...)      = plot!(args...; kw..., linetype = :ohlc)
+pie(args...; kw...)        = plot(args...; kw...,  linetype = :pie)
+pie!(args...; kw...)       = plot!(args...; kw..., linetype = :pie)
+contour(args...; kw...)    = plot(args...; kw...,  linetype = :contour)
+contour!(args...; kw...)   = plot!(args...; kw..., linetype = :contour)
+surface(args...; kw...)    = plot(args...; kw...,  linetype = :surface)
+surface!(args...; kw...)   = plot!(args...; kw..., linetype = :surface)
+wireframe(args...; kw...)  = plot(args...; kw...,  linetype = :wireframe)
+wireframe!(args...; kw...) = plot!(args...; kw..., linetype = :wireframe)
+path3d(args...; kw...)     = plot(args...; kw...,  linetype = :path3d)
+path3d!(args...; kw...)    = plot!(args...; kw..., linetype = :path3d)
+plot3d(args...; kw...)     = plot(args...; kw...,  linetype = :path3d)
+plot3d!(args...; kw...)    = plot!(args...; kw..., linetype = :path3d)
+scatter3d(args...; kw...)  = plot(args...; kw...,  linetype = :scatter3d)
+scatter3d!(args...; kw...) = plot!(args...; kw..., linetype = :scatter3d)
+
+
+title!(s::@compat(AbstractString); kw...)                 = plot!(; title = s, kw...)
+xlabel!(s::@compat(AbstractString); kw...)                = plot!(; xlabel = s, kw...)
+ylabel!(s::@compat(AbstractString); kw...)                = plot!(; ylabel = s, kw...)
+xlims!{T<:Real,S<:Real}(lims::@compat(Tuple{T,S}); kw...) = plot!(; xlims = lims, kw...)
+ylims!{T<:Real,S<:Real}(lims::@compat(Tuple{T,S}); kw...) = plot!(; ylims = lims, kw...)
+xlims!(xmin::Real, xmax::Real; kw...)                     = plot!(; xlims = (xmin,xmax), kw...)
+ylims!(ymin::Real, ymax::Real; kw...)                     = plot!(; ylims = (ymin,ymax), 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<:@compat(AbstractString)}(
+              ticks::AVec{T}, labels::AVec{S}; kw...)     = plot!(; xticks = (ticks,labels), kw...)
+yticks!{T<:Real,S<:@compat(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::@compat(AbstractString); kw...)                  = plot!(plt; title = s, kw...)
+xlabel!(plt::Plot, s::@compat(AbstractString); kw...)                 = plot!(plt; xlabel = s, kw...)
+ylabel!(plt::Plot, s::@compat(AbstractString); kw...)                 = plot!(plt; ylabel = s, kw...)
+xlims!{T<:Real,S<:Real}(plt::Plot, lims::@compat(Tuple{T,S}); kw...)  = plot!(plt; xlims = lims, kw...)
+ylims!{T<:Real,S<:Real}(plt::Plot, lims::@compat(Tuple{T,S}); kw...)  = plot!(plt; ylims = 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...)
+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<:@compat(AbstractString)}(plt::Plot,
+                          ticks::AVec{T}, labels::AVec{S}; kw...)     = plot!(plt; xticks = (ticks,labels), kw...)
+yticks!{T<:Real,S<:@compat(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...)
+
 
 
 # ---------------------------------------------------------
 
 
-savepng(args...; kw...) = savepng(currentPlot(), args...; kw...)
-savepng(plt::PlottingObject, args...; kw...) = savepng(plt.plotter, plt, args...; kw...)
+# try
+#   import DataFrames
+#   dataframes()
+# end
 
+# const CURRENT_BACKEND = pickDefaultBackend()
+
+# for be in backends()
+#   try
+#     backend(be)
+#     backend()
+#   catch err
+#     @show err
+#   end
+# end
+
+const CURRENT_BACKEND = CurrentBackend(:none)
+
+# function __init__()
+#   # global const CURRENT_BACKEND = pickDefaultBackend()
+#   # global const CURRENT_BACKEND = CurrentBackend(:none)
+
+#   # global CURRENT_BACKEND
+#   # println("[Plots.jl] Default backend: ", CURRENT_BACKEND.sym)
+
+#   # # auto init dataframes if the import statement doesn't error out
+#   # try
+#   #   @eval import DataFrames
+#   #   dataframes()
+#   # end
+# end
 
 # ---------------------------------------------------------
 

src/animation.jl

@@ -0,0 +1,86 @@
+
+immutable Animation
+  dir::ASCIIString
+  frames::Vector{ASCIIString}
+end
+
+function Animation()
+  tmpdir = convert(ASCIIString, mktempdir())
+  Animation(tmpdir, ASCIIString[])
+end
+
+function frame{P<:PlottingObject}(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::ASCIIString
+end
+
+function gif(anim::Animation, fn::@compat(AbstractString) = "tmp.gif"; fps::Integer = 20)
+  fn = abspath(fn)
+
+  try
+
+    # high quality
+    speed = round(Int, 100 / fps)
+    run(`convert -delay $speed -loop 0 $(anim.dir)/*.png $fn`)
+
+  catch err
+    warn("Tried to create gif using convert (ImageMagick), but got error: $err\nWill 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
+
+
+# -----------------------------------------------
+
+"""
+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
+```
+"""
+macro animate(forloop::Expr)
+  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")
+  block = forloop.args[2]
+  push!(block.args, :(frame($animsym)))
+
+  # full expression:
+  esc(quote
+    $animsym = Animation()  # init animation object
+    $forloop                   # for loop, saving a frame after each iteration
+    $animsym                # return the animation object
+  end)
+end

src/args.jl

@@ -1,133 +1,772 @@
 
 
-# const COLORS = [:black, :blue, :green, :red, :darkGray, :darkCyan, :darkYellow, :darkMagenta,
-#                 :darkBlue, :darkGreen, :darkRed, :gray, :cyan, :yellow, :magenta]
-const COLORS = distinguishable_colors(20)
-const NUMCOLORS = length(COLORS)
+const _allAxes = [:auto, :left, :right]
+@compat const _axesAliases = Dict(
+    :a => :auto,
+    :l => :left,
+    :r => :right
+  )
 
-# these are valid choices... first one is default value if unset
-const LINE_AXES = (:left, :right)
-const LINE_TYPES = (:line, :step, :stepinverted, :sticks, :dots, :none, :heatmap, :hexbin, :hist, :bar)
-const LINE_STYLES = (:solid, :dash, :dot, :dashdot, :dashdotdot)
-const LINE_MARKERS = (:none, :ellipse, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star1, :star2, :hexagon)
+const _3dTypes = [:path3d, :scatter3d, :surface, :wireframe]
+const _allTypes = vcat([
+                        :none, :line, :path, :steppre, :steppost, :sticks, :scatter,
+                        :heatmap, :hexbin, :hist, :density, :bar, :hline, :vline, :ohlc,
+                        :contour, :pie
+                       ], _3dTypes)
+@compat const _typeAliases = Dict(
+    :n             => :none,
+    :no            => :none,
+    :l             => :line,
+    :p             => :path,
+    :stepinv       => :steppre,
+    :stepsinv      => :steppre,
+    :stepinverted  => :steppre,
+    :stepsinverted => :steppre,
+    :step          => :steppost,
+    :steps         => :steppost,
+    :stair         => :steppost,
+    :stairs        => :steppost,
+    :stem          => :sticks,
+    :stems         => :sticks,
+    :dots          => :scatter,
+    :histogram     => :hist,
+    :pdf           => :density,
+    :contours      => :contour,
+    :line3d        => :path3d,
+    :surf          => :surface,
+    :wire          => :wireframe,
+  )
+
+ishistlike(lt::Symbol) = lt in (:hist, :density)
+islinelike(lt::Symbol) = lt in (:line, :path, :steppre, :steppost)
+isheatmaplike(lt::Symbol) = lt in (:heatmap, :hexbin)
+
+
+const _allStyles = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
+@compat const _styleAliases = Dict(
+    :a    => :auto,
+    :s    => :solid,
+    :d    => :dash,
+    :dd   => :dashdot,
+    :ddd  => :dashdotdot,
+  )
+
+# const _allMarkers = [:none, :auto, :ellipse, :rect, :diamond, :utriangle, :dtriangle,
+#                      :cross, :xcross, :star5, :star8, :hexagon, :octagon, Shape]
+const _allMarkers = vcat(:none, :auto, sort(collect(keys(_shapes))))
+@compat const _markerAliases = Dict(
+    :n            => :none,
+    :no           => :none,
+    :a            => :auto,
+    :circle       => :ellipse,
+    :c            => :ellipse,
+    :square       => :rect,
+    :sq           => :rect,
+    :r            => :rect,
+    :d            => :diamond,
+    :^            => :utriangle,
+    :ut           => :utriangle,
+    :utri         => :utriangle,
+    :uptri        => :utriangle,
+    :uptriangle   => :utriangle,
+    :v            => :dtriangle,
+    :V            => :dtriangle,
+    :dt           => :dtriangle,
+    :dtri         => :dtriangle,
+    :downtri      => :dtriangle,
+    :downtriangle => :dtriangle,
+    :+            => :cross,
+    :plus         => :cross,
+    :x            => :xcross,
+    :X            => :xcross,
+    :star         => :star5,
+    :s            => :star5,
+    :star1        => :star5,
+    :s2           => :star8,
+    :star2        => :star8,
+    :p            => :pentagon,
+    :pent         => :pentagon,
+    :h            => :hexagon,
+    :hex          => :hexagon,
+    :hep          => :heptagon,
+    :o            => :octagon,
+    :oct          => :octagon,
+    :spike        => :vline,
+  )
+
+const _allScales = [:identity, :ln, :log2, :log10, :asinh, :sqrt]
+@compat const _scaleAliases = Dict(
+    :none => :identity,
+    :log  => :log10,
+  )
 
 # -----------------------------------------------------------------------------
 
-const PLOT_DEFAULTS = Dict{Symbol, Any}()
+const _seriesDefaults = Dict{Symbol, Any}()
 
 # series-specific
-PLOT_DEFAULTS[:axis] = :left
-PLOT_DEFAULTS[:color] = :auto
-PLOT_DEFAULTS[:label] = "AUTO"
-PLOT_DEFAULTS[:width] = 1
-PLOT_DEFAULTS[:linetype] = :line
-PLOT_DEFAULTS[:linestyle] = :solid
-PLOT_DEFAULTS[:marker] = :none
-PLOT_DEFAULTS[:markercolor] = :match
-PLOT_DEFAULTS[:markersize] = 3
-PLOT_DEFAULTS[:nbins] = 100               # number of bins for heatmaps and hists
-PLOT_DEFAULTS[:heatmap_c] = (0.15, 0.5)
-PLOT_DEFAULTS[:fillto] = nothing          # fills in the area
-PLOT_DEFAULTS[:reg] = false               # regression line?
+_seriesDefaults[:axis]            = :left
+_seriesDefaults[:label]           = "AUTO"
+_seriesDefaults[:linetype]        = :path
+_seriesDefaults[:linestyle]       = :solid
+_seriesDefaults[:linewidth]       = 1
+_seriesDefaults[:linecolor]       = :auto
+_seriesDefaults[:linealpha]       = nothing
+# _seriesDefaults[:linestroke]      = Stroke(1, :auto, nothing, :solid)  # linewidth, linecolor, linealpha, linestyle
+# _seriesDefaults[:fillbrush]       = Brush(nothing, :match, nothing)  # fillrange, fillcolor, fillalpha
+_seriesDefaults[:fillrange]       = nothing   # ribbons, areas, etc
+_seriesDefaults[:fillcolor]       = :match
+_seriesDefaults[:fillalpha]       = nothing
+_seriesDefaults[:markershape]     = :none
+# _seriesDefaults[:markerstroke]    = Stroke(1, :match_foreground, nothing, :solid)
+# _seriesDefaults[:markerbrush]     = Brush(6, :match, nothing)
+_seriesDefaults[:markercolor]     = :match
+_seriesDefaults[:markeralpha]     = nothing
+_seriesDefaults[:markersize]      = 6
+_seriesDefaults[:markerstrokestyle] = :solid
+_seriesDefaults[:markerstrokewidth] = 1
+_seriesDefaults[:markerstrokecolor] = :match
+_seriesDefaults[:markerstrokealpha] = nothing
+# _seriesDefaults[:ribbon]          = nothing
+# _seriesDefaults[:ribboncolor]     = :match
+_seriesDefaults[:nbins]           = 30               # number of bins for heatmaps and hists
+_seriesDefaults[:smooth]          = false               # regression line?
+_seriesDefaults[:group]           = nothing           # groupby vector
+# _seriesDefaults[:annotation]      = nothing           # annotation tuple(s)... (x,y,annotation)
+_seriesDefaults[:x]               = nothing
+_seriesDefaults[:y]               = nothing
+_seriesDefaults[:z]               = nothing           # depth for contour, surface, etc
+_seriesDefaults[:zcolor]          = nothing           # value for color scale
+# _seriesDefaults[:surface]         = nothing
+# _seriesDefaults[:nlevels]         = 15
+_seriesDefaults[:levels]          = 15
+_seriesDefaults[:orientation]     = :vertical
+
+
+const _plotDefaults = Dict{Symbol, Any}()
 
 # plot globals
-PLOT_DEFAULTS[:title] = ""
-PLOT_DEFAULTS[:xlabel] = ""
-PLOT_DEFAULTS[:ylabel] = ""
-PLOT_DEFAULTS[:yrightlabel] = ""
-PLOT_DEFAULTS[:legend] = true
-# PLOT_DEFAULTS[:background_color] = nothing
-PLOT_DEFAULTS[:xticks] = true
-PLOT_DEFAULTS[:yticks] = true
-PLOT_DEFAULTS[:size] = (600,400)
+_plotDefaults[:title]             = ""
+_plotDefaults[:xlabel]            = ""
+_plotDefaults[:ylabel]            = ""
+_plotDefaults[:yrightlabel]       = ""
+_plotDefaults[:legend]            = :best
+_plotDefaults[:colorbar]          = :legend
+_plotDefaults[:background_color]  = colorant"white"
+_plotDefaults[:foreground_color]  = :auto
+_plotDefaults[:xlims]             = :auto
+_plotDefaults[:ylims]             = :auto
+_plotDefaults[:xticks]            = :auto
+_plotDefaults[:yticks]            = :auto
+_plotDefaults[:xscale]            = :identity
+_plotDefaults[:yscale]            = :identity
+_plotDefaults[:xflip]             = false
+_plotDefaults[:yflip]             = false
+_plotDefaults[:size]              = (600,400)
+_plotDefaults[:pos]               = (0,0)
+_plotDefaults[:windowtitle]       = "Plots.jl"
+_plotDefaults[:show]              = false
+_plotDefaults[:layout]            = nothing
+_plotDefaults[:n]                 = -1
+_plotDefaults[:nr]                = -1
+_plotDefaults[:nc]                = -1
+_plotDefaults[:color_palette]     = :auto
+_plotDefaults[:link]              = false
+_plotDefaults[:linkx]             = false
+_plotDefaults[:linky]             = false
+_plotDefaults[:linkfunc]          = nothing
+_plotDefaults[:tickfont]          = font(8)
+_plotDefaults[:guidefont]         = font(11)
+_plotDefaults[:legendfont]        = font(8)
+_plotDefaults[:grid]              = true
+_plotDefaults[:annotation]      = nothing           # annotation tuple(s)... (x,y,annotation)
+
+
 
 # TODO: x/y scales
 
+const _allArgs = sort(collect(union(keys(_seriesDefaults), keys(_plotDefaults))))
+supportedArgs(::PlottingPackage) = _allArgs
+supportedArgs() = supportedArgs(backend())
+
+
 
 # -----------------------------------------------------------------------------
 
-plotDefault(sym::Symbol) = PLOT_DEFAULTS[sym]
-function plotDefault!(sym::Symbol, val)
-  PLOT_DEFAULTS[sym] = val
+makeplural(s::Symbol) = symbol(string(s,"s"))
+
+autopick(arr::AVec, idx::Integer) = arr[mod1(idx,length(arr))]
+autopick(notarr, idx::Integer) = notarr
+
+autopick_ignore_none_auto(arr::AVec, idx::Integer) = autopick(setdiff(arr, [:none, :auto]), idx)
+autopick_ignore_none_auto(notarr, idx::Integer) = notarr
+
+function aliasesAndAutopick(d::Dict, sym::Symbol, aliases::Dict, options::AVec, plotIndex::Int)
+  if d[sym] == :auto
+    d[sym] = autopick_ignore_none_auto(options, plotIndex)
+  elseif haskey(aliases, d[sym])
+    d[sym] = aliases[d[sym]]
+  end
+end
+
+function aliases(aliasMap::Dict, val)
+  # sort(vcat(val, collect(keys(filter((k,v)-> v==val, aliasMap)))))
+  sortedkeys(filter((k,v)-> v==val, aliasMap))
 end
 
 # -----------------------------------------------------------------------------
 
-makeplural(s::Symbol) = Symbol(string(s,"s"))
-autocolor(idx::Integer) = COLORS[mod1(idx,NUMCOLORS)]
+# Alternate args
 
+@compat const _keyAliases = Dict(
+    :c                  => :linecolor,
+    :color              => :linecolor,
+    :colour             => :linecolor,
+    :lab                => :label,
+    :l                  => :line,
+    :w                  => :linewidth,
+    :width              => :linewidth,
+    :lw                 => :linewidth,
+    :la                 => :linealpha,
+    :lineopacity        => :linealpha,
+    :type               => :linetype,
+    :lt                 => :linetype,
+    :t                  => :linetype,
+    :style              => :linestyle,
+    :s                  => :linestyle,
+    :ls                 => :linestyle,
+    :m                  => :marker,
+    :mark               => :marker,
+    :shape              => :markershape,
+    :mc                 => :markercolor,
+    :mcolor             => :markercolor,
+    :markercolour       => :markercolor,
+    :ms                 => :markersize,
+    :msize              => :markersize,
+    :ma                 => :markeralpha,
+    :alpha              => :markeralpha,
+    :opacity            => :markeralpha,
+    :markeropacity      => :markeralpha,
+    :f                  => :fill,
+    :area               => :fill,
+    :fillrng            => :fillrange,
+    :fc                 => :fillcolor,
+    :fcolor             => :fillcolor,
+    :fillcolour         => :fillcolor,
+    :fa                 => :fillalpha,
+    :fillopacity        => :fillalpha,
+    :g                  => :group,
+    :nb                 => :nbins,
+    :nbin               => :nbins,
+    :rib                => :ribbon,
+    :ann                => :annotation,
+    :anns               => :annotation,
+    :annotate           => :annotation,
+    :annotations        => :annotation,
+    :xlab               => :xlabel,
+    :ylab               => :ylabel,
+    :yrlab              => :yrightlabel,
+    :ylabr              => :yrightlabel,
+    :y2lab              => :yrightlabel,
+    :ylab2              => :yrightlabel,
+    :ylabelright        => :yrightlabel,
+    :ylabel2            => :yrightlabel,
+    :y2label            => :yrightlabel,
+    :leg                => :legend,
+    :key                => :legend,
+    :cbar               => :colorbar,
+    :cb                 => :colorbar,
+    :bg                 => :background_color,
+    :bgcolor            => :background_color,
+    :bg_color           => :background_color,
+    :background         => :background_color,
+    :background_colour  => :background_color,
+    :fg                 => :foreground_color,
+    :fgcolor            => :foreground_color,
+    :fg_color           => :foreground_color,
+    :foreground         => :foreground_color,
+    :foreground_colour  => :foreground_color,
+    :regression         => :smooth,
+    :reg                => :smooth,
+    :nlevels            => :levels,
+    :nlev               => :levels,
+    :levs               => :levels,
+    :xlim               => :xlims,
+    :xlimit             => :xlims,
+    :xlimits            => :xlims,
+    :ylim               => :ylims,
+    :ylimit             => :ylims,
+    :ylimits            => :ylims,
+    :xtick              => :xticks,
+    :ytick              => :yticks,
+    :windowsize         => :size,
+    :wsize              => :size,
+    :wtitle             => :windowtitle,
+    :gui                => :show,
+    :display            => :show,
+    :palette            => :color_palette,
+    :xlink              => :linkx,
+    :ylink              => :linky,
+  )
 
-# converts a symbol or string into a colorant (Colors.RGB), and assigns a color automatically
-# note: if plt is nothing, we aren't doing anything with the color anyways
-function getRGBColor(c, n::Int = 0)
-
-  # auto-assign a color based on plot index
-  if c == :auto && n > 0
-    c = autocolor(n)
-  end
-
-  # convert it from a symbol/string
-  if isa(c, Symbol)
-    c = string(c)
-  end
-  if isa(c, String)
-    c = parse(Colorant, c)
-  end
-
-  # should be a RGB now... either it was passed in, generated automatically, or created from a string
-  @assert isa(c, RGB)
-
-  # return the RGB
-  c
+# add all pluralized forms to the _keyAliases dict
+for arg in keys(_seriesDefaults)
+  _keyAliases[makeplural(arg)] = arg
 end
 
 
-# note: idx is the index of this series within this call, n is the index of the series from all calls to plot/subplot
-function getPlotKeywordArgs(kw, idx::Int, n::Int)
-  d = Dict(kw)
 
-  # default to a white background, but only on the initial call (so we don't change the background automatically)
-  if haskey(d, :background_color)
-    d[:background_color] = getRGBColor(d[:background_color])
-  elseif n == 0
-    d[:background_color] = colorant"white"
-  end
+# -----------------------------------------------------------------------------
 
-  # fill in d with either 1) plural value, 2) value, 3) default
-  for k in keys(PLOT_DEFAULTS)
-    plural = makeplural(k)
-    # if haskey(d, plural)
-    #   d[k] = d[plural][idx]
-    if !haskey(d, k)
-      if n == 0 || k != :size
-        d[k] = haskey(d, plural) ? d[plural][idx] : PLOT_DEFAULTS[k]
-      end
-    end
-    delete!(d, plural)
-  end
+# update the defaults globally
 
+"""
+`default(key)` returns the current default value for that key
+`default(key, value)` sets the current default value for that key
+`default(; kw...)` will set the current default value for each key/value pair
+"""
 
-
-  # handle plot initialization differently
-  if n == 0
-    delete!(d, :x)
-    delete!(d, :y)
+function default(k::Symbol)
+  k = get(_keyAliases, k, k)
+  if haskey(_seriesDefaults, k)
+    return _seriesDefaults[k]
+  elseif haskey(_plotDefaults, k)
+    return _plotDefaults[k]
   else
-    # once the plot is created, we can get line/marker colors
-  
-    # update color
-    d[:color] = getRGBColor(d[:color], n)
-
-    # update markercolor
-    mc = d[:markercolor]
-    mc = (mc == :match ? d[:color] : getRGBColor(mc, n))
-    d[:markercolor] = mc
-
-    # set label
-    label = d[:label]
-    d[:label] = string(label == "AUTO" ? "y_$n" : label, d[:axis] == :left ? "" : " (R)")
+    error("Unknown key: ", k)
   end
+end
+
+function default(k::Symbol, v)
+  k = get(_keyAliases, k, k)
+  if haskey(_seriesDefaults, k)
+    _seriesDefaults[k] = v
+  elseif haskey(_plotDefaults, k)
+    _plotDefaults[k] = v
+  else
+    error("Unknown key: ", k)
+  end
+end
+
+function default(; kw...)
+  for (k,v) in kw
+    default(k, v)
+  end
+end
+
+# -----------------------------------------------------------------------------
+
+wraptuple(x::@compat(Tuple)) = x
+wraptuple(x) = (x,)
+
+trueOrAllTrue(f::Function, x::AbstractArray) = all(f, x)
+trueOrAllTrue(f::Function, x) = f(x)
+
+function handleColors!(d::Dict, arg, csym::Symbol)
+  try
+    if arg == :auto
+      d[csym] = :auto
+    else
+      c = colorscheme(arg)
+      d[csym] = c
+    end
+    return true
+  end
+  false
+end
+
+# given one value (:log, or :flip, or (-1,1), etc), set the appropriate arg
+# TODO: use trueOrAllTrue for subplots which can pass vectors for these
+function processAxisArg(d::Dict, axisletter::@compat(AbstractString), arg)
+  T = typeof(arg)
+  # if T <: Symbol
+
+  arg = get(_scaleAliases, arg, arg)
+
+  if arg in _allScales
+    d[symbol(axisletter * "scale")] = arg
+
+  elseif arg in (:flip, :invert, :inverted)
+    d[symbol(axisletter * "flip")] = true
+
+  elseif T <: @compat(AbstractString)
+    d[symbol(axisletter * "label")] = arg
+
+  # xlims/ylims
+  elseif (T <: Tuple || T <: AVec) && length(arg) == 2
+    d[symbol(axisletter * "lims")] = arg
+
+  # xticks/yticks
+  elseif T <: AVec
+    d[symbol(axisletter * "ticks")] = arg
+
+  elseif arg == nothing
+    d[symbol(axisletter * "ticks")] = []
+
+  else
+    warn("Skipped $(axisletter)axis arg $arg")
+
+  end
+end
+
+
+function processLineArg(d::Dict, arg)
+
+  # linetype
+  if trueOrAllTrue(a -> get(_typeAliases, a, a) in _allTypes, arg)
+    d[:linetype] = arg
+
+  # linestyle
+  elseif trueOrAllTrue(a -> get(_styleAliases, a, a) in _allStyles, arg)
+    d[:linestyle] = arg
+
+  elseif typeof(arg) <: Stroke
+    arg.width == nothing || (d[:linewidth] = arg.width)
+    arg.color == nothing || (d[:linecolor] = arg.color == :auto ? :auto : colorscheme(arg.color))
+    arg.alpha == nothing || (d[:linealpha] = arg.alpha)
+    arg.style == nothing || (d[:linestyle] = arg.style)
+
+  elseif typeof(arg) <: Brush
+    arg.size  == nothing || (d[:fillrange] = arg.size)
+    arg.color == nothing || (d[:fillcolor] = arg.color == :auto ? :auto : colorscheme(arg.color))
+    arg.alpha == nothing || (d[:fillalpha] = arg.alpha)
+
+  # linealpha
+  elseif trueOrAllTrue(a -> typeof(a) <: Real && a > 0 && a < 1, arg)
+    d[:linealpha] = arg
+
+  # linewidth
+  elseif trueOrAllTrue(a -> typeof(a) <: Real, arg)
+    d[:linewidth] = arg
+
+  # color
+  elseif !handleColors!(d, arg, :linecolor)
+    warn("Skipped line arg $arg.")
+
+  end
+end
+
+
+function processMarkerArg(d::Dict, arg)
+
+  # markershape
+  if trueOrAllTrue(a -> get(_markerAliases, a, a) in _allMarkers, arg)
+    d[:markershape] = arg
+  elseif trueOrAllTrue(a -> isa(a, Shape), arg)
+    d[:markershape] = arg
+
+  # stroke style
+  elseif trueOrAllTrue(a -> get(_styleAliases, a, a) in _allStyles, arg)
+    d[:markerstrokestyle] = arg
+
+  elseif typeof(arg) <: Stroke
+    arg.width == nothing || (d[:markerstrokewidth] = arg.width)
+    arg.color == nothing || (d[:markerstrokecolor] = arg.color == :auto ? :auto : colorscheme(arg.color))
+    arg.alpha == nothing || (d[:markerstrokealpha] = arg.alpha)
+    arg.style == nothing || (d[:markerstrokestyle] = arg.style)
+
+  elseif typeof(arg) <: Brush
+    arg.size  == nothing || (d[:markersize]  = arg.size)
+    arg.color == nothing || (d[:markercolor] = arg.color == :auto ? :auto : colorscheme(arg.color))
+    arg.alpha == nothing || (d[:markeralpha] = arg.alpha)
+
+  # linealpha
+  elseif trueOrAllTrue(a -> typeof(a) <: Real && a > 0 && a < 1, arg)
+    d[:markeralpha] = arg
+
+  # markersize
+  elseif trueOrAllTrue(a -> typeof(a) <: Real, arg)
+    d[:markersize] = arg
+
+  # markercolor
+  elseif !handleColors!(d, arg, :markercolor)
+    warn("Skipped marker arg $arg.")
+
+  end
+end
+
+
+function processFillArg(d::Dict, arg)
+
+  if typeof(arg) <: Brush
+    arg.size  == nothing || (d[:fillrange] = arg.size)
+    arg.color == nothing || (d[:fillcolor] = arg.color == :auto ? :auto : colorscheme(arg.color))
+    arg.alpha == nothing || (d[:fillalpha] = arg.alpha)
+
+  # fillrange function
+  elseif trueOrAllTrue(a -> isa(a, Function), arg)
+    d[:fillrange] = arg
+
+  # fillalpha
+  elseif trueOrAllTrue(a -> typeof(a) <: Real && a > 0 && a < 1, arg)
+    d[:fillalpha] = arg
+
+  elseif !handleColors!(d, arg, :fillcolor)
+    
+    d[:fillrange] = arg
+  end
+end
+
+"Handle all preprocessing of args... break out colors/sizes/etc and replace aliases."
+function preprocessArgs!(d::Dict)
+  replaceAliases!(d, _keyAliases)
+
+  # handle axis args
+  for axisletter in ("x", "y")
+    asym = symbol(axisletter * "axis")
+    for arg in wraptuple(get(d, asym, ()))
+      processAxisArg(d, axisletter, arg)
+    end
+    delete!(d, asym)
+  end
+
+  # handle line args
+  for arg in wraptuple(get(d, :line, ()))
+    processLineArg(d, arg)
+  end
+  delete!(d, :line)
+
+  # handle marker args... default to ellipse if shape not set
+  anymarker = false
+  for arg in wraptuple(get(d, :marker, ()))
+    processMarkerArg(d, arg)
+    anymarker = true
+  end
+  delete!(d, :marker)
+  if anymarker && !haskey(d, :markershape)
+    d[:markershape] = :ellipse
+  end
+
+  # handle fill
+  for arg in wraptuple(get(d, :fill, ()))
+    processFillArg(d, arg)
+  end
+  delete!(d, :fill)
+
+  # convert into strokes and brushes
+
+  # legends
+  if haskey(d, :legend)
+    d[:legend] = convertLegendValue(d[:legend])
+  end
+  if haskey(d, :colorbar)
+    d[:colorbar] = convertLegendValue(d[:colorbar])
+  end
+
+  # handle subplot links
+  if haskey(d, :link)
+    l = d[:link]
+    if isa(l, Bool)
+      d[:linkx] = l
+      d[:linky] = l
+    elseif isa(l, Function)
+      d[:linkx] = true
+      d[:linky] = true
+      d[:linkfunc] = l
+    else
+      warn("Unhandled/invalid link $l.  Should be a Bool or a function mapping (row,column) -> (linkx, linky), where linkx/y can be Bool or Void (nothing)")
+    end
+    delete!(d, :link)
+  end
+
+  return
+end
+
+# -----------------------------------------------------------------------------
+
+"A special type that will break up incoming data into groups, and allow for easier creation of grouped plots"
+type GroupBy
+  groupLabels::Vector{UTF8String}   # length == numGroups
+  groupIds::Vector{Vector{Int}}     # list of indices for each group
+end
+
+
+# this is when given a vector-type of values to group by
+function extractGroupArgs(v::AVec, args...)
+  groupLabels = sort(collect(unique(v)))
+  n = length(groupLabels)
+  if n > 20
+    error("Too many group labels. n=$n  Is that intended?")
+  end
+  groupIds = Vector{Int}[filter(i -> v[i] == glab, 1:length(v)) for glab in groupLabels]
+  GroupBy(map(string, groupLabels), groupIds)
+end
+
+
+# expecting a mapping of "group label" to "group indices"
+function extractGroupArgs{T, V<:AVec{Int}}(idxmap::Dict{T,V}, args...)
+  groupLabels = sortedkeys(idxmap)
+  groupIds = VecI[collect(idxmap[k]) for k in groupLabels]
+  GroupBy(groupLabels, groupIds)
+end
+
+
+# -----------------------------------------------------------------------------
+
+function warnOnUnsupportedArgs(pkg::PlottingPackage, d::Dict)
+  for k in sortedkeys(d)
+    if (!(k in supportedArgs(pkg))
+        && k != :subplot
+        && d[k] != default(k))
+      warn("Keyword argument $k not supported with $pkg.  Choose from: $(supportedArgs(pkg))")
+    end
+  end
+end
+
+
+function warnOnUnsupported(pkg::PlottingPackage, d::Dict)
+  (d[:axis] in supportedAxes(pkg)
+    || warn("axis $(d[:axis]) is unsupported with $pkg.  Choose from: $(supportedAxes(pkg))"))
+  (d[:linetype] == :none
+    || d[:linetype] in supportedTypes(pkg)
+    || warn("linetype $(d[:linetype]) is unsupported with $pkg.  Choose from: $(supportedTypes(pkg))"))
+  (d[:linestyle] in supportedStyles(pkg)
+    || warn("linestyle $(d[:linestyle]) is unsupported with $pkg.  Choose from: $(supportedStyles(pkg))"))
+  (d[:markershape] == :none
+    || d[:markershape] in supportedMarkers(pkg)
+    || (Shape in supportedMarkers(pkg) && typeof(d[:markershape]) <: Shape)
+    || warn("markershape $(d[:markershape]) is unsupported with $pkg.  Choose from: $(supportedMarkers(pkg))"))
+end
+
+function warnOnUnsupportedScales(pkg::PlottingPackage, d::Dict)
+  for k in (:xscale, :yscale)
+    if haskey(d, k)
+      d[k] in supportedScales(pkg) || warn("scale $(d[k]) is unsupported with $pkg.  Choose from: $(supportedScales(pkg))")
+    end
+  end
+end
+
+
+# -----------------------------------------------------------------------------
+
+# 1-row matrices will give an element
+# multi-row matrices will give a column
+# anything else is returned as-is
+# getArgValue(v::Tuple, idx::Int) = v[mod1(idx, length(v))]
+function getArgValue(v::AMat, idx::Int)
+  c = mod1(idx, size(v,2))
+  size(v,1) == 1 ? v[1,c] : v[:,c]
+end
+getArgValue(v, idx) = v
+
+
+# given an argument key (k), we want to extract the argument value for this index.
+# if nothing is set (or container is empty), return the default.
+function setDictValue(d_in::Dict, d_out::Dict, k::Symbol, idx::Int, defaults::Dict)
+  if haskey(d_in, k) && !(typeof(d_in[k]) <: @compat(Union{AbstractArray, Tuple}) && isempty(d_in[k]))
+    d_out[k] = getArgValue(d_in[k], idx)
+  else
+    d_out[k] = defaults[k]
+  end
+end
+
+function convertLegendValue(val::Symbol)
+  if val in (:both, :all, :yes)
+    :best
+  elseif val in (:no, :none)
+    :none
+  elseif val in (:right, :left, :top, :bottom, :inside, :best, :legend)
+    val
+  else
+    error("Invalid symbol for legend: $val")
+  end
+end
+convertLegendValue(val::Bool) = val ? :best : :none
+
+# -----------------------------------------------------------------------------
+
+# build the argument dictionary for the plot
+function getPlotArgs(pkg::PlottingPackage, kw, idx::Int; set_defaults = true)
+  kwdict = Dict(kw)
+  d = Dict()
+
+  # add defaults?
+  if set_defaults
+    for k in keys(_plotDefaults)
+      setDictValue(kwdict, d, k, idx, _plotDefaults)
+    end
+  end
+
+  for k in (:xscale, :yscale)
+    if haskey(_scaleAliases, d[k])
+      d[k] = _scaleAliases[d[k]]
+    end
+  end
+
+  # handle legend/colorbar
+  d[:legend] = convertLegendValue(d[:legend])
+  d[:colorbar] = convertLegendValue(d[:colorbar])
+  if d[:colorbar] == :legend
+    d[:colorbar] = d[:legend]
+  end
+
+  # convert color
+  handlePlotColors(pkg, d)
+
+  # no need for these
+  delete!(d, :x)
+  delete!(d, :y)
 
   d
 end
 
+
+
+# build the argument dictionary for a series
+function getSeriesArgs(pkg::PlottingPackage, plotargs::Dict, kw, commandIndex::Int, plotIndex::Int, globalIndex::Int)  # TODO, pass in plotargs, not plt
+  kwdict = Dict(kw)
+  d = Dict()
+
+  # add defaults?
+  for k in keys(_seriesDefaults)
+    setDictValue(kwdict, d, k, commandIndex, _seriesDefaults)
+  end
+
+  # groupby args?
+  for k in (:idxfilter, :numUncounted, :dataframe)
+    if haskey(kwdict, k)
+      d[k] = kwdict[k]
+    end
+  end
+
+  if haskey(_typeAliases, d[:linetype])
+    d[:linetype] = _typeAliases[d[:linetype]]
+  end
+
+  aliasesAndAutopick(d, :axis, _axesAliases, supportedAxes(pkg), plotIndex)
+  aliasesAndAutopick(d, :linestyle, _styleAliases, supportedStyles(pkg), plotIndex)
+  aliasesAndAutopick(d, :markershape, _markerAliases, supportedMarkers(pkg), plotIndex)
+
+  # update color
+  d[:linecolor] = getSeriesRGBColor(d[:linecolor], plotargs, plotIndex)
+
+  # update markercolor
+  c = d[:markercolor]
+  c = (c == :match ? d[:linecolor] : getSeriesRGBColor(c, plotargs, plotIndex))
+  d[:markercolor] = c
+
+  # update markerstrokecolor
+  c = d[:markerstrokecolor]
+  c = (c == :match ? plotargs[:foreground_color] : getSeriesRGBColor(c, plotargs, plotIndex))
+  d[:markerstrokecolor] = c
+
+  # update fillcolor
+  c = d[:fillcolor]
+  c = (c == :match ? d[:linecolor] : getSeriesRGBColor(c, plotargs, plotIndex))
+  d[:fillcolor] = c
+
+  # set label
+  label = d[:label]
+  label = (label == "AUTO" ? "y$globalIndex" : label)
+  if d[:axis] == :right && !(length(label) >= 4 && label[end-3:end] != " (R)")
+    label = string(label, " (R)")
+  end
+  d[:label] = label
+
+  warnOnUnsupported(pkg, d)
+
+
+  d
+end
+
+

src/backends/bokeh.jl

@@ -0,0 +1,175 @@
+
+# https://github.com/bokeh/Bokeh.jl
+
+
+function _initialize_backend(::BokehPackage; kw...)
+  @eval begin
+    import Bokeh
+    export Bokeh
+  end
+end
+
+# make255(x) = round(Int, 255 * x)
+
+# function bokehcolor(c::Colorant)
+#   @sprintf("rgba(%d, %d, %d, %1.3f)", [make255(f(c)) for f in [red,green,blue]]..., alpha(c))
+# end
+# bokehcolor(cs::ColorScheme) = bokehcolor(getColor(cs))
+
+
+const _glyphtypes = Dict(
+    :ellipse    => :Circle,
+    :rect       => :Square,
+    :diamond    => :Diamond,
+    :utriangle  => :Triangle,
+    :dtriangle  => :InvertedTriangle,
+    # :pentagon   => 
+    # :hexagon    => 
+    # :heptagon   => 
+    # :octagon    => 
+    :cross      => :Cross,
+    :xcross     => :X,
+    :star5      => :Asterisk,
+  )
+
+
+function bokeh_glyph_type(d::Dict)
+  lt = d[:linetype]
+  mt = d[:markershape]
+  if lt == :scatter && mt == :none
+    mt = :ellipse
+  end
+
+  # if we have a marker, use that
+  if lt == :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::BokehPackage; kw...)
+  d = Dict(kw)
+
+  # dumpdict(d, "plot", true)
+
+  # TODO: create the window/canvas/context that is the plot within the backend (call it `o`)
+  # TODO: initialize the plot... title, xlabel, bgcolor, etc
+
+  datacolumns = Bokeh.BokehDataSet[]
+  tools = Bokeh.tools()
+  filename = tempname() * ".html"
+  title = d[:title]
+  w, h = d[:size]
+  xaxis_type = d[:xscale] == :log10 ? :log : :auto
+  yaxis_type = d[:yscale] == :log10 ? :log : :auto
+  # legend = d[:legend] ? xxxx : nothing
+  legend = nothing
+  extra_args = Dict()  # TODO: we'll put extra settings (xlim, etc) here
+  bplt = Bokeh.Plot(datacolumns, tools, filename, title, w, h, xaxis_type, yaxis_type, legend) #, extra_args)
+
+  Plot(bplt, pkg, 0, d, Dict[])
+end
+
+
+function _add_series(::BokehPackage, plt::Plot; kw...)
+  d = Dict(kw)
+
+  # dumpdict(d, "plot!", true)
+
+  bdata = Dict{Symbol, Vector}(:x => collect(d[:x]), :y => collect(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(plt::Plot{BokehPackage}, d::Dict)
+end
+
+function _update_plot_pos_size(plt::PlottingObject{BokehPackage}, d::Dict)
+end
+
+# ----------------------------------------------------------------
+
+# accessors for x/y data
+
+function Base.getindex(plt::Plot{BokehPackage}, i::Int)
+  series = plt.o.datacolumns[i].data
+  series[:x], series[:y]
+end
+
+function Base.setindex!(plt::Plot{BokehPackage}, xy::Tuple, i::Integer)
+  series = plt.o.datacolumns[i].data
+  series[:x], series[:y] = xy
+  plt
+end
+
+
+# ----------------------------------------------------------------
+
+function _add_annotations{X,Y,V}(plt::Plot{BokehPackage}, anns::AVec{@compat(Tuple{X,Y,V})})
+  for ann in anns
+    # TODO: add the annotation to the plot
+  end
+end
+
+# ----------------------------------------------------------------
+
+function _create_subplot(subplt::Subplot{BokehPackage}, isbefore::Bool)
+  # TODO: build the underlying Subplot object.  this is where you might layout the panes within a GUI window, for example
+
+end
+
+
+function _expand_limits(lims, plt::Plot{BokehPackage}, isx::Bool)
+  # TODO: call expand limits for each plot data
+end
+
+function _remove_axis(plt::Plot{BokehPackage}, isx::Bool)
+  # TODO: if plot is inner subplot, might need to remove ticks or axis labels
+end
+
+# ----------------------------------------------------------------
+
+function Base.writemime(io::IO, ::MIME"image/png", plt::PlottingObject{BokehPackage})
+  # TODO: write a png to io
+  warn("mime png not implemented")
+end
+
+function Base.display(::PlotsDisplay, plt::Plot{BokehPackage})
+  Bokeh.showplot(plt.o)
+end
+
+function Base.display(::PlotsDisplay, plt::Subplot{BokehPackage})
+  # TODO: display/show the subplot
+end

src/backends/gadfly.jl

@@ -0,0 +1,739 @@
+
+# https://github.com/dcjones/Gadfly.jl
+
+
+function _initialize_backend(::GadflyPackage; 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::Dict)
+  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[:xlabel]),
+                                   Gadfly.Guide.ylabel(d[:ylabel]),
+                                   Gadfly.Guide.title(d[:title])]
+  gplt
+end
+
+# ---------------------------------------------------------------------------
+
+
+function getLineGeom(d::Dict)
+  lt = d[:linetype]
+  xbins, ybins = maketuple(d[:nbins])
+  if lt == :hexbin
+    Gadfly.Geom.hexbin(xbincount = xbins, ybincount = ybins)
+  elseif lt == :heatmap
+    Gadfly.Geom.histogram2d(xbincount = xbins, ybincount = ybins)
+  elseif lt == :hist
+    Gadfly.Geom.histogram(bincount = xbins)
+  elseif lt == :path
+    Gadfly.Geom.path
+  elseif lt in (:bar, :sticks)
+    Gadfly.Geom.bar
+  elseif lt == :steppost
+    Gadfly.Geom.step
+  elseif lt == :steppre
+    Gadfly.Geom.step(direction = :vh)
+  elseif lt == :hline
+    Gadfly.Geom.hline
+  elseif lt == :vline
+    Gadfly.Geom.vline
+  elseif lt == :contour
+    Gadfly.Geom.contour(levels = d[:levels])
+  else
+    nothing
+  end
+end
+
+function get_extra_theme_args(d::Dict, k::Symbol)
+  # gracefully handles old Gadfly versions
+  extra_theme_args = Dict()
+  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::Dict)
+  
+  lc = convertColor(getColor(d[:linecolor]), d[:linealpha])
+  # lc = getColor(d[:linecolor])
+  # α = d[:linealpha]
+  # if α != nothing
+  #   lc = RGBA(lc, α)
+  # end
+
+  fc = convertColor(getColor(d[:fillcolor]), d[:fillalpha])
+  # fc = getColor(d[:fillcolor])
+  # α = d[:fillalpha]
+  # if α != nothing
+  #   fc = RGBA(fc, α)
+  # end
+
+
+  Gadfly.Theme(;
+      default_color = lc,
+      line_width = (d[:linetype] == :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::Dict, geoms...)
+  gplt = getGadflyContext(plt)
+  gfargs = vcat(geoms...,
+                getGadflyLineTheme(d))
+  kwargs = Dict()
+  lt = d[:linetype]
+
+  # add a fill?
+  if d[:fillrange] != nothing && lt != :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 lt in (:hline, :vline)
+    kwargs[lt == :hline ? :yintercept : :xintercept] = d[:y]
+    
+  else
+    if lt == :sticks
+      w = 0.01 * mean(diff(d[:x]))
+      kwargs[:xmin] = d[:x] - w
+      kwargs[:xmax] = d[:x] + w
+    elseif lt == :contour
+      # d[:y] = reverse(d[:y])
+      kwargs[:z] = d[:z].surf
+      addGadflyContColorScale(plt, d[:linecolor])
+    end
+
+    kwargs[:x] = d[lt == :hist ? :y : :x]
+    kwargs[:y] = d[:y]
+
+  end
+
+  # # h/vlines
+  # if lt == :hline
+  #   kwargs[:yintercept] = d[:y]
+  # elseif lt == :vline
+  #   kwargs[:xintercept] = d[:y]
+  # elseif lt == :sticks
+  #   w = 0.01 * mean(diff(d[:x]))
+  #   kwargs[:xmin] = d[:x] - w
+  #   kwargs[:xmax] = d[:x] + w
+  # elseif lt == :contour
+  #   d[:y] = reverse(d[:y])
+  #   kwargs[:z] = d[:surface]
+  # end
+
+  # if lt == :hist
+  #   kwargs[:x] = kwargs[:y] = d[:y]
+  # elseif lt != :hline && lt != :vline
+  #   kwargs[:x] = d[:x]
+  #   kwargs[:y] = d[:y]
+  # end
+  
+  # # add the layer
+  # x = d[d[:linetype] == :hist ? :y : :x]
+  # Gadfly.layer(gfargs...; x = x, y = d[:y], order=numlayers, kwargs...)
+  Gadfly.layer(gfargs...; order=numlayers, kwargs...)
+end
+
+
+# ---------------------------------------------------------------------------
+
+
+function getMarkerGeom(d::Dict)
+  shape = d[:markershape]
+  gadflyshape(isa(shape, Shape) ? shape : _shapes[shape])
+end
+
+
+function getGadflyMarkerTheme(d::Dict, plotargs::Dict)
+  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
+
+  # fg = getColor(plotargs[:foreground_color])
+  Gadfly.Theme(;
+      default_color = c,
+      default_point_size = ms,
+      discrete_highlight_color = c -> RGB(getColor(d[:markerstrokecolor])),
+      highlight_width = d[:markerstrokewidth] * Gadfly.px,
+      # get_extra_theme_args(d, :markerstrokestyle)...
+    )
+end
+
+function addGadflyContColorScale(plt::Plot{GadflyPackage}, c)
+  plt.plotargs[:colorbar] == :none && return
+  if !isa(c, ColorGradient)
+    c = colorscheme(:bluesreds)
+  end
+  push!(getGadflyContext(plt).scales, Gadfly.Scale.ContinuousColorScale(p -> RGB(getColorZ(c, p))))
+end
+
+function addGadflyMarker!(plt::Plot, numlayers::Int, d::Dict, plotargs::Dict, geoms...)
+  gfargs = vcat(geoms...,
+                getGadflyMarkerTheme(d, plotargs),
+                getMarkerGeom(d))
+  kwargs = Dict()
+
+  # handle continuous color scales for the markers
+  zcolor = d[:zcolor]
+  if zcolor != nothing && typeof(zcolor) <: AVec
+    kwargs[:color] = zcolor
+    addGadflyContColorScale(plt, d[:markercolor])
+    # if !isa(d[:markercolor], ColorGradient)
+    #   d[:markercolor] = colorscheme(:bluesreds)
+    # end
+    # push!(getGadflyContext(plt).scales, Gadfly.Scale.ContinuousColorScale(p -> RGB(getColorZ(d[:markercolor], p))))
+  end
+
+  Gadfly.layer(gfargs...; x = d[:x], y = d[:y], order=numlayers, kwargs...)
+end
+
+
+# ---------------------------------------------------------------------------
+
+function addToGadflyLegend(plt::Plot, d::Dict)
+
+  # add the legend?
+  if plt.plotargs[: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::Dict)
+
+  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...))
+
+    # don't add a regression for markers too
+    smooth = Any[]
+  end
+
+  # special handling for ohlc and scatter
+  lt = d[:linetype]
+  if lt == :ohlc
+    error("Haven't re-implemented after refactoring")
+  elseif lt in (:heatmap, :hexbin) && (isa(d[:linecolor], ColorGradient) || isa(d[:linecolor], ColorFunction))
+    push!(gplt.scales, Gadfly.Scale.ContinuousColorScale(p -> RGB(getColorZ(d[:linecolor], p))))
+  elseif lt == :scatter && d[:markershape] == :none
+    d[:markershape] = :ellipse
+  end
+
+  # markers
+  if d[:markershape] != :none
+    prepend!(layers, addGadflyMarker!(plt, length(gplt.layers), d, plt.plotargs, smooth...))
+  end
+
+  lt in (:heatmap, :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
+  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 = ticks[1], 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::Dict, 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
+    scale == :log2 && return isx ? Gadfly.Scale.x_log2 : Gadfly.Scale.y_log2, hasScaleKey
+    scale == :log10 && return isx ? Gadfly.Scale.x_log10 : Gadfly.Scale.y_log10, hasScaleKey
+    scale == :asinh && return isx ? Gadfly.Scale.x_asinh : Gadfly.Scale.y_asinh, hasScaleKey
+    scale == :sqrt && return isx ? Gadfly.Scale.x_sqrt : Gadfly.Scale.y_sqrt, hasScaleKey
+  end
+  isx ? Gadfly.Scale.x_continuous : Gadfly.Scale.y_continuous, hasScaleKey
+end
+
+
+function addGadflyLimitsScale(gplt, d::Dict, isx::Bool)
+
+  # get the correct scale function
+  gfunc, hasScaleKey = 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)
+  # lims == :auto && return
+  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
+end
+
+function updateGadflyAxisFlips(gplt, d::Dict, xlims, ylims)
+  if isa(gplt.coord, Gadfly.Coord.Cartesian)
+    gplt.coord = Gadfly.Coord.cartesian(
+        gplt.coord.xvars,
+        gplt.coord.yvars;
+        xmin = xlims == nothing ? gplt.coord.xmin : minimum(xlims),
+        xmax = xlims == nothing ? gplt.coord.xmax : maximum(xlims),
+        ymin = ylims == nothing ? gplt.coord.ymin : minimum(ylims),
+        ymax = ylims == nothing ? gplt.coord.ymax : 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::Dict)
+  gplt = getGadflyContext(plt)
+  haskey(d, :title) && findGuideAndSet(gplt, Gadfly.Guide.title, string(d[:title]))
+  haskey(d, :xlabel) && findGuideAndSet(gplt, Gadfly.Guide.xlabel, string(d[:xlabel]))
+  haskey(d, :ylabel) && findGuideAndSet(gplt, Gadfly.Guide.ylabel, string(d[:ylabel]))
+
+  xlims = addGadflyLimitsScale(gplt, d, true)
+  ylims = 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
+  # haskey(d, :yticks) && addGadflyTicksGuide(gplt, d[:yticks], false)
+
+  updateGadflyAxisFlips(gplt, d, xlims, ylims)
+end
+
+function updateGadflyPlotTheme(plt::Plot, d::Dict)
+  kwargs = Dict()
+
+  # # get the full plotargs, overriding any new settings
+  # # TODO: should this be part of the main `plot` command in plot.jl???
+  # d = merge!(plt.plotargs, d)
+
+  # # hide the legend?
+  # if !get(d, :legend, true)
+  #   kwargs[:key_position] = :none
+  # end
+  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] = getColor(d[:background_color])
+  end
+
+  # fonts
+  tfont, gfont, lfont = d[:tickfont], d[:guidefont], d[:legendfont]
+
+  fg = getColor(d[:foreground_color])
+  getGadflyContext(plt).theme = Gadfly.Theme(;
+          background_color = getColor(d[:background_color]),
+          minor_label_color = fg,
+          minor_label_font = tfont.family,
+          minor_label_font_size = tfont.pointsize * Gadfly.pt,
+          major_label_color = fg,
+          major_label_font = gfont.family,
+          major_label_font_size = gfont.pointsize * Gadfly.pt,
+          key_title_color = fg,
+          key_title_font = gfont.family,
+          key_title_font_size = gfont.pointsize * Gadfly.pt,
+          key_label_color = fg,
+          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{GadflyPackage}, 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::GadflyPackage; kw...)
+  d = Dict(kw)
+  gplt = createGadflyPlotObject(d)
+  Plot(gplt, pkg, 0, d, Dict[])
+end
+
+
+# plot one data series
+function _add_series(::GadflyPackage, plt::Plot; kw...)
+  
+  # first clear out the temporary layer
+  gplt = getGadflyContext(plt)
+  if gplt.layers[1].geom.tag == :remove
+    gplt.layers = gplt.layers[2:end]
+  end
+
+  d = Dict(kw)
+  addGadflySeries!(plt, d)
+  push!(plt.seriesargs, d)
+  plt
+end
+
+
+
+function _update_plot(plt::Plot{GadflyPackage}, d::Dict)
+  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 Base.getindex(plt::Plot{GadflyPackage}, i::Integer)
+  mapping = getGadflyMappings(plt, i)[1]
+  mapping[:x], mapping[:y]
+end
+
+function Base.setindex!(plt::Plot{GadflyPackage}, xy::Tuple, 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{GadflyPackage}, isbefore::Bool)
+  isbefore && return false # wait until after plotting to create the subplots
+  subplt.o = nothing
+  true
+end
+
+
+function _remove_axis(plt::Plot{GadflyPackage}, 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{GadflyPackage}, isx::Bool)
+  for l in getGadflyContext(plt).layers
+    _expand_limits(lims, l.mapping[isx ? :x : :y])
+  end
+end
+
+
+# ----------------------------------------------------------------
+
+
+getGadflyContext(plt::Plot{GadflyPackage}) = plt.o
+getGadflyContext(subplt::Subplot{GadflyPackage}) = 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.plotargs[:size]...)
+setGadflyDisplaySize(subplt::Subplot) = setGadflyDisplaySize(getplotargs(subplt, 1)[:size]...)
+# -------------------------------------------------------------------------
+
+
+function dowritemime{P<:Union{GadflyPackage,ImmersePackage}}(io::IO, func, plt::PlottingObject{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{GadflyPackage,ImmersePackage}}(io::IO, ::$mime, plt::PlottingObject{P})
+    func = getGadflyWriteFunc($mime())
+    dowritemime(io, func, plt)
+  end
+end
+
+
+
+function Base.display(::PlotsDisplay, plt::Plot{GadflyPackage})
+  setGadflyDisplaySize(plt.plotargs[:size]...)
+  display(plt.o)
+end
+
+
+
+function Base.display(::PlotsDisplay, subplt::Subplot{GadflyPackage})
+  setGadflyDisplaySize(getplotargs(subplt,1)[:size]...)
+  ctx = buildGadflySubplotContext(subplt)
+
+
+  # taken from Gadfly since I couldn't figure out how to do it directly
+
+  filename = string(Gadfly.tempname(), ".html")
+  output = open(filename, "w")
+
+  plot_output = IOBuffer()
+  Gadfly.draw(Gadfly.SVGJS(plot_output, Compose.default_graphic_width,
+             Compose.default_graphic_height, false), ctx)
+  plotsvg = takebuf_string(plot_output)
+
+  write(output,
+      """
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <title>Gadfly Plot</title>
+          <meta charset="utf-8">
+        </head>
+          <body>
+          <script charset="utf-8">
+              $(readall(Compose.snapsvgjs))
+          </script>
+          <script charset="utf-8">
+              $(readall(Gadfly.gadflyjs))
+          </script>
+          $(plotsvg)
+        </body>
+      </html>
+      """)
+  close(output)
+  Gadfly.open_file(filename)
+end

src/backends/gadfly_shapes.jl

@@ -0,0 +1,89 @@
+
+
+# Geometry which displays arbitrary shapes at given (x, y) positions.
+immutable ShapeGeometry <: Gadfly.GeometryElement
+    vertices::AbstractVector{@compat(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(sv.vertices)
+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 = @compat(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 geom.vertices]
+  end
+  Gadfly.polygon(polys, geom.tag)
+end
+
+
+# ---------------------------------------------------------------------------------------------
+