desck 0.4.2

package/src/Theme.elm

@@ -0,0 +1,99 @@
+module Theme exposing (..)
+
+import Palette exposing (Palette)
+
+
+defaultPalette : Palette
+defaultPalette =
+    { black = "#111111"
+    , white = "#eeeeee"
+    , red = "#df0000"
+    , orange = "#bb6600"
+    , yellow = "#ebeb0a"
+    , green = "#12be12"
+    , cyan = "#12be80"
+    , blue = "#1234de"
+    , violet = "#8212d3"
+    , pink = "#e212e2"
+    , darkGray = "#333333"
+    , midGray = "#666666"
+    , lightGray = "#aaaaaa"
+    }
+
+
+d : Palette
+d =
+    defaultPalette
+
+
+default : Palette
+default =
+    d
+
+
+dark : Palette
+dark =
+    { d
+        | white = d.black
+        , lightGray = d.darkGray
+        , darkGray = d.lightGray
+        , black = d.lightGray
+        , blue = d.lightGray
+        , yellow = d.darkGray
+        , red = d.red
+    }
+
+
+ink : Palette
+ink =
+    { black = "#000000", white = "#ffffff", red = "#ff5252", orange = "#d64d00", yellow = "#eede4f", green = "#db6039", cyan = "#ff2305", blue = "#450b8e", violet = "#841010", pink = "#c70c00", darkGray = "#333333", midGray = "#737373", lightGray = "#cccccc" }
+
+
+earth : Palette
+earth =
+    { black = "#303419", white = "#ffffff", red = "#d65f1f", orange = "#868a5c", yellow = "#ccc47f", green = "#677a48", cyan = "#222a2a", blue = "#587a1f", violet = "#412a2a", pink = "#f1bab6", darkGray = "#000000", midGray = "#758264", lightGray = "#ccdfb9" }
+
+
+gem : Palette
+gem =
+    { black = "#191d34", white = "#ffffff", red = "#ff4292", orange = "#e5e4c8", yellow = "#b69aa4", green = "#152c47", cyan = "#02435f", blue = "#00648f", violet = "#602f46", pink = "#f8afc5", darkGray = "#000000", midGray = "#81cedf", lightGray = "#bcebf5" }
+
+
+royal : Palette
+royal =
+    { black = "#003e52", white = "#ffffff", red = "#ff4d00", orange = "#ff7629", yellow = "#ff9900", green = "#3aa68c", cyan = "#1c5959", blue = "#008bc7", violet = "#a30000", pink = "#db4343", darkGray = "#0076a8", midGray = "#188686", lightGray = "#adfbdf" }
+
+
+mono : Palette
+mono =
+    { black = "#000000", white = "#ffffff", red = "#cc2e2e", orange = "#949494", yellow = "#b8b8b8", green = "#c4c4c4", cyan = "#e6e6e6", blue = "#2b2b2b", violet = "#3b3b3b", pink = "#4f4f4f", darkGray = "#141414", midGray = "#737373", lightGray = "#cccccc" }
+
+
+aqua : Palette
+aqua =
+    { black = "#000000", white = "#ffffff", red = "#21a198", orange = "#6f88b8", yellow = "#a5b7e3", green = "#8a9cff", cyan = "#ccddff", blue = "#0d2344", violet = "#002175", pink = "#2b3691", darkGray = "#010042", midGray = "#3852ad", lightGray = "#99afff" }
+
+
+gold : Palette
+gold =
+    { black = "#3d1d10", white = "#7d7d7d", red = "#ddab64", orange = "#dc7138", yellow = "#d0a27c", green = "#3db872", cyan = "#5bb2be", blue = "#000000", violet = "#ad53c6", pink = "#ee8bb6", darkGray = "#141414", midGray = "#424242", lightGray = "#f5f5f5" }
+
+
+old : Palette
+old =
+    { black = "#4a5440", white = "#fde6c4", red = "#e34a4a", orange = "#d6ad71", yellow = "#b58712", green = "#3b5450", cyan = "#527575", blue = "#43637a", violet = "#698996", pink = "#c48787", darkGray = "#2c2321", midGray = "#3f3631", lightGray = "#c5ac96" }
+
+
+themes : List ( String, Palette )
+themes =
+    [ ( "default", default )
+    , ( "dark", dark )
+    , ( "ink", ink )
+    , ( "earth", earth )
+    , ( "gem", gem )
+    , ( "royal", royal )
+    , ( "mono", mono )
+    , ( "aqua", aqua )
+    , ( "gold", gold )
+    , ( "old", old )
+    ]

package/src/Util.elm

@@ -0,0 +1,337 @@
+module Util exposing (..)
+
+import Char exposing (isHexDigit, toCode)
+import Hex
+import Html exposing (Attribute)
+import Json.Decode as Decode
+import List.Extra
+import Random exposing (Seed, initialSeed, step)
+import Random.List
+import Svg
+import Svg.Attributes as A
+import Svg.Events
+import Vec exposing (Vec2)
+
+
+type alias Id =
+    String
+
+
+url : String -> String
+url s =
+    "url(#" ++ s ++ ")"
+
+
+transform : String -> List Float -> String -> String
+transform op ls sep =
+    " "
+        ++ op
+        ++ "("
+        ++ (ls
+                |> List.map String.fromFloat
+                |> String.join sep
+           )
+        ++ ") "
+
+
+translate : Float -> Float -> String
+translate x y =
+    transform "translate" [ x, y ] ", "
+
+
+translateXY : Vec2 -> String
+translateXY pos =
+    translate pos.x pos.y
+
+
+rotate : Float -> String
+rotate deg =
+    transform "rotate" [ deg ] " "
+
+
+rotateXY : Float -> Float -> Float -> String
+rotateXY deg x y =
+    transform "rotate" [ deg, x, y ] " "
+
+
+pivotRotate : Vec2 -> Vec2 -> Vec2 -> Float -> String
+pivotRotate pivot pos size deg =
+    let
+        ( x, y ) =
+            Vec.tuple pos
+
+        ( px, py ) =
+            Vec.tuple pivot
+
+        ( w, h ) =
+            Vec.tuple size
+    in
+    rotateXY deg (x + w * px) (y + h * py)
+
+
+centerRotate : Vec2 -> Vec2 -> Float -> String
+centerRotate pos size deg =
+    let
+        ( x, y ) =
+            Vec.tuple pos
+
+        ( w, h ) =
+            Vec.tuple size
+    in
+    rotateXY deg (x + w / 2) (y + h / 2)
+
+
+bottomMiddleRotate : Vec2 -> Vec2 -> Float -> String
+bottomMiddleRotate pos size deg =
+    let
+        ( x, y ) =
+            Vec.tuple pos
+
+        ( w, h ) =
+            Vec.tuple size
+    in
+    rotateXY deg (x + w / 2) (y + h)
+
+
+scale : Float -> String
+scale s =
+    transform "scale" [ s ] " "
+
+
+scaleXY : Float -> Float -> String
+scaleXY x y =
+    transform "scale" [ x, y ] ", "
+
+
+hexValue : Char -> Int
+hexValue h =
+    if isHexDigit h then
+        let
+            c =
+                toCode h
+        in
+        if c >= 65 && c <= 70 then
+            c - 55
+
+        else if c >= 97 && c <= 102 then
+            c - 87
+
+        else
+            0
+
+    else
+        0
+
+
+
+-- else if c >= 48
+
+
+num : (String -> Svg.Attribute msg) -> Float -> Svg.Attribute msg
+num attr value =
+    attr (String.fromFloat value)
+
+
+shuffleList : Int -> List a -> List a
+shuffleList seed ls =
+    step (Random.List.shuffle ls) (initialSeed seed)
+        |> Tuple.first
+
+
+randomFloat : Int -> Float
+randomFloat seed =
+    step (Random.float 0 1) (initialSeed seed)
+        |> Tuple.first
+
+
+randomOffset : Int -> Float -> Float
+randomOffset i s =
+    randomFloat i * s - s * 0.5
+
+
+randf : Seed -> ( Float, Seed )
+randf seed =
+    step (Random.float 0 1) seed
+
+
+shuffleListSeed : Int -> List a -> ( List a, Seed )
+shuffleListSeed seed ls =
+    step (Random.List.shuffle ls) (initialSeed seed)
+
+
+
+-- fitToScreen : { viewportWidth : Float, viewportHeight : Float, winWidth : Float, winHeight : Float } -> { x : Float, y : Float, scaledWidth : Float, scaledHeight : Float }
+
+
+one : Vec2
+one =
+    Vec2 1.0 1.0
+
+
+moveTowardsLast : (a -> Bool) -> List a -> List a
+moveTowardsLast selector list =
+    case List.Extra.splitWhen selector list of
+        Just ( before, selected :: after ) ->
+            case after of
+                [] ->
+                    list
+
+                next :: rest ->
+                    List.concat [ before, next :: selected :: rest ]
+
+        _ ->
+            list
+
+
+mapNothing : (a -> b) -> Maybe a -> Maybe b -> Maybe b
+mapNothing fn ma mb =
+    case mb of
+        Nothing ->
+            Maybe.map fn ma
+
+        Just _ ->
+            mb
+
+
+generateDuplicateName : List String -> String -> String
+generateDuplicateName ls s =
+    if List.member s ls then
+        generateDuplicateName ls (s ++ "_")
+
+    else
+        s
+
+
+alwaysPreventDefault : msg -> ( msg, Bool )
+alwaysPreventDefault msg =
+    ( msg, True )
+
+
+onRightClick : msg -> Attribute msg
+onRightClick msg =
+    Svg.Events.preventDefaultOn "contextmenu" (Decode.map alwaysPreventDefault (Decode.succeed msg))
+
+
+
+-- onMiddleClick : msg -> H.Attribute msg
+-- onMiddleClick msg =
+--     E.on "click"
+--         (Decode.field "button" Decode.int
+--             |> Decode.andThen
+--                 (\button ->
+--                     if button == 1 then
+--                         Decode.succeed msg
+--                     else
+--                         Decode.fail "Not middle click"
+--                 )
+--         )
+
+
+onWheel : (Float -> msg) -> Attribute msg
+onWheel decoder =
+    Svg.Events.on "wheel" (Decode.map decoder (Decode.field "deltaY" Decode.float))
+
+
+onMouseMove : (Float -> Float -> msg) -> Attribute msg
+onMouseMove decoder =
+    Svg.Events.on "mousemove" (Decode.map2 decoder (Decode.field "offsetX" Decode.float) (Decode.field "offsetY" Decode.float))
+
+
+type alias DragEvent =
+    { x : Float
+    , y : Float
+    , button : Int
+    , altKey : Bool
+    , shiftKey : Bool
+    , ctrlKey : Bool
+    }
+
+
+type MouseButton
+    = LMB
+    | MMB
+    | RMB
+
+
+parseMouseButton : Int -> MouseButton
+parseMouseButton i =
+    case i of
+        1 ->
+            MMB
+
+        2 ->
+            RMB
+
+        _ ->
+            LMB
+
+
+enumDecoder : (String -> Maybe a) -> Decode.Decoder a
+enumDecoder toEnum =
+    Decode.string
+        |> Decode.andThen
+            (\str ->
+                case toEnum str of
+                    Just val ->
+                        Decode.succeed val
+
+                    Nothing ->
+                        Decode.fail ("Invalid enum value: " ++ str)
+            )
+
+
+positionDecoder : String -> Decode.Decoder DragEvent
+positionDecoder s =
+    Decode.map6 DragEvent
+        (Decode.field (s ++ "X") Decode.float)
+        (Decode.field (s ++ "Y") Decode.float)
+        (Decode.field "button" Decode.int)
+        (Decode.field "altKey" Decode.bool)
+        (Decode.field "shiftKey" Decode.bool)
+        (Decode.field "ctrlKey" Decode.bool)
+
+
+offsetDecoder : Decode.Decoder DragEvent
+offsetDecoder =
+    positionDecoder "offset"
+
+
+colorAsTuple : String -> ( Int, Int, Int )
+colorAsTuple color =
+    let
+        hex =
+            String.dropLeft 1 color
+
+        byte n h =
+            case Hex.fromString <| String.slice (n * 2) (n * 2 + 2) h of
+                Ok i ->
+                    i
+
+                Err _ ->
+                    0
+    in
+    ( byte 0 hex, byte 1 hex, byte 2 hex )
+
+
+tupleAsColor : ( Int, Int, Int ) -> String
+tupleAsColor ( r, g, b ) =
+    "#" ++ Hex.toString r ++ Hex.toString g ++ Hex.toString b
+
+
+tintMatrix : String -> String
+tintMatrix color =
+    let
+        ( r, g, b ) =
+            colorAsTuple color
+    in
+    (String.fromFloat <| toFloat r / 255.0) ++ " 0 0 0 0 \n0 " ++ (String.fromFloat <| toFloat g / 255.0) ++ " 0 0 0 \n0 0 " ++ (String.fromFloat <| toFloat b / 255.0) ++ " 0 0 \n0 0 0 1 0"
+
+
+tintFilter : String -> String -> Svg.Svg msg
+tintFilter name color =
+    Svg.filter
+        [ A.id name ]
+        [ Svg.feColorMatrix
+            [ A.values <| tintMatrix color ]
+            []
+        ]

package/src/Vec.elm

@@ -0,0 +1,196 @@
+module Vec exposing (..)
+
+
+type alias Vec2 =
+    { x : Float
+    , y : Float
+    }
+
+
+vec2 : Float -> Float -> Vec2
+vec2 x y =
+    { x = x, y = y }
+
+
+add : Vec2 -> Vec2 -> Vec2
+add a b =
+    Vec2 (a.x + b.x) (a.y + b.y)
+
+
+sub : Vec2 -> Vec2 -> Vec2
+sub a b =
+    Vec2 (a.x - b.x) (a.y - b.y)
+
+
+scale : Float -> Vec2 -> Vec2
+scale s a =
+    Vec2 (a.x * s) (a.y * s)
+
+
+div : Vec2 -> Vec2 -> Vec2
+div d a =
+    Vec2 (a.x / d.x) (a.y / d.y)
+
+
+mult : Vec2 -> Vec2 -> Vec2
+mult a b =
+    Vec2 (a.x * b.x) (a.y * b.y)
+
+
+tuple : Vec2 -> ( Float, Float )
+tuple a =
+    ( a.x, a.y )
+
+
+fromTuple : ( Float, Float ) -> Vec2
+fromTuple ( x, y ) =
+    { x = x
+    , y = y
+    }
+
+
+show : Vec2 -> String
+show v =
+    "(" ++ (String.fromFloat <| v.x) ++ " " ++ (String.fromFloat <| v.y) ++ ")"
+
+
+half : Vec2 -> Vec2
+half v =
+    Vec2 (v.x / 2.0) (v.y / 2.0)
+
+
+setX : Float -> Vec2 -> Vec2
+setX x v =
+    { v | x = x }
+
+
+setY : Float -> Vec2 -> Vec2
+setY y v =
+    { v | y = y }
+
+
+length : Vec2 -> Float
+length v =
+    sqrt (v.x ^ 2 + v.y ^ 2)
+
+
+normalize : Vec2 -> Vec2
+normalize v =
+    let
+        l =
+            length v
+    in
+    if l == 0 then
+        v
+
+    else
+        { x = v.x / l, y = v.y / l }
+
+
+direction : Vec2 -> Vec2 -> Vec2
+direction from to =
+    sub to from |> normalize
+
+
+distance : Vec2 -> Vec2 -> Float
+distance a b =
+    sub b a |> length
+
+
+lerp : Vec2 -> Vec2 -> Float -> Vec2
+lerp a b t =
+    add (scale (1.0 - t) a) (scale t b)
+
+
+zero : Vec2
+zero =
+    vec2 0.0 0.0
+
+
+one : Vec2
+one =
+    vec2 1.0 1.0
+
+
+max : Vec2 -> Vec2 -> Vec2
+max a b =
+    vec2 (Basics.max a.x b.x) (Basics.max a.y b.y)
+
+
+min : Vec2 -> Vec2 -> Vec2
+min a b =
+    vec2 (Basics.min a.x b.x) (Basics.min a.y b.y)
+
+
+path : Bool -> List Vec2 -> String
+path close points =
+    let
+        ps code v =
+            " " ++ code ++ " " ++ String.fromFloat v.x ++ " " ++ String.fromFloat v.y ++ " "
+    in
+    case points of
+        first :: rest ->
+            List.foldl
+                (\v a -> a ++ ps "L" v)
+                (ps "M" first)
+                rest
+                ++ (if close then
+                        " Z "
+
+                    else
+                        ""
+                   )
+
+        _ ->
+            ""
+
+
+average : List Vec2 -> Vec2
+average ls =
+    case ( List.head ls, List.tail ls ) of
+        ( Just first, Just rest ) ->
+            let
+                l =
+                    List.length ls |> toFloat
+            in
+            List.foldl (\p a -> add a p) first rest
+                |> div (vec2 l l)
+
+        ( Just first, Nothing ) ->
+            first
+
+        _ ->
+            zero
+
+
+rotate : Float -> Vec2 -> Vec2
+rotate radians v =
+    let
+        x =
+            v.x
+
+        y =
+            v.y
+    in
+    { x = x * cos radians - y * sin radians
+    , y = x * sin radians + y * cos radians
+    }
+
+
+rotateAround : Vec2 -> Float -> Vec2 -> Vec2
+rotateAround pivot degrees p =
+    let
+        rad =
+            pi / 180.0 * degrees
+
+        translated =
+            { x = p.x - pivot.x, y = p.y - pivot.y }
+
+        rotated =
+            { x = translated.x * cos rad - translated.y * sin rad
+            , y = translated.x * sin rad + translated.y * cos rad
+            }
+    in
+    { x = rotated.x + pivot.x
+    , y = rotated.y + pivot.y
+    }