QImage.hs

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

module Graphics.UI.Qtah.Generated.Gui.QImage (
  castQImageToQPaintDevice,
  castQPaintDeviceToQImage,
  QImageValue (..),
  QImageConstPtr (..),
  allGray,
  bitPlaneCount,
  bitsConst,
  byteCount,
  bytesPerLine,
  color,
  colorCount,
  colorTable,
  constScanLine,
  copyRect,
  copyRaw,
  createAlphaMask,
  createHeuristicMask,
  createHeuristicMaskWithClipTight,
  createMaskFromColor,
  createMaskFromColorWithMode,
  depth,
  devicePixelRatio,
  dotsPerMeterX,
  dotsPerMeterY,
  format,
  hasAlphaChannel,
  height,
  isGrayscale,
  isNull,
  mirrored,
  offset,
  pixelAtPoint,
  pixelAtRaw,
  pixelColorAtPoint,
  pixelColorAtRaw,
  pixelIndexAtPoint,
  pixelIndexAtRaw,
  rect,
  rgbSwapped,
  scaled,
  scaledAll,
  scaledWithRaw,
  scaledWithRawAll,
  scaledToHeight,
  scaledToHeightAll,
  scaledToWidth,
  scaledToWidthAll,
  scanLineConst,
  size,
  text,
  textKeys,
  transformedWithTransform,
  transformedWithTransformAll,
  validAtPoint,
  validAtRaw,
  width,
  eQ,
  nE,
  QImagePtr (..),
  bits,
  setColorCount,
  setDevicePixelRatio,
  setDotsPerMeterX,
  setDotsPerMeterY,
  fillWithPixel,
  fillWithColor,
  fillWithGlobalColor,
  invertPixels,
  invertPixelsWithMode,
  load,
  loadFromDataByteArray,
  loadFromDataRaw,
  setOffset,
  save,
  scanLine,
  setColor,
  setColorTable,
  setPixelAtPoint,
  setPixelAtRaw,
  setPixelColorAtPoint,
  setPixelColorAtRaw,
  setText,
  swap,
  aSSIGN,
  newWithDataAndCleanup,
  newWithConstDataAndCleanup,
  newWithDataAndBytesPerLineAndCleanup,
  newWithConstDataAndBytesPerLineAndCleanup,
  newWithFileAndFormat,
  fromDataByteArray,
  fromDataByteArrayWithFormat,
  fromDataRaw,
  fromDataRawWithFormat,
  loadWithFormat,
  loadFromDataByteArrayWithFormat,
  loadFromDataRawWithFormat,
  saveAll,
  trueMatrixWithTransform,
  QImageConst (..),
  castQImageToConst,
  QImage (..),
  castQImageToNonconst,
  new,
  newWithSize,
  newWithSizeRaw,
  newWithData,
  newWithConstData,
  newWithDataAndBytesPerLine,
  newWithConstDataAndBytesPerLine,
  newWithFile,
  newCopy,
  QImageSuper (..),
  QImageSuperConst (..),
  QImageFormat (..),
  QImageInvertMode (..),
  ) where

import Control.Monad ((>=>))
import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
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.Generated.Core.QByteArray as M12
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.QStringList as M144
import qualified Graphics.UI.Qtah.Generated.Core.QVector.QRgb as M222
import qualified Graphics.UI.Qtah.Generated.Core.Types as M190
import qualified Graphics.UI.Qtah.Generated.Gui.QColor as M252
import qualified Graphics.UI.Qtah.Generated.Gui.QPaintDevice as M304
import qualified Graphics.UI.Qtah.Generated.Gui.QTransform as M336
import qualified Graphics.UI.Qtah.Gui.HColor as HColor
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Internal.Callback as M348
import Prelude (($), (.), (/=), (=<<), (==), (>>), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QImage_new" new' ::  HoppyP.IO (HoppyF.Ptr QImage)
foreign import ccall "genpop__QImage_newWithSize" newWithSize' ::  HoppyF.Ptr M134.QSizeConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QImage)
foreign import ccall "genpop__QImage_newWithSizeRaw" newWithSizeRaw' ::  HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QImage)
foreign import ccall "genpop__QImage_newWithData" newWithData' ::  HoppyF.Ptr HoppyFC.CUChar -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QImage)
foreign import ccall "genpop__QImage_newWithConstData" newWithConstData' ::  HoppyF.Ptr HoppyFC.CUChar -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QImage)
foreign import ccall "genpop__QImage_newWithDataAndBytesPerLine" newWithDataAndBytesPerLine' ::  HoppyF.Ptr HoppyFC.CUChar -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QImage)
foreign import ccall "genpop__QImage_newWithConstDataAndBytesPerLine" newWithConstDataAndBytesPerLine' ::  HoppyF.Ptr HoppyFC.CUChar -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QImage)
foreign import ccall "genpop__QImage_newWithFile" newWithFile' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QImage)
foreign import ccall "genpop__QImage_newCopy" newCopy' ::  HoppyF.Ptr QImageConst -> HoppyP.IO (HoppyF.Ptr QImage)
foreign import ccall "genpop__QImage_newWithDataAndCleanup" newWithDataAndCleanup' ::  HoppyF.Ptr HoppyFC.CUChar -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFHR.CCallback (HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr QImage)
foreign import ccall "genpop__QImage_newWithConstDataAndCleanup" newWithConstDataAndCleanup' ::  HoppyF.Ptr HoppyFC.CUChar -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFHR.CCallback (HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr QImage)
foreign import ccall "genpop__QImage_newWithDataAndBytesPerLineAndCleanup" newWithDataAndBytesPerLineAndCleanup' ::  HoppyF.Ptr HoppyFC.CUChar -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFHR.CCallback (HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr QImage)
foreign import ccall "genpop__QImage_newWithConstDataAndBytesPerLineAndCleanup" newWithConstDataAndBytesPerLineAndCleanup' ::  HoppyF.Ptr HoppyFC.CUChar -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFHR.CCallback (HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr QImage)
foreign import ccall "genpop__QImage_newWithFileAndFormat" newWithFileAndFormat' ::  HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QImage)
foreign import ccall "genpop__QImage_allGray" allGray' ::  HoppyF.Ptr QImageConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QImage_bitPlaneCount" bitPlaneCount' ::  HoppyF.Ptr QImageConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QImage_bits" bits' ::  HoppyF.Ptr QImage -> HoppyP.IO (HoppyF.Ptr HoppyFC.CUChar)
foreign import ccall "genpop__QImage_bitsConst" bitsConst' ::  HoppyF.Ptr QImageConst -> HoppyP.IO (HoppyF.Ptr HoppyFC.CUChar)
foreign import ccall "genpop__QImage_byteCount" byteCount' ::  HoppyF.Ptr QImageConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QImage_bytesPerLine" bytesPerLine' ::  HoppyF.Ptr QImageConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QImage_color" color' ::  HoppyF.Ptr QImageConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CUInt
foreign import ccall "genpop__QImage_colorCount" colorCount' ::  HoppyF.Ptr QImageConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QImage_setColorCount" setColorCount' ::  HoppyF.Ptr QImage -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QImage_colorTable" colorTable' ::  HoppyF.Ptr QImageConst -> HoppyP.IO (HoppyF.Ptr M222.QVectorQRgb)
foreign import ccall "genpop__QImage_constScanLine" constScanLine' ::  HoppyF.Ptr QImageConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr HoppyFC.CUChar)
foreign import ccall "genpop__QImage_copyRect" copyRect' ::  HoppyF.Ptr QImageConst -> HoppyF.Ptr M122.QRectConst -> HoppyP.IO (HoppyF.Ptr QImageConst)
foreign import ccall "genpop__QImage_copyRaw" copyRaw' ::  HoppyF.Ptr QImageConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QImageConst)
foreign import ccall "genpop__QImage_createAlphaMask" createAlphaMask' ::  HoppyF.Ptr QImageConst -> HoppyP.IO (HoppyF.Ptr QImageConst)
foreign import ccall "genpop__QImage_createHeuristicMask" createHeuristicMask' ::  HoppyF.Ptr QImageConst -> HoppyP.IO (HoppyF.Ptr QImageConst)
foreign import ccall "genpop__QImage_createHeuristicMaskWithClipTight" createHeuristicMaskWithClipTight' ::  HoppyF.Ptr QImageConst -> HoppyFC.CBool -> HoppyP.IO (HoppyF.Ptr QImageConst)
foreign import ccall "genpop__QImage_createMaskFromColor" createMaskFromColor' ::  HoppyF.Ptr QImageConst -> HoppyFC.CUInt -> HoppyP.IO (HoppyF.Ptr QImageConst)
foreign import ccall "genpop__QImage_createMaskFromColorWithMode" createMaskFromColorWithMode' ::  HoppyF.Ptr QImageConst -> HoppyFC.CUInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QImageConst)
foreign import ccall "genpop__QImage_depth" depth' ::  HoppyF.Ptr QImageConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QImage_devicePixelRatio" devicePixelRatio' ::  HoppyF.Ptr QImageConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QImage_setDevicePixelRatio" setDevicePixelRatio' ::  HoppyF.Ptr QImage -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QImage_dotsPerMeterX" dotsPerMeterX' ::  HoppyF.Ptr QImageConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QImage_setDotsPerMeterX" setDotsPerMeterX' ::  HoppyF.Ptr QImage -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QImage_dotsPerMeterY" dotsPerMeterY' ::  HoppyF.Ptr QImageConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QImage_setDotsPerMeterY" setDotsPerMeterY' ::  HoppyF.Ptr QImage -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QImage_fillWithPixel" fillWithPixel' ::  HoppyF.Ptr QImage -> HoppyFC.CUInt -> HoppyP.IO ()
foreign import ccall "genpop__QImage_fillWithColor" fillWithColor' ::  HoppyF.Ptr QImage -> HoppyF.Ptr M252.QColorConst -> HoppyP.IO ()
foreign import ccall "genpop__QImage_fillWithGlobalColor" fillWithGlobalColor' ::  HoppyF.Ptr QImage -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QImage_format" format' ::  HoppyF.Ptr QImageConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QImage_fromDataByteArray" fromDataByteArray' ::  HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO (HoppyF.Ptr QImage)
foreign import ccall "genpop__QImage_fromDataByteArrayWithFormat" fromDataByteArrayWithFormat' ::  HoppyF.Ptr M12.QByteArrayConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QImage)
foreign import ccall "genpop__QImage_fromDataRaw" fromDataRaw' ::  HoppyF.Ptr HoppyFC.CUChar -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QImage)
foreign import ccall "genpop__QImage_fromDataRawWithFormat" fromDataRawWithFormat' ::  HoppyF.Ptr HoppyFC.CUChar -> HoppyFC.CInt -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QImage)
foreign import ccall "genpop__QImage_hasAlphaChannel" hasAlphaChannel' ::  HoppyF.Ptr QImageConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QImage_height" height' ::  HoppyF.Ptr QImageConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QImage_invertPixels" invertPixels' ::  HoppyF.Ptr QImage -> HoppyP.IO ()
foreign import ccall "genpop__QImage_invertPixelsWithMode" invertPixelsWithMode' ::  HoppyF.Ptr QImage -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QImage_isGrayscale" isGrayscale' ::  HoppyF.Ptr QImageConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QImage_isNull" isNull' ::  HoppyF.Ptr QImageConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QImage_load" load' ::  HoppyF.Ptr QImage -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QImage_loadWithFormat" loadWithFormat' ::  HoppyF.Ptr QImage -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QImage_loadFromDataByteArray" loadFromDataByteArray' ::  HoppyF.Ptr QImage -> HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QImage_loadFromDataByteArrayWithFormat" loadFromDataByteArrayWithFormat' ::  HoppyF.Ptr QImage -> HoppyF.Ptr M12.QByteArrayConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QImage_loadFromDataRaw" loadFromDataRaw' ::  HoppyF.Ptr QImage -> HoppyF.Ptr HoppyFC.CUChar -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QImage_loadFromDataRawWithFormat" loadFromDataRawWithFormat' ::  HoppyF.Ptr QImage -> HoppyF.Ptr HoppyFC.CUChar -> HoppyFC.CInt -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QImage_mirrored" mirrored' ::  HoppyF.Ptr QImageConst -> HoppyFC.CBool -> HoppyFC.CBool -> HoppyP.IO (HoppyF.Ptr QImageConst)
foreign import ccall "genpop__QImage_offset" offset' ::  HoppyF.Ptr QImageConst -> HoppyP.IO (HoppyF.Ptr M114.QPointConst)
foreign import ccall "genpop__QImage_setOffset" setOffset' ::  HoppyF.Ptr QImage -> HoppyF.Ptr M114.QPointConst -> HoppyP.IO ()
foreign import ccall "genpop__QImage_pixelAtPoint" pixelAtPoint' ::  HoppyF.Ptr QImageConst -> HoppyF.Ptr M114.QPointConst -> HoppyP.IO HoppyFC.CUInt
foreign import ccall "genpop__QImage_pixelAtRaw" pixelAtRaw' ::  HoppyF.Ptr QImageConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CUInt
foreign import ccall "genpop__QImage_pixelColorAtPoint" pixelColorAtPoint' ::  HoppyF.Ptr QImageConst -> HoppyF.Ptr M114.QPointConst -> HoppyP.IO (HoppyF.Ptr M252.QColorConst)
foreign import ccall "genpop__QImage_pixelColorAtRaw" pixelColorAtRaw' ::  HoppyF.Ptr QImageConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M252.QColorConst)
foreign import ccall "genpop__QImage_pixelIndexAtPoint" pixelIndexAtPoint' ::  HoppyF.Ptr QImageConst -> HoppyF.Ptr M114.QPointConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QImage_pixelIndexAtRaw" pixelIndexAtRaw' ::  HoppyF.Ptr QImageConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QImage_rect" rect' ::  HoppyF.Ptr QImageConst -> HoppyP.IO (HoppyF.Ptr M122.QRectConst)
foreign import ccall "genpop__QImage_rgbSwapped" rgbSwapped' ::  HoppyF.Ptr QImageConst -> HoppyP.IO (HoppyF.Ptr QImageConst)
foreign import ccall "genpop__QImage_save" save' ::  HoppyF.Ptr QImage -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QImage_saveAll" saveAll' ::  HoppyF.Ptr QImage -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QImage_scaled" scaled' ::  HoppyF.Ptr QImageConst -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO (HoppyF.Ptr QImageConst)
foreign import ccall "genpop__QImage_scaledAll" scaledAll' ::  HoppyF.Ptr QImageConst -> HoppyF.Ptr M134.QSizeConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QImageConst)
foreign import ccall "genpop__QImage_scaledWithRaw" scaledWithRaw' ::  HoppyF.Ptr QImageConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QImageConst)
foreign import ccall "genpop__QImage_scaledWithRawAll" scaledWithRawAll' ::  HoppyF.Ptr QImageConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QImageConst)
foreign import ccall "genpop__QImage_scaledToHeight" scaledToHeight' ::  HoppyF.Ptr QImageConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QImageConst)
foreign import ccall "genpop__QImage_scaledToHeightAll" scaledToHeightAll' ::  HoppyF.Ptr QImageConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QImageConst)
foreign import ccall "genpop__QImage_scaledToWidth" scaledToWidth' ::  HoppyF.Ptr QImageConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QImageConst)
foreign import ccall "genpop__QImage_scaledToWidthAll" scaledToWidthAll' ::  HoppyF.Ptr QImageConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QImageConst)
foreign import ccall "genpop__QImage_scanLine" scanLine' ::  HoppyF.Ptr QImage -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr HoppyFC.CUChar)
foreign import ccall "genpop__QImage_scanLineConst" scanLineConst' ::  HoppyF.Ptr QImageConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr HoppyFC.CUChar)
foreign import ccall "genpop__QImage_setColor" setColor' ::  HoppyF.Ptr QImage -> HoppyFC.CInt -> HoppyFC.CUInt -> HoppyP.IO ()
foreign import ccall "genpop__QImage_setColorTable" setColorTable' ::  HoppyF.Ptr QImage -> HoppyF.Ptr M222.QVectorQRgbConst -> HoppyP.IO ()
foreign import ccall "genpop__QImage_setPixelAtPoint" setPixelAtPoint' ::  HoppyF.Ptr QImage -> HoppyF.Ptr M114.QPointConst -> HoppyFC.CUInt -> HoppyP.IO ()
foreign import ccall "genpop__QImage_setPixelAtRaw" setPixelAtRaw' ::  HoppyF.Ptr QImage -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CUInt -> HoppyP.IO ()
foreign import ccall "genpop__QImage_setPixelColorAtPoint" setPixelColorAtPoint' ::  HoppyF.Ptr QImage -> HoppyF.Ptr M114.QPointConst -> HoppyF.Ptr M252.QColorConst -> HoppyP.IO ()
foreign import ccall "genpop__QImage_setPixelColorAtRaw" setPixelColorAtRaw' ::  HoppyF.Ptr QImage -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr M252.QColorConst -> HoppyP.IO ()
foreign import ccall "genpop__QImage_setText" setText' ::  HoppyF.Ptr QImage -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QImage_size" size' ::  HoppyF.Ptr QImageConst -> HoppyP.IO (HoppyF.Ptr M134.QSizeConst)
foreign import ccall "genpop__QImage_swap" swap' ::  HoppyF.Ptr QImage -> HoppyF.Ptr QImage -> HoppyP.IO ()
foreign import ccall "genpop__QImage_text" text' ::  HoppyF.Ptr QImageConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QImage_textKeys" textKeys' ::  HoppyF.Ptr QImageConst -> HoppyP.IO (HoppyF.Ptr M144.QStringListConst)
foreign import ccall "genpop__QImage_transformedWithTransform" transformedWithTransform' ::  HoppyF.Ptr QImageConst -> HoppyF.Ptr M336.QTransformConst -> HoppyP.IO (HoppyF.Ptr QImageConst)
foreign import ccall "genpop__QImage_transformedWithTransformAll" transformedWithTransformAll' ::  HoppyF.Ptr QImageConst -> HoppyF.Ptr M336.QTransformConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QImageConst)
foreign import ccall "genpop__QImage_trueMatrixWithTransform" trueMatrixWithTransform' ::  HoppyF.Ptr M336.QTransformConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M336.QTransformConst)
foreign import ccall "genpop__QImage_validAtPoint" validAtPoint' ::  HoppyF.Ptr QImageConst -> HoppyF.Ptr M114.QPointConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QImage_validAtRaw" validAtRaw' ::  HoppyF.Ptr QImageConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QImage_width" width' ::  HoppyF.Ptr QImageConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QImage_EQ" eQ' ::  HoppyF.Ptr QImageConst -> HoppyF.Ptr QImageConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QImage_NE" nE' ::  HoppyF.Ptr QImageConst -> HoppyF.Ptr QImageConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QImage_ASSIGN" aSSIGN' ::  HoppyF.Ptr QImage -> HoppyF.Ptr QImageConst -> HoppyP.IO (HoppyF.Ptr QImage)
foreign import ccall "gencast__QImage__QPaintDevice" castQImageToQPaintDevice :: HoppyF.Ptr QImageConst -> HoppyF.Ptr M304.QPaintDeviceConst
foreign import ccall "gencast__QPaintDevice__QImage" castQPaintDeviceToQImage :: HoppyF.Ptr M304.QPaintDeviceConst -> HoppyF.Ptr QImageConst
foreign import ccall "gendel__QImage" delete'QImage :: HoppyF.Ptr QImageConst -> HoppyP.IO ()
foreign import ccall "&gendel__QImage" deletePtr'QImage :: HoppyF.FunPtr (HoppyF.Ptr QImageConst -> HoppyP.IO ())

class QImageValue a where
  withQImagePtr :: a -> (QImageConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QImageConstPtr a => QImageValue a where
  withQImagePtr = HoppyP.flip ($) . toQImageConst

class (M304.QPaintDeviceConstPtr this) => QImageConstPtr this where
  toQImageConst :: this -> QImageConst

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

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

bitsConst :: (QImageValue this) => (this) {- ^ this -} -> (HoppyP.IO (HoppyF.Ptr HoppyFC.CUChar))
bitsConst arg'1 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (bitsConst' arg'1')

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

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

color :: (QImageValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO HoppyFC.CUInt)
color arg'1 arg'2 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (color' arg'1' arg'2')

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

colorTable :: (QImageValue this) => (this) {- ^ this -} -> (HoppyP.IO M222.QVectorQRgb)
colorTable arg'1 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.toGc =<<
  HoppyP.fmap M222.QVectorQRgb
  (colorTable' arg'1')

constScanLine :: (QImageValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO (HoppyF.Ptr HoppyFC.CUChar))
constScanLine arg'1 arg'2 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (constScanLine' arg'1' arg'2')

copyRect :: (QImageValue this, M122.QRectValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QImage)
copyRect arg'1 arg'2 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M122.withQRectPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . QImageConst) =<<
  (copyRect' arg'1' arg'2')

copyRaw :: (QImageValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO QImage)
copyRaw arg'1 arg'2 arg'3 arg'4 arg'5 =
  withQImagePtr 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.return . HoppyFHR.coerceIntegral
  ) arg'4 >>= \arg'4' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'5 >>= \arg'5' ->
  (HoppyFHR.decodeAndDelete . QImageConst) =<<
  (copyRaw' arg'1' arg'2' arg'3' arg'4' arg'5')

createAlphaMask :: (QImageValue this) => (this) {- ^ this -} -> (HoppyP.IO QImage)
createAlphaMask arg'1 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . QImageConst) =<<
  (createAlphaMask' arg'1')

createHeuristicMask :: (QImageValue this) => (this) {- ^ this -} -> (HoppyP.IO QImage)
createHeuristicMask arg'1 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . QImageConst) =<<
  (createHeuristicMask' arg'1')

createHeuristicMaskWithClipTight :: (QImageValue this) => (this) {- ^ this -} -> (HoppyP.Bool) -> (HoppyP.IO QImage)
createHeuristicMaskWithClipTight arg'1 arg'2 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    \x -> HoppyP.return $ if x then 1 else 0
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . QImageConst) =<<
  (createHeuristicMaskWithClipTight' arg'1' arg'2')

createMaskFromColor :: (QImageValue this) => (this) {- ^ this -} -> (HoppyFC.CUInt) -> (HoppyP.IO QImage)
createMaskFromColor arg'1 arg'2 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (HoppyFHR.decodeAndDelete . QImageConst) =<<
  (createMaskFromColor' arg'1' arg'2')

createMaskFromColorWithMode :: (QImageValue this) => (this) {- ^ this -} -> (HoppyFC.CUInt) -> (M190.QtMaskMode) -> (HoppyP.IO QImage)
createMaskFromColorWithMode arg'1 arg'2 arg'3 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . QImageConst) =<<
  (createMaskFromColorWithMode' arg'1' arg'2' arg'3')

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

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

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

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

format :: (QImageValue this) => (this) {- ^ this -} -> (HoppyP.IO QImageFormat)
format arg'1 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (format' arg'1')

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

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

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

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

mirrored :: (QImageValue this) => (this) {- ^ this -} -> (HoppyP.Bool) -> (HoppyP.Bool) -> (HoppyP.IO QImage)
mirrored arg'1 arg'2 arg'3 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    \x -> HoppyP.return $ if x then 1 else 0
  ) arg'2 >>= \arg'2' ->
  (
    \x -> HoppyP.return $ if x then 1 else 0
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . QImageConst) =<<
  (mirrored' arg'1' arg'2' arg'3')

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

pixelAtPoint :: (QImageValue this, M114.QPointValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyFC.CUInt)
pixelAtPoint arg'1 arg'2 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M114.withQPointPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (pixelAtPoint' arg'1' arg'2')

pixelAtRaw :: (QImageValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO HoppyFC.CUInt)
pixelAtRaw arg'1 arg'2 arg'3 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (pixelAtRaw' arg'1' arg'2' arg'3')

pixelColorAtPoint :: (QImageValue this, M114.QPointValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HColor.HColor)
pixelColorAtPoint arg'1 arg'2 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M114.withQPointPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . M252.QColorConst) =<<
  (pixelColorAtPoint' arg'1' arg'2')

pixelColorAtRaw :: (QImageValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO HColor.HColor)
pixelColorAtRaw arg'1 arg'2 arg'3 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . M252.QColorConst) =<<
  (pixelColorAtRaw' arg'1' arg'2' arg'3')

pixelIndexAtPoint :: (QImageValue this, M114.QPointValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
pixelIndexAtPoint arg'1 arg'2 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M114.withQPointPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (pixelIndexAtPoint' arg'1' arg'2')

pixelIndexAtRaw :: (QImageValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Int)
pixelIndexAtRaw arg'1 arg'2 arg'3 =
  withQImagePtr 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.return . HoppyFHR.coerceIntegral
  ) =<<
  (pixelIndexAtRaw' arg'1' arg'2' arg'3')

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

rgbSwapped :: (QImageValue this) => (this) {- ^ this -} -> (HoppyP.IO QImage)
rgbSwapped arg'1 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . QImageConst) =<<
  (rgbSwapped' arg'1')

scaled :: (QImageValue this, M134.QSizeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QImage)
scaled arg'1 arg'2 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M134.withQSizePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . QImageConst) =<<
  (scaled' arg'1' arg'2')

scaledAll :: (QImageValue this, M134.QSizeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (M190.QtAspectRatioMode) -> (M190.QtTransformationMode) -> (HoppyP.IO QImage)
scaledAll arg'1 arg'2 arg'3 arg'4 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M134.withQSizePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'4 >>= \arg'4' ->
  (HoppyFHR.decodeAndDelete . QImageConst) =<<
  (scaledAll' arg'1' arg'2' arg'3' arg'4')

scaledWithRaw :: (QImageValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO QImage)
scaledWithRaw arg'1 arg'2 arg'3 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . QImageConst) =<<
  (scaledWithRaw' arg'1' arg'2' arg'3')

scaledWithRawAll :: (QImageValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (M190.QtAspectRatioMode) -> (M190.QtTransformationMode) -> (HoppyP.IO QImage)
scaledWithRawAll arg'1 arg'2 arg'3 arg'4 arg'5 =
  withQImagePtr 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.return . HoppyFHR.fromCppEnum
  ) arg'4 >>= \arg'4' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'5 >>= \arg'5' ->
  (HoppyFHR.decodeAndDelete . QImageConst) =<<
  (scaledWithRawAll' arg'1' arg'2' arg'3' arg'4' arg'5')

scaledToHeight :: (QImageValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO QImage)
scaledToHeight arg'1 arg'2 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . QImageConst) =<<
  (scaledToHeight' arg'1' arg'2')

scaledToHeightAll :: (QImageValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (M190.QtTransformationMode) -> (HoppyP.IO QImage)
scaledToHeightAll arg'1 arg'2 arg'3 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . QImageConst) =<<
  (scaledToHeightAll' arg'1' arg'2' arg'3')

scaledToWidth :: (QImageValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO QImage)
scaledToWidth arg'1 arg'2 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . QImageConst) =<<
  (scaledToWidth' arg'1' arg'2')

scaledToWidthAll :: (QImageValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (M190.QtTransformationMode) -> (HoppyP.IO QImage)
scaledToWidthAll arg'1 arg'2 arg'3 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . QImageConst) =<<
  (scaledToWidthAll' arg'1' arg'2' arg'3')

scanLineConst :: (QImageValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO (HoppyF.Ptr HoppyFC.CUChar))
scanLineConst arg'1 arg'2 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (scanLineConst' arg'1' arg'2')

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

text :: (QImageValue this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QtahP.String)
text arg'1 arg'2 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (text' arg'1' arg'2')

textKeys :: (QImageValue this) => (this) {- ^ this -} -> (HoppyP.IO [QtahP.String])
textKeys arg'1 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M144.QStringListConst) =<<
  (textKeys' arg'1')

transformedWithTransform :: (QImageValue this, M336.QTransformValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QImage)
transformedWithTransform arg'1 arg'2 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M336.withQTransformPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . QImageConst) =<<
  (transformedWithTransform' arg'1' arg'2')

transformedWithTransformAll :: (QImageValue this, M336.QTransformValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (M190.QtTransformationMode) -> (HoppyP.IO QImage)
transformedWithTransformAll arg'1 arg'2 arg'3 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M336.withQTransformPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . QImageConst) =<<
  (transformedWithTransformAll' arg'1' arg'2' arg'3')

validAtPoint :: (QImageValue this, M114.QPointValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
validAtPoint arg'1 arg'2 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M114.withQPointPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (validAtPoint' arg'1' arg'2')

validAtRaw :: (QImageValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Bool)
validAtRaw arg'1 arg'2 arg'3 =
  withQImagePtr 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.return . (/= 0))
  ) =<<
  (validAtRaw' arg'1' arg'2' arg'3')

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

eQ :: (QImageValue this, QImageValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
eQ arg'1 arg'2 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQImagePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (eQ' arg'1' arg'2')

nE :: (QImageValue this, QImageValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
nE arg'1 arg'2 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQImagePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (nE' arg'1' arg'2')

class (QImageConstPtr this, M304.QPaintDevicePtr this) => QImagePtr this where
  toQImage :: this -> QImage

bits :: (QImagePtr this) => (this) {- ^ this -} -> (HoppyP.IO (HoppyF.Ptr HoppyFC.CUChar))
bits arg'1 =
  HoppyFHR.withCppPtr (toQImage arg'1) $ \arg'1' ->
  (bits' arg'1')

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

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

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

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

fillWithPixel :: (QImagePtr this) => (this) {- ^ this -} -> (HoppyFC.CUInt) -> (HoppyP.IO ())
fillWithPixel arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQImage arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (fillWithPixel' arg'1' arg'2')

fillWithColor :: (QImagePtr this, M252.QColorValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
fillWithColor arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQImage arg'1) $ \arg'1' ->
  M252.withQColorPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (fillWithColor' arg'1' arg'2')

fillWithGlobalColor :: (QImagePtr this) => (this) {- ^ this -} -> (M190.QtGlobalColor) -> (HoppyP.IO ())
fillWithGlobalColor arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQImage arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (fillWithGlobalColor' arg'1' arg'2')

invertPixels :: (QImagePtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
invertPixels arg'1 =
  HoppyFHR.withCppPtr (toQImage arg'1) $ \arg'1' ->
  (invertPixels' arg'1')

invertPixelsWithMode :: (QImagePtr this) => (this) {- ^ this -} -> (QImageInvertMode) -> (HoppyP.IO ())
invertPixelsWithMode arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQImage arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (invertPixelsWithMode' arg'1' arg'2')

load :: (QImagePtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
load arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQImage arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (load' arg'1' arg'2')

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

loadFromDataRaw :: (QImagePtr this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CUChar) -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Bool)
loadFromDataRaw arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQImage arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (loadFromDataRaw' arg'1' arg'2' arg'3')

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

save :: (QImagePtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
save arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQImage arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (save' arg'1' arg'2')

scanLine :: (QImagePtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO (HoppyF.Ptr HoppyFC.CUChar))
scanLine arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQImage arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (scanLine' arg'1' arg'2')

setColor :: (QImagePtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyFC.CUInt) -> (HoppyP.IO ())
setColor arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQImage arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  let arg'3' = arg'3 in
  (setColor' arg'1' arg'2' arg'3')

setColorTable :: (QImagePtr this, M222.QVectorQRgbValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setColorTable arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQImage arg'1) $ \arg'1' ->
  M222.withQVectorQRgbPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setColorTable' arg'1' arg'2')

setPixelAtPoint :: (QImagePtr this, M114.QPointValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyFC.CUInt) -> (HoppyP.IO ())
setPixelAtPoint arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQImage arg'1) $ \arg'1' ->
  M114.withQPointPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  let arg'3' = arg'3 in
  (setPixelAtPoint' arg'1' arg'2' arg'3')

setPixelAtRaw :: (QImagePtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyFC.CUInt) -> (HoppyP.IO ())
setPixelAtRaw arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQImage arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  let arg'4' = arg'4 in
  (setPixelAtRaw' arg'1' arg'2' arg'3' arg'4')

setPixelColorAtPoint :: (QImagePtr this, M114.QPointValue arg'2, M252.QColorValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO ())
setPixelColorAtPoint arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQImage arg'1) $ \arg'1' ->
  M114.withQPointPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M252.withQColorPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (setPixelColorAtPoint' arg'1' arg'2' arg'3')

setPixelColorAtRaw :: (QImagePtr this, M252.QColorValue arg'4) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (arg'4) -> (HoppyP.IO ())
setPixelColorAtRaw arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQImage arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  M252.withQColorPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  (setPixelColorAtRaw' arg'1' arg'2' arg'3' arg'4')

setText :: (QImagePtr this, M142.QStringValue arg'2, M142.QStringValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO ())
setText arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQImage arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (setText' arg'1' arg'2' arg'3')

swap :: (QImagePtr this, QImagePtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
swap arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQImage arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (toQImage arg'2) $ \arg'2' ->
  (swap' arg'1' arg'2')

aSSIGN :: (QImagePtr this, QImageValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QImage)
aSSIGN arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQImage arg'1) $ \arg'1' ->
  withQImagePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QImage
  (aSSIGN' arg'1' arg'2')

newWithDataAndCleanup :: (HoppyF.Ptr HoppyFC.CUChar) -> (HoppyP.Int) -> (HoppyP.Int) -> (QImageFormat) -> (HoppyP.IO ()) -> (HoppyP.IO QImage)
newWithDataAndCleanup arg'1 arg'2 arg'3 arg'4 arg'5 =
  let arg'1' = arg'1 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'4 >>= \arg'4' ->
  (
    M348.callbackVoid_new
  ) arg'5 >>= \arg'5' ->
  HoppyP.fmap QImage
  (newWithDataAndCleanup' arg'1' arg'2' arg'3' arg'4' arg'5')

newWithConstDataAndCleanup :: (HoppyF.Ptr HoppyFC.CUChar) -> (HoppyP.Int) -> (HoppyP.Int) -> (QImageFormat) -> (HoppyP.IO ()) -> (HoppyP.IO QImage)
newWithConstDataAndCleanup arg'1 arg'2 arg'3 arg'4 arg'5 =
  let arg'1' = arg'1 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'4 >>= \arg'4' ->
  (
    M348.callbackVoid_new
  ) arg'5 >>= \arg'5' ->
  HoppyP.fmap QImage
  (newWithConstDataAndCleanup' arg'1' arg'2' arg'3' arg'4' arg'5')

newWithDataAndBytesPerLineAndCleanup :: (HoppyF.Ptr HoppyFC.CUChar) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.Int) -> (QImageFormat) -> (HoppyP.IO ()) -> (HoppyP.IO QImage)
newWithDataAndBytesPerLineAndCleanup arg'1 arg'2 arg'3 arg'4 arg'5 arg'6 =
  let arg'1' = arg'1 in
  (
    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.fromCppEnum
  ) arg'5 >>= \arg'5' ->
  (
    M348.callbackVoid_new
  ) arg'6 >>= \arg'6' ->
  HoppyP.fmap QImage
  (newWithDataAndBytesPerLineAndCleanup' arg'1' arg'2' arg'3' arg'4' arg'5' arg'6')

newWithConstDataAndBytesPerLineAndCleanup :: (HoppyF.Ptr HoppyFC.CUChar) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.Int) -> (QImageFormat) -> (HoppyP.IO ()) -> (HoppyP.IO QImage)
newWithConstDataAndBytesPerLineAndCleanup arg'1 arg'2 arg'3 arg'4 arg'5 arg'6 =
  let arg'1' = arg'1 in
  (
    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.fromCppEnum
  ) arg'5 >>= \arg'5' ->
  (
    M348.callbackVoid_new
  ) arg'6 >>= \arg'6' ->
  HoppyP.fmap QImage
  (newWithConstDataAndBytesPerLineAndCleanup' arg'1' arg'2' arg'3' arg'4' arg'5' arg'6')

newWithFileAndFormat :: (M142.QStringValue arg'1, M142.QStringValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO QImage)
newWithFileAndFormat arg'1 arg'2 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QImage
  (newWithFileAndFormat' arg'1' arg'2')

fromDataByteArray :: (M12.QByteArrayValue arg'1) => (arg'1) -> (HoppyP.IO QImage)
fromDataByteArray arg'1 =
  M12.withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QImage
  (fromDataByteArray' arg'1')

fromDataByteArrayWithFormat :: (M12.QByteArrayValue arg'1, M142.QStringValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO QImage)
fromDataByteArrayWithFormat arg'1 arg'2 =
  M12.withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QImage
  (fromDataByteArrayWithFormat' arg'1' arg'2')

fromDataRaw :: (HoppyF.Ptr HoppyFC.CUChar) -> (HoppyP.Int) -> (HoppyP.IO QImage)
fromDataRaw arg'1 arg'2 =
  let arg'1' = arg'1 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap QImage
  (fromDataRaw' arg'1' arg'2')

fromDataRawWithFormat :: (M142.QStringValue arg'3) => (HoppyF.Ptr HoppyFC.CUChar) -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO QImage)
fromDataRawWithFormat arg'1 arg'2 arg'3 =
  let arg'1' = arg'1 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  HoppyP.fmap QImage
  (fromDataRawWithFormat' arg'1' arg'2' arg'3')

loadWithFormat :: (QImagePtr arg'1, M142.QStringValue arg'2, M142.QStringValue arg'3) => (arg'1) -> (arg'2) -> (arg'3) -> (HoppyP.IO HoppyP.Bool)
loadWithFormat arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQImage arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (loadWithFormat' arg'1' arg'2' arg'3')

loadFromDataByteArrayWithFormat :: (QImagePtr arg'1, M12.QByteArrayValue arg'2, M142.QStringValue arg'3) => (arg'1) -> (arg'2) -> (arg'3) -> (HoppyP.IO HoppyP.Bool)
loadFromDataByteArrayWithFormat arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQImage arg'1) $ \arg'1' ->
  M12.withQByteArrayPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (loadFromDataByteArrayWithFormat' arg'1' arg'2' arg'3')

loadFromDataRawWithFormat :: (QImagePtr arg'1, M142.QStringValue arg'4) => (arg'1) -> (HoppyF.Ptr HoppyFC.CUChar) -> (HoppyP.Int) -> (arg'4) -> (HoppyP.IO HoppyP.Bool)
loadFromDataRawWithFormat arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQImage arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  M142.withQStringPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (loadFromDataRawWithFormat' arg'1' arg'2' arg'3' arg'4')

saveAll :: (QImagePtr arg'1, M142.QStringValue arg'2, M142.QStringValue arg'3) => (arg'1) -> (arg'2) -> (arg'3) -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Bool)
saveAll arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQImage arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'4 >>= \arg'4' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (saveAll' arg'1' arg'2' arg'3' arg'4')

trueMatrixWithTransform :: (M336.QTransformValue arg'1) => (arg'1) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO M336.QTransform)
trueMatrixWithTransform arg'1 arg'2 arg'3 =
  M336.withQTransformPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . M336.QTransformConst) =<<
  (trueMatrixWithTransform' arg'1' arg'2' arg'3')

data QImageConst =
    QImageConst (HoppyF.Ptr QImageConst)
  | QImageConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QImageConst)
  deriving (HoppyP.Show)

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

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

castQImageToConst :: QImage -> QImageConst
castQImageToConst (QImage ptr') = QImageConst $ HoppyF.castPtr ptr'
castQImageToConst (QImageGc fptr' ptr') = QImageConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QImageConst QImage where copy = newCopy

instance QImageConstPtr QImageConst where
  toQImageConst = HoppyP.id

instance M304.QPaintDeviceConstPtr QImageConst where
  toQPaintDeviceConst (QImageConst ptr') = M304.QPaintDeviceConst $ castQImageToQPaintDevice ptr'
  toQPaintDeviceConst (QImageConstGc fptr' ptr') = M304.QPaintDeviceConstGc fptr' $ castQImageToQPaintDevice ptr'

data QImage =
    QImage (HoppyF.Ptr QImage)
  | QImageGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QImage)
  deriving (HoppyP.Show)

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

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

castQImageToNonconst :: QImageConst -> QImage
castQImageToNonconst (QImageConst ptr') = QImage $ HoppyF.castPtr ptr'
castQImageToNonconst (QImageConstGc fptr' ptr') = QImageGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QImage QImage where copy = newCopy

instance QImageConstPtr QImage where
  toQImageConst (QImage ptr') = QImageConst $ (HoppyF.castPtr :: HoppyF.Ptr QImage -> HoppyF.Ptr QImageConst) ptr'
  toQImageConst (QImageGc fptr' ptr') = QImageConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QImage -> HoppyF.Ptr QImageConst) ptr'

instance QImagePtr QImage where
  toQImage = HoppyP.id

instance M304.QPaintDeviceConstPtr QImage where
  toQPaintDeviceConst (QImage ptr') = M304.QPaintDeviceConst $ castQImageToQPaintDevice $ (HoppyF.castPtr :: HoppyF.Ptr QImage -> HoppyF.Ptr QImageConst) ptr'
  toQPaintDeviceConst (QImageGc fptr' ptr') = M304.QPaintDeviceConstGc fptr' $ castQImageToQPaintDevice $ (HoppyF.castPtr :: HoppyF.Ptr QImage -> HoppyF.Ptr QImageConst) ptr'

instance M304.QPaintDevicePtr QImage where
  toQPaintDevice (QImage ptr') = M304.QPaintDevice $ (HoppyF.castPtr :: HoppyF.Ptr M304.QPaintDeviceConst -> HoppyF.Ptr M304.QPaintDevice) $ castQImageToQPaintDevice $ (HoppyF.castPtr :: HoppyF.Ptr QImage -> HoppyF.Ptr QImageConst) ptr'
  toQPaintDevice (QImageGc fptr' ptr') = M304.QPaintDeviceGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M304.QPaintDeviceConst -> HoppyF.Ptr M304.QPaintDevice) $ castQImageToQPaintDevice $ (HoppyF.castPtr :: HoppyF.Ptr QImage -> HoppyF.Ptr QImageConst) ptr'

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

newWithSize :: (M134.QSizeValue arg'1) => (arg'1) -> (QImageFormat) -> (HoppyP.IO QImage)
newWithSize arg'1 arg'2 =
  M134.withQSizePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap QImage
  (newWithSize' arg'1' arg'2')

newWithSizeRaw :: (HoppyP.Int) -> (HoppyP.Int) -> (QImageFormat) -> (HoppyP.IO QImage)
newWithSizeRaw arg'1 arg'2 arg'3 =
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'1 >>= \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  HoppyP.fmap QImage
  (newWithSizeRaw' arg'1' arg'2' arg'3')

newWithData :: (HoppyF.Ptr HoppyFC.CUChar) -> (HoppyP.Int) -> (HoppyP.Int) -> (QImageFormat) -> (HoppyP.IO QImage)
newWithData arg'1 arg'2 arg'3 arg'4 =
  let arg'1' = arg'1 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'4 >>= \arg'4' ->
  HoppyP.fmap QImage
  (newWithData' arg'1' arg'2' arg'3' arg'4')

newWithConstData :: (HoppyF.Ptr HoppyFC.CUChar) -> (HoppyP.Int) -> (HoppyP.Int) -> (QImageFormat) -> (HoppyP.IO QImage)
newWithConstData arg'1 arg'2 arg'3 arg'4 =
  let arg'1' = arg'1 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'4 >>= \arg'4' ->
  HoppyP.fmap QImage
  (newWithConstData' arg'1' arg'2' arg'3' arg'4')

newWithDataAndBytesPerLine :: (HoppyF.Ptr HoppyFC.CUChar) -> (HoppyP.Int) -> (HoppyP.Int) -> (QImageFormat) -> (HoppyP.IO QImage)
newWithDataAndBytesPerLine arg'1 arg'2 arg'3 arg'4 =
  let arg'1' = arg'1 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'4 >>= \arg'4' ->
  HoppyP.fmap QImage
  (newWithDataAndBytesPerLine' arg'1' arg'2' arg'3' arg'4')

newWithConstDataAndBytesPerLine :: (HoppyF.Ptr HoppyFC.CUChar) -> (HoppyP.Int) -> (HoppyP.Int) -> (QImageFormat) -> (HoppyP.IO QImage)
newWithConstDataAndBytesPerLine arg'1 arg'2 arg'3 arg'4 =
  let arg'1' = arg'1 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'4 >>= \arg'4' ->
  HoppyP.fmap QImage
  (newWithConstDataAndBytesPerLine' arg'1' arg'2' arg'3' arg'4')

newWithFile :: (M142.QStringValue arg'1) => (arg'1) -> (HoppyP.IO QImage)
newWithFile arg'1 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QImage
  (newWithFile' arg'1')

newCopy :: (QImageValue arg'1) => (arg'1) -> (HoppyP.IO QImage)
newCopy arg'1 =
  withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QImage
  (newCopy' arg'1')

class QImageSuper a where
  downToQImage :: a -> QImage

instance QImageSuper M304.QPaintDevice where
  downToQImage = castQImageToNonconst . cast' . M304.castQPaintDeviceToConst
    where
      cast' (M304.QPaintDeviceConst ptr') = QImageConst $ castQPaintDeviceToQImage ptr'
      cast' (M304.QPaintDeviceConstGc fptr' ptr') = QImageConstGc fptr' $ castQPaintDeviceToQImage ptr'

class QImageSuperConst a where
  downToQImageConst :: a -> QImageConst

instance QImageSuperConst M304.QPaintDeviceConst where
  downToQImageConst = cast'
    where
      cast' (M304.QPaintDeviceConst ptr') = QImageConst $ castQPaintDeviceToQImage ptr'
      cast' (M304.QPaintDeviceConstGc fptr' ptr') = QImageConstGc fptr' $ castQPaintDeviceToQImage ptr'

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

instance QImageValue a => HoppyFHR.Assignable QImage a where
  assign x' y' = aSSIGN x' y' >> HoppyP.return ()

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

instance HoppyFHR.Decodable QImage (QImage) where
  decode = HoppyFHR.decode . toQImageConst

instance HoppyFHR.Decodable QImageConst (QImage) where
  decode =
    HoppyFHR.copy >=> HoppyFHR.toGc

data QImageFormat =
  FormatInvalid
  | FormatMono
  | FormatMonoLsb
  | FormatIndexed8
  | FormatRgb32
  | FormatArgb32
  | FormatArgb32Premultiplied
  | FormatRgb16
  | FormatArgb8565Premultiplied
  | FormatRgb666
  | FormatArgb6666Premultiplied
  | FormatRgb555
  | FormatArgb8555Premultiplied
  | FormatRgb888
  | FormatRgb444
  | FormatArgb4444Premultiplied
  | FormatRgbx8888
  | FormatRgba8888Premultiplied
  | FormatBgr30
  | FormatA2Rgb30Premultiplied
  | FormatAlpha8
  | FormatGrayscale8
  | UnknownQImageFormat (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QImageFormat where
  fromCppEnum FormatInvalid = 0
  fromCppEnum FormatMono = 1
  fromCppEnum FormatMonoLsb = 2
  fromCppEnum FormatIndexed8 = 3
  fromCppEnum FormatRgb32 = 4
  fromCppEnum FormatArgb32 = 5
  fromCppEnum FormatArgb32Premultiplied = 6
  fromCppEnum FormatRgb16 = 7
  fromCppEnum FormatArgb8565Premultiplied = 8
  fromCppEnum FormatRgb666 = 9
  fromCppEnum FormatArgb6666Premultiplied = 10
  fromCppEnum FormatRgb555 = 11
  fromCppEnum FormatArgb8555Premultiplied = 12
  fromCppEnum FormatRgb888 = 13
  fromCppEnum FormatRgb444 = 14
  fromCppEnum FormatArgb4444Premultiplied = 15
  fromCppEnum FormatRgbx8888 = 16
  fromCppEnum FormatRgba8888Premultiplied = 18
  fromCppEnum FormatBgr30 = 19
  fromCppEnum FormatA2Rgb30Premultiplied = 22
  fromCppEnum FormatAlpha8 = 23
  fromCppEnum FormatGrayscale8 = 24
  fromCppEnum (UnknownQImageFormat n) = n
  
  toCppEnum (0) = FormatInvalid
  toCppEnum (1) = FormatMono
  toCppEnum (2) = FormatMonoLsb
  toCppEnum (3) = FormatIndexed8
  toCppEnum (4) = FormatRgb32
  toCppEnum (5) = FormatArgb32
  toCppEnum (6) = FormatArgb32Premultiplied
  toCppEnum (7) = FormatRgb16
  toCppEnum (8) = FormatArgb8565Premultiplied
  toCppEnum (9) = FormatRgb666
  toCppEnum (10) = FormatArgb6666Premultiplied
  toCppEnum (11) = FormatRgb555
  toCppEnum (12) = FormatArgb8555Premultiplied
  toCppEnum (13) = FormatRgb888
  toCppEnum (14) = FormatRgb444
  toCppEnum (15) = FormatArgb4444Premultiplied
  toCppEnum (16) = FormatRgbx8888
  toCppEnum (18) = FormatRgba8888Premultiplied
  toCppEnum (19) = FormatBgr30
  toCppEnum (22) = FormatA2Rgb30Premultiplied
  toCppEnum (23) = FormatAlpha8
  toCppEnum (24) = FormatGrayscale8
  toCppEnum n = UnknownQImageFormat n

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

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

data QImageInvertMode =
  InvertRgb
  | InvertRgba
  | UnknownQImageInvertMode (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QImageInvertMode where
  fromCppEnum InvertRgb = 0
  fromCppEnum InvertRgba = 1
  fromCppEnum (UnknownQImageInvertMode n) = n
  
  toCppEnum (0) = InvertRgb
  toCppEnum (1) = InvertRgba
  toCppEnum n = UnknownQImageInvertMode n

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

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