diff --git a/Controller.hs b/Controller.hs --- a/Controller.hs +++ b/Controller.hs @@ -1,23 +1,25 @@ {-# LANGUAGE ViewPatterns #-} {-# LANGUAGE GADTs #-} -module Controller (Evento (..), catchEvento, mkWorld, World (..), Lasso (..), Verso (..)) where +module Controller (Evento (..), catchEvento, mkWorld, World (..), Lasso (..), Verso (..), updateTime) where import Data.Maybe (fromMaybe) +import Control.Arrow (first, second) import Data.List.Zipper (mkZipper, Zipper , inserisci, elimina, destra, sinistra, modifica) -import Data.Tree.Missing (inspectTop , forward, backward) -import Model (Figura, Punto) -import IFigura (IFigura(IFigura), traslazione, rotazione, movimentoCentroTop, modificaSelettori, ricentra, iselectors) - -data MoveEffect = Ruotando Punto | Traslando Punto | SpostandoCentro Punto | Niente +import Data.Tree.Missing (inspectTop , forward, backward, topSelector) +import Model (Figura, Punto(..), vicino, assolutizza, Tempo (..), Normalizzato) +import IFigura (IFigura(IFigura), ifigura , traslazione, rotazione, movimentoCentroTop, modificaSelettori, ricentra, iselectors) +import Movie -data World = World (Zipper IFigura) MoveEffect +data MoveEffect = Ruotando Punto | Traslando Punto | SpostandoCentro Punto | SpostandoFulcrum Punto| Niente +data World = World (Tempo Normalizzato) (Zipper (IFigura,Fulcrum)) MoveEffect mkWorld :: Figura -> World mkWorld fig = World - (mkZipper $ IFigura fig [] (forward (inspectTop fig) fig) (backward (inspectTop fig) fig)) + (Tempo 0) + (mkZipper $ (IFigura fig [] (forward (inspectTop fig) fig) (backward (inspectTop fig) fig), Fulcrum (topSelector fig) $ Punto (0,0))) Niente data Lasso = Inizio | Fine @@ -36,33 +38,43 @@ Seleziona :: Punto -> Evento Deseleziona :: Evento Silent :: Evento + SpostamentoFulcrum :: Punto -> Lasso -> Evento + RicentraFulcrum :: Punto -> Evento +modificaIFigura f = modifica $ first f +modificaFulcrum f = modifica $ second f + catchEvento :: Evento -> World -> World -catchEvento Refresh (World z _) = World z Niente -catchEvento (Puntatore p) (World z Niente) = World z Niente -catchEvento (Puntatore p) (World z (Traslando q)) = World (modifica (traslazione q p) z) $ Traslando p -catchEvento (Puntatore p) (World z (Ruotando q)) = World (modifica (rotazione q p) z) $ Ruotando p -catchEvento (Puntatore p) (World z (SpostandoCentro q)) = World (modifica (movimentoCentroTop q p) z) $ SpostandoCentro p -catchEvento (Rotazione p Inizio) (World z _) = World z (Ruotando p) -catchEvento (Rotazione p Fine) (World z (Ruotando _)) = World z Niente +catchEvento Refresh (World t z _) = World t z Niente +catchEvento (Puntatore p) (World t z Niente) = World t z Niente +catchEvento (Puntatore p) (World t z (Traslando q)) = World t (modificaIFigura (traslazione q p) z) $ Traslando p +catchEvento (Puntatore p) (World t z (Ruotando q)) = World t (modificaIFigura (rotazione q p) z) $ Ruotando p +catchEvento (Puntatore p) (World t z (SpostandoCentro q)) = World t (modificaIFigura (movimentoCentroTop q p) z) $ SpostandoCentro p +catchEvento (Puntatore p) (World t z (SpostandoFulcrum q)) = World t (modificaFulcrum (\ful -> ful {fulcrum = q}) z) $ SpostandoFulcrum p +catchEvento (Rotazione p Inizio) (World t z _) = World t z (Ruotando p) +catchEvento (Rotazione p Fine) (World t z (Ruotando _)) = World t z Niente catchEvento (Rotazione p Fine) w = w -catchEvento (Traslazione p Inizio) (World z _) = World z (Traslando p) -catchEvento (Traslazione p Fine) (World z (Traslando _)) = World z Niente +catchEvento (Traslazione p Inizio) (World t z _) = World t z (Traslando p) +catchEvento (Traslazione p Fine) (World t z (Traslando _)) = World t z Niente catchEvento (Traslazione p Fine) w = w -catchEvento (SpostamentoCentro p Inizio) (World z _) = World z (SpostandoCentro p) -catchEvento (SpostamentoCentro p Fine) (World z (SpostandoCentro _)) = World z Niente +catchEvento (SpostamentoCentro p Inizio) (World t z _) = World t z (SpostandoCentro p) +catchEvento (SpostamentoCentro p Fine) (World t z (SpostandoCentro _)) = World t z Niente catchEvento (SpostamentoCentro p Fine) w = w -catchEvento Cancella (World z m) = World (fromMaybe z $ elimina z) m -catchEvento Clona (World z m) = World (inserisci id z) m -catchEvento (Fuoco Destra) (World z m) = World (destra z) m -catchEvento (Fuoco Sinistra) (World z m) = World (sinistra z) m -catchEvento (Seleziona p) (World z m) = World (modifica (modificaSelettori p) z) m -catchEvento Deseleziona (World z m) = World (modifica f z) m where +catchEvento Cancella (World t z m) = World t (fromMaybe z $ elimina z) m +catchEvento Clona (World t z m) = World t (inserisci id z) m +catchEvento (Fuoco Destra) (World t z m) = World t (destra z) m +catchEvento (Fuoco Sinistra) (World t z m) = World t (sinistra z) m +catchEvento (Seleziona p) (World t z m) = World t (modificaIFigura (modificaSelettori p) z) m +catchEvento Deseleziona (World t z m) = World t (modificaIFigura f z) m where f ifig = ifig {iselectors = []} -catchEvento (Ricentra p) (World z m) = World (modifica (ricentra p) z) m +catchEvento (Ricentra p) (World t z m) = World t (modificaIFigura (ricentra p) z) m catchEvento Silent w = w - - - - +catchEvento (SpostamentoFulcrum p Inizio) (World t z _) = World t z (SpostandoFulcrum p) +catchEvento (SpostamentoFulcrum p Fine) (World t z (SpostandoFulcrum _)) = World t z Niente +catchEvento (SpostamentoFulcrum p Fine) w = w +catchEvento (RicentraFulcrum p) (World t z m) = World t (modifica f z) m where + f (ifi, Fulcrum _ q) = (ifi, Fulcrum (vicino p (assolutizza $ ifigura ifi)) q) +updateTime :: Float -> World -> World +updateTime ((/3) -> t) (World (tempo -> t') z m) = World (Tempo t'') z m where + t'' = if t + t' > 1 then 0 else t + t' diff --git a/Data/List/Zipper.hs b/Data/List/Zipper.hs --- a/Data/List/Zipper.hs +++ b/Data/List/Zipper.hs @@ -17,7 +17,9 @@ module Data.List.Zipper where -data Zipper a = Zipper [a] [a] +data Zipper a = Zipper [a] [a] +instance Functor Zipper where + fmap f (Zipper xs ys) = Zipper (fmap f xs) (fmap f ys) sinistra z@(Zipper [] _) = z sinistra (Zipper (x:xs) ys) = Zipper xs (x:ys) @@ -25,6 +27,9 @@ destra z@(Zipper _ [x]) = z destra (Zipper xs (y:ys)) = Zipper (y:xs) ys +isLast (Zipper [] _) = True +isLast _ = False + mkZipper x = Zipper [] [x] valore (Zipper _ (x:_)) = x @@ -35,7 +40,7 @@ elimina (Zipper xs (y:ys)) = Just (Zipper xs ys) modifica f (Zipper xs (y:ys)) = Zipper xs (f y : ys) -elementi (Zipper xs ys) = xs ++ ys +elementi (Zipper xs ys) = reverse xs ++ ys diff --git a/Data/Tree/Missing.hs b/Data/Tree/Missing.hs --- a/Data/Tree/Missing.hs +++ b/Data/Tree/Missing.hs @@ -12,16 +12,16 @@ ----------------------------------------------------------------------------- -{-# LANGUAGE ScopedTypeVariables, NoMonomorphismRestriction #-} +{-# LANGUAGE ScopedTypeVariables, NoMonomorphismRestriction, Rank2Types, ImpredicativeTypes #-} -module Data.Tree.Missing (inspectTop, modifyTop, recurseTreeAccum, backward, forward, Routing, routingDumb) where +module Data.Tree.Missing (inspectTop, modifyTop, recurseTreeAccum, backward, forward, Routing, routingDumb, fromSelector, topSelector) where import Prelude hiding (zipWith) import Control.Monad (msum) import Data.List (splitAt,inits,tails) import Data.Tree (Tree (Node)) -import Data.Zip (Zip (..)) +import Data.Zip (Zip (..), labella, Selector , Label, mkSelector) @@ -69,5 +69,14 @@ routingDumb :: Routing b -> Tree b -> Tree b routingDumb r = snd . r undefined (const id) + +topSelector :: Tree a -> Selector Tree b +topSelector t = mkSelector (==0) $ labella t + +fromSelector :: Tree a -> Selector Tree Label -> (forall c . Routing c, forall c . Routing c) +fromSelector ifig ir = let + lifig = labella ifig + r = head $ snd (ir lifig) + in (forward r lifig, backward r lifig) diff --git a/Data/Zip.hs b/Data/Zip.hs --- a/Data/Zip.hs +++ b/Data/Zip.hs @@ -38,12 +38,15 @@ ch f (x,y) | t x = f y | otherwise = y -labella :: Traversable t => [a] -> t b -> t a -labella xs = snd . mapAccumL (\(x:xs) _ -> (xs,x)) xs +type Label = Int +labella :: Traversable t => t b -> t Label +labella = snd . mapAccumL (\(x:xs) _ -> (xs,x)) [0..] + moveSelector :: (Functor t, Foldable t, Traversable t, Zip t) => t a -> (forall a . t a -> t a) -> Selector t Bool -> Selector t b moveSelector tr r s = mkSelector id . r $ fst (s . fmap (const False) $ tr) (const True) + filterDuplicates :: forall t a b . (Functor t, Foldable t, Traversable t, Zip t) => t a -> (forall b . [Selector t b]) -> [Selector t b] diff --git a/Gloss.hs b/Gloss.hs --- a/Gloss.hs +++ b/Gloss.hs @@ -3,9 +3,9 @@ import Data.Monoid (mconcat) -import Graphics.Gloss.Interface.Game +import Graphics.Gloss.Interface.Pure.Game (Picture(..), translate, rotate, color - , yellow, white, Event (..), gameInWindow + , yellow, white, Event (..), play, Display (..) , scale, blue, makeColor, Key (..), MouseButton (..), SpecialKey (..), KeyState (..)) import View (RenderHelp, Colore, Render) @@ -51,4 +51,4 @@ gloss_implementazione = Implementazione renderPezzo colore renderHelp glCatch gloss_run :: String -> (Int,Int) -> (Int,Int) -> Run Picture Event -gloss_run s c l w rew ce = gameInWindow s c l white 0 w rew ce (const id) +gloss_run s c l w rew ce up = play (InWindow s c l) white 100 w rew ce up diff --git a/IFigura.hs b/IFigura.hs --- a/IFigura.hs +++ b/IFigura.hs @@ -1,12 +1,11 @@ {-# LANGUAGE Rank2Types #-} {-# LANGUAGE ViewPatterns #-} {-# LANGUAGE NoMonomorphismRestriction #-} -{-# LANGUAGE ImpredicativeTypes #-} module IFigura where import Data.Tree (Tree) -import Data.Tree.Missing (routingDumb, forward, backward,modifyTop, Routing) +import Data.Tree.Missing (routingDumb, forward, backward,modifyTop, Routing, fromSelector) import Data.Zip (Selector, moveSelector, filterDuplicates, labella) import Model (Figura, ruotaScelto, vicino, Punto (..), Pezzo (..), assolutizza, relativizza,rotazioneInOrigine, routingPezzi) @@ -22,11 +21,8 @@ ricentra l (IFigura ifig isels _ ibackw ) = let ifig' = rotazioneInOrigine . routingPezzi undefined ibackw $ assolutizza ifig isels' = map (moveSelector ifig $ routingDumb ibackw) isels - ir = vicino l ifig' - lifig = labella [0..] ifig' - c = head $ snd (ir lifig) - iforw = forward c lifig - ibackw' = backward c lifig + ir = vicino l ifig' + (iforw , ibackw') = fromSelector ifig' ir ifig'' = relativizza . rotazioneInOrigine . routingPezzi undefined iforw $ ifig' isels'' = map (moveSelector ifig' $ routingDumb iforw) isels' in IFigura ifig'' isels'' iforw ibackw' diff --git a/Math.hs b/Math.hs new file mode 100644 --- /dev/null +++ b/Math.hs @@ -0,0 +1,49 @@ +{-# LANGUAGE TypeFamilies, GeneralizedNewtypeDeriving #-} +module Math where + +import Data.VectorSpace + +-- | un punto nel piano 2d ascissa e ordinata o anche un vettore +newtype Punto = Punto (Float,Float) deriving (Eq,Show, Read, AdditiveGroup) + +-- | un angolo +type Angolo = Float + +-- campo dei Punto +instance Num Punto where + (+) (Punto (x,y)) (Punto (x1,y1)) = Punto (x+x1,y+y1) + negate (Punto (x,y)) = Punto (negate x,negate y) + (*) = error "Punto Num method undefined used" + abs x = error $ "abs :" ++ show x ++ " Punto Num method undefined used" + signum = error "signum : Punto Num method undefined used" + fromInteger x = error $ "fromInteger " ++ show x ++ ": Punto Num method undefined used" + + +instance VectorSpace Punto where + type Scalar Punto = Float + t *^ (Punto (x,y)) = Punto (x * t,y * t) + + +type Ruota = Punto -> Punto + +-- rotazione intorno all'origine +ruota :: Angolo -> Ruota +ruota alpha (Punto (x,y))= Punto (cos alpha * x - sin alpha * y, sin alpha * x + cos alpha * y) + + +-- modulo di un vettore +modulus :: Punto -> Float +modulus (Punto (x,y)) = sqrt (x ^ 2 + y ^ 2) + + +pointOfOnlyRotation :: (Punto,Angolo) -> (Punto,Angolo) -> Punto +pointOfOnlyRotation (p1,alpha1) (p2,alpha2) = let + dp@(Punto (dpx,dpy)) = p2 - p1 + s = modulus (p2 - p1) + x = Punto (s/2 , 0) + y = Punto (0, s / 2 / tan (alpha / 2)) + alpha = alpha2 - alpha1 + beta = atan2 dpy dpx + in ruota beta (y - x) + p2 + + diff --git a/Model.hs b/Model.hs --- a/Model.hs +++ b/Model.hs @@ -3,46 +3,22 @@ {-# LANGUAGE EmptyDataDecls #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} -module Model where -- (Punto (..), Semiretta (..), Angolo , TreePath, Tree, Accelerazione, configura, film) where +module Model (Punto (..), Angolo, Pezzo (..), rotazioneInOrigine, routingPezzi + , ruotaScelto, vicino, Figura , relativizza, assolutizza, Assoluto, Relativo, Normalizzato, Tempo (..) , interpolazione) where import Prelude hiding (zipWith) +import Data.VectorSpace ((*^)) import Data.Tree (Tree(..)) -import Data.Tree.Missing ( recurseTreeAccum, Routing, modifyTop) +import Data.Tree.Missing ( recurseTreeAccum, Routing, modifyTop, inspectTop) import Control.Applicative ((<$>)) import Control.Monad (ap) import Data.Foldable (minimumBy, toList) import Data.List.Zipper import Data.Ord (comparing) import Control.Arrow (Arrow(..)) -import Debug.Trace +import Math import Data.Zip - --- | un punto nel piano 2d ascissa e ordinata o anche un vettore -newtype Punto = Punto (Float,Float) deriving (Eq,Show, Read) - --- | un angolo -type Angolo = Float - --- campo dei Punto -instance Num Punto where - (+) (Punto (x,y)) (Punto (x1,y1)) = Punto (x+x1,y+y1) - negate (Punto (x,y)) = Punto (negate x,negate y) - (*) = error "Punto Num method undefined used" - abs x = error $ "abs :" ++ show x ++ " Punto Num method undefined used" - signum = error "signum : Punto Num method undefined used" - fromInteger x = error $ "fromInteger " ++ show x ++ ": Punto Num method undefined used" - - -type Ruota = Punto -> Punto - --- rotazione intorno all'origine -ruota :: Angolo -> Ruota -ruota alpha (Punto (x,y))= Punto (cos alpha * x - sin alpha * y, sin alpha * x + cos alpha * y) - - --- modulo di un vettore -modulus :: Punto -> Float -modulus (Punto (x,y)) = sqrt (x ^ 2 + y ^ 2) +import Debug.Trace data Relativo data Assoluto @@ -54,9 +30,6 @@ } deriving (Show,Read,Eq) - - - assolutizza :: Tree (Pezzo Relativo) -> Tree (Pezzo Assoluto) assolutizza = recurseTreeAccum (Punto (0,0)) f where f q (Pezzo c o alpha) = (qc, Pezzo qc (o + qc) alpha ) where qc = q + c @@ -97,12 +70,19 @@ (.-.) :: Tempo Assoluto -> Tempo Assoluto -> Tempo Relativo (.-.) = tf (-) +normalizzaAngolo alpha + | alpha < -pi = normalizzaAngolo $ alpha + 2 * pi + | alpha > pi = normalizzaAngolo $ alpha - 2 * pi + | otherwise = alpha interpolazione :: Tree (Pezzo Relativo) -> Tree (Pezzo Relativo) -> Tempo Normalizzato -> Tree (Pezzo Relativo) -interpolazione t1 t2 t = aggiorna $ zipWith variazioneAngolo t1 t2 where - variazioneAngolo p p' = ((rotazionePezzo p' - rotazionePezzo p) / tempo t, p) +interpolazione t1 t2 t = modifyTop (\(Pezzo _ r alpha) -> Pezzo (l t) r alpha) . aggiorna $ zipWith variazioneAngolo t1 t2 where + variazioneAngolo p p' = (tempo t * ((normalizzaAngolo $ rotazionePezzo p') - (normalizzaAngolo $ rotazionePezzo p)), p) + l t = l0 + tempo t *^ (l1 - l0) + l0 = fulcroPezzo (inspectTop t1) + l1 = fulcroPezzo (inspectTop t2) type Figura = Tree (Pezzo Relativo) diff --git a/Movie.hs b/Movie.hs new file mode 100644 --- /dev/null +++ b/Movie.hs @@ -0,0 +1,52 @@ +{-# LANGUAGE Rank2Types #-} +{-# LANGUAGE ViewPatterns #-} +{-# LANGUAGE ImpredicativeTypes #-} +module Movie where + +import Prelude hiding (foldr, zipWith) +import Data.Foldable + + +import Math.Spline.BSpline +import Math.Spline.Knots (Knots) + +import Data.Tree + +import Data.Vector (fromList) + +import Math + +import Model + +import Data.List.Zipper + +import Data.Tree.Missing + +import Data.Zip + +type Index = Int + + +spline :: Knots Float -> [Pezzo Assoluto] -> BSpline Punto +spline x = bSpline x . fromList . map originePezzo + + +type Movie = [Tree (Pezzo Assoluto)] + +splines :: Knots Float -> Movie -> Tree (BSpline Punto) +splines x (y:ys) = fmap (spline x) . foldr (zipWith (:)) (fmap return y) $ ys +splines x [] = error "empty movie to spline" + +generaPasso :: Tree (Pezzo Assoluto) -> Tree (Pezzo Assoluto) -> Fulcrum -> Tempo Normalizzato -> Figura +generaPasso fp fa (Fulcrum s p) = let + (forw,_) = fromSelector fp s + fp' = relativizza $ fp + fa' = relativizza $ fa + in interpolazione fp' fa' + +data Fulcrum = Fulcrum + { legato :: Selector Tree Label + , fulcrum :: Punto + } + + diff --git a/Run.hs b/Run.hs --- a/Run.hs +++ b/Run.hs @@ -5,7 +5,7 @@ import Model (Pezzo (Pezzo), Punto (Punto), Assoluto, relativizza) import View (Render, Colore, RenderHelp, renderWorld) -import Controller (World(World), Evento, mkWorld, catchEvento) +import Controller (World(World), Evento, mkWorld, catchEvento, updateTime) data Geometrici = Ge @@ -35,11 +35,11 @@ , catturaEvento :: e -> Evento } -type Run b e = World -> (World -> b) -> (e -> World -> World) -> IO () +type Run b e = World -> (World -> b) -> (e -> World -> World) -> (Float -> World -> World) -> IO () run :: Monoid b => Run b e -> Implementazione b e -> Descrizione -> IO () -run f (Implementazione mks co mo ca) de = f w rew cat where - rew = renderWorld co mo (fmap (mks . snd) de) . (\(World ifig _) -> ifig) +run f (Implementazione mks co mo ca) de = f w rew cat updateTime where + rew = renderWorld co mo (fmap (mks . snd) de) cat = catchEvento . ca w = mkWorld (relativizza $ fmap (mkPezzo . fst) de) diff --git a/View.hs b/View.hs --- a/View.hs +++ b/View.hs @@ -1,17 +1,19 @@ +{-# LANGUAGE ViewPatterns #-} module View (RenderHelp, Render, Colore, renderWorld) where import Prelude hiding (zipWith) import Data.Tree (Tree) import Data.Foldable (toList) -import Data.Monoid (mconcat,Monoid) +import Data.Monoid (mconcat,Monoid,mempty) import Data.Zip (zipWith) import Data.Tree.Missing (modifyTop, routingDumb) -import Data.List.Zipper (Zipper, elementi, valore) -import Model (assolutizza , Pezzo , Assoluto, Figura) +import Data.List.Zipper (Zipper, elementi, valore, destra, sinistra, isLast) +import Model (assolutizza , Pezzo , Assoluto, Figura, Tempo, Normalizzato, routingPezzi, rotazioneInOrigine) import IFigura (IFigura(IFigura)) - +import Controller (World (..)) +import Movie type Render b = Pezzo Assoluto -> b @@ -33,11 +35,21 @@ type RenderHelp b = [String] -> b -renderWorld :: Monoid b => Colore b -> RenderHelp b -> Tree (Render b) -> Zipper IFigura -> b -renderWorld co he re ca = let - ps = mconcat . map (renderIFigura co re) $ elementi ca - actual = renderIFigura co re . valore $ ca - in mconcat [co text $ he help, co (0.5,0.5,0.5) ps, co (0.1,0.1,0.1) actual] + +film = (0.7,0.7,0.7) + +renderMovie :: Monoid b => Tree (Render b) -> Tempo Normalizzato -> ((IFigura, Fulcrum), (IFigura, Fulcrum)) -> b +renderMovie re t ((IFigura ifig _ _ back,fu), (IFigura ifig2 _ _ back2,_)) = let + ifig' = rotazioneInOrigine . routingPezzi undefined back $ assolutizza ifig + ifig'' = rotazioneInOrigine . routingPezzi undefined back2 $ assolutizza ifig2 + in renderFigura re . generaPasso ifig' ifig'' fu $ t + +renderWorld :: Monoid b => Colore b -> RenderHelp b -> Tree (Render b) -> World -> b +renderWorld co he re (World t z _) = let + xs = elementi z + ms = co film . mconcat . map (renderMovie re t) . zip xs $ tail xs + actual = renderIFigura co re . fst . valore $ z + in mconcat [co text $ he help, actual, ms] help = [ "S: select/deselect nearest to pointer piece for rotation" , "Space: deselect all pieces" diff --git a/gloss.patch b/gloss.patch deleted file mode 100644 --- a/gloss.patch +++ /dev/null @@ -1,13 +0,0 @@ ---- Graphics/Gloss/Internals/Interface/Backend/GLUT.hs 2011-11-16 09:58:40.359886120 +0100 -+++ Graphics/Gloss/Internals/Interface/Backend/GLUT.patched.hs 2011-11-16 09:58:57.951886166 +0100 -@@ -239,7 +239,9 @@ - -> IO () - - installMotionCallbackGLUT ref callbacks -- = GLUT.motionCallback $= Just (callbackMotion ref callbacks) -+ = do GLUT.motionCallback $= Just (callbackMotion ref callbacks) -+ GLUT.passiveMotionCallback $= Just (callbackMotion ref callbacks) -+ - - callbackMotion - :: IORef GLUTState -> [Callback] diff --git a/marionetta.cabal b/marionetta.cabal --- a/marionetta.cabal +++ b/marionetta.cabal @@ -7,7 +7,7 @@ -- The package version. See the Haskell package versioning policy -- (http://www.haskell.org/haskellwiki/Package_versioning_policy) for -- standards guiding when and how versions should be incremented. -Version: 0.1.0.1 +Version: 0.1.0.3 -- A short (one-line) description of the package. Synopsis: A study of marionetta movements. @@ -40,7 +40,7 @@ -- Extra files to be distributed with the package, such as examples or -- a README. -Extra-source-files: gloss.patch +Extra-source-files: -- Constraint on the version of Cabal needed to build this package. Cabal-version: >=1.2 @@ -51,10 +51,10 @@ Main-is: marionetta.hs -- Packages needed in order to build this package. - Build-depends: base >=4 && <5, mtl -any, containers -any , gloss -any + Build-depends: base >=4 && <5, mtl >= 0.2.0.1, containers >= 0.4.2.1 , gloss == 1.7.4.1, splines == 0.3, vector-space == 0.8.0, vector == 0.9.1 -- Modules not exported by this package. - Other-modules: Controller Data.List.Zipper Data.Tree.Missing Data.Zip Gloss IFigura Model View Run + Other-modules: Controller Data.List.Zipper Data.Tree.Missing Data.Zip Gloss IFigura Model View Run Math Movie -- Extra tools (e.g. alex, hsc2hs, ...) needed to build the source. -- Build-tools: