/src/Template/InfoArea.elm at 4652d530b5c39ed63c36e71c7ac1c9bb99189115

-- Copyright 2026 Shota FUJI
--
-- This Source Code Form is subject to the terms of the Mozilla Public
-- License, v. 2.0. If a copy of the MPL was not distributed with this
-- file, You can obtain one at https://mozilla.org/MPL/2.0/.
--
-- SPDX-License-Identifier: MPL-2.0


module Template.InfoArea exposing (infoArea)

import Length exposing (toMM)
import Parameters exposing (Parameters)
import QRCode
import Svg exposing (..)
import Svg.Attributes as Attrs exposing (..)
import Svg.Path as Path exposing (..)
import Template.Layout.Container as Container exposing (aligned, columns, gapped, noGrow, padded, rows, withOutline)
import Template.Layout.Coordinate exposing (Request(..))
import Template.Layout.Item exposing (Item)
import Url exposing (Url)


infoArea : Url -> Parameters -> Item msg
infoArea url params =
    rows
        |> withOutline
            { color = "currentColor"
            , width = 0.2
            , radius = 0.3
            }
        |> Container.build
            [ columns
                |> Container.build
                    ([ rows
                        |> Container.build
                            [ columns
                                |> gapped 5
                                |> aligned Container.End
                                |> padded 2
                                |> Container.build
                                    [ scaleChcker |> noGrow
                                    , legends params |> noGrow
                                    , legal
                                    ]
                            ]
                        |> Just
                     , if params.rendering.qrCode then
                        qrCode url

                       else
                        Nothing
                     ]
                        |> List.filterMap identity
                    )
            ]


scaleChcker : Item msg
scaleChcker =
    { size = { width = Exactly 10, height = Exactly 10 }
    , element =
        \p _ ->
            let
                x : Float -> String
                x n =
                    String.fromFloat (p.x + n)

                y : Float -> String
                y n =
                    String.fromFloat (p.y + n)
            in
            g
                []
                [ g
                    [ stroke "currentColor", strokeWidth "0.2" ]
                    [ line
                        [ x1 (x 0), y1 (y 8), x2 (x 0), y2 (y 10) ]
                        []
                    , line
                        [ x1 (x 0), y1 (y 9), x2 (x 10), y2 (y 9) ]
                        []
                    , line
                        [ x1 (x 10), y1 (y 8), x2 (x 10), y2 (y 10) ]
                        []
                    ]
                , text_
                    [ Attrs.x (x 5)
                    , Attrs.y (y 7)
                    , fontSize "3"
                    , fontWeight "100"
                    , textAnchor "middle"
                    , fill "currentColor"
                    ]
                    [ text "10mm" ]
                ]
    }


legal : Item msg
legal =
    rows
        |> gapped 0.5
        |> aligned Container.End
        |> Container.build
            [ Item
                { width = Exactly 33.2, height = Exactly 2 }
                (\p size ->
                    text_
                        [ x (String.fromFloat p.x)
                        , y (String.fromFloat p.y)
                        , fontSize (String.fromFloat size.height)
                        , fontWeight "100"
                        , textAnchor "left"
                        , dominantBaseline "hanging"
                        , fill "currentColor"
                        ]
                        [ text "© Shota FUJI, licensed under CC BY 4.0" ]
                )
            , Item
                { width = Exactly 61, height = Exactly 2 }
                (\p size ->
                    text_
                        [ x (String.fromFloat p.x)
                        , y (String.fromFloat p.y)
                        , fontSize (String.fromFloat size.height)
                        , fontWeight "100"
                        , textAnchor "left"
                        , dominantBaseline "hanging"
                        , fill "currentColor"
                        ]
                        [ text "Barlow font © 2017 The Barlow Project Authors, SIL Open Font License 1.1" ]
                )
            ]


legends : Parameters -> Item msg
legends params =
    rows
        |> gapped 2
        |> aligned Container.Start
        |> Container.build
            [ columns
                |> gapped 2
                |> aligned Container.Center
                |> Container.build
                    [ Item
                        { width = Exactly 8, height = Exactly 5 }
                        (\p size ->
                            Svg.path
                                [ Path.d
                                    [ MoveTo Absolute ( p.x, p.y + size.height / 2 )
                                    , HorizontalLineTo Relative size.width
                                    ]
                                , stroke "currentColor"
                                , strokeWidth (params.rendering.lineWidth |> toMM |> String.fromFloat)
                                ]
                                []
                        )
                    , Item
                        { width = Exactly 12, height = Exactly 4 }
                        (\p size ->
                            text_
                                [ x (String.fromFloat p.x)
                                , y (String.fromFloat p.y)
                                , fontSize (String.fromFloat size.height)
                                , fontWeight "100"
                                , textAnchor "left"
                                , dominantBaseline "hanging"
                                , fill "currentColor"
                                ]
                                [ text "Cut line" ]
                        )
                    ]
            , columns
                |> gapped 2
                |> aligned Container.Center
                |> Container.build
                    [ Item
                        { width = Exactly 8, height = Exactly 5 }
                        (\p size ->
                            rect
                                [ x (String.fromFloat p.x)
                                , y (String.fromFloat p.y)
                                , width (String.fromFloat size.width)
                                , height (String.fromFloat size.height)
                                , stroke "currentColor"
                                , strokeWidth "0.2"
                                , fill "url(#SkivingPattern)"
                                ]
                                []
                        )
                    , Item
                        { width = Exactly 21, height = Exactly 4 }
                        (\p size ->
                            text_
                                [ x (String.fromFloat p.x)
                                , y (String.fromFloat p.y)
                                , fontSize (String.fromFloat size.height)
                                , fontWeight "100"
                                , textAnchor "left"
                                , dominantBaseline "hanging"
                                , fill "currentColor"
                                ]
                                [ text "Skiving area" ]
                        )
                    ]
            , columns
                |> gapped 2
                |> aligned Container.Center
                |> Container.build
                    [ Item
                        { width = Exactly 8, height = Exactly 5 }
                        (\p size ->
                            g
                                [ fill "none"
                                , stroke "currentColor"
                                , strokeWidth "0.1"
                                ]
                                [ Svg.path
                                    [ Path.d
                                        [ MoveTo Absolute ( p.x + (size.width - size.height) / 2, p.y + size.height / 2 )
                                        , HorizontalLineTo Relative size.height
                                        ]
                                    ]
                                    []
                                , Svg.path
                                    [ Path.d
                                        [ MoveTo Absolute ( p.x + size.width / 2, p.y )
                                        , VerticalLineTo Relative size.height
                                        ]
                                    ]
                                    []
                                ]
                        )
                    , Item
                        { width = Exactly 12, height = Exactly 4 }
                        (\p size ->
                            text_
                                [ x (String.fromFloat p.x)
                                , y (String.fromFloat p.y)
                                , fontSize (String.fromFloat size.height)
                                , fontWeight "100"
                                , textAnchor "left"
                                , dominantBaseline "hanging"
                                , fill "currentColor"
                                ]
                                [ text "Hole center" ]
                        )
                    ]
            ]


qrCode : Url -> Maybe (Item msg)
qrCode url =
    QRCode.fromString (Url.toString url)
        |> Result.toMaybe
        |> Maybe.map
            (\pixels ->
                Item
                    { width = Exactly 50, height = Exactly 50 }
                    (\p size ->
                        QRCode.toSvg
                            [ width (String.fromFloat size.width)
                            , height (String.fromFloat size.height)
                            , x (String.fromFloat p.x)
                            , y (String.fromFloat p.y)
                            , stroke "currentColor"
                            ]
                            pixels
                    )
            )