QDial.hs

{-# LANGUAGE FlexibleContexts, FlexibleInstances, ForeignFunctionInterface, MonoLocalBinds, MultiParamTypeClasses, ScopedTypeVariables, TypeSynonymInstances, UndecidableInstances #-}
---------- GENERATED FILE, EDITS WILL BE LOST ----------

module Graphics.UI.Qtah.Generated.Widgets.QDial (
  castQDialToQAbstractSlider,
  castQAbstractSliderToQDial,
  castQDialToQWidget,
  castQWidgetToQDial,
  castQDialToQObject,
  castQObjectToQDial,
  QDialValue (..),
  QDialConstPtr (..),
  notchSize,
  notchTarget,
  notchesVisible,
  wrapping,
  QDialPtr (..),
  setNotchTarget,
  setNotchesVisible,
  setWrapping,
  QDialConst (..),
  castQDialToConst,
  QDial (..),
  castQDialToNonconst,
  new,
  newWithParent,
  QDialSuper (..),
  QDialSuperConst (..),
  ) 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 M94
import qualified Graphics.UI.Qtah.Generated.Widgets.QAbstractSlider as M364
import qualified Graphics.UI.Qtah.Generated.Widgets.QWidget as M506
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QDial_new" new' ::  HoppyP.IO (HoppyF.Ptr QDial)
foreign import ccall "genpop__QDial_newWithParent" newWithParent' ::  HoppyF.Ptr M506.QWidget -> HoppyP.IO (HoppyF.Ptr QDial)
foreign import ccall "genpop__QDial_notchSize" notchSize' ::  HoppyF.Ptr QDialConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QDial_notchTarget" notchTarget' ::  HoppyF.Ptr QDialConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QDial_setNotchTarget" setNotchTarget' ::  HoppyF.Ptr QDial -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QDial_notchesVisible" notchesVisible' ::  HoppyF.Ptr QDialConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDial_setNotchesVisible" setNotchesVisible' ::  HoppyF.Ptr QDial -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QDial_wrapping" wrapping' ::  HoppyF.Ptr QDialConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QDial_setWrapping" setWrapping' ::  HoppyF.Ptr QDial -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "gencast__QDial__QAbstractSlider" castQDialToQAbstractSlider :: HoppyF.Ptr QDialConst -> HoppyF.Ptr M364.QAbstractSliderConst
foreign import ccall "gencast__QAbstractSlider__QDial" castQAbstractSliderToQDial :: HoppyF.Ptr M364.QAbstractSliderConst -> HoppyF.Ptr QDialConst
foreign import ccall "gencast__QDial__QWidget" castQDialToQWidget :: HoppyF.Ptr QDialConst -> HoppyF.Ptr M506.QWidgetConst
foreign import ccall "gencast__QWidget__QDial" castQWidgetToQDial :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr QDialConst
foreign import ccall "gencast__QDial__QObject" castQDialToQObject :: HoppyF.Ptr QDialConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QDial" castQObjectToQDial :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QDialConst
foreign import ccall "gendel__QDial" delete'QDial :: HoppyF.Ptr QDialConst -> HoppyP.IO ()
foreign import ccall "&gendel__QDial" deletePtr'QDial :: HoppyF.FunPtr (HoppyF.Ptr QDialConst -> HoppyP.IO ())

class QDialValue a where
  withQDialPtr :: a -> (QDialConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QDialConstPtr a => QDialValue a where
  withQDialPtr = HoppyP.flip ($) . toQDialConst

class (M364.QAbstractSliderConstPtr this) => QDialConstPtr this where
  toQDialConst :: this -> QDialConst

notchSize :: (QDialValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Int)
notchSize arg'1 =
  withQDialPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (notchSize' arg'1')

notchTarget :: (QDialValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Double)
notchTarget arg'1 =
  withQDialPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) =<<
  (notchTarget' arg'1')

notchesVisible :: (QDialValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Bool)
notchesVisible arg'1 =
  withQDialPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (notchesVisible' arg'1')

wrapping :: (QDialValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Bool)
wrapping arg'1 =
  withQDialPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (wrapping' arg'1')

class (QDialConstPtr this, M364.QAbstractSliderPtr this) => QDialPtr this where
  toQDial :: this -> QDial

setNotchTarget :: (QDialPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.IO ())
setNotchTarget arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQDial arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (setNotchTarget' arg'1' arg'2')

setNotchesVisible :: (QDialPtr this) => (this) {- ^ this -} -> (HoppyP.Bool) -> (HoppyP.IO ())
setNotchesVisible arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQDial arg'1) $ \arg'1' ->
  (
    \x -> HoppyP.return $ if x then 1 else 0
  ) arg'2 >>= \arg'2' ->
  (setNotchesVisible' arg'1' arg'2')

setWrapping :: (QDialPtr this) => (this) {- ^ this -} -> (HoppyP.Bool) -> (HoppyP.IO ())
setWrapping arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQDial arg'1) $ \arg'1' ->
  (
    \x -> HoppyP.return $ if x then 1 else 0
  ) arg'2 >>= \arg'2' ->
  (setWrapping' arg'1' arg'2')

data QDialConst =
    QDialConst (HoppyF.Ptr QDialConst)
  | QDialConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QDialConst)
  deriving (HoppyP.Show)

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

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

castQDialToConst :: QDial -> QDialConst
castQDialToConst (QDial ptr') = QDialConst $ HoppyF.castPtr ptr'
castQDialToConst (QDialGc fptr' ptr') = QDialConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QDialConstPtr QDialConst where
  toQDialConst = HoppyP.id

instance M364.QAbstractSliderConstPtr QDialConst where
  toQAbstractSliderConst (QDialConst ptr') = M364.QAbstractSliderConst $ castQDialToQAbstractSlider ptr'
  toQAbstractSliderConst (QDialConstGc fptr' ptr') = M364.QAbstractSliderConstGc fptr' $ castQDialToQAbstractSlider ptr'

instance M506.QWidgetConstPtr QDialConst where
  toQWidgetConst (QDialConst ptr') = M506.QWidgetConst $ castQDialToQWidget ptr'
  toQWidgetConst (QDialConstGc fptr' ptr') = M506.QWidgetConstGc fptr' $ castQDialToQWidget ptr'

instance M94.QObjectConstPtr QDialConst where
  toQObjectConst (QDialConst ptr') = M94.QObjectConst $ castQDialToQObject ptr'
  toQObjectConst (QDialConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQDialToQObject ptr'

data QDial =
    QDial (HoppyF.Ptr QDial)
  | QDialGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QDial)
  deriving (HoppyP.Show)

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

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

castQDialToNonconst :: QDialConst -> QDial
castQDialToNonconst (QDialConst ptr') = QDial $ HoppyF.castPtr ptr'
castQDialToNonconst (QDialConstGc fptr' ptr') = QDialGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QDialConstPtr QDial where
  toQDialConst (QDial ptr') = QDialConst $ (HoppyF.castPtr :: HoppyF.Ptr QDial -> HoppyF.Ptr QDialConst) ptr'
  toQDialConst (QDialGc fptr' ptr') = QDialConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QDial -> HoppyF.Ptr QDialConst) ptr'

instance QDialPtr QDial where
  toQDial = HoppyP.id

instance M364.QAbstractSliderConstPtr QDial where
  toQAbstractSliderConst (QDial ptr') = M364.QAbstractSliderConst $ castQDialToQAbstractSlider $ (HoppyF.castPtr :: HoppyF.Ptr QDial -> HoppyF.Ptr QDialConst) ptr'
  toQAbstractSliderConst (QDialGc fptr' ptr') = M364.QAbstractSliderConstGc fptr' $ castQDialToQAbstractSlider $ (HoppyF.castPtr :: HoppyF.Ptr QDial -> HoppyF.Ptr QDialConst) ptr'

instance M364.QAbstractSliderPtr QDial where
  toQAbstractSlider (QDial ptr') = M364.QAbstractSlider $ (HoppyF.castPtr :: HoppyF.Ptr M364.QAbstractSliderConst -> HoppyF.Ptr M364.QAbstractSlider) $ castQDialToQAbstractSlider $ (HoppyF.castPtr :: HoppyF.Ptr QDial -> HoppyF.Ptr QDialConst) ptr'
  toQAbstractSlider (QDialGc fptr' ptr') = M364.QAbstractSliderGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M364.QAbstractSliderConst -> HoppyF.Ptr M364.QAbstractSlider) $ castQDialToQAbstractSlider $ (HoppyF.castPtr :: HoppyF.Ptr QDial -> HoppyF.Ptr QDialConst) ptr'

instance M506.QWidgetConstPtr QDial where
  toQWidgetConst (QDial ptr') = M506.QWidgetConst $ castQDialToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QDial -> HoppyF.Ptr QDialConst) ptr'
  toQWidgetConst (QDialGc fptr' ptr') = M506.QWidgetConstGc fptr' $ castQDialToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QDial -> HoppyF.Ptr QDialConst) ptr'

instance M506.QWidgetPtr QDial where
  toQWidget (QDial ptr') = M506.QWidget $ (HoppyF.castPtr :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr M506.QWidget) $ castQDialToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QDial -> HoppyF.Ptr QDialConst) ptr'
  toQWidget (QDialGc fptr' ptr') = M506.QWidgetGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr M506.QWidget) $ castQDialToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QDial -> HoppyF.Ptr QDialConst) ptr'

instance M94.QObjectConstPtr QDial where
  toQObjectConst (QDial ptr') = M94.QObjectConst $ castQDialToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QDial -> HoppyF.Ptr QDialConst) ptr'
  toQObjectConst (QDialGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQDialToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QDial -> HoppyF.Ptr QDialConst) ptr'

instance M94.QObjectPtr QDial where
  toQObject (QDial ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQDialToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QDial -> HoppyF.Ptr QDialConst) ptr'
  toQObject (QDialGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQDialToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QDial -> HoppyF.Ptr QDialConst) ptr'

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

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

class QDialSuper a where
  downToQDial :: a -> QDial

instance QDialSuper M364.QAbstractSlider where
  downToQDial = castQDialToNonconst . cast' . M364.castQAbstractSliderToConst
    where
      cast' (M364.QAbstractSliderConst ptr') = QDialConst $ castQAbstractSliderToQDial ptr'
      cast' (M364.QAbstractSliderConstGc fptr' ptr') = QDialConstGc fptr' $ castQAbstractSliderToQDial ptr'
instance QDialSuper M506.QWidget where
  downToQDial = castQDialToNonconst . cast' . M506.castQWidgetToConst
    where
      cast' (M506.QWidgetConst ptr') = QDialConst $ castQWidgetToQDial ptr'
      cast' (M506.QWidgetConstGc fptr' ptr') = QDialConstGc fptr' $ castQWidgetToQDial ptr'
instance QDialSuper M94.QObject where
  downToQDial = castQDialToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QDialConst $ castQObjectToQDial ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QDialConstGc fptr' $ castQObjectToQDial ptr'

class QDialSuperConst a where
  downToQDialConst :: a -> QDialConst

instance QDialSuperConst M364.QAbstractSliderConst where
  downToQDialConst = cast'
    where
      cast' (M364.QAbstractSliderConst ptr') = QDialConst $ castQAbstractSliderToQDial ptr'
      cast' (M364.QAbstractSliderConstGc fptr' ptr') = QDialConstGc fptr' $ castQAbstractSliderToQDial ptr'
instance QDialSuperConst M506.QWidgetConst where
  downToQDialConst = cast'
    where
      cast' (M506.QWidgetConst ptr') = QDialConst $ castQWidgetToQDial ptr'
      cast' (M506.QWidgetConstGc fptr' ptr') = QDialConstGc fptr' $ castQWidgetToQDial ptr'
instance QDialSuperConst M94.QObjectConst where
  downToQDialConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QDialConst $ castQObjectToQDial ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QDialConstGc fptr' $ castQObjectToQDial ptr'

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

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