working on ticks

src/Plots.jl

@@ -103,6 +103,8 @@ xlims!{T<:Real,S<:Real}(lims::Tuple{T,S}) = plot!(xlims = lims)
 ylims!{T<:Real,S<:Real}(lims::Tuple{T,S}) = plot!(ylims = lims)
 xticks!{T<:Real}(v::AVec{T})              = plot!(xticks = v)
 yticks!{T<:Real}(v::AVec{T})              = plot!(yticks = v)
+xticks!{T<:Real,S<:AbstractString}(ticks::AVec{T}, labels::AVec{S})  = plot!(xticks = (ticks,labels))
+yticks!{T<:Real,S<:AbstractString}(ticks::AVec{T}, labels::AVec{S})  = plot!(yticks = (ticks,labels))
 annotate!(anns)                           = plot!(annotation = anns)
 
 title!(plt::Plot, s::AbstractString)                  = plot!(plt; title = s)
@@ -110,8 +112,10 @@ xlabel!(plt::Plot, s::AbstractString)                 = plot!(plt; xlabel = s)
 ylabel!(plt::Plot, s::AbstractString)                 = plot!(plt; ylabel = s)
 xlims!{T<:Real,S<:Real}(plt::Plot, lims::Tuple{T,S})  = plot!(plt; xlims = lims)
 ylims!{T<:Real,S<:Real}(plt::Plot, lims::Tuple{T,S})  = plot!(plt; ylims = lims)
-xticks!{T<:Real}(plt::Plot, v::AVec{T})               = plot!(plt; xticks = v)
+xticks!{T<:Real}(plt::Plot, ticks::AVec{T})           = plot!(plt; xticks = ticks)
-yticks!{T<:Real}(plt::Plot, v::AVec{T})               = plot!(plt; yticks = v)
+yticks!{T<:Real}(plt::Plot, ticks::AVec{T})           = plot!(plt; yticks = ticks)
+xticks!{T<:Real,S<:AbstractString}(plt::Plot, ticks::AVec{T}, labels::AVec{S})  = plot!(plt; xticks = (ticks,labels))
+yticks!{T<:Real,S<:AbstractString}(plt::Plot, ticks::AVec{T}, labels::AVec{S})  = plot!(plt; yticks = (ticks,labels))
 annotate!(plt::Plot, anns)                            = plot!(plt; annotation = anns)
 
 

src/backends/gadfly.jl

@@ -279,6 +279,12 @@ function addTicksGuide(gplt, ticks, isx::Bool)
   if ttype == :ticks
     gtype = isx ? Gadfly.Guide.xticks : Gadfly.Guide.yticks
     replaceType(gplt.guides, gtype(ticks = collect(ticks)))
+  elseif ttype == :ticks_and_labels
+    gtype = isx ? Gadfly.Guide.xticks : Gadfly.Guide.yticks
+    replaceType(gplt.guides, gtype(ticks = collect(ticks[1])))
+
+    # TODO add xtick_label function (given tick, return label??) to gplt.ascetics
+    # probably want to add to gplt.mapping!
   else
     error("Invalid input for $(isx ? "xticks" : "yticks"): ", ticks)
   end

src/backends/pyplot.jl

@@ -282,8 +282,8 @@ function addTicksGuide(gplt, ticks, isx::Bool)
   ttype = ticksType(ticks)
   if ttype == :ticks
     (isx ? PyPlot.xticks : PyPlot.yticks)(ticks)
-  elseif ttype == :ticklabels
+  elseif ttype == :ticks_and_labels
-    (isx ? PyPlot.xticks : PyPlot.yticks)(collect(1:length(ticks)), ticks)
+    (isx ? PyPlot.xticks : PyPlot.yticks)(ticks...)
   else
     error("Invalid input for $(isx ? "xticks" : "yticks"): ", ticks)
   end

src/plot.jl

@@ -132,28 +132,24 @@ end
 
 function setTicksFromStringVector(d::Dict, di::Dict, sym::Symbol, ticksym::Symbol)
   # if the x or y values are strings, set ticks to the unique values, and x/y to the indices of the ticks
-  # @show get(d,ticksym,:auto) == :auto isa(di[sym], AbstractArray) isa(eltype(di[sym]), AbstractString)
-  # @show get(d,ticksym,:auto) eltype(di[sym])
-
-  haskey(d, ticksym) || return
-  d[ticksym] == :auto || return
 
+  @show sym di
   v = di[sym]
   @show v
   isa(v, AbstractArray) || return
 
   T = eltype(v)
   @show T
-  if T <: AbstractString || all(x -> x <: AbstractString, T.types)
+  if T <: AbstractString || (!isempty(T.types) && all(x -> x <: AbstractString, T.types))
-
+    @show sym ticksym di[sym]
-  # if get(d,ticksym,:auto) == :auto && isa(di[sym], AbstractArray) &&
-  #         (issubtype(eltype(di[sym]), AbstractString) || all(x->x<:AbstractString, eltype(di[sym]).types))
-    @show sym ticksym di[sym] d[ticksym]
 
     ticks = unique(di[sym])
     @show ticks
     di[sym] = Int[findnext(ticks, v, 1) for v in di[sym]]
-    d[ticksym] = UTF8String[t for t in ticks]
+
+    if !haskey(d, ticksym) || d[ticksym] == :auto
+      d[ticksym] = (collect(1:length(ticks)), UTF8String[t for t in ticks])
+    end
   end
   # @show sym ticksym di[sym] d[ticksym]
 end

src/utils.jl

@@ -133,7 +133,7 @@ end
 
 # ticksType{T<:Real,S<:Real}(ticks::Tuple{T,S}) = :limits
 ticksType{T<:Real}(ticks::AVec{T}) = :ticks
-ticksType{T<:AbstractString}(ticks::AVec{T}) = :ticklabels
+ticksType{T<:AVec,S<:AVec}(ticks::Tuple{T,S}) = :ticks_and_labels
 ticksType(ticks) = :invalid
 
 limsType{T<:Real,S<:Real}(lims::Tuple{T,S}) = :limits