QWindow.hs

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

module Graphics.UI.Qtah.Generated.Gui.QWindow (
  castQWindowToQObject,
  castQObjectToQWindow,
  castQWindowToQSurface,
  castQSurfaceToQWindow,
  QWindowValue (..),
  QWindowConstPtr (..),
  baseSize,
  contentOrientation,
  cursor,
  devicePixelRatio,
  filePath,
  flags,
  focusObject,
  frameGeometry,
  frameMargins,
  framePosition,
  geometry,
  height,
  icon,
  isActive,
  isAncestorOf,
  isExposed,
  isModal,
  isTopLevel,
  mapFromGlobal,
  mapToGlobal,
  mask,
  maximumHeight,
  maximumSize,
  maximumWidth,
  minimumHeight,
  minimumSize,
  minimumWidth,
  modality,
  opacity,
  parent,
  position,
  sizeIncrement,
  title,
  transientParent,
  getType,
  visibility,
  isVisible,
  width,
  windowState,
  x,
  y,
  QWindowPtr (..),
  alert,
  setBaseSize,
  close,
  create,
  setCursor,
  destroy,
  setFilePath,
  setFlags,
  setFramePosition,
  setGeometry,
  setHeight,
  hide,
  setIcon,
  lower,
  setMask,
  setMaximumHeight,
  setMaximumSize,
  setMaximumWidth,
  setMinimumHeight,
  setMinimumSize,
  setMinimumWidth,
  setModality,
  setOpacity,
  setParent,
  setPosition,
  raise,
  reportContentOrientationChange,
  requestActivate,
  requestUpdate,
  resize,
  resizeRaw,
  setGeometryRaw,
  setKeyboardGrabEnabled,
  setMouseGrabEnabled,
  setPositionRaw,
  setSurfaceType,
  show,
  showFullScreen,
  showMaximized,
  showMinimized,
  showNormal,
  setSizeIncrement,
  setTitle,
  setTransientParent,
  unsetCursor,
  setVisibility,
  setVisible,
  setWidth,
  setWindowState,
  setX,
  setY,
  emitActiveChanged,
  emitContentOrientationChanged,
  emitFocusObjectChanged,
  emitHeightChanged,
  emitMaximumHeightChanged,
  emitMaximumWidthChanged,
  emitMinimumHeightChanged,
  emitMinimumWidthChanged,
  emitModalityChanged,
  emitOpacityChanged,
  emitVisibilityChanged,
  emitVisibleChanged,
  emitWidthChanged,
  emitWindowStateChanged,
  emitWindowTitleChanged,
  emitXChanged,
  emitYChanged,
  QWindowConst (..),
  castQWindowToConst,
  QWindow (..),
  castQWindowToNonconst,
  new,
  newWithParent,
  QWindowSuper (..),
  QWindowSuperConst (..),
  QWindowAncestorMode (..),
  QWindowVisibility (..),
  ) where

import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import qualified Graphics.UI.Qtah.Core.HMargins as HMargins
import qualified Graphics.UI.Qtah.Core.HPoint as HPoint
import qualified Graphics.UI.Qtah.Core.HRect as HRect
import qualified Graphics.UI.Qtah.Core.HSize as HSize
import qualified Graphics.UI.Qtah.Flags as QtahFlags
import qualified Graphics.UI.Qtah.Generated.Core.QMargins as M68
import qualified Graphics.UI.Qtah.Generated.Core.QObject as M94
import qualified Graphics.UI.Qtah.Generated.Core.QPoint as M114
import qualified Graphics.UI.Qtah.Generated.Core.QRect as M122
import qualified Graphics.UI.Qtah.Generated.Core.QSize as M134
import qualified Graphics.UI.Qtah.Generated.Core.QString as M142
import qualified Graphics.UI.Qtah.Generated.Core.Types as M190
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Gui.QCursor as M256
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Gui.QIcon as M288
import qualified Graphics.UI.Qtah.Generated.Gui.QRegion as M324
import qualified Graphics.UI.Qtah.Generated.Gui.QSurface as M334
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QWindow_new" new' ::  HoppyP.IO (HoppyF.Ptr QWindow)
foreign import ccall "genpop__QWindow_newWithParent" newWithParent' ::  HoppyF.Ptr QWindow -> HoppyP.IO (HoppyF.Ptr QWindow)
foreign import ccall "genpop__QWindow_alert" alert' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_baseSize" baseSize' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO (HoppyF.Ptr M134.QSizeConst)
foreign import ccall "genpop__QWindow_setBaseSize" setBaseSize' ::  HoppyF.Ptr QWindow -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_close" close' ::  HoppyF.Ptr QWindow -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_contentOrientation" contentOrientation' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWindow_create" create' ::  HoppyF.Ptr QWindow -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_cursor" cursor' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO (HoppyF.Ptr M256.QCursorConst)
foreign import ccall "genpop__QWindow_setCursor" setCursor' ::  HoppyF.Ptr QWindow -> HoppyF.Ptr M256.QCursorConst -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_destroy" destroy' ::  HoppyF.Ptr QWindow -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_devicePixelRatio" devicePixelRatio' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QWindow_filePath" filePath' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QWindow_setFilePath" setFilePath' ::  HoppyF.Ptr QWindow -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_flags" flags' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWindow_setFlags" setFlags' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_focusObject" focusObject' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO (HoppyF.Ptr M94.QObject)
foreign import ccall "genpop__QWindow_frameGeometry" frameGeometry' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO (HoppyF.Ptr M122.QRectConst)
foreign import ccall "genpop__QWindow_frameMargins" frameMargins' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO (HoppyF.Ptr M68.QMarginsConst)
foreign import ccall "genpop__QWindow_framePosition" framePosition' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO (HoppyF.Ptr M114.QPointConst)
foreign import ccall "genpop__QWindow_setFramePosition" setFramePosition' ::  HoppyF.Ptr QWindow -> HoppyF.Ptr M114.QPointConst -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_geometry" geometry' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO (HoppyF.Ptr M122.QRectConst)
foreign import ccall "genpop__QWindow_setGeometry" setGeometry' ::  HoppyF.Ptr QWindow -> HoppyF.Ptr M122.QRectConst -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_height" height' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWindow_setHeight" setHeight' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_hide" hide' ::  HoppyF.Ptr QWindow -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_icon" icon' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO (HoppyF.Ptr M288.QIconConst)
foreign import ccall "genpop__QWindow_setIcon" setIcon' ::  HoppyF.Ptr QWindow -> HoppyF.Ptr M288.QIconConst -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_isActive" isActive' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QWindow_isAncestorOf" isAncestorOf' ::  HoppyF.Ptr QWindowConst -> HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QWindow_isExposed" isExposed' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QWindow_isModal" isModal' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QWindow_isTopLevel" isTopLevel' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QWindow_lower" lower' ::  HoppyF.Ptr QWindow -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_mapFromGlobal" mapFromGlobal' ::  HoppyF.Ptr QWindowConst -> HoppyF.Ptr M114.QPointConst -> HoppyP.IO (HoppyF.Ptr M114.QPointConst)
foreign import ccall "genpop__QWindow_mapToGlobal" mapToGlobal' ::  HoppyF.Ptr QWindowConst -> HoppyF.Ptr M114.QPointConst -> HoppyP.IO (HoppyF.Ptr M114.QPointConst)
foreign import ccall "genpop__QWindow_mask" mask' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO (HoppyF.Ptr M324.QRegionConst)
foreign import ccall "genpop__QWindow_setMask" setMask' ::  HoppyF.Ptr QWindow -> HoppyF.Ptr M324.QRegionConst -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_maximumHeight" maximumHeight' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWindow_setMaximumHeight" setMaximumHeight' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_maximumSize" maximumSize' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO (HoppyF.Ptr M134.QSizeConst)
foreign import ccall "genpop__QWindow_setMaximumSize" setMaximumSize' ::  HoppyF.Ptr QWindow -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_maximumWidth" maximumWidth' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWindow_setMaximumWidth" setMaximumWidth' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_minimumHeight" minimumHeight' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWindow_setMinimumHeight" setMinimumHeight' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_minimumSize" minimumSize' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO (HoppyF.Ptr M134.QSizeConst)
foreign import ccall "genpop__QWindow_setMinimumSize" setMinimumSize' ::  HoppyF.Ptr QWindow -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_minimumWidth" minimumWidth' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWindow_setMinimumWidth" setMinimumWidth' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_modality" modality' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWindow_setModality" setModality' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_opacity" opacity' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QWindow_setOpacity" setOpacity' ::  HoppyF.Ptr QWindow -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_parent" parent' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO (HoppyF.Ptr QWindow)
foreign import ccall "genpop__QWindow_setParent" setParent' ::  HoppyF.Ptr QWindow -> HoppyF.Ptr QWindow -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_position" position' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO (HoppyF.Ptr M114.QPointConst)
foreign import ccall "genpop__QWindow_setPosition" setPosition' ::  HoppyF.Ptr QWindow -> HoppyF.Ptr M114.QPointConst -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_raise" raise' ::  HoppyF.Ptr QWindow -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_reportContentOrientationChange" reportContentOrientationChange' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_requestActivate" requestActivate' ::  HoppyF.Ptr QWindow -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_requestUpdate" requestUpdate' ::  HoppyF.Ptr QWindow -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_resize" resize' ::  HoppyF.Ptr QWindow -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_resizeRaw" resizeRaw' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_setGeometryRaw" setGeometryRaw' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_setKeyboardGrabEnabled" setKeyboardGrabEnabled' ::  HoppyF.Ptr QWindow -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_setMouseGrabEnabled" setMouseGrabEnabled' ::  HoppyF.Ptr QWindow -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_setPositionRaw" setPositionRaw' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_setSurfaceType" setSurfaceType' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_show" show' ::  HoppyF.Ptr QWindow -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_showFullScreen" showFullScreen' ::  HoppyF.Ptr QWindow -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_showMaximized" showMaximized' ::  HoppyF.Ptr QWindow -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_showMinimized" showMinimized' ::  HoppyF.Ptr QWindow -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_showNormal" showNormal' ::  HoppyF.Ptr QWindow -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_sizeIncrement" sizeIncrement' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO (HoppyF.Ptr M134.QSizeConst)
foreign import ccall "genpop__QWindow_setSizeIncrement" setSizeIncrement' ::  HoppyF.Ptr QWindow -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_title" title' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QWindow_setTitle" setTitle' ::  HoppyF.Ptr QWindow -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_transientParent" transientParent' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO (HoppyF.Ptr QWindow)
foreign import ccall "genpop__QWindow_setTransientParent" setTransientParent' ::  HoppyF.Ptr QWindow -> HoppyF.Ptr QWindow -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_getType" getType' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWindow_unsetCursor" unsetCursor' ::  HoppyF.Ptr QWindow -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_visibility" visibility' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWindow_setVisibility" setVisibility' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_isVisible" isVisible' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QWindow_setVisible" setVisible' ::  HoppyF.Ptr QWindow -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_width" width' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWindow_setWidth" setWidth' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_windowState" windowState' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWindow_setWindowState" setWindowState' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_x" x' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWindow_setX" setX' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_y" y' ::  HoppyF.Ptr QWindowConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWindow_setY" setY' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_emitActiveChanged" emitActiveChanged' ::  HoppyF.Ptr QWindow -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_emitContentOrientationChanged" emitContentOrientationChanged' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_emitFocusObjectChanged" emitFocusObjectChanged' ::  HoppyF.Ptr QWindow -> HoppyF.Ptr M94.QObject -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_emitHeightChanged" emitHeightChanged' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_emitMaximumHeightChanged" emitMaximumHeightChanged' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_emitMaximumWidthChanged" emitMaximumWidthChanged' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_emitMinimumHeightChanged" emitMinimumHeightChanged' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_emitMinimumWidthChanged" emitMinimumWidthChanged' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_emitModalityChanged" emitModalityChanged' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_emitOpacityChanged" emitOpacityChanged' ::  HoppyF.Ptr QWindow -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_emitVisibilityChanged" emitVisibilityChanged' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_emitVisibleChanged" emitVisibleChanged' ::  HoppyF.Ptr QWindow -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_emitWidthChanged" emitWidthChanged' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_emitWindowStateChanged" emitWindowStateChanged' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_emitWindowTitleChanged" emitWindowTitleChanged' ::  HoppyF.Ptr QWindow -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_emitXChanged" emitXChanged' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWindow_emitYChanged" emitYChanged' ::  HoppyF.Ptr QWindow -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "gencast__QWindow__QObject" castQWindowToQObject :: HoppyF.Ptr QWindowConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QWindow" castQObjectToQWindow :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QWindowConst
foreign import ccall "gencast__QWindow__QSurface" castQWindowToQSurface :: HoppyF.Ptr QWindowConst -> HoppyF.Ptr M334.QSurfaceConst
foreign import ccall "gencast__QSurface__QWindow" castQSurfaceToQWindow :: HoppyF.Ptr M334.QSurfaceConst -> HoppyF.Ptr QWindowConst
foreign import ccall "gendel__QWindow" delete'QWindow :: HoppyF.Ptr QWindowConst -> HoppyP.IO ()
foreign import ccall "&gendel__QWindow" deletePtr'QWindow :: HoppyF.FunPtr (HoppyF.Ptr QWindowConst -> HoppyP.IO ())

class QWindowValue a where
  withQWindowPtr :: a -> (QWindowConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QWindowConstPtr a => QWindowValue a where
  withQWindowPtr = HoppyP.flip ($) . toQWindowConst

class (M94.QObjectConstPtr this, M334.QSurfaceConstPtr this) => QWindowConstPtr this where
  toQWindowConst :: this -> QWindowConst

baseSize :: (QWindowValue this) => (this) {- ^ this -} -> (HoppyP.IO HSize.HSize)
baseSize arg'1 =
  withQWindowPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M134.QSizeConst) =<<
  (baseSize' arg'1')

contentOrientation :: (QWindowValue this) => (this) {- ^ this -} -> (HoppyP.IO M190.QtScreenOrientation)
contentOrientation arg'1 =
  withQWindowPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (contentOrientation' arg'1')

cursor :: (QWindowValue this) => (this) {- ^ this -} -> (HoppyP.IO M256.QCursor)
cursor arg'1 =
  withQWindowPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M256.QCursorConst) =<<
  (cursor' arg'1')

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

filePath :: (QWindowValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.String)
filePath arg'1 =
  withQWindowPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (filePath' arg'1')

flags :: (QWindowValue this) => (this) {- ^ this -} -> (HoppyP.IO M190.QtWindowFlags)
flags arg'1 =
  withQWindowPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.numToFlags
  ) =<<
  (flags' arg'1')

focusObject :: (QWindowValue this) => (this) {- ^ this -} -> (HoppyP.IO M94.QObject)
focusObject arg'1 =
  withQWindowPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M94.QObject
  (focusObject' arg'1')

frameGeometry :: (QWindowValue this) => (this) {- ^ this -} -> (HoppyP.IO HRect.HRect)
frameGeometry arg'1 =
  withQWindowPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M122.QRectConst) =<<
  (frameGeometry' arg'1')

frameMargins :: (QWindowValue this) => (this) {- ^ this -} -> (HoppyP.IO HMargins.HMargins)
frameMargins arg'1 =
  withQWindowPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M68.QMarginsConst) =<<
  (frameMargins' arg'1')

framePosition :: (QWindowValue this) => (this) {- ^ this -} -> (HoppyP.IO HPoint.HPoint)
framePosition arg'1 =
  withQWindowPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M114.QPointConst) =<<
  (framePosition' arg'1')

geometry :: (QWindowValue this) => (this) {- ^ this -} -> (HoppyP.IO HRect.HRect)
geometry arg'1 =
  withQWindowPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M122.QRectConst) =<<
  (geometry' arg'1')

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

icon :: (QWindowValue this) => (this) {- ^ this -} -> (HoppyP.IO M288.QIcon)
icon arg'1 =
  withQWindowPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M288.QIconConst) =<<
  (icon' arg'1')

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

isAncestorOf :: (QWindowValue this, QWindowPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (QWindowAncestorMode) -> (HoppyP.IO HoppyP.Bool)
isAncestorOf arg'1 arg'2 arg'3 =
  withQWindowPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (toQWindow arg'2) $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isAncestorOf' arg'1' arg'2' arg'3')

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

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

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

mapFromGlobal :: (QWindowValue this, M114.QPointValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HPoint.HPoint)
mapFromGlobal arg'1 arg'2 =
  withQWindowPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M114.withQPointPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . M114.QPointConst) =<<
  (mapFromGlobal' arg'1' arg'2')

mapToGlobal :: (QWindowValue this, M114.QPointValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HPoint.HPoint)
mapToGlobal arg'1 arg'2 =
  withQWindowPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M114.withQPointPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . M114.QPointConst) =<<
  (mapToGlobal' arg'1' arg'2')

mask :: (QWindowValue this) => (this) {- ^ this -} -> (HoppyP.IO M324.QRegion)
mask arg'1 =
  withQWindowPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M324.QRegionConst) =<<
  (mask' arg'1')

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

maximumSize :: (QWindowValue this) => (this) {- ^ this -} -> (HoppyP.IO HSize.HSize)
maximumSize arg'1 =
  withQWindowPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M134.QSizeConst) =<<
  (maximumSize' arg'1')

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

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

minimumSize :: (QWindowValue this) => (this) {- ^ this -} -> (HoppyP.IO HSize.HSize)
minimumSize arg'1 =
  withQWindowPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M134.QSizeConst) =<<
  (minimumSize' arg'1')

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

modality :: (QWindowValue this) => (this) {- ^ this -} -> (HoppyP.IO M190.QtWindowModality)
modality arg'1 =
  withQWindowPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (modality' arg'1')

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

parent :: (QWindowValue this) => (this) {- ^ this -} -> (HoppyP.IO QWindow)
parent arg'1 =
  withQWindowPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QWindow
  (parent' arg'1')

position :: (QWindowValue this) => (this) {- ^ this -} -> (HoppyP.IO HPoint.HPoint)
position arg'1 =
  withQWindowPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M114.QPointConst) =<<
  (position' arg'1')

sizeIncrement :: (QWindowValue this) => (this) {- ^ this -} -> (HoppyP.IO HSize.HSize)
sizeIncrement arg'1 =
  withQWindowPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M134.QSizeConst) =<<
  (sizeIncrement' arg'1')

title :: (QWindowValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.String)
title arg'1 =
  withQWindowPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (title' arg'1')

transientParent :: (QWindowValue this) => (this) {- ^ this -} -> (HoppyP.IO QWindow)
transientParent arg'1 =
  withQWindowPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QWindow
  (transientParent' arg'1')

getType :: (QWindowValue this) => (this) {- ^ this -} -> (HoppyP.IO M190.QtWindowType)
getType arg'1 =
  withQWindowPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (getType' arg'1')

visibility :: (QWindowValue this) => (this) {- ^ this -} -> (HoppyP.IO QWindowVisibility)
visibility arg'1 =
  withQWindowPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (visibility' arg'1')

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

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

windowState :: (QWindowValue this) => (this) {- ^ this -} -> (HoppyP.IO M190.QtWindowState)
windowState arg'1 =
  withQWindowPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (windowState' arg'1')

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

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

class (QWindowConstPtr this, M94.QObjectPtr this, M334.QSurfacePtr this) => QWindowPtr this where
  toQWindow :: this -> QWindow

alert :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
alert arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (alert' arg'1' arg'2')

setBaseSize :: (QWindowPtr this, M134.QSizeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setBaseSize arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  M134.withQSizePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setBaseSize' arg'1' arg'2')

close :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
close arg'1 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (close' arg'1')

create :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
create arg'1 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (create' arg'1')

setCursor :: (QWindowPtr this, M256.QCursorValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setCursor arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  M256.withQCursorPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setCursor' arg'1' arg'2')

destroy :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
destroy arg'1 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (destroy' arg'1')

setFilePath :: (QWindowPtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setFilePath arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setFilePath' arg'1' arg'2')

setFlags :: (QWindowPtr this, M190.IsQtWindowFlags arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setFlags arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtWindowFlags
  ) arg'2 >>= \arg'2' ->
  (setFlags' arg'1' arg'2')

setFramePosition :: (QWindowPtr this, M114.QPointValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setFramePosition arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  M114.withQPointPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setFramePosition' arg'1' arg'2')

setGeometry :: (QWindowPtr this, M122.QRectValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setGeometry arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  M122.withQRectPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setGeometry' arg'1' arg'2')

setHeight :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
setHeight arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (setHeight' arg'1' arg'2')

hide :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
hide arg'1 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (hide' arg'1')

setIcon :: (QWindowPtr this, M288.QIconValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setIcon arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  M288.withQIconPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setIcon' arg'1' arg'2')

lower :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
lower arg'1 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (lower' arg'1')

setMask :: (QWindowPtr this, M324.QRegionValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setMask arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  M324.withQRegionPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setMask' arg'1' arg'2')

setMaximumHeight :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
setMaximumHeight arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (setMaximumHeight' arg'1' arg'2')

setMaximumSize :: (QWindowPtr this, M134.QSizeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setMaximumSize arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  M134.withQSizePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setMaximumSize' arg'1' arg'2')

setMaximumWidth :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
setMaximumWidth arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (setMaximumWidth' arg'1' arg'2')

setMinimumHeight :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
setMinimumHeight arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (setMinimumHeight' arg'1' arg'2')

setMinimumSize :: (QWindowPtr this, M134.QSizeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setMinimumSize arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  M134.withQSizePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setMinimumSize' arg'1' arg'2')

setMinimumWidth :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
setMinimumWidth arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (setMinimumWidth' arg'1' arg'2')

setModality :: (QWindowPtr this) => (this) {- ^ this -} -> (M190.QtWindowModality) -> (HoppyP.IO ())
setModality arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setModality' arg'1' arg'2')

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

setParent :: (QWindowPtr this, QWindowPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setParent arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (toQWindow arg'2) $ \arg'2' ->
  (setParent' arg'1' arg'2')

setPosition :: (QWindowPtr this, M114.QPointValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setPosition arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  M114.withQPointPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setPosition' arg'1' arg'2')

raise :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
raise arg'1 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (raise' arg'1')

reportContentOrientationChange :: (QWindowPtr this) => (this) {- ^ this -} -> (M190.QtScreenOrientation) -> (HoppyP.IO ())
reportContentOrientationChange arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (reportContentOrientationChange' arg'1' arg'2')

requestActivate :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
requestActivate arg'1 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (requestActivate' arg'1')

requestUpdate :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
requestUpdate arg'1 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (requestUpdate' arg'1')

resize :: (QWindowPtr this, M134.QSizeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
resize arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  M134.withQSizePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (resize' arg'1' arg'2')

resizeRaw :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO ())
resizeRaw arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (resizeRaw' arg'1' arg'2' arg'3')

setGeometryRaw :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO ())
setGeometryRaw arg'1 arg'2 arg'3 arg'4 arg'5 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'4 >>= \arg'4' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'5 >>= \arg'5' ->
  (setGeometryRaw' arg'1' arg'2' arg'3' arg'4' arg'5')

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

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

setPositionRaw :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO ())
setPositionRaw arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (setPositionRaw' arg'1' arg'2' arg'3')

setSurfaceType :: (QWindowPtr this) => (this) {- ^ this -} -> (M334.QSurfaceSurfaceType) -> (HoppyP.IO ())
setSurfaceType arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setSurfaceType' arg'1' arg'2')

show :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
show arg'1 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (show' arg'1')

showFullScreen :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
showFullScreen arg'1 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (showFullScreen' arg'1')

showMaximized :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
showMaximized arg'1 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (showMaximized' arg'1')

showMinimized :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
showMinimized arg'1 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (showMinimized' arg'1')

showNormal :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
showNormal arg'1 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (showNormal' arg'1')

setSizeIncrement :: (QWindowPtr this, M134.QSizeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setSizeIncrement arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  M134.withQSizePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setSizeIncrement' arg'1' arg'2')

setTitle :: (QWindowPtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setTitle arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setTitle' arg'1' arg'2')

setTransientParent :: (QWindowPtr this, QWindowPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setTransientParent arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (toQWindow arg'2) $ \arg'2' ->
  (setTransientParent' arg'1' arg'2')

unsetCursor :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
unsetCursor arg'1 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (unsetCursor' arg'1')

setVisibility :: (QWindowPtr this) => (this) {- ^ this -} -> (QWindowVisibility) -> (HoppyP.IO ())
setVisibility arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setVisibility' arg'1' arg'2')

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

setWidth :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
setWidth arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (setWidth' arg'1' arg'2')

setWindowState :: (QWindowPtr this) => (this) {- ^ this -} -> (M190.QtWindowState) -> (HoppyP.IO ())
setWindowState arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setWindowState' arg'1' arg'2')

setX :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
setX arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (setX' arg'1' arg'2')

setY :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
setY arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (setY' arg'1' arg'2')

emitActiveChanged :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
emitActiveChanged arg'1 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (emitActiveChanged' arg'1')

emitContentOrientationChanged :: (QWindowPtr this) => (this) {- ^ this -} -> (M190.QtScreenOrientation) -> (HoppyP.IO ())
emitContentOrientationChanged arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (emitContentOrientationChanged' arg'1' arg'2')

emitFocusObjectChanged :: (QWindowPtr this, M94.QObjectPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
emitFocusObjectChanged arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M94.toQObject arg'2) $ \arg'2' ->
  (emitFocusObjectChanged' arg'1' arg'2')

emitHeightChanged :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
emitHeightChanged arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (emitHeightChanged' arg'1' arg'2')

emitMaximumHeightChanged :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
emitMaximumHeightChanged arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (emitMaximumHeightChanged' arg'1' arg'2')

emitMaximumWidthChanged :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
emitMaximumWidthChanged arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (emitMaximumWidthChanged' arg'1' arg'2')

emitMinimumHeightChanged :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
emitMinimumHeightChanged arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (emitMinimumHeightChanged' arg'1' arg'2')

emitMinimumWidthChanged :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
emitMinimumWidthChanged arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (emitMinimumWidthChanged' arg'1' arg'2')

emitModalityChanged :: (QWindowPtr this) => (this) {- ^ this -} -> (M190.QtWindowModality) -> (HoppyP.IO ())
emitModalityChanged arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (emitModalityChanged' arg'1' arg'2')

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

emitVisibilityChanged :: (QWindowPtr this) => (this) {- ^ this -} -> (QWindowVisibility) -> (HoppyP.IO ())
emitVisibilityChanged arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (emitVisibilityChanged' arg'1' arg'2')

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

emitWidthChanged :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
emitWidthChanged arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (emitWidthChanged' arg'1' arg'2')

emitWindowStateChanged :: (QWindowPtr this) => (this) {- ^ this -} -> (M190.QtWindowState) -> (HoppyP.IO ())
emitWindowStateChanged arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (emitWindowStateChanged' arg'1' arg'2')

emitWindowTitleChanged :: (QWindowPtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
emitWindowTitleChanged arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (emitWindowTitleChanged' arg'1' arg'2')

emitXChanged :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
emitXChanged arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (emitXChanged' arg'1' arg'2')

emitYChanged :: (QWindowPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
emitYChanged arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (emitYChanged' arg'1' arg'2')

data QWindowConst =
    QWindowConst (HoppyF.Ptr QWindowConst)
  | QWindowConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QWindowConst)
  deriving (HoppyP.Show)

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

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

castQWindowToConst :: QWindow -> QWindowConst
castQWindowToConst (QWindow ptr') = QWindowConst $ HoppyF.castPtr ptr'
castQWindowToConst (QWindowGc fptr' ptr') = QWindowConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QWindowConstPtr QWindowConst where
  toQWindowConst = HoppyP.id

instance M94.QObjectConstPtr QWindowConst where
  toQObjectConst (QWindowConst ptr') = M94.QObjectConst $ castQWindowToQObject ptr'
  toQObjectConst (QWindowConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQWindowToQObject ptr'

instance M334.QSurfaceConstPtr QWindowConst where
  toQSurfaceConst (QWindowConst ptr') = M334.QSurfaceConst $ castQWindowToQSurface ptr'
  toQSurfaceConst (QWindowConstGc fptr' ptr') = M334.QSurfaceConstGc fptr' $ castQWindowToQSurface ptr'

data QWindow =
    QWindow (HoppyF.Ptr QWindow)
  | QWindowGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QWindow)
  deriving (HoppyP.Show)

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

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

castQWindowToNonconst :: QWindowConst -> QWindow
castQWindowToNonconst (QWindowConst ptr') = QWindow $ HoppyF.castPtr ptr'
castQWindowToNonconst (QWindowConstGc fptr' ptr') = QWindowGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QWindowConstPtr QWindow where
  toQWindowConst (QWindow ptr') = QWindowConst $ (HoppyF.castPtr :: HoppyF.Ptr QWindow -> HoppyF.Ptr QWindowConst) ptr'
  toQWindowConst (QWindowGc fptr' ptr') = QWindowConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QWindow -> HoppyF.Ptr QWindowConst) ptr'

instance QWindowPtr QWindow where
  toQWindow = HoppyP.id

instance M94.QObjectConstPtr QWindow where
  toQObjectConst (QWindow ptr') = M94.QObjectConst $ castQWindowToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QWindow -> HoppyF.Ptr QWindowConst) ptr'
  toQObjectConst (QWindowGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQWindowToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QWindow -> HoppyF.Ptr QWindowConst) ptr'

instance M94.QObjectPtr QWindow where
  toQObject (QWindow ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQWindowToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QWindow -> HoppyF.Ptr QWindowConst) ptr'
  toQObject (QWindowGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQWindowToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QWindow -> HoppyF.Ptr QWindowConst) ptr'

instance M334.QSurfaceConstPtr QWindow where
  toQSurfaceConst (QWindow ptr') = M334.QSurfaceConst $ castQWindowToQSurface $ (HoppyF.castPtr :: HoppyF.Ptr QWindow -> HoppyF.Ptr QWindowConst) ptr'
  toQSurfaceConst (QWindowGc fptr' ptr') = M334.QSurfaceConstGc fptr' $ castQWindowToQSurface $ (HoppyF.castPtr :: HoppyF.Ptr QWindow -> HoppyF.Ptr QWindowConst) ptr'

instance M334.QSurfacePtr QWindow where
  toQSurface (QWindow ptr') = M334.QSurface $ (HoppyF.castPtr :: HoppyF.Ptr M334.QSurfaceConst -> HoppyF.Ptr M334.QSurface) $ castQWindowToQSurface $ (HoppyF.castPtr :: HoppyF.Ptr QWindow -> HoppyF.Ptr QWindowConst) ptr'
  toQSurface (QWindowGc fptr' ptr') = M334.QSurfaceGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M334.QSurfaceConst -> HoppyF.Ptr M334.QSurface) $ castQWindowToQSurface $ (HoppyF.castPtr :: HoppyF.Ptr QWindow -> HoppyF.Ptr QWindowConst) ptr'

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

newWithParent :: (QWindowPtr arg'1) => (arg'1) -> (HoppyP.IO QWindow)
newWithParent arg'1 =
  HoppyFHR.withCppPtr (toQWindow arg'1) $ \arg'1' ->
  HoppyP.fmap QWindow
  (newWithParent' arg'1')

class QWindowSuper a where
  downToQWindow :: a -> QWindow

instance QWindowSuper M94.QObject where
  downToQWindow = castQWindowToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QWindowConst $ castQObjectToQWindow ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QWindowConstGc fptr' $ castQObjectToQWindow ptr'
instance QWindowSuper M334.QSurface where
  downToQWindow = castQWindowToNonconst . cast' . M334.castQSurfaceToConst
    where
      cast' (M334.QSurfaceConst ptr') = QWindowConst $ castQSurfaceToQWindow ptr'
      cast' (M334.QSurfaceConstGc fptr' ptr') = QWindowConstGc fptr' $ castQSurfaceToQWindow ptr'

class QWindowSuperConst a where
  downToQWindowConst :: a -> QWindowConst

instance QWindowSuperConst M94.QObjectConst where
  downToQWindowConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QWindowConst $ castQObjectToQWindow ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QWindowConstGc fptr' $ castQObjectToQWindow ptr'
instance QWindowSuperConst M334.QSurfaceConst where
  downToQWindowConst = cast'
    where
      cast' (M334.QSurfaceConst ptr') = QWindowConst $ castQSurfaceToQWindow ptr'
      cast' (M334.QSurfaceConstGc fptr' ptr') = QWindowConstGc fptr' $ castQSurfaceToQWindow ptr'

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

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

data QWindowAncestorMode =
  ExcludeTransients
  | IncludeTransients
  | UnknownQWindowAncestorMode (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QWindowAncestorMode where
  fromCppEnum ExcludeTransients = 0
  fromCppEnum IncludeTransients = 1
  fromCppEnum (UnknownQWindowAncestorMode n) = n
  
  toCppEnum (0) = ExcludeTransients
  toCppEnum (1) = IncludeTransients
  toCppEnum n = UnknownQWindowAncestorMode n

instance HoppyP.Eq QWindowAncestorMode where
  x == y = HoppyFHR.fromCppEnum x == HoppyFHR.fromCppEnum y

instance HoppyP.Ord QWindowAncestorMode where
  compare x y = HoppyP.compare (HoppyFHR.fromCppEnum x) (HoppyFHR.fromCppEnum y)

data QWindowVisibility =
  Hidden
  | AutomaticVisibility
  | Windowed
  | Minimized
  | Maximized
  | FullScreen
  | UnknownQWindowVisibility (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QWindowVisibility where
  fromCppEnum Hidden = 0
  fromCppEnum AutomaticVisibility = 1
  fromCppEnum Windowed = 2
  fromCppEnum Minimized = 3
  fromCppEnum Maximized = 4
  fromCppEnum FullScreen = 5
  fromCppEnum (UnknownQWindowVisibility n) = n
  
  toCppEnum (0) = Hidden
  toCppEnum (1) = AutomaticVisibility
  toCppEnum (2) = Windowed
  toCppEnum (3) = Minimized
  toCppEnum (4) = Maximized
  toCppEnum (5) = FullScreen
  toCppEnum n = UnknownQWindowVisibility n

instance HoppyP.Eq QWindowVisibility where
  x == y = HoppyFHR.fromCppEnum x == HoppyFHR.fromCppEnum y

instance HoppyP.Ord QWindowVisibility where
  compare x y = HoppyP.compare (HoppyFHR.fromCppEnum x) (HoppyFHR.fromCppEnum y)