boxespy/boxes/generators/smallpartstray.py

#!/usr/bin/env python3
# Copyright (C) 2013-2016 Florian Festi
#
#   This program is free software: you can redistribute it and/or modify
#   it under the terms of the GNU General Public License as published by
#   the Free Software Foundation, either version 3 of the License, or
#   (at your option) any later version.
#
#   This program is distributed in the hope that it will be useful,
#   but WITHOUT ANY WARRANTY; without even the implied warranty of
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#   GNU General Public License for more details.
#
#   You should have received a copy of the GNU General Public License
#   along with this program.  If not, see <http://www.gnu.org/licenses/>.

from boxes import *
from boxes.edges import CompoundEdge

class SmallPartsTray(Boxes):
    """Tray with slants to easier get out game tokens or screws"""

    ui_group = "Tray"

    def __init__(self) -> None:
        Boxes.__init__(self)

        self.addSettingsArgs(edges.FingerJointSettings)
        # self.addSettingsArgs(edges.StackableSettings)

        self.buildArgParser(sx="50*3", y=100, h=30, outside=True)
        self.argparser.add_argument(
            "--angle",  action="store", type=float, default=45.,
            help="angle of the ramps")
        self.argparser.add_argument(
            "--rampheight",  action="store", type=float, default=.5,
            help="height of the ramps relative to to total height")
        self.argparser.add_argument(
            "--two_sided",  action="store", type=boolarg, default=True,
            help="have ramps on both sides. Enables sliding dividers")
        self.argparser.add_argument(
            "--front_panel",  action="store", type=boolarg, default=True,
            help="have a vertical wall at the ramp")
        

    def innerWall(self, h, y, ramp_h, ramp_y, two_ramps, front=True,
                  move=None):
        a = math.degrees(math.atan(ramp_h/ramp_y))
        l = (ramp_h**2 + ramp_y**2)**.5
        if two_ramps:
            self.polygonWall(
                [y-2*ramp_y, a, l, 90-a, h-ramp_h, 90, y,
                 90, h-ramp_h, 90-a, l, a],
                "fffeff" if front else "ffeeef", move=move)
        else:
            self.polygonWall(
                [y-ramp_y, 90, h, 90, y, 90, h-ramp_h, 90-a, l, a],
                "ffeff" if front else "ffeef", move=move)

    def outerWall(self, h, y, ramp_h, ramp_y, two_ramps, front=True,
                  move=None):
        a = math.degrees(math.atan(ramp_h/ramp_y))
        l = (ramp_h**2 + ramp_y**2)**.5
        t = self.thickness

        def cb():
            with self.saved_context():
                self.moveTo(ramp_y, 0, 180-a)
                self.fingerHolesAt(0, 0.5*t, l, 0)
            if two_ramps:
                self.moveTo(y-ramp_y, 0, a)
                self.fingerHolesAt(0, -0.5*t, l, 0)
        
        if two_ramps:
            self.rectangularWall(
                y, h,
                [CompoundEdge(self, "EFE", (ramp_y, y-2*ramp_y, ramp_y)),
                 CompoundEdge(self, "EF", (ramp_h, h-ramp_h)) if front else "e",
                 "e",
                 CompoundEdge(self, "FE", (h-ramp_h, ramp_h)) if front else "e"],
                callback=[cb], move=move)
        else:
            self.rectangularWall(
                y, h, [
                    CompoundEdge(self, "EF", (ramp_y, y-ramp_y)) if front else "e",
                    "F",
                    "e",
                    CompoundEdge(self, "FE", (h-ramp_h, ramp_h))],
                    callback=[cb], move=move)
            

    def holeCB(self, sections, height):
        def CB():
            pos = -0.5 * self.thickness
            for l in sections[:-1]:
                pos += l + self.thickness
                self.fingerHolesAt(pos, 0, height)
        return CB
            
    def render_simple_tray_divider(self, width, height, move):
        """
        Simple movable divider. A wall with small feet for a little more stability.
        """

        if self.move(width, height, move, True):
            return

        t = self.thickness
        self.moveTo(t)
        self.polyline(
            width - 2 * t,
            90,
            t,
            -90,
            t,
            90,
            height - t,
            90,
            width,
            90,
            height - t,
            90,
            t,
            -90,
            t,
            90,
        )

        self.move(width, height, move)

    def render_simple_tray_divider_feet(self, move=None):
        sqr2 = math.sqrt(2)
        t = self.thickness
        divider_foot_width = 2 * t
        full_width = t + 2 * divider_foot_width
        move_length = full_width / sqr2 + 2 * self.burn
        move_width = full_width / sqr2 + 2 * self.burn

        if self.move(move_width, move_length, move, True):
            return

        self.moveTo(self.burn)
        self.ctx.save()
        self.polyline(
            sqr2 * divider_foot_width,
            135,
            t,
            -90,
            t,
            -90,
            t,
            135,
            sqr2 * divider_foot_width,
            135,
            full_width,
            135,
        )
        self.ctx.restore()

        self.moveTo(-self.burn / sqr2, self.burn * (1 + 1 / sqr2), 45)
        self.moveTo(full_width)

        self.polyline(
            0,
            135,
            sqr2 * divider_foot_width,
            135,
            t,
            -90,
            t,
            -90,
            t,
            135,
            sqr2 * divider_foot_width,
            135,
        )

        self.move(move_width, move_length, move)


    def render(self):
        # adjust to the variables you want in the local scope
        sx, y, h = self.sx, self.y, self.h
        t = self.thickness
        a = self.angle
        b = "e"

        if self.outside:
            self.sx = sx = self.adjustSize(sx)
            self.h = h = self.adjustSize(h, False)
            dy = t if self.front_panel else t / 2**0.5
            self.y = y = self.adjustSize(y, dy, dy)

        x = sum(sx) + (len(sx)-1) * t

        ramp_h = h * self.rampheight
        ramp_y = ramp_h / math.tan(math.radians(a))

        if self.two_sided and (2*ramp_y + 3*t > y):
            ramp_y = (y - 3*t) / 2
            ramp_h = ramp_y * math.tan(math.radians(a))
        elif ramp_y > y - t:
            ramp_y = y - t
            ramp_h = ramp_y * math.tan(math.radians(a))

        ramp_l = (ramp_h**2 + ramp_y**2)**.5

        with self.saved_context():
            self.outerWall(h, y, ramp_h, ramp_y,
                           self.two_sided, self.front_panel, move="up")
            self.outerWall(h, y, ramp_h, ramp_y,
                           self.two_sided, self.front_panel, move="mirror up")
            for i in range(len(sx)-1):
                self.innerWall(h, y, ramp_h, ramp_y,
                               self.two_sided, self.front_panel, move="up")
        self.innerWall(h, y, ramp_h, ramp_y,
                       self.two_sided, self.front_panel, move="right only")

        if self.front_panel:
            self.rectangularWall(
                x, h-ramp_h, "efef",
                callback=[self.holeCB(sx, h-ramp_h)], move="up")
        self.rectangularWall(x, ramp_l, "efef",
                             callback=[self.holeCB(sx, ramp_l)], move="up")
        if self.two_sided:
            self.rectangularWall(
                x, y-2*ramp_y, "efef",
                callback=[self.holeCB(sx, y-2*ramp_y)], move="up")
            self.rectangularWall(
                x, ramp_l, "efef",
                callback=[self.holeCB(sx, ramp_l)], move="up")
            if self.front_panel:
                self.rectangularWall(
                    x, h-ramp_h, "efef",
                    callback=[self.holeCB(sx, h-ramp_h)], move="up")
        else:
            self.rectangularWall(
                x, y-ramp_y, "efff",
                callback=[self.holeCB(sx, y-ramp_y)], move="up")
            self.rectangularWall(
                x, h, "Ffef",
                callback=[self.holeCB(sx, h)], move="up")
            

        if self.two_sided:
            for l in self.sx:
                self.render_simple_tray_divider(l, h, move="right")

            self.partsMatrix(len(self.sx), 0, "right", self.render_simple_tray_divider_feet)