glwindow changes + depwarns (#194)

* accompany new changes from GLWindow

* Fix deprecations

* include new glwindow

Author: SimonDanisch

REQUIRE

@@ -3,7 +3,7 @@ julia 0.6
 StaticArrays 0.6.0
 GeometryTypes 0.4.1
 
-GLWindow 0.6 # 0.6 for fullscreen
+GLWindow 0.7 # 0.7 for reactive_run_till_now
 GLAbstraction 0.5
 ModernGL 0.1.0
 

examples/ExampleRunner.jl

@@ -43,7 +43,7 @@ function flatten_paths(path::String, paths = String[])
     paths
 end
 
-type RunnerConfig
+mutable struct RunnerConfig
     resolution
     make_docs
     files
@@ -368,7 +368,7 @@ end
 to_toggle(v0, b) = !v0
 
 
-import GLWindow: poll_reactive, poll_glfw, sleep_pessimistic
+import GLWindow: reactive_run_till_now, poll_glfw, sleep_pessimistic
 
 
 function inner_test(path, config, window, break_loop, runthrough, increase)
@@ -377,21 +377,18 @@ function inner_test(path, config, window, break_loop, runthrough, increase)
         display_msg(test_module, config)
         timings = Float64[]
         frames = 0;
-        @eval poll_glfw()
-        @eval poll_reactive()
-        @eval poll_reactive()
-        yield()
+        poll_glfw()
+        reactive_run_till_now()
         while !break_loop[] && isopen(config.rootscreen)
-            tic()
+            t = time()
             poll_glfw()
             if Base.n_avail(Reactive._messages) > 0
-                poll_reactive()
-                poll_reactive() # two times for secondary signals
+                reactive_run_till_now() # two times for secondary signals
                 render_frame(config.rootscreen)
                 swapbuffers(config.rootscreen)
             end
             frames += 1
-            t = toq()
+            t = time() - t
             if length(timings) < 1000 && frames > 2
                 push!(timings, t)
             end
@@ -453,7 +450,6 @@ function make_tests(config)
     end
 
     failed = fill(false, length(config.files))
-    Reactive.stop() # stop Reactive! We be pollin' ourselves!
     io = nothing
     while i <= length(config.files) && isopen(config.rootscreen)
         path = config.files[i]

examples/interactive/mario_game.jl

@@ -9,7 +9,7 @@ You can move mario around with the arrow keys
 """
 const record_interactive = true
 
-type Mario{T}
+mutable struct Mario{T}
     x             ::T
     y             ::T
     vx            ::T

examples/introduction/video_recording.jl

@@ -32,7 +32,7 @@ for i=1:10 # record 10 frames
     # if you call @async renderloop(window) you can replace this part with yield
     GLWindow.render_frame(window)
     GLWindow.swapbuffers(window)
-    GLWindow.poll_reactive()
+    GLWindow.reactive_run_till_now()
 
     # add the frame from the current window
     GLVisualize.add_frame!(io, window, buffer)

examples/parallel/simulation3d.jl

@@ -44,9 +44,9 @@ function p_empty!()
 end
 
 
-function solve_particles!{N, T}(
+function solve_particles!(
         positions::AbstractVector{Point{N, T}}, s, dt::T = T(0.01)
-    )
+    ) where {N, T}
     P = Point{N, T}
     # since Points are immutable, and we don't have comprehensions yet, there is
     # a map(index _> ..., ::Point) which we can use
@@ -70,7 +70,7 @@ end
 Generic implementation of initialising `N` dimensional points on an `N` dimensional
 Sphere.
 """
-function startpositions{T}(N, radius::T, n)
+function startpositions(N, radius::T, n) where T
     sphere = HyperSphere(Point{N, T}(0), T(radius))
     n = N == 3 ? floor(Int, sqrt(n)) : n # n must be n^2 for 3D Sphere
     decompose(Point{N, T}, sphere, n)

examples/sprites/distancefield.jl

@@ -31,7 +31,7 @@ dfield = map(timesignal) do t
     Float32[xy_data(x,y,tpi) + 0.5f0 for x=1:n2, y=1:n2]
 end
 Base.rand(m::MersenneTwister, ::Type{N0f8}) = N0f8(rand(m, UInt8))
-Base.rand{T <: Colorant}(m::MersenneTwister, ::Type{T}) = T(ntuple(x->rand(m, eltype(T)), Val{length(T)})...)
+Base.rand(m::MersenneTwister, ::Type{T}) where {T <: Colorant} = T(ntuple(x->rand(m, eltype(T)), Val{length(T)})...)
 
 distfield = visualize((DISTANCEFIELD, positions),
     stroke_width=4f0,

src/GLVisualize.jl

@@ -24,11 +24,7 @@ import GLAbstraction: N0f8
 export N0f8 # reexport for examples/tests
 using Base.Iterators: filter
 import Base: merge, convert, show
-if VERSION >= v"0.6.0-dev.1015"
-    using Base.Iterators: Repeated, repeated
-else
-    using Base.Repeated
-end
+using Base.Iterators: Repeated, repeated
 
 import AxisArrays, ImageAxes, Images
 const HasAxesArray{T, N} = Union{AxisArrays.AxisArray{T, N}, Images.ImageMetadata.ImageMetaAxis{T, N}}

src/StructsOfArrays.jl

@@ -2,18 +2,18 @@ module StructsOfArrays
 
 export StructOfArrays, ScalarRepeat
 
-immutable StructOfArrays{T,N,U<:Tuple} <: AbstractArray{T,N}
+struct StructOfArrays{T,N,U<:Tuple} <: AbstractArray{T,N}
     arrays::U
 end
 
 
-type ScalarRepeat{T}
+mutable struct ScalarRepeat{T}
     scalar::T
 end
 Base.ndims(::ScalarRepeat) = 1
 Base.getindex(s::ScalarRepeat, i...) = s.scalar
 #should setindex! really be allowed? It will set the index for the whole row...
-Base.setindex!{T}(s::ScalarRepeat{T}, value, i...) = (s.scalar = T(value))
+Base.setindex!(s::ScalarRepeat{T}, value, i...) where {T} = (s.scalar = T(value))
 Base.eltype{T}(::ScalarRepeat{T}) = T
 
 Base.start(::ScalarRepeat) = 1
@@ -85,7 +85,7 @@ Base.convert{T,S,N}(::Type{StructOfArrays{T}}, A::AbstractArray{S,N}) =
 Base.convert{T,N}(::Type{StructOfArrays}, A::AbstractArray{T,N}) =
     convert(StructOfArrays{T,N}, A)
 
-function Base.size{T, N, U}(A::StructOfArrays{T, N, U})
+function Base.size(A::StructOfArrays{T, N, U}) where {T, N, U}
     for elem in A.arrays
         if isa(elem, AbstractArray)
             return size(elem)
@@ -104,7 +104,7 @@ end
     )
 end
 
-function _getindex{T}(x::T, i)
+function _getindex(x::T, i) where T
     is_tuple_struct(T) ? x[i] : getfield(x, i)
 end
 @generated function Base.setindex!{T}(A::StructOfArrays{T}, x, i::Integer...)

src/boundingbox.jl

@@ -1,25 +1,25 @@
-AbsoluteRectangle{N,T}(mini::Vec{N,T}, maxi::Vec{N,T}) = HyperRectangle{N,T}(mini, maxi-mini)
+AbsoluteRectangle(mini::Vec{N,T}, maxi::Vec{N,T}) where {N,T} = HyperRectangle{N,T}(mini, maxi-mini)
 
-(::Type{AABB})(a) = AABB{Float32}(a)
-function (B::Type{AABB{T}}){T}(a::Pyramid)
+AABB(a) = AABB{Float32}(a)
+function (B::Type{AABB{T}})(a::Pyramid) where T
     w,h = a.width/T(2), a.length
     m = Vec{3,T}(a.middle)
     B(m-Vec{3,T}(w,w,0), m+Vec{3,T}(w, w, h))
 end
-(B::Type{AABB{T}}){T}(a::Cube) = B(origin(a), widths(a))
-(B::Type{AABB{T}}){T}(a::AbstractMesh) = B(vertices(a))
-(B::Type{AABB{T}}){T}(a::NativeMesh) = B(gpu_data(a.data[:vertices]))
+(B::Type{AABB{T}})(a::Cube) where {T} = B(origin(a), widths(a))
+(B::Type{AABB{T}})(a::AbstractMesh) where {T} = B(vertices(a))
+(B::Type{AABB{T}})(a::NativeMesh) where {T} = B(gpu_data(a.data[:vertices]))
 
 
-function (B::Type{AABB{T}}){T}(
+function (B::Type{AABB{T}})(
         positions, scale, rotation,
         primitive::AABB{T}
-    )
+    ) where T
 
     ti = TransformationIterator(positions, scale, rotation)
     B(ti, primitive)
 end
-function (B::Type{AABB{T}}){T}(instances::Instances)
+function (B::Type{AABB{T}})(instances::Instances) where T
     ti = TransformationIterator(instances)
     B(ti, B(instances.primitive))
 end
@@ -38,9 +38,9 @@ function transform(translation, scale, rotation, points)
     AABB{Float32}(_min, _max-_min)
 end
 
-function (B::Type{AABB{T}}){T}(
+function (B::Type{AABB{T}})(
       ti::TransformationIterator, primitive::AABB{T}
-    )
+    ) where T
     state = start(ti)
     if done(ti, state)
         return primitive

src/camera.jl

@@ -12,8 +12,8 @@ function cubeside_const_lift(_, id, mousehover)
     Vec3f0(1)
 end
 import Base: +
-Base.clamp{T}(x::T) = clamp(x, T(0),T(1))
-+{T}(a::RGBA{T}, b::Number) = RGBA{T}(clamp(comp1(a)+b), clamp(comp2(a)+b), clamp(comp3(a)+b), clamp(alpha(a)+b))
+Base.clamp(x::T) where {T} = clamp(x, T(0),T(1))
++(a::RGBA{T}, b::Number) where {T} = RGBA{T}(clamp(comp1(a)+b), clamp(comp2(a)+b), clamp(comp3(a)+b), clamp(alpha(a)+b))
 
 function cubeside_color(id, mousehover, startcolors, colortex)
     index = mousehover[2]
@@ -39,7 +39,7 @@ function colored_cube()
     cube_steering = merge(map(GLNormalMesh, quads))
 end
 
-Base.middle{T}(r::SimpleRectangle{T}) = Point{2, T}(r.x+(r.w/T(2)), r.y+(r.mousehover/T(2)))
+Base.middle(r::SimpleRectangle{T}) where {T} = Point{2, T}(r.x+(r.w/T(2)), r.y+(r.mousehover/T(2)))
 
 
 function get_rotation(m)