initial format

CairoMakie/src/CairoMakie.jl

@@ -14,7 +14,7 @@ using Makie: spaces, is_data_space, is_pixel_space, is_relative_space, is_clip_s
 using Makie: numbers_to_colors
 
 # re-export Makie, including deprecated names
-for name in names(Makie, all=true)
+for name in names(Makie, all = true)
     if Base.isexported(Makie, name)
         @eval using Makie: $(name)
         @eval export $(name)

CairoMakie/src/cairo-extension.jl

@@ -40,18 +40,18 @@ end
 function show_glyph(ctx, glyph, x, y)
     cg = Ref(CairoGlyph(glyph, x, y))
     ccall((:cairo_show_glyphs, Cairo.libcairo),
-            Nothing, (Ptr{Nothing}, Ptr{CairoGlyph}, Cint),
-            ctx.ptr, cg, 1)
+        Nothing, (Ptr{Nothing}, Ptr{CairoGlyph}, Cint),
+        ctx.ptr, cg, 1)
 end
 
 function glyph_path(ctx, glyph, x, y)
     cg = Ref(CairoGlyph(glyph, x, y))
     ccall((:cairo_glyph_path, Cairo.libcairo),
-            Nothing, (Ptr{Nothing}, Ptr{CairoGlyph}, Cint),
-            ctx.ptr, cg, 1)
+        Nothing, (Ptr{Nothing}, Ptr{CairoGlyph}, Cint),
+        ctx.ptr, cg, 1)
 end
 
-function surface_set_device_scale(surf, device_x_scale, device_y_scale=device_x_scale)
+function surface_set_device_scale(surf, device_x_scale, device_y_scale = device_x_scale)
     # this sets a scaling factor on the lowest level that is "hidden" so its even
     # enabled when the drawing space is reset for strokes
     # that means it can be used to increase or decrease the image resolution

CairoMakie/src/display.jl

@@ -31,13 +31,13 @@ function openurl(url::String)
     @warn("Can't find a way to open a browser, open $(url) manually!")
 end
 
-function Base.display(screen::Screen, scene::Scene; connect=false)
+function Base.display(screen::Screen, scene::Scene; connect = false)
     # Nothing to do, since drawing is done in the other functions
     # TODO write to file and implement upenurl
     return screen
 end
 
-function Base.display(screen::Screen{IMAGE}, scene::Scene; connect=false)
+function Base.display(screen::Screen{IMAGE}, scene::Scene; connect = false)
     path = joinpath(mktempdir(), "display.png")
     Makie.push_screen!(scene, screen)
     cairo_draw(screen, scene)
@@ -73,14 +73,14 @@ function Makie.backend_show(screen::Screen{SVG}, io::IO, ::MIME"image/svg+xml",
     # across svgs when embedding them on websites.
     # the hash and therefore the salt will always be the same for the same file
     # so the output is deterministic
-    salt = repr(CRC32c.crc32c(svg))[end-7:end]
+    salt = repr(CRC32c.crc32c(svg))[(end - 7):end]
 
     # matches:
     # id="someid"
     # xlink:href="someid" (but not xlink:href="data:someothercontent" which is how image data is attached)
     # url(#someid)
     svg = replace(svg, r"((?:(?:id|xlink:href)=\"(?!data:)[^\"]+)|url\(#[^)]+)" => SubstitutionString("\\1-$salt"))
-    
+
     print(io, svg)
     return screen
 end
@@ -110,7 +110,7 @@ end
 
 const DISABLED_MIMES = Set{String}()
 const SUPPORTED_MIMES = Set([
-    map(x->string(x()), Makie.WEB_MIMES)...,
+    map(x -> string(x()), Makie.WEB_MIMES)...,
     "image/svg+xml",
     "application/pdf",
     "application/postscript",
@@ -127,7 +127,7 @@ end
 
 Converts anything like `"png", :png, "image/png", MIME"image/png"()` to `"image/png"`.
 """
-function to_mime_string(mime::Union{String, Symbol, MIME})
+function to_mime_string(mime::Union{String,Symbol,MIME})
     if mime isa MIME
         mime_str = string(mime)
         if !(mime_str in SUPPORTED_MIMES)
@@ -150,7 +150,7 @@ The default is automatic, which lets the display system figure out the best mime
 If set to any other valid mime, will result in `showable(any_other_mime, figurelike)` to return false and only return true for `showable(preferred_mime, figurelike)`.
 Depending on the display system used, this may result in nothing getting displayed.
 """
-function disable_mime!(mimes::Union{String, Symbol, MIME}...)
+function disable_mime!(mimes::Union{String,Symbol,MIME}...)
     empty!(DISABLED_MIMES) # always start from 0
     if isempty(mimes)
         # Reset disabled mimes when called with no arguments
@@ -164,7 +164,7 @@ function disable_mime!(mimes::Union{String, Symbol, MIME}...)
     return
 end
 
-function enable_only_mime!(mimes::Union{String, Symbol, MIME}...)
+function enable_only_mime!(mimes::Union{String,Symbol,MIME}...)
     empty!(DISABLED_MIMES) # always start from 0
     if isempty(mimes)
         # Reset disabled mimes when called with no arguments

CairoMakie/src/infrastructure.jl

@@ -113,13 +113,13 @@ function draw_background(screen::Screen, scene::Scene)
     Cairo.save(cr)
     if scene.clear[]
         bg = scene.backgroundcolor[]
-        Cairo.set_source_rgba(cr, red(bg), green(bg), blue(bg), alpha(bg));
+        Cairo.set_source_rgba(cr, red(bg), green(bg), blue(bg), alpha(bg))
         r = viewport(scene)[]
         Cairo.rectangle(cr, origin(r)..., widths(r)...) # background
         fill(cr)
     end
     Cairo.restore(cr)
-    foreach(child_scene-> draw_background(screen, child_scene), scene.children)
+    foreach(child_scene -> draw_background(screen, child_scene), scene.children)
 end
 
 function draw_plot(scene::Scene, screen::Screen, primitive::Plot)

CairoMakie/src/overrides.jl

@@ -13,13 +13,13 @@ function draw_plot(scene::Scene, screen::Screen, poly::Poly)
     # so, we should also take a look at converted 
     # First, we check whether a `draw_poly` method exists for the input arguments
     # before conversion:
-    return if Base.hasmethod(draw_poly, Tuple{Scene, Screen, typeof(poly), typeof.(to_value.(poly.args))...})
+    return if Base.hasmethod(draw_poly, Tuple{Scene,Screen,typeof(poly),typeof.(to_value.(poly.args))...})
         draw_poly(scene, screen, poly, to_value.(poly.args)...)
-    # If not, we check whether a `draw_poly` method exists for the arguments after conversion
-    # (`plot.converted`).  This allows anything which decomposes to be checked for.
-    elseif Base.hasmethod(draw_poly, Tuple{Scene, Screen, typeof(poly), typeof.(to_value.(poly.converted))...})
+        # If not, we check whether a `draw_poly` method exists for the arguments after conversion
+        # (`plot.converted`).  This allows anything which decomposes to be checked for.
+    elseif Base.hasmethod(draw_poly, Tuple{Scene,Screen,typeof(poly),typeof.(to_value.(poly.converted))...})
         draw_poly(scene, screen, poly, to_value.(poly.converted)...)
-    # In the worst case, we return to drawing the polygon as a mesh + lines.
+        # In the worst case, we return to drawing the polygon as a mesh + lines.
     else
         draw_poly_as_mesh(scene, screen, poly)
     end
@@ -49,8 +49,8 @@ function draw_poly(scene::Scene, screen::Screen, poly, points::Vector{<:Point2})
 end
 
 # when color is a Makie.AbstractPattern, we don't need to go to Mesh
-function draw_poly(scene::Scene, screen::Screen, poly, points::Vector{<:Point2}, color::Union{Colorant, Cairo.CairoPattern},
-        model, strokecolor, strokestyle, strokewidth)
+function draw_poly(scene::Scene, screen::Screen, poly, points::Vector{<:Point2}, color::Union{Colorant,Cairo.CairoPattern},
+    model, strokecolor, strokestyle, strokewidth)
     space = to_value(get(poly, :space, :data))
     points = project_position.(Ref(poly), space, points, Ref(model))
     Cairo.move_to(screen.context, points[1]...)
@@ -75,7 +75,7 @@ function draw_poly(scene::Scene, screen::Screen, poly, points_list::Vector{<:Vec
 
     broadcast_foreach(points_list, color,
         strokecolor, strokestyle, poly.strokewidth[], Ref(poly.model[])) do points, color, strokecolor, strokestyle, strokewidth, model
-            draw_poly(scene, screen, poly, points, color, model, strokecolor, strokestyle, strokewidth)
+        draw_poly(scene, screen, poly, points, color, model, strokecolor, strokestyle, strokewidth)
     end
 end
 
@@ -180,7 +180,7 @@ function draw_poly(scene::Scene, screen::Screen, poly, polygons::AbstractArray{<
 
 end
 
-function draw_poly(scene::Scene, screen::Screen, poly, polygons::AbstractArray{<: MultiPolygon})
+function draw_poly(scene::Scene, screen::Screen, poly, polygons::AbstractArray{<:MultiPolygon})
     model = poly.model[]
     space = to_value(get(poly, :space, :data))
     projected_polys = project_multipolygon.(Ref(poly), space, polygons, Ref(model))
@@ -210,7 +210,7 @@ end
 ################################################################################
 
 function draw_plot(scene::Scene, screen::Screen,
-        band::Band{<:Tuple{<:AbstractVector{<:Point2},<:AbstractVector{<:Point2}}})
+    band::Band{<:Tuple{<:AbstractVector{<:Point2},<:AbstractVector{<:Point2}}})
 
     if !(band.color[] isa AbstractArray)
         color = to_cairo_color(band.color[], band)
@@ -262,7 +262,7 @@ function draw_plot(scene::Scene, screen::Screen, tric::Tricontourf)
     function draw_tripolys(polys, colornumbers, colors)
         for (i, (pol, colnum, col)) in enumerate(zip(polys, colornumbers, colors))
             polypath(screen.context, pol)
-            if i == length(colornumbers) || colnum != colornumbers[i+1]
+            if i == length(colornumbers) || colnum != colornumbers[i + 1]
                 set_source(screen.context, col)
                 Cairo.fill(screen.context)
             end

CairoMakie/src/precompiles.jl

@@ -16,8 +16,8 @@ let
     end
 end
 precompile(draw_atomic_scatter, (Scene, Cairo.CairoContext, Tuple{typeof(identity),typeof(identity)},
-                    Vector{ColorTypes.RGBA{Float32}}, Vec{2,Float32}, ColorTypes.RGBA{Float32},
-                    Float32, BezierPath, Vec{2,Float32}, Quaternionf,
-                    Mat4f, Vector{Point{2,Float32}},
-                    Mat4f, Makie.FreeTypeAbstraction.FTFont, Symbol,
-                    Symbol))
+    Vector{ColorTypes.RGBA{Float32}}, Vec{2,Float32}, ColorTypes.RGBA{Float32},
+    Float32, BezierPath, Vec{2,Float32}, Quaternionf,
+    Mat4f, Vector{Point{2,Float32}},
+    Mat4f, Makie.FreeTypeAbstraction.FTFont, Symbol,
+    Symbol))