Transparency for layers/pad functions about brick HOT 6 CLOSED

bottomLeftCorner :: Widget a -> Widget a
bottomLeftCorner child =
  Widget Greedy Greedy $ do
    ctx <- getContext
    childResult <- render child
    let childHeight = result^.imageL.to imageHeight
        offsetX = 0
        offsetY = ctx^.availHeightL - childHeight
        offset = Location (offsetX, offsetY)
    return $ addResultOffset offset $ childResult & imageL .~ translateBy offset

marginLeft :: Padding -> Widget a -> Widget a
marginLeft padding p =
  let (pad, sz) = case padding of
        Max -> (id, Greedy)
        Pad i -> (const i, hSize p)
  in Widget sz (vSize p) $ do
      (availWidth, lim) <- calculateLim padding availWidthL
      result <- render $ hLimit lim p
      let offsetX = pad (availWidth - result^.imageL.to imageWidth)
          offset = Location (offsetX, 0)
      return $ addResultOffset offset $ result & imageL %~ translateX offsetX


marginRight :: Padding -> Widget a -> Widget a
marginRight padding p =
  let (pad, sz) = case padding of
        Max -> (id, Greedy)
        Pad i -> (const i, hSize p)
  in Widget sz (vSize p) $ do
      (availWidth, lim) <- calculateLim padding availWidthL
      result <- render $ hLimit lim p
      let childWidth = result^.imageL.to imageWidth
          width = childWidth + pad (availWidth - childWidth)
      return $ result & imageL %~ resizeWidth width


marginTop :: Padding -> Widget a -> Widget a
marginTop padding p =
  let (pad, sz) = case padding of
        Max -> (id, Greedy)
        Pad i -> (const i, vSize p)
  in Widget (hSize p) sz $ do
      (availHeight, lim) <- calculateLim padding availHeightL
      result <- render $ vLimit lim p
      let offsetY = pad (availHeight - result^.imageL.to imageHeight)
          offset = Location (0, offsetY)
      return $ addResultOffset offset $ result & imageL %~ translateY offsetY


marginBottom :: Padding -> Widget a -> Widget a
marginBottom padding p =
  let (pad, sz) = case padding of
        Max -> (id, Greedy)
        Pad i -> (const i, vSize p)
  in Widget (hSize p) sz $ do
      (availHeight, lim) <- calculateLim padding availHeightL
      result <- render $ vLimit lim p
      let childHeight = result^.imageL.to imageHeight
          height = childHeight + pad (availHeight - childHeight)
      return $ result & imageL %~ resizeHeight height


calculateLim :: Padding -> Lens' Context Int -> RenderM n (Int, Int)
calculateLim padding widthOrHeight = do
    c <- getContext
    let lim = case padding of
          Max -> c^.widthOrHeight
          Pad i -> c^.widthOrHeight - i
    return (c^.widthOrHeight, lim)