wip: switching from ncurses to brick

2023-05-30 17:49:35 -04:00
parent 458554bef2
commit 227401461b
32 changed files with 400 additions and 446 deletions
@@ -21,15 +21,16 @@ along with this program.  If not, see <https://www.gnu.org/licenses/>.

 module Mtlstats.Control.CreateGoalie (createGoalieC) where

-import Control.Monad.Trans.State (gets, modify)
+import Brick.Widgets.Core (str)
+import Control.Monad.State.Class (gets, modify)
 import Lens.Micro ((^.), (.~), (?~), (%~), to)
-import qualified UI.NCurses as C

 import Mtlstats.Actions
 import Mtlstats.Format
 import Mtlstats.Handlers
 import Mtlstats.Prompt
 import Mtlstats.Types
+import Mtlstats.Util

 -- | Handles goalie creation
 createGoalieC :: CreateGoalieState -> Controller
@@ -48,33 +49,28 @@ getGoalieNameC = promptController goalieNamePrompt

 getRookieFlagC :: Controller
 getRookieFlagC = Controller
-  { drawController = const $ do
-    C.drawString "Is this goalie a rookie? (Y/N)"
-    return C.CursorInvisible
-  , handleController = \e -> do
+  { drawController = const $
+    str "Is this goalie a rookie? (Y/N)"
+  , handleController = \e ->
    modify $ case ynHandler e of
      Just True -> progMode.createGoalieStateL
        %~ (cgsRookieFlag ?~ True)
        .  (cgsActiveFlag ?~ True)
      rf -> progMode.createGoalieStateL.cgsRookieFlag .~ rf
-    return True
  }

 getActiveFlagC :: Controller
 getActiveFlagC = Controller
-  { drawController = const $ do
-    C.drawString "Is this goalie active? (Y/N)"
-    return C.CursorInvisible
-  , handleController = \e -> do
+  { drawController = const $ str "Is this goalie active? (Y/N)"
+  , handleController = \e ->
    modify $ progMode.createGoalieStateL.cgsActiveFlag .~ ynHandler e
-    return True
  }

 confirmCreateGoalieC :: Controller
 confirmCreateGoalieC = Controller
-  { drawController = \s -> do
-    let cgs = s^.progMode.createGoalieStateL
-    C.drawString $ unlines
+  { drawController = \s -> let
+    cgs = s^.progMode.createGoalieStateL
+    in linesToWidget
      $  labelTable
         [ ( "Goalie number", maybe "?" show $ cgs^.cgsNumber     )
         , ( "Goalie name",   cgs^.cgsName                        )
@@ -84,7 +80,6 @@ confirmCreateGoalieC = Controller
      ++ [ ""
         , "Create goalie: are you sure?  (Y/N)"
         ]
-    return C.CursorInvisible
  , handleController = \e -> do
    cgs <- gets (^.progMode.createGoalieStateL)
    let
@@ -103,5 +98,4 @@ confirmCreateGoalieC = Controller
            .  (egsCallback       .~ success)
      Just False -> failure
      Nothing    -> return ()
-    return True
  }
@@ -21,15 +21,16 @@ along with this program.  If not, see <https://www.gnu.org/licenses/>.

 module Mtlstats.Control.CreatePlayer (createPlayerC) where

-import Control.Monad.Trans.State (gets, modify)
+import Brick.Widgets.Core (str)
+import Control.Monad.State.Class (gets, modify)
 import Lens.Micro ((^.), (.~), (?~), (%~), to)
-import qualified UI.NCurses as C

 import Mtlstats.Actions
 import Mtlstats.Format
 import Mtlstats.Handlers
 import Mtlstats.Prompt
 import Mtlstats.Types
+import Mtlstats.Util

 -- | Handles player creation
 createPlayerC :: CreatePlayerState -> Controller
@@ -52,33 +53,26 @@ getPlayerPosC = promptController playerPosPrompt

 getRookieFlagC :: Controller
 getRookieFlagC = Controller
-  { drawController = const $ do
-    C.drawString "Is this player a rookie? (Y/N)"
-    return C.CursorInvisible
-  , handleController = \e -> do
+  { drawController = const $ str "Is this player a rookie? (Y/N)"
+  , handleController = \e ->
    modify $ case ynHandler e of
      Just True -> progMode.createPlayerStateL
        %~ (cpsRookieFlag ?~ True)
        .  (cpsActiveFlag ?~ True)
      rf -> progMode.createPlayerStateL.cpsRookieFlag .~ rf
-    return True
  }

 getActiveFlagC :: Controller
 getActiveFlagC = Controller
-  { drawController = const $ do
-    C.drawString "Is the player active? (Y/N)"
-    return C.CursorInvisible
-  , handleController = \e -> do
+  { drawController = const $ str "Is the player active? (Y/N)"
+  , handleController = \e ->
    modify $ progMode.createPlayerStateL.cpsActiveFlag .~ ynHandler e
-    return True
  }

 confirmCreatePlayerC :: Controller
 confirmCreatePlayerC = Controller
-  { drawController = \s -> do
-    let cps = s^.progMode.createPlayerStateL
-    C.drawString $ unlines
+  { drawController = \s -> let cps = s^.progMode.createPlayerStateL
+    in linesToWidget
      $  labelTable
         [ ( "Player number",   maybe "?" show $ cps^.cpsNumber     )
         , ( "Player name",     cps^.cpsName                        )
@@ -89,7 +83,6 @@ confirmCreatePlayerC = Controller
      ++ [ ""
         , "Create player: are you sure?  (Y/N)"
         ]
-    return C.CursorInvisible
  , handleController = \e -> do
    cps <- gets (^.progMode.createPlayerStateL)
    let
@@ -108,5 +101,4 @@ confirmCreatePlayerC = Controller
            .  (epsCallback       .~ success)
      Just False -> failure
      Nothing -> return ()
-    return True
  }
@@ -23,10 +23,11 @@ along with this program.  If not, see <https://www.gnu.org/licenses/>.

 module Mtlstats.Control.EditGoalie (editGoalieC) where

-import Control.Monad.Trans.State (gets, modify)
+import Brick.Types (Widget)
+import Brick.Widgets.Core (str, vBox)
+import Control.Monad.State.Class (gets, modify)
 import Data.Maybe (fromMaybe)
 import Lens.Micro ((^.), (.~), (%~))
-import UI.NCurses as C

 import Mtlstats.Actions
 import Mtlstats.Handlers
@@ -90,33 +91,19 @@ lifetimeMenuC _ = menuControllerWith header editGoalieLtMenu
 deleteC :: Action () -> Controller
 deleteC _ = Controller

-  { drawController = \s -> do
-
-    C.drawString $ let
-
-      hdr = fromMaybe [] $ do
-        gid    <- s^.progMode.editGoalieStateL.egsSelectedGoalie
-        goalie <- nth gid $ s^.database.dbGoalies
-        Just $ "Goalie: " ++ goalieDetails goalie ++ "\n\n"
-
-      in hdr ++ "Are you sure you want to delete this goalie? (Y/N)"
-
-    return C.CursorInvisible
-
-  , handleController = \e -> do
-
-    case ynHandler e of
-
-      Just True -> do
-        gets (^.progMode.editGoalieStateL.egsSelectedGoalie) >>= mapM_
-          (\gid -> modify $ database.dbGoalies %~ dropNth gid)
-        modify edit
-
-      Just False -> modify $ progMode.editGoalieStateL.egsMode .~ EGMenu
-      Nothing    -> return ()
-
-    return True
-
+  { drawController = \s -> let
+    hdr = fromMaybe "" $ do
+      gid    <- s^.progMode.editGoalieStateL.egsSelectedGoalie
+      goalie <- nth gid $ s^.database.dbGoalies
+      Just $ "Goalie: " ++ goalieDetails goalie ++ "\n\n"
+    in str $ hdr ++ "Are you sure you want to delete this goalie? (Y/N)"
+  , handleController = \e -> case ynHandler e of
+    Just True -> do
+      gets (^.progMode.editGoalieStateL.egsSelectedGoalie) >>= mapM_
+        (\gid -> modify $ database.dbGoalies %~ dropNth gid)
+      modify edit
+    Just False -> modify $ progMode.editGoalieStateL.egsMode .~ EGMenu
+    Nothing    -> return ()
  }

 ytdGamesC :: Bool -> Action () -> Controller
@@ -173,8 +160,11 @@ ltLossesC = curry $ promptController .
 ltTiesC :: Action () -> Controller
 ltTiesC = promptController . editGoalieLtTiesPrompt

-header :: ProgState -> C.Update ()
-header s = C.drawString $ fromMaybe "" $ do
-  gid <- s^.progMode.editGoalieStateL.egsSelectedGoalie
-  g   <- nth gid $ s^.database.dbGoalies
-  Just $ goalieDetails g ++ "\n"
+header :: ProgState -> Widget () -> Widget ()
+header s w = vBox
+  [ str $ fromMaybe "" $ do
+    gid <- s^.progMode.editGoalieStateL.egsSelectedGoalie
+    g   <- nth gid $ s^.database.dbGoalies
+    Just $ goalieDetails g
+  , w
+  ]
@@ -21,10 +21,11 @@ along with this program.  If not, see <https://www.gnu.org/licenses/>.

 module Mtlstats.Control.EditPlayer (editPlayerC) where

-import Control.Monad.Trans.State (gets, modify)
+import Brick.Types (Widget)
+import Brick.Widgets.Core (emptyWidget, str, vBox)
+import Control.Monad.State.Class (gets, modify)
 import Data.Maybe (fromMaybe)
 import Lens.Micro ((^.), (.~), (%~))
-import qualified UI.NCurses as C

 import Mtlstats.Actions
 import Mtlstats.Handlers
@@ -81,33 +82,19 @@ lifetimeC _ = menuControllerWith header editPlayerLtMenu
 deleteC :: Action () -> Controller
 deleteC _ = Controller

-  { drawController = \s -> do
-
-    C.drawString $ let
-
-      hdr = fromMaybe [] $ do
-        pid    <- s^.progMode.editPlayerStateL.epsSelectedPlayer
-        player <- nth pid $ s^.database.dbPlayers
-        Just $ "Player: " ++ playerDetails player ++ "\n\n"
-
-      in hdr ++ "Are you sure you want to delete this player? (Y/N)"
-
-    return C.CursorInvisible
-
-  , handleController = \e -> do
-
-    case ynHandler e of
-
-      Just True -> do
-        gets (^.progMode.editPlayerStateL.epsSelectedPlayer) >>= mapM_
-          (\pid -> modify $ database.dbPlayers %~ dropNth pid)
-        modify edit
-
-      Just False -> modify $ progMode.editPlayerStateL.epsMode .~ EPMenu
-      Nothing    -> return ()
-
-    return True
-
+  { drawController = \s -> let
+    hdr = fromMaybe [] $ do
+      pid    <- s^.progMode.editPlayerStateL.epsSelectedPlayer
+      player <- nth pid $ s^.database.dbPlayers
+      Just $ "Player: " ++ playerDetails player ++ "\n"
+    in str $ hdr ++ "Are you sure you want to delete this player? (Y/N)"
+  , handleController = \e -> case ynHandler e of
+    Just True -> do
+      gets (^.progMode.editPlayerStateL.epsSelectedPlayer) >>= mapM_
+        (\pid -> modify $ database.dbPlayers %~ dropNth pid)
+      modify edit
+    Just False -> modify $ progMode.editPlayerStateL.epsMode .~ EPMenu
+    Nothing    -> return ()
  }

 ytdGoalsC :: Bool -> Action () -> Controller
@@ -132,8 +119,11 @@ ltAssistsC batchMode callback = promptController $
 ltPMinC :: Action () -> Controller
 ltPMinC = promptController . editPlayerLtPMinPrompt

-header :: ProgState -> C.Update ()
-header s = C.drawString $ fromMaybe "" $ do
-  pid    <- s^.progMode.editPlayerStateL.epsSelectedPlayer
-  player <- nth pid $ s^.database.dbPlayers
-  Just $ playerDetails player ++ "\n"
+header :: ProgState -> Widget () -> Widget ()
+header s w = vBox
+  [ fromMaybe emptyWidget $ do
+    pid    <- s^.progMode.editPlayerStateL.epsSelectedPlayer
+    player <- nth pid $ s^.database.dbPlayers
+    Just $ str $ playerDetails player
+  , w
+  ]
@@ -23,8 +23,9 @@ along with this program.  If not, see <https://www.gnu.org/licenses/>.

 module Mtlstats.Control.EditStandings (editStandingsC) where

+import Brick.Types (Widget)
+import Brick.Widgets.Core (str, vBox)
 import Lens.Micro ((^.))
-import qualified UI.NCurses as C

 import Mtlstats.Format
 import Mtlstats.Menu
@@ -65,17 +66,16 @@ menuC = menuControllerWith header
 promptC :: Prompt -> Controller
 promptC = promptControllerWith header

-header :: ProgState -> C.Update ()
-header = do
-  db <- (^.database)
-  let
-    home  = db^.dbHomeGameStats
-    away  = db^.dbAwayGameStats
-    table = numTable ["   W", "   L", "  OT", "  GF", "  GA"]
+header :: ProgState -> Widget () -> Widget ()
+header s w = let
+  db    = s^.database
+  home  = db^.dbHomeGameStats
+  away  = db^.dbAwayGameStats
+  table  = numTable ["   W", "   L", "  OT", "  GF", "  GA"]
      [ ( "HOME", valsFor home )
      , ( "ROAD", valsFor away )
      ]
-  return $ C.drawString $ unlines $ table ++ [""]
+  in vBox $ map str (table ++ [""]) ++ [w]

 valsFor :: GameStats -> [Int]
 valsFor gs =
@@ -21,11 +21,23 @@ along with this program.  If not, see <https://www.gnu.org/licenses/>.

 module Mtlstats.Control.NewGame (newGameC) where

+import Brick.Main (vScrollBy, vScrollToBeginning)
+import Brick.Types
+  ( BrickEvent (VtyEvent)
+  , ViewportType (Vertical)
+  , Widget
+  )
+import Brick.Widgets.Center (hCenter)
+import Brick.Widgets.Core (str, vBox, viewport)
 import Control.Monad.IO.Class (liftIO)
-import Control.Monad.Trans.State (get, gets, modify)
+import Control.Monad.State.Class (get, gets, modify)
 import Data.Maybe (fromJust, fromMaybe, isJust)
+import Graphics.Vty.Input.Events
+  ( Event (EvKey)
+  , Key (KDown, KHome, KEnter, KUp)
+  )
 import Lens.Micro ((^.), (.~))
-import qualified UI.NCurses as C
+import Lens.Micro.Mtl (use)

 import Mtlstats.Actions
 import Mtlstats.Actions.NewGame
@@ -81,32 +93,30 @@ awayScoreC = promptControllerWith header awayScorePrompt

 overtimeFlagC :: Controller
 overtimeFlagC = Controller
-  { drawController = \s -> do
-    header s
-    C.drawString "Did the game go into overtime?  (Y/N)"
-    return C.CursorInvisible
-  , handleController = \e -> do
+  { drawController = \s -> header s $
+    str "Did the game go into overtime?  (Y/N)"
+  , handleController = \e ->
    modify $ progMode.gameStateL.overtimeFlag .~ ynHandler e
-    return True
  }

 verifyDataC :: Controller
 verifyDataC = Controller
-  { drawController = \s -> do
-    let gs = s^.progMode.gameStateL
-    header s
-    C.drawString "\n"
-    C.drawString $ unlines $ labelTable
+  { drawController = \s -> let
+    gs = s^.progMode.gameStateL
+    in header s $ vBox $ map str $
+    [""] ++
+    labelTable
      [ ( "Date",       gameDate gs                        )
      , ( "Game type",  show $ fromJust $ gs^.gameType     )
      , ( "Other team", gs^.otherTeam                      )
      , ( "Home score", show $ fromJust $ gs^.homeScore    )
      , ( "Away score", show $ fromJust $ gs^.awayScore    )
      , ( "Overtime",   show $ fromJust $ gs^.overtimeFlag )
-      ]
-    C.drawString "\nIs the above information correct?  (Y/N)"
-    return C.CursorInvisible
-  , handleController = \e -> do
+      ] ++
+    [ ""
+    , "Is the above information correct?  (Y/N)"
+    ]
+  , handleController = \e ->
    case ynHandler e of
      Just True  -> modify
        $ (progMode.gameStateL.dataVerified .~ True)
@@ -114,7 +124,6 @@ verifyDataC = Controller
        . awardShutouts
      Just False -> modify $ progMode.gameStateL .~ newGameState
      Nothing    -> return ()
-    return True
  }

 goalInput :: GameState -> Controller
@@ -131,7 +140,6 @@ recordGoalC = Controller
  , handleController = \e -> do
    (game, goal) <- gets gameGoal
    promptHandler (recordGoalPrompt game goal) e
-    return True
  }

 recordAssistC :: Controller
@@ -142,114 +150,97 @@ recordAssistC = Controller
  , handleController = \e -> do
    (game, goal, assist) <- gets gameGoalAssist
    promptHandler (recordAssistPrompt game goal assist) e
-    return True
  }

 confirmGoalDataC :: Controller
 confirmGoalDataC = Controller
-  { drawController = \s -> do
-    let
-      (game, goal) = gameGoal s
-      gs           = s^.progMode.gameStateL
-      players      = s^.database.dbPlayers
-      msg          = unlines $
-        [ "          Game: " ++ padNum 2 game
-        , "          Goal: " ++ show goal
-        , "Goal scored by: " ++
-          playerSummary (fromJust $ gs^.goalBy >>= flip nth players)
-        ] ++
-        map
-          (\pid -> "   Assisted by: " ++
-            playerSummary (fromJust $ nth pid players))
-          (gs^.assistsBy) ++
-        [ ""
-        , "Is the above information correct? (Y/N)"
-        ]
-    C.drawString msg
-    return C.CursorInvisible
+  { drawController = \s -> let
+    (game, goal) = gameGoal s
+    gs           = s^.progMode.gameStateL
+    players      = s^.database.dbPlayers
+    msg          =
+      [ "          Game: " ++ padNum 2 game
+      , "          Goal: " ++ show goal
+      , "Goal scored by: " ++
+        playerSummary (fromJust $ gs^.goalBy >>= flip nth players)
+      ] ++
+      map
+        ( \pid -> "   Assisted by: " ++
+          playerSummary (fromJust $ nth pid players)
+        )
+        (gs^.assistsBy) ++
+      [ ""
+      , "Is the above information correct? (Y/N)"
+      ]
+    in vBox $ map str msg
  , handleController = \e -> do
    case ynHandler e of
      Just True  -> modify recordGoalAssists
      Just False -> modify resetGoalData
      Nothing    -> return ()
-    return True
  }

 pMinPlayerC :: Controller
 pMinPlayerC = Controller
-  { drawController = \s -> do
-    header s
+  { drawController = \s -> header s $
    drawPrompt pMinPlayerPrompt s
-  , handleController = \e -> do
-    promptHandler pMinPlayerPrompt e
-    return True
+  , handleController = promptHandler pMinPlayerPrompt
  }

 getPMinsC :: Controller
 getPMinsC = Controller
-  { drawController = \s -> do
-    header s
-    C.drawString $ fromMaybe "" $ do
+  { drawController = \s ->  header s $ vBox
+    [ str $ fromMaybe "" $ do
      pid    <- s^.progMode.gameStateL.gameSelectedPlayer
      player <- nth pid $ s^.database.dbPlayers
-      Just $ playerSummary player ++ "\n"
-    drawPrompt assignPMinsPrompt s
-  , handleController = \e -> do
-    promptHandler assignPMinsPrompt e
-    return True
+      Just $ playerSummary player
+    , drawPrompt assignPMinsPrompt s
+    ]
+  , handleController = promptHandler assignPMinsPrompt
  }

 reportC :: Controller
 reportC = Controller
-  { drawController = \s -> do
-    (rows, cols) <- C.windowSize
-    C.drawString $ unlines $ slice
-      (s^.scrollOffset)
-      (fromInteger $ pred rows)
-      (displayReport (fromInteger $ pred cols) s)
-    return C.CursorInvisible
+  { drawController = viewport () Vertical . hCenter . vBox . map str .
+    displayReport reportCols
  , handleController = \e -> do
+    scr <- use scroller
    case e of
-      C.EventSpecialKey C.KeyUpArrow   -> modify scrollUp
-      C.EventSpecialKey C.KeyDownArrow -> modify scrollDown
-      C.EventSpecialKey C.KeyHome      -> modify $ scrollOffset .~ 0
-
-      C.EventCharacter '\n' -> do
-        get >>= liftIO . writeFile reportFilename . exportReport reportCols
-        modify backHome
-
+      VtyEvent (EvKey k []) -> case k of
+        KUp    -> vScrollBy scr (-1)
+        KDown  -> vScrollBy scr 1
+        KHome  -> vScrollToBeginning scr
+        KEnter -> do
+          get >>= liftIO . writeFile reportFilename . exportReport reportCols
+          modify backHome
+        _ -> return ()
      _ -> return ()
-    return True
  }

-header :: ProgState -> C.Update ()
-header s = C.drawString $
-  "*** GAME " ++ padNum 2 (s^.database.dbGames) ++ " ***\n"
+header :: ProgState -> Widget () -> Widget ()
+header s w = vBox
+  [ str $ "*** GAME " ++ padNum 2 (s^.database.dbGames) ++ " ***\n"
+  , w
+  ]

-monthHeader :: ProgState -> C.Update ()
-monthHeader s = do
-  (_, cols) <- C.windowSize
-  header s
-
-  let
-    table = labelTable $ zip (map show ([1..] :: [Int]))
-      [ "JANUARY"
-      , "FEBRUARY"
-      , "MARCH"
-      , "APRIL"
-      , "MAY"
-      , "JUNE"
-      , "JULY"
-      , "AUGUST"
-      , "SEPTEMBER"
-      , "OCTOBER"
-      , "NOVEMBER"
-      , "DECEMBER"
-      ]
-
-  C.drawString $ unlines $
-    map (centre $ fromIntegral $ pred cols) $
-      ["MONTH:", ""] ++ table ++ [""]
+monthHeader :: ProgState -> Widget () -> Widget ()
+monthHeader s w = let 
+  table = labelTable $ zip (map show ([1..] :: [Int]))
+    [ "JANUARY"
+    , "FEBRUARY"
+    , "MARCH"
+    , "APRIL"
+    , "MAY"
+    , "JUNE"
+    , "JULY"
+    , "AUGUST"
+    , "SEPTEMBER"
+    , "OCTOBER"
+    , "NOVEMBER"
+    , "DECEMBER"
+    ]
+  in header s $ vBox $ map (hCenter . str)
+    (["MONTH:", ""] ++ table ++ [""]) ++ [w]

 gameGoal :: ProgState -> (Int, Int)
 gameGoal s =
@@ -21,9 +21,10 @@ along with this program.  If not, see <https://www.gnu.org/licenses/>.

 module Mtlstats.Control.NewGame.GoalieInput (goalieInputC) where

+import Brick.Types (Widget)
+import Brick.Widgets.Core (str, vBox)
 import Data.Maybe (fromMaybe)
 import Lens.Micro ((^.))
-import qualified UI.NCurses as C

 import Mtlstats.Format
 import Mtlstats.Menu
@@ -52,11 +53,11 @@ goalsAllowedC = promptControllerWith header goalsAllowedPrompt
 selectGameGoalieC :: Controller
 selectGameGoalieC = menuStateController gameGoalieMenu

-header :: ProgState -> C.Update ()
-header s = C.drawString $ unlines
+header :: ProgState -> Widget () -> Widget ()
+header s w = vBox $ map str
  [ "*** GAME " ++ padNum 2 (s^.database.dbGames) ++ " ***"
  , fromMaybe "" $ do
    n <- s^.progMode.gameStateL.gameSelectedGoalie
    g <- nth n $ s^.database.dbGoalies
    Just $ goalieSummary g
-  ]
+  ] ++ [w]
@@ -23,34 +23,32 @@ along with this program.  If not, see <https://www.gnu.org/licenses/>.

 module Mtlstats.Control.TitleScreen (titleScreenC) where

-import Control.Monad.Trans.State (modify)
+import Brick.Types (BrickEvent (VtyEvent))
+import Brick.Widgets.Center (hCenter)
+import Brick.Widgets.Core (str, vBox)
+import Control.Monad.State.Class (modify)
 import Data.Char (chr)
-import qualified UI.NCurses as C
+import Graphics.Vty.Input.Events (Event (EvKey))

 import Mtlstats.Actions
-import Mtlstats.Format
 import Mtlstats.Types

 titleScreenC :: Controller
 titleScreenC = Controller
-  { drawController = const $ do
-    (_, cols) <- C.windowSize
-    C.drawString $ unlines $ map (centre $ fromIntegral $ pred cols)
-      $  [ ""
-         , "MONTREAL CANADIENS STATISTICS"
-         ]
-      ++ titleText
-      ++ [ ""
-         , "Copyright (C) 1984, 1985, 2019-2021, 2023 Rhéal Lamothe"
-         , "<rheal.lamothe@gmail.com>"
-         , ""
-         , "Press any key to continue..."
-         ]
-    return C.CursorInvisible
+  { drawController = const $ vBox $ map (hCenter . str)
+    $  [ ""
+       , "MONTREAL CANADIENS STATISTICS"
+       ]
+    ++ titleText
+    ++ [ ""
+       , "Copyright (C) 1984, 1985, 2019-2021, 2023 Rhéal Lamothe"
+       , "<rheal.lamothe@gmail.com>"
+       , ""
+       , "Press any key to continue..."
+       ]
  , handleController = \case
-    C.EventCharacter _  -> modify backHome >> return True
-    C.EventSpecialKey _ -> modify backHome >> return True
-    _                   -> return True
+    VtyEvent (EvKey _ _) -> modify backHome
+    _                   -> return ()
  }

 titleText :: [String]
@@ -60,7 +58,7 @@ titleText = box $ map (map blockify) $ foldl joinBlocks (repeat "")
 box :: [String] -> [String]
 box strs
  =  [[tl] ++ replicate width horiz ++ [tr]]
-  ++ map (\str -> [vert] ++ str ++ [vert]) strs
+  ++ map (\s -> [vert] ++ s ++ [vert]) strs
  ++ [[bl] ++ replicate width horiz ++ [br]]
  where
    width = length $ head strs