travis fix

Switch blue and violet in rainbow colour palette.

NEWS.md

@@ -7,7 +7,78 @@
 
 ---
 
-## 0.7 (current master/dev)
+## 0.8 (current master/dev)
+
+#### 0.8.0
+
+- added dependency on PlotUtils
+- BREAKING: removed DataFrames support (now in StatPlots.jl)
+- BREAKING: removed boxplot/violin/density recipes (now in StatPlots.jl)
+- GR:
+    - inline iterm2 support
+    - trisurface support
+    - heatmap fix
+- PyPlot:
+    - ijulia display fix
+- GLVisualize:
+    - first try with shapes
+- iter_segments improvements
+- bar_width support
+- horizontal bars
+- improve tick display
+- better shape handling in pyplot, plotly
+- improved padding calcs
+- internal reorg of _plots method, add pipeline.jl
+
+---
+
+## 0.7
+
+#### 0.7.5
+
+- GR: LaTeX support
+- Changed docs url to juliaplots.github.io
+- added `contourf` seriestype
+- allow `plt[1]` to return first Subplot
+- allow `sp[1]` to return the first Series of the Subplot
+- `series[k]` now passes through to `series.d[k]`
+- allow calling `plot!(sp, ...)` to update a target Subplot
+- PyPlot: zorder fix
+- new DataFrames logic/recipe: more flexible/robust and allow Symbols for:
+	- `(:fillrange, :line_z, :marker_z, :markersize, :ribbon, :weights, :xerror, :yerror)`
+- new `display_type` and `extra_kwargs` plot attributes
+- surface fix
+
+#### 0.7.4
+
+- added snooped precompiles, but left commented out
+- GR fixes: markersize, shapes, legends
+- fixes to recipes
+- turned on Appveyor
+
+#### 0.7.3
+
+- rebuild violin and boxplot recipes
+- "plot recipes"
+- `cgrad` method for easy color gradient creation
+- improvements to inset subplots
+- Segments and iter_segments for NaN-separated vectors
+- `bar` recipe now creates a `shape` series
+- writemime fix for Interact.jl
+- `link = :square` option
+- !!! set `shape` attributes with line/fill, NOT marker/markerstroke !!!
+- basic DPI support
+- moved chorddiagram to PlotRecipes
+- GR:
+	- use temp files for img output
+	- basic support for marker strokes and other marker fixes
+- PyPlot:
+	- Switch to recipes for bar, histogram, histogram2d
+- GLVisualize
+	- subplots
+	- path/scatter and path3d/scatter3d
+	- initial drawing of axes
+- many smaller fixes and improvements
 
 #### 0.7.2
 
@@ -55,7 +126,7 @@
 
 #### 0.7.0
 
-- Check out [the summary](http://plots.readthedocs.io/en/latest/plots_v0.7/)
+- Check out [the summary](http://juliaplots.github.io/plots_v0.7/)
 - Revamped and simplified internals
 - [Recipes, recipes, recipes](https://github.com/JuliaPlots/RecipesBase.jl/issues/6)
 - [Layouts and Subplots](https://github.com/tbreloff/Plots.jl/issues/60)
@@ -187,7 +258,7 @@
 - Integration with [PlotlyJS.jl](https://github.com/spencerlyon2/PlotlyJS.jl) for using Plotly inside a Blink window @spencerlyon2
 - The Plotly backend has been split into my built-in version (`plotly()`) and @spencerlyon2's backend (`plotlyjs()`)
 - Revamped backend setup code for easily adding new backends
-- New docs (WIP) at http://plots.readthedocs.org/
+- New docs (WIP) at http://juliaplots.github.io/
 - Overhaul to `:legend` keyword (see https://github.com/tbreloff/Plots.jl/issues/135)
 - New dependency on Requires, allows auto-loading of DataFrames support
 - Support for plotting lists of Tuples and FixedSizeArrays

README.md

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

REQUIRE

@@ -1,7 +1,7 @@
 julia 0.4
 
 RecipesBase
-Colors
+PlotUtils
 Reexport
 Compat
 FixedSizeArrays

appveyor.yml

@@ -1,14 +1,11 @@
 environment:
   matrix:
-  - JULIAVERSION: "julialang/bin/winnt/x86/0.3/julia-0.3-latest-win32.exe"
-  - JULIAVERSION: "julialang/bin/winnt/x64/0.3/julia-0.3-latest-win64.exe"
-  - JULIAVERSION: "julianightlies/bin/winnt/x86/julia-latest-win32.exe"
-  - JULIAVERSION: "julianightlies/bin/winnt/x64/julia-latest-win64.exe"
-
-branches:
-  only:
-    - master
-    - /release-.*/
+# Releases
+  - JULIAVERSION: "stable/win32"
+  - JULIAVERSION: "stable/win64"
+# Nightlies
+  - JULIAVERSION: "download/win32"
+  - JULIAVERSION: "download/win64"
 
 notifications:
   - provider: Email
@@ -18,17 +15,15 @@ notifications:
 
 install:
 # Download most recent Julia Windows binary
-  - ps: (new-object net.webclient).DownloadFile(
-        $("http://s3.amazonaws.com/"+$env:JULIAVERSION),
-        "C:\projects\julia-binary.exe")
+  - ps: (new-object net.webclient).DownloadFile($("http://status.julialang.org/"+$env:JULIAVERSION), "C:\projects\julia-binary.exe")
 # Run installer silently, output to C:\projects\julia
   - C:\projects\julia-binary.exe /S /D=C:\projects\julia
 
 build_script:
 # Need to convert from shallow to complete for Pkg.clone to work
   - IF EXIST .git\shallow (git fetch --unshallow)
-  - C:\projects\julia\bin\julia -e "versioninfo();
-      Pkg.clone(pwd(), \"Plots\"); Pkg.build(\"Plots\")"
+  - C:\projects\julia\bin\julia -e "versioninfo(); Pkg.clone(pwd(), \"Plots\"); Pkg.build(\"Plots\")"
 
 test_script:
-  - C:\projects\julia\bin\julia --check-bounds=yes -e "Pkg.test(\"Plots\")"
+  # - C:\projects\julia\bin\julia -e "Pkg.test(\"Plots\")"
+  - C:\projects\julia\bin\julia -e "include(Pkg.dir(\"Plots\", \"test\", \"travis_commands.jl\"))"

src/Plots.jl

@@ -1,15 +1,16 @@
 
- __precompile__()
+__precompile__()
 
 module Plots
 
 using Compat
 using Reexport
-@reexport using Colors
+# @reexport using Colors
 # using Requires
 using FixedSizeArrays
 @reexport using RecipesBase
 using Base.Meta
+@reexport using PlotUtils
 
 export
     AbstractPlot,
@@ -78,16 +79,17 @@ export
     Surface,
     OHLC,
     arrow,
+    Segments,
 
-    colorscheme,
-    ColorScheme,
-    ColorGradient,
-    ColorVector,
-    ColorWrapper,
-    ColorFunction,
-    ColorZFunction,
-    getColor,
-    getColorZ,
+    # colorscheme,
+    # ColorScheme,
+    # ColorGradient,
+    # ColorVector,
+    # ColorWrapper,
+    # ColorFunction,
+    # ColorZFunction,
+    # getColor,
+    # getColorZ,
 
     debugplots,
 
@@ -103,10 +105,7 @@ export
     @animate,
     @gif,
 
-    PlotRecipe,
     spy,
-    arcdiagram,
-    chorddiagram,
 
     test_examples,
     iter_segments,
@@ -133,15 +132,14 @@ export BBox, BoundingBox, mm, cm, inch, pt, px, pct, w, h
 
 include("types.jl")
 include("utils.jl")
-include("colors.jl")
 include("components.jl")
 include("axes.jl")
 include("backends.jl")
 include("args.jl")
 include("themes.jl")
 include("plot.jl")
-include("series_args.jl")
-include("series_new.jl")
+include("pipeline.jl")
+include("series.jl")
 include("layouts.jl")
 include("subplots.jl")
 include("recipes.jl")
@@ -176,6 +174,7 @@ end
 @shorthands vline
 @shorthands ohlc
 @shorthands contour
+@shorthands contourf
 @shorthands contour3d
 @shorthands surface
 @shorthands wireframe
@@ -255,4 +254,11 @@ end
 
 # ---------------------------------------------------------
 
+# if VERSION >= v"0.4.0-dev+5512"
+#     include("precompile.jl")
+#     _precompile_()
+# end
+
+# ---------------------------------------------------------
+
 end # module

src/animation.jl

@@ -24,7 +24,7 @@ immutable AnimatedGif
   filename::Compat.ASCIIString
 end
 
-function gif(anim::Animation, fn = tempname()*".gif"; fps::Integer = 20)
+function gif(anim::Animation, fn = (isijulia() ? "tmp.gif" : tempname()*".gif"); fps::Integer = 20)
   fn = abspath(fn)
 
   try
@@ -35,8 +35,8 @@ function gif(anim::Animation, fn = tempname()*".gif"; fps::Integer = 20)
     if isfile(file) && !haskey(ENV, "MAGICK_CONFIGURE_PATH")
         include(file)
     end
-    prefix = get(ENV, "MAGICK_CONFIGURE_PATH", "")
-    run(`$(joinpath(prefix, "convert")) -delay $speed -loop 0 $(joinpath(anim.dir, "*.png")) -alpha off $fn`)
+    # prefix = get(ENV, "MAGICK_CONFIGURE_PATH", "")
+    run(`convert -delay $speed -loop 0 $(joinpath(anim.dir, "*.png")) -alpha off $fn`)
 
   catch err
     warn("""Tried to create gif using convert (ImageMagick), but got error: $err
@@ -56,7 +56,7 @@ 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())>\" />")
+    write(io, "<img src=\"$(relpath(agif.filename))?$(rand())>\" />")
 end
 
 

src/arg_desc.jl

@@ -62,6 +62,9 @@ const _arg_desc = KW(
 :overwrite_figure         => "Bool.  Should we reuse the same GUI window/figure when plotting (true) or open a new one (false).",
 :html_output_format       => "Symbol.  When writing html output, what is the format?  `:png` and `:svg` are currently supported.",
 :inset_subplots 		  => "nothing or vector of 2-tuple (parent,bbox).  optionally pass a vector of (parent,bbox) tuples which are the parent layout and the relative bounding box of inset subplots",
+:dpi 					  => "Number.  Dots Per Inch of output figures",
+:display_type 			  => "Symbol (`:auto`, `:gui`, or `:inline`).  When supported, `display` will either open a GUI window or plot inline.",
+:extra_kwargs 			  => "KW (Dict{Symbol,Any}).  Pass a map of extra keyword args which may be specific to a backend.",
 
 # subplot args
 :title                    => "String. Subplot title.",

src/args.jl

@@ -1,6 +1,6 @@
 
 
-const _keyAliases = KW()
+const _keyAliases = Dict{Symbol,Symbol}()
 
 function add_aliases(sym::Symbol, aliases::Symbol...)
     for alias in aliases
@@ -11,7 +11,7 @@ function add_aliases(sym::Symbol, aliases::Symbol...)
     end
 end
 
-function add_non_underscore_aliases!(aliases::KW)
+function add_non_underscore_aliases!(aliases::Dict{Symbol,Symbol})
     for (k,v) in aliases
         s = string(k)
         if '_' in s
@@ -24,7 +24,7 @@ end
 # ------------------------------------------------------------
 
 const _allAxes = [:auto, :left, :right]
-const _axesAliases = KW(
+const _axesAliases = Dict{Symbol,Symbol}(
     :a => :auto,
     :l => :left,
     :r => :right
@@ -39,7 +39,7 @@ const _allTypes = vcat([
     :contour, :pie, :shape, :image
 ], _3dTypes)
 
-@compat const _typeAliases = KW(
+@compat const _typeAliases = Dict{Symbol,Symbol}(
     :n             => :none,
     :no            => :none,
     :l             => :line,
@@ -79,11 +79,11 @@ add_non_underscore_aliases!(_typeAliases)
 
 like_histogram(seriestype::Symbol) = seriestype in (:histogram, :density)
 like_line(seriestype::Symbol)      = seriestype in (:line, :path, :steppre, :steppost)
-like_surface(seriestype::Symbol)   = seriestype in (:contour, :contour3d, :heatmap, :surface, :wireframe, :image)
+like_surface(seriestype::Symbol)   = seriestype in (:contour, :contourf, :contour3d, :heatmap, :surface, :wireframe, :image)
 
 is3d(seriestype::Symbol) = seriestype in _3dTypes
 is3d(series::Series) = is3d(series.d)
-is3d(d::KW) = trueOrAllTrue(is3d, d[:seriestype])
+is3d(d::KW) = trueOrAllTrue(is3d, Symbol(d[:seriestype]))
 
 is3d(sp::Subplot) = string(sp.attr[:projection]) == "3d"
 ispolar(sp::Subplot) = string(sp.attr[:projection]) == "polar"
@@ -92,7 +92,7 @@ ispolar(series::Series) = ispolar(series.d[:subplot])
 # ------------------------------------------------------------
 
 const _allStyles = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
-@compat const _styleAliases = KW(
+@compat const _styleAliases = Dict{Symbol,Symbol}(
     :a    => :auto,
     :s    => :solid,
     :d    => :dash,
@@ -101,7 +101,7 @@ const _allStyles = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
 )
 
 const _allMarkers = vcat(:none, :auto, _shape_keys) #sort(collect(keys(_shapes))))
-@compat const _markerAliases = KW(
+@compat const _markerAliases = Dict{Symbol,Symbol}(
     :n            => :none,
     :no           => :none,
     :a            => :auto,
@@ -143,7 +143,7 @@ const _allMarkers = vcat(:none, :auto, _shape_keys) #sort(collect(keys(_shapes))
 )
 
 const _allScales = [:identity, :ln, :log2, :log10, :asinh, :sqrt]
-@compat const _scaleAliases = KW(
+@compat const _scaleAliases = Dict{Symbol,Symbol}(
     :none => :identity,
     :log  => :log10,
 )
@@ -216,6 +216,9 @@ const _plot_defaults = KW(
     :html_output_format          => :auto,
     :inset_subplots              => nothing,   # optionally pass a vector of (parent,bbox) tuples which are
                                                # the parent layout and the relative bounding box of inset subplots
+    :dpi                         => DPI,        # dots per inch for images, etc
+    :display_type                => :auto,
+    :extra_kwargs                => KW(),
 )
 
 
@@ -239,7 +242,7 @@ const _subplot_defaults = KW(
     :annotations              => [],                # annotation tuples... list of (x,y,annotation)
     :projection               => :none,             # can also be :polar or :3d
     :aspect_ratio             => :none,             # choose from :none or :equal
-    :margin                   => 2mm,
+    :margin                   => 1mm,
     :left_margin              => :match,
     :top_margin               => :match,
     :right_margin             => :match,
@@ -327,7 +330,7 @@ autopick(notarr, idx::Integer) = notarr
 autopick_ignore_none_auto(arr::AVec, idx::Integer) = autopick(setdiff(arr, [:none, :auto]), idx)
 autopick_ignore_none_auto(notarr, idx::Integer) = notarr
 
-function aliasesAndAutopick(d::KW, sym::Symbol, aliases::KW, options::AVec, plotIndex::Int)
+function aliasesAndAutopick(d::KW, sym::Symbol, aliases::Dict{Symbol,Symbol}, options::AVec, plotIndex::Int)
     if d[sym] == :auto
         d[sym] = autopick_ignore_none_auto(options, plotIndex)
     elseif haskey(aliases, d[sym])
@@ -335,7 +338,7 @@ function aliasesAndAutopick(d::KW, sym::Symbol, aliases::KW, options::AVec, plot
     end
 end
 
-function aliases(aliasMap::KW, val)
+function aliases(aliasMap::Dict{Symbol,Symbol}, val)
     sortedkeys(filter((k,v)-> v==val, aliasMap))
 end
 
@@ -432,6 +435,7 @@ add_aliases(:title_location, :title_loc, :titleloc, :title_position, :title_pos,
 add_aliases(:series_annotations, :series_ann, :seriesann, :series_anns, :seriesanns, :series_annotation)
 add_aliases(:html_output_format, :format, :fmt, :html_format)
 add_aliases(:orientation, :direction, :dir)
+add_aliases(:inset_subplots, :inset, :floating)
 
 
 # add all pluralized forms to the _keyAliases dict
@@ -494,7 +498,8 @@ function handleColors!(d::KW, arg, csym::Symbol)
         if arg == :auto
             d[csym] = :auto
         else
-            c = colorscheme(arg)
+            # c = colorscheme(arg)
+            c = plot_color(arg)
             d[csym] = c
         end
         return true
@@ -515,13 +520,13 @@ function processLineArg(d::KW, arg)
 
     elseif typeof(arg) <: Stroke
         arg.width == nothing || (d[:linewidth] = arg.width)
-        arg.color == nothing || (d[:linecolor] = arg.color == :auto ? :auto : colorscheme(arg.color))
+        arg.color == nothing || (d[:linecolor] = arg.color == :auto ? :auto : plot_color(arg.color))
         arg.alpha == nothing || (d[:linealpha] = arg.alpha)
         arg.style == nothing || (d[:linestyle] = arg.style)
 
     elseif typeof(arg) <: Brush
         arg.size  == nothing || (d[:fillrange] = arg.size)
-        arg.color == nothing || (d[:fillcolor] = arg.color == :auto ? :auto : colorscheme(arg.color))
+        arg.color == nothing || (d[:fillcolor] = arg.color == :auto ? :auto : plot_color(arg.color))
         arg.alpha == nothing || (d[:fillalpha] = arg.alpha)
 
     elseif typeof(arg) <: Arrow || arg in (:arrow, :arrows)
@@ -554,13 +559,13 @@ function processMarkerArg(d::KW, arg)
 
     elseif typeof(arg) <: Stroke
         arg.width == nothing || (d[:markerstrokewidth] = arg.width)
-        arg.color == nothing || (d[:markerstrokecolor] = arg.color == :auto ? :auto : colorscheme(arg.color))
+        arg.color == nothing || (d[:markerstrokecolor] = arg.color == :auto ? :auto : plot_color(arg.color))
         arg.alpha == nothing || (d[:markerstrokealpha] = arg.alpha)
         arg.style == nothing || (d[:markerstrokestyle] = arg.style)
 
     elseif typeof(arg) <: Brush
         arg.size  == nothing || (d[:markersize]  = arg.size)
-        arg.color == nothing || (d[:markercolor] = arg.color == :auto ? :auto : colorscheme(arg.color))
+        arg.color == nothing || (d[:markercolor] = arg.color == :auto ? :auto : plot_color(arg.color))
         arg.alpha == nothing || (d[:markeralpha] = arg.alpha)
 
     # linealpha
@@ -580,14 +585,15 @@ end
 
 
 function processFillArg(d::KW, arg)
+    fr = get(d, :fillrange, 0)
     if typeof(arg) <: Brush
-        arg.size  == nothing || (d[:fillrange] = arg.size)
-        arg.color == nothing || (d[:fillcolor] = arg.color == :auto ? :auto : colorscheme(arg.color))
+        arg.size  == nothing || (fr = arg.size)
+        arg.color == nothing || (d[:fillcolor] = arg.color == :auto ? :auto : plot_color(arg.color))
         arg.alpha == nothing || (d[:fillalpha] = arg.alpha)
 
     # fillrange function
     elseif allFunctions(arg)
-        d[:fillrange] = arg
+        fr = arg
 
     # fillalpha
     elseif allAlphas(arg)
@@ -595,8 +601,10 @@ function processFillArg(d::KW, arg)
 
     elseif !handleColors!(d, arg, :fillcolor)
 
-        d[:fillrange] = arg
+        fr = arg
     end
+    d[:fillrange] = fr
+    return    
 end
 
 _replace_markershape(shape::Symbol) = get(_markerAliases, shape, shape)
@@ -683,21 +691,13 @@ function preprocessArgs!(d::KW)
         d[:colorbar] = convertLegendValue(d[:colorbar])
     end
 
-    # # handle subplot links
-    # if haskey(d, :link)
-    #     l = d[:link]
-    #     if isa(l, Bool)
-    #         d[:linkx] = l
-    #         d[:linky] = l
-    #     elseif isa(l, Function)
-    #         d[:linkx] = true
-    #         d[:linky] = true
-    #         d[:linkfunc] = l
-    #     else
-    #         warn("Unhandled/invalid link $l.  Should be a Bool or a function mapping (row,column) -> (linkx, linky), where linkx/y can be Bool or Void (nothing)")
-    #     end
-    #     delete!(d, :link)
-    # end
+    # warnings for moved recipes
+    st = get(d, :seriestype, :path)
+    if st in (:boxplot, :violin, :density) && !isdefined(Main, :StatPlots)
+        warn("seriestype $st has been moved to StatPlots.  To use: \`Pkg.add(\"StatPlots\"); using StatPlots\`")
+    end
+
+    return
 end
 
 # -----------------------------------------------------------------------------
@@ -824,9 +824,9 @@ slice_arg(v, idx) = v
 # given an argument key (k), we want to extract the argument value for this index.
 # matrices are sliced by column, otherwise we
 # if nothing is set (or container is empty), return the default or the existing value.
-function slice_arg!(d_in::KW, d_out::KW, k::Symbol, default_value, idx::Int = 1; new_key::Symbol = k, remove_pair::Bool = true)
-    v = get(d_in, k, get(d_out, new_key, default_value))
-    d_out[new_key] = if haskey(d_in, k) && typeof(v) <: AMat && !isempty(v)
+function slice_arg!(d_in::KW, d_out::KW, k::Symbol, default_value, idx::Int, remove_pair::Bool)
+    v = get(d_in, k, get(d_out, k, default_value))
+    d_out[k] = if haskey(d_in, k) && typeof(v) <: AMat && !isempty(v)
         slice_arg(v, idx)
     else
         v
@@ -834,6 +834,7 @@ function slice_arg!(d_in::KW, d_out::KW, k::Symbol, default_value, idx::Int = 1;
     if remove_pair
         delete!(d_in, k)
     end
+    return
 end
 
 # -----------------------------------------------------------------------------
@@ -845,7 +846,7 @@ end
 #     d[k] = if v == :match
 #         match_color
 #     elseif v == nothing
-#         colorscheme(RGBA(0,0,0,0))
+#         plot_color(RGBA(0,0,0,0))
 #     else
 #         v
 #     end
@@ -854,10 +855,13 @@ end
 function color_or_nothing!(d::KW, k::Symbol)
     v = d[k]
     d[k] = if v == nothing || v == false
-        colorscheme(RGBA(0,0,0,0))
+        RGBA{Float64}(0,0,0,0)
+    elseif v != :match
+        plot_color(v)
     else
         v
     end
+    return
 end
 
 # -----------------------------------------------------------------------------
@@ -926,36 +930,43 @@ function Base.getindex(axis::Axis, k::Symbol)
     end
 end
 
+function Base.getindex(series::Series, k::Symbol)
+    series.d[k]
+end
+
+Base.setindex!(plt::Plot, v, k::Symbol)      = (plt.attr[k] = v)
+Base.setindex!(sp::Subplot, v, k::Symbol)    = (sp.attr[k] = v)
+Base.setindex!(axis::Axis, v, k::Symbol)     = (axis.d[k] = v)
+Base.setindex!(series::Series, v, k::Symbol) = (series.d[k] = v)
+
+Base.get(plt::Plot, k::Symbol, v)      = get(plt.attr, k, v)
+Base.get(sp::Subplot, k::Symbol, v)    = get(sp.attr, k, v)
+Base.get(axis::Axis, k::Symbol, v)     = get(axis.d, k, v)
+Base.get(series::Series, k::Symbol, v) = get(series.d, k, v)
+
+
 # -----------------------------------------------------------------------------
 
 # update attr from an input dictionary
 function _update_plot_args(plt::Plot, d_in::KW)
     for (k,v) in _plot_defaults
-        slice_arg!(d_in, plt.attr, k, v)
+        slice_arg!(d_in, plt.attr, k, v, 1, true)
     end
 
     # handle colors
-    bg = convertColor(plt.attr[:background_color])
+    bg = plot_color(plt.attr[:background_color])
     fg = plt.attr[:foreground_color]
     if fg == :auto
         fg = isdark(bg) ? colorant"white" : colorant"black"
     end
     plt.attr[:background_color] = bg
-    plt.attr[:foreground_color] = convertColor(fg)
-    # color_or_match!(plt.attr, :background_color_outside, bg)
+    plt.attr[:foreground_color] = plot_color(fg)
     color_or_nothing!(plt.attr, :background_color_outside)
 end
 
+# -----------------------------------------------------------------------------
 
-# update a subplots args and axes
-function _update_subplot_args(plt::Plot, sp::Subplot, d_in::KW, subplot_index::Integer; remove_pair = true)
-    anns = pop!(sp.attr, :annotations, [])
-
-    # grab those args which apply to this subplot
-    for (k,v) in _subplot_defaults
-        slice_arg!(d_in, sp.attr, k, v, subplot_index, remove_pair = remove_pair)
-    end
-
+function _update_subplot_periphery(sp::Subplot, anns::AVec)
     # extend annotations
     sp.attr[:annotations] = vcat(anns, sp[:annotations])
 
@@ -965,11 +976,13 @@ function _update_subplot_args(plt::Plot, sp::Subplot, d_in::KW, subplot_index::I
     if sp.attr[:colorbar] == :legend
         sp.attr[:colorbar] = sp.attr[:legend]
     end
+    return
+end
 
+function _update_subplot_colors(sp::Subplot)
     # background colors
-    # bg = color_or_match!(sp.attr, :background_color_subplot, plt.attr[:background_color])
     color_or_nothing!(sp.attr, :background_color_subplot)
-    bg = convertColor(sp[:background_color_subplot])
+    bg = plot_color(sp[:background_color_subplot])
     sp.attr[:color_palette] = get_color_palette(sp.attr[:color_palette], bg, 30)
     color_or_nothing!(sp.attr, :background_color_legend)
     color_or_nothing!(sp.attr, :background_color_inside)
@@ -979,64 +992,192 @@ function _update_subplot_args(plt::Plot, sp::Subplot, d_in::KW, subplot_index::I
     color_or_nothing!(sp.attr, :foreground_color_legend)
     color_or_nothing!(sp.attr, :foreground_color_grid)
     color_or_nothing!(sp.attr, :foreground_color_title)
+    return
+end
 
-    # for k in (:left_margin, :top_margin, :right_margin, :bottom_margin)
-    #     if sp.attr[k] == :match
-    #         sp.attr[k] = sp.attr[:margin]
-    #     end
-    # end
+function _update_axis(plt::Plot, sp::Subplot, d_in::KW, letter::Symbol, subplot_index::Int)
+    # get (maybe initialize) the axis
+    axis = get_axis(sp, letter)
+
+    _update_axis(axis, d_in, letter, subplot_index)
+
+    # convert a bool into auto or nothing
+    if isa(axis[:ticks], Bool)
+        axis[:ticks] = axis[:ticks] ? :auto : nothing
+    end
+
+    _update_axis_colors(axis)
+    _update_axis_links(plt, axis, letter)
+    return
+end
+
+function _update_axis(axis::Axis, d_in::KW, letter::Symbol, subplot_index::Int)
+    # grab magic args (for example `xaxis = (:flip, :log)`)
+    args = wraptuple(get(d_in, Symbol(letter, :axis), ()))
+
+    # build the KW of arguments from the letter version (i.e. xticks --> ticks)
+    kw = KW()
+    for (k,v) in _axis_defaults
+        # first get the args without the letter: `tickfont = font(10)`
+        # note: we don't pop because we want this to apply to all axes! (delete after all have finished)
+        if haskey(d_in, k)
+            kw[k] = slice_arg(d_in[k], subplot_index)
+        end
+
+        # then get those args that were passed with a leading letter: `xlabel = "X"`
+        lk = Symbol(letter, k)
+        if haskey(d_in, lk)
+            kw[k] = slice_arg(d_in[lk], subplot_index)
+        end
+    end
+
+    # update the axis
+    update!(axis, args...; kw...)
+    return
+end
+
+function _update_axis_colors(axis::Axis)
+    # # update the axis colors
+    color_or_nothing!(axis.d, :foreground_color_axis)
+    color_or_nothing!(axis.d, :foreground_color_border)
+    color_or_nothing!(axis.d, :foreground_color_guide)
+    color_or_nothing!(axis.d, :foreground_color_text)
+    return
+end
+
+function _update_axis_links(plt::Plot, axis::Axis, letter::Symbol)
+    # handle linking here.  if we're passed a list of
+    # other subplots to link to, link them together
+    link = axis[:link]
+    if !isempty(link)
+        for other_sp in link
+            other_sp = get_subplot(plt, other_sp)
+            link_axes!(axis, get_axis(other_sp, letter))
+        end
+        axis.d[:link] = []
+    end
+    return
+end
+
+# update a subplots args and axes
+function _update_subplot_args(plt::Plot, sp::Subplot, d_in::KW, subplot_index::Int, remove_pair::Bool)
+    anns = pop!(sp.attr, :annotations, [])
+
+    # grab those args which apply to this subplot
+    for (k,v) in _subplot_defaults
+        slice_arg!(d_in, sp.attr, k, v, subplot_index, remove_pair)
+    end
+
+    _update_subplot_periphery(sp, anns)
+    _update_subplot_colors(sp)
 
     for letter in (:x, :y, :z)
-        # get (maybe initialize) the axis
-        axis = get_axis(sp, letter)
-
-        # grab magic args (for example `xaxis = (:flip, :log)`)
-        args = wraptuple(get(d_in, Symbol(letter, :axis), ()))
-
-        # build the KW of arguments from the letter version (i.e. xticks --> ticks)
-        kw = KW()
-        for (k,v) in _axis_defaults
-            # first get the args without the letter: `tickfont = font(10)`
-            # note: we don't pop because we want this to apply to all axes! (delete after all have finished)
-            if haskey(d_in, k)
-                kw[k] = slice_arg(d_in[k], subplot_index)
-            end
-
-            # then get those args that were passed with a leading letter: `xlabel = "X"`
-            lk = Symbol(letter, k)
-            if haskey(d_in, lk)
-                kw[k] = slice_arg(d_in[lk], subplot_index)
-            end
-        end
-
-        # update the axis
-        update!(axis, args...; kw...)
-
-        # convert a bool into auto or nothing
-        if isa(axis[:ticks], Bool)
-            axis[:ticks] = axis[:ticks] ? :auto : nothing
-        end
-
-        # # update the axis colors
-        color_or_nothing!(axis.d, :foreground_color_axis)
-        color_or_nothing!(axis.d, :foreground_color_border)
-        color_or_nothing!(axis.d, :foreground_color_guide)
-        color_or_nothing!(axis.d, :foreground_color_text)
-
-        # handle linking here.  if we're passed a list of
-        # other subplots to link to, link them together
-        link = axis[:link]
-        if !isempty(link)
-            for other_sp in link
-                other_sp = get_subplot(plt, other_sp)
-                link_axes!(axis, get_axis(other_sp, letter))
-            end
-            axis.d[:link] = []
-        end
+        _update_axis(plt, sp, d_in, letter, subplot_index)
     end
 end
 
+# -----------------------------------------------------------------------------
 
 function has_black_border_for_default(st::Symbol)
-    like_histogram(st) || st in (:hexbin, :bar)
+    like_histogram(st) || st in (:hexbin, :bar, :shape)
 end
+
+
+# converts a symbol or string into a colorant (Colors.RGB), and assigns a color automatically
+function getSeriesRGBColor(c, α, sp::Subplot, n::Int)
+    if c == :auto
+        c = autopick(sp[:color_palette], n)
+    end
+    plot_color(c, α)
+end
+
+function ensure_gradient!(d::KW, csym::Symbol, asym::Symbol)
+    if !isa(d[csym], ColorGradient)
+        d[csym] = cgrad(alpha = d[asym])
+    end
+end
+
+function _replace_linewidth(d::KW)
+    # get a good default linewidth... 0 for surface and heatmaps
+    if get(d, :linewidth, :auto) == :auto
+        d[:linewidth] = (get(d, :seriestype, :path) in (:surface,:heatmap,:image) ? 0 : 1)
+    end
+end
+
+function _add_defaults!(d::KW, plt::Plot, sp::Subplot, commandIndex::Int)
+    pkg = plt.backend
+    globalIndex = d[:series_plotindex]
+
+    # add default values to our dictionary, being careful not to delete what we just added!
+    for (k,v) in _series_defaults
+        slice_arg!(d, d, k, v, commandIndex, false)
+    end
+
+    # this is how many series belong to this subplot
+    plotIndex = count(series -> series.d[:subplot] === sp && series.d[:primary], plt.series_list)
+    if get(d, :primary, true)
+        plotIndex += 1
+    end
+
+    aliasesAndAutopick(d, :linestyle, _styleAliases, supported_styles(pkg), plotIndex)
+    aliasesAndAutopick(d, :markershape, _markerAliases, supported_markers(pkg), plotIndex)
+
+    # update alphas
+    for asym in (:linealpha, :markeralpha, :fillalpha)
+        if d[asym] == nothing
+            d[asym] = d[:seriesalpha]
+        end
+    end
+    if d[:markerstrokealpha] == nothing
+        d[:markerstrokealpha] = d[:markeralpha]
+    end
+
+    # update series color
+    d[:seriescolor] = getSeriesRGBColor(d[:seriescolor], d[:seriesalpha], sp, plotIndex)
+
+    # update other colors
+    for s in (:line, :marker, :fill)
+        csym, asym = Symbol(s,:color), Symbol(s,:alpha)
+        d[csym] = if d[csym] == :match
+            plot_color(if has_black_border_for_default(d[:seriestype]) && s == :line
+                sp[:foreground_color_subplot]
+            else
+                d[:seriescolor]
+            end, d[asym])
+        else
+            getSeriesRGBColor(d[csym], d[asym], sp, plotIndex)
+        end
+    end
+
+    # update markerstrokecolor
+    d[:markerstrokecolor] = if d[:markerstrokecolor] == :match
+        plot_color(sp[:foreground_color_subplot], d[:markerstrokealpha])
+    else
+        getSeriesRGBColor(d[:markerstrokecolor], d[:markerstrokealpha], sp, plotIndex)
+    end
+
+    # if marker_z or line_z are set, ensure we have a gradient
+    if d[:marker_z] != nothing
+        ensure_gradient!(d, :markercolor, :markeralpha)
+    end
+    if d[:line_z] != nothing
+        ensure_gradient!(d, :linecolor, :linealpha)
+    end
+
+    # scatter plots don't have a line, but must have a shape
+    if d[:seriestype] in (:scatter, :scatter3d)
+        d[:linewidth] = 0
+        if d[:markershape] == :none
+            d[:markershape] = :circle
+        end
+    end
+
+    # set label
+    label = d[:label]
+    label = (label == "AUTO" ? "y$globalIndex" : label)
+    d[:label] = label
+
+    _replace_linewidth(d)
+    d
+end
+

src/axes.jl

@@ -38,7 +38,7 @@ function get_axis(sp::Subplot, letter::Symbol)
         sp.attr[axissym]
     else
         sp.attr[axissym] = Axis(sp, letter)
-    end
+    end::Axis
 end
 
 function process_axis_arg!(d::KW, arg, letter = "")
@@ -122,7 +122,14 @@ function get_ticks(axis::Axis)
     ticks = axis[:ticks]
     dvals = axis[:discrete_values]
     if !isempty(dvals) && ticks == :auto
-        axis[:continuous_values], dvals
+        cv, dv = axis[:continuous_values], dvals
+        # TODO: better/smarter cutoff values for sampling ticks
+        if length(cv) > 30
+            rng = Int[round(Int,i) for i in linspace(1, length(cv), 15)]
+            cv[rng], dv[rng]
+        else
+            cv, dv
+        end
     else
         ticks
     end
@@ -159,16 +166,18 @@ function expand_extrema!(sp::Subplot, d::KW)
     for letter in (:x, :y, :z)
         data = d[letter]
         axis = sp.attr[Symbol(letter, "axis")]
-        if eltype(data) <: Number
-            expand_extrema!(axis, data)
-        elseif isa(data, Surface) && eltype(data.surf) <: Number
+        if eltype(data) <: Number || (isa(data, Surface) && all(di -> isa(di, Number), data.surf))
+            if !(eltype(data) <: Number)
+                # huh... must have been a mis-typed surface? lets swap it out
+                data = d[letter] = Surface(Matrix{Float64}(data.surf))
+            end
             expand_extrema!(axis, data)
         elseif data != nothing
             # TODO: need more here... gotta track the discrete reference value
             #       as well as any coord offset (think of boxplot shape coords... they all
             #       correspond to the same x-value)
-            # @show letter,eltype(data),typeof(data)
             d[letter], d[Symbol(letter,"_discrete_indices")] = discrete_value!(axis, data)
+            expand_extrema!(axis, d[letter])
         end
     end
 

src/backends.jl

@@ -57,13 +57,26 @@ _before_layout_calcs(plt::Plot) = nothing
 title_padding(sp::Subplot) = sp[:title] == "" ? 0mm : sp[:titlefont].pointsize * pt
 guide_padding(axis::Axis) = axis[:guide] == "" ? 0mm : axis[:guidefont].pointsize * pt
 
+# TODO: this should account for both tick font and the size/length/rotation of tick labels
+function tick_padding(axis::Axis)
+    ptsz = axis[:tickfont].pointsize * pt
+    if axis[:ticks] in (nothing,false)
+        0mm
+    elseif axis[:letter] == :x
+        2mm + ptsz
+    else
+        8mm
+    end
+end
+
 # Set the (left, top, right, bottom) minimum padding around the plot area
 # to fit ticks, tick labels, guides, colorbars, etc.
 function _update_min_padding!(sp::Subplot)
-    leftpad   = 10mm + sp[:left_margin]   + guide_padding(sp[:yaxis])
-    toppad    =  2mm + sp[:top_margin]    + title_padding(sp)
-    rightpad  =  3mm + sp[:right_margin]
-    bottompad =  5mm + sp[:bottom_margin] + guide_padding(sp[:xaxis])
+    # TODO: something different when `is3d(sp) == true`
+    leftpad   = tick_padding(sp[:yaxis]) + sp[:left_margin]   + guide_padding(sp[:yaxis])
+    toppad    = sp[:top_margin]    + title_padding(sp)
+    rightpad  = sp[:right_margin]
+    bottompad = tick_padding(sp[:xaxis]) + sp[:bottom_margin] + guide_padding(sp[:xaxis])
     # @show (leftpad, toppad, rightpad, bottompad)
     sp.minpad = (leftpad, toppad, rightpad, bottompad)
 end

src/backends/glvisualize.jl

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

src/backends/gr.jl

@@ -28,6 +28,7 @@ supported_args(::GRBackend) = merge_with_base_supported([
     :aspect_ratio,
     :normalize, :weights,
     :inset_subplots,
+    :bar_width,
 ])
 supported_types(::GRBackend) = [
     :path, :scatter,
@@ -41,7 +42,6 @@ supported_scales(::GRBackend) = [:identity, :log10]
 is_subplot_supported(::GRBackend) = true
 
 
-
 function _initialize_backend(::GRBackend; kw...)
     @eval begin
         import GR
@@ -107,47 +107,18 @@ const gr_font_family = Dict(
 
 # --------------------------------------------------------------------------------------
 
-function gr_getcolorind(v, a =nothing)
-    c = getColor(v)
-    idx = convert(Int, GR.inqcolorfromrgb(c.r, c.g, c.b))
-    GR.settransparency(float(a==nothing ? alpha(c) : a))
-    idx
+function gr_getcolorind(c)
+    GR.settransparency(float(alpha(c)))
+    convert(Int, GR.inqcolorfromrgb(red(c), green(c), blue(c)))
 end
 
-gr_set_linecolor(c, a=nothing) = GR.setlinecolorind(gr_getcolorind(c, a))
-gr_set_fillcolor(c, a=nothing) = GR.setfillcolorind(gr_getcolorind(c, a))
-gr_set_markercolor(c, a=nothing) = GR.setmarkercolorind(gr_getcolorind(c, a))
-gr_set_textcolor(c, a=nothing) = GR.settextcolorind(gr_getcolorind(c, a))
+gr_set_linecolor(c)   = GR.setlinecolorind(gr_getcolorind(cycle(c,1)))
+gr_set_fillcolor(c)   = GR.setfillcolorind(gr_getcolorind(cycle(c,1)))
+gr_set_markercolor(c) = GR.setmarkercolorind(gr_getcolorind(cycle(c,1)))
+gr_set_textcolor(c)   = GR.settextcolorind(gr_getcolorind(cycle(c,1)))
 
 # --------------------------------------------------------------------------------------
 
-function gr_setmarkershape(d)
-    if d[:markershape] != :none
-        shape = d[:markershape]
-        if isa(shape, Shape)
-            d[:vertices] = vertices(shape)
-        else
-            GR.setmarkertype(gr_markertype[shape])
-            d[:vertices] = :none
-        end
-    end
-end
-
-function gr_polymarker(d, x, y)
-    if d[:vertices] != :none
-        vertices= d[:vertices]
-        dx = Float64[el[1] for el in vertices] * 0.03
-        dy = Float64[el[2] for el in vertices] * 0.03
-        GR.selntran(0)
-        for i = 1:length(x)
-            xn, yn = GR.wctondc(x[i], y[i])
-            GR.fillarea(xn + dx, yn + dy)
-        end
-        GR.selntran(1)
-    else
-        GR.polymarker(x, y)
-    end
-end
 
 # draw line segments, splitting x/y into contiguous/finite segments
 # note: this can be used for shapes by passing func `GR.fillarea`
@@ -185,6 +156,25 @@ function gr_polyline(x, y, func = GR.polyline)
     end
 end
 
+function gr_inqtext(x, y, s)
+    if length(s) >= 2 && s[1] == '$' && s[end] == '$'
+        GR.inqtextext(x, y, s[2:end-1])
+    elseif search(s, '\\') != 0 || search(s, '_') != 0 || search(s, '^') != 0
+        GR.inqtextext(x, y, s)
+    else
+        GR.inqtext(x, y, s)
+    end
+end
+
+function gr_text(x, y, s)
+    if length(s) >= 2 && s[1] == '$' && s[end] == '$'
+        GR.mathtex(x, y, s[2:end-1])
+    elseif search(s, '\\') != 0 || search(s, '_') != 0 || search(s, '^') != 0
+        GR.textext(x, y, s)
+    else
+        GR.text(x, y, s)
+    end
+end
 
 function gr_polaraxes(rmin, rmax)
     GR.savestate()
@@ -260,59 +250,77 @@ function normalize_zvals(zv::AVec)
     end
 end
 
+# ---------------------------------------------------------
 
-function gr_draw_markers(d::KW, x, y, msize, mz, c, a)
-    if length(x) > 0
-        mz == nothing && gr_set_markercolor(c, a)
-        
-        if typeof(msize) <: Number && mz == nothing
-            # draw the markers all the same
-            GR.setmarkersize(msize)
-            gr_polymarker(d, x, y)
-        else
-            # draw each marker differently
-            for i = 1:length(x)
-                if mz != nothing
-                    ci = round(Int, 1000 + mz[i] * 255)
-                    GR.setmarkercolorind(ci)
-                end
-                GR.setmarkersize(isa(msize, Number) ? msize : msize[mod1(i, length(msize))])
-                gr_polymarker(d, [x[i]], [y[i]])
+# draw ONE Shape
+function gr_draw_marker(xi, yi, msize, shape::Shape)
+    sx, sy = shape_coords(shape)
+    GR.selntran(0)
+    xi, yi = GR.wctondc(xi, yi)
+    GR.fillarea(xi + sx * 0.0015msize,
+                yi + sy * 0.0015msize)
+    GR.selntran(1)
+end
+
+# draw ONE symbol marker
+function gr_draw_marker(xi, yi, msize::Number, shape::Symbol)
+    GR.setmarkertype(gr_markertype[shape])
+    GR.setmarkersize(0.3msize)
+    GR.polymarker([xi], [yi])
+end
+
+
+# draw the markers, one at a time
+function gr_draw_markers(series::Series, x, y, msize, mz)
+    shape = series[:markershape]
+    if shape != :none
+        for i=1:length(x)
+            msi = cycle(msize, i)
+            cfunc = isa(shape, Shape) ? gr_set_fillcolor : gr_set_markercolor
+            cfuncind = isa(shape, Shape) ? GR.setfillcolorind : GR.setmarkercolorind
+
+            # draw a filled in shape, slightly bigger, to estimate a stroke
+            if series[:markerstrokewidth] > 0
+                cfunc(cycle(series[:markerstrokecolor], i)) #, series[:markerstrokealpha])
+                gr_draw_marker(x[i], y[i], msi + series[:markerstrokewidth], shape)
             end
+
+            # draw the shape
+            if mz == nothing
+                cfunc(cycle(series[:markercolor], i)) #, series[:markeralpha])
+            else
+                # pick a color from the pre-loaded gradient
+                ci = round(Int, 1000 + cycle(mz, i) * 255)
+                cfuncind(ci)
+                GR.settransparency(_gr_gradient_alpha[ci-999])
+            end
+            gr_draw_marker(x[i], y[i], msi, shape)
         end
     end
 end
 
 function gr_draw_markers(series::Series, x, y)
-    d = series.d
-    msize = 0.5 * d[:markersize]
-    mz = normalize_zvals(d[:marker_z])
-
-    # draw the marker
-    gr_setmarkershape(d)
+    isempty(x) && return
+    mz = normalize_zvals(series[:marker_z])
     GR.setfillintstyle(GR.INTSTYLE_SOLID)
-    gr_draw_markers(d, x, y, msize, mz, d[:markercolor], d[:markeralpha])
-
-    # # draw the stroke
-    # GR.setfillintstyle(GR.INTSTYLE_HOLLOW)
-    # gr_draw_markers(d, x, y, msize, mz, d[:markerstrokecolor], d[:markerstrokealpha])
-
+    gr_draw_markers(series, x, y, series[:markersize], mz)
     if mz != nothing
-        gr_colorbar(d[:subplot])
+        gr_colorbar(series[:subplot])
     end
 end
 
+# ---------------------------------------------------------
 
-function gr_set_line(w, style, c, a)
+function gr_set_line(w, style, c) #, a)
     GR.setlinetype(gr_linetype[style])
     GR.setlinewidth(w)
-    gr_set_linecolor(c, a)
+    gr_set_linecolor(c) #, a)
 end
 
 
 
-function gr_set_fill(c, a)
-    gr_set_fillcolor(c, a)
+function gr_set_fill(c) #, a)
+    gr_set_fillcolor(c) #, a)
     GR.setfillintstyle(GR.INTSTYLE_SOLID)
 end
 
@@ -395,13 +403,14 @@ gr_view_ydiff() = viewport_plotarea[4] - viewport_plotarea[3]
 
 # --------------------------------------------------------------------------------------
 
+const _gr_gradient_alpha = ones(256)
 
-function gr_set_gradient(c, a)
-    grad = isa(c, ColorGradient) ? c : default_gradient()
-    grad = ColorGradient(grad, alpha=a)
+function gr_set_gradient(c)
+    grad = isa(c, ColorGradient) ? c : cgrad()
     for (i,z) in enumerate(linspace(0, 1, 256))
-        c = getColorZ(grad, z)
+        c = grad[z]
         GR.setcolorrep(999+i, red(c), green(c), blue(c))
+        _gr_gradient_alpha[i] = alpha(c)
     end
     grad
 end
@@ -456,7 +465,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
     viewport_plotarea[:] = gr_viewport_from_bbox(plotarea(sp), w, h, viewport_canvas)
 
     # fill in the plot area background
-    bg = getColor(sp[:background_color_inside])
+    bg = plot_color(sp[:background_color_inside])
     gr_fill_viewport(viewport_plotarea, bg)
 
     # reduced from before... set some flags based on the series in this subplot
@@ -466,8 +475,8 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
     draw_axes = true
     # axes_2d = true
     for series in series_list(sp)
-        st = series.d[:seriestype]
-        if st in (:contour, :surface, :heatmap) || series.d[:marker_z] != nothing
+        st = series[:seriestype]
+        if st in (:contour, :surface, :heatmap) || series[:marker_z] != nothing
             cmap = true
         end
         if st == :pie
@@ -495,6 +504,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
     data_lims = gr_xy_axislims(sp)
     xmin, xmax, ymin, ymax = data_lims
     scale = 0
+    xtick, ytick = 1, 1
     if xmax > xmin && ymax > ymin
         # NOTE: for log axes, the major_x and major_y - if non-zero (omit labels) - control the minor grid lines (1 = draw 9 minor grid lines, 2 = no minor grid lines)
         # NOTE: for log axes, the x_tick and y_tick - if non-zero (omit axes) - only affect the output appearance (1 = nomal, 2 = scientiic notation)
@@ -580,14 +590,14 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
         gr_set_font(sp[:titlefont])
         GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_TOP)
         gr_set_textcolor(sp[:foreground_color_title])
-        GR.text(gr_view_xcenter(), viewport_subplot[4], sp[:title])
+        gr_text(gr_view_xcenter(), viewport_subplot[4], sp[:title])
     end
 
     if xaxis[:guide] != ""
         gr_set_font(xaxis[:guidefont])
         GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_BOTTOM)
         gr_set_textcolor(xaxis[:foreground_color_guide])
-        GR.text(gr_view_xcenter(), viewport_subplot[3], xaxis[:guide])
+        gr_text(gr_view_xcenter(), viewport_subplot[3], xaxis[:guide])
     end
 
     if yaxis[:guide] != ""
@@ -595,7 +605,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
         GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_TOP)
         GR.setcharup(-1, 0)
         gr_set_textcolor(yaxis[:foreground_color_guide])
-        GR.text(viewport_subplot[1], gr_view_ycenter(), yaxis[:guide])
+        gr_text(viewport_subplot[1], gr_view_ycenter(), yaxis[:guide])
     end
     GR.restorestate()
 
@@ -604,14 +614,13 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
     GR.setcolormap(1000 + GR.COLORMAP_COOLWARM)
 
     for (idx, series) in enumerate(series_list(sp))
-        d = series.d
-        st = d[:seriestype]
+        st = series[:seriestype]
 
         # update the current stored gradient
         if st in (:contour, :surface, :wireframe, :heatmap)
-            gr_set_gradient(d[:fillcolor], d[:fillalpha])
-        elseif d[:marker_z] != nothing
-            d[:markercolor] = gr_set_gradient(d[:markercolor], d[:markeralpha])
+            gr_set_gradient(series[:fillcolor]) #, series[:fillalpha])
+        elseif series[:marker_z] != nothing
+            series[:markercolor] = gr_set_gradient(series[:markercolor])
         end
 
         GR.savestate()
@@ -626,12 +635,21 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
             end
         end
 
-        x, y, z = d[:x], d[:y], d[:z]
-        frng = d[:fillrange]
+        x, y, z = series[:x], series[:y], series[:z]
+        frng = series[:fillrange]
 
         # recompute data
-        if st in (:contour, :surface, :wireframe)
-            z = vec(transpose_z(d, z.surf, false))
+        if typeof(z) <: Surface
+            if st == :heatmap #&& size(z.surf) == (length(y), length(x))
+                expand_extrema!(sp[:xaxis], (x[1]-0.5*(x[2]-x[1]), x[end]+0.5*(x[end]-x[end-1])))
+                expand_extrema!(sp[:yaxis], (y[1]-0.5*(y[2]-y[1]), y[end]+0.5*(y[end]-y[end-1])))
+            #     # coords are centers... turn into edges
+            #     xd = diff(x)
+            #     x = vcat(x[1]-0.5xd[1], x[1]+xd, x[end]+0.5xd[end])
+            #     yd = diff(y)
+            #     y = vcat(y[1]-0.5yd[1], y[1]+yd, y[end]+0.5yd[end])
+            end
+            z = vec(transpose_z(series, z.surf, false))
         elseif ispolar(sp)
             if frng != nothing
                 _, frng = convert_to_polar(x, frng, (rmin, rmax))
@@ -644,7 +662,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
 
                 # do area fill
                 if frng != nothing
-                    gr_set_fillcolor(d[:fillcolor], d[:fillalpha])
+                    gr_set_fillcolor(series[:fillcolor]) #, series[:fillalpha])
                     GR.setfillintstyle(GR.INTSTYLE_SOLID)
                     frng = isa(frng, Number) ? Float64[frng] : frng
                     nx, ny, nf = length(x), length(y), length(frng)
@@ -660,24 +678,24 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
 
                 # draw the line(s)
                 if st == :path
-                    gr_set_line(d[:linewidth], d[:linestyle], d[:linecolor], d[:linealpha])
+                    gr_set_line(series[:linewidth], series[:linestyle], series[:linecolor]) #, series[:linealpha])
                     gr_polyline(x, y)
                 end
             end
 
-            if d[:markershape] != :none
+            if series[:markershape] != :none
                 gr_draw_markers(series, x, y)
             end
 
         elseif st == :contour
             zmin, zmax = gr_lims(zaxis, false)
-            if typeof(d[:levels]) <: Array
-                h = d[:levels]
+            if typeof(series[:levels]) <: Array
+                h = series[:levels]
             else
-                h = linspace(zmin, zmax, d[:levels])
+                h = linspace(zmin, zmax, series[:levels])
             end
             GR.setspace(zmin, zmax, 0, 90)
-            if d[:fillrange] != nothing
+            if series[:fillrange] != nothing
                 GR.surface(x, y, z, GR.OPTION_CELL_ARRAY)
             else
                 GR.contour(x, y, h, z, 1000)
@@ -696,7 +714,11 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
 
         elseif st in [:surface, :wireframe]
             if st == :surface
-                GR.gr3.surface(x, y, z, GR.OPTION_COLORED_MESH)
+                if length(x) == length(y) == length(z)
+                    GR.trisurface(x, y, z)
+                else
+                    GR.gr3.surface(x, y, z, GR.OPTION_COLORED_MESH)
+                end
             else
                 GR.setfillcolorind(0)
                 GR.surface(x, y, z, GR.OPTION_FILLED_MESH)
@@ -704,23 +726,24 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
             cmap && gr_colorbar(sp)
 
         elseif st == :heatmap
-            z = vec(transpose_z(d, z.surf, false))
+            # z = vec(transpose_z(series, z.surf, false))
             zmin, zmax = gr_lims(zaxis, true)
             GR.setspace(zmin, zmax, 0, 90)
-            GR.surface(x, y, z, GR.OPTION_COLORED_MESH)
+            # GR.surface(x, y, z, GR.OPTION_COLORED_MESH)
+            GR.surface(x, y, z, GR.OPTION_HEATMAP)
             cmap && gr_colorbar(sp)
 
         elseif st in (:path3d, :scatter3d)
             # draw path
             if st == :path3d
                 if length(x) > 1
-                    gr_set_line(d[:linewidth], d[:linestyle], d[:linecolor], d[:linealpha])
+                    gr_set_line(series[:linewidth], series[:linestyle], series[:linecolor]) #, series[:linealpha])
                     GR.polyline3d(x, y, z)
                 end
             end
 
             # draw markers
-            if st == :scatter3d || d[:markershape] != :none
+            if st == :scatter3d || series[:markershape] != :none
                 x2, y2 = unzip(map(GR.wc3towc, x, y, z))
                 gr_draw_markers(series, x2, y2)
             end
@@ -741,7 +764,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
                 ymin, ymax = ycenter - r, ycenter + r
             end
             labels = pie_labels(sp, series)
-            slices = d[:y]
+            slices = series[:y]
             numslices = length(slices)
             total = sum(slices)
             a1 = 0
@@ -762,11 +785,11 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
                 if 90 <= alpha < 270
                     x[3] = x[2] - 0.05
                     GR.settextalign(GR.TEXT_HALIGN_RIGHT, GR.TEXT_VALIGN_HALF)
-                    GR.text(x[3] - 0.01, y[3], string(labels[i]))
+                    gr_text(x[3] - 0.01, y[3], string(labels[i]))
                 else
                     x[3] = x[2] + 0.05
                     GR.settextalign(GR.TEXT_HALIGN_LEFT, GR.TEXT_VALIGN_HALF)
-                    GR.text(x[3] + 0.01, y[3], string(labels[i]))
+                    gr_text(x[3] + 0.01, y[3], string(labels[i]))
                 end
                 gr_polyline(x, y)
                 a1 = a2
@@ -774,18 +797,27 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
             GR.selntran(1)
 
         elseif st == :shape
-            # draw the shapes
-            gr_set_line(d[:markerstrokewidth], :solid, d[:markerstrokecolor], d[:markerstrokealpha])
-            gr_polyline(d[:x], d[:y])
+            for (i,rng) in enumerate(iter_segments(series[:x], series[:y]))
+                if length(rng) > 1
+                    # connect to the beginning
+                    rng = vcat(rng, rng[1])
 
-            # draw the interior
-            gr_set_fill(d[:markercolor], d[:markeralpha])
-            gr_polyline(d[:x], d[:y], GR.fillarea)
+                    # get the segments
+                    x, y = series[:x][rng], series[:y][rng]
 
+                    # draw the interior
+                    gr_set_fill(cycle(series[:fillcolor], i))
+                    GR.fillarea(x, y)
+
+                    # draw the shapes
+                    gr_set_line(series[:linewidth], :solid, cycle(series[:linecolor], i))
+                    GR.polyline(x, y)
+                end
+            end
 
 
         elseif st == :image
-            img = d[:z].surf
+            img = series[:z].surf
             w, h = size(img)
             if eltype(img) <: Colors.AbstractGray
                 grey = round(UInt8, float(img) * 255)
@@ -815,13 +847,13 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
         for series in series_list(sp)
             should_add_to_legend(series) || continue
             n += 1
-            if typeof(series.d[:label]) <: Array
+            if typeof(series[:label]) <: Array
                 i += 1
-                lab = series.d[:label][i]
+                lab = series[:label][i]
             else
-                lab = series.d[:label]
+                lab = series[:label]
             end
-            tbx, tby = GR.inqtext(0, 0, lab)
+            tbx, tby = gr_inqtext(0, 0, lab)
             w = max(w, tbx[3] - tbx[1])
         end
         if w > 0
@@ -837,32 +869,33 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
             i = 0
             for series in series_list(sp)
                 should_add_to_legend(series) || continue
-                d = series.d
-                st = d[:seriestype]
-                GR.setlinewidth(d[:linewidth])
+                st = series[:seriestype]
+                gr_set_line(series[:linewidth], series[:linestyle], series[:linecolor]) #, series[:linealpha])
                 if st == :path
-                    gr_set_linecolor(d[:linecolor], d[:linealpha])
-                    GR.setlinetype(gr_linetype[d[:linestyle]])
                     GR.polyline([xpos - 0.07, xpos - 0.01], [ypos, ypos])
+                elseif st == :shape
+                    gr_set_fill(series[:fillcolor]) #, series[:fillalpha])
+                    l, r = xpos-0.07, xpos-0.01
+                    b, t = ypos-0.4dy, ypos+0.4dy
+                    x = [l, r, r, l, l]
+                    y = [b, b, t, t, b]
+                    gr_polyline(x, y, GR.fillarea)
+                    gr_polyline(x, y)
                 end
-                if st == :scatter || d[:markershape] != :none
-                    gr_set_markercolor(d[:markercolor], d[:markeralpha])
-                    gr_setmarkershape(d)
-                    if st == :path
-                        gr_polymarker(d, [xpos - 0.06, xpos - 0.02], [ypos, ypos])
-                    else
-                        gr_polymarker(d, [xpos - 0.06, xpos - 0.04, xpos - 0.02], [ypos, ypos, ypos])
-                    end
+
+                if series[:markershape] != :none
+                    gr_draw_markers(series, xpos-[0.06,0.02], [ypos,ypos], 10, nothing)
                 end
-                if typeof(d[:label]) <: Array
+
+                if typeof(series[:label]) <: Array
                     i += 1
-                    lab = d[:label][i]
+                    lab = series[:label][i]
                 else
-                    lab = d[:label]
+                    lab = series[:label]
                 end
                 GR.settextalign(GR.TEXT_HALIGN_LEFT, GR.TEXT_VALIGN_HALF)
                 gr_set_textcolor(sp[:foreground_color_legend])
-                GR.text(xpos, ypos, lab)
+                gr_text(xpos, ypos, lab)
                 ypos -= dy
             end
         end
@@ -876,7 +909,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
         x, y, val = ann
         x, y = GR.wctondc(x, y)
         gr_set_font(val.font)
-        GR.text(x, y, val.str)
+        gr_text(x, y, val.str)
     end
     GR.restorestate()
 end
@@ -896,14 +929,29 @@ for (mime, fmt) in _gr_mimeformats
     @eval function _writemime(io::IO, ::MIME{Symbol($mime)}, plt::Plot{GRBackend})
         GR.emergencyclosegks()
         wstype = haskey(ENV, "GKS_WSTYPE") ? ENV["GKS_WSTYPE"] : "0"
+        filepath = tempname() * "." * $fmt
         ENV["GKS_WSTYPE"] = $fmt
+        ENV["GKS_FILEPATH"] = filepath
         gr_display(plt)
         GR.emergencyclosegks()
-        write(io, readall("gks." * $fmt))
+        write(io, readall(filepath))
         ENV["GKS_WSTYPE"] = wstype
+        rm(filepath)
     end
 end
 
 function _display(plt::Plot{GRBackend})
-    gr_display(plt)
+    if plt[:display_type] == :inline
+        GR.emergencyclosegks()
+        filepath = tempname() * ".pdf"
+        ENV["GKS_WSTYPE"] = "pdf"
+        ENV["GKS_FILEPATH"] = filepath
+        gr_display(plt)
+        GR.emergencyclosegks()
+        content = string("\033]1337;File=inline=1;preserveAspectRatio=0:", base64encode(open(readbytes, filepath)), "\a")
+        println(content)
+        rm(filepath)
+    else
+        gr_display(plt)
+    end
 end

src/backends/pgfplots.jl

@@ -94,20 +94,18 @@ const _pgf_series_extrastyle = KW(
 # --------------------------------------------------------------------------------------
 
 # takes in color,alpha, and returns color and alpha appropriate for pgf style
-function pgf_color(c, a = nothing)
-    c = getColor(c)
+function pgf_color(c)
     cstr = @sprintf("{rgb,1:red,%.8f;green,%.8f;blue,%.8f}", red(c), green(c), blue(c))
-    a = float(a == nothing ? alpha(c) : a)
-    cstr, a
+    cstr, alpha(c)
 end
 
 function pgf_fillstyle(d::KW)
-    cstr,a = pgf_color(d[:fillcolor], d[:fillalpha])
+    cstr,a = pgf_color(d[:fillcolor])
     "fill = $cstr, fill opacity=$a"
 end
 
 function pgf_linestyle(d::KW)
-    cstr,a = pgf_color(d[:linecolor], d[:linealpha])
+    cstr,a = pgf_color(d[:linecolor])
     """
     color = $cstr,
     draw opacity=$a,
@@ -117,8 +115,8 @@ end
 
 function pgf_marker(d::KW)
     shape = d[:markershape]
-    cstr, a = pgf_color(d[:markercolor], d[:markeralpha])
-    cstr_stroke, a_stroke = pgf_color(d[:markerstrokecolor], d[:markerstrokealpha])
+    cstr, a = pgf_color(d[:markercolor])
+    cstr_stroke, a_stroke = pgf_color(d[:markerstrokecolor])
     """
     mark = $(get(_pgfplots_markers, shape, "*")),
     mark size = $(0.5 * d[:markersize]),

src/backends/plotly.jl

@@ -88,7 +88,7 @@ function plotly_font(font::Font, color = font.color)
     KW(
         :family => font.family,
         :size   => round(Int, font.pointsize*1.4),
-        :color  => webcolor(color),
+        :color  => rgba_string(color),
     )
 end
 
@@ -126,7 +126,7 @@ end
 #         # :ay => -40,
 #         :ax => 10xdiff / dist,
 #         :ay => -10ydiff / dist,
-#         :arrowcolor => webcolor(d[:linecolor], d[:linealpha]),
+#         :arrowcolor => rgba_string(d[:linecolor]),
 #         :xref => "x",
 #         :yref => "y",
 #         :arrowsize => 10a.headwidth,
@@ -175,8 +175,8 @@ function plotly_axis(axis::Axis, sp::Subplot)
         ax[:titlefont] = plotly_font(axis[:guidefont], axis[:foreground_color_guide])
         ax[:type] = plotly_scale(axis[:scale])
         ax[:tickfont] = plotly_font(axis[:tickfont], axis[:foreground_color_text])
-        ax[:tickcolor] = webcolor(axis[:foreground_color_border])
-        ax[:linecolor] = webcolor(axis[:foreground_color_border])
+        ax[:tickcolor] = rgba_string(axis[:foreground_color_border])
+        ax[:linecolor] = rgba_string(axis[:foreground_color_border])
 
         # lims
         lims = axis[:lims]
@@ -190,7 +190,7 @@ function plotly_axis(axis::Axis, sp::Subplot)
         end
 
         # ticks
-        ticks = axis[:ticks]
+        ticks = get_ticks(axis)
         if ticks != :auto
             ttype = ticksType(ticks)
             if ttype == :ticks
@@ -214,7 +214,7 @@ function plotly_layout(plt::Plot)
 
     w, h = plt[:size]
     d_out[:width], d_out[:height] = w, h
-    d_out[:paper_bgcolor] = webcolor(plt[:background_color_outside])
+    d_out[:paper_bgcolor] = rgba_string(plt[:background_color_outside])
     d_out[:margin] = KW(:l=>0, :b=>0, :r=>0, :t=>20)
 
     d_out[:annotations] = KW[]
@@ -239,7 +239,7 @@ function plotly_layout(plt::Plot)
             push!(d_out[:annotations], plotly_annotation_dict(titlex, titley, text(sp[:title], titlefont)))
         end
 
-        d_out[:plot_bgcolor] = webcolor(sp[:background_color_inside])
+        d_out[:plot_bgcolor] = rgba_string(sp[:background_color_inside])
 
         # TODO: x/y axis tick values/labels
 
@@ -259,8 +259,8 @@ function plotly_layout(plt::Plot)
         d_out[:showlegend] = sp[:legend] != :none
         if sp[:legend] != :none
             d_out[:legend] = KW(
-                :bgcolor  => webcolor(sp[:background_color_legend]),
-                :bordercolor => webcolor(sp[:foreground_color_legend]),
+                :bgcolor  => rgba_string(sp[:background_color_legend]),
+                :bordercolor => rgba_string(sp[:foreground_color_legend]),
                 :font     => plotly_font(sp[:legendfont], sp[:foreground_color_legend]),
             )
         end
@@ -298,10 +298,11 @@ function plotly_layout_json(plt::Plot)
 end
 
 
-function plotly_colorscale(grad::ColorGradient, alpha = nothing)
-    [[grad.values[i], webcolor(grad.colors[i], alpha)] for i in 1:length(grad.colors)]
+function plotly_colorscale(grad::ColorGradient, α)
+    [[grad.values[i], rgb_string(grad.colors[i])] for i in 1:length(grad.colors)]
 end
-plotly_colorscale(c, alpha = nothing) = plotly_colorscale(default_gradient(), alpha)
+plotly_colorscale(c, α) = plotly_colorscale(cgrad(alpha=α), α)
+# plotly_colorscale(c, alpha = nothing) = plotly_colorscale(cgrad(), alpha)
 
 const _plotly_markers = KW(
     :rect       => "square",
@@ -330,10 +331,17 @@ function plotly_close_shapes(x, y)
     nanvcat(xs), nanvcat(ys)
 end
 
+plotly_data(v) = collect(v)
+plotly_data{R<:Rational}(v::AbstractArray{R}) = float(v)
+
 # get a dictionary representing the series params (d is the Plots-dict, d_out is the Plotly-dict)
 function plotly_series(plt::Plot, series::Series)
-    d = series.d
-    sp = d[:subplot]
+    st = series[:seriestype]
+    if st == :shape
+        return plotly_series_shapes(plt, series)
+    end
+
+    sp = series[:subplot]
     d_out = KW()
 
     # these are the axes that the series should be mapped to
@@ -342,12 +350,11 @@ function plotly_series(plt::Plot, series::Series)
     d_out[:yaxis] = "y$spidx"
     d_out[:showlegend] = should_add_to_legend(series)
 
-    x, y = collect(d[:x]), collect(d[:y])
-    d_out[:name] = d[:label]
-    st = d[:seriestype]
+    x, y = plotly_data(series[:x]), plotly_data(series[:y])
+    d_out[:name] = series[:label]
+
     isscatter = st in (:scatter, :scatter3d, :scattergl)
-    hasmarker = isscatter || d[:markershape] != :none
-    # hasline = !isscatter
+    hasmarker = isscatter || series[:markershape] != :none
     hasline = st in (:path, :path3d)
 
     # set the "type"
@@ -358,76 +365,36 @@ function plotly_series(plt::Plot, series::Series)
         else
             hasline ? "lines" : "none"
         end
-        if d[:fillrange] == true || d[:fillrange] == 0
+        if series[:fillrange] == true || series[:fillrange] == 0
             d_out[:fill] = "tozeroy"
-            d_out[:fillcolor] = webcolor(d[:fillcolor], d[:fillalpha])
-        elseif !(d[:fillrange] in (false, nothing))
-            warn("fillrange ignored... plotly only supports filling to zero. fillrange: $(d[:fillrange])")
+            d_out[:fillcolor] = rgba_string(series[:fillcolor])
+        elseif !(series[:fillrange] in (false, nothing))
+            warn("fillrange ignored... plotly only supports filling to zero. fillrange: $(series[:fillrange])")
         end
         d_out[:x], d_out[:y] = x, y
 
-    elseif st == :shape
-        # to draw polygons, we actually draw lines with fill
-        d_out[:type] = "scatter"
-        d_out[:mode] = "lines"
-        d_out[:x], d_out[:y] = plotly_close_shapes(x, y)
-        # @show map(length, (x,y,d_out[:x],d_out[:y]))
-        # @show d_out[:x] d_out[:y]
-        d_out[:fill] = "tozeroy"
-        d_out[:fillcolor] = webcolor(d[:markercolor], d[:markeralpha])
-        if d[:markerstrokewidth] > 0
-            d_out[:line] = KW(
-                :color => webcolor(d[:markerstrokecolor], d[:markerstrokealpha]),
-                :width => d[:markerstrokewidth],
-                :dash => string(d[:markerstrokestyle]),
-            )
-        end
-
-
-
     elseif st == :bar
         d_out[:type] = "bar"
         d_out[:x], d_out[:y] = x, y
-        d_out[:orientation] = isvertical(d) ? "v" : "h"
-
-    # elseif st == :histogram2d
-    #     d_out[:type] = "histogram2d"
-    #     d_out[:x], d_out[:y] = x, y
-    #     if isa(d[:bins], Tuple)
-    #         xbins, ybins = d[:bins]
-    #     else
-    #         xbins = ybins = d[:bins]
-    #     end
-    #     d_out[:nbinsx] = xbins
-    #     d_out[:nbinsy] = ybins
-    #     d_out[:colorscale] = plotly_colorscale(d[:fillcolor], d[:fillalpha])
-
-    # elseif st in (:histogram, :density)
-    #     d_out[:type] = "histogram"
-    #     isvert = isvertical(d)
-    #     d_out[isvert ? :x : :y] = y
-    #     d_out[isvert ? :nbinsx : :nbinsy] = d[:bins]
-    #     if st == :density
-    #         d_out[:histogramnorm] = "probability density"
-    #     end
+        d_out[:orientation] = isvertical(series) ? "v" : "h"
 
     elseif st == :heatmap
         d_out[:type] = "heatmap"
-        d_out[:x], d_out[:y], d_out[:z] = d[:x], d[:y], transpose_z(d, d[:z].surf, false)
-        d_out[:colorscale] = plotly_colorscale(d[:fillcolor], d[:fillalpha])
+        d_out[:x], d_out[:y], d_out[:z] = series[:x], series[:y], transpose_z(series, series[:z].surf, false)
+        d_out[:colorscale] = plotly_colorscale(series[:fillcolor], series[:fillalpha])
 
     elseif st == :contour
         d_out[:type] = "contour"
-        d_out[:x], d_out[:y], d_out[:z] = d[:x], d[:y], transpose_z(d, d[:z].surf, false)
-        # d_out[:showscale] = d[:colorbar] != :none
-        d_out[:ncontours] = d[:levels]
-        d_out[:contours] = KW(:coloring => d[:fillrange] != nothing ? "fill" : "lines")
-        d_out[:colorscale] = plotly_colorscale(d[:linecolor], d[:linealpha])
+        d_out[:x], d_out[:y], d_out[:z] = series[:x], series[:y], transpose_z(series, series[:z].surf, false)
+        # d_out[:showscale] = series[:colorbar] != :none
+        d_out[:ncontours] = series[:levels]
+        d_out[:contours] = KW(:coloring => series[:fillrange] != nothing ? "fill" : "lines")
+        d_out[:colorscale] = plotly_colorscale(series[:linecolor], series[:linealpha])
 
     elseif st in (:surface, :wireframe)
         d_out[:type] = "surface"
-        d_out[:x], d_out[:y], d_out[:z] = d[:x], d[:y], transpose_z(d, d[:z].surf, false)
-        d_out[:colorscale] = plotly_colorscale(d[:fillcolor], d[:fillalpha])
+        d_out[:x], d_out[:y], d_out[:z] = series[:x], series[:y], transpose_z(series, series[:z].surf, false)
+        d_out[:colorscale] = plotly_colorscale(series[:fillcolor], series[:fillalpha])
 
     elseif st == :pie
         d_out[:type] = "pie"
@@ -443,7 +410,7 @@ function plotly_series(plt::Plot, series::Series)
             hasline ? "lines" : "none"
         end
         d_out[:x], d_out[:y] = x, y
-        d_out[:z] = collect(d[:z])
+        d_out[:z] = plotly_data(series[:z])
 
     else
         warn("Plotly: seriestype $st isn't supported.")
@@ -453,32 +420,32 @@ function plotly_series(plt::Plot, series::Series)
     # add "marker"
     if hasmarker
         d_out[:marker] = KW(
-            :symbol => get(_plotly_markers, d[:markershape], string(d[:markershape])),
-            :opacity => d[:markeralpha],
-            :size => 2 * d[:markersize],
-            :color => webcolor(d[:markercolor], d[:markeralpha]),
+            :symbol => get(_plotly_markers, series[:markershape], string(series[:markershape])),
+            # :opacity => series[:markeralpha],
+            :size => 2 * series[:markersize],
+            # :color => rgba_string(series[:markercolor]),
             :line => KW(
-                :color => webcolor(d[:markerstrokecolor], d[:markerstrokealpha]),
-                :width => d[:markerstrokewidth],
+                :color => rgba_string(series[:markerstrokecolor]),
+                :width => series[:markerstrokewidth],
             ),
         )
 
         # gotta hack this (for now?) since plotly can't handle rgba values inside the gradient
-        if d[:marker_z] != nothing
-            # d_out[:marker][:color] = d[:marker_z]
-            # d_out[:marker][:colorscale] = plotly_colorscale(d[:markercolor], d[:markeralpha])
-            # d_out[:showscale] = true
-            grad = ColorGradient(d[:markercolor], alpha=d[:markeralpha])
-            zmin, zmax = extrema(d[:marker_z])
-            d_out[:marker][:color] = [webcolor(getColorZ(grad, (zi - zmin) / (zmax - zmin))) for zi in d[:marker_z]]
+        d_out[:marker][:color] = if series[:marker_z] == nothing
+            rgba_string(series[:markercolor])
+        else
+            # grad = ColorGradient(series[:markercolor], alpha=series[:markeralpha])
+            grad = series[:markercolor]
+            zmin, zmax = extrema(series[:marker_z])
+            [rgba_string(grad[(zi - zmin) / (zmax - zmin)]) for zi in series[:marker_z]]
         end
     end
 
     # add "line"
     if hasline
         d_out[:line] = KW(
-            :color => webcolor(d[:linecolor], d[:linealpha]),
-            :width => d[:linewidth],
+            :color => rgba_string(series[:linecolor]),
+            :width => series[:linewidth],
             :shape => if st == :steppre
                 "vh"
             elseif st == :steppost
@@ -486,32 +453,85 @@ function plotly_series(plt::Plot, series::Series)
             else
                 "linear"
             end,
-            :dash => string(d[:linestyle]),
+            :dash => string(series[:linestyle]),
             # :dash => "solid",
         )
     end
 
+    plotly_polar!(d_out, series)
+    plotly_hover!(d_out, series[:hover])
+
+    [d_out]
+end
+
+function plotly_series_shapes(plt::Plot, series::Series)
+    d_outs = []
+    
+    # TODO: create a d_out for each polygon
+    # x, y = series[:x], series[:y]
+    
+    # these are the axes that the series should be mapped to
+    spidx = plotly_subplot_index(series[:subplot])
+    base_d = KW()
+    base_d[:xaxis] = "x$spidx"
+    base_d[:yaxis] = "y$spidx"
+    base_d[:name] = series[:label]
+    # base_d[:legendgroup] = series[:label]
+    
+    x, y = plotly_data(series[:x]), plotly_data(series[:y])
+    for (i,rng) in enumerate(iter_segments(x,y))
+        length(rng) < 2 && continue
+
+        # to draw polygons, we actually draw lines with fill
+        d_out = merge(base_d, KW(
+            :type => "scatter",
+            :mode => "lines",
+            :x => vcat(x[rng], x[rng[1]]),
+            :y => vcat(y[rng], y[rng[1]]),
+            :fill => "tozeroy",
+            :fillcolor => rgba_string(cycle(series[:fillcolor], i)),
+        ))
+        if series[:markerstrokewidth] > 0
+            d_out[:line] = KW(
+                :color => rgba_string(cycle(series[:linecolor], i)),
+                :width => series[:linewidth],
+                :dash => string(series[:linestyle]),
+            )
+        end
+        d_out[:showlegend] = i==1 ? should_add_to_legend(series) : false
+        plotly_polar!(d_out, series)
+        plotly_hover!(d_out, cycle(series[:hover], i))
+        push!(d_outs, d_out)
+    end
+    d_outs
+end
+
+function plotly_polar!(d_out::KW, series::Series)
     # convert polar plots x/y to theta/radius
-    if ispolar(d[:subplot])
+    if ispolar(series[:subplot])
         d_out[:t] = rad2deg(pop!(d_out, :x))
         d_out[:r] = pop!(d_out, :y)
     end
+end
 
+function plotly_hover!(d_out::KW, hover)
     # hover text
-    hover = d[:hover]
     if hover in (:none, false)
         d_out[:hoverinfo] = "none"
     elseif hover != nothing
         d_out[:hoverinfo] = "text"
         d_out[:text] = hover
     end
-
-    d_out
 end
 
 # get a list of dictionaries, each representing the series params
 function plotly_series_json(plt::Plot)
-    JSON.json(map(series -> plotly_series(plt, series), plt.series_list))
+    slist = []
+    for series in plt.series_list
+        append!(slist, plotly_series(plt, series))
+    end
+    JSON.json(slist)
+    # JSON.json(map(series -> plotly_series(plt, series), plt.series_list))
 end
 
 # ----------------------------------------------------------------

src/backends/plotlyjs.jl

@@ -5,6 +5,7 @@ supported_args(::PlotlyJSBackend) = supported_args(PlotlyBackend())
 supported_types(::PlotlyJSBackend) = supported_types(PlotlyBackend())
 supported_styles(::PlotlyJSBackend) = supported_styles(PlotlyBackend())
 supported_markers(::PlotlyJSBackend) = supported_markers(PlotlyBackend())
+supported_scales(::PlotlyJSBackend) = supported_scales(PlotlyBackend())
 is_subplot_supported(::PlotlyJSBackend) = true
 is_string_supported(::PlotlyJSBackend) = true
 
@@ -32,10 +33,12 @@ end
 
 function _series_added(plt::Plot{PlotlyJSBackend}, series::Series)
     syncplot = plt.o
-    pdict = plotly_series(plt, series)
-    typ = pop!(pdict, :type)
-    gt = PlotlyJS.GenericTrace(typ; pdict...)
-    PlotlyJS.addtraces!(syncplot, gt)
+    pdicts = plotly_series(plt, series)
+    for pdict in pdicts
+        typ = pop!(pdict, :type)
+        gt = PlotlyJS.GenericTrace(typ; pdict...)
+        PlotlyJS.addtraces!(syncplot, gt)
+    end
 end
 
 function _series_updated(plt::Plot{PlotlyJSBackend}, series::Series)

src/backends/pyplot.jl

@@ -30,11 +30,12 @@ supported_args(::PyPlotBackend) = merge_with_base_supported([
     :match_dimensions,
     :clims,
     :inset_subplots,
+    :dpi,
   ])
 supported_types(::PyPlotBackend) = [
         :path, :steppre, :steppost, :shape,
-        :scatter, :histogram2d, :hexbin, :histogram,
-        :bar,
+        :scatter, :hexbin, #:histogram2d, :histogram,
+        # :bar,
         :heatmap, :pie, :image,
         :contour, :contour3d, :path3d, :scatter3d, :surface, :wireframe
     ]
@@ -49,10 +50,12 @@ is_subplot_supported(::PyPlotBackend) = true
 
 function _initialize_backend(::PyPlotBackend)
     @eval begin
-        # see: https://github.com/tbreloff/Plots.jl/issues/308
-        ENV["OVERRIDE_PYPLOT_DISPLAY"] = true
-
+        # problem: https://github.com/tbreloff/Plots.jl/issues/308
+        # solution: hack from @stevengj: https://github.com/stevengj/PyPlot.jl/pull/223#issuecomment-229747768
+        otherdisplays = splice!(Base.Multimedia.displays, 2:length(Base.Multimedia.displays))
         import PyPlot
+        append!(Base.Multimedia.displays, otherdisplays)
+
         export PyPlot
         const pycolors = PyPlot.pywrap(PyPlot.pyimport("matplotlib.colors"))
         const pypath = PyPlot.pywrap(PyPlot.pyimport("matplotlib.path"))
@@ -62,6 +65,7 @@ function _initialize_backend(::PyPlotBackend)
         const pyticker = PyPlot.pywrap(PyPlot.pyimport("matplotlib.ticker"))
         const pycmap = PyPlot.pywrap(PyPlot.pyimport("matplotlib.cm"))
         const pynp = PyPlot.pywrap(PyPlot.pyimport("numpy"))
+        pynp.seterr(invalid="ignore")
         const pytransforms = PyPlot.pywrap(PyPlot.pyimport("matplotlib.transforms"))
         const pycollections = PyPlot.pywrap(PyPlot.pyimport("matplotlib.collections"))
         const pyart3d = PyPlot.pywrap(PyPlot.pyimport("mpl_toolkits.mplot3d.art3d"))
@@ -74,26 +78,37 @@ end
 # --------------------------------------------------------------------------------------
 # --------------------------------------------------------------------------------------
 
-# convert colorant to 4-tuple RGBA
-py_color(c::Colorant, α=nothing) = map(f->float(f(convertColor(c,α))), (red, green, blue, alpha))
-py_color(cvec::ColorVector, α=nothing) = map(py_color, convertColor(cvec, α).v)
-py_color(grad::ColorGradient, α=nothing) = map(c -> py_color(c, α), grad.colors)
-py_color(scheme::ColorScheme, α=nothing) = py_color(convertColor(getColor(scheme), α))
-py_color(vec::AVec, α=nothing) = map(c->py_color(c,α), vec)
-py_color(c, α=nothing) = py_color(convertColor(c, α))
+# # convert colorant to 4-tuple RGBA
+# py_color(c::Colorant, α=nothing) = map(f->float(f(convertColor(c,α))), (red, green, blue, alpha))
+# py_color(cvec::ColorVector, α=nothing) = map(py_color, convertColor(cvec, α).v)
+# py_color(grad::ColorGradient, α=nothing) = map(c -> py_color(c, α), grad.colors)
+# py_color(scheme::ColorScheme, α=nothing) = py_color(convertColor(getColor(scheme), α))
+# py_color(vec::AVec, α=nothing) = map(c->py_color(c,α), vec)
+# py_color(c, α=nothing) = py_color(convertColor(c, α))
 
-function py_colormap(c::ColorGradient, α=nothing)
-    pyvals = [(v, py_color(getColorZ(c, v), α)) for v in c.values]
-    pycolors.pymember("LinearSegmentedColormap")[:from_list]("tmp", pyvals)
+# function py_colormap(c::ColorGradient, α=nothing)
+#     pyvals = [(v, py_color(getColorZ(c, v), α)) for v in c.values]
+#     pycolors.pymember("LinearSegmentedColormap")[:from_list]("tmp", pyvals)
+# end
+
+# # convert vectors and ColorVectors to standard ColorGradients
+# # TODO: move this logic to colors.jl and keep a barebones wrapper for pyplot
+# py_colormap(cv::ColorVector, α=nothing) = py_colormap(ColorGradient(cv.v), α)
+# py_colormap(v::AVec, α=nothing) = py_colormap(ColorGradient(v), α)
+
+# # anything else just gets a bluesred gradient
+# py_colormap(c, α=nothing) = py_colormap(default_gradient(), α)
+
+py_color(c::Colorant) = (red(c), green(c), blue(c), alpha(c))
+py_color(cs::AVec) = map(py_color, cs)
+py_color(grad::ColorGradient) = py_color(grad.colors)
+
+function py_colormap(grad::ColorGradient)
+    pyvals = [(z, py_color(grad[z])) for z in grad.values]
+    pycolors.LinearSegmentedColormap[:from_list]("tmp", pyvals)
 end
+py_colormap(c) = py_colormap(cgrad())
 
-# convert vectors and ColorVectors to standard ColorGradients
-# TODO: move this logic to colors.jl and keep a barebones wrapper for pyplot
-py_colormap(cv::ColorVector, α=nothing) = py_colormap(ColorGradient(cv.v), α)
-py_colormap(v::AVec, α=nothing) = py_colormap(ColorGradient(v), α)
-
-# anything else just gets a bluesred gradient
-py_colormap(c, α=nothing) = py_colormap(default_gradient(), α)
 
 function py_shading(c, z, α=nothing)
     cmap = py_colormap(c, α)
@@ -128,27 +143,27 @@ const _path_MOVETO = UInt8(1)
 const _path_LINETO = UInt8(2)
 const _path_CLOSEPOLY = UInt8(79)
 
-# see http://matplotlib.org/users/path_tutorial.html
-# and http://matplotlib.org/api/path_api.html#matplotlib.path.Path
-function py_path(x, y)
-    n = length(x)
-    mat = zeros(n+1, 2)
-    codes = zeros(UInt8, n+1)
-    lastnan = true
-    for i=1:n
-        mat[i,1] = x[i]
-        mat[i,2] = y[i]
-        nan = !ok(x[i], y[i])
-        codes[i] = if nan
-            _path_CLOSEPOLY
-        else
-            lastnan ? _path_MOVETO : _path_LINETO
-        end
-        lastnan = nan
-    end
-    codes[n+1] = _path_CLOSEPOLY
-    pypath.pymember("Path")(mat, codes)
-end
+# # see http://matplotlib.org/users/path_tutorial.html
+# # and http://matplotlib.org/api/path_api.html#matplotlib.path.Path
+# function py_path(x, y)
+#     n = length(x)
+#     mat = zeros(n+1, 2)
+#     codes = zeros(UInt8, n+1)
+#     lastnan = true
+#     for i=1:n
+#         mat[i,1] = x[i]
+#         mat[i,2] = y[i]
+#         nan = !ok(x[i], y[i])
+#         codes[i] = if nan && i>1
+#             _path_CLOSEPOLY
+#         else
+#             lastnan ? _path_MOVETO : _path_LINETO
+#         end
+#         lastnan = nan
+#     end
+#     codes[n+1] = _path_CLOSEPOLY
+#     pypath.pymember("Path")(mat, codes)
+# end
 
 # get the marker shape
 function py_marker(marker::Symbol)
@@ -158,8 +173,8 @@ function py_marker(marker::Symbol)
     marker == :diamond && return "D"
     marker == :utriangle && return "^"
     marker == :dtriangle && return "v"
-    marker == :cross && return "+"
-    marker == :xcross && return "x"
+    # marker == :cross && return "+"
+    # marker == :xcross && return "x"
     marker == :star5 && return "*"
     marker == :pentagon && return "p"
     marker == :hexagon && return "h"
@@ -188,13 +203,13 @@ function py_stepstyle(seriestype::Symbol)
     return "default"
 end
 
-# untested... return a FontProperties object from a Plots.Font
-function py_font(font::Font)
-    pyfont.pymember("FontProperties")(
-        family = font.family,
-        size = font.size
-    )
-end
+# # untested... return a FontProperties object from a Plots.Font
+# function py_font(font::Font)
+#     pyfont.pymember("FontProperties")(
+#         family = font.family,
+#         size = font.size
+#     )
+# end
 
 function get_locator_and_formatter(vals::AVec)
     pyticker.pymember("FixedLocator")(1:length(vals)), pyticker.pymember("FixedFormatter")(vals)
@@ -205,29 +220,17 @@ function add_pyfixedformatter(cbar, vals::AVec)
     cbar[:update_ticks]()
 end
 
-# # TODO: smoothing should be moved into the SliceIt method, should not touch backends
-# function handleSmooth(plt::Plot{PyPlotBackend}, ax, d::KW, smooth::Bool)
-#     if smooth
-#         xs, ys = regressionXY(d[:x], d[:y])
-#         ax[:plot](xs, ys,
-#                   # linestyle = py_linestyle(:path, :dashdot),
-#                   color = py_color(d[:linecolor]),
-#                   linewidth = 2
-#                  )
-#     end
-# end
-# handleSmooth(plt::Plot{PyPlotBackend}, ax, d::KW, smooth::Real) = handleSmooth(plt, ax, d, true)
 
 # ---------------------------------------------------------------------------
 
-function fix_xy_lengths!(plt::Plot{PyPlotBackend}, d::KW)
-    x, y = d[:x], d[:y]
+function fix_xy_lengths!(plt::Plot{PyPlotBackend}, series::Series)
+    x, y = series[:x], series[:y]
     nx, ny = length(x), length(y)
-    if !isa(get(d, :z, nothing), Surface) && nx != ny
+    if !isa(get(series.d, :z, nothing), Surface) && nx != ny
         if nx < ny
-            d[:x] = Float64[x[mod1(i,nx)] for i=1:ny]
+            series[:x] = Float64[x[mod1(i,nx)] for i=1:ny]
         else
-            d[:y] = Float64[y[mod1(i,ny)] for i=1:nx]
+            series[:y] = Float64[y[mod1(i,ny)] for i=1:nx]
         end
     end
 end
@@ -243,14 +246,14 @@ function py_color_fix(c, x)
     end
 end
 
-py_linecolor(d::KW)          = py_color(d[:linecolor], d[:linealpha])
-py_markercolor(d::KW)        = py_color(d[:markercolor], d[:markeralpha])
-py_markerstrokecolor(d::KW)  = py_color(d[:markerstrokecolor], d[:markerstrokealpha])
-py_fillcolor(d::KW)          = py_color(d[:fillcolor], d[:fillalpha])
+py_linecolor(series::Series)          = py_color(series[:linecolor])
+py_markercolor(series::Series)        = py_color(series[:markercolor])
+py_markerstrokecolor(series::Series)  = py_color(series[:markerstrokecolor])
+py_fillcolor(series::Series)          = py_color(series[:fillcolor])
 
-py_linecolormap(d::KW)       = py_colormap(d[:linecolor], d[:linealpha])
-py_markercolormap(d::KW)     = py_colormap(d[:markercolor], d[:markeralpha])
-py_fillcolormap(d::KW)       = py_colormap(d[:fillcolor], d[:fillalpha])
+py_linecolormap(series::Series)       = py_colormap(series[:linecolor])
+py_markercolormap(series::Series)     = py_colormap(series[:markercolor])
+py_fillcolormap(series::Series)       = py_colormap(series[:fillcolor])
 
 # ---------------------------------------------------------------------------
 
@@ -327,6 +330,10 @@ function py_bbox_title(ax)
     bb
 end
 
+function py_dpi_scale(plt::Plot{PyPlotBackend}, ptsz)
+    ptsz * DPI / plt[:dpi]
+end
+
 # ---------------------------------------------------------------------------
 
 # Create the window/figure for this backend.
@@ -373,9 +380,9 @@ end
 # function _series_added(plt::Plot{PyPlotBackend}, series::Series)
 
 function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
-    d = series.d
-    st = d[:seriestype]
-    sp = d[:subplot]
+    # d = series.d
+    st = series[:seriestype]
+    sp = series[:subplot]
     ax = sp.o
 
     if !(st in supported_types(plt.backend))
@@ -383,10 +390,10 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
     end
 
     # PyPlot doesn't handle mismatched x/y
-    fix_xy_lengths!(plt, d)
+    fix_xy_lengths!(plt, series)
 
     # ax = getAxis(plt, series)
-    x, y, z = d[:x], d[:y], d[:z]
+    x, y, z = series[:x], series[:y], series[:z]
     xyargs = (st in _3dTypes ? (x,y,z) : (x,y))
 
     # handle zcolor and get c/cmap
@@ -399,7 +406,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
 
 
     # pass in an integer value as an arg, but a levels list as a keyword arg
-    levels = d[:levels]
+    levels = series[:levels]
     levelargs = if isscalar(levels)
         (levels)
     elseif isvector(levels)
@@ -413,14 +420,14 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
 
     # line plot
     if st in (:path, :path3d, :steppre, :steppost)
-        if d[:linewidth] > 0
-            if d[:line_z] == nothing
+        if series[:linewidth] > 0
+            if series[:line_z] == nothing
                 handle = ax[:plot](xyargs...;
-                    label = d[:label],
-                    zorder = plt.n,
-                    color = py_linecolor(d),
-                    linewidth = d[:linewidth],
-                    linestyle = py_linestyle(st, d[:linestyle]),
+                    label = series[:label],
+                    zorder = series[:series_plotindex],
+                    color = py_linecolor(series),
+                    linewidth = py_dpi_scale(plt, series[:linewidth]),
+                    linestyle = py_linestyle(st, series[:linestyle]),
                     solid_capstyle = "round",
                     drawstyle = py_stepstyle(st)
                 )[1]
@@ -429,28 +436,38 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
             else
                 # multicolored line segments
                 n = length(x) - 1
-                segments = Array(Any,n)
+                # segments = Array(Any,n)
+                segments = []
                 kw = KW(
-                    :label => d[:label],
+                    :label => series[:label],
                     :zorder => plt.n,
-                    :cmap => py_linecolormap(d),
-                    :linewidth => d[:linewidth],
-                    :linestyle => py_linestyle(st, d[:linestyle])
+                    :cmap => py_linecolormap(series),
+                    :linewidth => py_dpi_scale(plt, series[:linewidth]),
+                    :linestyle => py_linestyle(st, series[:linestyle])
                 )
+                lz = collect(series[:line_z])
                 handle = if is3d(st)
-                    for i=1:n
-                        segments[i] = [(cycle(x,i), cycle(y,i), cycle(z,i)), (cycle(x,i+1), cycle(y,i+1), cycle(z,i+1))]
+                    for rng in iter_segments(x, y, z)
+                        length(rng) < 2 && continue
+                        push!(segments, [(cycle(x,i),cycle(y,i),cycle(z,i)) for i in rng])
                     end
+                    # for i=1:n
+                    #     segments[i] = [(cycle(x,i), cycle(y,i), cycle(z,i)), (cycle(x,i+1), cycle(y,i+1), cycle(z,i+1))]
+                    # end
                     lc = pyart3d.Line3DCollection(segments; kw...)
-                    lc[:set_array](d[:line_z])
+                    lc[:set_array](lz)
                     ax[:add_collection3d](lc, zs=z) #, zdir='y')
                     lc
                 else
-                    for i=1:n
-                        segments[i] = [(cycle(x,i), cycle(y,i)), (cycle(x,i+1), cycle(y,i+1))]
+                    for rng in iter_segments(x, y)
+                        length(rng) < 2 && continue
+                        push!(segments, [(cycle(x,i),cycle(y,i)) for i in rng])
                     end
+                    # for i=1:n
+                    #     segments[i] = [(cycle(x,i), cycle(y,i)), (cycle(x,i+1), cycle(y,i+1))]
+                    # end
                     lc = pycollections.LineCollection(segments; kw...)
-                    lc[:set_array](d[:line_z])
+                    lc[:set_array](lz)
                     ax[:add_collection](lc)
                     lc
                 end
@@ -458,7 +475,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                 needs_colorbar = true
             end
 
-            a = d[:arrow]
+            a = series[:arrow]
             if a != nothing && !is3d(st)  # TODO: handle 3d later
                 if typeof(a) != Arrow
                     warn("Unexpected type for arrow: $(typeof(a))")
@@ -467,10 +484,10 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                         :arrowstyle => "simple,head_length=$(a.headlength),head_width=$(a.headwidth)",
                         :shrinkA => 0,
                         :shrinkB => 0,
-                        :edgecolor => py_linecolor(d),
-                        :facecolor => py_linecolor(d),
-                        :linewidth => d[:linewidth],
-                        :linestyle => py_linestyle(st, d[:linestyle]),
+                        :edgecolor => py_linecolor(series),
+                        :facecolor => py_linecolor(series),
+                        :linewidth => py_dpi_scale(plt, series[:linewidth]),
+                        :linestyle => py_linestyle(st, series[:linestyle]),
                     )
                     add_arrows(x, y) do xyprev, xy
                         ax[:annotate]("",
@@ -485,53 +502,16 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
         end
     end
 
-    if st == :bar
-        bw = d[:bar_width]
-        if bw == nothing
-            bw = mean(diff(isvertical(d) ? x : y))
-        end
-        extrakw[isvertical(d) ? :width : :height] = bw
-        fr = get(d, :fillrange, nothing)
-        if fr != nothing
-            extrakw[:bottom] = fr
-            d[:fillrange] = nothing
-        end
-        handle = ax[isvertical(d) ? :bar : :barh](x, y;
-            label = d[:label],
-            zorder = plt.n,
-            color = py_fillcolor(d),
-            edgecolor = py_linecolor(d),
-            linewidth = d[:linewidth],
-            align = d[:bar_edges] ? "edge" : "center",
-            extrakw...
-        )[1]
-        push!(handles, handle)
-    end
-
-    # if st == :sticks
-    #     extrakw[isvertical(d) ? :width : :height] = 0.0
-    #     handle = ax[isvertical(d) ? :bar : :barh](x, y;
-    #         label = d[:label],
-    #         zorder = plt.n,
-    #         color = py_linecolor(d),
-    #         edgecolor = py_linecolor(d),
-    #         linewidth = d[:linewidth],
-    #         align = "center",
-    #         extrakw...
-    #     )[1]
-    #     push!(handles, handle)
-    # end
-
     # add markers?
-    if d[:markershape] != :none && st in (:path, :scatter, :path3d,
+    if series[:markershape] != :none && st in (:path, :scatter, :path3d,
                                           :scatter3d, :steppre, :steppost,
                                           :bar)
         extrakw = KW()
-        if d[:marker_z] == nothing
-            extrakw[:c] = py_color_fix(py_markercolor(d), x)
+        if series[:marker_z] == nothing
+            extrakw[:c] = py_color_fix(py_markercolor(series), x)
         else
-            extrakw[:c] = convert(Vector{Float64}, d[:marker_z])
-            extrakw[:cmap] = py_markercolormap(d)
+            extrakw[:c] = convert(Vector{Float64}, series[:marker_z])
+            extrakw[:cmap] = py_markercolormap(series)
             clims = sp[:clims]
             if is_2tuple(clims)
                 isfinite(clims[1]) && (extrakw[:vmin] = clims[1])
@@ -539,72 +519,23 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
             end
             needs_colorbar = true
         end
-        xyargs = if st == :bar && !isvertical(d)
+        xyargs = if st == :bar && !isvertical(series)
             (y, x)
         else
             xyargs
         end
         handle = ax[:scatter](xyargs...;
-            label = d[:label],
-            zorder = plt.n + 0.5,
-            marker = py_marker(d[:markershape]),
-            s = d[:markersize] .^ 2,
-            edgecolors = py_markerstrokecolor(d),
-            linewidths = d[:markerstrokewidth],
+            label = series[:label],
+            zorder = series[:series_plotindex] + 0.5,
+            marker = py_marker(series[:markershape]),
+            s = py_dpi_scale(plt, series[:markersize] .^ 2),
+            edgecolors = py_markerstrokecolor(series),
+            linewidths = py_dpi_scale(plt, series[:markerstrokewidth]),
             extrakw...
         )
         push!(handles, handle)
     end
 
-    if st == :histogram
-        handle = ax[:hist](y;
-            label = d[:label],
-            zorder = plt.n,
-            color = py_fillcolor(d),
-            edgecolor = py_linecolor(d),
-            linewidth = d[:linewidth],
-            bins = d[:bins],
-            normed = d[:normalize],
-            weights = d[:weights],
-            orientation = (isvertical(d) ? "vertical" : "horizontal"),
-            histtype = (d[:bar_position] == :stack ? "barstacked" : "bar")
-        )[3]
-        push!(handles, handle)
-
-        # expand the extrema... handle is a list of Rectangle objects
-        for rect in handle
-            xmin, ymin, xmax, ymax = rect[:get_bbox]()[:extents]
-            expand_extrema!(sp, xmin, xmax, ymin, ymax)
-            # expand_extrema!(sp[:xaxis], (xmin, xmax))
-            # expand_extrema!(sp[:yaxis], (ymin, ymax))
-        end
-    end
-
-    if st == :histogram2d
-        clims = sp[:clims]
-        if is_2tuple(clims)
-            isfinite(clims[1]) && (extrakw[:vmin] = clims[1])
-            isfinite(clims[2]) && (extrakw[:vmax] = clims[2])
-        end
-        handle = ax[:hist2d](x, y;
-            label = d[:label],
-            zorder = plt.n,
-            bins = d[:bins],
-            normed = d[:normalize],
-            weights = d[:weights],
-            cmap = py_fillcolormap(d),  # applies to the pcolorfast object
-            extrakw...
-        )[4]
-        push!(handles, handle)
-        needs_colorbar = true
-
-        # expand the extrema... handle is a AxesImage object
-        expand_extrema!(sp, handle[:get_extent]()...)
-        # xmin, xmax, ymin, ymax = handle[:get_extent]()
-        # expand_extrema!(sp[:xaxis], (xmin, xmax))
-        # expand_extrema!(sp[:yaxis], (ymin, ymax))
-    end
-
     if st == :hexbin
         clims = sp[:clims]
         if is_2tuple(clims)
@@ -612,33 +543,20 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
             isfinite(clims[2]) && (extrakw[:vmax] = clims[2])
         end
         handle = ax[:hexbin](x, y;
-            label = d[:label],
-            zorder = plt.n,
-            gridsize = d[:bins],
-            linewidths = d[:linewidth],
-            edgecolors = py_linecolor(d),
-            cmap = py_fillcolormap(d),  # applies to the pcolorfast object
+            label = series[:label],
+            zorder = series[:series_plotindex],
+            gridsize = series[:bins],
+            linewidths = py_dpi_scale(plt, series[:linewidth]),
+            edgecolors = py_linecolor(series),
+            cmap = py_fillcolormap(series),  # applies to the pcolorfast object
             extrakw...
         )
         push!(handles, handle)
         needs_colorbar = true
     end
 
-    # if st in (:hline,:vline)
-    #     for yi in d[:y]
-    #         func = ax[st == :hline ? :axhline : :axvline]
-    #         handle = func(yi;
-    #             linewidth=d[:linewidth],
-    #             color=py_linecolor(d),
-    #             linestyle=py_linestyle(st, d[:linestyle])
-    #         )
-    #         push!(handles, handle)
-    #     end
-    # end
-
     if st in (:contour, :contour3d)
-        # z = z.surf'
-        z = transpose_z(d, z.surf)
+        z = transpose_z(series, z.surf)
         needs_colorbar = true
 
         clims = sp[:clims]
@@ -653,21 +571,21 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
 
         # contour lines
         handle = ax[:contour](x, y, z, levelargs...;
-            label = d[:label],
-            zorder = plt.n,
-            linewidths = d[:linewidth],
-            linestyles = py_linestyle(st, d[:linestyle]),
-            cmap = py_linecolormap(d),
+            label = series[:label],
+            zorder = series[:series_plotindex],
+            linewidths = py_dpi_scale(plt, series[:linewidth]),
+            linestyles = py_linestyle(st, series[:linestyle]),
+            cmap = py_linecolormap(series),
             extrakw...
         )
         push!(handles, handle)
 
         # contour fills
-        if d[:fillrange] != nothing
+        if series[:fillrange] != nothing
             handle = ax[:contourf](x, y, z, levelargs...;
-                label = d[:label],
-                zorder = plt.n + 0.5,
-                cmap = py_fillcolormap(d),
+                label = series[:label],
+                zorder = series[:series_plotindex] + 0.5,
+                cmap = py_fillcolormap(series),
                 extrakw...
             )
             push!(handles, handle)
@@ -679,13 +597,13 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
             x, y, z = map(Array, (x,y,z))
             if !ismatrix(x) || !ismatrix(y)
                 x = repmat(x', length(y), 1)
-                y = repmat(y, 1, length(d[:x]))
+                y = repmat(y, 1, length(series[:x]))
             end
             # z = z'
-            z = transpose_z(d, z)
+            z = transpose_z(series, z)
             if st == :surface
-                if d[:marker_z] != nothing
-                    extrakw[:facecolors] = py_shading(d[:fillcolor], d[:marker_z], d[:fillalpha])
+                if series[:marker_z] != nothing
+                    extrakw[:facecolors] = py_shading(series[:fillcolor], series[:marker_z], series[:fillalpha])
                     extrakw[:shade] = false
                     clims = sp[:clims]
                     if is_2tuple(clims)
@@ -693,28 +611,28 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                         isfinite(clims[2]) && (extrakw[:vmax] = clims[2])
                     end
                 else
-                    extrakw[:cmap] = py_fillcolormap(d)
+                    extrakw[:cmap] = py_fillcolormap(series)
                     needs_colorbar = true
                 end
             end
             handle = ax[st == :surface ? :plot_surface : :plot_wireframe](x, y, z;
-                label = d[:label],
-                zorder = plt.n,
+                label = series[:label],
+                zorder = series[:series_plotindex],
                 rstride = 1,
                 cstride = 1,
-                linewidth = d[:linewidth],
-                edgecolor = py_linecolor(d),
+                linewidth = py_dpi_scale(plt, series[:linewidth]),
+                edgecolor = py_linecolor(series),
                 extrakw...
             )
             push!(handles, handle)
 
             # contours on the axis planes
-            if d[:contours]
+            if series[:contours]
                 for (zdir,mat) in (("x",x), ("y",y), ("z",z))
                     offset = (zdir == "y" ? maximum : minimum)(mat)
                     handle = ax[:contourf](x, y, z, levelargs...;
                         zdir = zdir,
-                        cmap = py_fillcolormap(d),
+                        cmap = py_fillcolormap(series),
                         offset = (zdir == "y" ? maximum : minimum)(mat)  # where to draw the contour plane
                     )
                     push!(handles, handle)
@@ -735,11 +653,11 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                 isfinite(clims[2]) && (extrakw[:vmax] = clims[2])
             end
             handle = ax[:plot_trisurf](x, y, z;
-                label = d[:label],
-                zorder = plt.n,
-                cmap = py_fillcolormap(d),
-                linewidth = d[:linewidth],
-                edgecolor = py_linecolor(d),
+                label = series[:label],
+                zorder = series[:series_plotindex],
+                cmap = py_fillcolormap(series),
+                linewidth = py_dpi_scale(plt, series[:linewidth]),
+                edgecolor = py_linecolor(series),
                 extrakw...
             )
             push!(handles, handle)
@@ -751,7 +669,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
 
     if st == :image
         # @show typeof(z)
-        img = Array(transpose_z(d, z.surf))
+        img = Array(transpose_z(series, z.surf))
         z = if eltype(img) <: Colors.AbstractGray
             float(img)
         elseif eltype(img) <: Colorant
@@ -760,7 +678,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
             z  # hopefully it's in a data format that will "just work" with imshow
         end
         handle = ax[:imshow](z;
-            zorder = plt.n,
+            zorder = series[:series_plotindex],
             cmap = py_colormap([:black, :white]),
             vmin = 0.0,
             vmax = 1.0
@@ -770,11 +688,11 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
         # expand extrema... handle is AxesImage object
         xmin, xmax, ymax, ymin = handle[:get_extent]()
         expand_extrema!(sp, xmin, xmax, ymin, ymax)
-        # sp[:yaxis].d[:flip] = true
+        # sp[:yaxis].series[:flip] = true
     end
 
     if st == :heatmap
-        x, y, z = heatmap_edges(x), heatmap_edges(y), transpose_z(d, z.surf)
+        x, y, z = heatmap_edges(x), heatmap_edges(y), transpose_z(series, z.surf)
         # if !(eltype(z) <: Number)
         #     z, discrete_colorbar_values = indices_and_unique_values(z)
         # end
@@ -790,10 +708,10 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
         end
         
         handle = ax[:pcolormesh](x, y, z;
-            label = d[:label],
-            zorder = plt.n,
-            cmap = py_fillcolormap(d),
-            edgecolors = (d[:linewidth] > 0 ? py_linecolor(d) : "face"),
+            label = series[:label],
+            zorder = series[:series_plotindex],
+            cmap = py_fillcolormap(series),
+            edgecolors = (series[:linewidth] > 0 ? py_linecolor(series) : "face"),
             extrakw...
         )
         push!(handles, handle)
@@ -811,16 +729,32 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
     end
 
     if st == :shape
-        path = py_path(x, y)
-        patches = pypatches.pymember("PathPatch")(path;
-            label = d[:label],
-            zorder = plt.n,
-            edgecolor = py_markerstrokecolor(d),
-            facecolor = py_markercolor(d),
-            linewidth = d[:markerstrokewidth],
-            fill = true
-        )
-        handle = ax[:add_patch](patches)
+        handle = []
+        for (i,rng) in enumerate(iter_segments(x, y))
+            if length(rng) > 1
+                path = pypath.pymember("Path")(hcat(x[rng], y[rng]))
+                patches = pypatches.pymember("PathPatch")(
+                    path;
+                    label = series[:label],
+                    zorder = series[:series_plotindex],
+                    edgecolor = py_color(cycle(series[:linecolor], i)),
+                    facecolor = py_color(cycle(series[:fillcolor], i)),
+                    linewidth = py_dpi_scale(plt, series[:linewidth]),
+                    fill = true
+                )
+                push!(handle, ax[:add_patch](patches))
+            end
+        end
+        # path = py_path(x, y)
+        # patches = pypatches.pymember("PathPatch")(path;
+        #     label = series[:label],
+        #     zorder = series[:series_plotindex],
+        #     edgecolor = py_linecolor(series),
+        #     facecolor = py_fillcolor(series),
+        #     linewidth = py_dpi_scale(plt, series[:linewidth]),
+        #     fill = true
+        # )
+        # handle = ax[:add_patch](patches)
         push!(handles, handle)
     end
 
@@ -839,10 +773,10 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
         expand_extrema!(sp, -lim, lim, -lim, lim)
     end
 
-    d[:serieshandle] = handles
+    series[:serieshandle] = handles
 
     # # smoothing
-    # handleSmooth(plt, ax, d, d[:smooth])
+    # handleSmooth(plt, ax, series, series[:smooth])
 
     # add the colorbar legend
     if needs_colorbar && sp[:colorbar] != :none
@@ -867,55 +801,29 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
     end
 
     # handle area filling
-    fillrange = d[:fillrange]
+    fillrange = series[:fillrange]
     if fillrange != nothing && st != :contour
-        f, dim1, dim2 = if isvertical(d)
+        f, dim1, dim2 = if isvertical(series)
             :fill_between, x, y
         else
             :fill_betweenx, y, x
         end
+        n = length(dim1)
         args = if typeof(fillrange) <: Union{Real, AVec}
-            dim1, fillrange, dim2
-        else
-            dim1, fillrange...
+            dim1, expand_data(fillrange, n), dim2
+        elseif is_2tuple(fillrange)
+            dim1, expand_data(fillrange[1], n), expand_data(fillrange[2], n)
         end
 
         handle = ax[f](args...;
-            zorder = plt.n,
-            facecolor = py_fillcolor(d),
+            zorder = series[:series_plotindex],
+            facecolor = py_fillcolor(series),
             linewidths = 0
         )
         push!(handles, handle)
     end
 end
 
-
-# --------------------------------------------------------------------------
-
-# function update_limits!(sp::Subplot{PyPlotBackend}, series::Series, letters)
-#     for letter in letters
-#         py_set_lims(sp.o, sp[Symbol(letter, :axis)])
-#     end
-# end
-
-# function _series_updated(plt::Plot{PyPlotBackend}, series::Series)
-#     d = series.d
-#     for handle in get(d, :serieshandle, [])
-#         if is3d(series)
-#             handle[:set_data](d[:x], d[:y])
-#             handle[:set_3d_properties](d[:z])
-#         else
-#             try
-#                 handle[:set_data](d[:x], d[:y])
-#             catch
-#                 handle[:set_offsets](hcat(d[:x], d[:y]))
-#             end
-#         end
-#     end
-#     update_limits!(d[:subplot], series, is3d(series) ? (:x,:y,:z) : (:x,:y))
-# end
-
-
 # --------------------------------------------------------------------------
 
 function py_set_lims(ax, axis::Axis)
@@ -927,7 +835,7 @@ end
 function py_set_ticks(ax, ticks, letter)
     ticks == :auto && return
     axis = ax[Symbol(letter,"axis")]
-    if ticks == :none || ticks == nothing
+    if ticks == :none || ticks == nothing || ticks == false
         kw = KW()
         for dir in (:top,:bottom,:left,:right)
             kw[dir] = kw[Symbol(:label,dir)] = "off"
@@ -1010,9 +918,10 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
     w, h = plt[:size]
     fig = plt.o
     fig[:clear]()
-    fig[:set_size_inches](px2inch(w), px2inch(h), forward = true)
+    dpi = plt[:dpi]
+    fig[:set_size_inches](w/dpi, h/dpi, forward = true)
     fig[:set_facecolor](py_color(plt[:background_color_outside]))
-    fig[:set_dpi](DPI)
+    fig[:set_dpi](dpi)
     
     # resize the window
     PyPlot.plt[:get_current_fig_manager]()[:resize](w, h)
@@ -1050,7 +959,7 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
                 :title
             end
             ax[func][:set_text](sp[:title])
-            ax[func][:set_fontsize](sp[:titlefont].pointsize)
+            ax[func][:set_fontsize](py_dpi_scale(plt, sp[:titlefont].pointsize))
             ax[func][:set_color](py_color(sp[:foreground_color_title]))
             # ax[:set_title](sp[:title], loc = loc)
         end
@@ -1067,9 +976,9 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
             if get(axis.d, :flip, false)
                 ax[Symbol("invert_", letter, "axis")]()
             end
-            ax[axissym][:label][:set_fontsize](axis[:guidefont].pointsize)
+            ax[axissym][:label][:set_fontsize](py_dpi_scale(plt, axis[:guidefont].pointsize))
             for lab in ax[Symbol("get_", letter, "ticklabels")]()
-                lab[:set_fontsize](axis[:tickfont].pointsize)
+                lab[:set_fontsize](py_dpi_scale(plt, axis[:tickfont].pointsize))
                 lab[:set_rotation](axis[:rotation])
             end
             if sp[:grid]
@@ -1106,10 +1015,10 @@ function _update_min_padding!(sp::Subplot{PyPlotBackend})
     # TODO: this should initialize to the margin from sp.attr
     # figure out how much the axis components and title "stick out" from the plot area
     # leftpad = toppad = rightpad = bottompad = 1mm
-    leftpad   = sp[:left_margin]
-    toppad    = sp[:top_margin]
-    rightpad  = sp[:right_margin]
-    bottompad = sp[:bottom_margin]
+    leftpad   = 0mm
+    toppad    = 0mm
+    rightpad  = 0mm
+    bottompad = 0mm
     for bb in (py_bbox_axis(ax, "x"), py_bbox_axis(ax, "y"), py_bbox_title(ax))
         if ispositive(width(bb)) && ispositive(height(bb))
             leftpad   = max(leftpad,   left(plotbb) - left(bb))
@@ -1126,6 +1035,12 @@ function _update_min_padding!(sp::Subplot{PyPlotBackend})
         rightpad = rightpad + sp.attr[:cbar_width]
     end
 
+    # add in the user-specified margin
+    leftpad   += sp[:left_margin]
+    toppad    += sp[:top_margin]
+    rightpad  += sp[:right_margin]
+    bottompad += sp[:bottom_margin]
+
     sp.minpad = (leftpad, toppad, rightpad, bottompad)
 end
 
@@ -1147,28 +1062,13 @@ function py_add_annotations(sp::Subplot{PyPlotBackend}, x, y, val::PlotText)
         horizontalalignment = val.font.halign == :hcenter ? "center" : string(val.font.halign),
         verticalalignment = val.font.valign == :vcenter ? "center" : string(val.font.valign),
         rotation = val.font.rotation * 180 / π,
-        size = val.font.pointsize,
+        size = py_dpi_scale(sp.plt, val.font.pointsize),
         zorder = 999
     )
 end
 
 # -----------------------------------------------------------------
 
-# function _remove_axis(plt::Plot{PyPlotBackend}, isx::Bool)
-#     if isx
-#         plot!(plt, xticks=zeros(0), xlabel="")
-#     else
-#         plot!(plt, yticks=zeros(0), ylabel="")
-#     end
-# end
-#
-# function _expand_limits(lims, plt::Plot{PyPlotBackend}, isx::Bool)
-#     pltlims = plt.o.ax[isx ? :get_xbound : :get_ybound]()
-#     _expand_limits(lims, pltlims)
-# end
-
-# -----------------------------------------------------------------
-
 const _pyplot_legend_pos = KW(
     :right => "right",
     :left => "center left",
@@ -1189,12 +1089,15 @@ function py_add_legend(plt::Plot, sp::Subplot, ax)
         for series in series_list(sp)
             if should_add_to_legend(series)
                 # add a line/marker and a label
-                push!(handles, if series.d[:seriestype] == :histogram
-                    PyPlot.plt[:Line2D]((0,1),(0,0), color=py_fillcolor(series.d), linewidth=4)
+                push!(handles, if series[:seriestype] == :shape
+                    PyPlot.plt[:Line2D]((0,1),(0,0),
+                        color = py_color(cycle(series[:fillcolor],1)),
+                        linewidth = py_dpi_scale(plt, 4)
+                    )
                 else
-                    series.d[:serieshandle][1]
+                    series[:serieshandle][1]
                 end)
-                push!(labels, series.d[:label])
+                push!(labels, series[:label])
             end
         end
 
@@ -1204,7 +1107,7 @@ function py_add_legend(plt::Plot, sp::Subplot, ax)
                 labels,
                 loc = get(_pyplot_legend_pos, leg, "best"),
                 scatterpoints = 1,
-                fontsize = sp[:legendfont].pointsize
+                fontsize = py_dpi_scale(plt, sp[:legendfont].pointsize)
                 # framealpha = 0.6
             )
             leg[:set_zorder](1000)
@@ -1270,14 +1173,14 @@ const _pyplot_mimeformats = Dict(
 for (mime, fmt) in _pyplot_mimeformats
     @eval function _writemime(io::IO, ::MIME{Symbol($mime)}, plt::Plot{PyPlotBackend})
         fig = plt.o
-        fig.o["canvas"][:print_figure](
+        fig.o[:canvas][:print_figure](
             io,
             format=$fmt,
             # bbox_inches = "tight",
             # figsize = map(px2inch, plt[:size]),
-            facecolor = fig.o["get_facecolor"](),
+            facecolor = fig.o[:get_facecolor](),
             edgecolor = "none",
-            dpi = DPI
+            dpi = plt[:dpi]
         )
     end
 end

src/components.jl

@@ -14,13 +14,13 @@ compute_angle(v::P2) = (angle = atan2(v[2], v[1]); angle < 0 ? 2π - angle : ang
 immutable Shape
     x::Vector{Float64}
     y::Vector{Float64}
-    function Shape(x::AVec, y::AVec)
-        if x[1] != x[end] || y[1] != y[end]
-            new(vcat(x, x[1]), vcat(y, y[1]))
-        else
-            new(x, y)
-        end
-    end
+    # function Shape(x::AVec, y::AVec)
+    #     # if x[1] != x[end] || y[1] != y[end]
+    #     #     new(vcat(x, x[1]), vcat(y, y[1]))
+    #     # else
+    #         new(x, y)
+    #     end
+    # end
 end
 Shape(verts::AVec) = Shape(unzip(verts)...)
 
@@ -399,8 +399,8 @@ Base.Array(surf::Surface) = surf.surf
 for f in (:length, :size)
   @eval Base.$f(surf::Surface, args...) = $f(surf.surf, args...)
 end
-Base.copy(surf::Surface) = Surface(copy(surf.surf))
-Base.eltype(surf::Surface) = eltype(surf.surf)
+Base.copy(surf::Surface) = Surface{typeof(surf.surf)}(copy(surf.surf))
+Base.eltype{T}(surf::Surface{T}) = eltype(T)
 
 function expand_extrema!(a::Axis, surf::Surface)
     ex = a[:extrema]

src/deprecated/colors.jl

@@ -1,10 +1,38 @@
 
 abstract ColorScheme
 
+Base.getindex(scheme::ColorScheme, i::Integer) = getColor(scheme, i)
+
+export
+    cgrad
+
+cgrad() = default_gradient()
+
+function cgrad(arg, values = nothing; alpha = nothing, scale = :identity)
+    colors = ColorGradient(arg, alpha=alpha).colors
+    values = if values != nothing
+        values
+    elseif scale in (:log, :log10)
+        log10(linspace(1,10,30))
+    elseif scale == :log2
+        log2(linspace(1,2,30))
+    elseif scale == :ln
+        log(linspace(1,pi,30))
+    elseif scale in (:exp, :exp10)
+        (exp10(linspace(0,1,30)) - 1) / 9
+    else
+        linspace(0, 1, length(colors))
+    end
+    ColorGradient(colors, values)
+end
+
+# --------------------------------------------------------------
+
 getColor(scheme::ColorScheme) = getColor(scheme, 1)
 getColorVector(scheme::ColorScheme) = [getColor(scheme)]
 
 colorscheme(scheme::ColorScheme) = scheme
+colorscheme(s::AbstractString; kw...) = colorscheme(Symbol(s); kw...)
 colorscheme(s::Symbol; kw...) = haskey(_gradients, s) ? ColorGradient(s; kw...) : ColorWrapper(convertColor(s); kw...)
 colorscheme{T<:Real}(s::Symbol, vals::AVec{T}; kw...) = ColorGradient(s, vals; kw...)
 colorscheme(cs::AVec, vs::AVec; kw...) = ColorGradient(cs, vs; kw...)
@@ -28,10 +56,10 @@ convertColor(b::Bool) = b ? RGBA(0,0,0,1) : RGBA(0,0,0,0)
 
 function convertColor(c, α::Real)
   c = convertColor(c)
-  RGBA(RGB(c), α)
+  RGBA(RGB(getColor(c)), α)
 end
 convertColor(cs::AVec, α::Real) = map(c -> convertColor(c, α), cs)
-convertColor(c, α::@compat(Void)) = convertColor(c)
+convertColor(c, α::Void) = convertColor(c)
 
 # backup... try to convert
 getColor(c) = convertColor(c)
@@ -51,7 +79,7 @@ end
 
 # --------------------------------------------------------------
 
-const _rainbowColors = [colorant"blue", colorant"purple", colorant"green", colorant"orange", colorant"red"]
+const _rainbowColors = [colorant"purple", colorant"blue", colorant"green", colorant"orange", colorant"red"]
 const _testColors = [colorant"darkblue", colorant"blueviolet",  colorant"darkcyan",colorant"green",
                      darken(colorant"yellow",0.3), colorant"orange", darken(colorant"red",0.2)]
 
@@ -103,6 +131,12 @@ immutable ColorGradient <: ColorScheme
   end
 end
 
+
+
+Base.getindex(cs::ColorGradient, i::Integer) = getColor(cs, i)
+Base.getindex(cs::ColorGradient, z::Number) = getColorZ(cs, z)
+
+
 # create a gradient from a symbol (blues, reds, etc) and vector of boundary values
 function ColorGradient{T<:Real}(s::Symbol, vals::AVec{T} = 0:0; kw...)
   haskey(_gradients, s) || error("Invalid gradient symbol.  Choose from: ", sort(collect(keys(_gradients))))
@@ -187,7 +221,7 @@ immutable ColorZFunction <: ColorScheme
   f::Function
 end
 
-getColorZ(scheme::ColorFunction, z::Real) = scheme.f(z)
+getColorZ(scheme::ColorZFunction, z::Real) = scheme.f(z)
 
 # --------------------------------------------------------------
 
@@ -213,6 +247,7 @@ ColorWrapper(s::Symbol; alpha = nothing) = ColorWrapper(convertColor(parse(Color
 
 getColor(scheme::ColorWrapper, idx::Int) = scheme.c
 getColorZ(scheme::ColorWrapper, z::Real) = scheme.c
+convertColor(c::ColorWrapper, α::Void) = c.c
 
 # --------------------------------------------------------------
 

src/deprecated/series_args.jl

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

src/examples.jl

@@ -221,12 +221,6 @@ PlotExample("Contours",
         p2 = contour(x, y, Z)
         plot(p1, p2)
     end)]
-    # [:(begin
-    #     x = 1:0.3:20
-    #     y = x
-    #     f(x,y) = sin(x)+cos(y)
-    #     contour(x, y, f, fill=true)
-    # end)]
 ),
 
 PlotExample("Pie",
@@ -303,8 +297,8 @@ PlotExample("Boxplot and Violin series recipes",
     [:(begin
         import RDatasets
         singers = RDatasets.dataset("lattice", "singer")
-        violin(singers, :VoicePart, :Height, marker = (0.2, :blue, stroke(0)))
-        boxplot!(singers, :VoicePart, :Height, marker = (0.3, :orange, stroke(2)))
+        violin(singers, :VoicePart, :Height, line = 0, fill = (0.2, :blue))
+        boxplot!(singers, :VoicePart, :Height, line = (2,:black), fill = (0.3, :orange))
     end)]
 )
 

src/layouts.jl

@@ -101,19 +101,46 @@ end
 
 Base.show(io::IO, layout::AbstractLayout) = print(io, "$(typeof(layout))$(size(layout))")
 
+make_measure_hor(n::Number) = n * w
+make_measure_hor(m::Measure) = m
+
+make_measure_vert(n::Number) = n * h
+make_measure_vert(m::Measure) = m
+
+
+function bbox(x, y, w, h, oarg1::Symbol, originargs::Symbol...)
+    oargs = vcat(oarg1, originargs...)
+    orighor = :left
+    origver = :top
+    for oarg in oargs
+        if oarg in (:left, :right)
+            orighor = oarg
+        elseif oarg in (:top, :bottom)
+            origver = oarg
+        else
+            warn("Unused origin arg in bbox construction: $oarg")
+        end
+    end
+    bbox(x, y, w, h; h_anchor = orighor, v_anchor = origver)
+end
+
 # create a new bbox
-function bbox(x, y, w, h; h_anchor = :left, v_anchor = :top)
+function bbox(x, y, width, height; h_anchor = :left, v_anchor = :top)
+    x = make_measure_hor(x)
+    y = make_measure_vert(y)
+    width = make_measure_hor(width)
+    height = make_measure_vert(height)
     left = if h_anchor == :left
         x
     else
-        x - w * (h_anchor == :right ? 1.0 : 0.5)
+        1w - x - width 
     end
     top = if v_anchor == :top
         y
     else
-        y - h * (v_anchor == :bottom ? 1.0 : 0.5)
+        1h - y - height 
     end
-    BoundingBox(left, top, w, h)
+    BoundingBox(left, top, width, height)
 end
 
 # this is the available area for drawing everything in this layout... as percentages of total canvas
@@ -664,6 +691,16 @@ function link_axes!(layout::GridLayout, link::Symbol)
             link_axes!(layout.grid[r,:], :yaxis)
         end
     end
+    if link == :square
+        sps = filter(l -> isa(l, Subplot), layout.grid)
+        if !isempty(sps)
+            base_axis = sps[1][:xaxis]
+            for sp in sps
+                link_axes!(base_axis, sp[:xaxis])
+                link_axes!(base_axis, sp[:yaxis])
+            end
+        end
+    end
     if link == :all
         link_axes!(layout.grid, :xaxis)
         link_axes!(layout.grid, :yaxis)

src/output.jl

@@ -149,6 +149,12 @@ end
 
 # for writing to io streams... first prepare, then callback
 for mime in keys(_mimeformats)
+    @eval function _writemime(io::IO, m, plt::Plot)
+        warn("_writemime is not defined for this backend. m=", string(m))
+    end
+    @eval function _display(plt::Plot)
+        warn("_display is not defined for this backend.")
+    end
     @eval function Base.writemime(io::IO, m::MIME{Symbol($mime)}, plt::Plot)
         prepare_output(plt)
         _writemime(io, m, plt)
@@ -222,6 +228,11 @@ function setup_ijulia()
                 global _ijulia_output
                 Dict{Compat.ASCIIString, ByteString}(_ijulia_output[1] => sprint(writemime, _ijulia_output[1], plt))
             end
+
+            # default text/plain passes to html... handles Interact issues
+            function Base.writemime(io::IO, m::MIME"text/plain", plt::Plot)
+                writemime(io, MIME("text/html"), plt)
+            end
         end
         set_ijulia_output("text/html")
     end
@@ -237,10 +248,11 @@ function setup_atom()
         # @eval import Atom, Media
         @eval import Atom
 
-        # connects the render function
-        for T in (GadflyBackend,ImmerseBackend,PyPlotBackend,GRBackend)
-            Atom.Media.media(Plot{T}, Atom.Media.Plot)
-        end
+        # # connects the render function
+        # for T in (GadflyBackend,ImmerseBackend,PyPlotBackend,GRBackend)
+        #     Atom.Media.media(Plot{T}, Atom.Media.Plot)
+        # end
+        Atom.Media.media(Plot, Atom.Media.Graphical)
         # Atom.Media.media{T <: Union{GadflyBackend,ImmerseBackend,PyPlotBackend,GRBackend}}(Plot{T}, Atom.Media.Plot)
 
         # Atom.displaysize(::Plot) = (535, 379)
@@ -248,9 +260,15 @@ function setup_atom()
 
         # this is like "display"... sends an html div with the plot to the PlotPane
         function Atom.Media.render(pane::Atom.PlotPane, plt::Plot)
+            @show "here"
             Atom.Media.render(pane, Atom.div(Atom.d(), Atom.HTML(stringmime(MIME("text/html"), plt))))
         end
 
+        # # force text/plain to output to the PlotPane
+        # function Base.writemime(io::IO, ::MIME"text/plain", plt::Plot)
+        #     # writemime(io::IO, MIME("text/html"), plt)
+        #     Atom.Media.render(pane)
+        # end
 
         # function Atom.Media.render(pane::Atom.PlotPane, plt::Plot{PlotlyBackend})
         #     html = Media.render(pane, Atom.div(Atom.d(), Atom.HTML(stringmime(MIME("text/html"), plt))))

src/pipeline.jl

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

src/plot.jl

@@ -49,7 +49,7 @@ function plot(args...; kw...)
     # create an empty Plot then process
     plt = Plot()
     # plt.user_attr = d
-    _plot!(plt, d, args...)
+    _plot!(plt, d, args)
 end
 
 # build a new plot from existing plots
@@ -105,22 +105,11 @@ function plot(plt1::Plot, plts_tail::Plot...; kw...)
         end
     end
 
-    # # just in case the backend needs to set up the plot (make it current or something)
-    # _prepare_plot_object(plt)
-
     # first apply any args for the subplots
     for (idx,sp) in enumerate(plt.subplots)
-        _update_subplot_args(plt, sp, d, idx, remove_pair = false)
+        _update_subplot_args(plt, sp, d, idx, false)
     end
 
-    # # now we can get rid of the axis keys without a letter
-    # for k in keys(_axis_defaults)
-    #     delete!(d, k)
-    #     for letter in (:x,:y,:z)
-    #         delete!(d, Symbol(letter,k))
-    #     end
-    # end
-
     # do we need to link any axes together?
     link_axes!(plt.layout, plt[:link])
 
@@ -150,341 +139,61 @@ function plot!(plt::Plot, args...; kw...)
     d = KW(kw)
     preprocessArgs!(d)
     # merge!(plt.user_attr, d)
-    _plot!(plt, d, args...)
-end
-
-function strip_first_letter(s::Symbol)
-    str = string(s)
-    str[1:1], Symbol(str[2:end])
-end
-
-
-# this method recursively applies series recipes when the seriestype is not supported
-# natively by the backend
-function _apply_series_recipe(plt::Plot, d::KW)
-    st = d[:seriestype]
-    # @show st
-    if st in supported_types()
-
-        # getting ready to add the series... last update to subplot from anything
-        # that might have been added during series recipes
-        sp = d[:subplot]
-        sp_idx = get_subplot_index(plt, sp)
-        _update_subplot_args(plt, sp, d, sp_idx)
-
-        # do we want to override the series type?
-        if !is3d(st) && d[:z] != nothing && (size(d[:x]) == size(d[:y]) == size(d[:z]))
-            st = d[:seriestype] = (st == :scatter ? :scatter3d : :path3d)
-        end
-
-        # change to a 3d projection for this subplot?
-        if is3d(st)
-            sp.attr[:projection] = "3d"
-        end
-
-        # initialize now that we know the first series type
-        if !haskey(sp.attr, :init)
-            _initialize_subplot(plt, sp)
-            sp.attr[:init] = true
-        end
-
-        # strip out series annotations (those which are based on series x/y coords)
-        # and add them to the subplot attr
-        sp_anns = annotations(sp[:annotations])
-        anns = annotations(pop!(d, :series_annotations, []))
-        if length(anns) > 0
-            x, y = d[:x], d[:y]
-            nx, ny, na = map(length, (x,y,anns))
-            n = max(nx, ny, na)
-            anns = [(x[mod1(i,nx)], y[mod1(i,ny)], text(anns[mod1(i,na)])) for i=1:n]
-        end
-        sp.attr[:annotations] = vcat(sp_anns, anns)
-
-        # adjust extrema and discrete info
-        if st == :image
-            w, h = size(d[:z])
-            expand_extrema!(sp[:xaxis], (0,w))
-            expand_extrema!(sp[:yaxis], (0,h))
-            sp[:yaxis].d[:flip] = true
-        elseif !(st in (:pie, :histogram, :histogram2d))
-            expand_extrema!(sp, d)
-        end
-
-
-        # add the series!
-        warnOnUnsupported_args(plt.backend, d)
-        warnOnUnsupported(plt.backend, d)
-        series = Series(d)
-        push!(plt.series_list, series)
-        # @show series
-        
-        _series_added(plt, series)
-
-    else
-        # get a sub list of series for this seriestype
-        datalist = try
-            RecipesBase.apply_recipe(d, Val{st}, d[:x], d[:y], d[:z])
-        catch
-            warn("Exception during apply_recipe(Val{$st}, ...) with types ($(typeof(d[:x])), $(typeof(d[:y])), $(typeof(d[:z])))")
-            rethrow()
-        end
-
-        # assuming there was no error, recursively apply the series recipes
-        for data in datalist
-            if isa(data, RecipeData)
-                _apply_series_recipe(plt, data.d)
-            else
-                warn("Unhandled recipe: $(data)")
-                break
-            end
-        end
-    end
+    _plot!(plt, d, args)
 end
 
+# -------------------------------------------------------------------------------
 
 # this is the core plotting function.  recursively apply recipes to build
 # a list of series KW dicts.
 # note: at entry, we only have those preprocessed args which were passed in... no default values yet
-function _plot!(plt::Plot, d::KW, args...)
-    # d = plt.user_attr
-    d[:plot_object] = plt
+function _plot!(plt::Plot, d::KW, args::Tuple)
+    # d[:plot_object] = plt
 
-    # the grouping mechanism is a recipe on a GroupBy object
-    # we simply add the GroupBy object to the front of the args list to allow
-    # the recipe to be applied
-    if haskey(d, :group)
-        args = (extractGroupArgs(d[:group], args...), args...)
-    end
+    # --------------------------------
+    # "USER RECIPES"
+    # --------------------------------
+
+    kw_list = _process_userrecipes(plt, d, args)
 
 
-    # for plotting recipes, swap out the args and update the parameter dictionary
-    # we are keeping a queue of series that still need to be processed.
-    # each pass through the loop, we pop one off and apply the recipe.
-    # the recipe will return a list a Series objects... the ones that are
-    # finished (no more args) get added to the kw_list, and the rest go into the queue
-    # for processing.
+    # --------------------------------
+    # "PLOT RECIPES"
+    # --------------------------------
+
+    # "plot recipe", which acts like a series type, and is processed before
+    # the plot layout is created, which allows for setting layouts and other plot-wide attributes.
+    # we get inputs which have been fully processed by "user recipes" and "type recipes",
+    # so we can expect standard vectors, surfaces, etc.  No defaults have been set yet.
+    still_to_process = kw_list
     kw_list = KW[]
-    still_to_process = isempty(args) ? [] : [RecipeData(copy(d), args)]
     while !isempty(still_to_process)
-
-        # grab the first in line to be processed and pass it through apply_recipe
-        # to generate a list of RecipeData objects (data + attributes)
-        next_series = shift!(still_to_process)
-        for recipedata in RecipesBase.apply_recipe(next_series.d, next_series.args...)
-
-            # recipedata should be of type RecipeData.  if it's not then the inputs must not have been fully processed by recipes
-            if !(typeof(recipedata) <: RecipeData)
-                error("Inputs couldn't be processed... expected RecipeData but got: $recipedata")
-            end
-
-            if isempty(recipedata.args)
-                # when the arg tuple is empty, that means there's nothing left to recursively
-                # process... finish up and add to the kw_list
-                kw = recipedata.d
-                _add_markershape(kw)
-
-                # if there was a grouping, filter the data here
-                _filter_input_data!(kw)
-
-                # map marker_z if it's a Function
-                if isa(get(kw, :marker_z, nothing), Function)
-                    # TODO: should this take y and/or z as arguments?
-                    kw[:marker_z] = map(kw[:marker_z], kw[:x], kw[:y], kw[:z])
-                end
-
-                # map line_z if it's a Function
-                if isa(get(kw, :line_z, nothing), Function)
-                    kw[:line_z] = map(kw[:line_z], kw[:x], kw[:y], kw[:z])
-                end
-
-                # convert a ribbon into a fillrange
-                if get(kw, :ribbon, nothing) != nothing
-                    make_fillrange_from_ribbon(kw)
-                end
-
-                # add the plot index
-                plt.n += 1
-                kw[:series_plotindex] = plt.n
-
-                # check that the backend will support the command and add it to the list
-                warnOnUnsupported_scales(plt.backend, kw)
-                push!(kw_list, kw)
-
-                # handle error bars by creating new recipedata data... these will have
-                # the same recipedata index as the recipedata they are copied from
-                for esym in (:xerror, :yerror)
-                    if get(d, esym, nothing) != nothing
-                        # we make a copy of the KW and apply an errorbar recipe
-                        errkw = copy(kw)
-                        errkw[:seriestype] = esym
-                        errkw[:label] = ""
-                        errkw[:primary] = false
-                        push!(kw_list, errkw)
-                    end
-                end
-
-                # handle smoothing by adding a new series
-                if get(d, :smooth, false)
-                    x, y = kw[:x], kw[:y]
-                    β, α = convert(Matrix{Float64}, [x ones(length(x))]) \ convert(Vector{Float64}, y)
-                    sx = [minimum(x), maximum(x)]
-                    sy = β * sx + α
-                    push!(kw_list, merge(copy(kw), KW(
-                        :seriestype => :path,
-                        :x => sx,
-                        :y => sy,
-                        :fillrange => nothing,
-                        :label => "",
-                        :primary => false,
-                    )))
-                end
-
-            else
-                # args are non-empty, so there's still processing to do... add it back to the queue
-                push!(still_to_process, recipedata)
-            end
-        end
+        next_kw = shift!(still_to_process)
+        _process_plotrecipe(plt, next_kw, kw_list, still_to_process)
     end
 
-    # don't allow something else to handle it
-    d[:smooth] = false
-
-    # merge in anything meant for plot/subplot/axis
-    for kw in kw_list
-        for (k,v) in kw
-            for defdict in (_plot_defaults,)
-                            # _subplot_defaults,
-                            # _axis_defaults,
-                            # _axis_defaults_byletter)
-                if haskey(defdict, k)
-                    d[k] = pop!(kw, k)
-                end
-            end
-        end
-    end
-
-    # TODO: init subplots here
-    _update_plot_args(plt, d)
-    if !plt.init
-        plt.o = _create_backend_figure(plt)
-        # DD(d)
-
-        # create the layout and subplots from the inputs
-        plt.layout, plt.subplots, plt.spmap = build_layout(plt.attr)
-        for (idx,sp) in enumerate(plt.subplots)
-            sp.plt = plt
-            sp.attr[:subplot_index] = idx
-        end
-
-        plt.init = true
-    end
-
-
-    # handle inset subplots
-    insets = plt[:inset_subplots]
-    if insets != nothing
-        for inset in insets
-            parent, bb = is_2tuple(inset) ? inset : (nothing, inset)
-            P = typeof(parent)
-            if P <: Integer
-                parent = plt.subplots[parent]
-            elseif P == Symbol
-                parent = plt.spmap[parent]
-            else
-                parent = plt.layout
-            end
-            sp = Subplot(backend(), parent=parent)
-            sp.plt = plt
-            sp.attr[:relative_bbox] = bb
-            push!(plt.subplots, sp)
-            sp.attr[:subplot_index] = length(plt.subplots)
-            push!(plt.inset_subplots, sp)
-        end
-    end
-
-    # we'll keep a map of subplot to an attribute override dict.
-    # any series which belong to that subplot
-    sp_attrs = Dict{Subplot,Any}()
-    for kw in kw_list
-        # get the Subplot object to which the series belongs
-        sp = get(kw, :subplot, :auto)
-        command_idx = kw[:series_plotindex] - kw_list[1][:series_plotindex] + 1
-        sp = if sp == :auto
-            cycle(plt.subplots, command_idx)
-            # mod1(command_idx, length(plt.subplots))
-        else
-            slice_arg(sp, command_idx)
-        end
-        sp = kw[:subplot] = get_subplot(plt, sp)
-        # idx = get_subplot_index(plt, sp)
-        attr = KW()
-
-        for (k,v) in kw
-            for defdict in (_subplot_defaults,
-                            _axis_defaults,
-                            _axis_defaults_byletter)
-                if haskey(defdict, k)
-                    attr[k] = pop!(kw, k)
-                end
-            end
-        end
-        sp_attrs[sp] = attr
-    end
-
-
-
-    # # just in case the backend needs to set up the plot (make it current or something)
-    # _prepare_plot_object(plt)
-
-    # first apply any args for the subplots
-    for (idx,sp) in enumerate(plt.subplots)
-        # if we picked up any subplot-specific overrides, merge them here
-        attr = merge(d, get(sp_attrs, sp, KW()))
-        # DD(attr, "sp$idx")
-        _update_subplot_args(plt, sp, attr, idx, remove_pair = false)
-    end
-
-
-
-    # do we need to link any axes together?
-    link_axes!(plt.layout, plt[:link])
+    # --------------------------------
+    # Plot/Subplot/Layout setup
+    # --------------------------------
+    _plot_setup(plt, d, kw_list)
+    _subplot_setup(plt, d, kw_list)
 
     # !!! note: At this point, kw_list is fully decomposed into individual series... one KW per series.          !!!
     # !!!       The next step is to recursively apply series recipes until the backend supports that series type !!!
 
-    # this is it folks!
-    # TODO: we probably shouldn't use i for tracking series index, but rather explicitly track it in recipes
+    # --------------------------------
+    # "SERIES RECIPES"
+    # --------------------------------
+    
     for kw in kw_list
-        command_idx = kw[:series_plotindex] - kw_list[1][:series_plotindex] + 1
+        sp::Subplot = kw[:subplot]
+        # idx = get_subplot_index(plt, sp)
 
-        # # get the Subplot object to which the series belongs
-        # sp = get(kw, :subplot, :auto)
-        # sp = if sp == :auto
-        #     mod1(i,length(plt.subplots))
-        # else
-        #     slice_arg(sp, i)
-        # end
-        # sp = kw[:subplot] = get_subplot(plt, sp)
-        sp = kw[:subplot]
-        idx = get_subplot_index(plt, sp)
-
-        # # strip out series annotations (those which are based on series x/y coords)
-        # # and add them to the subplot attr
-        # sp_anns = annotations(sp[:annotations])
-        # anns = annotations(pop!(kw, :series_annotations, []))
-        # if length(anns) > 0
-        #     x, y = kw[:x], kw[:y]
-        #     nx, ny, na = map(length, (x,y,anns))
-        #     n = max(nx, ny, na)
-        #     anns = [(x[mod1(i,nx)], y[mod1(i,ny)], text(anns[mod1(i,na)])) for i=1:n]
-        # end
-        # sp.attr[:annotations] = vcat(sp_anns, anns)
-
-        # we update subplot args in case something like the color palatte is part of the recipe
-        _update_subplot_args(plt, sp, kw, idx)
+        # # we update subplot args in case something like the color palatte is part of the recipe
+        # _update_subplot_args(plt, sp, kw, idx, true)
 
         # set default values, select from attribute cycles, and generally set the final attributes
-        _add_defaults!(kw, plt, sp, command_idx)
+        _add_defaults!(kw, plt, sp, command_idx(kw_list,kw))
 
         # now we have a fully specified series, with colors chosen.   we must recursively handle
         # series recipes, which dispatch on seriestype.  If a backend does not natively support a seriestype,
@@ -492,29 +201,22 @@ function _plot!(plt::Plot, d::KW, args...)
         # For example, a histogram is just a bar plot with binned data, a bar plot is really a filled step plot,
         # and a step plot is really just a path.  So any backend that supports drawing a path will implicitly
         # be able to support step, bar, and histogram plots (and any recipes that use those components).
-        _apply_series_recipe(plt, kw)
+        _process_seriesrecipe(plt, kw)
     end
 
+    # --------------------------------
+
     current(plt)
 
-    # note: lets ignore the show param and effectively use the semicolon at the end of the REPL statement
-    # # do we want to show it?
-    # if haskey(d, :show) && d[:show]
-    if get(d, :show, default(:show))
-        gui()
+    # do we want to force display?
+    if plt[:show]
+        gui(plt)
     end
 
     plt
 end
 
 
-function _replace_linewidth(d::KW)
-    # get a good default linewidth... 0 for surface and heatmaps
-    if get(d, :linewidth, :auto) == :auto
-        d[:linewidth] = (get(d, :seriestype, :path) in (:surface,:heatmap,:image) ? 0 : 1)
-    end
-end
-
 # we're getting ready to display/output.  prep for layout calcs, then update
 # the plot object after
 function prepare_output(plt::Plot)
@@ -546,75 +248,15 @@ function prepared_object(plt::Plot)
 end
 
 # --------------------------------------------------------------------
+# plot to a Subplot
 
-# function get_indices(orig, labels)
-#     Int[findnext(labels, l, 1) for l in orig]
-# end
-
-# # TODO: remove?? this is the old way of handling discrete data... should be
-# # replaced by the Axis type and logic
-# function setTicksFromStringVector(plt::Plot, d::KW, di::KW, letter)
-#     sym = Symbol(letter)
-#     ticksym = Symbol(letter * "ticks")
-#     pargs = plt.attr
-#     v = di[sym]
-#
-#     # do we really want to do this?
-#     typeof(v) <: AbstractArray || return
-#     isempty(v) && return
-#     trueOrAllTrue(_ -> typeof(_) <: AbstractString, v) || return
-#
-#     # compute the ticks and labels
-#     ticks, labels = if ticksType(pargs[ticksym]) == :ticks_and_labels
-#         # extend the existing ticks and labels. only add to labels if they're new!
-#         ticks, labels = pargs[ticksym]
-#         newlabels = filter(_ -> !(_ in labels), unique(v))
-#         newticks = if isempty(ticks)
-#             collect(1:length(newlabels))
-#         else
-#             maximum(ticks) + collect(1:length(newlabels))
-#         end
-#         ticks = vcat(ticks, newticks)
-#         labels = vcat(labels, newlabels)
-#         ticks, labels
-#     else
-#         # create new ticks and labels
-#         newlabels = unique(v)
-#         collect(1:length(newlabels)), newlabels
-#     end
-#
-#     d[ticksym] = ticks, labels
-#     plt.attr[ticksym] = ticks, labels
-#
-#     # add an origsym field so that later on we can re-compute the x vector if ticks change
-#     origsym = Symbol(letter * "orig")
-#     di[origsym] = v
-#     di[sym] = get_indices(v, labels)
-#
-#     # loop through existing plt.seriesargs and adjust indices if there is an origsym key
-#     for sargs in plt.seriesargs
-#         if haskey(sargs, origsym)
-#             # TODO: might need to call the setindex function instead to trigger a plot update for some backends??
-#             sargs[sym] = get_indices(sargs[origsym], labels)
-#         end
-#     end
-# end
-
-
-# --------------------------------------------------------------------
-
-
-
-# --------------------------------------------------------------------
-
-# function Base.copy(plt::Plot)
-#     backend(plt.backend)
-#     plt2 = plot(; plt.attr...)
-#     for sargs in plt.seriesargs
-#         sargs = filter((k,v) -> haskey(_series_defaults,k), sargs)
-#         plot!(plt2; sargs...)
-#     end
-#     plt2
-# end
+function plot(sp::Subplot, args...; kw...)
+    plt = sp.plt
+    plot(plt, args...; kw..., subplot = findfirst(plt.subplots, sp))
+end
+function plot!(sp::Subplot, args...; kw...)
+    plt = sp.plt
+    plot!(plt, args...; kw..., subplot = findfirst(plt.subplots, sp))
+end
 
 # --------------------------------------------------------------------

src/precompile.jl

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

src/recipes.jl

@@ -1,10 +1,5 @@
 
 
-# TODO: there should be a distinction between an object that will manage a full plot, vs a component of a plot.
-# the PlotRecipe as currently implemented is more of a "custom component"
-# a recipe should fully describe the plotting command(s) and call them, likewise for updating.
-#   actually... maybe those should explicitly derive from AbstractPlot???
-
 
 """
 You can easily define your own plotting recipes with convenience methods:
@@ -98,92 +93,59 @@ end
 
 # ----------------------------------------------------------------------------------
 
-abstract PlotRecipe
-
-getRecipeXY(recipe::PlotRecipe) = Float64[], Float64[]
-getRecipeArgs(recipe::PlotRecipe) = ()
-
-plot(recipe::PlotRecipe, args...; kw...) = plot(getRecipeXY(recipe)..., args...; getRecipeArgs(recipe)..., kw...)
-plot!(recipe::PlotRecipe, args...; kw...) = plot!(getRecipeXY(recipe)..., args...; getRecipeArgs(recipe)..., kw...)
-plot!(plt::Plot, recipe::PlotRecipe, args...; kw...) = plot!(getRecipeXY(recipe)..., args...; getRecipeArgs(recipe)..., kw...)
 
 num_series(x::AMat) = size(x,2)
 num_series(x) = 1
 
 
-# # if it's not a recipe, just do nothing and return the args
-# function RecipesBase.apply_recipe(d::KW, args...; issubplot=false)
-#     if issubplot && !isempty(args) && !haskey(d, :n) && !haskey(d, :layout)
-#         # put in a sensible default
-#         d[:n] = maximum(map(num_series, args))
+RecipesBase.apply_recipe{T}(d::KW, ::Type{T}, plt::Plot) = throw(MethodError("Unmatched plot recipe: $T"))
+
+
+# # TODO: remove when StatPlots is ready
+# if is_installed("DataFrames")
+#     @eval begin
+#         import DataFrames
+
+#         # if it's one symbol, set the guide and return the column
+#         function handle_dfs(df::DataFrames.AbstractDataFrame, d::KW, letter, sym::Symbol)
+#             get!(d, Symbol(letter * "guide"), string(sym))
+#             collect(df[sym])
+#         end
+
+#         # if it's an array of symbols, set the labels and return a Vector{Any} of columns
+#         function handle_dfs(df::DataFrames.AbstractDataFrame, d::KW, letter, syms::AbstractArray{Symbol})
+#             get!(d, :label, reshape(syms, 1, length(syms)))
+#             Any[collect(df[s]) for s in syms]
+#         end
+
+#         # for anything else, no-op
+#         function handle_dfs(df::DataFrames.AbstractDataFrame, d::KW, letter, anything)
+#             anything
+#         end
+
+#         # handle grouping by DataFrame column
+#         function extractGroupArgs(group::Symbol, df::DataFrames.AbstractDataFrame, args...)
+#             extractGroupArgs(collect(df[group]))
+#         end
+
+#         # if a DataFrame is the first arg, lets swap symbols out for columns
+#         @recipe function f(df::DataFrames.AbstractDataFrame, args...)
+#             # if any of these attributes are symbols, swap out for the df column
+#             for k in (:fillrange, :line_z, :marker_z, :markersize, :ribbon, :weights, :xerror, :yerror)
+#                 if haskey(d, k) && isa(d[k], Symbol)
+#                     d[k] = collect(df[d[k]])
+#                 end
+#             end
+
+#             # return a list of new arguments
+#             tuple(Any[handle_dfs(df, d, (i==1 ? "x" : i==2 ? "y" : "z"), arg) for (i,arg) in enumerate(args)]...)
+#         end
 #     end
-#     args
 # end
 
 
-if is_installed("DataFrames")
-    @eval begin
-        import DataFrames
-        DFS = Union{Symbol, AbstractArray{Symbol}}
-
-        function handle_dfs(df::DataFrames.AbstractDataFrame, d::KW, letter, dfs::DFS)
-            if isa(dfs, Symbol)
-                get!(d, Symbol(letter * "guide"), string(dfs))
-                collect(df[dfs])
-            else
-                get!(d, :label, reshape(dfs, 1, length(dfs)))
-                Any[collect(df[s]) for s in dfs]
-            end
-        end
-
-        function extractGroupArgs(group::Symbol, df::DataFrames.AbstractDataFrame, args...)
-            extractGroupArgs(collect(df[group]))
-        end
-
-
-        function handle_group(df::DataFrames.AbstractDataFrame, d::KW)
-            if haskey(d, :group)
-                g = d[:group]
-                if isa(g, Symbol)
-                    d[:group] = collect(df[g])
-                end
-            end
-        end
-
-        @recipe function f(df::DataFrames.AbstractDataFrame, sy::DFS)
-            handle_group(df, d)
-            handle_dfs(df, d, "y", sy)
-        end
-
-        @recipe function f(df::DataFrames.AbstractDataFrame, sx::DFS, sy::DFS)
-            handle_group(df, d)
-            x = handle_dfs(df, d, "x", sx)
-            y = handle_dfs(df, d, "y", sy)
-            x, y
-        end
-
-        @recipe function f(df::DataFrames.AbstractDataFrame, sx::DFS, sy::DFS, sz::DFS)
-            handle_group(df, d)
-            x = handle_dfs(df, d, "x", sx)
-            y = handle_dfs(df, d, "y", sy)
-            z = handle_dfs(df, d, "z", sz)
-            x, y, z
-        end
-    end
-end
-
-
 # ---------------------------------------------------------------------------
 
-# """
-# `apply_series_recipe` should take a processed series KW dict and break it up
-# into component parts.  For example, a box plot is made up of `shape` for the
-# boxes, `path` for the lines, and `scatter` for the outliers.
-#
-# Returns a Vector{KW}.
-# """
-# apply_series_recipe(d::KW, st) = KW[d]
-
 
 # for seriestype `line`, need to sort by x values
 @recipe function f(::Type{Val{:line}}, x, y, z)
@@ -198,24 +160,21 @@ end
 end
 @deps line path
 
-# @recipe function f(::Type{Val{:sticks}}, x, y, z)
-#     nx = length(x)
-#     n = 3nx
-#     newx, newy = zeros(n), zeros(n)
-#     for i=1:nx
-#         rng = 3i-2:3i
-#         newx[rng] = x[i]
-#         newy[rng] = [0., y[i], 0.]
-#     end
-#     x := newx
-#     y := newy
-#     seriestype := :path
-#     ()
-# end
-# @deps sticks path
+
+function hvline_limits(axis::Axis)
+    vmin, vmax = axis_limits(axis)
+    if vmin >= vmax
+        if isfinite(vmin)
+            vmax = vmin + 1
+        else
+            vmin, vmax = 0.0, 1.1
+        end
+    end
+    vmin, vmax
+end
 
 @recipe function f(::Type{Val{:hline}}, x, y, z)
-    xmin, xmax = axis_limits(d[:subplot][:xaxis])
+    xmin, xmax = hvline_limits(d[:subplot][:xaxis])
     n = length(y)
     newx = repmat(Float64[xmin, xmax, NaN], n)
     newy = vec(Float64[yi for i=1:3,yi=y])
@@ -227,7 +186,7 @@ end
 @deps hline path
 
 @recipe function f(::Type{Val{:vline}}, x, y, z)
-    ymin, ymax = axis_limits(d[:subplot][:yaxis])
+    ymin, ymax = hvline_limits(d[:subplot][:yaxis])
     n = length(y)
     newx = vec(Float64[yi for i=1:3,yi=y])
     newy = repmat(Float64[ymin, ymax, NaN], n)
@@ -352,15 +311,14 @@ function bezier_value(pts::AVec, t::Real)
 end
 
 # create segmented bezier curves in place of line segments
-@recipe function f(::Type{Val{:curves}}, x, y, z)
+@recipe function f(::Type{Val{:curves}}, x, y, z; npoints = 30)
     args = z != nothing ? (x,y,z) : (x,y)
     newx, newy = zeros(0), zeros(0)
     fr = d[:fillrange]
     newfr = fr != nothing ? zeros(0) : nothing
     newz = z != nothing ? zeros(0) : nothing
-    lz = d[:line_z]
-    newlz = lz != nothing ? zeros(0) : nothing
-    npoints = pop!(d, :npoints, 30)
+    # lz = d[:line_z]
+    # newlz = lz != nothing ? zeros(0) : nothing
 
     # for each line segment (point series with no NaNs), convert it into a bezier curve
     # where the points are the control points of the curve
@@ -375,15 +333,11 @@ end
         if fr != nothing
             nanappend!(newfr, map(t -> bezier_value(cycle(fr,rng), t), ts))
         end
-        if lz != nothing
-            lzrng = cycle(lz, rng) # the line_z's for this segment
-            # @show lzrng, sizeof(lzrng) map(t -> 1+floor(Int, t * (length(rng)-1)), ts)
-            # choose the line_z value of the control point just before this t
-            push!(newlz, 0.0)
-            append!(newlz, map(t -> lzrng[1+floor(Int, t * (length(rng)-1))], ts))
-            # lzrng = vcat()
-            # nanappend!(newlz,   #map(t -> bezier_value(cycle(lz,rng), t), ts))
-        end
+        # if lz != nothing
+        #     lzrng = cycle(lz, rng) # the line_z's for this segment
+        #     push!(newlz, 0.0)
+        #     append!(newlz, map(t -> lzrng[1+floor(Int, t * (length(rng)-1))], ts))
+        # end
     end
 
     x := newx
@@ -397,10 +351,10 @@ end
     if fr != nothing
         fillrange := newfr
     end
-    if lz != nothing
-        line_z := newlz
-        linecolor := (isa(d[:linecolor], ColorGradient) ? d[:linecolor] : default_gradient())
-    end
+    # if lz != nothing
+    #     # line_z := newlz
+    #     linecolor := (isa(d[:linecolor], ColorGradient) ? d[:linecolor] : cgrad())
+    # end
     # Plots.DD(d)
     ()
 end
@@ -411,61 +365,52 @@ end
 # create a bar plot as a filled step function
 @recipe function f(::Type{Val{:bar}}, x, y, z)
     nx, ny = length(x), length(y)
-    edges = if nx == ny
-        # x is centers, calc the edges
-        # TODO: use bar_width, etc
-        midpoints = x
-        halfwidths = diff(midpoints) * 0.5
-        Float64[if i == 1
-            midpoints[1] - halfwidths[1]
-        elseif i == ny+1
-            midpoints[i-1] + halfwidths[i-2]
-        else
-            midpoints[i-1] + halfwidths[i-1]
-        end for i=1:ny+1]
+    axis = d[:subplot][isvertical(d) ? :xaxis : :yaxis]
+    cv = [discrete_value!(axis, xi)[1] for xi=x]
+    x = if nx == ny
+        cv
     elseif nx == ny + 1
-        # x is edges
-        x
+        0.5diff(cv) + cv[1:end-1]
     else
         error("bar recipe: x must be same length as y (centers), or one more than y (edges).\n\t\tlength(x)=$(length(x)), length(y)=$(length(y))")
     end
 
+    # compute half-width of bars
+    bw = d[:bar_width]
+    hw = if bw == nothing
+        0.5mean(diff(x))
+    else
+        Float64[0.5cycle(bw,i) for i=1:length(x)]
+    end
+
     # make fillto a vector... default fills to 0
     fillto = d[:fillrange]
     if fillto == nothing
-        fillto = zeros(1)
-    elseif isa(fillto, Number)
-        fillto = Float64[fillto]
+        fillto = 0
     end
-    nf = length(fillto)
 
-    npts = 3ny + 1
-    heights = y
-    x = zeros(npts)
-    y = zeros(npts)
-    fillrng = zeros(npts)
-
-    # create the path in triplets.  after the first bottom-left coord of the first bar:
-    # add the top-left, top-right, and bottom-right coords for each height
-    x[1] = edges[1]
-    y[1] = fillto[1]
-    fillrng[1] = fillto[1]
+    # create the bar shapes by adding x/y segments
+    xseg, yseg = Segments(), Segments()
     for i=1:ny
-        idx = 3i
-        rng = idx-1:idx+1
-        fi = fillto[mod1(i,nf)]
-        x[rng] = [edges[i], edges[i+1], edges[i+1]]
-        y[rng] = [heights[i], heights[i], fi]
-        fillrng[rng] = [fi, fi, fi]
+        center = x[i]
+        hwi = cycle(hw,i)
+        yi = y[i]
+        fi = cycle(fillto,i)
+        push!(xseg, center-hwi, center-hwi, center+hwi, center+hwi, center-hwi)
+        push!(yseg, yi, fi, fi, yi, yi)
     end
 
-    x := x
-    y := y
-    fillrange := fillrng
-    seriestype := :path
+    # switch back
+    if !isvertical(d)
+        xseg, yseg = yseg, xseg
+    end
+
+    x := xseg.pts
+    y := yseg.pts
+    seriestype := :shape
     ()
 end
-@deps bar path
+@deps bar shape
 
 # ---------------------------------------------------------------------------
 # Histograms
@@ -477,7 +422,7 @@ function calc_edges(v, bins::Integer)
 end
 
 # just pass through arrays
-calc_edges(v, bins::AVec) = v
+calc_edges(v, bins::AVec) = bins
 
 # find the bucket index of this value
 function bucket_index(vi, edges)
@@ -548,7 +493,7 @@ function my_hist_2d(x, y, bins; normed = false, weights = nothing)
     xedges, yedges, counts ./ norm_denom
 end
 
-centers(v::AVec) = v[1] + cumsum(diff(v))
+centers(v::AVec) = 0.5 * (v[1:end-1] + v[2:end])
 
 @recipe function f(::Type{Val{:histogram2d}}, x, y, z)
     xedges, yedges, counts = my_hist_2d(x, y, d[:bins],
@@ -557,6 +502,7 @@ centers(v::AVec) = v[1] + cumsum(diff(v))
     x := centers(xedges)
     y := centers(yedges)
     z := Surface(counts)
+    linewidth := 0
     seriestype := :heatmap
     ()
 end
@@ -578,198 +524,188 @@ end
 
 # note: don't add dependencies because this really isn't a drop-in replacement
 
-# ---------------------------------------------------------------------------
-# Box Plot
+# # TODO: move boxplots and violin plots to StatPlots when it's ready
 
-const _box_halfwidth = 0.4
+# # ---------------------------------------------------------------------------
+# # Box Plot
 
-notch_width(q2, q4, N) = 1.58 * (q4-q2)/sqrt(N)
+# const _box_halfwidth = 0.4
 
-# function apply_series_recipe(d::KW, ::Type{Val{:box}})
-@recipe function f(::Type{Val{:boxplot}}, x, y, z; notch=false, range=1.5)
-    # Plots.dumpdict(d, "box before", true)
+# notch_width(q2, q4, N) = 1.58 * (q4-q2)/sqrt(N)
 
-    # create a list of shapes, where each shape is a single boxplot
-    shapes = Shape[]
-    groupby = extractGroupArgs(x)
-    outliers_y = Float64[]
-    outliers_x = Float64[]
 
-    warning = false
+# @recipe function f(::Type{Val{:boxplot}}, x, y, z; notch=false, range=1.5)
+#     xsegs, ysegs = Segments(), Segments()
+#     glabels = sort(collect(unique(x)))
+#     warning = false
+#     outliers_x, outliers_y = zeros(0), zeros(0)
+#     for (i,glabel) in enumerate(glabels)
+#         # filter y
+#         values = y[filter(i -> cycle(x,i) == glabel, 1:length(y))]
 
-    for (i, glabel) in enumerate(groupby.groupLabels)
+#         # compute quantiles
+#         q1,q2,q3,q4,q5 = quantile(values, linspace(0,1,5))
+        
+#         # notch
+#         n = notch_width(q2, q4, length(values))
 
-        # filter y values
-        values = d[:y][groupby.groupIds[i]]
-        # then compute quantiles
-        q1,q2,q3,q4,q5 = quantile(values, linspace(0,1,5))
-        # notch
-        n = notch_width(q2, q4, length(values))
+#         # warn on inverted notches?
+#         if notch && !warning && ( (q2>(q3-n)) || (q4<(q3+n)) )
+#             warn("Boxplot's notch went outside hinges. Set notch to false.")
+#             warning = true # Show the warning only one time
+#         end
 
-        if notch && !warning && ( (q2>(q3-n)) || (q4<(q3+n)) )
-            warn("Boxplot's notch went outside hinges. Set notch to false.")
-            warning = true # Show the warning only one time
-        end
+#         # make the shape
+#         center = discrete_value!(d[:subplot][:xaxis], glabel)[1]
+#         hw = d[:bar_width] == nothing ? _box_halfwidth : 0.5cycle(d[:bar_width], i)
+#         l, m, r = center - hw, center, center + hw
+        
+#         # internal nodes for notches
+#         L, R = center - 0.5 * hw, center + 0.5 * hw
+        
+#         # outliers
+#         if Float64(range) != 0.0  # if the range is 0.0, the whiskers will extend to the data
+#             limit = range*(q4-q2)
+#             inside = Float64[]
+#             for value in values
+#                 if (value < (q2 - limit)) || (value > (q4 + limit))
+#                     push!(outliers_y, value)
+#                     push!(outliers_x, center)
+#                 else
+#                     push!(inside, value)
+#                 end
+#             end
+#             # change q1 and q5 to show outliers
+#             # using maximum and minimum values inside the limits
+#             q1, q5 = extrema(inside)
+#         end
 
-        # make the shape
-        center = discrete_value!(d[:subplot][:xaxis], glabel)[1]
-        l, m, r = center - _box_halfwidth, center, center + _box_halfwidth
-        # internal nodes for notches
-        L, R = center - 0.5 * _box_halfwidth, center + 0.5 * _box_halfwidth
-        # outliers
-        if Float64(range) != 0.0  # if the range is 0.0, the whiskers will extend to the data
-            limit = range*(q4-q2)
-            inside = Float64[]
-            for value in values
-                if (value < (q2 - limit)) || (value > (q4 + limit))
-                    push!(outliers_y, value)
-                    push!(outliers_x, center)
-                else
-                    push!(inside, value)
-                end
-            end
-            # change q1 and q5 to show outliers
-            # using maximum and minimum values inside the limits
-            q1, q5 = extrema(inside)
-        end
-        # Box
-        xcoords = notch::Bool ? [
-            m, l, r, m, m, NaN,       # lower T
-            l, l, L, R, r, r, l, NaN, # lower box
-            l, l, L, R, r, r, l, NaN, # upper box
-            m, l, r, m, m, NaN,       # upper T
-        ] : [
-            m, l, r, m, m, NaN,         # lower T
-            l, l, r, r, l, NaN,         # lower box
-            l, l, r, r, l, NaN,         # upper box
-            m, l, r, m, m, NaN,         # upper T
-        ]
-        ycoords = notch::Bool ? [
-            q1, q1, q1, q1, q2, NaN,             # lower T
-            q2, q3-n, q3, q3, q3-n, q2, q2, NaN, # lower box
-            q4, q3+n, q3, q3, q3+n, q4, q4, NaN, # upper box
-            q5, q5, q5, q5, q4, NaN,             # upper T
-        ] : [
-            q1, q1, q1, q1, q2, NaN,    # lower T
-            q2, q3, q3, q2, q2, NaN,    # lower box
-            q4, q3, q3, q4, q4, NaN,    # upper box
-            q5, q5, q5, q5, q4, NaN,    # upper T
-        ]
-        push!(shapes, Shape(xcoords, ycoords))
-    end
+#         # Box
+#         if notch
+#             push!(xsegs, m, l, r, m, m)       # lower T
+#             push!(xsegs, l, l, L, R, r, r, l) # lower box
+#             push!(xsegs, l, l, L, R, r, r, l) # upper box
+#             push!(xsegs, m, l, r, m, m)       # upper T
 
-    # d[:plotarg_overrides] = KW(:xticks => (1:length(shapes), groupby.groupLabels))
+#             push!(ysegs, q1, q1, q1, q1, q2)             # lower T
+#             push!(ysegs, q2, q3-n, q3, q3, q3-n, q2, q2) # lower box
+#             push!(ysegs, q4, q3+n, q3, q3, q3+n, q4, q4) # upper box
+#             push!(ysegs, q5, q5, q5, q5, q4)             # upper T
+#         else
+#             push!(xsegs, m, l, r, m, m)         # lower T
+#             push!(xsegs, l, l, r, r, l)         # lower box
+#             push!(xsegs, l, l, r, r, l)         # upper box
+#             push!(xsegs, m, l, r, m, m)         # upper T
 
-    seriestype := :shape
-    # n = length(groupby.groupLabels)
-    # xticks --> (linspace(0.5,n-0.5,n), groupby.groupLabels)
+#             push!(ysegs, q1, q1, q1, q1, q2)    # lower T
+#             push!(ysegs, q2, q3, q3, q2, q2)    # lower box
+#             push!(ysegs, q4, q3, q3, q4, q4)    # upper box
+#             push!(ysegs, q5, q5, q5, q5, q4)    # upper T
+#         end
+#     end
 
-    # clean d
-    pop!(d, :notch)
-    pop!(d, :range)
+#     # Outliers
+#     @series begin
+#         seriestype  := :scatter
+#         markershape := :circle
+#         markercolor := d[:fillcolor]
+#         markeralpha := d[:fillalpha]
+#         markerstrokecolor := d[:linecolor]
+#         markerstrokealpha := d[:linealpha]
+#         x           := outliers_x
+#         y           := outliers_y
+#         primary     := false
+#         ()
+#     end
 
-    # we want to set the fields directly inside series recipes... args are ignored
-    d[:x], d[:y] = Plots.shape_coords(shapes)
+#     seriestype := :shape
+#     x := xsegs.pts
+#     y := ysegs.pts
+#     ()
+# end
+# @deps boxplot shape scatter
 
-    # Outliers
-    @series begin
-        seriestype := :scatter
-        markershape := :circle
-        x := outliers_x
-        y := outliers_y
-        label := ""
-        primary := false
-        ()
-    end
+# # ---------------------------------------------------------------------------
+# # Violin Plot
 
-    () # expects a tuple returned
-end
-@deps boxplot shape scatter
+# const _violin_warned = [false]
+
+# # if the user has KernelDensity installed, use this for violin plots.
+# # otherwise, just use a histogram
+# if is_installed("KernelDensity")
+#     @eval import KernelDensity
+#     @eval function violin_coords(y; trim::Bool=false)
+#         kd = KernelDensity.kde(y, npoints = 200)
+#         if trim
+#             xmin, xmax = extrema(y)
+#             inside = Bool[ xmin <= x <= xmax for x in kd.x]
+#             return(kd.density[inside], kd.x[inside])
+#         end
+#         kd.density, kd.x
+#     end
+# else
+#     @eval function violin_coords(y; trim::Bool=false)
+#         if !_violin_warned[1]
+#             warn("Install the KernelDensity package for best results.")
+#             _violin_warned[1] = true
+#         end
+#         edges, widths = my_hist(y, 10)
+#         centers = 0.5 * (edges[1:end-1] + edges[2:end])
+#         ymin, ymax = extrema(y)
+#         vcat(0.0, widths, 0.0), vcat(ymin, centers, ymax)
+#     end
+# end
+
+
+# @recipe function f(::Type{Val{:violin}}, x, y, z; trim=true)
+#     xsegs, ysegs = Segments(), Segments()
+#     glabels = sort(collect(unique(x)))
+#     for glabel in glabels
+#         widths, centers = violin_coords(y[filter(i -> cycle(x,i) == glabel, 1:length(y))], trim=trim)
+#         isempty(widths) && continue
+
+#         # normalize
+#         widths = _box_halfwidth * widths / maximum(widths)
+
+#         # make the violin
+#         xcenter = discrete_value!(d[:subplot][:xaxis], glabel)[1]
+#         xcoords = vcat(widths, -reverse(widths)) + xcenter
+#         ycoords = vcat(centers, reverse(centers))
+
+#         push!(xsegs, xcoords)
+#         push!(ysegs, ycoords)
+#     end
+
+#     seriestype := :shape
+#     x := xsegs.pts
+#     y := ysegs.pts
+#     ()
+# end
+# @deps violin shape
+
+# # ---------------------------------------------------------------------------
+# # density
+
+# @recipe function f(::Type{Val{:density}}, x, y, z; trim=false)
+#     newx, newy = violin_coords(y, trim=trim)
+#     if isvertical(d)
+#         newx, newy = newy, newx
+#     end
+#     x := newx
+#     y := newy
+#     seriestype := :path
+#     ()
+# end
+# @deps density path
 
 # ---------------------------------------------------------------------------
-# Violin Plot
+# contourf - filled contours
 
-# if the user has KernelDensity installed, use this for violin plots.
-# otherwise, just use a histogram
-if is_installed("KernelDensity")
-    @eval import KernelDensity
-    @eval function violin_coords(y; trim::Bool=false)
-        kd = KernelDensity.kde(y, npoints = 200)
-        if trim
-            xmin, xmax = extrema(y)
-            inside = Bool[ xmin <= x <= xmax for x in kd.x]
-            return(kd.density[inside], kd.x[inside])
-        end
-        kd.density, kd.x
-    end
-else
-    @eval function violin_coords(y; trim::Bool=false)
-        edges, widths = hist(y, 30)
-        centers = 0.5 * (edges[1:end-1] + edges[2:end])
-        ymin, ymax = extrema(y)
-        vcat(0.0, widths, 0.0), vcat(ymin, centers, ymax)
-    end
-end
-
-
-# function apply_series_recipe(d::KW, ::Type{Val{:violin}})
-@recipe function f(::Type{Val{:violin}}, x, y, z; trim=true)
-    # dumpdict(d, "box before", true)
-    # TODO: add scatter series with outliers
-
-    # create a list of shapes, where each shape is a single boxplot
-    shapes = Shape[]
-    groupby = extractGroupArgs(d[:x])
-
-    for (i, glabel) in enumerate(groupby.groupLabels)
-
-        # get the edges and widths
-        y = d[:y][groupby.groupIds[i]]
-        widths, centers = violin_coords(y, trim=trim)
-
-        # normalize
-        widths = _box_halfwidth * widths / maximum(widths)
-
-        # make the violin
-        xcenter = discrete_value!(d[:subplot][:xaxis], glabel)[1]
-        xcoords = vcat(widths, -reverse(widths)) + xcenter
-        ycoords = vcat(centers, reverse(centers))
-        push!(shapes, Shape(xcoords, ycoords))
-    end
-
-    # d[:plotarg_overrides] = KW(:xticks => (1:length(shapes), groupby.groupLabels))
-    seriestype := :shape
-    # n = length(groupby.groupLabels)
-    # xticks --> (linspace(0.5,n-0.5,n), groupby.groupLabels)
-
-    # clean up d
-    pop!(d, :trim)
-
-    d[:x], d[:y] = shape_coords(shapes)
+@recipe function f(::Type{Val{:contourf}}, x, y, z)
+    fillrange := true
+    seriestype := :contour
     ()
 end
-@deps violin shape
-
-# ---------------------------------------------------------------------------
-# density
-
-@recipe function f(::Type{Val{:density}}, x, y, z; trim=false)
-    newx, newy = violin_coords(y, trim=trim)
-    if isvertical(d)
-        newx, newy = newy, newx
-    end
-    x := newx
-    y := newy
-    seriestype := :path
-
-    # clean up d
-    pop!(d, :trim)
-
-    ()
-end
-@deps density path
-
-
 
 # ---------------------------------------------------------------------------
 # Error Bars
@@ -831,6 +767,8 @@ end
 @deps xerror path
 
 
+# TODO: move quiver to PlotRecipes
+
 # ---------------------------------------------------------------------------
 # quiver
 
@@ -931,56 +869,10 @@ end
 @deps quiver shape path
 
 
-# ---------------------------------------------------------------------------
-# ---------------------------------------------------------------------------
-# ---------------------------------------------------------------------------
-
-# function rotate(x::Real, y::Real, θ::Real; center = (0,0))
-#   cx = x - center[1]
-#   cy = y - center[2]
-#   xrot = cx * cos(θ) - cy * sin(θ)
-#   yrot = cy * cos(θ) + cx * sin(θ)
-#   xrot + center[1], yrot + center[2]
-# end
-#
-# # ---------------------------------------------------------------------------
-#
-# type EllipseRecipe <: PlotRecipe
-#   w::Float64
-#   h::Float64
-#   x::Float64
-#   y::Float64
-#   θ::Float64
-# end
-# EllipseRecipe(w,h,x,y) = EllipseRecipe(w,h,x,y,0)
-#
-# # return x,y coords of a rotated ellipse, centered at the origin
-# function rotatedEllipse(w, h, x, y, θ, rotθ)
-#   # # coord before rotation
-#   xpre = w * cos(θ)
-#   ypre = h * sin(θ)
-#
-#   # rotate and translate
-#   r = rotate(xpre, ypre, rotθ)
-#   x + r[1], y + r[2]
-# end
-#
-# function getRecipeXY(ep::EllipseRecipe)
-#   x, y = unzip([rotatedEllipse(ep.w, ep.h, ep.x, ep.y, u, ep.θ) for u in linspace(0,2π,100)])
-#   top = rotate(0, ep.h, ep.θ)
-#   right = rotate(ep.w, 0, ep.θ)
-#   linex = Float64[top[1], 0, right[1]] + ep.x
-#   liney = Float64[top[2], 0, right[2]] + ep.y
-#   Any[x, linex], Any[y, liney]
-# end
-#
-# function getRecipeArgs(ep::EllipseRecipe)
-#   [(:line, (3, [:dot :solid], [:red :blue], :path))]
-# end
-
 # -------------------------------------------------
 
-# TODO: this should really be in another package...
+# TODO: move OHLC to PlotRecipes finance.jl
+
 type OHLC{T<:Real}
   open::T
   high::T
@@ -1058,189 +950,3 @@ function abline!(plt::Plot, a, b; kw...)
 end
 
 abline!(args...; kw...) = abline!(current(), args...; kw...)
-
-# =================================================
-# Arc and chord diagrams
-
-"Takes an adjacency matrix and returns source, destiny and weight lists"
-function mat2list{T}(mat::AbstractArray{T,2})
-    nrow, ncol = size(mat) # rows are sources and columns are destinies
-
-    nosymmetric = !issym(mat) # plots only triu for symmetric matrices
-    nosparse = !issparse(mat) # doesn't plot zeros from a sparse matrix
-
-    L = length(mat)
-
-    source  = Array(Int, L)
-    destiny = Array(Int, L)
-    weight  = Array(T, L)
-
-    idx = 1
-    for i in 1:nrow, j in 1:ncol
-        value = mat[i, j]
-        if !isnan(value) && ( nosparse || value != zero(T) ) # TODO: deal with Nullable
-
-            if i < j
-                source[idx]  = i
-                destiny[idx] = j
-                weight[idx]  = value
-                idx += 1
-            elseif nosymmetric && (i > j)
-                source[idx]  = i
-                destiny[idx] = j
-                weight[idx]  = value
-                idx += 1
-            end
-
-        end
-    end
-
-    resize!(source, idx-1), resize!(destiny, idx-1), resize!(weight, idx-1)
-end
-
-# ---------------------------------------------------------------------------
-# Arc Diagram
-
-curvecolor(value, min, max, grad) = getColorZ(grad, (value-min)/(max-min))
-
-# "Plots a clockwise arc, from source to destiny, colored by weight"
-# function arc!(source, destiny, weight, min, max, grad)
-#     radius = (destiny - source) / 2
-#     arc = Plots.partialcircle(0, π, 30, radius)
-#     x, y = Plots.unzip(arc)
-#     plot!(x .+ radius .+ source,  y, line = (curvecolor(weight, min, max, grad), 0.5, 2), legend=false)
-# end
-
-# """
-# `arcdiagram(source, destiny, weight[, grad])`
-
-# Plots an arc diagram, form `source` to `destiny` (clockwise), using `weight` to determine the colors.
-# """
-# function arcdiagram(source, destiny, weight; kargs...)
-
-#     args = KW(kargs)
-#     grad = pop!(args, :grad,   ColorGradient([colorant"darkred", colorant"darkblue"]))
-
-#     if length(source) == length(destiny) == length(weight)
-
-#         vertices = unique(vcat(source, destiny))
-#         sort!(vertices)
-
-#         xmin, xmax = extrema(vertices)
-#         plot(xlim=(xmin - 0.5, xmax + 0.5), legend=false)
-
-#         wmin,wmax = extrema(weight)
-
-#         for (i, j, value) in zip(source,destiny,weight)
-#             arc!(i, j, value, wmin, wmax, grad)
-#         end
-
-#         scatter!(vertices, zeros(length(vertices)); legend=false, args...)
-
-#     else
-
-#         throw(ArgumentError("source, destiny and weight should have the same length"))
-
-#     end
-# end
-
-# """
-# `arcdiagram(mat[, grad])`
-
-# Plots an arc diagram from an adjacency matrix, form rows to columns (clockwise),
-# using the values on the matrix as weights to determine the colors.
-# Doesn't show edges with value zero if the input is sparse.
-# For simmetric matrices, only the upper triangular values are used.
-# """
-# arcdiagram{T}(mat::AbstractArray{T,2}; kargs...) = arcdiagram(mat2list(mat)...; kargs...)
-
-# ---------------------------------------------------------------------------
-# Chord diagram
-
-arcshape(θ1, θ2) = Shape(vcat(Plots.partialcircle(θ1, θ2, 15, 1.1),
-                            reverse(Plots.partialcircle(θ1, θ2, 15, 0.9))))
-
-colorlist(grad, ::Void) = :darkgray
-
-function colorlist(grad, z)
-    zmin, zmax = extrema(z)
-    RGBA{Float64}[getColorZ(grad, (zi-zmin)/(zmax-zmin)) for zi in z]'
-end
-
-"""
-`chorddiagram(source, destiny, weight[, grad, zcolor, group])`
-
-Plots a chord diagram, form `source` to `destiny`,
-using `weight` to determine the edge colors using `grad`.
-`zcolor` or `group` can be used to determine the node colors.
-"""
-function chorddiagram(source, destiny, weight; kargs...)
-
-    args  = KW(kargs)
-    grad  = pop!(args, :grad,   ColorGradient([colorant"darkred", colorant"darkblue"]))
-    zcolor= pop!(args, :zcolor, nothing)
-    group = pop!(args, :group,  nothing)
-
-    if zcolor !== nothing && group !== nothing
-        throw(ErrorException("group and zcolor can not be used together."))
-    end
-
-    if length(source) == length(destiny) == length(weight)
-
-        plt = plot(xlim=(-2,2), ylim=(-2,2), legend=false, grid=false,
-        xticks=nothing, yticks=nothing,
-        xlim=(-1.2,1.2), ylim=(-1.2,1.2))
-
-        nodemin, nodemax = extrema(vcat(source, destiny))
-
-        weightmin, weightmax = extrema(weight)
-
-        A  = 1.5π # Filled space
-        B  = 0.5π # White space (empirical)
-
-        Δα = A / nodemax
-        Δβ = B / nodemax
-
-        δ = Δα  + Δβ
-
-        for i in 1:length(source)
-            curve = BezierCurve(P2[ (cos((source[i ]-1)*δ + 0.5Δα), sin((source[i ]-1)*δ + 0.5Δα)), (0,0),
-                                    (cos((destiny[i]-1)*δ + 0.5Δα), sin((destiny[i]-1)*δ + 0.5Δα)) ])
-            plot!(curve_points(curve), line = (Plots.curvecolor(weight[i], weightmin, weightmax, grad), 1, 1))
-        end
-
-        if group === nothing
-            c =  colorlist(grad, zcolor)
-        elseif length(group) == nodemax
-
-            idx = collect(0:(nodemax-1))
-
-            for g in group
-                plot!([arcshape(n*δ, n*δ + Δα) for n in idx[group .== g]]; args...)
-            end
-
-            return plt
-
-        else
-            throw(ErrorException("group should the ", nodemax, " elements."))
-        end
-
-        plot!([arcshape(n*δ, n*δ + Δα) for n in 0:(nodemax-1)]; mc=c, args...)
-
-        return plt
-
-    else
-        throw(ArgumentError("source, destiny and weight should have the same length"))
-    end
-end
-
-"""
-`chorddiagram(mat[, grad, zcolor, group])`
-
-Plots a chord diagram from an adjacency matrix,
-using the values on the matrix as weights to determine edge colors.
-Doesn't show edges with value zero if the input is sparse.
-For simmetric matrices, only the upper triangular values are used.
-`zcolor` or `group` can be used to determine the node colors.
-"""
-chorddiagram(mat::AbstractMatrix; kargs...) = chorddiagram(mat2list(mat)...; kargs...)

src/series.jl

@@ -1,81 +1,106 @@
 
-# we are going to build recipes to do the processing and splitting of the args
-
 
-function _add_defaults!(d::KW, plt::Plot, sp::Subplot, commandIndex::Int)
-    pkg = plt.backend
-    globalIndex = d[:series_plotindex]
+# create a new "build_series_args" which converts all inputs into xs = Any[xitems], ys = Any[yitems].
+# Special handling for: no args, xmin/xmax, parametric, dataframes
+# Then once inputs have been converted, build the series args, map functions, etc.
+# This should cut down on boilerplate code and allow more focused dispatch on type
+# note: returns meta information... mainly for use with automatic labeling from DataFrames for now
 
-    # add default values to our dictionary, being careful not to delete what we just added!
-    for (k,v) in _series_defaults
-        slice_arg!(d, d, k, v, commandIndex, remove_pair = false)
-    end
+typealias FuncOrFuncs @compat(Union{Function, AVec{Function}})
 
-    # this is how many series belong to this subplot
-    plotIndex = count(series -> series.d[:subplot] === sp && series.d[:primary], plt.series_list)
-    if get(d, :primary, true)
-        plotIndex += 1
-    end
+all3D(d::KW) = trueOrAllTrue(st -> st in (:contour, :contourf, :heatmap, :surface, :wireframe, :contour3d, :image), get(d, :seriestype, :none))
 
-    aliasesAndAutopick(d, :linestyle, _styleAliases, supported_styles(pkg), plotIndex)
-    aliasesAndAutopick(d, :markershape, _markerAliases, supported_markers(pkg), plotIndex)
+# missing
+convertToAnyVector(v::@compat(Void), d::KW) = Any[nothing], nothing
 
-    # update color
-    d[:seriescolor] = getSeriesRGBColor(d[:seriescolor], sp, plotIndex)
+# fixed number of blank series
+convertToAnyVector(n::Integer, d::KW) = Any[zeros(0) for i in 1:n], nothing
 
-    # update colors
-    for csym in (:linecolor, :markercolor, :fillcolor)
-        d[csym] = if d[csym] == :match
-            if has_black_border_for_default(d[:seriestype]) && csym == :linecolor
-                :black
-            else
-                d[:seriescolor]
-            end
-        else
-            getSeriesRGBColor(d[csym], sp, plotIndex)
-        end
-    end
+# numeric vector
+convertToAnyVector{T<:Number}(v::AVec{T}, d::KW) = Any[v], nothing
 
-    # update markerstrokecolor
-    c = d[:markerstrokecolor]
-    c = if c == :match
-        sp[:foreground_color_subplot]
+# string vector
+convertToAnyVector{T<:@compat(AbstractString)}(v::AVec{T}, d::KW) = Any[v], nothing
+
+function convertToAnyVector(v::AMat, d::KW)
+    if all3D(d)
+        Any[Surface(v)]
     else
-        getSeriesRGBColor(c, sp, plotIndex)
-    end
-    d[:markerstrokecolor] = c
-
-    # update alphas
-    for asym in (:linealpha, :markeralpha, :fillalpha)
-        if d[asym] == nothing
-            d[asym] = d[:seriesalpha]
-        end
-    end
-    if d[:markerstrokealpha] == nothing
-        d[:markerstrokealpha] = d[:markeralpha]
-    end
-
-    # scatter plots don't have a line, but must have a shape
-    if d[:seriestype] in (:scatter, :scatter3d)
-        d[:linewidth] = 0
-        if d[:markershape] == :none
-            d[:markershape] = :circle
-        end
-    end
-
-    # set label
-    label = d[:label]
-    label = (label == "AUTO" ? "y$globalIndex" : label)
-    d[:label] = label
-
-    _replace_linewidth(d)
-    d
+        Any[v[:,i] for i in 1:size(v,2)]
+    end, nothing
 end
 
-# -------------------------------------------------------------------
-# -------------------------------------------------------------------
+# function
+convertToAnyVector(f::Function, d::KW) = Any[f], nothing
 
-# instead of process_inputs:
+# surface
+convertToAnyVector(s::Surface, d::KW) = Any[s], nothing
+
+# # vector of OHLC
+# convertToAnyVector(v::AVec{OHLC}, d::KW) = Any[v], nothing
+
+# dates
+convertToAnyVector{D<:Union{Date,DateTime}}(dts::AVec{D}, d::KW) = Any[dts], nothing
+
+# list of things (maybe other vectors, functions, or something else)
+function convertToAnyVector(v::AVec, d::KW)
+    if all(x -> typeof(x) <: Number, v)
+        # all real numbers wrap the whole vector as one item
+        Any[convert(Vector{Float64}, v)], nothing
+    else
+        # something else... treat each element as an item
+        vcat(Any[convertToAnyVector(vi, d)[1] for vi in v]...), nothing
+        # Any[vi for vi in v], nothing
+    end
+end
+
+convertToAnyVector(t::Tuple, d::KW) = Any[t], nothing
+
+
+function convertToAnyVector(args...)
+    error("In convertToAnyVector, could not handle the argument types: $(map(typeof, args[1:end-1]))")
+end
+
+# --------------------------------------------------------------------
+
+# TODO: can we avoid the copy here?  one error that crops up is that mapping functions over the same array
+#       result in that array being shared.  push!, etc will add too many items to that array
+
+compute_x(x::Void, y::Void, z)      = 1:size(z,1)
+compute_x(x::Void, y, z)            = 1:size(y,1)
+compute_x(x::Function, y, z)        = map(x, y)
+compute_x(x, y, z)                  = copy(x)
+
+# compute_y(x::Void, y::Function, z)  = error()
+compute_y(x::Void, y::Void, z)      = 1:size(z,2)
+compute_y(x, y::Function, z)        = map(y, x)
+compute_y(x, y, z)                  = copy(y)
+
+compute_z(x, y, z::Function)        = map(z, x, y)
+compute_z(x, y, z::AbstractMatrix)  = Surface(z)
+compute_z(x, y, z::Void)            = nothing
+compute_z(x, y, z)                  = copy(z)
+
+nobigs(v::AVec{BigFloat}) = map(Float64, v)
+nobigs(v::AVec{BigInt}) = map(Int64, v)
+nobigs(v) = v
+
+@noinline function compute_xyz(x, y, z)
+    x = compute_x(x,y,z)
+    y = compute_y(x,y,z)
+    z = compute_z(x,y,z)
+    nobigs(x), nobigs(y), nobigs(z)
+end
+
+# not allowed
+compute_xyz(x::Void, y::FuncOrFuncs, z)       = error("If you want to plot the function `$y`, you need to define the x values!")
+compute_xyz(x::Void, y::Void, z::FuncOrFuncs) = error("If you want to plot the function `$z`, you need to define x and y values!")
+compute_xyz(x::Void, y::Void, z::Void)        = error("x/y/z are all nothing!")
+
+# --------------------------------------------------------------------
+
+
+# we are going to build recipes to do the processing and splitting of the args
 
 # ensure we dispatch to the slicer
 immutable SliceIt end
@@ -180,15 +205,6 @@ end
     newargs
 end
 
-# @recipe f(x, y, z)  = SliceIt, apply_recipe(typeof(x), x), apply_recipe(typeof(y), y), apply_recipe(typeof(z), z)
-# @recipe f(x, y)     = SliceIt, apply_recipe(typeof(x), x), apply_recipe(typeof(y), y), nothing
-# @recipe f(y)        = SliceIt, nothing, apply_recipe(typeof(y), y), nothing
-
-# # pass these through to the slicer
-# @recipe f(x, y, z)  = SliceIt, x, y, z
-# @recipe f(x, y)     = SliceIt, x, y, nothing
-# @recipe f(y)        = SliceIt, nothing, y, nothing
-
 
 # # --------------------------------------------------------------------
 # # 1 argument
@@ -241,33 +257,30 @@ end
 # # plotting arbitrary shapes/polygons
 
 @recipe function f(shape::Shape)
-    seriestype := :shape
+    seriestype --> :shape
     shape_coords(shape)
 end
 
 @recipe function f(shapes::AVec{Shape})
-    seriestype := :shape
+    seriestype --> :shape
     shape_coords(shapes)
 end
 
 @recipe function f(shapes::AMat{Shape})
+    seriestype --> :shape
     for j in 1:size(shapes,2)
-        # create one series for each column
-        # @series shape_coords(vec(shapes[:,j]))
-        di = copy(d)
-        push!(series_list, RecipeData(di, shape_coords(vec(shapes[:,j]))))
+        @series shape_coords(vec(shapes[:,j]))
     end
-    nothing # don't create a series for the main block
 end
 
 #
 #
 # # function without range... use the current range of the x-axis
 
-@recipe function f(f::FuncOrFuncs)
-    plt = d[:plot_object]
-    f, xmin(plt), xmax(plt)
-end
+# @recipe function f(f::FuncOrFuncs)
+#     plt = d[:plot_object]
+#     f, xmin(plt), xmax(plt)
+# end
 
 #
 # # --------------------------------------------------------------------

src/series_args.jl

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

src/subplots.jl

@@ -30,7 +30,7 @@ get_subplot(plt::Plot, i::Integer) = plt.subplots[i]
 get_subplot(plt::Plot, k) = plt.spmap[k]
 get_subplot(series::Series) = series.d[:subplot]
 
-get_subplot_index(plt::Plot, idx::Integer) = idx
+get_subplot_index(plt::Plot, idx::Integer) = Int(idx)
 get_subplot_index(plt::Plot, sp::Subplot) = findfirst(_ -> _ === sp, plt.subplots)
 
 series_list(sp::Subplot) = filter(series -> series.d[:subplot] === sp, sp.plt.series_list)
@@ -39,7 +39,7 @@ function should_add_to_legend(series::Series)
     series.d[:primary] && series.d[:label] != "" &&
         !(series.d[:seriestype] in (
             :hexbin,:histogram2d,:hline,:vline,
-            :contour,:contour3d,:surface,:wireframe,
+            :contour,:contourf,:contour3d,:surface,:wireframe,
             :heatmap, :pie, :image
         ))
 end

src/types.jl

@@ -83,12 +83,13 @@ function Plot()
          Subplot[], false)
 end
 
-# TODO: make a decision... should plt[1] return the first subplot or the first series??
-# Base.getindex(plt::Plot, i::Integer) = plt.subplots[i]
-Base.getindex(plt::Plot, s::Symbol) = plt.spmap[s]
-Base.getindex(plt::Plot, r::Integer, c::Integer) = plt.layout[r,c]
-attr(plt::Plot, k::Symbol) = plt.attr[k]
-attr!(plt::Plot, v, k::Symbol) = (plt.attr[k] = v)
+# -----------------------------------------------------------------------
 
+Base.getindex(plt::Plot, i::Integer) = plt.subplots[i]
+Base.getindex(plt::Plot, r::Integer, c::Integer) = plt.layout[r,c]
+# attr(plt::Plot, k::Symbol) = plt.attr[k]
+# attr!(plt::Plot, v, k::Symbol) = (plt.attr[k] = v)
+
+Base.getindex(sp::Subplot, i::Integer) = series_list(sp)[i]
 
 # -----------------------------------------------------------------------

src/utils.jl

@@ -137,33 +137,62 @@ function imageHack(d::KW)
 end
 # ---------------------------------------------------------------
 
+
+type Segments
+    pts::Vector{Float64}
+end
+
+Segments() = Segments(zeros(0))
+
+function Base.push!(segments::Segments, vs...)
+    push!(segments.pts, NaN)
+    for v in vs
+        push!(segments.pts, v)
+    end
+    segments
+end
+
+function Base.push!(segments::Segments, vs::AVec)
+    push!(segments.pts, NaN)
+    for v in vs
+        push!(segments.pts, v)
+    end
+    segments
+end
+
+
 # -----------------------------------------------------
 # helper to manage NaN-separated segments
 
 type SegmentsIterator
     args::Tuple
-    nextidx::Int
     n::Int
 end
 function iter_segments(args...)
     tup = Plots.wraptuple(args)
     n = maximum(map(length, tup))
-    SegmentsIterator(tup, 0, n)
+    SegmentsIterator(tup, n)
 end
 
 # helpers to figure out if there are NaN values in a list of array types
-anynan(i::Int, args...) = any(a -> !isfinite(cycle(a,i)), args)
-anynan(istart::Int, iend::Int, args...) = any(i -> anynan(i, args...), istart:iend)
-allnan(istart::Int, iend::Int, args...) = all(i -> anynan(i, args...), istart:iend)
+anynan(i::Int, args::Tuple) = any(a -> !isfinite(cycle(a,i)), args)
+anynan(istart::Int, iend::Int, args::Tuple) = any(i -> anynan(i, args), istart:iend)
+allnan(istart::Int, iend::Int, args::Tuple) = all(i -> anynan(i, args), istart:iend)
 
-Base.start(itr::SegmentsIterator) = (itr.nextidx = 1) #resets
-Base.done(itr::SegmentsIterator, unused::Int) = itr.nextidx > itr.n
-function Base.next(itr::SegmentsIterator, unused::Int)
-    i = istart = iend = itr.nextidx
+function Base.start(itr::SegmentsIterator)
+    nextidx = 1
+    if anynan(1, itr.args)
+        _, nextidx = next(itr, 1)
+    end
+    nextidx
+end
+Base.done(itr::SegmentsIterator, nextidx::Int) = nextidx > itr.n
+function Base.next(itr::SegmentsIterator, nextidx::Int)
+    i = istart = iend = nextidx
 
     # find the next NaN, and iend is the one before
     while i <= itr.n + 1
-        if i > itr.n || anynan(i, itr.args...)
+        if i > itr.n || anynan(i, itr.args)
             # done... array end or found NaN
             iend = i-1
             break
@@ -171,16 +200,15 @@ function Base.next(itr::SegmentsIterator, unused::Int)
         i += 1
     end
 
-    # find the next non-NaN, and set itr.nextidx
+    # find the next non-NaN, and set nextidx
     while i <= itr.n
-        if !anynan(i, itr.args...)
+        if !anynan(i, itr.args)
             break
         end
         i += 1
     end
 
-    itr.nextidx = i
-    istart:iend, 0
+    istart:iend, i
 end
 
 # ------------------------------------------------------------------------------------
@@ -189,6 +217,9 @@ end
 nop() = nothing
 notimpl() = error("This has not been implemented yet")
 
+Base.cycle(wrapper::InputWrapper, idx::Int) = wrapper.obj
+Base.cycle(wrapper::InputWrapper, idx::AVec{Int}) = wrapper.obj
+
 Base.cycle(v::AVec, idx::Int) = v[mod1(idx, length(v))]
 Base.cycle(v::AMat, idx::Int) = size(v,1) == 1 ? v[1, mod1(idx, size(v,2))] : v[:, mod1(idx, size(v,2))]
 Base.cycle(v, idx::Int)       = v
@@ -197,6 +228,8 @@ Base.cycle(v::AVec, indices::AVec{Int}) = map(i -> cycle(v,i), indices)
 Base.cycle(v::AMat, indices::AVec{Int}) = map(i -> cycle(v,i), indices)
 Base.cycle(v, idx::AVec{Int})       = v
 
+Base.cycle(grad::ColorGradient, idx::Int) = cycle(grad.colors, idx)
+
 makevec(v::AVec) = v
 makevec{T}(v::T) = T[v]
 
@@ -232,6 +265,7 @@ function _expand_limits(lims, x)
   nothing
 end
 
+expand_data(v, n::Integer) = [cycle(v, i) for i=1:n]
 
 # if the type exists in a list, replace the first occurence.  otherwise add it to the end
 function addOrReplace(v::AbstractVector, t::DataType, args...; kw...)
@@ -250,20 +284,16 @@ function replaceType(vec, val)
   push!(vec, val)
 end
 
-function replaceAlias!(d::KW, k::Symbol, aliases::KW)
+function replaceAlias!(d::KW, k::Symbol, aliases::Dict{Symbol,Symbol})
   if haskey(aliases, k)
     d[aliases[k]] = pop!(d, k)
   end
 end
 
-function replaceAliases!(d::KW, aliases::KW)
+function replaceAliases!(d::KW, aliases::Dict{Symbol,Symbol})
   ks = collect(keys(d))
   for k in ks
       replaceAlias!(d, k, aliases)
-    # if haskey(aliases, k)
-    #   d[aliases[k]] = d[k]
-    #   delete!(d, k)
-    # end
   end
 end
 
@@ -336,6 +366,7 @@ is_2tuple(v) = typeof(v) <: Tuple && length(v) == 2
 
 
 isvertical(d::KW) = get(d, :orientation, :vertical) in (:vertical, :v, :vert)
+isvertical(series::Series) = isvertical(series.d)
 
 
 # ticksType{T<:Real,S<:Real}(ticks::@compat(Tuple{T,S})) = :limits
@@ -395,7 +426,7 @@ end
 # this is a helper function to determine whether we need to transpose a surface matrix.
 # it depends on whether the backend matches rows to x (transpose_on_match == true) or vice versa
 # for example: PyPlot sends rows to y, so transpose_on_match should be true
-function transpose_z(d::KW, z, transpose_on_match::Bool = true)
+function transpose_z(d, z, transpose_on_match::Bool = true)
     if d[:match_dimensions] == transpose_on_match
         z'
     else
@@ -615,7 +646,7 @@ end
 # -------------------------------------------------------
 # indexing notation
 
-Base.getindex(plt::Plot, i::Integer) = getxy(plt, i)
+# Base.getindex(plt::Plot, i::Integer) = getxy(plt, i)
 Base.setindex!{X,Y}(plt::Plot, xy::Tuple{X,Y}, i::Integer) = setxy!(plt, xy, i)
 Base.setindex!{X,Y,Z}(plt::Plot, xyz::Tuple{X,Y,Z}, i::Integer) = setxyz!(plt, xyz, i)
 

test/REQUIRE

@@ -1,12 +1,12 @@
 julia 0.4
 
 RecipesBase
-Colors
+PlotUtils
+StatPlots
 Reexport
 Measures
 FactCheck
 Images
-PyPlot
 @osx QuartzImageIO
 GR
 DataFrames

test/imgcomp.jl

@@ -13,7 +13,9 @@ try
 end
 
 
-using Plots, FactCheck
+using Plots
+using StatPlots
+using FactCheck
 using Glob
 
 default(size=(500,300))
@@ -22,7 +24,7 @@ default(size=(500,300))
 # TODO: use julia's Condition type and the wait() and notify() functions to initialize a Window, then wait() on a condition that
 #       is referenced in a button press callback (the button clicked callback will call notify() on that condition)
 
-const _current_plots_version = v"0.7.2"
+const _current_plots_version = v"0.8.0"
 
 
 function image_comparison_tests(pkg::Symbol, idx::Int; debug = false, popup = isinteractive(), sigma = [1,1], eps = 1e-2)
@@ -41,9 +43,10 @@ function image_comparison_tests(pkg::Symbol, idx::Int; debug = false, popup = is
     fn = "ref$idx.png"
 
     # firgure out version info
-    G = glob(relpath(refdir) * "/*")
+    G = glob(joinpath(relpath(refdir), "*"))
     # @show refdir fn G
-    versions = map(fn -> VersionNumber(split(fn,"/")[end]), G)
+    slash = (@windows ? "\\" : "/")
+    versions = map(fn -> VersionNumber(split(fn, slash)[end]), G)
     versions = reverse(sort(versions))
     versions = filter(v -> v <= _current_plots_version, versions)
     # @show refdir fn versions

test/runtests.jl

@@ -5,7 +5,7 @@ include("imgcomp.jl")
 # don't actually show the plots
 srand(1234)
 default(show=false, reuse=true)
-img_eps = 5e-2
+img_eps = isinteractive() ? 1e-2 : 10e-2
 
 # facts("Gadfly") do
 #     @fact gadfly() --> Plots.GadflyBackend()
@@ -23,14 +23,14 @@ facts("PyPlot") do
     @fact pyplot() --> Plots.PyPlotBackend()
     @fact backend() --> Plots.PyPlotBackend()
 
-    image_comparison_facts(:pyplot, skip=[30], eps=img_eps)
+    image_comparison_facts(:pyplot, skip=[], eps=img_eps)
 end
 
 facts("GR") do
     @fact gr() --> Plots.GRBackend()
     @fact backend() --> Plots.GRBackend()
 
-    @linux_only image_comparison_facts(:gr, skip=[30], eps=img_eps)
+    # @linux_only image_comparison_facts(:gr, skip=[], eps=img_eps)
 end
 
 facts("Plotly") do

test/snoop.jl

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

test/travis_commands.jl

@@ -1,23 +1,22 @@
-# Pkg.clone(pwd())
-# Pkg.build("Plots")
-
 Pkg.clone("ImageMagick")
 Pkg.build("ImageMagick")
 
 Pkg.clone("GR")
 Pkg.build("GR")
 
-# Pkg.clone("https://github.com/JuliaPlots/RecipesBase.jl.git")
-# Pkg.clone("https://github.com/tbreloff/ExamplePlots.jl.git");
 Pkg.clone("https://github.com/JuliaPlots/PlotReferenceImages.jl.git")
 
+# Pkg.clone("https://github.com/JuliaStats/KernelDensity.jl.git")
+
+Pkg.clone("StatPlots")
+
 # Pkg.clone("https://github.com/JunoLab/Blink.jl.git")
 # Pkg.build("Blink")
 # import Blink
 # Blink.AtomShell.install()
 # Pkg.clone("https://github.com/spencerlyon2/PlotlyJS.jl.git")
 
-Pkg.checkout("RecipesBase")
+# Pkg.checkout("RecipesBase")
 Pkg.clone("VisualRegressionTests")
 
 ENV["PYTHON"] = ""