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

module Graphics.UI.Qtah.Generated.Widgets.QWidget (
  castQWidgetToQObject,
  castQObjectToQWidget,
  QWidgetValue (..),
  QWidgetConstPtr (..),
  acceptDrops,
  accessibleDescription,
  accessibleName,
  autoFillBackground,
  backgroundRole,
  baseSize,
  childAtRaw,
  childAtPoint,
  childrenRect,
  contentsMargins,
  contentsRect,
  contextMenuPolicy,
  cursor,
  ensurePolished,
  focusProxy,
  focusWidget,
  font,
  frameGeometry,
  frameSize,
  geometry,
  hasFocus,
  hasMouseTracking,
  height,
  heightForWidth,
  isActiveWindow,
  isAncestorOf,
  isEnabled,
  isEnabledTo,
  isFullScreen,
  isHidden,
  isMaximized,
  isMinimized,
  isModal,
  isVisible,
  isVisibleTo,
  isWindow,
  isWindowModified,
  layout,
  layoutDirection,
  mapFrom,
  mapFromGlobal,
  mapFromParent,
  mapTo,
  mapToGlobal,
  mapToParent,
  maximumHeight,
  maximumSize,
  maximumWidth,
  minimumHeight,
  minimumSize,
  minimumWidth,
  nativeParentWidget,
  nextInFocusChain,
  normalGeometry,
  palette,
  parentWidget,
  pos,
  previousInFocusChain,
  rect,
  saveGeometry,
  size,
  sizeHint,
  sizeIncrement,
  sizePolicy,
  statusTip,
  styleSheet,
  toolTip,
  underMouse,
  updatesEnabled,
  whatsThis,
  width,
  window,
  windowFilePath,
  windowFlags,
  windowIcon,
  windowIconText,
  windowModality,
  windowOpacity,
  windowRole,
  windowState,
  windowTitle,
  x,
  y,
  QWidgetPtr (..),
  activateWindow,
  addAction,
  adjustSize,
  setBackgroundRole,
  clearFocus,
  clearMask,
  close,
  setContextMenuPolicy,
  setCursor,
  setFont,
  grab,
  grabWithRect,
  grabKeyboard,
  grabMouse,
  grabMouseWithCursor,
  hide,
  insertAction,
  lower,
  move,
  setPalette,
  raise,
  releaseKeyboard,
  releaseMouse,
  removeAction,
  renderWithTarget,
  renderWithTargetAndOffset,
  renderWithTargetAndOffsetAndRegion,
  renderWithPainter,
  renderWithPainterAndOffset,
  renderWithPainterAndOffsetAndRegion,
  repaint,
  repaintRaw,
  repaintRect,
  resize,
  resizeRaw,
  restoreGeometry,
  scrollRaw,
  scrollRect,
  setAcceptDrops,
  setAccessibleDescription,
  setAccessibleName,
  setAutoFillBackground,
  setBaseSize,
  setBaseSizeRaw,
  setContentsMargins,
  setContentsMarginsRaw,
  setEnabled,
  setDisabled,
  setFixedHeight,
  setFixedSize,
  setFixedSizeRaw,
  setFixedWidth,
  setFocus,
  setFocusProxy,
  setGeometryRaw,
  setGeometryRect,
  setHidden,
  setLayout,
  setLayoutDirection,
  setMaximumHeight,
  setMaximumSize,
  setMaximumSizeRaw,
  setMaximumWidth,
  setMinimumHeight,
  setMinimumSize,
  setMinimumSizeRaw,
  setMinimumWidth,
  setMouseTracking,
  setParent,
  setParentWithFlags,
  setSizeIncrement,
  setSizeIncrementRaw,
  setSizePolicyRaw,
  setStatusTip,
  setStyleSheet,
  setToolTip,
  setUpdatesEnabled,
  setVisible,
  setWhatsThis,
  setWindowFilePath,
  setWindowIconText,
  setWindowModified,
  setWindowRole,
  show,
  showFullScreen,
  showMaximized,
  showMinimized,
  showNormal,
  setSizePolicy,
  stackUnder,
  unsetCursor,
  unsetLayoutDirection,
  unsetLocale,
  update,
  updateRaw,
  updateRect,
  updateGeometry,
  setWindowFlags,
  setWindowIcon,
  setWindowModality,
  setWindowOpacity,
  setWindowState,
  setWindowTitle,
  emitCustomContextMenuRequested,
  emitWindowIconChanged,
  emitWindowTitleChanged,
  keyboardGrabber,
  mouseGrabber,
  setTabOrder,
  QWidgetConst (..),
  castQWidgetToConst,
  QWidget (..),
  castQWidgetToNonconst,
  new,
  newWithParent,
  QWidgetSuper (..),
  QWidgetSuperConst (..),
  ) where

import qualified Data.ByteString as QtahDBS
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.QByteArray as M12
import qualified Graphics.UI.Qtah.Generated.Core.QMargins as M68
import qualified Graphics.UI.Qtah.Generated.Core.QObject as M94
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Core.QPalette as M98
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 qualified Graphics.UI.Qtah.Generated.Gui.QFont as M276
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Gui.QIcon as M288
import qualified Graphics.UI.Qtah.Generated.Gui.QPaintDevice as M304
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Gui.QPainter as M310
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Gui.QPixmap as M316
import qualified Graphics.UI.Qtah.Generated.Gui.QRegion as M324
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Widgets.QAction as M368
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Widgets.QLayout as M432
import qualified Graphics.UI.Qtah.Generated.Widgets.QSizePolicy as M468
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QWidget_new" new' ::  HoppyP.IO (HoppyF.Ptr QWidget)
foreign import ccall "genpop__QWidget_newWithParent" newWithParent' ::  HoppyF.Ptr QWidget -> HoppyP.IO (HoppyF.Ptr QWidget)
foreign import ccall "genpop__QWidget_acceptDrops" acceptDrops' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QWidget_accessibleDescription" accessibleDescription' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QWidget_accessibleName" accessibleName' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QWidget_activateWindow" activateWindow' ::  HoppyF.Ptr QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_addAction" addAction' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M368.QAction -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_adjustSize" adjustSize' ::  HoppyF.Ptr QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_autoFillBackground" autoFillBackground' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QWidget_backgroundRole" backgroundRole' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWidget_setBackgroundRole" setBackgroundRole' ::  HoppyF.Ptr QWidget -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_baseSize" baseSize' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M134.QSizeConst)
foreign import ccall "genpop__QWidget_childAtRaw" childAtRaw' ::  HoppyF.Ptr QWidgetConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QWidget)
foreign import ccall "genpop__QWidget_childAtPoint" childAtPoint' ::  HoppyF.Ptr QWidgetConst -> HoppyF.Ptr M114.QPointConst -> HoppyP.IO (HoppyF.Ptr QWidget)
foreign import ccall "genpop__QWidget_childrenRect" childrenRect' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M122.QRectConst)
foreign import ccall "genpop__QWidget_clearFocus" clearFocus' ::  HoppyF.Ptr QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_clearMask" clearMask' ::  HoppyF.Ptr QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_close" close' ::  HoppyF.Ptr QWidget -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QWidget_contentsMargins" contentsMargins' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M68.QMarginsConst)
foreign import ccall "genpop__QWidget_contentsRect" contentsRect' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M122.QRectConst)
foreign import ccall "genpop__QWidget_contextMenuPolicy" contextMenuPolicy' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWidget_setContextMenuPolicy" setContextMenuPolicy' ::  HoppyF.Ptr QWidget -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_cursor" cursor' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M256.QCursorConst)
foreign import ccall "genpop__QWidget_setCursor" setCursor' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M256.QCursorConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_ensurePolished" ensurePolished' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_focusProxy" focusProxy' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr QWidget)
foreign import ccall "genpop__QWidget_focusWidget" focusWidget' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr QWidget)
foreign import ccall "genpop__QWidget_font" font' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M276.QFontConst)
foreign import ccall "genpop__QWidget_setFont" setFont' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M276.QFontConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_frameGeometry" frameGeometry' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M122.QRectConst)
foreign import ccall "genpop__QWidget_frameSize" frameSize' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M134.QSizeConst)
foreign import ccall "genpop__QWidget_geometry" geometry' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M122.QRectConst)
foreign import ccall "genpop__QWidget_grab" grab' ::  HoppyF.Ptr QWidget -> HoppyP.IO (HoppyF.Ptr M316.QPixmapConst)
foreign import ccall "genpop__QWidget_grabWithRect" grabWithRect' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M122.QRectConst -> HoppyP.IO (HoppyF.Ptr M316.QPixmapConst)
foreign import ccall "genpop__QWidget_grabKeyboard" grabKeyboard' ::  HoppyF.Ptr QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_grabMouse" grabMouse' ::  HoppyF.Ptr QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_grabMouseWithCursor" grabMouseWithCursor' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M256.QCursorConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_hasFocus" hasFocus' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QWidget_hasMouseTracking" hasMouseTracking' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QWidget_height" height' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWidget_heightForWidth" heightForWidth' ::  HoppyF.Ptr QWidgetConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWidget_hide" hide' ::  HoppyF.Ptr QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_insertAction" insertAction' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M368.QAction -> HoppyF.Ptr M368.QAction -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_isActiveWindow" isActiveWindow' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QWidget_isAncestorOf" isAncestorOf' ::  HoppyF.Ptr QWidgetConst -> HoppyF.Ptr QWidget -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QWidget_isEnabled" isEnabled' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QWidget_isEnabledTo" isEnabledTo' ::  HoppyF.Ptr QWidgetConst -> HoppyF.Ptr QWidget -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QWidget_isFullScreen" isFullScreen' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QWidget_isHidden" isHidden' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QWidget_isMaximized" isMaximized' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QWidget_isMinimized" isMinimized' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QWidget_isModal" isModal' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QWidget_isVisible" isVisible' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QWidget_isVisibleTo" isVisibleTo' ::  HoppyF.Ptr QWidgetConst -> HoppyF.Ptr QWidget -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QWidget_isWindow" isWindow' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QWidget_isWindowModified" isWindowModified' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QWidget_keyboardGrabber" keyboardGrabber' ::  HoppyP.IO (HoppyF.Ptr QWidget)
foreign import ccall "genpop__QWidget_layout" layout' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M432.QLayout)
foreign import ccall "genpop__QWidget_layoutDirection" layoutDirection' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWidget_lower" lower' ::  HoppyF.Ptr QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_mapFrom" mapFrom' ::  HoppyF.Ptr QWidgetConst -> HoppyF.Ptr QWidget -> HoppyF.Ptr M114.QPointConst -> HoppyP.IO (HoppyF.Ptr M114.QPointConst)
foreign import ccall "genpop__QWidget_mapFromGlobal" mapFromGlobal' ::  HoppyF.Ptr QWidgetConst -> HoppyF.Ptr M114.QPointConst -> HoppyP.IO (HoppyF.Ptr M114.QPointConst)
foreign import ccall "genpop__QWidget_mapFromParent" mapFromParent' ::  HoppyF.Ptr QWidgetConst -> HoppyF.Ptr M114.QPointConst -> HoppyP.IO (HoppyF.Ptr M114.QPointConst)
foreign import ccall "genpop__QWidget_mapTo" mapTo' ::  HoppyF.Ptr QWidgetConst -> HoppyF.Ptr QWidget -> HoppyF.Ptr M114.QPointConst -> HoppyP.IO (HoppyF.Ptr M114.QPointConst)
foreign import ccall "genpop__QWidget_mapToGlobal" mapToGlobal' ::  HoppyF.Ptr QWidgetConst -> HoppyF.Ptr M114.QPointConst -> HoppyP.IO (HoppyF.Ptr M114.QPointConst)
foreign import ccall "genpop__QWidget_mapToParent" mapToParent' ::  HoppyF.Ptr QWidgetConst -> HoppyF.Ptr M114.QPointConst -> HoppyP.IO (HoppyF.Ptr M114.QPointConst)
foreign import ccall "genpop__QWidget_maximumHeight" maximumHeight' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWidget_maximumSize" maximumSize' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M134.QSizeConst)
foreign import ccall "genpop__QWidget_maximumWidth" maximumWidth' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWidget_minimumHeight" minimumHeight' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWidget_minimumSize" minimumSize' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M134.QSizeConst)
foreign import ccall "genpop__QWidget_minimumWidth" minimumWidth' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWidget_mouseGrabber" mouseGrabber' ::  HoppyP.IO (HoppyF.Ptr QWidget)
foreign import ccall "genpop__QWidget_move" move' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M114.QPointConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_nativeParentWidget" nativeParentWidget' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr QWidget)
foreign import ccall "genpop__QWidget_nextInFocusChain" nextInFocusChain' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr QWidget)
foreign import ccall "genpop__QWidget_normalGeometry" normalGeometry' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M122.QRectConst)
foreign import ccall "genpop__QWidget_palette" palette' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M98.QPaletteConst)
foreign import ccall "genpop__QWidget_setPalette" setPalette' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M98.QPaletteConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_parentWidget" parentWidget' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr QWidget)
foreign import ccall "genpop__QWidget_pos" pos' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M114.QPointConst)
foreign import ccall "genpop__QWidget_previousInFocusChain" previousInFocusChain' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr QWidget)
foreign import ccall "genpop__QWidget_raise" raise' ::  HoppyF.Ptr QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_rect" rect' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M122.QRectConst)
foreign import ccall "genpop__QWidget_releaseKeyboard" releaseKeyboard' ::  HoppyF.Ptr QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_releaseMouse" releaseMouse' ::  HoppyF.Ptr QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_removeAction" removeAction' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M368.QAction -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_renderWithTarget" renderWithTarget' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M304.QPaintDevice -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_renderWithTargetAndOffset" renderWithTargetAndOffset' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M304.QPaintDevice -> HoppyF.Ptr M114.QPointConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_renderWithTargetAndOffsetAndRegion" renderWithTargetAndOffsetAndRegion' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M304.QPaintDevice -> HoppyF.Ptr M114.QPointConst -> HoppyF.Ptr M324.QRegionConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_renderWithPainter" renderWithPainter' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M310.QPainter -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_renderWithPainterAndOffset" renderWithPainterAndOffset' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M310.QPainter -> HoppyF.Ptr M114.QPointConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_renderWithPainterAndOffsetAndRegion" renderWithPainterAndOffsetAndRegion' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M310.QPainter -> HoppyF.Ptr M114.QPointConst -> HoppyF.Ptr M324.QRegionConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_repaint" repaint' ::  HoppyF.Ptr QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_repaintRaw" repaintRaw' ::  HoppyF.Ptr QWidget -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_repaintRect" repaintRect' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M122.QRectConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_resize" resize' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_resizeRaw" resizeRaw' ::  HoppyF.Ptr QWidget -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_restoreGeometry" restoreGeometry' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QWidget_saveGeometry" saveGeometry' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QWidget_scrollRaw" scrollRaw' ::  HoppyF.Ptr QWidget -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_scrollRect" scrollRect' ::  HoppyF.Ptr QWidget -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr M122.QRectConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setAcceptDrops" setAcceptDrops' ::  HoppyF.Ptr QWidget -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setAccessibleDescription" setAccessibleDescription' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setAccessibleName" setAccessibleName' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setAutoFillBackground" setAutoFillBackground' ::  HoppyF.Ptr QWidget -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setBaseSize" setBaseSize' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setBaseSizeRaw" setBaseSizeRaw' ::  HoppyF.Ptr QWidget -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setContentsMargins" setContentsMargins' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M68.QMarginsConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setContentsMarginsRaw" setContentsMarginsRaw' ::  HoppyF.Ptr QWidget -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setEnabled" setEnabled' ::  HoppyF.Ptr QWidget -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setDisabled" setDisabled' ::  HoppyF.Ptr QWidget -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setFixedHeight" setFixedHeight' ::  HoppyF.Ptr QWidget -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setFixedSize" setFixedSize' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setFixedSizeRaw" setFixedSizeRaw' ::  HoppyF.Ptr QWidget -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setFixedWidth" setFixedWidth' ::  HoppyF.Ptr QWidget -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setFocus" setFocus' ::  HoppyF.Ptr QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setFocusProxy" setFocusProxy' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setGeometryRaw" setGeometryRaw' ::  HoppyF.Ptr QWidget -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setGeometryRect" setGeometryRect' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M122.QRectConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setHidden" setHidden' ::  HoppyF.Ptr QWidget -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setLayout" setLayout' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M432.QLayout -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setLayoutDirection" setLayoutDirection' ::  HoppyF.Ptr QWidget -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setMaximumHeight" setMaximumHeight' ::  HoppyF.Ptr QWidget -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setMaximumSize" setMaximumSize' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setMaximumSizeRaw" setMaximumSizeRaw' ::  HoppyF.Ptr QWidget -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setMaximumWidth" setMaximumWidth' ::  HoppyF.Ptr QWidget -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setMinimumHeight" setMinimumHeight' ::  HoppyF.Ptr QWidget -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setMinimumSize" setMinimumSize' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setMinimumSizeRaw" setMinimumSizeRaw' ::  HoppyF.Ptr QWidget -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setMinimumWidth" setMinimumWidth' ::  HoppyF.Ptr QWidget -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setMouseTracking" setMouseTracking' ::  HoppyF.Ptr QWidget -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setParent" setParent' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setParentWithFlags" setParentWithFlags' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr QWidget -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setSizeIncrement" setSizeIncrement' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setSizeIncrementRaw" setSizeIncrementRaw' ::  HoppyF.Ptr QWidget -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setSizePolicyRaw" setSizePolicyRaw' ::  HoppyF.Ptr QWidget -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setStatusTip" setStatusTip' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setStyleSheet" setStyleSheet' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setTabOrder" setTabOrder' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setToolTip" setToolTip' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setUpdatesEnabled" setUpdatesEnabled' ::  HoppyF.Ptr QWidget -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setVisible" setVisible' ::  HoppyF.Ptr QWidget -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setWhatsThis" setWhatsThis' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setWindowFilePath" setWindowFilePath' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setWindowIconText" setWindowIconText' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setWindowModified" setWindowModified' ::  HoppyF.Ptr QWidget -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_setWindowRole" setWindowRole' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_show" show' ::  HoppyF.Ptr QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_showFullScreen" showFullScreen' ::  HoppyF.Ptr QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_showMaximized" showMaximized' ::  HoppyF.Ptr QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_showMinimized" showMinimized' ::  HoppyF.Ptr QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_showNormal" showNormal' ::  HoppyF.Ptr QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_size" size' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M134.QSizeConst)
foreign import ccall "genpop__QWidget_sizeHint" sizeHint' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M134.QSizeConst)
foreign import ccall "genpop__QWidget_sizeIncrement" sizeIncrement' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M134.QSizeConst)
foreign import ccall "genpop__QWidget_sizePolicy" sizePolicy' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M468.QSizePolicyConst)
foreign import ccall "genpop__QWidget_setSizePolicy" setSizePolicy' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M468.QSizePolicyConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_stackUnder" stackUnder' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_statusTip" statusTip' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QWidget_styleSheet" styleSheet' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QWidget_toolTip" toolTip' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QWidget_underMouse" underMouse' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QWidget_unsetCursor" unsetCursor' ::  HoppyF.Ptr QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_unsetLayoutDirection" unsetLayoutDirection' ::  HoppyF.Ptr QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_unsetLocale" unsetLocale' ::  HoppyF.Ptr QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_update" update' ::  HoppyF.Ptr QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_updateRaw" updateRaw' ::  HoppyF.Ptr QWidget -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_updateRect" updateRect' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M122.QRectConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_updateGeometry" updateGeometry' ::  HoppyF.Ptr QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_updatesEnabled" updatesEnabled' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QWidget_whatsThis" whatsThis' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QWidget_width" width' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWidget_window" window' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr QWidget)
foreign import ccall "genpop__QWidget_windowFilePath" windowFilePath' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QWidget_windowFlags" windowFlags' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWidget_setWindowFlags" setWindowFlags' ::  HoppyF.Ptr QWidget -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_windowIcon" windowIcon' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M288.QIconConst)
foreign import ccall "genpop__QWidget_setWindowIcon" setWindowIcon' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M288.QIconConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_windowIconText" windowIconText' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QWidget_windowModality" windowModality' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWidget_setWindowModality" setWindowModality' ::  HoppyF.Ptr QWidget -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_windowOpacity" windowOpacity' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QWidget_setWindowOpacity" setWindowOpacity' ::  HoppyF.Ptr QWidget -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_windowRole" windowRole' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QWidget_windowState" windowState' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWidget_setWindowState" setWindowState' ::  HoppyF.Ptr QWidget -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_windowTitle" windowTitle' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QWidget_setWindowTitle" setWindowTitle' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_x" x' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWidget_y" y' ::  HoppyF.Ptr QWidgetConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QWidget_emitCustomContextMenuRequested" emitCustomContextMenuRequested' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M114.QPointConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_emitWindowIconChanged" emitWindowIconChanged' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M288.QIconConst -> HoppyP.IO ()
foreign import ccall "genpop__QWidget_emitWindowTitleChanged" emitWindowTitleChanged' ::  HoppyF.Ptr QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "gencast__QWidget__QObject" castQWidgetToQObject :: HoppyF.Ptr QWidgetConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QWidget" castQObjectToQWidget :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QWidgetConst
foreign import ccall "gendel__QWidget" delete'QWidget :: HoppyF.Ptr QWidgetConst -> HoppyP.IO ()
foreign import ccall "&gendel__QWidget" deletePtr'QWidget :: HoppyF.FunPtr (HoppyF.Ptr QWidgetConst -> HoppyP.IO ())

class QWidgetValue a where
  withQWidgetPtr :: a -> (QWidgetConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QWidgetConstPtr a => QWidgetValue a where
  withQWidgetPtr = HoppyP.flip ($) . toQWidgetConst

class (M94.QObjectConstPtr this) => QWidgetConstPtr this where
  toQWidgetConst :: this -> QWidgetConst

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

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

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

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

backgroundRole :: (QWidgetValue this) => (this) {- ^ this -} -> (HoppyP.IO M98.QPaletteColorRole)
backgroundRole arg'1 =
  withQWidgetPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (backgroundRole' arg'1')

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

childAtRaw :: (QWidgetValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO QWidget)
childAtRaw arg'1 arg'2 arg'3 =
  withQWidgetPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  HoppyP.fmap QWidget
  (childAtRaw' arg'1' arg'2' arg'3')

childAtPoint :: (QWidgetValue this, M114.QPointValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QWidget)
childAtPoint arg'1 arg'2 =
  withQWidgetPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M114.withQPointPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QWidget
  (childAtPoint' arg'1' arg'2')

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

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

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

contextMenuPolicy :: (QWidgetValue this) => (this) {- ^ this -} -> (HoppyP.IO M190.QtContextMenuPolicy)
contextMenuPolicy arg'1 =
  withQWidgetPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (contextMenuPolicy' arg'1')

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

ensurePolished :: (QWidgetValue this) => (this) {- ^ this -} -> (HoppyP.IO ())
ensurePolished arg'1 =
  withQWidgetPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (ensurePolished' arg'1')

focusProxy :: (QWidgetValue this) => (this) {- ^ this -} -> (HoppyP.IO QWidget)
focusProxy arg'1 =
  withQWidgetPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QWidget
  (focusProxy' arg'1')

focusWidget :: (QWidgetValue this) => (this) {- ^ this -} -> (HoppyP.IO QWidget)
focusWidget arg'1 =
  withQWidgetPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QWidget
  (focusWidget' arg'1')

font :: (QWidgetValue this) => (this) {- ^ this -} -> (HoppyP.IO M276.QFont)
font arg'1 =
  withQWidgetPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M276.QFontConst) =<<
  (font' arg'1')

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

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

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

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

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

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

heightForWidth :: (QWidgetValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Int)
heightForWidth arg'1 arg'2 =
  withQWidgetPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (heightForWidth' arg'1' arg'2')

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

isAncestorOf :: (QWidgetValue this, QWidgetPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
isAncestorOf arg'1 arg'2 =
  withQWidgetPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (toQWidget arg'2) $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isAncestorOf' arg'1' arg'2')

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

isEnabledTo :: (QWidgetValue this, QWidgetPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
isEnabledTo arg'1 arg'2 =
  withQWidgetPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (toQWidget arg'2) $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isEnabledTo' arg'1' arg'2')

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

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

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

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

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

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

isVisibleTo :: (QWidgetValue this, QWidgetPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
isVisibleTo arg'1 arg'2 =
  withQWidgetPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (toQWidget arg'2) $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isVisibleTo' arg'1' arg'2')

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

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

layout :: (QWidgetValue this) => (this) {- ^ this -} -> (HoppyP.IO M432.QLayout)
layout arg'1 =
  withQWidgetPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M432.QLayout
  (layout' arg'1')

layoutDirection :: (QWidgetValue this) => (this) {- ^ this -} -> (HoppyP.IO M190.QtLayoutDirection)
layoutDirection arg'1 =
  withQWidgetPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (layoutDirection' arg'1')

mapFrom :: (QWidgetValue this, QWidgetPtr arg'2, M114.QPointValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO HPoint.HPoint)
mapFrom arg'1 arg'2 arg'3 =
  withQWidgetPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (toQWidget arg'2) $ \arg'2' ->
  M114.withQPointPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (HoppyFHR.decodeAndDelete . M114.QPointConst) =<<
  (mapFrom' arg'1' arg'2' arg'3')

mapFromGlobal :: (QWidgetValue this, M114.QPointValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HPoint.HPoint)
mapFromGlobal arg'1 arg'2 =
  withQWidgetPtr 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')

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

mapTo :: (QWidgetValue this, QWidgetPtr arg'2, M114.QPointValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO HPoint.HPoint)
mapTo arg'1 arg'2 arg'3 =
  withQWidgetPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (toQWidget arg'2) $ \arg'2' ->
  M114.withQPointPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (HoppyFHR.decodeAndDelete . M114.QPointConst) =<<
  (mapTo' arg'1' arg'2' arg'3')

mapToGlobal :: (QWidgetValue this, M114.QPointValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HPoint.HPoint)
mapToGlobal arg'1 arg'2 =
  withQWidgetPtr 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')

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

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

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

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

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

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

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

nativeParentWidget :: (QWidgetValue this) => (this) {- ^ this -} -> (HoppyP.IO QWidget)
nativeParentWidget arg'1 =
  withQWidgetPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QWidget
  (nativeParentWidget' arg'1')

nextInFocusChain :: (QWidgetValue this) => (this) {- ^ this -} -> (HoppyP.IO QWidget)
nextInFocusChain arg'1 =
  withQWidgetPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QWidget
  (nextInFocusChain' arg'1')

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

palette :: (QWidgetValue this) => (this) {- ^ this -} -> (HoppyP.IO M98.QPalette)
palette arg'1 =
  withQWidgetPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M98.QPaletteConst) =<<
  (palette' arg'1')

parentWidget :: (QWidgetValue this) => (this) {- ^ this -} -> (HoppyP.IO QWidget)
parentWidget arg'1 =
  withQWidgetPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QWidget
  (parentWidget' arg'1')

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

previousInFocusChain :: (QWidgetValue this) => (this) {- ^ this -} -> (HoppyP.IO QWidget)
previousInFocusChain arg'1 =
  withQWidgetPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QWidget
  (previousInFocusChain' arg'1')

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

saveGeometry :: (QWidgetValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahDBS.ByteString)
saveGeometry arg'1 =
  withQWidgetPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (saveGeometry' arg'1')

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

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

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

sizePolicy :: (QWidgetValue this) => (this) {- ^ this -} -> (HoppyP.IO M468.QSizePolicy)
sizePolicy arg'1 =
  withQWidgetPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M468.QSizePolicyConst) =<<
  (sizePolicy' arg'1')

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

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

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

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

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

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

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

window :: (QWidgetValue this) => (this) {- ^ this -} -> (HoppyP.IO QWidget)
window arg'1 =
  withQWidgetPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QWidget
  (window' arg'1')

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

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

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

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

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

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

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

windowState :: (QWidgetValue this) => (this) {- ^ this -} -> (HoppyP.IO M190.QtWindowStates)
windowState arg'1 =
  withQWidgetPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.numToFlags
  ) =<<
  (windowState' arg'1')

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

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

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

class (QWidgetConstPtr this, M94.QObjectPtr this) => QWidgetPtr this where
  toQWidget :: this -> QWidget

activateWindow :: (QWidgetPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
activateWindow arg'1 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  (activateWindow' arg'1')

addAction :: (QWidgetPtr this, M368.QActionPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
addAction arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M368.toQAction arg'2) $ \arg'2' ->
  (addAction' arg'1' arg'2')

adjustSize :: (QWidgetPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
adjustSize arg'1 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  (adjustSize' arg'1')

setBackgroundRole :: (QWidgetPtr this) => (this) {- ^ this -} -> (M98.QPaletteColorRole) -> (HoppyP.IO ())
setBackgroundRole arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setBackgroundRole' arg'1' arg'2')

clearFocus :: (QWidgetPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
clearFocus arg'1 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  (clearFocus' arg'1')

clearMask :: (QWidgetPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
clearMask arg'1 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  (clearMask' arg'1')

close :: (QWidgetPtr this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Bool)
close arg'1 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (close' arg'1')

setContextMenuPolicy :: (QWidgetPtr this) => (this) {- ^ this -} -> (M190.QtContextMenuPolicy) -> (HoppyP.IO ())
setContextMenuPolicy arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setContextMenuPolicy' arg'1' arg'2')

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

setFont :: (QWidgetPtr this, M276.QFontValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setFont arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  M276.withQFontPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setFont' arg'1' arg'2')

grab :: (QWidgetPtr this) => (this) {- ^ this -} -> (HoppyP.IO M316.QPixmap)
grab arg'1 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M316.QPixmapConst) =<<
  (grab' arg'1')

grabWithRect :: (QWidgetPtr this, M122.QRectValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO M316.QPixmap)
grabWithRect arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  M122.withQRectPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . M316.QPixmapConst) =<<
  (grabWithRect' arg'1' arg'2')

grabKeyboard :: (QWidgetPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
grabKeyboard arg'1 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  (grabKeyboard' arg'1')

grabMouse :: (QWidgetPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
grabMouse arg'1 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  (grabMouse' arg'1')

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

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

insertAction :: (QWidgetPtr this, M368.QActionPtr arg'2, M368.QActionPtr arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO ())
insertAction arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M368.toQAction arg'2) $ \arg'2' ->
  HoppyFHR.withCppPtr (M368.toQAction arg'3) $ \arg'3' ->
  (insertAction' arg'1' arg'2' arg'3')

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

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

setPalette :: (QWidgetPtr this, M98.QPaletteValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setPalette arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  M98.withQPalettePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setPalette' arg'1' arg'2')

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

releaseKeyboard :: (QWidgetPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
releaseKeyboard arg'1 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  (releaseKeyboard' arg'1')

releaseMouse :: (QWidgetPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
releaseMouse arg'1 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  (releaseMouse' arg'1')

removeAction :: (QWidgetPtr this, M368.QActionPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
removeAction arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M368.toQAction arg'2) $ \arg'2' ->
  (removeAction' arg'1' arg'2')

renderWithTarget :: (QWidgetPtr this, M304.QPaintDevicePtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
renderWithTarget arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M304.toQPaintDevice arg'2) $ \arg'2' ->
  (renderWithTarget' arg'1' arg'2')

renderWithTargetAndOffset :: (QWidgetPtr this, M304.QPaintDevicePtr arg'2, M114.QPointValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO ())
renderWithTargetAndOffset arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M304.toQPaintDevice arg'2) $ \arg'2' ->
  M114.withQPointPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (renderWithTargetAndOffset' arg'1' arg'2' arg'3')

renderWithTargetAndOffsetAndRegion :: (QWidgetPtr this, M304.QPaintDevicePtr arg'2, M114.QPointValue arg'3, M324.QRegionValue arg'4) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (arg'4) -> (HoppyP.IO ())
renderWithTargetAndOffsetAndRegion arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M304.toQPaintDevice arg'2) $ \arg'2' ->
  M114.withQPointPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  M324.withQRegionPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  (renderWithTargetAndOffsetAndRegion' arg'1' arg'2' arg'3' arg'4')

renderWithPainter :: (QWidgetPtr this, M310.QPainterPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
renderWithPainter arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M310.toQPainter arg'2) $ \arg'2' ->
  (renderWithPainter' arg'1' arg'2')

renderWithPainterAndOffset :: (QWidgetPtr this, M310.QPainterPtr arg'2, M114.QPointValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO ())
renderWithPainterAndOffset arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M310.toQPainter arg'2) $ \arg'2' ->
  M114.withQPointPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (renderWithPainterAndOffset' arg'1' arg'2' arg'3')

renderWithPainterAndOffsetAndRegion :: (QWidgetPtr this, M310.QPainterPtr arg'2, M114.QPointValue arg'3, M324.QRegionValue arg'4) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (arg'4) -> (HoppyP.IO ())
renderWithPainterAndOffsetAndRegion arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M310.toQPainter arg'2) $ \arg'2' ->
  M114.withQPointPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  M324.withQRegionPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  (renderWithPainterAndOffsetAndRegion' arg'1' arg'2' arg'3' arg'4')

repaint :: (QWidgetPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
repaint arg'1 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  (repaint' arg'1')

repaintRaw :: (QWidgetPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO ())
repaintRaw arg'1 arg'2 arg'3 arg'4 arg'5 =
  HoppyFHR.withCppPtr (toQWidget 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' ->
  (repaintRaw' arg'1' arg'2' arg'3' arg'4' arg'5')

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

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

resizeRaw :: (QWidgetPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO ())
resizeRaw arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQWidget 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')

restoreGeometry :: (QWidgetPtr this, M12.QByteArrayValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
restoreGeometry arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  M12.withQByteArrayPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (restoreGeometry' arg'1' arg'2')

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

scrollRect :: (QWidgetPtr this, M122.QRectValue arg'4) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (arg'4) -> (HoppyP.IO ())
scrollRect arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  M122.withQRectPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  (scrollRect' arg'1' arg'2' arg'3' arg'4')

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

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

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

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

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

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

setContentsMargins :: (QWidgetPtr this, M68.QMarginsValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setContentsMargins arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  M68.withQMarginsPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setContentsMargins' arg'1' arg'2')

setContentsMarginsRaw :: (QWidgetPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO ())
setContentsMarginsRaw arg'1 arg'2 arg'3 arg'4 arg'5 =
  HoppyFHR.withCppPtr (toQWidget 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' ->
  (setContentsMarginsRaw' arg'1' arg'2' arg'3' arg'4' arg'5')

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

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

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

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

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

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

setFocus :: (QWidgetPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
setFocus arg'1 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  (setFocus' arg'1')

setFocusProxy :: (QWidgetPtr this, QWidgetPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setFocusProxy arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (toQWidget arg'2) $ \arg'2' ->
  (setFocusProxy' arg'1' arg'2')

setGeometryRaw :: (QWidgetPtr 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 (toQWidget 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')

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

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

setLayout :: (QWidgetPtr this, M432.QLayoutPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setLayout arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M432.toQLayout arg'2) $ \arg'2' ->
  (setLayout' arg'1' arg'2')

setLayoutDirection :: (QWidgetPtr this) => (this) {- ^ this -} -> (M190.QtLayoutDirection) -> (HoppyP.IO ())
setLayoutDirection arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setLayoutDirection' arg'1' arg'2')

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

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

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

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

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

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

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

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

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

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

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

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

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

setSizePolicyRaw :: (QWidgetPtr this) => (this) {- ^ this -} -> (M468.QSizePolicyPolicy) -> (M468.QSizePolicyPolicy) -> (HoppyP.IO ())
setSizePolicyRaw arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (setSizePolicyRaw' arg'1' arg'2' arg'3')

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

setSizePolicy :: (QWidgetPtr this, M468.QSizePolicyValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setSizePolicy arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  M468.withQSizePolicyPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setSizePolicy' arg'1' arg'2')

stackUnder :: (QWidgetPtr this, QWidgetPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
stackUnder arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (toQWidget arg'2) $ \arg'2' ->
  (stackUnder' arg'1' arg'2')

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

unsetLayoutDirection :: (QWidgetPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
unsetLayoutDirection arg'1 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  (unsetLayoutDirection' arg'1')

unsetLocale :: (QWidgetPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
unsetLocale arg'1 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  (unsetLocale' arg'1')

update :: (QWidgetPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
update arg'1 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  (update' arg'1')

updateRaw :: (QWidgetPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO ())
updateRaw arg'1 arg'2 arg'3 arg'4 arg'5 =
  HoppyFHR.withCppPtr (toQWidget 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' ->
  (updateRaw' arg'1' arg'2' arg'3' arg'4' arg'5')

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

updateGeometry :: (QWidgetPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
updateGeometry arg'1 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  (updateGeometry' arg'1')

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

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

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

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

setWindowState :: (QWidgetPtr this, M190.IsQtWindowStates arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setWindowState arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtWindowStates
  ) arg'2 >>= \arg'2' ->
  (setWindowState' arg'1' arg'2')

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

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

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

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

keyboardGrabber :: (HoppyP.IO QWidget)
keyboardGrabber =
  HoppyP.fmap QWidget
  (keyboardGrabber')

mouseGrabber :: (HoppyP.IO QWidget)
mouseGrabber =
  HoppyP.fmap QWidget
  (mouseGrabber')

setTabOrder :: (QWidgetPtr arg'1, QWidgetPtr arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO ())
setTabOrder arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQWidget arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (toQWidget arg'2) $ \arg'2' ->
  (setTabOrder' arg'1' arg'2')

data QWidgetConst =
    QWidgetConst (HoppyF.Ptr QWidgetConst)
  | QWidgetConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QWidgetConst)
  deriving (HoppyP.Show)

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

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

castQWidgetToConst :: QWidget -> QWidgetConst
castQWidgetToConst (QWidget ptr') = QWidgetConst $ HoppyF.castPtr ptr'
castQWidgetToConst (QWidgetGc fptr' ptr') = QWidgetConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QWidgetConstPtr QWidgetConst where
  toQWidgetConst = HoppyP.id

instance M94.QObjectConstPtr QWidgetConst where
  toQObjectConst (QWidgetConst ptr') = M94.QObjectConst $ castQWidgetToQObject ptr'
  toQObjectConst (QWidgetConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQWidgetToQObject ptr'

data QWidget =
    QWidget (HoppyF.Ptr QWidget)
  | QWidgetGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QWidget)
  deriving (HoppyP.Show)

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

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

castQWidgetToNonconst :: QWidgetConst -> QWidget
castQWidgetToNonconst (QWidgetConst ptr') = QWidget $ HoppyF.castPtr ptr'
castQWidgetToNonconst (QWidgetConstGc fptr' ptr') = QWidgetGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QWidgetConstPtr QWidget where
  toQWidgetConst (QWidget ptr') = QWidgetConst $ (HoppyF.castPtr :: HoppyF.Ptr QWidget -> HoppyF.Ptr QWidgetConst) ptr'
  toQWidgetConst (QWidgetGc fptr' ptr') = QWidgetConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QWidget -> HoppyF.Ptr QWidgetConst) ptr'

instance QWidgetPtr QWidget where
  toQWidget = HoppyP.id

instance M94.QObjectConstPtr QWidget where
  toQObjectConst (QWidget ptr') = M94.QObjectConst $ castQWidgetToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QWidget -> HoppyF.Ptr QWidgetConst) ptr'
  toQObjectConst (QWidgetGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQWidgetToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QWidget -> HoppyF.Ptr QWidgetConst) ptr'

instance M94.QObjectPtr QWidget where
  toQObject (QWidget ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQWidgetToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QWidget -> HoppyF.Ptr QWidgetConst) ptr'
  toQObject (QWidgetGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQWidgetToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QWidget -> HoppyF.Ptr QWidgetConst) ptr'

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

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

class QWidgetSuper a where
  downToQWidget :: a -> QWidget

instance QWidgetSuper M94.QObject where
  downToQWidget = castQWidgetToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QWidgetConst $ castQObjectToQWidget ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QWidgetConstGc fptr' $ castQObjectToQWidget ptr'

class QWidgetSuperConst a where
  downToQWidgetConst :: a -> QWidgetConst

instance QWidgetSuperConst M94.QObjectConst where
  downToQWidgetConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QWidgetConst $ castQObjectToQWidget ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QWidgetConstGc fptr' $ castQObjectToQWidget ptr'

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

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