QLineEdit.hs

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

module Graphics.UI.Qtah.Generated.Widgets.QLineEdit (
  castQLineEditToQWidget,
  castQWidgetToQLineEdit,
  castQLineEditToQObject,
  castQObjectToQLineEdit,
  QLineEditValue (..),
  QLineEditConstPtr (..),
  alignment,
  isClearButtonEnabled,
  copy,
  cursorMoveStyle,
  cursorPosition,
  displayText,
  dragEnabled,
  echoMode,
  hasFrame,
  hasAcceptableInput,
  hasSelectedText,
  inputMask,
  isRedoAvailable,
  isUndoAvailable,
  maxLength,
  isModified,
  placeholderText,
  isReadOnly,
  selectedText,
  selectionStart,
  text,
  textMargins,
  validator,
  QLineEditPtr (..),
  setAlignment,
  backspace,
  clear,
  setClearButtonEnabled,
  createStandardContextMenu,
  cursorBackward,
  cursorForward,
  setCursorMoveStyle,
  setCursorPosition,
  cursorPositionAt,
  cursorWordBackward,
  cursorWordForward,
  cut,
  del,
  deselect,
  setDragEnabled,
  setEchoMode,
  end,
  setFrame,
  home,
  setInputMask,
  insert,
  setMaxLength,
  setModified,
  paste,
  setPlaceholderText,
  setReadOnly,
  redo,
  selectAll,
  setSelection,
  setTextMargins,
  setTextMarginsRaw,
  setText,
  undo,
  setValidator,
  emitCursorPositionChanged,
  emitEditingFinished,
  emitReturnPressed,
  emitSelectionChanged,
  emitTextEdited,
  emitTextChanged,
  QLineEditConst (..),
  castQLineEditToConst,
  QLineEdit (..),
  castQLineEditToNonconst,
  new,
  newWithParent,
  newWithText,
  newWithTextAndParent,
  QLineEditSuper (..),
  QLineEditSuperConst (..),
  QLineEditEchoMode (..),
  ) where

import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import qualified Graphics.UI.Qtah.Core.HMargins as HMargins
import qualified Graphics.UI.Qtah.Flags as QtahFlags
import qualified Graphics.UI.Qtah.Generated.Core.QMargins as M68
import qualified Graphics.UI.Qtah.Generated.Core.QObject as M94
import qualified Graphics.UI.Qtah.Generated.Core.QPoint as M114
import qualified Graphics.UI.Qtah.Generated.Core.QString as M142
import qualified Graphics.UI.Qtah.Generated.Core.Types as M190
import qualified Graphics.UI.Qtah.Generated.Gui.QValidator as M338
import qualified Graphics.UI.Qtah.Generated.Widgets.QMenu as M448
import qualified Graphics.UI.Qtah.Generated.Widgets.QWidget as M506
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QLineEdit_new" new' ::  HoppyP.IO (HoppyF.Ptr QLineEdit)
foreign import ccall "genpop__QLineEdit_newWithParent" newWithParent' ::  HoppyF.Ptr M506.QWidget -> HoppyP.IO (HoppyF.Ptr QLineEdit)
foreign import ccall "genpop__QLineEdit_newWithText" newWithText' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QLineEdit)
foreign import ccall "genpop__QLineEdit_newWithTextAndParent" newWithTextAndParent' ::  HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M506.QWidget -> HoppyP.IO (HoppyF.Ptr QLineEdit)
foreign import ccall "genpop__QLineEdit_alignment" alignment' ::  HoppyF.Ptr QLineEditConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QLineEdit_setAlignment" setAlignment' ::  HoppyF.Ptr QLineEdit -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_backspace" backspace' ::  HoppyF.Ptr QLineEdit -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_clear" clear' ::  HoppyF.Ptr QLineEdit -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_isClearButtonEnabled" isClearButtonEnabled' ::  HoppyF.Ptr QLineEditConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLineEdit_setClearButtonEnabled" setClearButtonEnabled' ::  HoppyF.Ptr QLineEdit -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_copy" copy' ::  HoppyF.Ptr QLineEditConst -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_createStandardContextMenu" createStandardContextMenu' ::  HoppyF.Ptr QLineEdit -> HoppyP.IO (HoppyF.Ptr M448.QMenu)
foreign import ccall "genpop__QLineEdit_cursorBackward" cursorBackward' ::  HoppyF.Ptr QLineEdit -> HoppyFC.CBool -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_cursorForward" cursorForward' ::  HoppyF.Ptr QLineEdit -> HoppyFC.CBool -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_cursorMoveStyle" cursorMoveStyle' ::  HoppyF.Ptr QLineEditConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QLineEdit_setCursorMoveStyle" setCursorMoveStyle' ::  HoppyF.Ptr QLineEdit -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_cursorPosition" cursorPosition' ::  HoppyF.Ptr QLineEditConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QLineEdit_setCursorPosition" setCursorPosition' ::  HoppyF.Ptr QLineEdit -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_cursorPositionAt" cursorPositionAt' ::  HoppyF.Ptr QLineEdit -> HoppyF.Ptr M114.QPointConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QLineEdit_cursorWordBackward" cursorWordBackward' ::  HoppyF.Ptr QLineEdit -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_cursorWordForward" cursorWordForward' ::  HoppyF.Ptr QLineEdit -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_cut" cut' ::  HoppyF.Ptr QLineEdit -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_del" del' ::  HoppyF.Ptr QLineEdit -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_deselect" deselect' ::  HoppyF.Ptr QLineEdit -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_displayText" displayText' ::  HoppyF.Ptr QLineEditConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QLineEdit_dragEnabled" dragEnabled' ::  HoppyF.Ptr QLineEditConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLineEdit_setDragEnabled" setDragEnabled' ::  HoppyF.Ptr QLineEdit -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_echoMode" echoMode' ::  HoppyF.Ptr QLineEditConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QLineEdit_setEchoMode" setEchoMode' ::  HoppyF.Ptr QLineEdit -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_end" end' ::  HoppyF.Ptr QLineEdit -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_hasFrame" hasFrame' ::  HoppyF.Ptr QLineEditConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLineEdit_setFrame" setFrame' ::  HoppyF.Ptr QLineEdit -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_hasAcceptableInput" hasAcceptableInput' ::  HoppyF.Ptr QLineEditConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLineEdit_hasSelectedText" hasSelectedText' ::  HoppyF.Ptr QLineEditConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLineEdit_home" home' ::  HoppyF.Ptr QLineEdit -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_inputMask" inputMask' ::  HoppyF.Ptr QLineEditConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QLineEdit_setInputMask" setInputMask' ::  HoppyF.Ptr QLineEdit -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_insert" insert' ::  HoppyF.Ptr QLineEdit -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_isRedoAvailable" isRedoAvailable' ::  HoppyF.Ptr QLineEditConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLineEdit_isUndoAvailable" isUndoAvailable' ::  HoppyF.Ptr QLineEditConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLineEdit_maxLength" maxLength' ::  HoppyF.Ptr QLineEditConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QLineEdit_setMaxLength" setMaxLength' ::  HoppyF.Ptr QLineEdit -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_isModified" isModified' ::  HoppyF.Ptr QLineEditConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLineEdit_setModified" setModified' ::  HoppyF.Ptr QLineEdit -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_paste" paste' ::  HoppyF.Ptr QLineEdit -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_placeholderText" placeholderText' ::  HoppyF.Ptr QLineEditConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QLineEdit_setPlaceholderText" setPlaceholderText' ::  HoppyF.Ptr QLineEdit -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_isReadOnly" isReadOnly' ::  HoppyF.Ptr QLineEditConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLineEdit_setReadOnly" setReadOnly' ::  HoppyF.Ptr QLineEdit -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_redo" redo' ::  HoppyF.Ptr QLineEdit -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_selectAll" selectAll' ::  HoppyF.Ptr QLineEdit -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_selectedText" selectedText' ::  HoppyF.Ptr QLineEditConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QLineEdit_selectionStart" selectionStart' ::  HoppyF.Ptr QLineEditConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QLineEdit_setSelection" setSelection' ::  HoppyF.Ptr QLineEdit -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_setTextMargins" setTextMargins' ::  HoppyF.Ptr QLineEdit -> HoppyF.Ptr M68.QMarginsConst -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_setTextMarginsRaw" setTextMarginsRaw' ::  HoppyF.Ptr QLineEdit -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_text" text' ::  HoppyF.Ptr QLineEditConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QLineEdit_setText" setText' ::  HoppyF.Ptr QLineEdit -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_textMargins" textMargins' ::  HoppyF.Ptr QLineEditConst -> HoppyP.IO (HoppyF.Ptr M68.QMarginsConst)
foreign import ccall "genpop__QLineEdit_undo" undo' ::  HoppyF.Ptr QLineEdit -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_validator" validator' ::  HoppyF.Ptr QLineEditConst -> HoppyP.IO (HoppyF.Ptr M338.QValidatorConst)
foreign import ccall "genpop__QLineEdit_setValidator" setValidator' ::  HoppyF.Ptr QLineEdit -> HoppyF.Ptr M338.QValidatorConst -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_emitCursorPositionChanged" emitCursorPositionChanged' ::  HoppyF.Ptr QLineEdit -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_emitEditingFinished" emitEditingFinished' ::  HoppyF.Ptr QLineEdit -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_emitReturnPressed" emitReturnPressed' ::  HoppyF.Ptr QLineEdit -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_emitSelectionChanged" emitSelectionChanged' ::  HoppyF.Ptr QLineEdit -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_emitTextEdited" emitTextEdited' ::  HoppyF.Ptr QLineEdit -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QLineEdit_emitTextChanged" emitTextChanged' ::  HoppyF.Ptr QLineEdit -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "gencast__QLineEdit__QWidget" castQLineEditToQWidget :: HoppyF.Ptr QLineEditConst -> HoppyF.Ptr M506.QWidgetConst
foreign import ccall "gencast__QWidget__QLineEdit" castQWidgetToQLineEdit :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr QLineEditConst
foreign import ccall "gencast__QLineEdit__QObject" castQLineEditToQObject :: HoppyF.Ptr QLineEditConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QLineEdit" castQObjectToQLineEdit :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QLineEditConst
foreign import ccall "gendel__QLineEdit" delete'QLineEdit :: HoppyF.Ptr QLineEditConst -> HoppyP.IO ()
foreign import ccall "&gendel__QLineEdit" deletePtr'QLineEdit :: HoppyF.FunPtr (HoppyF.Ptr QLineEditConst -> HoppyP.IO ())

class QLineEditValue a where
  withQLineEditPtr :: a -> (QLineEditConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QLineEditConstPtr a => QLineEditValue a where
  withQLineEditPtr = HoppyP.flip ($) . toQLineEditConst

class (M506.QWidgetConstPtr this) => QLineEditConstPtr this where
  toQLineEditConst :: this -> QLineEditConst

alignment :: (QLineEditValue this) => (this) {- ^ this -} -> (HoppyP.IO M190.QtAlignment)
alignment arg'1 =
  withQLineEditPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.numToFlags
  ) =<<
  (alignment' arg'1')

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

copy :: (QLineEditValue this) => (this) {- ^ this -} -> (HoppyP.IO ())
copy arg'1 =
  withQLineEditPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (copy' arg'1')

cursorMoveStyle :: (QLineEditValue this) => (this) {- ^ this -} -> (HoppyP.IO M190.QtCursorMoveStyle)
cursorMoveStyle arg'1 =
  withQLineEditPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (cursorMoveStyle' arg'1')

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

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

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

echoMode :: (QLineEditValue this) => (this) {- ^ this -} -> (HoppyP.IO QLineEditEchoMode)
echoMode arg'1 =
  withQLineEditPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (echoMode' arg'1')

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

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

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

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

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

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

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

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

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

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

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

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

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

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

validator :: (QLineEditValue this) => (this) {- ^ this -} -> (HoppyP.IO M338.QValidatorConst)
validator arg'1 =
  withQLineEditPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M338.QValidatorConst
  (validator' arg'1')

class (QLineEditConstPtr this, M506.QWidgetPtr this) => QLineEditPtr this where
  toQLineEdit :: this -> QLineEdit

setAlignment :: (QLineEditPtr this, M190.IsQtAlignment arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setAlignment arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQLineEdit arg'1) $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtAlignment
  ) arg'2 >>= \arg'2' ->
  (setAlignment' arg'1' arg'2')

backspace :: (QLineEditPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
backspace arg'1 =
  HoppyFHR.withCppPtr (toQLineEdit arg'1) $ \arg'1' ->
  (backspace' arg'1')

clear :: (QLineEditPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
clear arg'1 =
  HoppyFHR.withCppPtr (toQLineEdit arg'1) $ \arg'1' ->
  (clear' arg'1')

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

createStandardContextMenu :: (QLineEditPtr this) => (this) {- ^ this -} -> (HoppyP.IO M448.QMenu)
createStandardContextMenu arg'1 =
  HoppyFHR.withCppPtr (toQLineEdit arg'1) $ \arg'1' ->
  HoppyP.fmap M448.QMenu
  (createStandardContextMenu' arg'1')

cursorBackward :: (QLineEditPtr this) => (this) {- ^ this -} -> (HoppyP.Bool) -> (HoppyP.Int) -> (HoppyP.IO ())
cursorBackward arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQLineEdit arg'1) $ \arg'1' ->
  (
    \x -> HoppyP.return $ if x then 1 else 0
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (cursorBackward' arg'1' arg'2' arg'3')

cursorForward :: (QLineEditPtr this) => (this) {- ^ this -} -> (HoppyP.Bool) -> (HoppyP.Int) -> (HoppyP.IO ())
cursorForward arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQLineEdit arg'1) $ \arg'1' ->
  (
    \x -> HoppyP.return $ if x then 1 else 0
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (cursorForward' arg'1' arg'2' arg'3')

setCursorMoveStyle :: (QLineEditPtr this) => (this) {- ^ this -} -> (M190.QtCursorMoveStyle) -> (HoppyP.IO ())
setCursorMoveStyle arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQLineEdit arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setCursorMoveStyle' arg'1' arg'2')

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

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

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

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

cut :: (QLineEditPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
cut arg'1 =
  HoppyFHR.withCppPtr (toQLineEdit arg'1) $ \arg'1' ->
  (cut' arg'1')

del :: (QLineEditPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
del arg'1 =
  HoppyFHR.withCppPtr (toQLineEdit arg'1) $ \arg'1' ->
  (del' arg'1')

deselect :: (QLineEditPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
deselect arg'1 =
  HoppyFHR.withCppPtr (toQLineEdit arg'1) $ \arg'1' ->
  (deselect' arg'1')

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

setEchoMode :: (QLineEditPtr this) => (this) {- ^ this -} -> (QLineEditEchoMode) -> (HoppyP.IO ())
setEchoMode arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQLineEdit arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setEchoMode' arg'1' arg'2')

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

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

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

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

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

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

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

paste :: (QLineEditPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
paste arg'1 =
  HoppyFHR.withCppPtr (toQLineEdit arg'1) $ \arg'1' ->
  (paste' arg'1')

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

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

redo :: (QLineEditPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
redo arg'1 =
  HoppyFHR.withCppPtr (toQLineEdit arg'1) $ \arg'1' ->
  (redo' arg'1')

selectAll :: (QLineEditPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
selectAll arg'1 =
  HoppyFHR.withCppPtr (toQLineEdit arg'1) $ \arg'1' ->
  (selectAll' arg'1')

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

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

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

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

undo :: (QLineEditPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
undo arg'1 =
  HoppyFHR.withCppPtr (toQLineEdit arg'1) $ \arg'1' ->
  (undo' arg'1')

setValidator :: (QLineEditPtr this, M338.QValidatorValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setValidator arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQLineEdit arg'1) $ \arg'1' ->
  M338.withQValidatorPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setValidator' arg'1' arg'2')

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

emitEditingFinished :: (QLineEditPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
emitEditingFinished arg'1 =
  HoppyFHR.withCppPtr (toQLineEdit arg'1) $ \arg'1' ->
  (emitEditingFinished' arg'1')

emitReturnPressed :: (QLineEditPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
emitReturnPressed arg'1 =
  HoppyFHR.withCppPtr (toQLineEdit arg'1) $ \arg'1' ->
  (emitReturnPressed' arg'1')

emitSelectionChanged :: (QLineEditPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
emitSelectionChanged arg'1 =
  HoppyFHR.withCppPtr (toQLineEdit arg'1) $ \arg'1' ->
  (emitSelectionChanged' arg'1')

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

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

data QLineEditConst =
    QLineEditConst (HoppyF.Ptr QLineEditConst)
  | QLineEditConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QLineEditConst)
  deriving (HoppyP.Show)

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

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

castQLineEditToConst :: QLineEdit -> QLineEditConst
castQLineEditToConst (QLineEdit ptr') = QLineEditConst $ HoppyF.castPtr ptr'
castQLineEditToConst (QLineEditGc fptr' ptr') = QLineEditConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QLineEditConstPtr QLineEditConst where
  toQLineEditConst = HoppyP.id

instance M506.QWidgetConstPtr QLineEditConst where
  toQWidgetConst (QLineEditConst ptr') = M506.QWidgetConst $ castQLineEditToQWidget ptr'
  toQWidgetConst (QLineEditConstGc fptr' ptr') = M506.QWidgetConstGc fptr' $ castQLineEditToQWidget ptr'

instance M94.QObjectConstPtr QLineEditConst where
  toQObjectConst (QLineEditConst ptr') = M94.QObjectConst $ castQLineEditToQObject ptr'
  toQObjectConst (QLineEditConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQLineEditToQObject ptr'

data QLineEdit =
    QLineEdit (HoppyF.Ptr QLineEdit)
  | QLineEditGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QLineEdit)
  deriving (HoppyP.Show)

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

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

castQLineEditToNonconst :: QLineEditConst -> QLineEdit
castQLineEditToNonconst (QLineEditConst ptr') = QLineEdit $ HoppyF.castPtr ptr'
castQLineEditToNonconst (QLineEditConstGc fptr' ptr') = QLineEditGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QLineEditConstPtr QLineEdit where
  toQLineEditConst (QLineEdit ptr') = QLineEditConst $ (HoppyF.castPtr :: HoppyF.Ptr QLineEdit -> HoppyF.Ptr QLineEditConst) ptr'
  toQLineEditConst (QLineEditGc fptr' ptr') = QLineEditConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QLineEdit -> HoppyF.Ptr QLineEditConst) ptr'

instance QLineEditPtr QLineEdit where
  toQLineEdit = HoppyP.id

instance M506.QWidgetConstPtr QLineEdit where
  toQWidgetConst (QLineEdit ptr') = M506.QWidgetConst $ castQLineEditToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QLineEdit -> HoppyF.Ptr QLineEditConst) ptr'
  toQWidgetConst (QLineEditGc fptr' ptr') = M506.QWidgetConstGc fptr' $ castQLineEditToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QLineEdit -> HoppyF.Ptr QLineEditConst) ptr'

instance M506.QWidgetPtr QLineEdit where
  toQWidget (QLineEdit ptr') = M506.QWidget $ (HoppyF.castPtr :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr M506.QWidget) $ castQLineEditToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QLineEdit -> HoppyF.Ptr QLineEditConst) ptr'
  toQWidget (QLineEditGc fptr' ptr') = M506.QWidgetGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr M506.QWidget) $ castQLineEditToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QLineEdit -> HoppyF.Ptr QLineEditConst) ptr'

instance M94.QObjectConstPtr QLineEdit where
  toQObjectConst (QLineEdit ptr') = M94.QObjectConst $ castQLineEditToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QLineEdit -> HoppyF.Ptr QLineEditConst) ptr'
  toQObjectConst (QLineEditGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQLineEditToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QLineEdit -> HoppyF.Ptr QLineEditConst) ptr'

instance M94.QObjectPtr QLineEdit where
  toQObject (QLineEdit ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQLineEditToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QLineEdit -> HoppyF.Ptr QLineEditConst) ptr'
  toQObject (QLineEditGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQLineEditToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QLineEdit -> HoppyF.Ptr QLineEditConst) ptr'

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

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

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

newWithTextAndParent :: (M142.QStringValue arg'1, M506.QWidgetPtr arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO QLineEdit)
newWithTextAndParent arg'1 arg'2 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (M506.toQWidget arg'2) $ \arg'2' ->
  HoppyP.fmap QLineEdit
  (newWithTextAndParent' arg'1' arg'2')

class QLineEditSuper a where
  downToQLineEdit :: a -> QLineEdit

instance QLineEditSuper M506.QWidget where
  downToQLineEdit = castQLineEditToNonconst . cast' . M506.castQWidgetToConst
    where
      cast' (M506.QWidgetConst ptr') = QLineEditConst $ castQWidgetToQLineEdit ptr'
      cast' (M506.QWidgetConstGc fptr' ptr') = QLineEditConstGc fptr' $ castQWidgetToQLineEdit ptr'
instance QLineEditSuper M94.QObject where
  downToQLineEdit = castQLineEditToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QLineEditConst $ castQObjectToQLineEdit ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QLineEditConstGc fptr' $ castQObjectToQLineEdit ptr'

class QLineEditSuperConst a where
  downToQLineEditConst :: a -> QLineEditConst

instance QLineEditSuperConst M506.QWidgetConst where
  downToQLineEditConst = cast'
    where
      cast' (M506.QWidgetConst ptr') = QLineEditConst $ castQWidgetToQLineEdit ptr'
      cast' (M506.QWidgetConstGc fptr' ptr') = QLineEditConstGc fptr' $ castQWidgetToQLineEdit ptr'
instance QLineEditSuperConst M94.QObjectConst where
  downToQLineEditConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QLineEditConst $ castQObjectToQLineEdit ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QLineEditConstGc fptr' $ castQObjectToQLineEdit ptr'

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

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

data QLineEditEchoMode =
  Normal
  | NoEcho
  | Password
  | PasswordEchoOnEdit
  | UnknownQLineEditEchoMode (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QLineEditEchoMode where
  fromCppEnum Normal = 0
  fromCppEnum NoEcho = 1
  fromCppEnum Password = 2
  fromCppEnum PasswordEchoOnEdit = 3
  fromCppEnum (UnknownQLineEditEchoMode n) = n
  
  toCppEnum (0) = Normal
  toCppEnum (1) = NoEcho
  toCppEnum (2) = Password
  toCppEnum (3) = PasswordEchoOnEdit
  toCppEnum n = UnknownQLineEditEchoMode n

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

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