desck 0.4.2

package/src/Rect.elm

@@ -0,0 +1,292 @@
+module Rect exposing (..)
+
+import Vec exposing (Vec2)
+
+
+type alias Rect =
+    { pos : Vec2
+    , size : Vec2
+    }
+
+
+type RectCoordinate
+    = PosX
+    | PosY
+    | SizeX
+    | SizeY
+
+
+rect2 : Vec2 -> Vec2 -> Rect
+rect2 pos size =
+    { pos = pos
+    , size = size
+    }
+
+
+rect4 : Float -> Float -> Float -> Float -> Rect
+rect4 x y w h =
+    rect2 (Vec.vec2 x y) (Vec.vec2 w h)
+
+
+rightCorner : Rect -> Vec2
+rightCorner rect =
+    Vec.add rect.pos rect.size
+
+
+includeRect : Rect -> Rect -> Rect
+includeRect r rect =
+    let
+        pos =
+            Vec.vec2 (min rect.pos.x r.pos.x) (min rect.pos.y r.pos.y)
+
+        corner =
+            Vec.max (rightCorner rect) (rightCorner r)
+    in
+    { pos = pos
+    , size = Vec.sub corner pos
+    }
+
+
+includeVec : Rect -> Vec2 -> Rect
+includeVec r v =
+    includeRect r (rect2 v Vec.zero)
+
+
+toPoints : Rect -> List Vec2
+toPoints r =
+    [ r.pos
+    , Vec.vec2 (r.pos.x + r.size.x) r.pos.y
+    , Vec.vec2 (r.pos.x + r.size.x) (r.pos.y + r.size.y)
+    , Vec.vec2 r.pos.x (r.pos.y + r.size.y)
+    ]
+
+
+fromPoints : List Vec2 -> Rect
+fromPoints points =
+    let
+        r =
+            rect2 (Vec.average points) Vec.zero
+    in
+    List.foldl (\p a -> includeVec a p) r points
+
+
+enlarge : Float -> Rect -> Rect
+enlarge f r =
+    let
+        v =
+            Vec.scale f Vec.one
+
+        v2 =
+            Vec.scale (f * 0.5) Vec.one
+    in
+    { pos = Vec.sub r.pos v2
+    , size = Vec.add r.size v
+    }
+
+
+shrink : Float -> Rect -> Rect
+shrink f r =
+    let
+        v =
+            Vec.scale f Vec.one
+
+        v2 =
+            Vec.scale (f * 0.5) Vec.one
+    in
+    { pos = Vec.add r.pos v2
+    , size = Vec.sub r.size v
+    }
+
+
+changeSize : Vec2 -> Rect -> Rect
+changeSize v r =
+    let
+        v2 =
+            Vec.scale 0.5 v
+    in
+    rect2 (Vec.add r.pos v2) (Vec.add r.size (Vec.scale -1.0 v))
+
+
+scale : Float -> Rect -> Rect
+scale f r =
+    let
+        size =
+            Vec.scale f r.size
+
+        change =
+            Vec.sub r.size size
+    in
+    changeSize change r
+
+
+normalizeRect : Vec2 -> Vec2 -> Rect
+normalizeRect a b =
+    let
+        pos =
+            Vec.min a b
+
+        corner =
+            Vec.max a b
+    in
+    rect2 pos (Vec.sub corner pos)
+
+
+hasPoint : Vec2 -> Rect -> Bool
+hasPoint p r =
+    r.pos.x <= p.x && r.pos.y <= p.y && r.pos.x + r.size.x >= p.x && r.pos.y + r.size.y >= p.y
+
+
+hasRect : Rect -> Rect -> Bool
+hasRect a b =
+    hasPoint b.pos a
+        && hasPoint (Vec.add b.pos b.size) a
+
+
+overlaps : Rect -> Rect -> Bool
+overlaps a b =
+    rectanglesIntersect ( a.pos.x, a.pos.y )
+        ( a.pos.x + a.size.x, a.pos.y + a.size.y )
+        ( b.pos.x, b.pos.y )
+        ( b.pos.x + b.size.x, b.pos.y + b.size.y )
+
+
+rectangleContains : Vec2 -> Vec2 -> Vec2 -> Vec2 -> Bool
+rectangleContains a1 b1 a2 b2 =
+    let
+        r =
+            normalizeRect a1 b1
+
+        c1 =
+            r.pos
+
+        d1 =
+            rightCorner r
+    in
+    c1.x < a2.x && d1.x > b2.x && c1.y < a2.y && d1.y > b2.y
+
+
+rectanglesIntersect : ( Float, Float ) -> ( Float, Float ) -> ( Float, Float ) -> ( Float, Float ) -> Bool
+rectanglesIntersect ( x1a, y1a ) ( x1b, y1b ) ( x2a, y2a ) ( x2b, y2b ) =
+    let
+        x1_min =
+            min x1a x1b
+
+        y1_min =
+            min y1a y1b
+
+        x1_max =
+            max x1a x1b
+
+        y1_max =
+            max y1a y1b
+
+        x2_min =
+            min x2a x2b
+
+        y2_min =
+            min y2a y2b
+
+        x2_max =
+            max x2a x2b
+
+        y2_max =
+            max y2a y2b
+    in
+    not (x1_max < x2_min || x2_max < x1_min || y1_max < y2_min || y2_max < y1_min)
+
+
+modifyRect : Rect -> Rect -> RectCoordinate -> Float -> Rect
+modifyRect rect factor rc v =
+    let
+        { pos, size } =
+            rect
+    in
+    case rc of
+        PosX ->
+            { rect | pos = Vec.setX (v * factor.pos.x) pos }
+
+        PosY ->
+            { rect | pos = Vec.setY (v * factor.pos.y) pos }
+
+        SizeX ->
+            { rect | size = Vec.setX (v * factor.size.x) size }
+
+        SizeY ->
+            { rect | size = Vec.setY (v * factor.size.y) size }
+
+
+minSized : Vec2 -> Rect -> Rect
+minSized minSize rect =
+    { rect | size = Vec.vec2 (max minSize.x rect.size.x) (max minSize.y rect.size.y) }
+
+
+center : Rect -> Vec2
+center r =
+    Vec.half r.size
+        |> Vec.add r.pos
+
+
+rectString : Rect -> String
+rectString r =
+    String.fromFloat r.pos.x
+        ++ " "
+        ++ String.fromFloat r.pos.y
+        ++ " "
+        ++ String.fromFloat r.size.x
+        ++ " "
+        ++ String.fromFloat r.size.y
+
+
+showRect : Rect -> String
+showRect r =
+    Vec.show r.pos ++ " : " ++ Vec.show r.size
+
+
+area : Rect -> Float
+area r =
+    r.size.x * r.size.y
+
+
+fitToCenter : Vec2 -> Vec2 -> Rect
+fitToCenter viewport window =
+    let
+        imgWidth =
+            viewport.x
+
+        imgHeight =
+            viewport.y
+
+        winWidth =
+            window.x
+
+        winHeight =
+            window.y
+
+        ratio =
+            min (winWidth / imgWidth) (winHeight / imgHeight)
+
+        w =
+            imgWidth * ratio
+
+        h =
+            imgHeight * ratio
+    in
+    { pos = Vec2 ((winWidth - w) / 2.0) ((winHeight - h) / 2.0), size = Vec2 w h }
+
+
+clamp : Rect -> Vec2 -> Vec2
+clamp r p =
+    Vec.vec2 (Basics.clamp r.pos.x (r.pos.x + r.size.x) p.x) (Basics.clamp r.pos.y (r.pos.y + r.size.y) p.y)
+
+
+type alias Rotation =
+    { angle : Float
+    , pivot : Vec2
+    }
+
+
+angled : Float -> Rotation
+angled a =
+    { pivot = Vec.half Vec.one
+    , angle = a
+    }

package/src/SaveFile.elm

@@ -0,0 +1,422 @@
+module SaveFile exposing (..)
+
+import Card exposing (Card)
+import Deck exposing (encodeModel, modelDecoder)
+import Json.Decode as D exposing (Decoder)
+import Json.Decode.Pipeline exposing (optional, required)
+import Json.Encode exposing (Value, bool, float, int, list, null, object, string)
+import Palette exposing (Color(..), Palette, colorAsString, colorFromString)
+import Project exposing (Project)
+import Rect exposing (Rect, Rotation)
+import Theme
+import Util exposing (..)
+import Vec exposing (Vec2)
+import Zone exposing (Anchor, Arrow, Border, Grid, Head, Stamp, Text, Zone, headFromString, headString)
+
+
+
+-- TODO implement version field
+
+
+type alias Settings =
+    { embedSymbols : Bool
+    , stripData : Bool
+    , mapColors : Bool
+    , mapFont : Bool
+    , primaryFont : Maybe String
+    , secondaryFont : Maybe String
+    , heightPixels : Int
+    }
+
+
+default_settings : Settings
+default_settings =
+    { embedSymbols = True
+    , stripData = False
+    , mapColors = True
+    , mapFont = True
+    , primaryFont = Nothing
+    , secondaryFont = Nothing
+    , heightPixels = 128
+    }
+
+
+type alias SaveFile =
+    { name : String
+    , project : Project
+    , palette : Palette
+    , settings : Settings
+    }
+
+
+
+-- hsl : Float -> Float -> Float -> C.Color
+-- hsl h s l =
+--     C.fromHsla { hue = h, saturation = s, lightness = l, alpha = 1.0 }
+-- colorDecoder : Decoder Color
+-- colorDecoder =
+-- D.map3 hsl
+--     (D.field "h" D.float)
+--     (D.field "s" D.float)
+--     (D.field "l" D.float)
+
+
+anchorDecoder : Decoder Anchor
+anchorDecoder =
+    enumDecoder
+        (\s -> Just <| Zone.anchorFromString s)
+
+
+paletteDecoder : Decoder Palette
+paletteDecoder =
+    D.succeed Palette
+        |> required "black" D.string
+        |> required "white" D.string
+        |> required "red" D.string
+        |> required "orange" D.string
+        |> required "yellow" D.string
+        |> required "green" D.string
+        |> required "cyan" D.string
+        |> required "blue" D.string
+        |> required "violet" D.string
+        |> required "pink" D.string
+        |> required "darkGray" D.string
+        |> required "midGray" D.string
+        |> required "lightGray" D.string
+
+
+
+-- encodeColor : C.Color -> Value
+-- encodeColor c =
+--     let
+--         { hue, saturation, lightness } =
+--             C.toHsla c
+--     in
+--     object
+--         [ ( "h", float hue )
+--         , ( "s", float saturation )
+--         , ( "l", float lightness )
+--         ]
+
+
+encodePalette : Palette -> Value
+encodePalette p =
+    object
+        [ ( "black", string p.black )
+        , ( "white", string p.white )
+        , ( "red", string p.red )
+        , ( "orange", string p.orange )
+        , ( "yellow", string p.yellow )
+        , ( "green", string p.green )
+        , ( "cyan", string p.cyan )
+        , ( "blue", string p.blue )
+        , ( "violet", string p.violet )
+        , ( "pink", string p.pink )
+        , ( "darkGray", string p.darkGray )
+        , ( "midGray", string p.midGray )
+        , ( "lightGray", string p.lightGray )
+        ]
+
+
+color : Color -> Value
+color c =
+    string <| colorAsString c
+
+
+encodeArrow : Arrow -> Value
+encodeArrow a =
+    object
+        [ ( "from", string a.from )
+        , ( "to", string a.to )
+        , ( "id", string a.id )
+        , ( "fill", color a.fill )
+        , ( "width", float a.width )
+        , ( "head", string <| headString a.head )
+        ]
+
+
+fromResult : Result a b -> Decoder b
+fromResult result =
+    case result of
+        Ok a ->
+            D.succeed a
+
+        Err _ ->
+            D.fail "error decoding"
+
+
+vec2Decoder : Decoder Vec2
+vec2Decoder =
+    D.map2 Vec2
+        (D.field "x" D.float)
+        (D.field "y" D.float)
+
+
+rectDecoder : Decoder Rect
+rectDecoder =
+    D.map2 Rect
+        (D.field "pos" vec2Decoder)
+        (D.field "size" vec2Decoder)
+
+
+cardDecoder : Decoder Card
+cardDecoder =
+    D.map7 Card
+        (D.field "model" modelDecoder)
+        (D.field "rect" rectDecoder)
+        (D.field "rot" rotDecoder)
+        (D.field "front" D.bool)
+        (D.field "highlight" D.bool)
+        (D.field "id" D.string)
+        (D.field "z" D.int)
+
+
+paletteColorDecoder : Decoder Color
+paletteColorDecoder =
+    D.string
+        |> D.andThen
+            (\str ->
+                D.succeed <| colorFromString str
+            )
+
+
+borderDecode : Decoder Border
+borderDecode =
+    D.map3 Border
+        (D.field "color" paletteColorDecoder)
+        (D.field "width" D.int)
+        (D.field "dash" D.int)
+
+
+textDecoder : Decoder Text
+textDecoder =
+    D.map5 Text
+        (D.field "label" D.string)
+        (D.field "color" paletteColorDecoder)
+        (D.field "size" D.int)
+        (D.field "primary" D.bool)
+        (D.field "anchor" anchorDecoder)
+
+
+gridDecoder : Decoder Grid
+gridDecoder =
+    D.map2 Grid
+        (D.field "rows" D.int)
+        (D.field "columns" D.int)
+
+
+rotDecoder : Decoder Rotation
+rotDecoder =
+    D.map2 Rotation
+        (D.field "angle" D.float)
+        (D.field "pivot" vec2Decoder)
+
+
+zoneDecoder : Decoder Zone
+zoneDecoder =
+    D.map7 Zone
+        (D.field "rect" rectDecoder)
+        (D.field "rot" rotDecoder)
+        (D.field "id" D.string)
+        (D.field "fill" paletteColorDecoder)
+        (D.field "border" borderDecode)
+        (D.field "text" textDecoder)
+        (D.field "grid" gridDecoder)
+
+
+headDecoder : Decoder Head
+headDecoder =
+    enumDecoder
+        (\s -> Just <| headFromString s)
+
+
+arrowDecoder : Decoder Arrow
+arrowDecoder =
+    D.map6 Arrow
+        (D.field "from" D.string)
+        (D.field "to" D.string)
+        (D.field "id" D.string)
+        (D.field "fill" paletteColorDecoder)
+        (D.field "width" D.float)
+        (D.field "head" headDecoder)
+
+
+settingsDecoder : Decoder Settings
+settingsDecoder =
+    D.succeed Settings
+        |> optional "embedSymbols" D.bool False
+        |> optional "stripData" D.bool False
+        |> optional "mapColors" D.bool True
+        |> optional "mapFont" D.bool True
+        |> optional "primaryFont" (D.nullable D.string) Nothing
+        |> optional "secondaryFont" (D.nullable D.string) Nothing
+        |> optional "heightPixels" D.int 128
+
+
+stampDecoder : Decoder Stamp
+stampDecoder =
+    D.map5 Stamp
+        (D.field "pos" vec2Decoder)
+        (D.field "id" D.string)
+        (D.field "text" textDecoder)
+        (D.field "fill" paletteColorDecoder)
+        (D.field "radius" D.float)
+
+
+projectDecoder : Decoder Project
+projectDecoder =
+    D.succeed Project
+        |> required "description" D.string
+        |> required "background" paletteColorDecoder
+        |> required "viewport" rectDecoder
+        |> required "cards" (D.list cardDecoder)
+        |> required "zones" (D.list zoneDecoder)
+        |> required "arrows" (D.list arrowDecoder)
+        |> required "stamps" (D.list stampDecoder)
+
+
+saveFileDecoder : Decoder SaveFile
+saveFileDecoder =
+    D.succeed SaveFile
+        |> required "name" D.string
+        |> required "project" projectDecoder
+        |> optional "palette" paletteDecoder Theme.default
+        |> optional "settings" settingsDecoder default_settings
+
+
+decodeSaveFile : String -> Result D.Error SaveFile
+decodeSaveFile s =
+    D.decodeString saveFileDecoder s
+
+
+encodeVec2 : Vec2 -> Value
+encodeVec2 p =
+    object
+        [ ( "x", float <| p.x )
+        , ( "y", float <| p.y )
+        ]
+
+
+encodeRect : Rect -> Value
+encodeRect r =
+    object
+        [ ( "pos", encodeVec2 r.pos )
+        , ( "size", encodeVec2 r.size )
+        ]
+
+
+encodeRot : Rotation -> Value
+encodeRot r =
+    object
+        [ ( "angle", float r.angle )
+        , ( "pivot", encodeVec2 r.pivot )
+        ]
+
+
+encodeCard : Card -> Value
+encodeCard c =
+    object
+        [ ( "model", encodeModel c.model )
+        , ( "rect", encodeRect c.rect )
+        , ( "rot", encodeRot c.rot )
+        , ( "front", bool c.front )
+        , ( "highlight", bool c.highlight )
+        , ( "id", string c.id )
+        , ( "z", int c.z )
+        ]
+
+
+encodeBorder : Border -> Value
+encodeBorder b =
+    object
+        [ ( "color", color b.color )
+        , ( "width", int b.width )
+        , ( "dash", int b.dash )
+        ]
+
+
+encodeGrid : Grid -> Value
+encodeGrid g =
+    object
+        [ ( "rows", int g.rows )
+        , ( "columns", int g.columns )
+        ]
+
+
+encodeAnchor : Anchor -> Value
+encodeAnchor a =
+    string <| Zone.anchorString a
+
+
+encodeText : Text -> Value
+encodeText t =
+    object
+        [ ( "label", string t.label )
+        , ( "color", color t.color )
+        , ( "size", int t.size )
+        , ( "primary", bool t.primary )
+        , ( "anchor", encodeAnchor t.anchor )
+        ]
+
+
+encodeZone : Zone -> Value
+encodeZone z =
+    object
+        [ ( "id", string z.id )
+        , ( "rect", encodeRect z.rect )
+        , ( "rot", encodeRot z.rot )
+        , ( "fill", color z.fill )
+        , ( "border", encodeBorder z.border )
+        , ( "text", encodeText z.text )
+        , ( "grid", encodeGrid z.grid )
+        ]
+
+
+encodeStamp : Stamp -> Value
+encodeStamp s =
+    object
+        [ ( "pos", encodeVec2 s.pos )
+        , ( "id", string s.id )
+        , ( "text", encodeText s.text )
+        , ( "fill", color s.fill )
+        , ( "radius", float s.radius )
+        ]
+
+
+encodeSettings : Settings -> Value
+encodeSettings settings =
+    object
+        [ ( "embedSymbols", bool settings.embedSymbols )
+        , ( "stripData", bool settings.stripData )
+        , ( "mapColors", bool settings.mapColors )
+        , ( "mapFont", bool settings.mapFont )
+        , ( "primaryFont"
+          , Maybe.map string settings.primaryFont |> Maybe.withDefault null
+          )
+        , ( "secondaryFont"
+          , Maybe.map string settings.secondaryFont |> Maybe.withDefault null
+          )
+        ]
+
+
+encodeProject : Project -> Value
+encodeProject project =
+    object
+        [ ( "description", string project.description )
+        , ( "background", color project.background )
+        , ( "viewport", encodeRect project.viewport )
+        , ( "cards", list encodeCard project.cards )
+        , ( "zones", list encodeZone project.zones )
+        , ( "arrows", list encodeArrow project.arrows )
+        , ( "stamps", list encodeStamp project.stamps )
+        ]
+
+
+encodeSaveFile : SaveFile -> Value
+encodeSaveFile pf =
+    object
+        [ ( "name", string pf.name )
+        , ( "project", encodeProject pf.project )
+        , ( "palette", encodePalette pf.palette )
+        , ( "settings", encodeSettings pf.settings )
+        ]