{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TemplateHaskell #-}

-- TODO move to Potato.Flow.Controller
module Potato.Flow.Controller.OwlLayers where

import           Relude

import           Potato.Flow.Controller.Types
import           Potato.Flow.Types
import Potato.Flow.Serialization.Snake
import           Potato.Flow.OwlItem
import Potato.Flow.Owl
import Potato.Flow.OwlState
import Potato.Flow.DebugHelpers

import           Control.Lens                 (over, _2)
import Data.Foldable (foldl)
import           Data.Default
import qualified Data.IntMap                  as IM
import qualified Data.IntSet as IS
import           Data.Sequence                ((><), (|>))
import qualified Data.Sequence                as Seq
import qualified Data.Text as T
import qualified Text.Show

data LockHiddenState = LHS_True | LHS_False | LHS_True_InheritTrue | LHS_False_InheritTrue deriving (LockHiddenState -> LockHiddenState -> Bool
(LockHiddenState -> LockHiddenState -> Bool)
-> (LockHiddenState -> LockHiddenState -> Bool)
-> Eq LockHiddenState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LockHiddenState -> LockHiddenState -> Bool
== :: LockHiddenState -> LockHiddenState -> Bool
$c/= :: LockHiddenState -> LockHiddenState -> Bool
/= :: LockHiddenState -> LockHiddenState -> Bool
Eq, REltId -> LockHiddenState -> ShowS
[LockHiddenState] -> ShowS
LockHiddenState -> String
(REltId -> LockHiddenState -> ShowS)
-> (LockHiddenState -> String)
-> ([LockHiddenState] -> ShowS)
-> Show LockHiddenState
forall a.
(REltId -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: REltId -> LockHiddenState -> ShowS
showsPrec :: REltId -> LockHiddenState -> ShowS
$cshow :: LockHiddenState -> String
show :: LockHiddenState -> String
$cshowList :: [LockHiddenState] -> ShowS
showList :: [LockHiddenState] -> ShowS
Show)

lockHiddenStateToBool :: LockHiddenState -> Bool
lockHiddenStateToBool :: LockHiddenState -> Bool
lockHiddenStateToBool = \case
  LockHiddenState
LHS_False -> Bool
False
  LockHiddenState
_ -> Bool
True

toggleLockHiddenState :: LockHiddenState -> LockHiddenState
toggleLockHiddenState :: LockHiddenState -> LockHiddenState
toggleLockHiddenState = \case
  LockHiddenState
LHS_True -> LockHiddenState
LHS_False
  LockHiddenState
LHS_False -> LockHiddenState
LHS_True
  LockHiddenState
LHS_True_InheritTrue -> LockHiddenState
LHS_False_InheritTrue
  LockHiddenState
LHS_False_InheritTrue -> LockHiddenState
LHS_True_InheritTrue

setLockHiddenStateInChildren :: LockHiddenState -> Bool -> LockHiddenState
setLockHiddenStateInChildren :: LockHiddenState -> Bool -> LockHiddenState
setLockHiddenStateInChildren LockHiddenState
parentstate = \case
  Bool
False -> case LockHiddenState
parentstate of
    LockHiddenState
LHS_False -> LockHiddenState
LHS_False
    LockHiddenState
_         -> LockHiddenState
LHS_False_InheritTrue
  Bool
True -> case LockHiddenState
parentstate of
    LockHiddenState
LHS_False -> LockHiddenState
LHS_True
    LockHiddenState
_         -> LockHiddenState
LHS_True_InheritTrue

-- ancestor state got set, update the child
updateLockHiddenStateInChildren :: LockHiddenState -> LockHiddenState -> LockHiddenState
updateLockHiddenStateInChildren :: LockHiddenState -> LockHiddenState -> LockHiddenState
updateLockHiddenStateInChildren LockHiddenState
parentstate = \case
  LockHiddenState
LHS_False -> case LockHiddenState
parentstate of
    LockHiddenState
LHS_True  -> LockHiddenState
LHS_False_InheritTrue
    LockHiddenState
LHS_False -> LockHiddenState
LHS_False
    LockHiddenState
_         -> LockHiddenState
forall {a}. a
invalid
  LockHiddenState
LHS_True -> case LockHiddenState
parentstate of
    LockHiddenState
LHS_True  -> LockHiddenState
LHS_True_InheritTrue
    LockHiddenState
LHS_False -> LockHiddenState
LHS_True
    LockHiddenState
_         -> LockHiddenState
forall {a}. a
invalid
  LockHiddenState
LHS_True_InheritTrue -> case LockHiddenState
parentstate of
    LockHiddenState
LHS_False -> LockHiddenState
LHS_True
    LockHiddenState
LHS_True  -> LockHiddenState
LHS_True_InheritTrue
    LockHiddenState
_         -> LockHiddenState
forall {a}. a
invalid
  LockHiddenState
LHS_False_InheritTrue -> case LockHiddenState
parentstate of
    LockHiddenState
LHS_False -> LockHiddenState
LHS_False
    LockHiddenState
LHS_True  -> LockHiddenState
LHS_False_InheritTrue
    LockHiddenState
_         -> LockHiddenState
forall {a}. a
invalid
  where
    invalid :: a
invalid = Text -> a
forall a t. (HasCallStack, IsText t) => t -> a
error Text
"toggling of LHS_XXX_InheritTrue elements disallowed"

-- TODO be careful with hidden cost of Eq SuperOwl
-- this stores info just for what is displayed, Seq LayerEntry is uniquely generated from LayerMetaMap and PFState
data LayerEntry = LayerEntry {
  LayerEntry -> LockHiddenState
_layerEntry_lockState      :: LockHiddenState
  , LayerEntry -> LockHiddenState
_layerEntry_hideState      :: LockHiddenState
  , LayerEntry -> Bool
_layerEntry_isCollapsed    :: Bool -- this parameter is ignored if not a folder, Maybe Bool instead?
  , LayerEntry -> SuperOwl
_layerEntry_superOwl :: SuperOwl
} deriving (LayerEntry -> LayerEntry -> Bool
(LayerEntry -> LayerEntry -> Bool)
-> (LayerEntry -> LayerEntry -> Bool) -> Eq LayerEntry
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LayerEntry -> LayerEntry -> Bool
== :: LayerEntry -> LayerEntry -> Bool
$c/= :: LayerEntry -> LayerEntry -> Bool
/= :: LayerEntry -> LayerEntry -> Bool
Eq)

instance Show LayerEntry where
  show :: LayerEntry -> String
show LayerEntry {Bool
SuperOwl
LockHiddenState
_layerEntry_lockState :: LayerEntry -> LockHiddenState
_layerEntry_hideState :: LayerEntry -> LockHiddenState
_layerEntry_isCollapsed :: LayerEntry -> Bool
_layerEntry_superOwl :: LayerEntry -> SuperOwl
_layerEntry_lockState :: LockHiddenState
_layerEntry_hideState :: LockHiddenState
_layerEntry_isCollapsed :: Bool
_layerEntry_superOwl :: SuperOwl
..} = String
"LayerEntry (lhc: "
    String -> ShowS
forall a. Semigroup a => a -> a -> a
<> LockHiddenState -> String
forall b a. (Show a, IsString b) => a -> b
show LockHiddenState
_layerEntry_lockState
    String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
"," String -> ShowS
forall a. Semigroup a => a -> a -> a
<> LockHiddenState -> String
forall b a. (Show a, IsString b) => a -> b
show LockHiddenState
_layerEntry_hideState
    String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
"," String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Bool -> String
forall b a. (Show a, IsString b) => a -> b
show Bool
_layerEntry_isCollapsed
    String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
"):\n" String -> ShowS
forall a. Semigroup a => a -> a -> a
<> (Text -> String
T.unpack (Text -> String) -> Text -> String
forall a b. (a -> b) -> a -> b
$ SuperOwl -> Text
forall a. PotatoShow a => a -> Text
potatoShow SuperOwl
_layerEntry_superOwl)

layerEntry_depth :: LayerEntry -> Int
layerEntry_depth :: LayerEntry -> REltId
layerEntry_depth LayerEntry {Bool
SuperOwl
LockHiddenState
_layerEntry_lockState :: LayerEntry -> LockHiddenState
_layerEntry_hideState :: LayerEntry -> LockHiddenState
_layerEntry_isCollapsed :: LayerEntry -> Bool
_layerEntry_superOwl :: LayerEntry -> SuperOwl
_layerEntry_lockState :: LockHiddenState
_layerEntry_hideState :: LockHiddenState
_layerEntry_isCollapsed :: Bool
_layerEntry_superOwl :: SuperOwl
..} = OwlItemMeta -> REltId
_owlItemMeta_depth (OwlItemMeta -> REltId)
-> (SuperOwl -> OwlItemMeta) -> SuperOwl -> REltId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SuperOwl -> OwlItemMeta
_superOwl_meta (SuperOwl -> REltId) -> SuperOwl -> REltId
forall a b. (a -> b) -> a -> b
$ SuperOwl
_layerEntry_superOwl

layerEntry_display :: LayerEntry -> Text
layerEntry_display :: LayerEntry -> Text
layerEntry_display LayerEntry {Bool
SuperOwl
LockHiddenState
_layerEntry_lockState :: LayerEntry -> LockHiddenState
_layerEntry_hideState :: LayerEntry -> LockHiddenState
_layerEntry_isCollapsed :: LayerEntry -> Bool
_layerEntry_superOwl :: LayerEntry -> SuperOwl
_layerEntry_lockState :: LockHiddenState
_layerEntry_hideState :: LockHiddenState
_layerEntry_isCollapsed :: Bool
_layerEntry_superOwl :: SuperOwl
..} = SuperOwl -> Text
forall o. HasOwlItem o => o -> Text
hasOwlItem_name SuperOwl
_layerEntry_superOwl

layerEntry_isFolder :: LayerEntry -> Bool
layerEntry_isFolder :: LayerEntry -> Bool
layerEntry_isFolder LayerEntry {Bool
SuperOwl
LockHiddenState
_layerEntry_lockState :: LayerEntry -> LockHiddenState
_layerEntry_hideState :: LayerEntry -> LockHiddenState
_layerEntry_isCollapsed :: LayerEntry -> Bool
_layerEntry_superOwl :: LayerEntry -> SuperOwl
_layerEntry_lockState :: LockHiddenState
_layerEntry_hideState :: LockHiddenState
_layerEntry_isCollapsed :: Bool
_layerEntry_superOwl :: SuperOwl
..} = SuperOwl -> Bool
forall o. MommyOwl o => o -> Bool
mommyOwl_hasKiddos SuperOwl
_layerEntry_superOwl

layerEntry_rEltId :: LayerEntry -> REltId
layerEntry_rEltId :: LayerEntry -> REltId
layerEntry_rEltId LayerEntry {Bool
SuperOwl
LockHiddenState
_layerEntry_lockState :: LayerEntry -> LockHiddenState
_layerEntry_hideState :: LayerEntry -> LockHiddenState
_layerEntry_isCollapsed :: LayerEntry -> Bool
_layerEntry_superOwl :: LayerEntry -> SuperOwl
_layerEntry_lockState :: LockHiddenState
_layerEntry_hideState :: LockHiddenState
_layerEntry_isCollapsed :: Bool
_layerEntry_superOwl :: SuperOwl
..} = SuperOwl -> REltId
_superOwl_id SuperOwl
_layerEntry_superOwl

-- index type into Seq LayerEntry
type LayerEntryPos = Int
type LayerEntries = Seq LayerEntry

layerEntriesToPrettyText :: LayerEntries -> Text
layerEntriesToPrettyText :: LayerEntries -> Text
layerEntriesToPrettyText LayerEntries
lentries = (LayerEntry -> Text -> Text) -> Text -> LayerEntries -> Text
forall a b. (a -> b -> b) -> b -> Seq a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr LayerEntry -> Text -> Text
foldrfn Text
"" LayerEntries
lentries where
  foldrfn :: LayerEntry -> Text -> Text
foldrfn le :: LayerEntry
le@LayerEntry {Bool
SuperOwl
LockHiddenState
_layerEntry_lockState :: LayerEntry -> LockHiddenState
_layerEntry_hideState :: LayerEntry -> LockHiddenState
_layerEntry_isCollapsed :: LayerEntry -> Bool
_layerEntry_superOwl :: LayerEntry -> SuperOwl
_layerEntry_lockState :: LockHiddenState
_layerEntry_hideState :: LockHiddenState
_layerEntry_isCollapsed :: Bool
_layerEntry_superOwl :: SuperOwl
..} Text
acc = Text
r where
    collapseText :: Text
collapseText = if LayerEntry -> Bool
layerEntry_isFolder LayerEntry
le
      then if Bool
_layerEntry_isCollapsed
        then Text
">"
        else Text
"v"
      else Text
" "
    hideText :: Text
hideText = case LockHiddenState
_layerEntry_hideState of
      LockHiddenState
LHS_True              -> Text
"▓"
      LockHiddenState
LHS_False             -> Text
" "
      LockHiddenState
LHS_True_InheritTrue  -> Text
"▓"
      LockHiddenState
LHS_False_InheritTrue -> Text
"▒"
    lockText :: Text
lockText = case LockHiddenState
_layerEntry_lockState of
      LockHiddenState
LHS_True              -> Text
"▓"
      LockHiddenState
LHS_False             -> Text
" "
      LockHiddenState
LHS_True_InheritTrue  -> Text
"▓"
      LockHiddenState
LHS_False_InheritTrue -> Text
"▒"
    sowl :: SuperOwl
sowl = SuperOwl
_layerEntry_superOwl
    r :: Text
r = REltId -> Text -> Text
T.replicate (LayerEntry -> REltId
layerEntry_depth LayerEntry
le) Text
" " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
collapseText Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
hideText Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
lockText Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> SuperOwl -> Text
forall o. HasOwlItem o => o -> Text
hasOwlItem_name SuperOwl
sowl Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"\n" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
acc

data LayersState = LayersState {
    -- mapping from REltId to element meta data
    LayersState -> LayerMetaMap
_layersState_meta :: LayerMetaMap
    -- sequence of visible folders
    , LayersState -> LayerEntries
_layersState_entries :: LayerEntries
    , LayersState -> REltId
_layersState_scrollPos :: Int
  } deriving (REltId -> LayersState -> ShowS
[LayersState] -> ShowS
LayersState -> String
(REltId -> LayersState -> ShowS)
-> (LayersState -> String)
-> ([LayersState] -> ShowS)
-> Show LayersState
forall a.
(REltId -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: REltId -> LayersState -> ShowS
showsPrec :: REltId -> LayersState -> ShowS
$cshow :: LayersState -> String
show :: LayersState -> String
$cshowList :: [LayersState] -> ShowS
showList :: [LayersState] -> ShowS
Show, LayersState -> LayersState -> Bool
(LayersState -> LayersState -> Bool)
-> (LayersState -> LayersState -> Bool) -> Eq LayersState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LayersState -> LayersState -> Bool
== :: LayersState -> LayersState -> Bool
$c/= :: LayersState -> LayersState -> Bool
/= :: LayersState -> LayersState -> Bool
Eq)

instance PotatoShow LayersState where
  potatoShow :: LayersState -> Text
potatoShow LayersState{REltId
LayerEntries
LayerMetaMap
_layersState_meta :: LayersState -> LayerMetaMap
_layersState_entries :: LayersState -> LayerEntries
_layersState_scrollPos :: LayersState -> REltId
_layersState_meta :: LayerMetaMap
_layersState_entries :: LayerEntries
_layersState_scrollPos :: REltId
..} = Text
r where
    r :: Text
r = Text
"LayersState: "
      Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> LayerMetaMap -> Text
forall b a. (Show a, IsString b) => a -> b
show LayerMetaMap
_layersState_meta
      Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"\nLayerEntries:\n"
      Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> LayerEntries -> Text
layerEntriesToPrettyText LayerEntries
_layersState_entries

--instance Show LayersState where
--  show ls = T.unpack (potatoShow ls)


data LockHideCollapseOp = LHCO_ToggleLock | LHCO_ToggleHide | LHCO_ToggleCollapse deriving (REltId -> LockHideCollapseOp -> ShowS
[LockHideCollapseOp] -> ShowS
LockHideCollapseOp -> String
(REltId -> LockHideCollapseOp -> ShowS)
-> (LockHideCollapseOp -> String)
-> ([LockHideCollapseOp] -> ShowS)
-> Show LockHideCollapseOp
forall a.
(REltId -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: REltId -> LockHideCollapseOp -> ShowS
showsPrec :: REltId -> LockHideCollapseOp -> ShowS
$cshow :: LockHideCollapseOp -> String
show :: LockHideCollapseOp -> String
$cshowList :: [LockHideCollapseOp] -> ShowS
showList :: [LockHideCollapseOp] -> ShowS
Show)

alterWithDefault :: (Eq a, Default a) => (a -> a) -> REltId -> REltIdMap a -> REltIdMap a
alterWithDefault :: forall a.
(Eq a, Default a) =>
(a -> a) -> REltId -> REltIdMap a -> REltIdMap a
alterWithDefault a -> a
f REltId
k REltIdMap a
m = (Maybe a -> Maybe a) -> REltId -> REltIdMap a -> REltIdMap a
forall a. (Maybe a -> Maybe a) -> REltId -> IntMap a -> IntMap a
IM.alter Maybe a -> Maybe a
f' REltId
k REltIdMap a
m where
  apply :: a -> Maybe a
apply a
x = if a
fx a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
forall a. Default a => a
def then Maybe a
forall a. Maybe a
Nothing else a -> Maybe a
forall a. a -> Maybe a
Just a
fx where
    fx :: a
fx = a -> a
f a
x
  f' :: Maybe a -> Maybe a
f' = \case
    Maybe a
Nothing -> a -> Maybe a
apply a
forall a. Default a => a
def
    Just a
x -> a -> Maybe a
apply a
x

lookupWithDefault :: (Default a) => REltId -> REltIdMap a -> a
lookupWithDefault :: forall a. Default a => REltId -> REltIdMap a -> a
lookupWithDefault REltId
rid REltIdMap a
ridm = case REltId -> REltIdMap a -> Maybe a
forall a. REltId -> IntMap a -> Maybe a
IM.lookup REltId
rid REltIdMap a
ridm of
  Maybe a
Nothing -> a
forall a. Default a => a
def
  Just a
x  -> a
x





-- TODO test
-- | assumes LayersState is after hide state of given lepos has just been toggled
changesFromToggleHide :: OwlPFState -> LayersState -> LayerEntryPos -> SuperOwlChanges
changesFromToggleHide :: OwlPFState -> LayersState -> REltId -> SuperOwlChanges
changesFromToggleHide OwlPFState {SCanvas
OwlTree
_owlPFState_owlTree :: OwlTree
_owlPFState_canvas :: SCanvas
_owlPFState_owlTree :: OwlPFState -> OwlTree
_owlPFState_canvas :: OwlPFState -> SCanvas
..} LayersState {REltId
LayerEntries
LayerMetaMap
_layersState_meta :: LayersState -> LayerMetaMap
_layersState_entries :: LayersState -> LayerEntries
_layersState_scrollPos :: LayersState -> REltId
_layersState_meta :: LayerMetaMap
_layersState_entries :: LayerEntries
_layersState_scrollPos :: REltId
..} REltId
lepos = SuperOwlChanges
r where
  le :: LayerEntry
le = LayerEntries -> REltId -> LayerEntry
forall a. Seq a -> REltId -> a
Seq.index LayerEntries
_layersState_entries REltId
lepos
  sowl :: SuperOwl
sowl = LayerEntry -> SuperOwl
_layerEntry_superOwl LayerEntry
le
  lerid :: REltId
lerid = SuperOwl -> REltId
_superOwl_id SuperOwl
sowl
  lm :: LayerMeta
lm = REltId -> LayerMetaMap -> LayerMeta
forall a. Default a => REltId -> REltIdMap a -> a
lookupWithDefault REltId
lerid LayerMetaMap
_layersState_meta
  isHidden :: Bool
isHidden = LayerMeta -> Bool
_layerMeta_isHidden LayerMeta
lm

  -- find all children that weren't already hidden
  children :: Seq SuperOwl
children = OwlTree -> REltId -> Seq SuperOwl
owliteratechildrenat OwlTree
_owlPFState_owlTree REltId
lerid
  isunhidden :: SuperOwl -> Bool
isunhidden SuperOwl
sowl' = Bool -> Bool
not (Bool -> Bool) -> (LayerMeta -> Bool) -> LayerMeta -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LayerMeta -> Bool
_layerMeta_isHidden (LayerMeta -> Bool) -> LayerMeta -> Bool
forall a b. (a -> b) -> a -> b
$ REltId -> LayerMetaMap -> LayerMeta
forall a. Default a => REltId -> REltIdMap a -> a
lookupWithDefault (SuperOwl -> REltId
_superOwl_id SuperOwl
sowl') LayerMetaMap
_layersState_meta
  unhiddenChildren :: [(REltId, SuperOwl)]
unhiddenChildren = Seq (REltId, SuperOwl) -> [(REltId, SuperOwl)]
forall a. Seq a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList (Seq (REltId, SuperOwl) -> [(REltId, SuperOwl)])
-> (Seq SuperOwl -> Seq (REltId, SuperOwl))
-> Seq SuperOwl
-> [(REltId, SuperOwl)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SuperOwl -> (REltId, SuperOwl))
-> Seq SuperOwl -> Seq (REltId, SuperOwl)
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\SuperOwl
sowl' -> (SuperOwl -> REltId
_superOwl_id SuperOwl
sowl', SuperOwl
sowl')) (Seq SuperOwl -> [(REltId, SuperOwl)])
-> Seq SuperOwl -> [(REltId, SuperOwl)]
forall a b. (a -> b) -> a -> b
$ (SuperOwl -> Bool) -> Seq SuperOwl -> Seq SuperOwl
forall a. (a -> Bool) -> Seq a -> Seq a
Seq.filter SuperOwl -> Bool
isunhidden Seq SuperOwl
children

  r :: SuperOwlChanges
r = if Bool
isHidden
    then [(REltId, Maybe SuperOwl)] -> SuperOwlChanges
forall a. [(REltId, a)] -> IntMap a
IM.fromList ([(REltId, Maybe SuperOwl)] -> SuperOwlChanges)
-> [(REltId, Maybe SuperOwl)] -> SuperOwlChanges
forall a b. (a -> b) -> a -> b
$ (REltId
lerid, Maybe SuperOwl
forall a. Maybe a
Nothing) (REltId, Maybe SuperOwl)
-> [(REltId, Maybe SuperOwl)] -> [(REltId, Maybe SuperOwl)]
forall a. a -> [a] -> [a]
: (((REltId, SuperOwl) -> (REltId, Maybe SuperOwl))
-> [(REltId, SuperOwl)] -> [(REltId, Maybe SuperOwl)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (ASetter
  (REltId, SuperOwl)
  (REltId, Maybe SuperOwl)
  SuperOwl
  (Maybe SuperOwl)
-> (SuperOwl -> Maybe SuperOwl)
-> (REltId, SuperOwl)
-> (REltId, Maybe SuperOwl)
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
over ASetter
  (REltId, SuperOwl)
  (REltId, Maybe SuperOwl)
  SuperOwl
  (Maybe SuperOwl)
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (REltId, SuperOwl)
  (REltId, Maybe SuperOwl)
  SuperOwl
  (Maybe SuperOwl)
_2 (Maybe SuperOwl -> SuperOwl -> Maybe SuperOwl
forall a b. a -> b -> a
const Maybe SuperOwl
forall a. Maybe a
Nothing)) [(REltId, SuperOwl)]
unhiddenChildren)
    else [(REltId, Maybe SuperOwl)] -> SuperOwlChanges
forall a. [(REltId, a)] -> IntMap a
IM.fromList ([(REltId, Maybe SuperOwl)] -> SuperOwlChanges)
-> [(REltId, Maybe SuperOwl)] -> SuperOwlChanges
forall a b. (a -> b) -> a -> b
$ (REltId
lerid,SuperOwl -> Maybe SuperOwl
forall a. a -> Maybe a
Just SuperOwl
sowl) (REltId, Maybe SuperOwl)
-> [(REltId, Maybe SuperOwl)] -> [(REltId, Maybe SuperOwl)]
forall a. a -> [a] -> [a]
: (((REltId, SuperOwl) -> (REltId, Maybe SuperOwl))
-> [(REltId, SuperOwl)] -> [(REltId, Maybe SuperOwl)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (ASetter
  (REltId, SuperOwl)
  (REltId, Maybe SuperOwl)
  SuperOwl
  (Maybe SuperOwl)
-> (SuperOwl -> Maybe SuperOwl)
-> (REltId, SuperOwl)
-> (REltId, Maybe SuperOwl)
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
over ASetter
  (REltId, SuperOwl)
  (REltId, Maybe SuperOwl)
  SuperOwl
  (Maybe SuperOwl)
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (REltId, SuperOwl)
  (REltId, Maybe SuperOwl)
  SuperOwl
  (Maybe SuperOwl)
_2 SuperOwl -> Maybe SuperOwl
forall a. a -> Maybe a
Just) [(REltId, SuperOwl)]
unhiddenChildren)

-- iterates over LayerEntryPos, skipping all children of entries where skipfn evaluates to true
doChildrenRecursive :: (LayerEntry -> Bool) -> (LayerEntry -> LayerEntry) -> Seq LayerEntry -> Seq LayerEntry
doChildrenRecursive :: (LayerEntry -> Bool)
-> (LayerEntry -> LayerEntry) -> LayerEntries -> LayerEntries
doChildrenRecursive LayerEntry -> Bool
skipfn LayerEntry -> LayerEntry
entryfn = (REltId, LayerEntries) -> LayerEntries
forall a b. (a, b) -> b
snd ((REltId, LayerEntries) -> LayerEntries)
-> (LayerEntries -> (REltId, LayerEntries))
-> LayerEntries
-> LayerEntries
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (REltId -> LayerEntry -> (REltId, LayerEntry))
-> REltId -> LayerEntries -> (REltId, LayerEntries)
forall (t :: * -> *) s a b.
Traversable t =>
(s -> a -> (s, b)) -> s -> t a -> (s, t b)
mapAccumL REltId -> LayerEntry -> (REltId, LayerEntry)
mapaccumlfn REltId
forall a. Bounded a => a
maxBound where
  mapaccumlfn :: REltId -> LayerEntry -> (REltId, LayerEntry)
mapaccumlfn REltId
skipdepth LayerEntry
le = (REltId
newskipdepth, LayerEntry
newle) where
    depth :: REltId
depth = LayerEntry -> REltId
layerEntry_depth LayerEntry
le
    newskipdepth :: REltId
newskipdepth
      -- skip, so keep skipping
      | REltId
depth REltId -> REltId -> Bool
forall a. Ord a => a -> a -> Bool
>= REltId
skipdepth = REltId
skipdepth
      -- skip all children
      -- note, no need to check for collapsed state because we are iterating over LayerEntry which do not include children of collapsed entries
      | LayerEntry -> Bool
skipfn LayerEntry
le = REltId
depth REltId -> REltId -> REltId
forall a. Num a => a -> a -> a
+ REltId
1
      -- either we exited a skipped folder or aren't skipping, reset skip counter (since we skip subfolders of skipped entries, maximal skip stack depth is 1 so reset is OK)
      | Bool
otherwise = REltId
forall a. Bounded a => a
maxBound
    newle :: LayerEntry
newle = if REltId
depth REltId -> REltId -> Bool
forall a. Ord a => a -> a -> Bool
>= REltId
skipdepth
      then LayerEntry
le -- no changes to skipped elts
      else LayerEntry -> LayerEntry
entryfn LayerEntry
le


toggleLayerEntry :: OwlPFState -> LayersState -> LayerEntryPos -> LockHideCollapseOp -> LayersState
toggleLayerEntry :: OwlPFState
-> LayersState -> REltId -> LockHideCollapseOp -> LayersState
toggleLayerEntry OwlPFState {SCanvas
OwlTree
_owlPFState_owlTree :: OwlPFState -> OwlTree
_owlPFState_canvas :: OwlPFState -> SCanvas
_owlPFState_owlTree :: OwlTree
_owlPFState_canvas :: SCanvas
..} LayersState {REltId
LayerEntries
LayerMetaMap
_layersState_meta :: LayersState -> LayerMetaMap
_layersState_entries :: LayersState -> LayerEntries
_layersState_scrollPos :: LayersState -> REltId
_layersState_meta :: LayerMetaMap
_layersState_entries :: LayerEntries
_layersState_scrollPos :: REltId
..} REltId
lepos LockHideCollapseOp
op = LayersState
r where
  le :: LayerEntry
le = LayerEntries -> REltId -> LayerEntry
forall a. Seq a -> REltId -> a
Seq.index LayerEntries
_layersState_entries REltId
lepos
  lerid :: REltId
lerid = LayerEntry -> REltId
layerEntry_rEltId LayerEntry
le
  ledepth :: REltId
ledepth = LayerEntry -> REltId
layerEntry_depth LayerEntry
le
  childFrom :: LayerEntry -> Bool
childFrom LayerEntry
nextLayerEntry = LayerEntry -> REltId
layerEntry_depth LayerEntry
nextLayerEntry REltId -> REltId -> Bool
forall a. Ord a => a -> a -> Bool
> REltId
ledepth
  -- visible children of le
  childles :: LayerEntries
childles = (LayerEntry -> Bool) -> LayerEntries -> LayerEntries
forall a. (a -> Bool) -> Seq a -> Seq a
Seq.takeWhileL LayerEntry -> Bool
childFrom (LayerEntries -> LayerEntries)
-> (LayerEntries -> LayerEntries) -> LayerEntries -> LayerEntries
forall b c a. (b -> c) -> (a -> b) -> a -> c
. REltId -> LayerEntries -> LayerEntries
forall a. REltId -> Seq a -> Seq a
Seq.drop (REltId
leposREltId -> REltId -> REltId
forall a. Num a => a -> a -> a
+REltId
1) (LayerEntries -> LayerEntries) -> LayerEntries -> LayerEntries
forall a b. (a -> b) -> a -> b
$ LayerEntries
_layersState_entries
  -- everything before le
  frontOfLe :: LayerEntries
frontOfLe = REltId -> LayerEntries -> LayerEntries
forall a. REltId -> Seq a -> Seq a
Seq.take REltId
lepos LayerEntries
_layersState_entries
  -- everything after childles
  backOfChildles :: LayerEntries
backOfChildles = REltId -> LayerEntries -> LayerEntries
forall a. REltId -> Seq a -> Seq a
Seq.drop (REltId
lepos REltId -> REltId -> REltId
forall a. Num a => a -> a -> a
+ REltId
1 REltId -> REltId -> REltId
forall a. Num a => a -> a -> a
+ LayerEntries -> REltId
forall a. Seq a -> REltId
Seq.length LayerEntries
childles) LayerEntries
_layersState_entries

  -- simple helper function for setting lock/hidden state
  togglefn :: (LayerEntry -> LockHiddenState)
-> (LayerMeta -> Bool -> LayerMeta)
-> (LayerEntry -> LockHiddenState -> LayerEntry)
-> LayersState
togglefn LayerEntry -> LockHiddenState
fn LayerMeta -> Bool -> LayerMeta
setlmfn LayerEntry -> LockHiddenState -> LayerEntry
setlefn = (LayerMetaMap -> LayerEntries -> REltId -> LayersState
LayersState LayerMetaMap
newlmm LayerEntries
newlentries REltId
0) where
    newlhsstate :: LockHiddenState
newlhsstate = LockHiddenState -> LockHiddenState
toggleLockHiddenState (LockHiddenState -> LockHiddenState)
-> LockHiddenState -> LockHiddenState
forall a b. (a -> b) -> a -> b
$ LayerEntry -> LockHiddenState
fn LayerEntry
le
    newlmm :: LayerMetaMap
newlmm = (LayerMeta -> LayerMeta) -> REltId -> LayerMetaMap -> LayerMetaMap
forall a.
(Eq a, Default a) =>
(a -> a) -> REltId -> REltIdMap a -> REltIdMap a
alterWithDefault (\LayerMeta
lm' -> LayerMeta -> Bool -> LayerMeta
setlmfn LayerMeta
lm' (LockHiddenState -> Bool
lockHiddenStateToBool LockHiddenState
newlhsstate)) REltId
lerid LayerMetaMap
_layersState_meta
    entryfn :: LayerEntry -> LayerEntry
entryfn LayerEntry
childle = LayerEntry -> LockHiddenState -> LayerEntry
setlefn LayerEntry
childle (LockHiddenState -> LayerEntry) -> LockHiddenState -> LayerEntry
forall a b. (a -> b) -> a -> b
$ LockHiddenState -> LockHiddenState -> LockHiddenState
updateLockHiddenStateInChildren LockHiddenState
newlhsstate (LayerEntry -> LockHiddenState
fn LayerEntry
childle)
    newchildles :: LayerEntries
newchildles = (LayerEntry -> Bool)
-> (LayerEntry -> LayerEntry) -> LayerEntries -> LayerEntries
doChildrenRecursive (LockHiddenState -> Bool
lockHiddenStateToBool (LockHiddenState -> Bool)
-> (LayerEntry -> LockHiddenState) -> LayerEntry -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LayerEntry -> LockHiddenState
fn) LayerEntry -> LayerEntry
entryfn LayerEntries
childles
    newle :: LayerEntry
newle = LayerEntry -> LockHiddenState -> LayerEntry
setlefn LayerEntry
le LockHiddenState
newlhsstate
    newlentries :: LayerEntries
newlentries = (LayerEntries
frontOfLe LayerEntries -> LayerEntry -> LayerEntries
forall a. Seq a -> a -> Seq a
|> LayerEntry
newle) LayerEntries -> LayerEntries -> LayerEntries
forall a. Seq a -> Seq a -> Seq a
>< LayerEntries
newchildles LayerEntries -> LayerEntries -> LayerEntries
forall a. Seq a -> Seq a -> Seq a
>< LayerEntries
backOfChildles

  r :: LayersState
r = case LockHideCollapseOp
op of
    LockHideCollapseOp
LHCO_ToggleCollapse -> (LayerMetaMap -> LayerEntries -> REltId -> LayersState
LayersState LayerMetaMap
newlmm LayerEntries
newlentries REltId
0) where
      newcollapse :: Bool
newcollapse = Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ LayerEntry -> Bool
_layerEntry_isCollapsed LayerEntry
le
      newlmm :: LayerMetaMap
newlmm = (LayerMeta -> LayerMeta) -> REltId -> LayerMetaMap -> LayerMetaMap
forall a.
(Eq a, Default a) =>
(a -> a) -> REltId -> REltIdMap a -> REltIdMap a
alterWithDefault (\LayerMeta
le' -> LayerMeta
le' { _layerMeta_isCollapsed = newcollapse }) REltId
lerid LayerMetaMap
_layersState_meta
      newle :: LayerEntry
newle = LayerEntry
le { _layerEntry_isCollapsed = newcollapse }
      newchildles :: LayerEntries
newchildles = OwlTree
-> LayerMetaMap -> LayerEntries -> Maybe LayerEntry -> LayerEntries
buildLayerEntriesRecursive OwlTree
_owlPFState_owlTree LayerMetaMap
_layersState_meta LayerEntries
forall a. Seq a
Seq.empty (LayerEntry -> Maybe LayerEntry
forall a. a -> Maybe a
Just LayerEntry
newle)
      newlentries :: LayerEntries
newlentries = if Bool
newcollapse
        then (LayerEntries
frontOfLe LayerEntries -> LayerEntry -> LayerEntries
forall a. Seq a -> a -> Seq a
|> LayerEntry
newle) LayerEntries -> LayerEntries -> LayerEntries
forall a. Seq a -> Seq a -> Seq a
>< LayerEntries
backOfChildles
        else (LayerEntries
frontOfLe LayerEntries -> LayerEntry -> LayerEntries
forall a. Seq a -> a -> Seq a
|> LayerEntry
newle) LayerEntries -> LayerEntries -> LayerEntries
forall a. Seq a -> Seq a -> Seq a
>< LayerEntries
newchildles LayerEntries -> LayerEntries -> LayerEntries
forall a. Seq a -> Seq a -> Seq a
>< LayerEntries
backOfChildles

    LockHideCollapseOp
LHCO_ToggleLock -> (LayerEntry -> LockHiddenState)
-> (LayerMeta -> Bool -> LayerMeta)
-> (LayerEntry -> LockHiddenState -> LayerEntry)
-> LayersState
togglefn LayerEntry -> LockHiddenState
_layerEntry_lockState (\LayerMeta
lm' Bool
x -> LayerMeta
lm' { _layerMeta_isLocked = x }) (\LayerEntry
le' LockHiddenState
x -> LayerEntry
le' { _layerEntry_lockState = x })
    LockHideCollapseOp
LHCO_ToggleHide -> (LayerEntry -> LockHiddenState)
-> (LayerMeta -> Bool -> LayerMeta)
-> (LayerEntry -> LockHiddenState -> LayerEntry)
-> LayersState
togglefn LayerEntry -> LockHiddenState
_layerEntry_hideState (\LayerMeta
lm' Bool
x -> LayerMeta
lm' { _layerMeta_isHidden = x }) (\LayerEntry
le' LockHiddenState
x -> LayerEntry
le' { _layerEntry_hideState = x })

expandAllCollapsedParents :: Selection -> OwlPFState -> LayersState -> LayersState
expandAllCollapsedParents :: Selection -> OwlPFState -> LayersState -> LayersState
expandAllCollapsedParents Selection
selection OwlPFState
pfs LayersState
ls = LayersState
r where
  ops :: OwlParliamentSet
ops = OwlTree -> OwlParliamentSet -> OwlParliamentSet
owlParliamentSet_findParents (OwlPFState -> OwlTree
forall o. HasOwlTree o => o -> OwlTree
hasOwlTree_owlTree OwlPFState
pfs) (OwlParliamentSet -> OwlParliamentSet)
-> (Selection -> OwlParliamentSet) -> Selection -> OwlParliamentSet
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Selection -> OwlParliamentSet
superOwlParliament_toOwlParliamentSet (Selection -> OwlParliamentSet) -> Selection -> OwlParliamentSet
forall a b. (a -> b) -> a -> b
$  Selection
selection
  oldlmm :: LayerMetaMap
oldlmm = LayersState -> LayerMetaMap
_layersState_meta LayersState
ls
  iscollapsedfilterfn :: REltId -> Bool
iscollapsedfilterfn REltId
rid = case REltId -> LayerMetaMap -> Maybe LayerMeta
forall a. REltId -> IntMap a -> Maybe a
IM.lookup REltId
rid LayerMetaMap
oldlmm of
    Just LayerMeta
lm -> LayerMeta -> Bool
_layerMeta_isCollapsed LayerMeta
lm
    Maybe LayerMeta
Nothing -> Bool
defaultFolderCollapseState
  collapsedParents :: OwlParliamentSet
collapsedParents = (REltId -> Bool) -> OwlParliamentSet -> OwlParliamentSet
IS.filter REltId -> Bool
iscollapsedfilterfn OwlParliamentSet
ops
  alterfn :: Maybe LayerMeta -> Maybe LayerMeta
alterfn Maybe LayerMeta
mlm = case Maybe LayerMeta
mlm of
    Maybe LayerMeta
Nothing -> LayerMeta -> Maybe LayerMeta
forall a. a -> Maybe a
Just (LayerMeta
forall a. Default a => a
def { _layerMeta_isCollapsed = False })
    Just LayerMeta
x -> LayerMeta -> Maybe LayerMeta
forall a. a -> Maybe a
Just (LayerMeta
x { _layerMeta_isCollapsed = False })
  newlmm :: LayerMetaMap
newlmm = (REltId -> LayerMetaMap -> LayerMetaMap)
-> LayerMetaMap -> OwlParliamentSet -> LayerMetaMap
forall b. (REltId -> b -> b) -> b -> OwlParliamentSet -> b
IS.foldr ((Maybe LayerMeta -> Maybe LayerMeta)
-> REltId -> LayerMetaMap -> LayerMetaMap
forall a. (Maybe a -> Maybe a) -> REltId -> IntMap a -> IntMap a
IM.alter Maybe LayerMeta -> Maybe LayerMeta
alterfn) LayerMetaMap
oldlmm OwlParliamentSet
collapsedParents
  r :: LayersState
r = if OwlParliamentSet -> Bool
IS.null OwlParliamentSet
collapsedParents
    then LayersState
ls
    -- can we do this more efficiently?
    else (OwlPFState -> LayerMetaMap -> LayersState
makeLayersStateFromOwlPFState OwlPFState
pfs LayerMetaMap
newlmm) { _layersState_scrollPos = _layersState_scrollPos ls }

makeLayersStateFromOwlPFState :: OwlPFState -> LayerMetaMap -> LayersState
makeLayersStateFromOwlPFState :: OwlPFState -> LayerMetaMap -> LayersState
makeLayersStateFromOwlPFState OwlPFState
pfs LayerMetaMap
lmm = LayersState {
    _layersState_meta :: LayerMetaMap
_layersState_meta = LayerMetaMap
lmm
    , _layersState_entries :: LayerEntries
_layersState_entries = OwlTree -> LayerMetaMap -> LayerEntries
generateLayersNew (OwlPFState -> OwlTree
_owlPFState_owlTree OwlPFState
pfs) LayerMetaMap
lmm
    , _layersState_scrollPos :: REltId
_layersState_scrollPos = REltId
0
  }

updateLayers :: OwlPFState -> SuperOwlChanges -> LayersState -> LayersState
updateLayers :: OwlPFState -> SuperOwlChanges -> LayersState -> LayersState
updateLayers OwlPFState
pfs SuperOwlChanges
changes LayersState {REltId
LayerEntries
LayerMetaMap
_layersState_meta :: LayersState -> LayerMetaMap
_layersState_entries :: LayersState -> LayerEntries
_layersState_scrollPos :: LayersState -> REltId
_layersState_meta :: LayerMetaMap
_layersState_entries :: LayerEntries
_layersState_scrollPos :: REltId
..} = LayersState
r where
  -- update _layersState_meta
  (SuperOwlChanges
deletestuff, SuperOwlChanges
maybenewstuff) = (Maybe SuperOwl -> Bool)
-> SuperOwlChanges -> (SuperOwlChanges, SuperOwlChanges)
forall a. (a -> Bool) -> IntMap a -> (IntMap a, IntMap a)
IM.partition Maybe SuperOwl -> Bool
forall a. Maybe a -> Bool
isNothing SuperOwlChanges
changes

  maybenewstuffcollapsed :: LayerMetaMap
maybenewstuffcollapsed = ((Maybe SuperOwl -> LayerMeta) -> SuperOwlChanges -> LayerMetaMap
forall a b. (a -> b) -> IntMap a -> IntMap b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (LayerMeta -> Maybe SuperOwl -> LayerMeta
forall a b. a -> b -> a
const (LayerMeta
forall a. Default a => a
def {_layerMeta_isCollapsed = True})) SuperOwlChanges
maybenewstuff)

  newlmm :: LayerMetaMap
newlmm = LayerMetaMap -> SuperOwlChanges -> LayerMetaMap
forall a b. IntMap a -> IntMap b -> IntMap a
IM.difference (LayerMetaMap -> LayerMetaMap -> LayerMetaMap
forall a. IntMap a -> IntMap a -> IntMap a
IM.union LayerMetaMap
_layersState_meta LayerMetaMap
maybenewstuffcollapsed) SuperOwlChanges
deletestuff


  -- keep deleted elts so that folder state is preserved after undos/redos
  --newlmm = IM.union _layersState_meta (fmap (const def) maybenewstuff)

  -- TODO incremental rather than regenerate...
  newlentries :: LayerEntries
newlentries = OwlTree -> LayerMetaMap -> LayerEntries
generateLayersNew (OwlPFState -> OwlTree
_owlPFState_owlTree OwlPFState
pfs) LayerMetaMap
newlmm

  r :: LayersState
r = LayerMetaMap -> LayerEntries -> REltId -> LayersState
LayersState LayerMetaMap
newlmm LayerEntries
newlentries REltId
_layersState_scrollPos

buildLayerEntriesRecursive :: OwlTree -> LayerMetaMap -> Seq LayerEntry -> Maybe LayerEntry -> Seq LayerEntry
buildLayerEntriesRecursive :: OwlTree
-> LayerMetaMap -> LayerEntries -> Maybe LayerEntry -> LayerEntries
buildLayerEntriesRecursive OwlTree
ot LayerMetaMap
lmm LayerEntries
acc Maybe LayerEntry
mparent = LayerEntries
r where
  foldlfn :: LayerEntries -> REltId -> LayerEntries
foldlfn LayerEntries
acclentries REltId
rid = LayerEntries
newacclentries where
    sowl :: SuperOwl
sowl = HasCallStack => OwlTree -> REltId -> SuperOwl
OwlTree -> REltId -> SuperOwl
owlTree_mustFindSuperOwl OwlTree
ot REltId
rid
    lm :: LayerMeta
lm = REltId -> LayerMetaMap -> LayerMeta
forall a. Default a => REltId -> REltIdMap a -> a
lookupWithDefault REltId
rid LayerMetaMap
lmm
    -- add self
    lentry :: LayerEntry
lentry = case Maybe LayerEntry
mparent of
      Maybe LayerEntry
Nothing -> LayerEntry {
        _layerEntry_lockState :: LockHiddenState
_layerEntry_lockState =  if LayerMeta -> Bool
_layerMeta_isLocked LayerMeta
lm then LockHiddenState
LHS_True else LockHiddenState
LHS_False
        , _layerEntry_hideState :: LockHiddenState
_layerEntry_hideState = if LayerMeta -> Bool
_layerMeta_isHidden LayerMeta
lm then LockHiddenState
LHS_True else LockHiddenState
LHS_False
        , _layerEntry_isCollapsed :: Bool
_layerEntry_isCollapsed = LayerMeta -> Bool
_layerMeta_isCollapsed LayerMeta
lm
        , _layerEntry_superOwl :: SuperOwl
_layerEntry_superOwl = SuperOwl
sowl
      }
      Just LayerEntry
parent -> LayerEntry {
        _layerEntry_lockState :: LockHiddenState
_layerEntry_lockState = LockHiddenState -> Bool -> LockHiddenState
setLockHiddenStateInChildren (LayerEntry -> LockHiddenState
_layerEntry_lockState LayerEntry
parent) (Bool -> LockHiddenState) -> Bool -> LockHiddenState
forall a b. (a -> b) -> a -> b
$ LayerMeta -> Bool
_layerMeta_isLocked LayerMeta
lm
        , _layerEntry_hideState :: LockHiddenState
_layerEntry_hideState = LockHiddenState -> Bool -> LockHiddenState
setLockHiddenStateInChildren (LayerEntry -> LockHiddenState
_layerEntry_hideState LayerEntry
parent) (Bool -> LockHiddenState) -> Bool -> LockHiddenState
forall a b. (a -> b) -> a -> b
$ LayerMeta -> Bool
_layerMeta_isHidden LayerMeta
lm
        , _layerEntry_isCollapsed :: Bool
_layerEntry_isCollapsed = LayerMeta -> Bool
_layerMeta_isCollapsed LayerMeta
lm
        , _layerEntry_superOwl :: SuperOwl
_layerEntry_superOwl = SuperOwl
sowl
      }
    newacclentries' :: LayerEntries
newacclentries' = LayerEntries
acclentries LayerEntries -> LayerEntry -> LayerEntries
forall a. Seq a -> a -> Seq a
|> LayerEntry
lentry
    -- recursively add children
    newacclentries :: LayerEntries
newacclentries = if LayerMeta -> Bool
_layerMeta_isCollapsed LayerMeta
lm
      then LayerEntries
newacclentries'
      else OwlTree
-> LayerMetaMap -> LayerEntries -> Maybe LayerEntry -> LayerEntries
buildLayerEntriesRecursive OwlTree
ot LayerMetaMap
lmm LayerEntries
newacclentries' (LayerEntry -> Maybe LayerEntry
forall a. a -> Maybe a
Just LayerEntry
lentry)
  r :: LayerEntries
r = (LayerEntries -> REltId -> LayerEntries)
-> LayerEntries -> Seq REltId -> LayerEntries
forall b a. (b -> a -> b) -> b -> Seq a -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl LayerEntries -> REltId -> LayerEntries
foldlfn LayerEntries
acc (Seq REltId -> LayerEntries) -> Seq REltId -> LayerEntries
forall a b. (a -> b) -> a -> b
$ Seq REltId -> Maybe (Seq REltId) -> Seq REltId
forall a. a -> Maybe a -> a
fromMaybe Seq REltId
forall a. Seq a
Seq.empty (Maybe (Seq REltId) -> Seq REltId)
-> Maybe (Seq REltId) -> Seq REltId
forall a b. (a -> b) -> a -> b
$ case Maybe LayerEntry
mparent of
    Maybe LayerEntry
Nothing -> OwlTree -> Maybe (Seq REltId)
forall o. MommyOwl o => o -> Maybe (Seq REltId)
mommyOwl_kiddos OwlTree
ot
    Just LayerEntry
lentry -> SuperOwl -> Maybe (Seq REltId)
forall o. MommyOwl o => o -> Maybe (Seq REltId)
mommyOwl_kiddos (LayerEntry -> SuperOwl
_layerEntry_superOwl LayerEntry
lentry)

generateLayersNew :: OwlTree -> LayerMetaMap -> Seq LayerEntry
generateLayersNew :: OwlTree -> LayerMetaMap -> LayerEntries
generateLayersNew OwlTree
ot LayerMetaMap
lmm = OwlTree
-> LayerMetaMap -> LayerEntries -> Maybe LayerEntry -> LayerEntries
buildLayerEntriesRecursive OwlTree
ot LayerMetaMap
lmm LayerEntries
forall a. Seq a
Seq.empty Maybe LayerEntry
forall a. Maybe a
Nothing


layerMetaMap_isInheritHiddenOrLocked :: OwlTree -> REltId -> LayerMetaMap -> Bool
layerMetaMap_isInheritHiddenOrLocked :: OwlTree -> REltId -> LayerMetaMap -> Bool
layerMetaMap_isInheritHiddenOrLocked OwlTree
ot REltId
rid LayerMetaMap
lmm = case REltId -> LayerMetaMap -> Maybe LayerMeta
forall a. REltId -> IntMap a -> Maybe a
IM.lookup REltId
rid LayerMetaMap
lmm of
  -- these may both be false, but it may inherit from a parent where these are true therefore we still need to walk up the tree if these are both false
  Just LayerMeta
lm | LayerMeta -> Bool
_layerMeta_isLocked LayerMeta
lm Bool -> Bool -> Bool
|| LayerMeta -> Bool
_layerMeta_isHidden LayerMeta
lm -> Bool
True
  Maybe LayerMeta
_ -> case REltId
-> IntMap (OwlItemMeta, OwlItem) -> Maybe (OwlItemMeta, OwlItem)
forall a. REltId -> IntMap a -> Maybe a
IM.lookup REltId
rid (OwlTree -> IntMap (OwlItemMeta, OwlItem)
_owlTree_mapping OwlTree
ot) of
    Maybe (OwlItemMeta, OwlItem)
Nothing -> Bool
False
    Just (OwlItemMeta
oem,OwlItem
_) -> OwlTree -> REltId -> LayerMetaMap -> Bool
layerMetaMap_isInheritHiddenOrLocked OwlTree
ot (OwlItemMeta -> REltId
_owlItemMeta_parent OwlItemMeta
oem) LayerMetaMap
lmm

layerMetaMap_isInheritHidden :: OwlTree -> REltId -> LayerMetaMap -> Bool
layerMetaMap_isInheritHidden :: OwlTree -> REltId -> LayerMetaMap -> Bool
layerMetaMap_isInheritHidden OwlTree
ot REltId
rid LayerMetaMap
lmm = case REltId -> LayerMetaMap -> Maybe LayerMeta
forall a. REltId -> IntMap a -> Maybe a
IM.lookup REltId
rid LayerMetaMap
lmm of
  Just LayerMeta
lm | LayerMeta -> Bool
_layerMeta_isHidden LayerMeta
lm -> Bool
True
  Maybe LayerMeta
_ -> case REltId
-> IntMap (OwlItemMeta, OwlItem) -> Maybe (OwlItemMeta, OwlItem)
forall a. REltId -> IntMap a -> Maybe a
IM.lookup REltId
rid (OwlTree -> IntMap (OwlItemMeta, OwlItem)
_owlTree_mapping OwlTree
ot) of
    Maybe (OwlItemMeta, OwlItem)
Nothing -> Bool
False
    Just (OwlItemMeta
oem,OwlItem
_) -> OwlTree -> REltId -> LayerMetaMap -> Bool
layerMetaMap_isInheritHidden OwlTree
ot (OwlItemMeta -> REltId
_owlItemMeta_parent OwlItemMeta
oem) LayerMetaMap
lmm