module Chiasma.Ui.Data.View where

import Chiasma.Data.Ident (Ident, Identifiable(..))
import Control.Lens (Index, IxValue, Ixed(ix), makeClassy_)
import Control.Lens.Plated (Plated)
import Data.Data (Data)
import Data.Text.Prettyprint.Doc (Doc, Pretty(..), emptyDoc, nest, space, vsep, (<+>))
import Prelude hiding (state)

import Chiasma.Ui.Data.ViewGeometry (ViewGeometry)
import Chiasma.Ui.Data.ViewState (ViewState(ViewState))
import Chiasma.Ui.Lens.Ident (matchIdentP)

data Pane =
  Pane {
    Pane -> Bool
_open :: Bool,
    Pane -> Bool
_pin :: Bool,
    Pane -> Maybe FilePath
_cwd :: Maybe FilePath
  }
  deriving (Pane -> Pane -> Bool
(Pane -> Pane -> Bool) -> (Pane -> Pane -> Bool) -> Eq Pane
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Pane -> Pane -> Bool
$c/= :: Pane -> Pane -> Bool
== :: Pane -> Pane -> Bool
$c== :: Pane -> Pane -> Bool
Eq, Int -> Pane -> ShowS
[Pane] -> ShowS
Pane -> FilePath
(Int -> Pane -> ShowS)
-> (Pane -> FilePath) -> ([Pane] -> ShowS) -> Show Pane
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
showList :: [Pane] -> ShowS
$cshowList :: [Pane] -> ShowS
show :: Pane -> FilePath
$cshow :: Pane -> FilePath
showsPrec :: Int -> Pane -> ShowS
$cshowsPrec :: Int -> Pane -> ShowS
Show, Typeable Pane
DataType
Constr
Typeable Pane
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Pane -> c Pane)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Pane)
-> (Pane -> Constr)
-> (Pane -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Pane))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pane))
-> ((forall b. Data b => b -> b) -> Pane -> Pane)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pane -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pane -> r)
-> (forall u. (forall d. Data d => d -> u) -> Pane -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Pane -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Pane -> m Pane)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pane -> m Pane)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pane -> m Pane)
-> Data Pane
Pane -> DataType
Pane -> Constr
(forall b. Data b => b -> b) -> Pane -> Pane
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pane -> c Pane
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pane
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Pane -> u
forall u. (forall d. Data d => d -> u) -> Pane -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pane -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pane -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pane -> m Pane
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pane -> m Pane
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pane
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pane -> c Pane
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Pane)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pane)
$cPane :: Constr
$tPane :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Pane -> m Pane
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pane -> m Pane
gmapMp :: (forall d. Data d => d -> m d) -> Pane -> m Pane
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pane -> m Pane
gmapM :: (forall d. Data d => d -> m d) -> Pane -> m Pane
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pane -> m Pane
gmapQi :: Int -> (forall d. Data d => d -> u) -> Pane -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Pane -> u
gmapQ :: (forall d. Data d => d -> u) -> Pane -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Pane -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pane -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pane -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pane -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pane -> r
gmapT :: (forall b. Data b => b -> b) -> Pane -> Pane
$cgmapT :: (forall b. Data b => b -> b) -> Pane -> Pane
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pane)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pane)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Pane)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Pane)
dataTypeOf :: Pane -> DataType
$cdataTypeOf :: Pane -> DataType
toConstr :: Pane -> Constr
$ctoConstr :: Pane -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pane
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pane
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pane -> c Pane
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pane -> c Pane
$cp1Data :: Typeable Pane
Data, (forall x. Pane -> Rep Pane x)
-> (forall x. Rep Pane x -> Pane) -> Generic Pane
forall x. Rep Pane x -> Pane
forall x. Pane -> Rep Pane x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Pane x -> Pane
$cfrom :: forall x. Pane -> Rep Pane x
Generic)

makeClassy ''Pane

instance Default Pane where
  def :: Pane
def = Bool -> Bool -> Maybe FilePath -> Pane
Pane Bool
False Bool
False Maybe FilePath
forall a. Maybe a
Nothing

newtype Layout =
  Layout {
    Layout -> Bool
vertical :: Bool
  }
  deriving (Layout -> Layout -> Bool
(Layout -> Layout -> Bool)
-> (Layout -> Layout -> Bool) -> Eq Layout
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Layout -> Layout -> Bool
$c/= :: Layout -> Layout -> Bool
== :: Layout -> Layout -> Bool
$c== :: Layout -> Layout -> Bool
Eq, Int -> Layout -> ShowS
[Layout] -> ShowS
Layout -> FilePath
(Int -> Layout -> ShowS)
-> (Layout -> FilePath) -> ([Layout] -> ShowS) -> Show Layout
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
showList :: [Layout] -> ShowS
$cshowList :: [Layout] -> ShowS
show :: Layout -> FilePath
$cshow :: Layout -> FilePath
showsPrec :: Int -> Layout -> ShowS
$cshowsPrec :: Int -> Layout -> ShowS
Show, Typeable Layout
DataType
Constr
Typeable Layout
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Layout -> c Layout)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Layout)
-> (Layout -> Constr)
-> (Layout -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Layout))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Layout))
-> ((forall b. Data b => b -> b) -> Layout -> Layout)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Layout -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Layout -> r)
-> (forall u. (forall d. Data d => d -> u) -> Layout -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Layout -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Layout -> m Layout)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Layout -> m Layout)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Layout -> m Layout)
-> Data Layout
Layout -> DataType
Layout -> Constr
(forall b. Data b => b -> b) -> Layout -> Layout
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Layout -> c Layout
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Layout
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Layout -> u
forall u. (forall d. Data d => d -> u) -> Layout -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Layout -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Layout -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Layout -> m Layout
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Layout -> m Layout
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Layout
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Layout -> c Layout
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Layout)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Layout)
$cLayout :: Constr
$tLayout :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Layout -> m Layout
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Layout -> m Layout
gmapMp :: (forall d. Data d => d -> m d) -> Layout -> m Layout
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Layout -> m Layout
gmapM :: (forall d. Data d => d -> m d) -> Layout -> m Layout
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Layout -> m Layout
gmapQi :: Int -> (forall d. Data d => d -> u) -> Layout -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Layout -> u
gmapQ :: (forall d. Data d => d -> u) -> Layout -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Layout -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Layout -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Layout -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Layout -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Layout -> r
gmapT :: (forall b. Data b => b -> b) -> Layout -> Layout
$cgmapT :: (forall b. Data b => b -> b) -> Layout -> Layout
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Layout)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Layout)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Layout)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Layout)
dataTypeOf :: Layout -> DataType
$cdataTypeOf :: Layout -> DataType
toConstr :: Layout -> Constr
$ctoConstr :: Layout -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Layout
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Layout
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Layout -> c Layout
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Layout -> c Layout
$cp1Data :: Typeable Layout
Data, (forall x. Layout -> Rep Layout x)
-> (forall x. Rep Layout x -> Layout) -> Generic Layout
forall x. Rep Layout x -> Layout
forall x. Layout -> Rep Layout x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Layout x -> Layout
$cfrom :: forall x. Layout -> Rep Layout x
Generic)

makeClassy_ ''Layout

instance Default Layout where
  def :: Layout
def = Bool -> Layout
Layout Bool
True

data View a =
  View {
    View a -> Ident
_ident :: Ident,
    View a -> ViewState
_state :: ViewState,
    View a -> ViewGeometry
_geometry :: ViewGeometry,
    View a -> a
_extra :: a
  }
  deriving (View a -> View a -> Bool
(View a -> View a -> Bool)
-> (View a -> View a -> Bool) -> Eq (View a)
forall a. Eq a => View a -> View a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: View a -> View a -> Bool
$c/= :: forall a. Eq a => View a -> View a -> Bool
== :: View a -> View a -> Bool
$c== :: forall a. Eq a => View a -> View a -> Bool
Eq, Int -> View a -> ShowS
[View a] -> ShowS
View a -> FilePath
(Int -> View a -> ShowS)
-> (View a -> FilePath) -> ([View a] -> ShowS) -> Show (View a)
forall a. Show a => Int -> View a -> ShowS
forall a. Show a => [View a] -> ShowS
forall a. Show a => View a -> FilePath
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
showList :: [View a] -> ShowS
$cshowList :: forall a. Show a => [View a] -> ShowS
show :: View a -> FilePath
$cshow :: forall a. Show a => View a -> FilePath
showsPrec :: Int -> View a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> View a -> ShowS
Show, Typeable (View a)
DataType
Constr
Typeable (View a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> View a -> c (View a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (View a))
-> (View a -> Constr)
-> (View a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (View a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (View a)))
-> ((forall b. Data b => b -> b) -> View a -> View a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> View a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> View a -> r)
-> (forall u. (forall d. Data d => d -> u) -> View a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> View a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> View a -> m (View a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> View a -> m (View a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> View a -> m (View a))
-> Data (View a)
View a -> DataType
View a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (View a))
(forall b. Data b => b -> b) -> View a -> View a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> View a -> c (View a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (View a)
forall a. Data a => Typeable (View a)
forall a. Data a => View a -> DataType
forall a. Data a => View a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> View a -> View a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> View a -> u
forall a u. Data a => (forall d. Data d => d -> u) -> View a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> View a -> r
forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> View a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> View a -> m (View a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> View a -> m (View a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (View a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> View a -> c (View a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (View a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (View a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> View a -> u
forall u. (forall d. Data d => d -> u) -> View a -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> View a -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> View a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> View a -> m (View a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> View a -> m (View a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (View a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> View a -> c (View a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (View a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (View a))
$cView :: Constr
$tView :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> View a -> m (View a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> View a -> m (View a)
gmapMp :: (forall d. Data d => d -> m d) -> View a -> m (View a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> View a -> m (View a)
gmapM :: (forall d. Data d => d -> m d) -> View a -> m (View a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> View a -> m (View a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> View a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> View a -> u
gmapQ :: (forall d. Data d => d -> u) -> View a -> [u]
$cgmapQ :: forall a u. Data a => (forall d. Data d => d -> u) -> View a -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> View a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> View a -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> View a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> View a -> r
gmapT :: (forall b. Data b => b -> b) -> View a -> View a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> View a -> View a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (View a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (View a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (View a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (View a))
dataTypeOf :: View a -> DataType
$cdataTypeOf :: forall a. Data a => View a -> DataType
toConstr :: View a -> Constr
$ctoConstr :: forall a. Data a => View a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (View a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (View a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> View a -> c (View a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> View a -> c (View a)
$cp1Data :: forall a. Data a => Typeable (View a)
Data, (forall x. View a -> Rep (View a) x)
-> (forall x. Rep (View a) x -> View a) -> Generic (View a)
forall x. Rep (View a) x -> View a
forall x. View a -> Rep (View a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (View a) x -> View a
forall a x. View a -> Rep (View a) x
$cto :: forall a x. Rep (View a) x -> View a
$cfrom :: forall a x. View a -> Rep (View a) x
Generic)

makeClassy ''View

instance Default a => Default (View a) where
  def :: View a
def = Ident -> ViewState -> ViewGeometry -> a -> View a
forall a. Ident -> ViewState -> ViewGeometry -> a -> View a
View Ident
forall a. Default a => a
def ViewState
forall a. Default a => a
def ViewGeometry
forall a. Default a => a
def a
forall a. Default a => a
def

type PaneView = View Pane
type LayoutView = View Layout

instance Pretty Layout where
  pretty :: Layout -> Doc ann
pretty (Layout Bool
vertical) =
    if Bool
vertical then Doc ann
"▤" else Doc ann
"▥"

instance Pretty Pane where
  pretty :: Pane -> Doc ann
pretty (Pane Bool
open' Bool
pin' Maybe FilePath
_) =
    (if Bool
open' then Doc ann
"🔓" else Doc ann
"🔒") Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> (if Bool
pin' then Doc ann
"📌" else Doc ann
forall ann. Doc ann
emptyDoc)

prettyView :: Doc a -> Ident -> ViewState -> ViewGeometry -> Doc a
prettyView :: Doc a -> Ident -> ViewState -> ViewGeometry -> Doc a
prettyView Doc a
sym Ident
ident' (ViewState Bool
minimized) ViewGeometry
geo =
  Doc a
sym Doc a -> Doc a -> Doc a
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Ident -> Doc a
forall a ann. Pretty a => a -> Doc ann
pretty Ident
ident' Doc a -> Doc a -> Doc a
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc a
"⎸" Doc a -> Doc a -> Doc a
forall ann. Doc ann -> Doc ann -> Doc ann
<+> (if Bool
minimized then Doc a
"▂" Doc a -> Doc a -> Doc a
forall a. Semigroup a => a -> a -> a
<> Doc a
forall ann. Doc ann
space else Doc a
forall ann. Doc ann
emptyDoc) Doc a -> Doc a -> Doc a
forall a. Semigroup a => a -> a -> a
<> ViewGeometry -> Doc a
forall a ann. Pretty a => a -> Doc ann
pretty ViewGeometry
geo

instance Pretty (View Pane) where
  pretty :: View Pane -> Doc ann
pretty (View Ident
ident' ViewState
st ViewGeometry
geo Pane
a) =
    Doc ann -> Ident -> ViewState -> ViewGeometry -> Doc ann
forall a. Doc a -> Ident -> ViewState -> ViewGeometry -> Doc a
prettyView Doc ann
"◳" Ident
ident' ViewState
st ViewGeometry
geo Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Pane -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Pane
a

instance Pretty (View Layout) where
  pretty :: View Layout -> Doc ann
pretty (View Ident
ident' ViewState
st ViewGeometry
geo Layout
a) =
    Doc ann -> Ident -> ViewState -> ViewGeometry -> Doc ann
forall a. Doc a -> Ident -> ViewState -> ViewGeometry -> Doc a
prettyView (Layout -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Layout
a) Ident
ident' ViewState
st ViewGeometry
geo

consPane :: Ident -> PaneView
consPane :: Ident -> View Pane
consPane Ident
ident' = Ident -> ViewState -> ViewGeometry -> Pane -> View Pane
forall a. Ident -> ViewState -> ViewGeometry -> a -> View a
View Ident
ident' (Bool -> ViewState
ViewState Bool
False) ViewGeometry
forall a. Default a => a
def (Bool -> Bool -> Maybe FilePath -> Pane
Pane Bool
False Bool
False Maybe FilePath
forall a. Maybe a
Nothing)

consLayoutAs :: Bool -> Ident -> LayoutView
consLayoutAs :: Bool -> Ident -> View Layout
consLayoutAs Bool
vert Ident
ident' = Ident -> ViewState -> ViewGeometry -> Layout -> View Layout
forall a. Ident -> ViewState -> ViewGeometry -> a -> View a
View Ident
ident' (Bool -> ViewState
ViewState Bool
False) ViewGeometry
forall a. Default a => a
def (Bool -> Layout
Layout Bool
vert)

consLayout :: Ident -> LayoutView
consLayout :: Ident -> View Layout
consLayout =
  Bool -> Ident -> View Layout
consLayoutAs Bool
False

consLayoutVertical :: Ident -> LayoutView
consLayoutVertical :: Ident -> View Layout
consLayoutVertical =
  Bool -> Ident -> View Layout
consLayoutAs Bool
True

instance Identifiable (View a) where
  identify :: View a -> Ident
identify = View a -> Ident
forall a. View a -> Ident
_ident

-- split in two so there can be no lone leaves (panes without layout) as type 'Tree'
data Tree l p =
  Tree {
    Tree l p -> l
treeData :: l,
    Tree l p -> [TreeSub l p]
treeSubs :: [TreeSub l p]
    }
  deriving (Tree l p -> Tree l p -> Bool
(Tree l p -> Tree l p -> Bool)
-> (Tree l p -> Tree l p -> Bool) -> Eq (Tree l p)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall l p. (Eq l, Eq p) => Tree l p -> Tree l p -> Bool
/= :: Tree l p -> Tree l p -> Bool
$c/= :: forall l p. (Eq l, Eq p) => Tree l p -> Tree l p -> Bool
== :: Tree l p -> Tree l p -> Bool
$c== :: forall l p. (Eq l, Eq p) => Tree l p -> Tree l p -> Bool
Eq, Int -> Tree l p -> ShowS
[Tree l p] -> ShowS
Tree l p -> FilePath
(Int -> Tree l p -> ShowS)
-> (Tree l p -> FilePath)
-> ([Tree l p] -> ShowS)
-> Show (Tree l p)
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
forall l p. (Show l, Show p) => Int -> Tree l p -> ShowS
forall l p. (Show l, Show p) => [Tree l p] -> ShowS
forall l p. (Show l, Show p) => Tree l p -> FilePath
showList :: [Tree l p] -> ShowS
$cshowList :: forall l p. (Show l, Show p) => [Tree l p] -> ShowS
show :: Tree l p -> FilePath
$cshow :: forall l p. (Show l, Show p) => Tree l p -> FilePath
showsPrec :: Int -> Tree l p -> ShowS
$cshowsPrec :: forall l p. (Show l, Show p) => Int -> Tree l p -> ShowS
Show, Typeable (Tree l p)
DataType
Constr
Typeable (Tree l p)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Tree l p -> c (Tree l p))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Tree l p))
-> (Tree l p -> Constr)
-> (Tree l p -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Tree l p)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Tree l p)))
-> ((forall b. Data b => b -> b) -> Tree l p -> Tree l p)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Tree l p -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Tree l p -> r)
-> (forall u. (forall d. Data d => d -> u) -> Tree l p -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Tree l p -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Tree l p -> m (Tree l p))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Tree l p -> m (Tree l p))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Tree l p -> m (Tree l p))
-> Data (Tree l p)
Tree l p -> DataType
Tree l p -> Constr
(forall b. Data b => b -> b) -> Tree l p -> Tree l p
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tree l p -> c (Tree l p)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Tree l p)
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Tree l p))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Tree l p -> u
forall u. (forall d. Data d => d -> u) -> Tree l p -> [u]
forall l p. (Data l, Data p) => Typeable (Tree l p)
forall l p. (Data l, Data p) => Tree l p -> DataType
forall l p. (Data l, Data p) => Tree l p -> Constr
forall l p.
(Data l, Data p) =>
(forall b. Data b => b -> b) -> Tree l p -> Tree l p
forall l p u.
(Data l, Data p) =>
Int -> (forall d. Data d => d -> u) -> Tree l p -> u
forall l p u.
(Data l, Data p) =>
(forall d. Data d => d -> u) -> Tree l p -> [u]
forall l p r r'.
(Data l, Data p) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Tree l p -> r
forall l p r r'.
(Data l, Data p) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Tree l p -> r
forall l p (m :: * -> *).
(Data l, Data p, Monad m) =>
(forall d. Data d => d -> m d) -> Tree l p -> m (Tree l p)
forall l p (m :: * -> *).
(Data l, Data p, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Tree l p -> m (Tree l p)
forall l p (c :: * -> *).
(Data l, Data p) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Tree l p)
forall l p (c :: * -> *).
(Data l, Data p) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tree l p -> c (Tree l p)
forall l p (t :: * -> *) (c :: * -> *).
(Data l, Data p, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Tree l p))
forall l p (t :: * -> * -> *) (c :: * -> *).
(Data l, Data p, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Tree l p))
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Tree l p -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Tree l p -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Tree l p -> m (Tree l p)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tree l p -> m (Tree l p)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Tree l p)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tree l p -> c (Tree l p)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Tree l p))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Tree l p))
$cTree :: Constr
$tTree :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Tree l p -> m (Tree l p)
$cgmapMo :: forall l p (m :: * -> *).
(Data l, Data p, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Tree l p -> m (Tree l p)
gmapMp :: (forall d. Data d => d -> m d) -> Tree l p -> m (Tree l p)
$cgmapMp :: forall l p (m :: * -> *).
(Data l, Data p, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Tree l p -> m (Tree l p)
gmapM :: (forall d. Data d => d -> m d) -> Tree l p -> m (Tree l p)
$cgmapM :: forall l p (m :: * -> *).
(Data l, Data p, Monad m) =>
(forall d. Data d => d -> m d) -> Tree l p -> m (Tree l p)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Tree l p -> u
$cgmapQi :: forall l p u.
(Data l, Data p) =>
Int -> (forall d. Data d => d -> u) -> Tree l p -> u
gmapQ :: (forall d. Data d => d -> u) -> Tree l p -> [u]
$cgmapQ :: forall l p u.
(Data l, Data p) =>
(forall d. Data d => d -> u) -> Tree l p -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Tree l p -> r
$cgmapQr :: forall l p r r'.
(Data l, Data p) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Tree l p -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Tree l p -> r
$cgmapQl :: forall l p r r'.
(Data l, Data p) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Tree l p -> r
gmapT :: (forall b. Data b => b -> b) -> Tree l p -> Tree l p
$cgmapT :: forall l p.
(Data l, Data p) =>
(forall b. Data b => b -> b) -> Tree l p -> Tree l p
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Tree l p))
$cdataCast2 :: forall l p (t :: * -> * -> *) (c :: * -> *).
(Data l, Data p, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Tree l p))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Tree l p))
$cdataCast1 :: forall l p (t :: * -> *) (c :: * -> *).
(Data l, Data p, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Tree l p))
dataTypeOf :: Tree l p -> DataType
$cdataTypeOf :: forall l p. (Data l, Data p) => Tree l p -> DataType
toConstr :: Tree l p -> Constr
$ctoConstr :: forall l p. (Data l, Data p) => Tree l p -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Tree l p)
$cgunfold :: forall l p (c :: * -> *).
(Data l, Data p) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Tree l p)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tree l p -> c (Tree l p)
$cgfoldl :: forall l p (c :: * -> *).
(Data l, Data p) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tree l p -> c (Tree l p)
$cp1Data :: forall l p. (Data l, Data p) => Typeable (Tree l p)
Data, (forall x. Tree l p -> Rep (Tree l p) x)
-> (forall x. Rep (Tree l p) x -> Tree l p) -> Generic (Tree l p)
forall x. Rep (Tree l p) x -> Tree l p
forall x. Tree l p -> Rep (Tree l p) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l p x. Rep (Tree l p) x -> Tree l p
forall l p x. Tree l p -> Rep (Tree l p) x
$cto :: forall l p x. Rep (Tree l p) x -> Tree l p
$cfrom :: forall l p x. Tree l p -> Rep (Tree l p) x
Generic)

instance Bifunctor Tree where
  first :: (a -> b) -> Tree a c -> Tree b c
first a -> b
f (Tree a
l [TreeSub a c]
sub) = b -> [TreeSub b c] -> Tree b c
forall l p. l -> [TreeSub l p] -> Tree l p
Tree (a -> b
f a
l) ((TreeSub a c -> TreeSub b c) -> [TreeSub a c] -> [TreeSub b c]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> TreeSub a c -> TreeSub b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
f) [TreeSub a c]
sub)

  second :: (b -> c) -> Tree a b -> Tree a c
second b -> c
f (Tree a
l [TreeSub a b]
sub) =
    a -> [TreeSub a c] -> Tree a c
forall l p. l -> [TreeSub l p] -> Tree l p
Tree a
l ((TreeSub a b -> TreeSub a c) -> [TreeSub a b] -> [TreeSub a c]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((b -> c) -> TreeSub a b -> TreeSub a c
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second b -> c
f) [TreeSub a b]
sub)

instance Bifoldable Tree where
  bifoldMap :: (a -> m) -> (b -> m) -> Tree a b -> m
bifoldMap a -> m
fl b -> m
fr (Tree a
l [TreeSub a b]
sub) = m -> m -> m
forall a. Monoid a => a -> a -> a
mappend (a -> m
fl a
l) ((TreeSub a b -> m) -> [TreeSub a b] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap ((a -> m) -> (b -> m) -> TreeSub a b -> m
forall (p :: * -> * -> *) m a b.
(Bifoldable p, Monoid m) =>
(a -> m) -> (b -> m) -> p a b -> m
bifoldMap a -> m
fl b -> m
fr) [TreeSub a b]
sub)

data TreeSub l p =
  TreeNode { TreeSub l p -> Tree l p
_subTree :: Tree l p }
  |
  TreeLeaf { TreeSub l p -> p
_leafData :: p }
  deriving (TreeSub l p -> TreeSub l p -> Bool
(TreeSub l p -> TreeSub l p -> Bool)
-> (TreeSub l p -> TreeSub l p -> Bool) -> Eq (TreeSub l p)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall l p. (Eq l, Eq p) => TreeSub l p -> TreeSub l p -> Bool
/= :: TreeSub l p -> TreeSub l p -> Bool
$c/= :: forall l p. (Eq l, Eq p) => TreeSub l p -> TreeSub l p -> Bool
== :: TreeSub l p -> TreeSub l p -> Bool
$c== :: forall l p. (Eq l, Eq p) => TreeSub l p -> TreeSub l p -> Bool
Eq, Int -> TreeSub l p -> ShowS
[TreeSub l p] -> ShowS
TreeSub l p -> FilePath
(Int -> TreeSub l p -> ShowS)
-> (TreeSub l p -> FilePath)
-> ([TreeSub l p] -> ShowS)
-> Show (TreeSub l p)
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
forall l p. (Show l, Show p) => Int -> TreeSub l p -> ShowS
forall l p. (Show l, Show p) => [TreeSub l p] -> ShowS
forall l p. (Show l, Show p) => TreeSub l p -> FilePath
showList :: [TreeSub l p] -> ShowS
$cshowList :: forall l p. (Show l, Show p) => [TreeSub l p] -> ShowS
show :: TreeSub l p -> FilePath
$cshow :: forall l p. (Show l, Show p) => TreeSub l p -> FilePath
showsPrec :: Int -> TreeSub l p -> ShowS
$cshowsPrec :: forall l p. (Show l, Show p) => Int -> TreeSub l p -> ShowS
Show, Typeable (TreeSub l p)
DataType
Constr
Typeable (TreeSub l p)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TreeSub l p -> c (TreeSub l p))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (TreeSub l p))
-> (TreeSub l p -> Constr)
-> (TreeSub l p -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (TreeSub l p)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (TreeSub l p)))
-> ((forall b. Data b => b -> b) -> TreeSub l p -> TreeSub l p)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TreeSub l p -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TreeSub l p -> r)
-> (forall u. (forall d. Data d => d -> u) -> TreeSub l p -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TreeSub l p -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TreeSub l p -> m (TreeSub l p))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TreeSub l p -> m (TreeSub l p))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TreeSub l p -> m (TreeSub l p))
-> Data (TreeSub l p)
TreeSub l p -> DataType
TreeSub l p -> Constr
(forall b. Data b => b -> b) -> TreeSub l p -> TreeSub l p
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TreeSub l p -> c (TreeSub l p)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TreeSub l p)
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TreeSub l p))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> TreeSub l p -> u
forall u. (forall d. Data d => d -> u) -> TreeSub l p -> [u]
forall l p. (Data l, Data p) => Typeable (TreeSub l p)
forall l p. (Data l, Data p) => TreeSub l p -> DataType
forall l p. (Data l, Data p) => TreeSub l p -> Constr
forall l p.
(Data l, Data p) =>
(forall b. Data b => b -> b) -> TreeSub l p -> TreeSub l p
forall l p u.
(Data l, Data p) =>
Int -> (forall d. Data d => d -> u) -> TreeSub l p -> u
forall l p u.
(Data l, Data p) =>
(forall d. Data d => d -> u) -> TreeSub l p -> [u]
forall l p r r'.
(Data l, Data p) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TreeSub l p -> r
forall l p r r'.
(Data l, Data p) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TreeSub l p -> r
forall l p (m :: * -> *).
(Data l, Data p, Monad m) =>
(forall d. Data d => d -> m d) -> TreeSub l p -> m (TreeSub l p)
forall l p (m :: * -> *).
(Data l, Data p, MonadPlus m) =>
(forall d. Data d => d -> m d) -> TreeSub l p -> m (TreeSub l p)
forall l p (c :: * -> *).
(Data l, Data p) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TreeSub l p)
forall l p (c :: * -> *).
(Data l, Data p) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TreeSub l p -> c (TreeSub l p)
forall l p (t :: * -> *) (c :: * -> *).
(Data l, Data p, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (TreeSub l p))
forall l p (t :: * -> * -> *) (c :: * -> *).
(Data l, Data p, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TreeSub l p))
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TreeSub l p -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TreeSub l p -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TreeSub l p -> m (TreeSub l p)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TreeSub l p -> m (TreeSub l p)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TreeSub l p)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TreeSub l p -> c (TreeSub l p)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (TreeSub l p))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TreeSub l p))
$cTreeLeaf :: Constr
$cTreeNode :: Constr
$tTreeSub :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> TreeSub l p -> m (TreeSub l p)
$cgmapMo :: forall l p (m :: * -> *).
(Data l, Data p, MonadPlus m) =>
(forall d. Data d => d -> m d) -> TreeSub l p -> m (TreeSub l p)
gmapMp :: (forall d. Data d => d -> m d) -> TreeSub l p -> m (TreeSub l p)
$cgmapMp :: forall l p (m :: * -> *).
(Data l, Data p, MonadPlus m) =>
(forall d. Data d => d -> m d) -> TreeSub l p -> m (TreeSub l p)
gmapM :: (forall d. Data d => d -> m d) -> TreeSub l p -> m (TreeSub l p)
$cgmapM :: forall l p (m :: * -> *).
(Data l, Data p, Monad m) =>
(forall d. Data d => d -> m d) -> TreeSub l p -> m (TreeSub l p)
gmapQi :: Int -> (forall d. Data d => d -> u) -> TreeSub l p -> u
$cgmapQi :: forall l p u.
(Data l, Data p) =>
Int -> (forall d. Data d => d -> u) -> TreeSub l p -> u
gmapQ :: (forall d. Data d => d -> u) -> TreeSub l p -> [u]
$cgmapQ :: forall l p u.
(Data l, Data p) =>
(forall d. Data d => d -> u) -> TreeSub l p -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TreeSub l p -> r
$cgmapQr :: forall l p r r'.
(Data l, Data p) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TreeSub l p -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TreeSub l p -> r
$cgmapQl :: forall l p r r'.
(Data l, Data p) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TreeSub l p -> r
gmapT :: (forall b. Data b => b -> b) -> TreeSub l p -> TreeSub l p
$cgmapT :: forall l p.
(Data l, Data p) =>
(forall b. Data b => b -> b) -> TreeSub l p -> TreeSub l p
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TreeSub l p))
$cdataCast2 :: forall l p (t :: * -> * -> *) (c :: * -> *).
(Data l, Data p, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TreeSub l p))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (TreeSub l p))
$cdataCast1 :: forall l p (t :: * -> *) (c :: * -> *).
(Data l, Data p, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (TreeSub l p))
dataTypeOf :: TreeSub l p -> DataType
$cdataTypeOf :: forall l p. (Data l, Data p) => TreeSub l p -> DataType
toConstr :: TreeSub l p -> Constr
$ctoConstr :: forall l p. (Data l, Data p) => TreeSub l p -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TreeSub l p)
$cgunfold :: forall l p (c :: * -> *).
(Data l, Data p) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TreeSub l p)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TreeSub l p -> c (TreeSub l p)
$cgfoldl :: forall l p (c :: * -> *).
(Data l, Data p) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TreeSub l p -> c (TreeSub l p)
$cp1Data :: forall l p. (Data l, Data p) => Typeable (TreeSub l p)
Data, (forall x. TreeSub l p -> Rep (TreeSub l p) x)
-> (forall x. Rep (TreeSub l p) x -> TreeSub l p)
-> Generic (TreeSub l p)
forall x. Rep (TreeSub l p) x -> TreeSub l p
forall x. TreeSub l p -> Rep (TreeSub l p) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l p x. Rep (TreeSub l p) x -> TreeSub l p
forall l p x. TreeSub l p -> Rep (TreeSub l p) x
$cto :: forall l p x. Rep (TreeSub l p) x -> TreeSub l p
$cfrom :: forall l p x. TreeSub l p -> Rep (TreeSub l p) x
Generic)

instance Bifunctor TreeSub where
  first :: (a -> b) -> TreeSub a c -> TreeSub b c
first a -> b
f (TreeNode Tree a c
t) = Tree b c -> TreeSub b c
forall l p. Tree l p -> TreeSub l p
TreeNode ((a -> b) -> Tree a c -> Tree b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first a -> b
f Tree a c
t)
  first a -> b
_ (TreeLeaf c
p) = c -> TreeSub b c
forall l p. p -> TreeSub l p
TreeLeaf c
p

  second :: (b -> c) -> TreeSub a b -> TreeSub a c
second b -> c
f (TreeNode Tree a b
t) = Tree a c -> TreeSub a c
forall l p. Tree l p -> TreeSub l p
TreeNode ((b -> c) -> Tree a b -> Tree a c
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second b -> c
f Tree a b
t)
  second b -> c
f (TreeLeaf b
p) = c -> TreeSub a c
forall l p. p -> TreeSub l p
TreeLeaf (b -> c
f b
p)

instance Bifoldable TreeSub where
  bifoldMap :: (a -> m) -> (b -> m) -> TreeSub a b -> m
bifoldMap a -> m
fl b -> m
fr (TreeNode Tree a b
t) = (a -> m) -> (b -> m) -> Tree a b -> m
forall (p :: * -> * -> *) m a b.
(Bifoldable p, Monoid m) =>
(a -> m) -> (b -> m) -> p a b -> m
bifoldMap a -> m
fl b -> m
fr Tree a b
t
  bifoldMap a -> m
_ b -> m
fr (TreeLeaf b
p) = b -> m
fr b
p

instance (Data l, Data p) => Plated (Tree l p)

makeClassy_ ''Tree
makeClassy ''TreeSub

type ViewTree = Tree LayoutView PaneView
type ViewTreeSub = TreeSub LayoutView PaneView

instance Identifiable l => Identifiable (Tree l p) where
  identify :: Tree l p -> Ident
identify (Tree l
l [TreeSub l p]
_) = l -> Ident
forall a. Identifiable a => a -> Ident
identify l
l

type instance Index (Tree _ _) = Ident
type instance IxValue (Tree l p) = Tree l p

instance Identifiable l => Ixed (Tree l p) where
  ix :: Index (Tree l p) -> Traversal' (Tree l p) (IxValue (Tree l p))
ix = Index (Tree l p)
-> (IxValue (Tree l p) -> f (IxValue (Tree l p)))
-> Tree l p
-> f (Tree l p)
forall a. Identifiable a => Ident -> Prism' a a
matchIdentP

instance (Pretty l, Pretty p) => Pretty (TreeSub l p) where
  pretty :: TreeSub l p -> Doc ann
pretty (TreeNode Tree l p
a) =
    Tree l p -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Tree l p
a
  pretty (TreeLeaf p
a) =
    p -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty p
a

instance (Pretty l, Pretty p) => Pretty (Tree l p) where
  pretty :: Tree l p -> Doc ann
pretty (Tree l
l [TreeSub l p]
sub) =
    Int -> Doc ann -> Doc ann
forall ann. Int -> Doc ann -> Doc ann
nest Int
2 (Doc ann -> Doc ann)
-> ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
vsep ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall a b. (a -> b) -> a -> b
$ l -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty l
l Doc ann -> [Doc ann] -> [Doc ann]
forall a. a -> [a] -> [a]
: (TreeSub l p -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (TreeSub l p -> Doc ann) -> [TreeSub l p] -> [Doc ann]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [TreeSub l p]
sub)