{-# LANGUAGE OverloadedStrings #-}
module Network.MPD.Commands.Extensions where
import Network.MPD.Core
import Network.MPD.Commands
import qualified Network.MPD.Applicative.Internal as A
import qualified Network.MPD.Applicative.CurrentPlaylist as A
import qualified Network.MPD.Applicative.StoredPlaylists as A
import Control.Monad (liftM)
import Data.Traversable (for)
import Data.Foldable (for_)
addMany :: MonadMPD m => PlaylistName -> [Path] -> m ()
addMany :: forall (m :: * -> *). MonadMPD m => PlaylistName -> [Path] -> m ()
addMany PlaylistName
plname [Path]
xs = forall (m :: * -> *) a. MonadMPD m => Command a -> m a
A.runCommand (forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [Path]
xs Path -> Command ()
cmd)
where cmd :: Path -> Command ()
cmd | PlaylistName
plname forall a. Eq a => a -> a -> Bool
== PlaylistName
"" = Path -> Command ()
A.add
| Bool
otherwise = PlaylistName -> Path -> Command ()
A.playlistAdd PlaylistName
plname
addIdMany :: MonadMPD m => Path -> Maybe Position -> m [Id]
addIdMany :: forall (m :: * -> *).
MonadMPD m =>
Path -> Maybe Position -> m [Id]
addIdMany Path
x (Just Position
p) = do
[Path]
fs <- forall (m :: * -> *). MonadMPD m => Path -> m [Path]
listAll Path
x
let fs' :: [(Path, Maybe Position)]
fs' = forall a b. (a -> b) -> [a] -> [b]
map (\(Path
a, Position
b) -> (Path
a, forall a. a -> Maybe a
Just Position
b)) forall a b. (a -> b) -> a -> b
$ forall a b. [a] -> [b] -> [(a, b)]
zip [Path]
fs [Position
p ..]
forall (m :: * -> *) a. MonadMPD m => Command a -> m a
A.runCommand forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
t a -> (a -> f b) -> f (t b)
for [(Path, Maybe Position)]
fs' (forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Path -> Maybe Position -> Command Id
A.addId)
addIdMany Path
x Maybe Position
Nothing = do
[Path]
fs <- forall (m :: * -> *). MonadMPD m => Path -> m [Path]
listAll Path
x
forall (m :: * -> *) a. MonadMPD m => Command a -> m a
A.runCommand forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
t a -> (a -> f b) -> f (t b)
for [Path]
fs (Path -> Maybe Position -> Command Id
`A.addId` forall a. Maybe a
Nothing)
listArtists :: MonadMPD m => m [Artist]
listArtists :: forall (m :: * -> *). MonadMPD m => m [Artist]
listArtists = forall (m :: * -> *). MonadMPD m => Metadata -> Query -> m [Artist]
list Metadata
Artist forall a. Monoid a => a
mempty
listAlbums :: MonadMPD m => Maybe Artist -> m [Album]
listAlbums :: forall (m :: * -> *). MonadMPD m => Maybe Artist -> m [Artist]
listAlbums Maybe Artist
ma = forall (m :: * -> *). MonadMPD m => Metadata -> Query -> m [Artist]
list Metadata
Album (case Maybe Artist
ma of
Maybe Artist
Nothing -> forall a. Monoid a => a
mempty
Just Artist
a -> Metadata
Artist Metadata -> Artist -> Query
=? Artist
a)
listAlbum :: MonadMPD m => Artist -> Album -> m [Song]
listAlbum :: forall (m :: * -> *). MonadMPD m => Artist -> Artist -> m [Song]
listAlbum Artist
artist Artist
album = forall (m :: * -> *). MonadMPD m => Query -> m [Song]
find (Metadata
Artist Metadata -> Artist -> Query
=? Artist
artist forall a. Semigroup a => a -> a -> a
<> Metadata
Album Metadata -> Artist -> Query
=? Artist
album)
getPlaylist :: MonadMPD m => m [Song]
getPlaylist :: forall (m :: * -> *). MonadMPD m => m [Song]
getPlaylist = forall (m :: * -> *). MonadMPD m => Maybe Position -> m [Song]
playlistInfo forall a. Maybe a
Nothing
volume :: MonadMPD m => Int -> m ()
volume :: forall (m :: * -> *). MonadMPD m => Position -> m ()
volume Position
n = do
Maybe Volume
cur <- Status -> Maybe Volume
stVolume forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` forall (m :: * -> *). MonadMPD m => m Status
status
case Maybe Volume
cur of
Maybe Volume
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
Just Volume
v -> forall (m :: * -> *). MonadMPD m => Volume -> m ()
setVolume (forall {b} {p}. (Integral b, Integral p) => p -> b
adjust Volume
v)
where
adjust :: p -> b
adjust p
x = forall a b. (RealFrac a, Integral b) => a -> b
round forall a b. (a -> b) -> a -> b
$ (forall a b. (Integral a, Num b) => a -> b
fromIntegral Position
n forall a. Fractional a => a -> a -> a
/ (Double
100 :: Double)) forall a. Num a => a -> a -> a
* Double
x' forall a. Num a => a -> a -> a
+ Double
x'
where x' :: Double
x' = forall a b. (Integral a, Num b) => a -> b
fromIntegral p
x