{-# LANGUAGE CPP, FlexibleContexts, FlexibleInstances, GeneralizedNewtypeDeriving, MultiParamTypeClasses, ScopedTypeVariables, TypeSynonymInstances, UndecidableInstances #-}
#if !MIN_VERSION_base(4,8,0)
{-# LANGUAGE OverlappingInstances #-}
#endif

---------- GENERATED FILE, EDITS WILL BE LOST ----------

module Graphics.UI.Qtah.Generated.Widgets.QSlider (
  castQSliderToQAbstractSlider,
  castQAbstractSliderToQSlider,
  castQSliderToQWidget,
  castQWidgetToQSlider,
  castQSliderToQObject,
  castQObjectToQSlider,
  QSliderValue (..),
  QSliderConstPtr (..),
  tickInterval,
  tickPosition,
  QSliderPtr (..),
  setTickInterval,
  setTickPosition,
  QSliderConst (..),
  castQSliderToConst,
  QSlider (..),
  castQSliderToNonconst,
  new,
  newWithParent,
  newWithOrientation,
  newWithOrientationAndParent,
  QSliderSuper (..),
  QSliderSuperConst (..),
  QSliderTickPosition (..),
  ) where

import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import qualified Graphics.UI.Qtah.Generated.Core.QObject as M30
import qualified Graphics.UI.Qtah.Generated.Core.Types as M58
import qualified Graphics.UI.Qtah.Generated.Widgets.QAbstractSlider as M170
import qualified Graphics.UI.Qtah.Generated.Widgets.QWidget as M280
import Prelude (($), (++), (.), (==))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QSlider_new" new' ::  HoppyP.IO (HoppyF.Ptr QSlider)
foreign import ccall "genpop__QSlider_newWithParent" newWithParent' ::  HoppyF.Ptr M280.QWidget -> HoppyP.IO (HoppyF.Ptr QSlider)
foreign import ccall "genpop__QSlider_newWithOrientation" newWithOrientation' ::  HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QSlider)
foreign import ccall "genpop__QSlider_newWithOrientationAndParent" newWithOrientationAndParent' ::  HoppyFC.CInt -> HoppyF.Ptr M280.QWidget -> HoppyP.IO (HoppyF.Ptr QSlider)
foreign import ccall "genpop__QSlider_tickInterval" tickInterval' ::  HoppyF.Ptr QSliderConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QSlider_setTickInterval" setTickInterval' ::  HoppyF.Ptr QSlider -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QSlider_tickPosition" tickPosition' ::  HoppyF.Ptr QSliderConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QSlider_setTickPosition" setTickPosition' ::  HoppyF.Ptr QSlider -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "gencast__QSlider__QAbstractSlider" castQSliderToQAbstractSlider :: HoppyF.Ptr QSliderConst -> HoppyF.Ptr M170.QAbstractSliderConst
foreign import ccall "gencast__QAbstractSlider__QSlider" castQAbstractSliderToQSlider :: HoppyF.Ptr M170.QAbstractSliderConst -> HoppyF.Ptr QSliderConst
foreign import ccall "gencast__QSlider__QWidget" castQSliderToQWidget :: HoppyF.Ptr QSliderConst -> HoppyF.Ptr M280.QWidgetConst
foreign import ccall "gencast__QWidget__QSlider" castQWidgetToQSlider :: HoppyF.Ptr M280.QWidgetConst -> HoppyF.Ptr QSliderConst
foreign import ccall "gencast__QSlider__QObject" castQSliderToQObject :: HoppyF.Ptr QSliderConst -> HoppyF.Ptr M30.QObjectConst
foreign import ccall "gencast__QObject__QSlider" castQObjectToQSlider :: HoppyF.Ptr M30.QObjectConst -> HoppyF.Ptr QSliderConst
foreign import ccall "gendel__QSlider" delete'QSlider :: HoppyF.Ptr QSliderConst -> HoppyP.IO ()
foreign import ccall "&gendel__QSlider" deletePtr'QSlider :: HoppyF.FunPtr (HoppyF.Ptr QSliderConst -> HoppyP.IO ())

class QSliderValue a where
  withQSliderPtr :: a -> (QSliderConst -> HoppyP.IO b) -> HoppyP.IO b

#if MIN_VERSION_base(4,8,0)
instance {-# OVERLAPPABLE #-} QSliderConstPtr a => QSliderValue a where
#else
instance QSliderConstPtr a => QSliderValue a where
#endif
  withQSliderPtr = HoppyP.flip ($) . toQSliderConst

class (M170.QAbstractSliderConstPtr this) => QSliderConstPtr this where
  toQSliderConst :: this -> QSliderConst

tickInterval :: (QSliderValue arg'1) => arg'1 -> HoppyP.IO HoppyP.Int
tickInterval arg'1 =
  withQSliderPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap HoppyFHR.coerceIntegral
  (tickInterval' arg'1')

tickPosition :: (QSliderValue arg'1) => arg'1 -> HoppyP.IO QSliderTickPosition
tickPosition arg'1 =
  withQSliderPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap (HoppyP.toEnum . HoppyFHR.coerceIntegral)
  (tickPosition' arg'1')

class (QSliderConstPtr this, M170.QAbstractSliderPtr this) => QSliderPtr this where
  toQSlider :: this -> QSlider

setTickInterval :: (QSliderPtr arg'1) => arg'1 -> HoppyP.Int -> HoppyP.IO ()
setTickInterval arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQSlider arg'1) $ \arg'1' ->
  let arg'2' = HoppyFHR.coerceIntegral arg'2 in
  (setTickInterval' arg'1' arg'2')

setTickPosition :: (QSliderPtr arg'1) => arg'1 -> QSliderTickPosition -> HoppyP.IO ()
setTickPosition arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQSlider arg'1) $ \arg'1' ->
  let arg'2' = HoppyFHR.coerceIntegral $ HoppyP.fromEnum arg'2 in
  (setTickPosition' arg'1' arg'2')

data QSliderConst =
    QSliderConst (HoppyF.Ptr QSliderConst)
  | QSliderConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QSliderConst)
  deriving (HoppyP.Show)

instance HoppyP.Eq QSliderConst where
  x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y

instance HoppyP.Ord QSliderConst where
  compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)

castQSliderToConst :: QSlider -> QSliderConst
castQSliderToConst (QSlider ptr') = QSliderConst $ HoppyF.castPtr ptr'
castQSliderToConst (QSliderGc fptr' ptr') = QSliderConstGc fptr' $ HoppyF.castPtr ptr'

instance HoppyFHR.CppPtr QSliderConst where
  nullptr = QSliderConst HoppyF.nullPtr
  
  withCppPtr (QSliderConst ptr') f' = f' ptr'
  withCppPtr (QSliderConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
  
  toPtr (QSliderConst ptr') = ptr'
  toPtr (QSliderConstGc _ ptr') = ptr'
  
  touchCppPtr (QSliderConst _) = HoppyP.return ()
  touchCppPtr (QSliderConstGc fptr' _) = HoppyF.touchForeignPtr fptr'

instance HoppyFHR.Deletable QSliderConst where
  delete (QSliderConst ptr') = delete'QSlider ptr'
  delete (QSliderConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "QSliderConst", " object."]
  
  toGc this'@(QSliderConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip QSliderConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'QSlider :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
  toGc this'@(QSliderConstGc {}) = HoppyP.return this'

instance QSliderConstPtr QSliderConst where
  toQSliderConst = HoppyP.id

instance M170.QAbstractSliderConstPtr QSliderConst where
  toQAbstractSliderConst (QSliderConst ptr') = M170.QAbstractSliderConst $ castQSliderToQAbstractSlider ptr'
  toQAbstractSliderConst (QSliderConstGc fptr' ptr') = M170.QAbstractSliderConstGc fptr' $ castQSliderToQAbstractSlider ptr'

instance M280.QWidgetConstPtr QSliderConst where
  toQWidgetConst (QSliderConst ptr') = M280.QWidgetConst $ castQSliderToQWidget ptr'
  toQWidgetConst (QSliderConstGc fptr' ptr') = M280.QWidgetConstGc fptr' $ castQSliderToQWidget ptr'

instance M30.QObjectConstPtr QSliderConst where
  toQObjectConst (QSliderConst ptr') = M30.QObjectConst $ castQSliderToQObject ptr'
  toQObjectConst (QSliderConstGc fptr' ptr') = M30.QObjectConstGc fptr' $ castQSliderToQObject ptr'

data QSlider =
    QSlider (HoppyF.Ptr QSlider)
  | QSliderGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QSlider)
  deriving (HoppyP.Show)

instance HoppyP.Eq QSlider where
  x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y

instance HoppyP.Ord QSlider where
  compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)

castQSliderToNonconst :: QSliderConst -> QSlider
castQSliderToNonconst (QSliderConst ptr') = QSlider $ HoppyF.castPtr ptr'
castQSliderToNonconst (QSliderConstGc fptr' ptr') = QSliderGc fptr' $ HoppyF.castPtr ptr'

instance HoppyFHR.CppPtr QSlider where
  nullptr = QSlider HoppyF.nullPtr
  
  withCppPtr (QSlider ptr') f' = f' ptr'
  withCppPtr (QSliderGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
  
  toPtr (QSlider ptr') = ptr'
  toPtr (QSliderGc _ ptr') = ptr'
  
  touchCppPtr (QSlider _) = HoppyP.return ()
  touchCppPtr (QSliderGc fptr' _) = HoppyF.touchForeignPtr fptr'

instance HoppyFHR.Deletable QSlider where
  delete (QSlider ptr') = delete'QSlider $ (HoppyF.castPtr ptr' :: HoppyF.Ptr QSliderConst)
  delete (QSliderGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "QSlider", " object."]
  
  toGc this'@(QSlider ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip QSliderGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'QSlider :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
  toGc this'@(QSliderGc {}) = HoppyP.return this'

instance QSliderConstPtr QSlider where
  toQSliderConst (QSlider ptr') = QSliderConst $ (HoppyF.castPtr :: HoppyF.Ptr QSlider -> HoppyF.Ptr QSliderConst) ptr'
  toQSliderConst (QSliderGc fptr' ptr') = QSliderConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QSlider -> HoppyF.Ptr QSliderConst) ptr'

instance QSliderPtr QSlider where
  toQSlider = HoppyP.id

instance M170.QAbstractSliderConstPtr QSlider where
  toQAbstractSliderConst (QSlider ptr') = M170.QAbstractSliderConst $ castQSliderToQAbstractSlider $ (HoppyF.castPtr :: HoppyF.Ptr QSlider -> HoppyF.Ptr QSliderConst) ptr'
  toQAbstractSliderConst (QSliderGc fptr' ptr') = M170.QAbstractSliderConstGc fptr' $ castQSliderToQAbstractSlider $ (HoppyF.castPtr :: HoppyF.Ptr QSlider -> HoppyF.Ptr QSliderConst) ptr'

instance M170.QAbstractSliderPtr QSlider where
  toQAbstractSlider (QSlider ptr') = M170.QAbstractSlider $ (HoppyF.castPtr :: HoppyF.Ptr M170.QAbstractSliderConst -> HoppyF.Ptr M170.QAbstractSlider) $ castQSliderToQAbstractSlider $ (HoppyF.castPtr :: HoppyF.Ptr QSlider -> HoppyF.Ptr QSliderConst) ptr'
  toQAbstractSlider (QSliderGc fptr' ptr') = M170.QAbstractSliderGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M170.QAbstractSliderConst -> HoppyF.Ptr M170.QAbstractSlider) $ castQSliderToQAbstractSlider $ (HoppyF.castPtr :: HoppyF.Ptr QSlider -> HoppyF.Ptr QSliderConst) ptr'

instance M280.QWidgetConstPtr QSlider where
  toQWidgetConst (QSlider ptr') = M280.QWidgetConst $ castQSliderToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QSlider -> HoppyF.Ptr QSliderConst) ptr'
  toQWidgetConst (QSliderGc fptr' ptr') = M280.QWidgetConstGc fptr' $ castQSliderToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QSlider -> HoppyF.Ptr QSliderConst) ptr'

instance M280.QWidgetPtr QSlider where
  toQWidget (QSlider ptr') = M280.QWidget $ (HoppyF.castPtr :: HoppyF.Ptr M280.QWidgetConst -> HoppyF.Ptr M280.QWidget) $ castQSliderToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QSlider -> HoppyF.Ptr QSliderConst) ptr'
  toQWidget (QSliderGc fptr' ptr') = M280.QWidgetGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M280.QWidgetConst -> HoppyF.Ptr M280.QWidget) $ castQSliderToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QSlider -> HoppyF.Ptr QSliderConst) ptr'

instance M30.QObjectConstPtr QSlider where
  toQObjectConst (QSlider ptr') = M30.QObjectConst $ castQSliderToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QSlider -> HoppyF.Ptr QSliderConst) ptr'
  toQObjectConst (QSliderGc fptr' ptr') = M30.QObjectConstGc fptr' $ castQSliderToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QSlider -> HoppyF.Ptr QSliderConst) ptr'

instance M30.QObjectPtr QSlider where
  toQObject (QSlider ptr') = M30.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M30.QObjectConst -> HoppyF.Ptr M30.QObject) $ castQSliderToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QSlider -> HoppyF.Ptr QSliderConst) ptr'
  toQObject (QSliderGc fptr' ptr') = M30.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M30.QObjectConst -> HoppyF.Ptr M30.QObject) $ castQSliderToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QSlider -> HoppyF.Ptr QSliderConst) ptr'

new ::  HoppyP.IO QSlider
new =
  HoppyP.fmap QSlider
  (new')

newWithParent :: (M280.QWidgetPtr arg'1) => arg'1 -> HoppyP.IO QSlider
newWithParent arg'1 =
  HoppyFHR.withCppPtr (M280.toQWidget arg'1) $ \arg'1' ->
  HoppyP.fmap QSlider
  (newWithParent' arg'1')

newWithOrientation ::  M58.QtOrientation -> HoppyP.IO QSlider
newWithOrientation arg'1 =
  let arg'1' = HoppyFHR.coerceIntegral $ HoppyP.fromEnum arg'1 in
  HoppyP.fmap QSlider
  (newWithOrientation' arg'1')

newWithOrientationAndParent :: (M280.QWidgetPtr arg'2) => M58.QtOrientation -> arg'2 -> HoppyP.IO QSlider
newWithOrientationAndParent arg'1 arg'2 =
  let arg'1' = HoppyFHR.coerceIntegral $ HoppyP.fromEnum arg'1 in
  HoppyFHR.withCppPtr (M280.toQWidget arg'2) $ \arg'2' ->
  HoppyP.fmap QSlider
  (newWithOrientationAndParent' arg'1' arg'2')

class QSliderSuper a where
  downToQSlider :: a -> QSlider

instance QSliderSuper M170.QAbstractSlider where
  downToQSlider = castQSliderToNonconst . cast' . M170.castQAbstractSliderToConst
    where
      cast' (M170.QAbstractSliderConst ptr') = QSliderConst $ castQAbstractSliderToQSlider ptr'
      cast' (M170.QAbstractSliderConstGc fptr' ptr') = QSliderConstGc fptr' $ castQAbstractSliderToQSlider ptr'
instance QSliderSuper M280.QWidget where
  downToQSlider = castQSliderToNonconst . cast' . M280.castQWidgetToConst
    where
      cast' (M280.QWidgetConst ptr') = QSliderConst $ castQWidgetToQSlider ptr'
      cast' (M280.QWidgetConstGc fptr' ptr') = QSliderConstGc fptr' $ castQWidgetToQSlider ptr'
instance QSliderSuper M30.QObject where
  downToQSlider = castQSliderToNonconst . cast' . M30.castQObjectToConst
    where
      cast' (M30.QObjectConst ptr') = QSliderConst $ castQObjectToQSlider ptr'
      cast' (M30.QObjectConstGc fptr' ptr') = QSliderConstGc fptr' $ castQObjectToQSlider ptr'

class QSliderSuperConst a where
  downToQSliderConst :: a -> QSliderConst

instance QSliderSuperConst M170.QAbstractSliderConst where
  downToQSliderConst = cast'
    where
      cast' (M170.QAbstractSliderConst ptr') = QSliderConst $ castQAbstractSliderToQSlider ptr'
      cast' (M170.QAbstractSliderConstGc fptr' ptr') = QSliderConstGc fptr' $ castQAbstractSliderToQSlider ptr'
instance QSliderSuperConst M280.QWidgetConst where
  downToQSliderConst = cast'
    where
      cast' (M280.QWidgetConst ptr') = QSliderConst $ castQWidgetToQSlider ptr'
      cast' (M280.QWidgetConstGc fptr' ptr') = QSliderConstGc fptr' $ castQWidgetToQSlider ptr'
instance QSliderSuperConst M30.QObjectConst where
  downToQSliderConst = cast'
    where
      cast' (M30.QObjectConst ptr') = QSliderConst $ castQObjectToQSlider ptr'
      cast' (M30.QObjectConstGc fptr' ptr') = QSliderConstGc fptr' $ castQObjectToQSlider ptr'

instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr QSlider)) QSlider where
  assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'

instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr QSlider)) QSlider where
  decode = HoppyP.fmap QSlider . HoppyF.peek

data QSliderTickPosition =
  NoTicks
  | TicksBothSides
  | TicksAbove
  | TicksBelow
  deriving (HoppyP.Bounded, HoppyP.Eq, HoppyP.Ord, HoppyP.Show)

instance HoppyP.Enum QSliderTickPosition where
  fromEnum NoTicks = 0
  fromEnum TicksBothSides = 1
  fromEnum TicksAbove = 2
  fromEnum TicksBelow = 3
  
  toEnum (0) = NoTicks
  toEnum (1) = TicksBothSides
  toEnum (2) = TicksAbove
  toEnum (3) = TicksBelow
  toEnum n' = HoppyP.error $ "Unknown QSliderTickPosition numeric value: " ++ HoppyP.show n'