{-# INCLUDE "wxc.h" #-}
{-# LANGUAGE ForeignFunctionInterface #-}
--------------------------------------------------------------------------------
{-|	Module      :  WxcClassesAL
	Copyright   :  Copyright (c) Daan Leijen 2003, 2004
	License     :  wxWidgets

	Maintainer  :  wxhaskell-devel@lists.sourceforge.net
	Stability   :  provisional
	Portability :  portable

Haskell class definitions for the wxWidgets C library (@wxc.dll@).

Do not edit this file manually!
This file was automatically generated by wxDirect on: 

  * @2010-09-10 18:28:55.718584 UTC@

From the files:

  * @src\/include\/wxc.h@

And contains 1560 methods for 120 classes.
-}
--------------------------------------------------------------------------------
module Graphics.UI.WXCore.WxcClassesAL
    ( -- * Version
      versionWxcClassesAL
      -- * Global
     -- ** Misc.
     ,bitmapDataObjectCreate
     ,bitmapDataObjectCreateEmpty
     ,bitmapDataObjectDelete
     ,bitmapDataObjectGetBitmap
     ,bitmapDataObjectSetBitmap
     ,cFree
     ,cursorCreateFromImage
     ,cursorCreateFromStock
     ,cursorCreateLoad
     ,dragIcon
     ,dragListItem
     ,dragString
     ,dragTreeItem
     ,dropSourceCreate
     ,dropSourceDelete
     ,dropSourceDoDragDrop
     ,fileDataObjectAddFile
     ,fileDataObjectCreate
     ,fileDataObjectDelete
     ,fileDataObjectGetFilenames
     ,genericDragIcon
     ,genericDragListItem
     ,genericDragString
     ,genericDragTreeItem
     ,getApplicationDir
     ,getApplicationPath
     ,getColourFromUser
     ,getELJLocale
     ,getELJTranslation
     ,getFontFromUser
     ,getNumberFromUser
     ,getPasswordFromUser
     ,getTextFromUser
     ,isDefined
     ,kill
     ,logDebug
     ,logError
     ,logErrorMsg
     ,logFatalError
     ,logFatalErrorMsg
     ,logMessage
     ,logMessageMsg
     ,logStatus
     ,logSysError
     ,logTrace
     ,logVerbose
     ,logWarning
     ,logWarningMsg
      -- * Classes
     -- ** AcceleratorEntry
     ,acceleratorEntryCreate
     ,acceleratorEntryDelete
     ,acceleratorEntryGetCommand
     ,acceleratorEntryGetFlags
     ,acceleratorEntryGetKeyCode
     ,acceleratorEntrySet
     -- ** AcceleratorTable
     ,acceleratorTableCreate
     ,acceleratorTableDelete
     -- ** ActivateEvent
     ,activateEventCopyObject
     ,activateEventGetActive
     -- ** AutoBufferedPaintDC
     ,autoBufferedPaintDCCreate
     ,autoBufferedPaintDCDelete
     -- ** Bitmap
     ,bitmapAddHandler
     ,bitmapCleanUpHandlers
     ,bitmapCreate
     ,bitmapCreateDefault
     ,bitmapCreateEmpty
     ,bitmapCreateFromImage
     ,bitmapCreateFromXPM
     ,bitmapCreateLoad
     ,bitmapDelete
     ,bitmapFindHandlerByExtension
     ,bitmapFindHandlerByName
     ,bitmapFindHandlerByType
     ,bitmapGetDepth
     ,bitmapGetHeight
     ,bitmapGetMask
     ,bitmapGetSubBitmap
     ,bitmapGetWidth
     ,bitmapInitStandardHandlers
     ,bitmapInsertHandler
     ,bitmapIsOk
     ,bitmapIsStatic
     ,bitmapLoadFile
     ,bitmapRemoveHandler
     ,bitmapSafeDelete
     ,bitmapSaveFile
     ,bitmapSetDepth
     ,bitmapSetHeight
     ,bitmapSetMask
     ,bitmapSetWidth
     -- ** BitmapButton
     ,bitmapButtonCreate
     ,bitmapButtonGetBitmapDisabled
     ,bitmapButtonGetBitmapFocus
     ,bitmapButtonGetBitmapLabel
     ,bitmapButtonGetBitmapSelected
     ,bitmapButtonGetMarginX
     ,bitmapButtonGetMarginY
     ,bitmapButtonSetBitmapDisabled
     ,bitmapButtonSetBitmapFocus
     ,bitmapButtonSetBitmapLabel
     ,bitmapButtonSetBitmapSelected
     ,bitmapButtonSetMargins
     -- ** BoxSizer
     ,boxSizerCalcMin
     ,boxSizerCreate
     ,boxSizerGetOrientation
     ,boxSizerRecalcSizes
     -- ** Brush
     ,brushAssign
     ,brushCreateDefault
     ,brushCreateFromBitmap
     ,brushCreateFromColour
     ,brushCreateFromStock
     ,brushDelete
     ,brushGetColour
     ,brushGetStipple
     ,brushGetStyle
     ,brushIsEqual
     ,brushIsOk
     ,brushIsStatic
     ,brushSafeDelete
     ,brushSetColour
     ,brushSetColourSingle
     ,brushSetStipple
     ,brushSetStyle
     -- ** BufferedDC
     ,bufferedDCCreateByDCAndBitmap
     ,bufferedDCCreateByDCAndSize
     ,bufferedDCDelete
     -- ** BufferedPaintDC
     ,bufferedPaintDCCreate
     ,bufferedPaintDCCreateWithBitmap
     ,bufferedPaintDCDelete
     -- ** BusyCursor
     ,busyCursorCreate
     ,busyCursorCreateWithCursor
     ,busyCursorDelete
     -- ** BusyInfo
     ,busyInfoCreate
     ,busyInfoDelete
     -- ** Button
     ,buttonCreate
     ,buttonSetBackgroundColour
     ,buttonSetDefault
     -- ** CalculateLayoutEvent
     ,calculateLayoutEventCreate
     ,calculateLayoutEventGetFlags
     ,calculateLayoutEventGetRect
     ,calculateLayoutEventSetFlags
     ,calculateLayoutEventSetRect
     -- ** CalendarCtrl
     ,calendarCtrlCreate
     ,calendarCtrlEnableHolidayDisplay
     ,calendarCtrlEnableMonthChange
     ,calendarCtrlEnableYearChange
     ,calendarCtrlGetAttr
     ,calendarCtrlGetDate
     ,calendarCtrlGetHeaderColourBg
     ,calendarCtrlGetHeaderColourFg
     ,calendarCtrlGetHighlightColourBg
     ,calendarCtrlGetHighlightColourFg
     ,calendarCtrlGetHolidayColourBg
     ,calendarCtrlGetHolidayColourFg
     ,calendarCtrlHitTest
     ,calendarCtrlResetAttr
     ,calendarCtrlSetAttr
     ,calendarCtrlSetDate
     ,calendarCtrlSetHeaderColours
     ,calendarCtrlSetHighlightColours
     ,calendarCtrlSetHoliday
     ,calendarCtrlSetHolidayColours
     -- ** CalendarDateAttr
     ,calendarDateAttrCreate
     ,calendarDateAttrCreateDefault
     ,calendarDateAttrDelete
     ,calendarDateAttrGetBackgroundColour
     ,calendarDateAttrGetBorder
     ,calendarDateAttrGetBorderColour
     ,calendarDateAttrGetFont
     ,calendarDateAttrGetTextColour
     ,calendarDateAttrHasBackgroundColour
     ,calendarDateAttrHasBorder
     ,calendarDateAttrHasBorderColour
     ,calendarDateAttrHasFont
     ,calendarDateAttrHasTextColour
     ,calendarDateAttrIsHoliday
     ,calendarDateAttrSetBackgroundColour
     ,calendarDateAttrSetBorder
     ,calendarDateAttrSetBorderColour
     ,calendarDateAttrSetFont
     ,calendarDateAttrSetHoliday
     ,calendarDateAttrSetTextColour
     -- ** CalendarEvent
     ,calendarEventGetDate
     ,calendarEventGetWeekDay
     -- ** Caret
     ,caretCreate
     ,caretGetBlinkTime
     ,caretGetPosition
     ,caretGetSize
     ,caretGetWindow
     ,caretHide
     ,caretIsOk
     ,caretIsVisible
     ,caretMove
     ,caretSetBlinkTime
     ,caretSetSize
     ,caretShow
     -- ** CheckBox
     ,checkBoxCreate
     ,checkBoxDelete
     ,checkBoxGetValue
     ,checkBoxSetValue
     -- ** CheckListBox
     ,checkListBoxCheck
     ,checkListBoxCreate
     ,checkListBoxDelete
     ,checkListBoxIsChecked
     -- ** Choice
     ,choiceAppend
     ,choiceClear
     ,choiceCreate
     ,choiceDelete
     ,choiceFindString
     ,choiceGetCount
     ,choiceGetSelection
     ,choiceGetString
     ,choiceSetSelection
     ,choiceSetString
     -- ** ClassInfo
     ,classInfoCreateClassByName
     ,classInfoFindClass
     ,classInfoGetBaseClassName1
     ,classInfoGetBaseClassName2
     ,classInfoGetClassName
     ,classInfoGetClassNameEx
     ,classInfoGetSize
     ,classInfoIsKindOf
     ,classInfoIsKindOfEx
     -- ** ClientDC
     ,clientDCCreate
     ,clientDCDelete
     -- ** Clipboard
     ,clipboardAddData
     ,clipboardClear
     ,clipboardClose
     ,clipboardCreate
     ,clipboardFlush
     ,clipboardGetData
     ,clipboardIsOpened
     ,clipboardIsSupported
     ,clipboardOpen
     ,clipboardSetData
     ,clipboardUsePrimarySelection
     -- ** CloseEvent
     ,closeEventCanVeto
     ,closeEventCopyObject
     ,closeEventGetLoggingOff
     ,closeEventGetVeto
     ,closeEventSetCanVeto
     ,closeEventSetLoggingOff
     ,closeEventVeto
     -- ** Closure
     ,closureCreate
     ,closureGetData
     -- ** ComboBox
     ,comboBoxAppend
     ,comboBoxAppendData
     ,comboBoxClear
     ,comboBoxCopy
     ,comboBoxCreate
     ,comboBoxCut
     ,comboBoxDelete
     ,comboBoxFindString
     ,comboBoxGetClientData
     ,comboBoxGetCount
     ,comboBoxGetInsertionPoint
     ,comboBoxGetLastPosition
     ,comboBoxGetSelection
     ,comboBoxGetString
     ,comboBoxGetStringSelection
     ,comboBoxGetValue
     ,comboBoxPaste
     ,comboBoxRemove
     ,comboBoxReplace
     ,comboBoxSetClientData
     ,comboBoxSetEditable
     ,comboBoxSetInsertionPoint
     ,comboBoxSetInsertionPointEnd
     ,comboBoxSetSelection
     ,comboBoxSetTextSelection
     -- ** CommandEvent
     ,commandEventCopyObject
     ,commandEventCreate
     ,commandEventDelete
     ,commandEventGetClientData
     ,commandEventGetClientObject
     ,commandEventGetExtraLong
     ,commandEventGetInt
     ,commandEventGetSelection
     ,commandEventGetString
     ,commandEventIsChecked
     ,commandEventIsSelection
     ,commandEventSetClientData
     ,commandEventSetClientObject
     ,commandEventSetExtraLong
     ,commandEventSetInt
     ,commandEventSetString
     -- ** ConfigBase
     ,configBaseCreate
     ,configBaseDelete
     ,configBaseDeleteAll
     ,configBaseDeleteEntry
     ,configBaseDeleteGroup
     ,configBaseExists
     ,configBaseExpandEnvVars
     ,configBaseFlush
     ,configBaseGet
     ,configBaseGetAppName
     ,configBaseGetEntryType
     ,configBaseGetFirstEntry
     ,configBaseGetFirstGroup
     ,configBaseGetNextEntry
     ,configBaseGetNextGroup
     ,configBaseGetNumberOfEntries
     ,configBaseGetNumberOfGroups
     ,configBaseGetPath
     ,configBaseGetStyle
     ,configBaseGetVendorName
     ,configBaseHasEntry
     ,configBaseHasGroup
     ,configBaseIsExpandingEnvVars
     ,configBaseIsRecordingDefaults
     ,configBaseReadBool
     ,configBaseReadDouble
     ,configBaseReadInteger
     ,configBaseReadString
     ,configBaseRenameEntry
     ,configBaseRenameGroup
     ,configBaseSet
     ,configBaseSetAppName
     ,configBaseSetExpandEnvVars
     ,configBaseSetPath
     ,configBaseSetRecordDefaults
     ,configBaseSetStyle
     ,configBaseSetVendorName
     ,configBaseWriteBool
     ,configBaseWriteDouble
     ,configBaseWriteInteger
     ,configBaseWriteLong
     ,configBaseWriteString
     -- ** ContextHelp
     ,contextHelpBeginContextHelp
     ,contextHelpCreate
     ,contextHelpDelete
     ,contextHelpEndContextHelp
     -- ** ContextHelpButton
     ,contextHelpButtonCreate
     -- ** Control
     ,controlCommand
     ,controlGetLabel
     ,controlSetLabel
     -- ** Cursor
     ,cursorDelete
     ,cursorIsStatic
     ,cursorSafeDelete
     -- ** DC
     ,dcBeginDrawing
     ,dcBlit
     ,dcCalcBoundingBox
     ,dcCanDrawBitmap
     ,dcCanGetTextExtent
     ,dcClear
     ,dcComputeScaleAndOrigin
     ,dcCrossHair
     ,dcDelete
     ,dcDestroyClippingRegion
     ,dcDeviceToLogicalX
     ,dcDeviceToLogicalXRel
     ,dcDeviceToLogicalY
     ,dcDeviceToLogicalYRel
     ,dcDrawArc
     ,dcDrawBitmap
     ,dcDrawCheckMark
     ,dcDrawCircle
     ,dcDrawEllipse
     ,dcDrawEllipticArc
     ,dcDrawIcon
     ,dcDrawLabel
     ,dcDrawLabelBitmap
     ,dcDrawLine
     ,dcDrawLines
     ,dcDrawPoint
     ,dcDrawPolyPolygon
     ,dcDrawPolygon
     ,dcDrawRectangle
     ,dcDrawRotatedText
     ,dcDrawRoundedRectangle
     ,dcDrawText
     ,dcEndDoc
     ,dcEndDrawing
     ,dcEndPage
     ,dcFloodFill
     ,dcGetBackground
     ,dcGetBackgroundMode
     ,dcGetBrush
     ,dcGetCharHeight
     ,dcGetCharWidth
     ,dcGetClippingBox
     ,dcGetDepth
     ,dcGetDeviceOrigin
     ,dcGetFont
     ,dcGetLogicalFunction
     ,dcGetLogicalOrigin
     ,dcGetLogicalScale
     ,dcGetMapMode
     ,dcGetMultiLineTextExtent
     ,dcGetPPI
     ,dcGetPen
     ,dcGetPixel
     ,dcGetPixel2
     ,dcGetSize
     ,dcGetSizeMM
     ,dcGetTextBackground
     ,dcGetTextExtent
     ,dcGetTextForeground
     ,dcGetUserScale
     ,dcGetUserScaleX
     ,dcGetUserScaleY
     ,dcIsOk
     ,dcLogicalToDeviceX
     ,dcLogicalToDeviceXRel
     ,dcLogicalToDeviceY
     ,dcLogicalToDeviceYRel
     ,dcMaxX
     ,dcMaxY
     ,dcMinX
     ,dcMinY
     ,dcResetBoundingBox
     ,dcSetAxisOrientation
     ,dcSetBackground
     ,dcSetBackgroundMode
     ,dcSetBrush
     ,dcSetClippingRegion
     ,dcSetClippingRegionFromRegion
     ,dcSetDeviceOrigin
     ,dcSetFont
     ,dcSetLogicalFunction
     ,dcSetLogicalOrigin
     ,dcSetLogicalScale
     ,dcSetMapMode
     ,dcSetPalette
     ,dcSetPen
     ,dcSetTextBackground
     ,dcSetTextForeground
     ,dcSetUserScale
     ,dcStartDoc
     ,dcStartPage
     -- ** DataFormat
     ,dataFormatCreateFromId
     ,dataFormatCreateFromType
     ,dataFormatDelete
     ,dataFormatGetId
     ,dataFormatGetType
     ,dataFormatIsEqual
     ,dataFormatSetId
     ,dataFormatSetType
     -- ** DataObjectComposite
     ,dataObjectCompositeAdd
     ,dataObjectCompositeCreate
     ,dataObjectCompositeDelete
     -- ** DateTime
     ,dateTimeAddDate
     ,dateTimeAddDateValues
     ,dateTimeAddTime
     ,dateTimeAddTimeValues
     ,dateTimeConvertYearToBC
     ,dateTimeCreate
     ,dateTimeDelete
     ,dateTimeFormat
     ,dateTimeFormatDate
     ,dateTimeFormatISODate
     ,dateTimeFormatISOTime
     ,dateTimeFormatTime
     ,dateTimeGetAmString
     ,dateTimeGetBeginDST
     ,dateTimeGetCentury
     ,dateTimeGetCountry
     ,dateTimeGetCurrentMonth
     ,dateTimeGetCurrentYear
     ,dateTimeGetDay
     ,dateTimeGetDayOfYear
     ,dateTimeGetEndDST
     ,dateTimeGetHour
     ,dateTimeGetLastMonthDay
     ,dateTimeGetLastWeekDay
     ,dateTimeGetMillisecond
     ,dateTimeGetMinute
     ,dateTimeGetMonth
     ,dateTimeGetMonthName
     ,dateTimeGetNextWeekDay
     ,dateTimeGetNumberOfDays
     ,dateTimeGetNumberOfDaysMonth
     ,dateTimeGetPmString
     ,dateTimeGetPrevWeekDay
     ,dateTimeGetSecond
     ,dateTimeGetTicks
     ,dateTimeGetTimeNow
     ,dateTimeGetValue
     ,dateTimeGetWeekDay
     ,dateTimeGetWeekDayInSameWeek
     ,dateTimeGetWeekDayName
     ,dateTimeGetWeekDayTZ
     ,dateTimeGetWeekOfMonth
     ,dateTimeGetWeekOfYear
     ,dateTimeGetYear
     ,dateTimeIsBetween
     ,dateTimeIsDST
     ,dateTimeIsDSTApplicable
     ,dateTimeIsEarlierThan
     ,dateTimeIsEqualTo
     ,dateTimeIsEqualUpTo
     ,dateTimeIsLaterThan
     ,dateTimeIsLeapYear
     ,dateTimeIsSameDate
     ,dateTimeIsSameTime
     ,dateTimeIsStrictlyBetween
     ,dateTimeIsValid
     ,dateTimeIsWestEuropeanCountry
     ,dateTimeIsWorkDay
     ,dateTimeMakeGMT
     ,dateTimeMakeTimezone
     ,dateTimeNow
     ,dateTimeParseDate
     ,dateTimeParseDateTime
     ,dateTimeParseFormat
     ,dateTimeParseRfc822Date
     ,dateTimeParseTime
     ,dateTimeResetTime
     ,dateTimeSet
     ,dateTimeSetCountry
     ,dateTimeSetDay
     ,dateTimeSetHour
     ,dateTimeSetMillisecond
     ,dateTimeSetMinute
     ,dateTimeSetMonth
     ,dateTimeSetSecond
     ,dateTimeSetTime
     ,dateTimeSetToCurrent
     ,dateTimeSetToLastMonthDay
     ,dateTimeSetToLastWeekDay
     ,dateTimeSetToNextWeekDay
     ,dateTimeSetToPrevWeekDay
     ,dateTimeSetToWeekDay
     ,dateTimeSetToWeekDayInSameWeek
     ,dateTimeSetYear
     ,dateTimeSubtractDate
     ,dateTimeSubtractTime
     ,dateTimeToGMT
     ,dateTimeToTimezone
     ,dateTimeToday
     ,dateTimeUNow
     ,dateTimewxDateTime
     -- ** Db
     ,dbClose
     ,dbCloseConnections
     ,dbCommitTrans
     ,dbConnectionsInUse
     ,dbCreate
     ,dbDbms
     ,dbDelete
     ,dbExecSql
     ,dbFreeConnection
     ,dbGetCatalog
     ,dbGetColumnCount
     ,dbGetColumns
     ,dbGetConnection
     ,dbGetData
     ,dbGetDataBinary
     ,dbGetDataDate
     ,dbGetDataDouble
     ,dbGetDataInt
     ,dbGetDataSource
     ,dbGetDataTime
     ,dbGetDataTimeStamp
     ,dbGetDatabaseName
     ,dbGetDatasourceName
     ,dbGetErrorMessage
     ,dbGetErrorMsg
     ,dbGetHDBC
     ,dbGetHENV
     ,dbGetHSTMT
     ,dbGetNativeError
     ,dbGetNext
     ,dbGetNextError
     ,dbGetNumErrorMessages
     ,dbGetPassword
     ,dbGetResultColumns
     ,dbGetStatus
     ,dbGetTableCount
     ,dbGetUsername
     ,dbGrant
     ,dbIsOpen
     ,dbIsSupported
     ,dbOpen
     ,dbRollbackTrans
     ,dbSQLColumnName
     ,dbSQLTableName
     ,dbSqlTypeToStandardSqlType
     ,dbStandardSqlTypeToSqlType
     ,dbTableExists
     ,dbTablePrivileges
     ,dbTranslateSqlState
     -- ** DbColInf
     ,dbColInfGetBufferLength
     ,dbColInfGetCatalog
     ,dbColInfGetColName
     ,dbColInfGetColumnSize
     ,dbColInfGetDbDataType
     ,dbColInfGetDecimalDigits
     ,dbColInfGetFkCol
     ,dbColInfGetFkTableName
     ,dbColInfGetNumPrecRadix
     ,dbColInfGetPkCol
     ,dbColInfGetPkTableName
     ,dbColInfGetRemarks
     ,dbColInfGetSchema
     ,dbColInfGetSqlDataType
     ,dbColInfGetTableName
     ,dbColInfGetTypeName
     ,dbColInfIsNullable
     -- ** DbColInfArray
     ,dbColInfArrayDelete
     ,dbColInfArrayGetColInf
     -- ** DbConnectInf
     ,dbConnectInfAllocHenv
     ,dbConnectInfCreate
     ,dbConnectInfDelete
     ,dbConnectInfFreeHenv
     ,dbConnectInfGetHenv
     -- ** DbInf
     ,dbInfDelete
     ,dbInfGetCatalogName
     ,dbInfGetNumTables
     ,dbInfGetSchemaName
     ,dbInfGetTableInf
     -- ** DbTableInf
     ,dbTableInfGetNumCols
     ,dbTableInfGetTableName
     ,dbTableInfGetTableRemarks
     ,dbTableInfGetTableType
     -- ** Dialog
     ,dialogCreate
     ,dialogEndModal
     ,dialogGetReturnCode
     ,dialogIsModal
     ,dialogSetReturnCode
     ,dialogShowModal
     -- ** DirDialog
     ,dirDialogCreate
     ,dirDialogGetMessage
     ,dirDialogGetPath
     ,dirDialogGetStyle
     ,dirDialogSetMessage
     ,dirDialogSetPath
     ,dirDialogSetStyle
     -- ** DragImage
     ,dragImageBeginDrag
     ,dragImageBeginDragFullScreen
     ,dragImageCreate
     ,dragImageDelete
     ,dragImageEndDrag
     ,dragImageHide
     ,dragImageMove
     ,dragImageShow
     -- ** DrawControl
     ,drawControlCreate
     -- ** DrawWindow
     ,drawWindowCreate
     -- ** DropTarget
     ,dropTargetGetData
     ,dropTargetSetDataObject
     -- ** EncodingConverter
     ,encodingConverterConvert
     ,encodingConverterCreate
     ,encodingConverterDelete
     ,encodingConverterGetAllEquivalents
     ,encodingConverterGetPlatformEquivalents
     ,encodingConverterInit
     -- ** EraseEvent
     ,eraseEventCopyObject
     ,eraseEventGetDC
     -- ** Event
     ,eventCopyObject
     ,eventGetEventObject
     ,eventGetEventType
     ,eventGetId
     ,eventGetSkipped
     ,eventGetTimestamp
     ,eventIsCommandEvent
     ,eventNewEventType
     ,eventSetEventObject
     ,eventSetEventType
     ,eventSetId
     ,eventSetTimestamp
     ,eventSkip
     -- ** EvtHandler
     ,evtHandlerAddPendingEvent
     ,evtHandlerConnect
     ,evtHandlerCreate
     ,evtHandlerDelete
     ,evtHandlerDisconnect
     ,evtHandlerGetClientClosure
     ,evtHandlerGetClosure
     ,evtHandlerGetEvtHandlerEnabled
     ,evtHandlerGetNextHandler
     ,evtHandlerGetPreviousHandler
     ,evtHandlerProcessEvent
     ,evtHandlerProcessPendingEvents
     ,evtHandlerSetClientClosure
     ,evtHandlerSetEvtHandlerEnabled
     ,evtHandlerSetNextHandler
     ,evtHandlerSetPreviousHandler
     -- ** FileConfig
     ,fileConfigCreate
     -- ** FileDialog
     ,fileDialogCreate
     ,fileDialogGetDirectory
     ,fileDialogGetFilename
     ,fileDialogGetFilenames
     ,fileDialogGetFilterIndex
     ,fileDialogGetMessage
     ,fileDialogGetPath
     ,fileDialogGetPaths
     ,fileDialogGetStyle
     ,fileDialogGetWildcard
     ,fileDialogSetDirectory
     ,fileDialogSetFilename
     ,fileDialogSetFilterIndex
     ,fileDialogSetMessage
     ,fileDialogSetPath
     ,fileDialogSetStyle
     ,fileDialogSetWildcard
     -- ** FileHistory
     ,fileHistoryAddFileToHistory
     ,fileHistoryAddFilesToMenu
     ,fileHistoryCreate
     ,fileHistoryDelete
     ,fileHistoryGetCount
     ,fileHistoryGetHistoryFile
     ,fileHistoryGetMaxFiles
     ,fileHistoryGetMenus
     ,fileHistoryLoad
     ,fileHistoryRemoveFileFromHistory
     ,fileHistoryRemoveMenu
     ,fileHistorySave
     ,fileHistoryUseMenu
     -- ** FileType
     ,fileTypeDelete
     ,fileTypeExpandCommand
     ,fileTypeGetDescription
     ,fileTypeGetExtensions
     ,fileTypeGetIcon
     ,fileTypeGetMimeType
     ,fileTypeGetMimeTypes
     ,fileTypeGetOpenCommand
     ,fileTypeGetPrintCommand
     -- ** FindDialogEvent
     ,findDialogEventGetFindString
     ,findDialogEventGetFlags
     ,findDialogEventGetReplaceString
     -- ** FindReplaceData
     ,findReplaceDataCreate
     ,findReplaceDataCreateDefault
     ,findReplaceDataDelete
     ,findReplaceDataGetFindString
     ,findReplaceDataGetFlags
     ,findReplaceDataGetReplaceString
     ,findReplaceDataSetFindString
     ,findReplaceDataSetFlags
     ,findReplaceDataSetReplaceString
     -- ** FindReplaceDialog
     ,findReplaceDialogCreate
     ,findReplaceDialogGetData
     ,findReplaceDialogSetData
     -- ** FlexGridSizer
     ,flexGridSizerAddGrowableCol
     ,flexGridSizerAddGrowableRow
     ,flexGridSizerCalcMin
     ,flexGridSizerCreate
     ,flexGridSizerRecalcSizes
     ,flexGridSizerRemoveGrowableCol
     ,flexGridSizerRemoveGrowableRow
     -- ** Font
     ,fontCreate
     ,fontCreateDefault
     ,fontCreateFromStock
     ,fontDelete
     ,fontGetDefaultEncoding
     ,fontGetEncoding
     ,fontGetFaceName
     ,fontGetFamily
     ,fontGetFamilyString
     ,fontGetPointSize
     ,fontGetStyle
     ,fontGetStyleString
     ,fontGetUnderlined
     ,fontGetWeight
     ,fontGetWeightString
     ,fontIsOk
     ,fontIsStatic
     ,fontSafeDelete
     ,fontSetDefaultEncoding
     ,fontSetEncoding
     ,fontSetFaceName
     ,fontSetFamily
     ,fontSetPointSize
     ,fontSetStyle
     ,fontSetUnderlined
     ,fontSetWeight
     -- ** FontData
     ,fontDataCreate
     ,fontDataDelete
     ,fontDataEnableEffects
     ,fontDataGetAllowSymbols
     ,fontDataGetChosenFont
     ,fontDataGetColour
     ,fontDataGetEnableEffects
     ,fontDataGetEncoding
     ,fontDataGetInitialFont
     ,fontDataGetShowHelp
     ,fontDataSetAllowSymbols
     ,fontDataSetChosenFont
     ,fontDataSetColour
     ,fontDataSetEncoding
     ,fontDataSetInitialFont
     ,fontDataSetRange
     ,fontDataSetShowHelp
     -- ** FontDialog
     ,fontDialogCreate
     ,fontDialogGetFontData
     -- ** FontEnumerator
     ,fontEnumeratorCreate
     ,fontEnumeratorDelete
     ,fontEnumeratorEnumerateEncodings
     ,fontEnumeratorEnumerateFacenames
     -- ** FontMapper
     ,fontMapperCreate
     ,fontMapperGetAltForEncoding
     ,fontMapperIsEncodingAvailable
     -- ** Frame
     ,frameCentre
     ,frameCreate
     ,frameCreateStatusBar
     ,frameCreateToolBar
     ,frameGetClientAreaOriginleft
     ,frameGetClientAreaOrigintop
     ,frameGetMenuBar
     ,frameGetStatusBar
     ,frameGetTitle
     ,frameGetToolBar
     ,frameIsFullScreen
     ,frameRestore
     ,frameSetMenuBar
     ,frameSetShape
     ,frameSetStatusBar
     ,frameSetStatusText
     ,frameSetStatusWidths
     ,frameSetTitle
     ,frameSetToolBar
     ,frameShowFullScreen
     -- ** Gauge
     ,gaugeCreate
     ,gaugeGetBezelFace
     ,gaugeGetRange
     ,gaugeGetShadowWidth
     ,gaugeGetValue
     ,gaugeSetBezelFace
     ,gaugeSetRange
     ,gaugeSetShadowWidth
     ,gaugeSetValue
     -- ** GenericDragImage
     ,genericDragImageCreate
     ,genericDragImageDoDrawImage
     ,genericDragImageGetImageRect
     ,genericDragImageUpdateBackingFromWindow
     -- ** GraphicsBrush
     ,graphicsBrushCreate
     ,graphicsBrushDelete
     -- ** GraphicsContext
     ,graphicsContextClip
     ,graphicsContextClipByRectangle
     ,graphicsContextConcatTransform
     ,graphicsContextCreate
     ,graphicsContextCreateFromNative
     ,graphicsContextCreateFromNativeWindow
     ,graphicsContextCreateFromWindow
     ,graphicsContextDelete
     ,graphicsContextDrawBitmap
     ,graphicsContextDrawEllipse
     ,graphicsContextDrawIcon
     ,graphicsContextDrawLines
     ,graphicsContextDrawPath
     ,graphicsContextDrawRectangle
     ,graphicsContextDrawRoundedRectangle
     ,graphicsContextDrawText
     ,graphicsContextDrawTextWithAngle
     ,graphicsContextFillPath
     ,graphicsContextGetNativeContext
     ,graphicsContextGetTextExtent
     ,graphicsContextResetClip
     ,graphicsContextRotate
     ,graphicsContextScale
     ,graphicsContextSetBrush
     ,graphicsContextSetFont
     ,graphicsContextSetGraphicsBrush
     ,graphicsContextSetGraphicsFont
     ,graphicsContextSetGraphicsPen
     ,graphicsContextSetPen
     ,graphicsContextSetTransform
     ,graphicsContextStrokeLine
     ,graphicsContextStrokeLines
     ,graphicsContextStrokePath
     ,graphicsContextTranslate
     -- ** GraphicsFont
     ,graphicsFontCreate
     ,graphicsFontDelete
     -- ** GraphicsMatrix
     ,graphicsMatrixConcat
     ,graphicsMatrixCreate
     ,graphicsMatrixDelete
     ,graphicsMatrixGet
     ,graphicsMatrixGetNativeMatrix
     ,graphicsMatrixInvert
     ,graphicsMatrixIsEqual
     ,graphicsMatrixIsIdentity
     ,graphicsMatrixRotate
     ,graphicsMatrixScale
     ,graphicsMatrixSet
     ,graphicsMatrixTransformDistance
     ,graphicsMatrixTransformPoint
     ,graphicsMatrixTranslate
     -- ** GraphicsObject
     ,graphicsObjectGetRenderer
     ,graphicsObjectIsNull
     -- ** GraphicsPath
     ,graphicsPathAddArc
     ,graphicsPathAddArcToPoint
     ,graphicsPathAddCircle
     ,graphicsPathAddCurveToPoint
     ,graphicsPathAddEllipse
     ,graphicsPathAddLineToPoint
     ,graphicsPathAddPath
     ,graphicsPathAddQuadCurveToPoint
     ,graphicsPathAddRectangle
     ,graphicsPathAddRoundedRectangle
     ,graphicsPathCloseSubpath
     ,graphicsPathContains
     ,graphicsPathCreate
     ,graphicsPathDelete
     ,graphicsPathGetBox
     ,graphicsPathGetCurrentPoint
     ,graphicsPathGetNativePath
     ,graphicsPathMoveToPoint
     ,graphicsPathTransform
     ,graphicsPathUnGetNativePath
     -- ** GraphicsPen
     ,graphicsPenCreate
     ,graphicsPenDelete
     -- ** GraphicsRenderer
     ,graphicsRendererCreateContext
     ,graphicsRendererCreateContextFromNativeContext
     ,graphicsRendererCreateContextFromNativeWindow
     ,graphicsRendererCreateContextFromWindow
     ,graphicsRendererDelete
     ,graphicsRendererGetDefaultRenderer
     -- ** Grid
     ,gridAppendCols
     ,gridAppendRows
     ,gridAutoSize
     ,gridAutoSizeColumn
     ,gridAutoSizeColumns
     ,gridAutoSizeRow
     ,gridAutoSizeRows
     ,gridBeginBatch
     ,gridBlockToDeviceRect
     ,gridCalcCellsExposed
     ,gridCalcColLabelsExposed
     ,gridCalcRowLabelsExposed
     ,gridCanDragColSize
     ,gridCanDragGridSize
     ,gridCanDragRowSize
     ,gridCanEnableCellControl
     ,gridCellToRect
     ,gridClearGrid
     ,gridClearSelection
     ,gridCreate
     ,gridCreateGrid
     ,gridDeleteCols
     ,gridDeleteRows
     ,gridDisableCellEditControl
     ,gridDisableDragColSize
     ,gridDisableDragGridSize
     ,gridDisableDragRowSize
     ,gridDoEndDragResizeCol
     ,gridDoEndDragResizeRow
     ,gridDrawAllGridLines
     ,gridDrawCell
     ,gridDrawCellBorder
     ,gridDrawCellHighlight
     ,gridDrawColLabel
     ,gridDrawColLabels
     ,gridDrawGridCellArea
     ,gridDrawGridSpace
     ,gridDrawHighlight
     ,gridDrawRowLabel
     ,gridDrawRowLabels
     ,gridDrawTextRectangle
     ,gridEnableCellEditControl
     ,gridEnableDragColSize
     ,gridEnableDragGridSize
     ,gridEnableDragRowSize
     ,gridEnableEditing
     ,gridEnableGridLines
     ,gridEndBatch
     ,gridGetBatchCount
     ,gridGetCellAlignment
     ,gridGetCellBackgroundColour
     ,gridGetCellEditor
     ,gridGetCellFont
     ,gridGetCellHighlightColour
     ,gridGetCellRenderer
     ,gridGetCellTextColour
     ,gridGetCellValue
     ,gridGetColLabelAlignment
     ,gridGetColLabelSize
     ,gridGetColLabelValue
     ,gridGetColSize
     ,gridGetDefaultCellAlignment
     ,gridGetDefaultCellBackgroundColour
     ,gridGetDefaultCellFont
     ,gridGetDefaultCellTextColour
     ,gridGetDefaultColLabelSize
     ,gridGetDefaultColSize
     ,gridGetDefaultEditor
     ,gridGetDefaultEditorForCell
     ,gridGetDefaultEditorForType
     ,gridGetDefaultRenderer
     ,gridGetDefaultRendererForCell
     ,gridGetDefaultRendererForType
     ,gridGetDefaultRowLabelSize
     ,gridGetDefaultRowSize
     ,gridGetGridCursorCol
     ,gridGetGridCursorRow
     ,gridGetGridLineColour
     ,gridGetLabelBackgroundColour
     ,gridGetLabelFont
     ,gridGetLabelTextColour
     ,gridGetNumberCols
     ,gridGetNumberRows
     ,gridGetRowLabelAlignment
     ,gridGetRowLabelSize
     ,gridGetRowLabelValue
     ,gridGetRowSize
     ,gridGetSelectedCells
     ,gridGetSelectedCols
     ,gridGetSelectedRows
     ,gridGetSelectionBackground
     ,gridGetSelectionBlockBottomRight
     ,gridGetSelectionBlockTopLeft
     ,gridGetSelectionForeground
     ,gridGetTable
     ,gridGetTextBoxSize
     ,gridGridLinesEnabled
     ,gridHideCellEditControl
     ,gridInsertCols
     ,gridInsertRows
     ,gridIsCellEditControlEnabled
     ,gridIsCellEditControlShown
     ,gridIsCurrentCellReadOnly
     ,gridIsEditable
     ,gridIsInSelection
     ,gridIsReadOnly
     ,gridIsSelection
     ,gridIsVisible
     ,gridMakeCellVisible
     ,gridMoveCursorDown
     ,gridMoveCursorDownBlock
     ,gridMoveCursorLeft
     ,gridMoveCursorLeftBlock
     ,gridMoveCursorRight
     ,gridMoveCursorRightBlock
     ,gridMoveCursorUp
     ,gridMoveCursorUpBlock
     ,gridMovePageDown
     ,gridMovePageUp
     ,gridNewCalcCellsExposed
     ,gridNewDrawGridCellArea
     ,gridNewDrawHighlight
     ,gridProcessColLabelMouseEvent
     ,gridProcessCornerLabelMouseEvent
     ,gridProcessGridCellMouseEvent
     ,gridProcessRowLabelMouseEvent
     ,gridProcessTableMessage
     ,gridRegisterDataType
     ,gridSaveEditControlValue
     ,gridSelectAll
     ,gridSelectBlock
     ,gridSelectCol
     ,gridSelectRow
     ,gridSetCellAlignment
     ,gridSetCellBackgroundColour
     ,gridSetCellEditor
     ,gridSetCellFont
     ,gridSetCellHighlightColour
     ,gridSetCellRenderer
     ,gridSetCellTextColour
     ,gridSetCellValue
     ,gridSetColAttr
     ,gridSetColFormatBool
     ,gridSetColFormatCustom
     ,gridSetColFormatFloat
     ,gridSetColFormatNumber
     ,gridSetColLabelAlignment
     ,gridSetColLabelSize
     ,gridSetColLabelValue
     ,gridSetColMinimalWidth
     ,gridSetColSize
     ,gridSetDefaultCellAlignment
     ,gridSetDefaultCellBackgroundColour
     ,gridSetDefaultCellFont
     ,gridSetDefaultCellTextColour
     ,gridSetDefaultColSize
     ,gridSetDefaultEditor
     ,gridSetDefaultRenderer
     ,gridSetDefaultRowSize
     ,gridSetGridCursor
     ,gridSetGridLineColour
     ,gridSetLabelBackgroundColour
     ,gridSetLabelFont
     ,gridSetLabelTextColour
     ,gridSetMargins
     ,gridSetReadOnly
     ,gridSetRowAttr
     ,gridSetRowLabelAlignment
     ,gridSetRowLabelSize
     ,gridSetRowLabelValue
     ,gridSetRowMinimalHeight
     ,gridSetRowSize
     ,gridSetSelectionBackground
     ,gridSetSelectionForeground
     ,gridSetSelectionMode
     ,gridSetTable
     ,gridShowCellEditControl
     ,gridStringToLines
     ,gridXToCol
     ,gridXToEdgeOfCol
     ,gridXYToCell
     ,gridYToEdgeOfRow
     ,gridYToRow
     -- ** GridCellAttr
     ,gridCellAttrCtor
     ,gridCellAttrDecRef
     ,gridCellAttrGetAlignment
     ,gridCellAttrGetBackgroundColour
     ,gridCellAttrGetEditor
     ,gridCellAttrGetFont
     ,gridCellAttrGetRenderer
     ,gridCellAttrGetTextColour
     ,gridCellAttrHasAlignment
     ,gridCellAttrHasBackgroundColour
     ,gridCellAttrHasEditor
     ,gridCellAttrHasFont
     ,gridCellAttrHasRenderer
     ,gridCellAttrHasTextColour
     ,gridCellAttrIncRef
     ,gridCellAttrIsReadOnly
     ,gridCellAttrSetAlignment
     ,gridCellAttrSetBackgroundColour
     ,gridCellAttrSetDefAttr
     ,gridCellAttrSetEditor
     ,gridCellAttrSetFont
     ,gridCellAttrSetReadOnly
     ,gridCellAttrSetRenderer
     ,gridCellAttrSetTextColour
     -- ** GridCellBoolEditor
     ,gridCellBoolEditorCtor
     -- ** GridCellChoiceEditor
     ,gridCellChoiceEditorCtor
     -- ** GridCellCoordsArray
     ,gridCellCoordsArrayCreate
     ,gridCellCoordsArrayDelete
     ,gridCellCoordsArrayGetCount
     ,gridCellCoordsArrayItem
     -- ** GridCellEditor
     ,gridCellEditorBeginEdit
     ,gridCellEditorCreate
     ,gridCellEditorDestroy
     ,gridCellEditorEndEdit
     ,gridCellEditorGetControl
     ,gridCellEditorHandleReturn
     ,gridCellEditorIsAcceptedKey
     ,gridCellEditorIsCreated
     ,gridCellEditorPaintBackground
     ,gridCellEditorReset
     ,gridCellEditorSetControl
     ,gridCellEditorSetParameters
     ,gridCellEditorSetSize
     ,gridCellEditorShow
     ,gridCellEditorStartingClick
     ,gridCellEditorStartingKey
     -- ** GridCellFloatEditor
     ,gridCellFloatEditorCtor
     -- ** GridCellNumberEditor
     ,gridCellNumberEditorCtor
     -- ** GridCellTextEditor
     ,gridCellTextEditorCtor
     -- ** GridCellTextEnterEditor
     ,gridCellTextEnterEditorCtor
     -- ** GridEditorCreatedEvent
     ,gridEditorCreatedEventGetCol
     ,gridEditorCreatedEventGetControl
     ,gridEditorCreatedEventGetRow
     ,gridEditorCreatedEventSetCol
     ,gridEditorCreatedEventSetControl
     ,gridEditorCreatedEventSetRow
     -- ** GridEvent
     ,gridEventAltDown
     ,gridEventControlDown
     ,gridEventGetCol
     ,gridEventGetPosition
     ,gridEventGetRow
     ,gridEventMetaDown
     ,gridEventSelecting
     ,gridEventShiftDown
     -- ** GridRangeSelectEvent
     ,gridRangeSelectEventAltDown
     ,gridRangeSelectEventControlDown
     ,gridRangeSelectEventGetBottomRightCoords
     ,gridRangeSelectEventGetBottomRow
     ,gridRangeSelectEventGetLeftCol
     ,gridRangeSelectEventGetRightCol
     ,gridRangeSelectEventGetTopLeftCoords
     ,gridRangeSelectEventGetTopRow
     ,gridRangeSelectEventMetaDown
     ,gridRangeSelectEventSelecting
     ,gridRangeSelectEventShiftDown
     -- ** GridSizeEvent
     ,gridSizeEventAltDown
     ,gridSizeEventControlDown
     ,gridSizeEventGetPosition
     ,gridSizeEventGetRowOrCol
     ,gridSizeEventMetaDown
     ,gridSizeEventShiftDown
     -- ** GridSizer
     ,gridSizerCalcMin
     ,gridSizerCreate
     ,gridSizerGetCols
     ,gridSizerGetHGap
     ,gridSizerGetRows
     ,gridSizerGetVGap
     ,gridSizerRecalcSizes
     ,gridSizerSetCols
     ,gridSizerSetHGap
     ,gridSizerSetRows
     ,gridSizerSetVGap
     -- ** HelpControllerHelpProvider
     ,helpControllerHelpProviderCreate
     ,helpControllerHelpProviderGetHelpController
     ,helpControllerHelpProviderSetHelpController
     -- ** HelpEvent
     ,helpEventGetLink
     ,helpEventGetPosition
     ,helpEventGetTarget
     ,helpEventSetLink
     ,helpEventSetPosition
     ,helpEventSetTarget
     -- ** HelpProvider
     ,helpProviderAddHelp
     ,helpProviderAddHelpById
     ,helpProviderDelete
     ,helpProviderGet
     ,helpProviderGetHelp
     ,helpProviderRemoveHelp
     ,helpProviderSet
     ,helpProviderShowHelp
     -- ** HtmlHelpController
     ,htmlHelpControllerAddBook
     ,htmlHelpControllerCreate
     ,htmlHelpControllerDelete
     ,htmlHelpControllerDisplay
     ,htmlHelpControllerDisplayBlock
     ,htmlHelpControllerDisplayContents
     ,htmlHelpControllerDisplayIndex
     ,htmlHelpControllerDisplayNumber
     ,htmlHelpControllerDisplaySection
     ,htmlHelpControllerDisplaySectionNumber
     ,htmlHelpControllerGetFrame
     ,htmlHelpControllerGetFrameParameters
     ,htmlHelpControllerInitialize
     ,htmlHelpControllerKeywordSearch
     ,htmlHelpControllerLoadFile
     ,htmlHelpControllerQuit
     ,htmlHelpControllerReadCustomization
     ,htmlHelpControllerSetFrameParameters
     ,htmlHelpControllerSetTempDir
     ,htmlHelpControllerSetTitleFormat
     ,htmlHelpControllerSetViewer
     ,htmlHelpControllerUseConfig
     ,htmlHelpControllerWriteCustomization
     -- ** HtmlWindow
     ,htmlWindowAppendToPage
     ,htmlWindowCreate
     ,htmlWindowGetInternalRepresentation
     ,htmlWindowGetOpenedAnchor
     ,htmlWindowGetOpenedPage
     ,htmlWindowGetOpenedPageTitle
     ,htmlWindowGetRelatedFrame
     ,htmlWindowHistoryBack
     ,htmlWindowHistoryCanBack
     ,htmlWindowHistoryCanForward
     ,htmlWindowHistoryClear
     ,htmlWindowHistoryForward
     ,htmlWindowLoadPage
     ,htmlWindowReadCustomization
     ,htmlWindowSetBorders
     ,htmlWindowSetFonts
     ,htmlWindowSetPage
     ,htmlWindowSetRelatedFrame
     ,htmlWindowSetRelatedStatusBar
     ,htmlWindowWriteCustomization
     -- ** Icon
     ,iconAssign
     ,iconCopyFromBitmap
     ,iconCreateDefault
     ,iconCreateLoad
     ,iconDelete
     ,iconFromRaw
     ,iconFromXPM
     ,iconGetDepth
     ,iconGetHeight
     ,iconGetWidth
     ,iconIsEqual
     ,iconIsOk
     ,iconIsStatic
     ,iconLoad
     ,iconSafeDelete
     ,iconSetDepth
     ,iconSetHeight
     ,iconSetWidth
     -- ** IconBundle
     ,iconBundleAddIcon
     ,iconBundleAddIconFromFile
     ,iconBundleCreateDefault
     ,iconBundleCreateFromFile
     ,iconBundleCreateFromIcon
     ,iconBundleDelete
     ,iconBundleGetIcon
     -- ** IdleEvent
     ,idleEventCopyObject
     ,idleEventMoreRequested
     ,idleEventRequestMore
     -- ** Image
     ,imageCanRead
     ,imageConvertToBitmap
     ,imageConvertToByteString
     ,imageConvertToLazyByteString
     ,imageCountColours
     ,imageCreateDefault
     ,imageCreateFromBitmap
     ,imageCreateFromByteString
     ,imageCreateFromData
     ,imageCreateFromDataEx
     ,imageCreateFromFile
     ,imageCreateFromLazyByteString
     ,imageCreateSized
     ,imageDelete
     ,imageDestroy
     ,imageGetBlue
     ,imageGetData
     ,imageGetGreen
     ,imageGetHeight
     ,imageGetMaskBlue
     ,imageGetMaskGreen
     ,imageGetMaskRed
     ,imageGetOption
     ,imageGetOptionInt
     ,imageGetRed
     ,imageGetSubImage
     ,imageGetWidth
     ,imageHasMask
     ,imageHasOption
     ,imageInitialize
     ,imageInitializeFromData
     ,imageIsOk
     ,imageLoadFile
     ,imageMirror
     ,imagePaste
     ,imageReplace
     ,imageRescale
     ,imageRotate
     ,imageRotate90
     ,imageSaveFile
     ,imageScale
     ,imageSetData
     ,imageSetDataAndSize
     ,imageSetMask
     ,imageSetMaskColour
     ,imageSetOption
     ,imageSetOptionInt
     ,imageSetRGB
     -- ** ImageList
     ,imageListAddBitmap
     ,imageListAddIcon
     ,imageListAddMasked
     ,imageListCreate
     ,imageListDelete
     ,imageListDraw
     ,imageListGetImageCount
     ,imageListGetSize
     ,imageListRemove
     ,imageListRemoveAll
     ,imageListReplace
     ,imageListReplaceIcon
     -- ** IndividualLayoutConstraint
     ,individualLayoutConstraintAbove
     ,individualLayoutConstraintAbsolute
     ,individualLayoutConstraintAsIs
     ,individualLayoutConstraintBelow
     ,individualLayoutConstraintGetDone
     ,individualLayoutConstraintGetEdge
     ,individualLayoutConstraintGetMargin
     ,individualLayoutConstraintGetMyEdge
     ,individualLayoutConstraintGetOtherEdge
     ,individualLayoutConstraintGetOtherWindow
     ,individualLayoutConstraintGetPercent
     ,individualLayoutConstraintGetRelationship
     ,individualLayoutConstraintGetValue
     ,individualLayoutConstraintLeftOf
     ,individualLayoutConstraintPercentOf
     ,individualLayoutConstraintResetIfWin
     ,individualLayoutConstraintRightOf
     ,individualLayoutConstraintSameAs
     ,individualLayoutConstraintSatisfyConstraint
     ,individualLayoutConstraintSet
     ,individualLayoutConstraintSetDone
     ,individualLayoutConstraintSetEdge
     ,individualLayoutConstraintSetMargin
     ,individualLayoutConstraintSetRelationship
     ,individualLayoutConstraintSetValue
     ,individualLayoutConstraintUnconstrained
     -- ** InputSink
     ,inputSinkCreate
     ,inputSinkGetId
     ,inputSinkStart
     -- ** InputSinkEvent
     ,inputSinkEventLastError
     ,inputSinkEventLastInput
     ,inputSinkEventLastRead
     -- ** InputStream
     ,inputStreamCanRead
     ,inputStreamDelete
     ,inputStreamEof
     ,inputStreamGetC
     ,inputStreamLastRead
     ,inputStreamPeek
     ,inputStreamRead
     ,inputStreamSeekI
     ,inputStreamTell
     ,inputStreamUngetBuffer
     ,inputStreamUngetch
     -- ** KeyEvent
     ,keyEventAltDown
     ,keyEventControlDown
     ,keyEventCopyObject
     ,keyEventGetKeyCode
     ,keyEventGetModifiers
     ,keyEventGetPosition
     ,keyEventGetX
     ,keyEventGetY
     ,keyEventHasModifiers
     ,keyEventMetaDown
     ,keyEventSetKeyCode
     ,keyEventShiftDown
     -- ** LayoutAlgorithm
     ,layoutAlgorithmCreate
     ,layoutAlgorithmDelete
     ,layoutAlgorithmLayoutFrame
     ,layoutAlgorithmLayoutMDIFrame
     ,layoutAlgorithmLayoutWindow
     -- ** LayoutConstraints
     ,layoutConstraintsCreate
     ,layoutConstraintsbottom
     ,layoutConstraintscentreX
     ,layoutConstraintscentreY
     ,layoutConstraintsheight
     ,layoutConstraintsleft
     ,layoutConstraintsright
     ,layoutConstraintstop
     ,layoutConstraintswidth
     -- ** ListBox
     ,listBoxAppend
     ,listBoxAppendData
     ,listBoxClear
     ,listBoxCreate
     ,listBoxDelete
     ,listBoxFindString
     ,listBoxGetClientData
     ,listBoxGetCount
     ,listBoxGetSelection
     ,listBoxGetSelections
     ,listBoxGetString
     ,listBoxInsertItems
     ,listBoxIsSelected
     ,listBoxSetClientData
     ,listBoxSetFirstItem
     ,listBoxSetSelection
     ,listBoxSetString
     ,listBoxSetStringSelection
     -- ** ListCtrl
     ,listCtrlArrange
     ,listCtrlAssignImageList
     ,listCtrlClearAll
     ,listCtrlCreate
     ,listCtrlDeleteAllColumns
     ,listCtrlDeleteAllItems
     ,listCtrlDeleteColumn
     ,listCtrlDeleteItem
     ,listCtrlEditLabel
     ,listCtrlEndEditLabel
     ,listCtrlEnsureVisible
     ,listCtrlFindItem
     ,listCtrlFindItemByData
     ,listCtrlFindItemByPosition
     ,listCtrlGetColumn
     ,listCtrlGetColumn2
     ,listCtrlGetColumnCount
     ,listCtrlGetColumnWidth
     ,listCtrlGetCountPerPage
     ,listCtrlGetEditControl
     ,listCtrlGetImageList
     ,listCtrlGetItem
     ,listCtrlGetItem2
     ,listCtrlGetItemCount
     ,listCtrlGetItemData
     ,listCtrlGetItemPosition
     ,listCtrlGetItemPosition2
     ,listCtrlGetItemRect
     ,listCtrlGetItemSpacing
     ,listCtrlGetItemState
     ,listCtrlGetItemText
     ,listCtrlGetNextItem
     ,listCtrlGetSelectedItemCount
     ,listCtrlGetTextColour
     ,listCtrlGetTopItem
     ,listCtrlHitTest
     ,listCtrlInsertColumn
     ,listCtrlInsertColumnFromInfo
     ,listCtrlInsertItem
     ,listCtrlInsertItemWithData
     ,listCtrlInsertItemWithImage
     ,listCtrlInsertItemWithLabel
     ,listCtrlScrollList
     ,listCtrlSetBackgroundColour
     ,listCtrlSetColumn
     ,listCtrlSetColumnWidth
     ,listCtrlSetForegroundColour
     ,listCtrlSetImageList
     ,listCtrlSetItem
     ,listCtrlSetItemData
     ,listCtrlSetItemFromInfo
     ,listCtrlSetItemImage
     ,listCtrlSetItemPosition
     ,listCtrlSetItemState
     ,listCtrlSetItemText
     ,listCtrlSetSingleStyle
     ,listCtrlSetTextColour
     ,listCtrlSetWindowStyleFlag
     ,listCtrlSortItems
     ,listCtrlSortItems2
     ,listCtrlUpdateStyle
     -- ** ListEvent
     ,listEventCancelled
     ,listEventGetCacheFrom
     ,listEventGetCacheTo
     ,listEventGetCode
     ,listEventGetColumn
     ,listEventGetData
     ,listEventGetImage
     ,listEventGetIndex
     ,listEventGetItem
     ,listEventGetLabel
     ,listEventGetMask
     ,listEventGetPoint
     ,listEventGetText
     -- ** ListItem
     ,listItemClear
     ,listItemClearAttributes
     ,listItemCreate
     ,listItemDelete
     ,listItemGetAlign
     ,listItemGetAttributes
     ,listItemGetBackgroundColour
     ,listItemGetColumn
     ,listItemGetData
     ,listItemGetFont
     ,listItemGetId
     ,listItemGetImage
     ,listItemGetMask
     ,listItemGetState
     ,listItemGetText
     ,listItemGetTextColour
     ,listItemGetWidth
     ,listItemHasAttributes
     ,listItemSetAlign
     ,listItemSetBackgroundColour
     ,listItemSetColumn
     ,listItemSetData
     ,listItemSetDataPointer
     ,listItemSetFont
     ,listItemSetId
     ,listItemSetImage
     ,listItemSetMask
     ,listItemSetState
     ,listItemSetStateMask
     ,listItemSetText
     ,listItemSetTextColour
     ,listItemSetWidth
     -- ** Locale
     ,localeAddCatalog
     ,localeAddCatalogLookupPathPrefix
     ,localeCreate
     ,localeDelete
     ,localeGetLocale
     ,localeGetName
     ,localeGetString
     ,localeIsLoaded
     ,localeIsOk
     -- ** Log
     ,logAddTraceMask
     ,logDelete
     ,logDontCreateOnDemand
     ,logFlush
     ,logFlushActive
     ,logGetActiveTarget
     ,logGetTimestamp
     ,logGetTraceMask
     ,logGetVerbose
     ,logHasPendingMessages
     ,logIsAllowedTraceMask
     ,logOnLog
     ,logRemoveTraceMask
     ,logResume
     ,logSetActiveTarget
     ,logSetTimestamp
     ,logSetTraceMask
     ,logSetVerbose
     ,logSuspend
     -- ** LogChain
     ,logChainCreate
     ,logChainDelete
     ,logChainGetOldLog
     ,logChainIsPassingMessages
     ,logChainPassMessages
     ,logChainSetLog
     -- ** LogNull
     ,logNullCreate
     -- ** LogStderr
     ,logStderrCreate
     ,logStderrCreateStdOut
     -- ** LogTextCtrl
     ,logTextCtrlCreate
     -- ** LogWindow
     ,logWindowCreate
     ,logWindowGetFrame
    ) where

import qualified Data.ByteString as B (ByteString, useAsCStringLen)
import qualified Data.ByteString.Lazy as LB (ByteString, length, unpack)
import System.IO.Unsafe( unsafePerformIO )
import Graphics.UI.WXCore.WxcTypes
import Graphics.UI.WXCore.WxcClassTypes

versionWxcClassesAL :: String
versionWxcClassesAL  = "2010-09-10 18:28:55.718581 UTC"

-- | usage: (@acceleratorEntryCreate flags keyCode cmd@).
acceleratorEntryCreate :: Int -> Int -> Int ->  IO (AcceleratorEntry  ())
acceleratorEntryCreate flags keyCode cmd 
  = withObjectResult $
    wxAcceleratorEntry_Create (toCInt flags)  (toCInt keyCode)  (toCInt cmd)  
foreign import ccall "wxAcceleratorEntry_Create" wxAcceleratorEntry_Create :: CInt -> CInt -> CInt -> IO (Ptr (TAcceleratorEntry ()))

-- | usage: (@acceleratorEntryDelete obj@).
acceleratorEntryDelete :: AcceleratorEntry  a ->  IO ()
acceleratorEntryDelete _obj 
  = withObjectRef "acceleratorEntryDelete" _obj $ \cobj__obj -> 
    wxAcceleratorEntry_Delete cobj__obj  
foreign import ccall "wxAcceleratorEntry_Delete" wxAcceleratorEntry_Delete :: Ptr (TAcceleratorEntry a) -> IO ()

-- | usage: (@acceleratorEntryGetCommand obj@).
acceleratorEntryGetCommand :: AcceleratorEntry  a ->  IO Int
acceleratorEntryGetCommand _obj 
  = withIntResult $
    withObjectRef "acceleratorEntryGetCommand" _obj $ \cobj__obj -> 
    wxAcceleratorEntry_GetCommand cobj__obj  
foreign import ccall "wxAcceleratorEntry_GetCommand" wxAcceleratorEntry_GetCommand :: Ptr (TAcceleratorEntry a) -> IO CInt

-- | usage: (@acceleratorEntryGetFlags obj@).
acceleratorEntryGetFlags :: AcceleratorEntry  a ->  IO Int
acceleratorEntryGetFlags _obj 
  = withIntResult $
    withObjectRef "acceleratorEntryGetFlags" _obj $ \cobj__obj -> 
    wxAcceleratorEntry_GetFlags cobj__obj  
foreign import ccall "wxAcceleratorEntry_GetFlags" wxAcceleratorEntry_GetFlags :: Ptr (TAcceleratorEntry a) -> IO CInt

-- | usage: (@acceleratorEntryGetKeyCode obj@).
acceleratorEntryGetKeyCode :: AcceleratorEntry  a ->  IO Int
acceleratorEntryGetKeyCode _obj 
  = withIntResult $
    withObjectRef "acceleratorEntryGetKeyCode" _obj $ \cobj__obj -> 
    wxAcceleratorEntry_GetKeyCode cobj__obj  
foreign import ccall "wxAcceleratorEntry_GetKeyCode" wxAcceleratorEntry_GetKeyCode :: Ptr (TAcceleratorEntry a) -> IO CInt

-- | usage: (@acceleratorEntrySet obj flags keyCode cmd@).
acceleratorEntrySet :: AcceleratorEntry  a -> Int -> Int -> Int ->  IO ()
acceleratorEntrySet _obj flags keyCode cmd 
  = withObjectRef "acceleratorEntrySet" _obj $ \cobj__obj -> 
    wxAcceleratorEntry_Set cobj__obj  (toCInt flags)  (toCInt keyCode)  (toCInt cmd)  
foreign import ccall "wxAcceleratorEntry_Set" wxAcceleratorEntry_Set :: Ptr (TAcceleratorEntry a) -> CInt -> CInt -> CInt -> IO ()

-- | usage: (@acceleratorTableCreate n entries@).
acceleratorTableCreate :: Int -> Ptr  b ->  IO (AcceleratorTable  ())
acceleratorTableCreate n entries 
  = withObjectResult $
    wxAcceleratorTable_Create (toCInt n)  entries  
foreign import ccall "wxAcceleratorTable_Create" wxAcceleratorTable_Create :: CInt -> Ptr  b -> IO (Ptr (TAcceleratorTable ()))

-- | usage: (@acceleratorTableDelete obj@).
acceleratorTableDelete :: AcceleratorTable  a ->  IO ()
acceleratorTableDelete _obj 
  = withObjectRef "acceleratorTableDelete" _obj $ \cobj__obj -> 
    wxAcceleratorTable_Delete cobj__obj  
foreign import ccall "wxAcceleratorTable_Delete" wxAcceleratorTable_Delete :: Ptr (TAcceleratorTable a) -> IO ()

-- | usage: (@activateEventCopyObject obj obj@).
activateEventCopyObject :: ActivateEvent  a -> Ptr  b ->  IO ()
activateEventCopyObject _obj obj 
  = withObjectRef "activateEventCopyObject" _obj $ \cobj__obj -> 
    wxActivateEvent_CopyObject cobj__obj  obj  
foreign import ccall "wxActivateEvent_CopyObject" wxActivateEvent_CopyObject :: Ptr (TActivateEvent a) -> Ptr  b -> IO ()

-- | usage: (@activateEventGetActive obj@).
activateEventGetActive :: ActivateEvent  a ->  IO Bool
activateEventGetActive _obj 
  = withBoolResult $
    withObjectRef "activateEventGetActive" _obj $ \cobj__obj -> 
    wxActivateEvent_GetActive cobj__obj  
foreign import ccall "wxActivateEvent_GetActive" wxActivateEvent_GetActive :: Ptr (TActivateEvent a) -> IO CBool

-- | usage: (@autoBufferedPaintDCCreate window@).
autoBufferedPaintDCCreate :: Window  a ->  IO (AutoBufferedPaintDC  ())
autoBufferedPaintDCCreate window 
  = withObjectResult $
    withObjectPtr window $ \cobj_window -> 
    wxAutoBufferedPaintDC_Create cobj_window  
foreign import ccall "wxAutoBufferedPaintDC_Create" wxAutoBufferedPaintDC_Create :: Ptr (TWindow a) -> IO (Ptr (TAutoBufferedPaintDC ()))

-- | usage: (@autoBufferedPaintDCDelete self@).
autoBufferedPaintDCDelete :: AutoBufferedPaintDC  a ->  IO ()
autoBufferedPaintDCDelete
  = objectDelete


-- | usage: (@bitmapAddHandler handler@).
bitmapAddHandler :: EvtHandler  a ->  IO ()
bitmapAddHandler handler 
  = withObjectPtr handler $ \cobj_handler -> 
    wxBitmap_AddHandler cobj_handler  
foreign import ccall "wxBitmap_AddHandler" wxBitmap_AddHandler :: Ptr (TEvtHandler a) -> IO ()

-- | usage: (@bitmapButtonCreate prt id bmp lfttopwdthgt stl@).
bitmapButtonCreate :: Window  a -> Id -> Bitmap  c -> Rect -> Style ->  IO (BitmapButton  ())
bitmapButtonCreate _prt _id _bmp _lfttopwdthgt _stl 
  = withObjectResult $
    withObjectPtr _prt $ \cobj__prt -> 
    withObjectPtr _bmp $ \cobj__bmp -> 
    wxBitmapButton_Create cobj__prt  (toCInt _id)  cobj__bmp  (toCIntRectX _lfttopwdthgt) (toCIntRectY _lfttopwdthgt)(toCIntRectW _lfttopwdthgt) (toCIntRectH _lfttopwdthgt)  (toCInt _stl)  
foreign import ccall "wxBitmapButton_Create" wxBitmapButton_Create :: Ptr (TWindow a) -> CInt -> Ptr (TBitmap c) -> CInt -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (TBitmapButton ()))

-- | usage: (@bitmapButtonGetBitmapDisabled obj@).
bitmapButtonGetBitmapDisabled :: BitmapButton  a ->  IO (Bitmap  ())
bitmapButtonGetBitmapDisabled _obj 
  = withRefBitmap $ \pref -> 
    withObjectRef "bitmapButtonGetBitmapDisabled" _obj $ \cobj__obj -> 
    wxBitmapButton_GetBitmapDisabled cobj__obj   pref
foreign import ccall "wxBitmapButton_GetBitmapDisabled" wxBitmapButton_GetBitmapDisabled :: Ptr (TBitmapButton a) -> Ptr (TBitmap ()) -> IO ()

-- | usage: (@bitmapButtonGetBitmapFocus obj@).
bitmapButtonGetBitmapFocus :: BitmapButton  a ->  IO (Bitmap  ())
bitmapButtonGetBitmapFocus _obj 
  = withRefBitmap $ \pref -> 
    withObjectRef "bitmapButtonGetBitmapFocus" _obj $ \cobj__obj -> 
    wxBitmapButton_GetBitmapFocus cobj__obj   pref
foreign import ccall "wxBitmapButton_GetBitmapFocus" wxBitmapButton_GetBitmapFocus :: Ptr (TBitmapButton a) -> Ptr (TBitmap ()) -> IO ()

-- | usage: (@bitmapButtonGetBitmapLabel obj@).
bitmapButtonGetBitmapLabel :: BitmapButton  a ->  IO (Bitmap  ())
bitmapButtonGetBitmapLabel _obj 
  = withRefBitmap $ \pref -> 
    withObjectRef "bitmapButtonGetBitmapLabel" _obj $ \cobj__obj -> 
    wxBitmapButton_GetBitmapLabel cobj__obj   pref
foreign import ccall "wxBitmapButton_GetBitmapLabel" wxBitmapButton_GetBitmapLabel :: Ptr (TBitmapButton a) -> Ptr (TBitmap ()) -> IO ()

-- | usage: (@bitmapButtonGetBitmapSelected obj@).
bitmapButtonGetBitmapSelected :: BitmapButton  a ->  IO (Bitmap  ())
bitmapButtonGetBitmapSelected _obj 
  = withRefBitmap $ \pref -> 
    withObjectRef "bitmapButtonGetBitmapSelected" _obj $ \cobj__obj -> 
    wxBitmapButton_GetBitmapSelected cobj__obj   pref
foreign import ccall "wxBitmapButton_GetBitmapSelected" wxBitmapButton_GetBitmapSelected :: Ptr (TBitmapButton a) -> Ptr (TBitmap ()) -> IO ()

-- | usage: (@bitmapButtonGetMarginX obj@).
bitmapButtonGetMarginX :: BitmapButton  a ->  IO Int
bitmapButtonGetMarginX _obj 
  = withIntResult $
    withObjectRef "bitmapButtonGetMarginX" _obj $ \cobj__obj -> 
    wxBitmapButton_GetMarginX cobj__obj  
foreign import ccall "wxBitmapButton_GetMarginX" wxBitmapButton_GetMarginX :: Ptr (TBitmapButton a) -> IO CInt

-- | usage: (@bitmapButtonGetMarginY obj@).
bitmapButtonGetMarginY :: BitmapButton  a ->  IO Int
bitmapButtonGetMarginY _obj 
  = withIntResult $
    withObjectRef "bitmapButtonGetMarginY" _obj $ \cobj__obj -> 
    wxBitmapButton_GetMarginY cobj__obj  
foreign import ccall "wxBitmapButton_GetMarginY" wxBitmapButton_GetMarginY :: Ptr (TBitmapButton a) -> IO CInt

-- | usage: (@bitmapButtonSetBitmapDisabled obj disabled@).
bitmapButtonSetBitmapDisabled :: BitmapButton  a -> Bitmap  b ->  IO ()
bitmapButtonSetBitmapDisabled _obj disabled 
  = withObjectRef "bitmapButtonSetBitmapDisabled" _obj $ \cobj__obj -> 
    withObjectPtr disabled $ \cobj_disabled -> 
    wxBitmapButton_SetBitmapDisabled cobj__obj  cobj_disabled  
foreign import ccall "wxBitmapButton_SetBitmapDisabled" wxBitmapButton_SetBitmapDisabled :: Ptr (TBitmapButton a) -> Ptr (TBitmap b) -> IO ()

-- | usage: (@bitmapButtonSetBitmapFocus obj focus@).
bitmapButtonSetBitmapFocus :: BitmapButton  a -> Bitmap  b ->  IO ()
bitmapButtonSetBitmapFocus _obj focus 
  = withObjectRef "bitmapButtonSetBitmapFocus" _obj $ \cobj__obj -> 
    withObjectPtr focus $ \cobj_focus -> 
    wxBitmapButton_SetBitmapFocus cobj__obj  cobj_focus  
foreign import ccall "wxBitmapButton_SetBitmapFocus" wxBitmapButton_SetBitmapFocus :: Ptr (TBitmapButton a) -> Ptr (TBitmap b) -> IO ()

-- | usage: (@bitmapButtonSetBitmapLabel obj bitmap@).
bitmapButtonSetBitmapLabel :: BitmapButton  a -> Bitmap  b ->  IO ()
bitmapButtonSetBitmapLabel _obj bitmap 
  = withObjectRef "bitmapButtonSetBitmapLabel" _obj $ \cobj__obj -> 
    withObjectPtr bitmap $ \cobj_bitmap -> 
    wxBitmapButton_SetBitmapLabel cobj__obj  cobj_bitmap  
foreign import ccall "wxBitmapButton_SetBitmapLabel" wxBitmapButton_SetBitmapLabel :: Ptr (TBitmapButton a) -> Ptr (TBitmap b) -> IO ()

-- | usage: (@bitmapButtonSetBitmapSelected obj sel@).
bitmapButtonSetBitmapSelected :: BitmapButton  a -> Bitmap  b ->  IO ()
bitmapButtonSetBitmapSelected _obj sel 
  = withObjectRef "bitmapButtonSetBitmapSelected" _obj $ \cobj__obj -> 
    withObjectPtr sel $ \cobj_sel -> 
    wxBitmapButton_SetBitmapSelected cobj__obj  cobj_sel  
foreign import ccall "wxBitmapButton_SetBitmapSelected" wxBitmapButton_SetBitmapSelected :: Ptr (TBitmapButton a) -> Ptr (TBitmap b) -> IO ()

-- | usage: (@bitmapButtonSetMargins obj xy@).
bitmapButtonSetMargins :: BitmapButton  a -> Point ->  IO ()
bitmapButtonSetMargins _obj xy 
  = withObjectRef "bitmapButtonSetMargins" _obj $ \cobj__obj -> 
    wxBitmapButton_SetMargins cobj__obj  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxBitmapButton_SetMargins" wxBitmapButton_SetMargins :: Ptr (TBitmapButton a) -> CInt -> CInt -> IO ()

-- | usage: (@bitmapCleanUpHandlers@).
bitmapCleanUpHandlers ::  IO ()
bitmapCleanUpHandlers 
  = wxBitmap_CleanUpHandlers 
foreign import ccall "wxBitmap_CleanUpHandlers" wxBitmap_CleanUpHandlers :: IO ()

-- | usage: (@bitmapCreate wxdata wxtype widthheight depth@).
bitmapCreate :: Ptr  a -> Int -> Size -> Int ->  IO (Bitmap  ())
bitmapCreate _data _type _widthheight _depth 
  = withManagedBitmapResult $
    wxBitmap_Create _data  (toCInt _type)  (toCIntSizeW _widthheight) (toCIntSizeH _widthheight)  (toCInt _depth)  
foreign import ccall "wxBitmap_Create" wxBitmap_Create :: Ptr  a -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (TBitmap ()))

-- | usage: (@bitmapCreateDefault@).
bitmapCreateDefault ::  IO (Bitmap  ())
bitmapCreateDefault 
  = withManagedBitmapResult $
    wxBitmap_CreateDefault 
foreign import ccall "wxBitmap_CreateDefault" wxBitmap_CreateDefault :: IO (Ptr (TBitmap ()))

-- | usage: (@bitmapCreateEmpty widthheight depth@).
bitmapCreateEmpty :: Size -> Int ->  IO (Bitmap  ())
bitmapCreateEmpty _widthheight _depth 
  = withManagedBitmapResult $
    wxBitmap_CreateEmpty (toCIntSizeW _widthheight) (toCIntSizeH _widthheight)  (toCInt _depth)  
foreign import ccall "wxBitmap_CreateEmpty" wxBitmap_CreateEmpty :: CInt -> CInt -> CInt -> IO (Ptr (TBitmap ()))

-- | usage: (@bitmapCreateFromImage image depth@).
bitmapCreateFromImage :: Image  a -> Int ->  IO (Bitmap  ())
bitmapCreateFromImage image depth 
  = withManagedBitmapResult $
    withObjectPtr image $ \cobj_image -> 
    wxBitmap_CreateFromImage cobj_image  (toCInt depth)  
foreign import ccall "wxBitmap_CreateFromImage" wxBitmap_CreateFromImage :: Ptr (TImage a) -> CInt -> IO (Ptr (TBitmap ()))

-- | usage: (@bitmapCreateFromXPM wxdata@).
bitmapCreateFromXPM :: Bitmap  a ->  IO (Bitmap  ())
bitmapCreateFromXPM wxdata 
  = withManagedBitmapResult $
    withObjectRef "bitmapCreateFromXPM" wxdata $ \cobj_wxdata -> 
    wxBitmap_CreateFromXPM cobj_wxdata  
foreign import ccall "wxBitmap_CreateFromXPM" wxBitmap_CreateFromXPM :: Ptr (TBitmap a) -> IO (Ptr (TBitmap ()))

-- | usage: (@bitmapCreateLoad name wxtype@).
bitmapCreateLoad :: String -> Int ->  IO (Bitmap  ())
bitmapCreateLoad name wxtype 
  = withManagedBitmapResult $
    withStringPtr name $ \cobj_name -> 
    wxBitmap_CreateLoad cobj_name  (toCInt wxtype)  
foreign import ccall "wxBitmap_CreateLoad" wxBitmap_CreateLoad :: Ptr (TWxString a) -> CInt -> IO (Ptr (TBitmap ()))

-- | usage: (@bitmapDataObjectCreate bmp@).
bitmapDataObjectCreate :: Bitmap  a ->  IO (BitmapDataObject  ())
bitmapDataObjectCreate _bmp 
  = withObjectResult $
    withObjectPtr _bmp $ \cobj__bmp -> 
    wx_BitmapDataObject_Create cobj__bmp  
foreign import ccall "BitmapDataObject_Create" wx_BitmapDataObject_Create :: Ptr (TBitmap a) -> IO (Ptr (TBitmapDataObject ()))

-- | usage: (@bitmapDataObjectCreateEmpty@).
bitmapDataObjectCreateEmpty ::  IO (BitmapDataObject  ())
bitmapDataObjectCreateEmpty 
  = withObjectResult $
    wx_BitmapDataObject_CreateEmpty 
foreign import ccall "BitmapDataObject_CreateEmpty" wx_BitmapDataObject_CreateEmpty :: IO (Ptr (TBitmapDataObject ()))

-- | usage: (@bitmapDataObjectDelete obj@).
bitmapDataObjectDelete :: BitmapDataObject  a ->  IO ()
bitmapDataObjectDelete _obj 
  = withObjectPtr _obj $ \cobj__obj -> 
    wx_BitmapDataObject_Delete cobj__obj  
foreign import ccall "BitmapDataObject_Delete" wx_BitmapDataObject_Delete :: Ptr (TBitmapDataObject a) -> IO ()

-- | usage: (@bitmapDataObjectGetBitmap obj@).
bitmapDataObjectGetBitmap :: BitmapDataObject  a ->  IO (Bitmap  ())
bitmapDataObjectGetBitmap _obj 
  = withRefBitmap $ \pref -> 
    withObjectPtr _obj $ \cobj__obj -> 
    wx_BitmapDataObject_GetBitmap cobj__obj   pref
foreign import ccall "BitmapDataObject_GetBitmap" wx_BitmapDataObject_GetBitmap :: Ptr (TBitmapDataObject a) -> Ptr (TBitmap ()) -> IO ()

-- | usage: (@bitmapDataObjectSetBitmap obj bmp@).
bitmapDataObjectSetBitmap :: BitmapDataObject  a -> Bitmap  b ->  IO ()
bitmapDataObjectSetBitmap _obj _bmp 
  = withObjectPtr _obj $ \cobj__obj -> 
    withObjectPtr _bmp $ \cobj__bmp -> 
    wx_BitmapDataObject_SetBitmap cobj__obj  cobj__bmp  
foreign import ccall "BitmapDataObject_SetBitmap" wx_BitmapDataObject_SetBitmap :: Ptr (TBitmapDataObject a) -> Ptr (TBitmap b) -> IO ()

-- | usage: (@bitmapDelete obj@).
bitmapDelete :: Bitmap  a ->  IO ()
bitmapDelete
  = objectDelete


-- | usage: (@bitmapFindHandlerByExtension extension wxtype@).
bitmapFindHandlerByExtension :: Bitmap  a -> Int ->  IO (Ptr  ())
bitmapFindHandlerByExtension extension wxtype 
  = withObjectRef "bitmapFindHandlerByExtension" extension $ \cobj_extension -> 
    wxBitmap_FindHandlerByExtension cobj_extension  (toCInt wxtype)  
foreign import ccall "wxBitmap_FindHandlerByExtension" wxBitmap_FindHandlerByExtension :: Ptr (TBitmap a) -> CInt -> IO (Ptr  ())

-- | usage: (@bitmapFindHandlerByName name@).
bitmapFindHandlerByName :: String ->  IO (Ptr  ())
bitmapFindHandlerByName name 
  = withStringPtr name $ \cobj_name -> 
    wxBitmap_FindHandlerByName cobj_name  
foreign import ccall "wxBitmap_FindHandlerByName" wxBitmap_FindHandlerByName :: Ptr (TWxString a) -> IO (Ptr  ())

-- | usage: (@bitmapFindHandlerByType wxtype@).
bitmapFindHandlerByType :: Int ->  IO (Ptr  ())
bitmapFindHandlerByType wxtype 
  = wxBitmap_FindHandlerByType (toCInt wxtype)  
foreign import ccall "wxBitmap_FindHandlerByType" wxBitmap_FindHandlerByType :: CInt -> IO (Ptr  ())

-- | usage: (@bitmapGetDepth obj@).
bitmapGetDepth :: Bitmap  a ->  IO Int
bitmapGetDepth _obj 
  = withIntResult $
    withObjectRef "bitmapGetDepth" _obj $ \cobj__obj -> 
    wxBitmap_GetDepth cobj__obj  
foreign import ccall "wxBitmap_GetDepth" wxBitmap_GetDepth :: Ptr (TBitmap a) -> IO CInt

-- | usage: (@bitmapGetHeight obj@).
bitmapGetHeight :: Bitmap  a ->  IO Int
bitmapGetHeight _obj 
  = withIntResult $
    withObjectRef "bitmapGetHeight" _obj $ \cobj__obj -> 
    wxBitmap_GetHeight cobj__obj  
foreign import ccall "wxBitmap_GetHeight" wxBitmap_GetHeight :: Ptr (TBitmap a) -> IO CInt

-- | usage: (@bitmapGetMask obj@).
bitmapGetMask :: Bitmap  a ->  IO (Mask  ())
bitmapGetMask _obj 
  = withObjectResult $
    withObjectRef "bitmapGetMask" _obj $ \cobj__obj -> 
    wxBitmap_GetMask cobj__obj  
foreign import ccall "wxBitmap_GetMask" wxBitmap_GetMask :: Ptr (TBitmap a) -> IO (Ptr (TMask ()))

-- | usage: (@bitmapGetSubBitmap obj xywh@).
bitmapGetSubBitmap :: Bitmap  a -> Rect ->  IO (Bitmap  ())
bitmapGetSubBitmap _obj xywh 
  = withRefBitmap $ \pref -> 
    withObjectRef "bitmapGetSubBitmap" _obj $ \cobj__obj -> 
    wxBitmap_GetSubBitmap cobj__obj  (toCIntRectX xywh) (toCIntRectY xywh)(toCIntRectW xywh) (toCIntRectH xywh)   pref
foreign import ccall "wxBitmap_GetSubBitmap" wxBitmap_GetSubBitmap :: Ptr (TBitmap a) -> CInt -> CInt -> CInt -> CInt -> Ptr (TBitmap ()) -> IO ()

-- | usage: (@bitmapGetWidth obj@).
bitmapGetWidth :: Bitmap  a ->  IO Int
bitmapGetWidth _obj 
  = withIntResult $
    withObjectRef "bitmapGetWidth" _obj $ \cobj__obj -> 
    wxBitmap_GetWidth cobj__obj  
foreign import ccall "wxBitmap_GetWidth" wxBitmap_GetWidth :: Ptr (TBitmap a) -> IO CInt

-- | usage: (@bitmapInitStandardHandlers@).
bitmapInitStandardHandlers ::  IO ()
bitmapInitStandardHandlers 
  = wxBitmap_InitStandardHandlers 
foreign import ccall "wxBitmap_InitStandardHandlers" wxBitmap_InitStandardHandlers :: IO ()

-- | usage: (@bitmapInsertHandler handler@).
bitmapInsertHandler :: EvtHandler  a ->  IO ()
bitmapInsertHandler handler 
  = withObjectPtr handler $ \cobj_handler -> 
    wxBitmap_InsertHandler cobj_handler  
foreign import ccall "wxBitmap_InsertHandler" wxBitmap_InsertHandler :: Ptr (TEvtHandler a) -> IO ()

-- | usage: (@bitmapIsOk obj@).
bitmapIsOk :: Bitmap  a ->  IO Bool
bitmapIsOk _obj 
  = withBoolResult $
    withObjectRef "bitmapIsOk" _obj $ \cobj__obj -> 
    wxBitmap_IsOk cobj__obj  
foreign import ccall "wxBitmap_IsOk" wxBitmap_IsOk :: Ptr (TBitmap a) -> IO CBool

-- | usage: (@bitmapIsStatic self@).
bitmapIsStatic :: Bitmap  a ->  IO Bool
bitmapIsStatic self 
  = withBoolResult $
    withObjectPtr self $ \cobj_self -> 
    wxBitmap_IsStatic cobj_self  
foreign import ccall "wxBitmap_IsStatic" wxBitmap_IsStatic :: Ptr (TBitmap a) -> IO CBool

-- | usage: (@bitmapLoadFile obj name wxtype@).
bitmapLoadFile :: Bitmap  a -> String -> Int ->  IO Int
bitmapLoadFile _obj name wxtype 
  = withIntResult $
    withObjectRef "bitmapLoadFile" _obj $ \cobj__obj -> 
    withStringPtr name $ \cobj_name -> 
    wxBitmap_LoadFile cobj__obj  cobj_name  (toCInt wxtype)  
foreign import ccall "wxBitmap_LoadFile" wxBitmap_LoadFile :: Ptr (TBitmap a) -> Ptr (TWxString b) -> CInt -> IO CInt

-- | usage: (@bitmapRemoveHandler name@).
bitmapRemoveHandler :: String ->  IO Bool
bitmapRemoveHandler name 
  = withBoolResult $
    withStringPtr name $ \cobj_name -> 
    wxBitmap_RemoveHandler cobj_name  
foreign import ccall "wxBitmap_RemoveHandler" wxBitmap_RemoveHandler :: Ptr (TWxString a) -> IO CBool

-- | usage: (@bitmapSafeDelete self@).
bitmapSafeDelete :: Bitmap  a ->  IO ()
bitmapSafeDelete self 
  = withObjectPtr self $ \cobj_self -> 
    wxBitmap_SafeDelete cobj_self  
foreign import ccall "wxBitmap_SafeDelete" wxBitmap_SafeDelete :: Ptr (TBitmap a) -> IO ()

-- | usage: (@bitmapSaveFile obj name wxtype cmap@).
bitmapSaveFile :: Bitmap  a -> String -> Int -> Palette  d ->  IO Int
bitmapSaveFile _obj name wxtype cmap 
  = withIntResult $
    withObjectRef "bitmapSaveFile" _obj $ \cobj__obj -> 
    withStringPtr name $ \cobj_name -> 
    withObjectPtr cmap $ \cobj_cmap -> 
    wxBitmap_SaveFile cobj__obj  cobj_name  (toCInt wxtype)  cobj_cmap  
foreign import ccall "wxBitmap_SaveFile" wxBitmap_SaveFile :: Ptr (TBitmap a) -> Ptr (TWxString b) -> CInt -> Ptr (TPalette d) -> IO CInt

-- | usage: (@bitmapSetDepth obj d@).
bitmapSetDepth :: Bitmap  a -> Int ->  IO ()
bitmapSetDepth _obj d 
  = withObjectRef "bitmapSetDepth" _obj $ \cobj__obj -> 
    wxBitmap_SetDepth cobj__obj  (toCInt d)  
foreign import ccall "wxBitmap_SetDepth" wxBitmap_SetDepth :: Ptr (TBitmap a) -> CInt -> IO ()

-- | usage: (@bitmapSetHeight obj h@).
bitmapSetHeight :: Bitmap  a -> Int ->  IO ()
bitmapSetHeight _obj h 
  = withObjectRef "bitmapSetHeight" _obj $ \cobj__obj -> 
    wxBitmap_SetHeight cobj__obj  (toCInt h)  
foreign import ccall "wxBitmap_SetHeight" wxBitmap_SetHeight :: Ptr (TBitmap a) -> CInt -> IO ()

-- | usage: (@bitmapSetMask obj mask@).
bitmapSetMask :: Bitmap  a -> Mask  b ->  IO ()
bitmapSetMask _obj mask 
  = withObjectRef "bitmapSetMask" _obj $ \cobj__obj -> 
    withObjectPtr mask $ \cobj_mask -> 
    wxBitmap_SetMask cobj__obj  cobj_mask  
foreign import ccall "wxBitmap_SetMask" wxBitmap_SetMask :: Ptr (TBitmap a) -> Ptr (TMask b) -> IO ()

-- | usage: (@bitmapSetWidth obj w@).
bitmapSetWidth :: Bitmap  a -> Int ->  IO ()
bitmapSetWidth _obj w 
  = withObjectRef "bitmapSetWidth" _obj $ \cobj__obj -> 
    wxBitmap_SetWidth cobj__obj  (toCInt w)  
foreign import ccall "wxBitmap_SetWidth" wxBitmap_SetWidth :: Ptr (TBitmap a) -> CInt -> IO ()

-- | usage: (@boxSizerCalcMin obj@).
boxSizerCalcMin :: BoxSizer  a ->  IO (Size)
boxSizerCalcMin _obj 
  = withWxSizeResult $
    withObjectRef "boxSizerCalcMin" _obj $ \cobj__obj -> 
    wxBoxSizer_CalcMin cobj__obj  
foreign import ccall "wxBoxSizer_CalcMin" wxBoxSizer_CalcMin :: Ptr (TBoxSizer a) -> IO (Ptr (TWxSize ()))

-- | usage: (@boxSizerCreate orient@).
boxSizerCreate :: Int ->  IO (BoxSizer  ())
boxSizerCreate orient 
  = withObjectResult $
    wxBoxSizer_Create (toCInt orient)  
foreign import ccall "wxBoxSizer_Create" wxBoxSizer_Create :: CInt -> IO (Ptr (TBoxSizer ()))

-- | usage: (@boxSizerGetOrientation obj@).
boxSizerGetOrientation :: BoxSizer  a ->  IO Int
boxSizerGetOrientation _obj 
  = withIntResult $
    withObjectRef "boxSizerGetOrientation" _obj $ \cobj__obj -> 
    wxBoxSizer_GetOrientation cobj__obj  
foreign import ccall "wxBoxSizer_GetOrientation" wxBoxSizer_GetOrientation :: Ptr (TBoxSizer a) -> IO CInt

-- | usage: (@boxSizerRecalcSizes obj@).
boxSizerRecalcSizes :: BoxSizer  a ->  IO ()
boxSizerRecalcSizes _obj 
  = withObjectRef "boxSizerRecalcSizes" _obj $ \cobj__obj -> 
    wxBoxSizer_RecalcSizes cobj__obj  
foreign import ccall "wxBoxSizer_RecalcSizes" wxBoxSizer_RecalcSizes :: Ptr (TBoxSizer a) -> IO ()

-- | usage: (@brushAssign obj brush@).
brushAssign :: Brush  a -> Brush  b ->  IO ()
brushAssign _obj brush 
  = withObjectRef "brushAssign" _obj $ \cobj__obj -> 
    withObjectPtr brush $ \cobj_brush -> 
    wxBrush_Assign cobj__obj  cobj_brush  
foreign import ccall "wxBrush_Assign" wxBrush_Assign :: Ptr (TBrush a) -> Ptr (TBrush b) -> IO ()

-- | usage: (@brushCreateDefault@).
brushCreateDefault ::  IO (Brush  ())
brushCreateDefault 
  = withManagedBrushResult $
    wxBrush_CreateDefault 
foreign import ccall "wxBrush_CreateDefault" wxBrush_CreateDefault :: IO (Ptr (TBrush ()))

-- | usage: (@brushCreateFromBitmap bitmap@).
brushCreateFromBitmap :: Bitmap  a ->  IO (Brush  ())
brushCreateFromBitmap bitmap 
  = withManagedBrushResult $
    withObjectPtr bitmap $ \cobj_bitmap -> 
    wxBrush_CreateFromBitmap cobj_bitmap  
foreign import ccall "wxBrush_CreateFromBitmap" wxBrush_CreateFromBitmap :: Ptr (TBitmap a) -> IO (Ptr (TBrush ()))

-- | usage: (@brushCreateFromColour col style@).
brushCreateFromColour :: Color -> Int ->  IO (Brush  ())
brushCreateFromColour col style 
  = withManagedBrushResult $
    withColourPtr col $ \cobj_col -> 
    wxBrush_CreateFromColour cobj_col  (toCInt style)  
foreign import ccall "wxBrush_CreateFromColour" wxBrush_CreateFromColour :: Ptr (TColour a) -> CInt -> IO (Ptr (TBrush ()))

-- | usage: (@brushCreateFromStock id@).
brushCreateFromStock :: Id ->  IO (Brush  ())
brushCreateFromStock id 
  = withManagedBrushResult $
    wxBrush_CreateFromStock (toCInt id)  
foreign import ccall "wxBrush_CreateFromStock" wxBrush_CreateFromStock :: CInt -> IO (Ptr (TBrush ()))

-- | usage: (@brushDelete obj@).
brushDelete :: Brush  a ->  IO ()
brushDelete
  = objectDelete


-- | usage: (@brushGetColour obj@).
brushGetColour :: Brush  a ->  IO (Color)
brushGetColour _obj 
  = withRefColour $ \pref -> 
    withObjectRef "brushGetColour" _obj $ \cobj__obj -> 
    wxBrush_GetColour cobj__obj   pref
foreign import ccall "wxBrush_GetColour" wxBrush_GetColour :: Ptr (TBrush a) -> Ptr (TColour ()) -> IO ()

-- | usage: (@brushGetStipple obj@).
brushGetStipple :: Brush  a ->  IO (Bitmap  ())
brushGetStipple _obj 
  = withRefBitmap $ \pref -> 
    withObjectRef "brushGetStipple" _obj $ \cobj__obj -> 
    wxBrush_GetStipple cobj__obj   pref
foreign import ccall "wxBrush_GetStipple" wxBrush_GetStipple :: Ptr (TBrush a) -> Ptr (TBitmap ()) -> IO ()

-- | usage: (@brushGetStyle obj@).
brushGetStyle :: Brush  a ->  IO Int
brushGetStyle _obj 
  = withIntResult $
    withObjectRef "brushGetStyle" _obj $ \cobj__obj -> 
    wxBrush_GetStyle cobj__obj  
foreign import ccall "wxBrush_GetStyle" wxBrush_GetStyle :: Ptr (TBrush a) -> IO CInt

-- | usage: (@brushIsEqual obj brush@).
brushIsEqual :: Brush  a -> Brush  b ->  IO Bool
brushIsEqual _obj brush 
  = withBoolResult $
    withObjectRef "brushIsEqual" _obj $ \cobj__obj -> 
    withObjectPtr brush $ \cobj_brush -> 
    wxBrush_IsEqual cobj__obj  cobj_brush  
foreign import ccall "wxBrush_IsEqual" wxBrush_IsEqual :: Ptr (TBrush a) -> Ptr (TBrush b) -> IO CBool

-- | usage: (@brushIsOk obj@).
brushIsOk :: Brush  a ->  IO Bool
brushIsOk _obj 
  = withBoolResult $
    withObjectRef "brushIsOk" _obj $ \cobj__obj -> 
    wxBrush_IsOk cobj__obj  
foreign import ccall "wxBrush_IsOk" wxBrush_IsOk :: Ptr (TBrush a) -> IO CBool

-- | usage: (@brushIsStatic self@).
brushIsStatic :: Brush  a ->  IO Bool
brushIsStatic self 
  = withBoolResult $
    withObjectPtr self $ \cobj_self -> 
    wxBrush_IsStatic cobj_self  
foreign import ccall "wxBrush_IsStatic" wxBrush_IsStatic :: Ptr (TBrush a) -> IO CBool

-- | usage: (@brushSafeDelete self@).
brushSafeDelete :: Brush  a ->  IO ()
brushSafeDelete self 
  = withObjectPtr self $ \cobj_self -> 
    wxBrush_SafeDelete cobj_self  
foreign import ccall "wxBrush_SafeDelete" wxBrush_SafeDelete :: Ptr (TBrush a) -> IO ()

-- | usage: (@brushSetColour obj col@).
brushSetColour :: Brush  a -> Color ->  IO ()
brushSetColour _obj col 
  = withObjectRef "brushSetColour" _obj $ \cobj__obj -> 
    withColourPtr col $ \cobj_col -> 
    wxBrush_SetColour cobj__obj  cobj_col  
foreign import ccall "wxBrush_SetColour" wxBrush_SetColour :: Ptr (TBrush a) -> Ptr (TColour b) -> IO ()

-- | usage: (@brushSetColourSingle obj r g b@).
brushSetColourSingle :: Brush  a -> Char -> Char -> Char ->  IO ()
brushSetColourSingle _obj r g b 
  = withObjectRef "brushSetColourSingle" _obj $ \cobj__obj -> 
    wxBrush_SetColourSingle cobj__obj  (toCWchar r)  (toCWchar g)  (toCWchar b)  
foreign import ccall "wxBrush_SetColourSingle" wxBrush_SetColourSingle :: Ptr (TBrush a) -> CWchar -> CWchar -> CWchar -> IO ()

-- | usage: (@brushSetStipple obj stipple@).
brushSetStipple :: Brush  a -> Bitmap  b ->  IO ()
brushSetStipple _obj stipple 
  = withObjectRef "brushSetStipple" _obj $ \cobj__obj -> 
    withObjectPtr stipple $ \cobj_stipple -> 
    wxBrush_SetStipple cobj__obj  cobj_stipple  
foreign import ccall "wxBrush_SetStipple" wxBrush_SetStipple :: Ptr (TBrush a) -> Ptr (TBitmap b) -> IO ()

-- | usage: (@brushSetStyle obj style@).
brushSetStyle :: Brush  a -> Int ->  IO ()
brushSetStyle _obj style 
  = withObjectRef "brushSetStyle" _obj $ \cobj__obj -> 
    wxBrush_SetStyle cobj__obj  (toCInt style)  
foreign import ccall "wxBrush_SetStyle" wxBrush_SetStyle :: Ptr (TBrush a) -> CInt -> IO ()

-- | usage: (@bufferedDCCreateByDCAndBitmap dc bitmap style@).
bufferedDCCreateByDCAndBitmap :: DC  a -> Bitmap  b -> Int ->  IO (BufferedDC  ())
bufferedDCCreateByDCAndBitmap dc bitmap style 
  = withObjectResult $
    withObjectPtr dc $ \cobj_dc -> 
    withObjectPtr bitmap $ \cobj_bitmap -> 
    wxBufferedDC_CreateByDCAndBitmap cobj_dc  cobj_bitmap  (toCInt style)  
foreign import ccall "wxBufferedDC_CreateByDCAndBitmap" wxBufferedDC_CreateByDCAndBitmap :: Ptr (TDC a) -> Ptr (TBitmap b) -> CInt -> IO (Ptr (TBufferedDC ()))

-- | usage: (@bufferedDCCreateByDCAndSize dc widthhight style@).
bufferedDCCreateByDCAndSize :: DC  a -> Size -> Int ->  IO (BufferedDC  ())
bufferedDCCreateByDCAndSize dc widthhight style 
  = withObjectResult $
    withObjectPtr dc $ \cobj_dc -> 
    wxBufferedDC_CreateByDCAndSize cobj_dc  (toCIntSizeW widthhight) (toCIntSizeH widthhight)  (toCInt style)  
foreign import ccall "wxBufferedDC_CreateByDCAndSize" wxBufferedDC_CreateByDCAndSize :: Ptr (TDC a) -> CInt -> CInt -> CInt -> IO (Ptr (TBufferedDC ()))

-- | usage: (@bufferedDCDelete self@).
bufferedDCDelete :: BufferedDC  a ->  IO ()
bufferedDCDelete
  = objectDelete


-- | usage: (@bufferedPaintDCCreate window style@).
bufferedPaintDCCreate :: Window  a -> Int ->  IO (BufferedPaintDC  ())
bufferedPaintDCCreate window style 
  = withObjectResult $
    withObjectPtr window $ \cobj_window -> 
    wxBufferedPaintDC_Create cobj_window  (toCInt style)  
foreign import ccall "wxBufferedPaintDC_Create" wxBufferedPaintDC_Create :: Ptr (TWindow a) -> CInt -> IO (Ptr (TBufferedPaintDC ()))

-- | usage: (@bufferedPaintDCCreateWithBitmap window bitmap style@).
bufferedPaintDCCreateWithBitmap :: Window  a -> Bitmap  b -> Int ->  IO (BufferedPaintDC  ())
bufferedPaintDCCreateWithBitmap window bitmap style 
  = withObjectResult $
    withObjectPtr window $ \cobj_window -> 
    withObjectPtr bitmap $ \cobj_bitmap -> 
    wxBufferedPaintDC_CreateWithBitmap cobj_window  cobj_bitmap  (toCInt style)  
foreign import ccall "wxBufferedPaintDC_CreateWithBitmap" wxBufferedPaintDC_CreateWithBitmap :: Ptr (TWindow a) -> Ptr (TBitmap b) -> CInt -> IO (Ptr (TBufferedPaintDC ()))

-- | usage: (@bufferedPaintDCDelete self@).
bufferedPaintDCDelete :: BufferedPaintDC  a ->  IO ()
bufferedPaintDCDelete
  = objectDelete


-- | usage: (@busyCursorCreate@).
busyCursorCreate ::  IO (BusyCursor  ())
busyCursorCreate 
  = withObjectResult $
    wxBusyCursor_Create 
foreign import ccall "wxBusyCursor_Create" wxBusyCursor_Create :: IO (Ptr (TBusyCursor ()))

-- | usage: (@busyCursorCreateWithCursor cur@).
busyCursorCreateWithCursor :: BusyCursor  a ->  IO (Ptr  ())
busyCursorCreateWithCursor _cur 
  = withObjectRef "busyCursorCreateWithCursor" _cur $ \cobj__cur -> 
    wxBusyCursor_CreateWithCursor cobj__cur  
foreign import ccall "wxBusyCursor_CreateWithCursor" wxBusyCursor_CreateWithCursor :: Ptr (TBusyCursor a) -> IO (Ptr  ())

-- | usage: (@busyCursorDelete obj@).
busyCursorDelete :: BusyCursor  a ->  IO ()
busyCursorDelete _obj 
  = withObjectRef "busyCursorDelete" _obj $ \cobj__obj -> 
    wxBusyCursor_Delete cobj__obj  
foreign import ccall "wxBusyCursor_Delete" wxBusyCursor_Delete :: Ptr (TBusyCursor a) -> IO ()

-- | usage: (@busyInfoCreate txt@).
busyInfoCreate :: String ->  IO (BusyInfo  ())
busyInfoCreate _txt 
  = withObjectResult $
    withStringPtr _txt $ \cobj__txt -> 
    wxBusyInfo_Create cobj__txt  
foreign import ccall "wxBusyInfo_Create" wxBusyInfo_Create :: Ptr (TWxString a) -> IO (Ptr (TBusyInfo ()))

-- | usage: (@busyInfoDelete obj@).
busyInfoDelete :: BusyInfo  a ->  IO ()
busyInfoDelete _obj 
  = withObjectRef "busyInfoDelete" _obj $ \cobj__obj -> 
    wxBusyInfo_Delete cobj__obj  
foreign import ccall "wxBusyInfo_Delete" wxBusyInfo_Delete :: Ptr (TBusyInfo a) -> IO ()

-- | usage: (@buttonCreate prt id txt lfttopwdthgt stl@).
buttonCreate :: Window  a -> Id -> String -> Rect -> Style ->  IO (Button  ())
buttonCreate _prt _id _txt _lfttopwdthgt _stl 
  = withObjectResult $
    withObjectPtr _prt $ \cobj__prt -> 
    withStringPtr _txt $ \cobj__txt -> 
    wxButton_Create cobj__prt  (toCInt _id)  cobj__txt  (toCIntRectX _lfttopwdthgt) (toCIntRectY _lfttopwdthgt)(toCIntRectW _lfttopwdthgt) (toCIntRectH _lfttopwdthgt)  (toCInt _stl)  
foreign import ccall "wxButton_Create" wxButton_Create :: Ptr (TWindow a) -> CInt -> Ptr (TWxString c) -> CInt -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (TButton ()))

-- | usage: (@buttonSetBackgroundColour obj colour@).
buttonSetBackgroundColour :: Button  a -> Color ->  IO Int
buttonSetBackgroundColour _obj colour 
  = withIntResult $
    withObjectRef "buttonSetBackgroundColour" _obj $ \cobj__obj -> 
    withColourPtr colour $ \cobj_colour -> 
    wxButton_SetBackgroundColour cobj__obj  cobj_colour  
foreign import ccall "wxButton_SetBackgroundColour" wxButton_SetBackgroundColour :: Ptr (TButton a) -> Ptr (TColour b) -> IO CInt

-- | usage: (@buttonSetDefault obj@).
buttonSetDefault :: Button  a ->  IO ()
buttonSetDefault _obj 
  = withObjectRef "buttonSetDefault" _obj $ \cobj__obj -> 
    wxButton_SetDefault cobj__obj  
foreign import ccall "wxButton_SetDefault" wxButton_SetDefault :: Ptr (TButton a) -> IO ()

-- | usage: (@cFree ptr@).
cFree :: Ptr  a ->  IO ()
cFree _ptr 
  = wx_wxCFree _ptr  
foreign import ccall "wxCFree" wx_wxCFree :: Ptr  a -> IO ()

-- | usage: (@calculateLayoutEventCreate id@).
calculateLayoutEventCreate :: Id ->  IO (CalculateLayoutEvent  ())
calculateLayoutEventCreate id 
  = withObjectResult $
    wxCalculateLayoutEvent_Create (toCInt id)  
foreign import ccall "wxCalculateLayoutEvent_Create" wxCalculateLayoutEvent_Create :: CInt -> IO (Ptr (TCalculateLayoutEvent ()))

-- | usage: (@calculateLayoutEventGetFlags obj@).
calculateLayoutEventGetFlags :: CalculateLayoutEvent  a ->  IO Int
calculateLayoutEventGetFlags _obj 
  = withIntResult $
    withObjectRef "calculateLayoutEventGetFlags" _obj $ \cobj__obj -> 
    wxCalculateLayoutEvent_GetFlags cobj__obj  
foreign import ccall "wxCalculateLayoutEvent_GetFlags" wxCalculateLayoutEvent_GetFlags :: Ptr (TCalculateLayoutEvent a) -> IO CInt

-- | usage: (@calculateLayoutEventGetRect obj@).
calculateLayoutEventGetRect :: CalculateLayoutEvent  a ->  IO (Rect)
calculateLayoutEventGetRect _obj 
  = withWxRectResult $
    withObjectRef "calculateLayoutEventGetRect" _obj $ \cobj__obj -> 
    wxCalculateLayoutEvent_GetRect cobj__obj  
foreign import ccall "wxCalculateLayoutEvent_GetRect" wxCalculateLayoutEvent_GetRect :: Ptr (TCalculateLayoutEvent a) -> IO (Ptr (TWxRect ()))

-- | usage: (@calculateLayoutEventSetFlags obj flags@).
calculateLayoutEventSetFlags :: CalculateLayoutEvent  a -> Int ->  IO ()
calculateLayoutEventSetFlags _obj flags 
  = withObjectRef "calculateLayoutEventSetFlags" _obj $ \cobj__obj -> 
    wxCalculateLayoutEvent_SetFlags cobj__obj  (toCInt flags)  
foreign import ccall "wxCalculateLayoutEvent_SetFlags" wxCalculateLayoutEvent_SetFlags :: Ptr (TCalculateLayoutEvent a) -> CInt -> IO ()

-- | usage: (@calculateLayoutEventSetRect obj xywh@).
calculateLayoutEventSetRect :: CalculateLayoutEvent  a -> Rect ->  IO ()
calculateLayoutEventSetRect _obj xywh 
  = withObjectRef "calculateLayoutEventSetRect" _obj $ \cobj__obj -> 
    wxCalculateLayoutEvent_SetRect cobj__obj  (toCIntRectX xywh) (toCIntRectY xywh)(toCIntRectW xywh) (toCIntRectH xywh)  
foreign import ccall "wxCalculateLayoutEvent_SetRect" wxCalculateLayoutEvent_SetRect :: Ptr (TCalculateLayoutEvent a) -> CInt -> CInt -> CInt -> CInt -> IO ()

-- | usage: (@calendarCtrlCreate prt id dat lfttopwdthgt stl@).
calendarCtrlCreate :: Window  a -> Id -> DateTime  c -> Rect -> Style ->  IO (CalendarCtrl  ())
calendarCtrlCreate _prt _id _dat _lfttopwdthgt _stl 
  = withObjectResult $
    withObjectPtr _prt $ \cobj__prt -> 
    withObjectPtr _dat $ \cobj__dat -> 
    wxCalendarCtrl_Create cobj__prt  (toCInt _id)  cobj__dat  (toCIntRectX _lfttopwdthgt) (toCIntRectY _lfttopwdthgt)(toCIntRectW _lfttopwdthgt) (toCIntRectH _lfttopwdthgt)  (toCInt _stl)  
foreign import ccall "wxCalendarCtrl_Create" wxCalendarCtrl_Create :: Ptr (TWindow a) -> CInt -> Ptr (TDateTime c) -> CInt -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (TCalendarCtrl ()))

-- | usage: (@calendarCtrlEnableHolidayDisplay obj display@).
calendarCtrlEnableHolidayDisplay :: CalendarCtrl  a -> Int ->  IO ()
calendarCtrlEnableHolidayDisplay _obj display 
  = withObjectRef "calendarCtrlEnableHolidayDisplay" _obj $ \cobj__obj -> 
    wxCalendarCtrl_EnableHolidayDisplay cobj__obj  (toCInt display)  
foreign import ccall "wxCalendarCtrl_EnableHolidayDisplay" wxCalendarCtrl_EnableHolidayDisplay :: Ptr (TCalendarCtrl a) -> CInt -> IO ()

-- | usage: (@calendarCtrlEnableMonthChange obj enable@).
calendarCtrlEnableMonthChange :: CalendarCtrl  a -> Bool ->  IO ()
calendarCtrlEnableMonthChange _obj enable 
  = withObjectRef "calendarCtrlEnableMonthChange" _obj $ \cobj__obj -> 
    wxCalendarCtrl_EnableMonthChange cobj__obj  (toCBool enable)  
foreign import ccall "wxCalendarCtrl_EnableMonthChange" wxCalendarCtrl_EnableMonthChange :: Ptr (TCalendarCtrl a) -> CBool -> IO ()

-- | usage: (@calendarCtrlEnableYearChange obj enable@).
calendarCtrlEnableYearChange :: CalendarCtrl  a -> Bool ->  IO ()
calendarCtrlEnableYearChange _obj enable 
  = withObjectRef "calendarCtrlEnableYearChange" _obj $ \cobj__obj -> 
    wxCalendarCtrl_EnableYearChange cobj__obj  (toCBool enable)  
foreign import ccall "wxCalendarCtrl_EnableYearChange" wxCalendarCtrl_EnableYearChange :: Ptr (TCalendarCtrl a) -> CBool -> IO ()

-- | usage: (@calendarCtrlGetAttr obj day@).
calendarCtrlGetAttr :: CalendarCtrl  a -> Int ->  IO (Ptr  ())
calendarCtrlGetAttr _obj day 
  = withObjectRef "calendarCtrlGetAttr" _obj $ \cobj__obj -> 
    wxCalendarCtrl_GetAttr cobj__obj  (toCInt day)  
foreign import ccall "wxCalendarCtrl_GetAttr" wxCalendarCtrl_GetAttr :: Ptr (TCalendarCtrl a) -> CInt -> IO (Ptr  ())

-- | usage: (@calendarCtrlGetDate obj date@).
calendarCtrlGetDate :: CalendarCtrl  a -> Ptr  b ->  IO ()
calendarCtrlGetDate _obj date 
  = withObjectRef "calendarCtrlGetDate" _obj $ \cobj__obj -> 
    wxCalendarCtrl_GetDate cobj__obj  date  
foreign import ccall "wxCalendarCtrl_GetDate" wxCalendarCtrl_GetDate :: Ptr (TCalendarCtrl a) -> Ptr  b -> IO ()

-- | usage: (@calendarCtrlGetHeaderColourBg obj@).
calendarCtrlGetHeaderColourBg :: CalendarCtrl  a ->  IO (Color)
calendarCtrlGetHeaderColourBg _obj 
  = withRefColour $ \pref -> 
    withObjectRef "calendarCtrlGetHeaderColourBg" _obj $ \cobj__obj -> 
    wxCalendarCtrl_GetHeaderColourBg cobj__obj   pref
foreign import ccall "wxCalendarCtrl_GetHeaderColourBg" wxCalendarCtrl_GetHeaderColourBg :: Ptr (TCalendarCtrl a) -> Ptr (TColour ()) -> IO ()

-- | usage: (@calendarCtrlGetHeaderColourFg obj@).
calendarCtrlGetHeaderColourFg :: CalendarCtrl  a ->  IO (Color)
calendarCtrlGetHeaderColourFg _obj 
  = withRefColour $ \pref -> 
    withObjectRef "calendarCtrlGetHeaderColourFg" _obj $ \cobj__obj -> 
    wxCalendarCtrl_GetHeaderColourFg cobj__obj   pref
foreign import ccall "wxCalendarCtrl_GetHeaderColourFg" wxCalendarCtrl_GetHeaderColourFg :: Ptr (TCalendarCtrl a) -> Ptr (TColour ()) -> IO ()

-- | usage: (@calendarCtrlGetHighlightColourBg obj@).
calendarCtrlGetHighlightColourBg :: CalendarCtrl  a ->  IO (Color)
calendarCtrlGetHighlightColourBg _obj 
  = withRefColour $ \pref -> 
    withObjectRef "calendarCtrlGetHighlightColourBg" _obj $ \cobj__obj -> 
    wxCalendarCtrl_GetHighlightColourBg cobj__obj   pref
foreign import ccall "wxCalendarCtrl_GetHighlightColourBg" wxCalendarCtrl_GetHighlightColourBg :: Ptr (TCalendarCtrl a) -> Ptr (TColour ()) -> IO ()

-- | usage: (@calendarCtrlGetHighlightColourFg obj@).
calendarCtrlGetHighlightColourFg :: CalendarCtrl  a ->  IO (Color)
calendarCtrlGetHighlightColourFg _obj 
  = withRefColour $ \pref -> 
    withObjectRef "calendarCtrlGetHighlightColourFg" _obj $ \cobj__obj -> 
    wxCalendarCtrl_GetHighlightColourFg cobj__obj   pref
foreign import ccall "wxCalendarCtrl_GetHighlightColourFg" wxCalendarCtrl_GetHighlightColourFg :: Ptr (TCalendarCtrl a) -> Ptr (TColour ()) -> IO ()

-- | usage: (@calendarCtrlGetHolidayColourBg obj@).
calendarCtrlGetHolidayColourBg :: CalendarCtrl  a ->  IO (Color)
calendarCtrlGetHolidayColourBg _obj 
  = withRefColour $ \pref -> 
    withObjectRef "calendarCtrlGetHolidayColourBg" _obj $ \cobj__obj -> 
    wxCalendarCtrl_GetHolidayColourBg cobj__obj   pref
foreign import ccall "wxCalendarCtrl_GetHolidayColourBg" wxCalendarCtrl_GetHolidayColourBg :: Ptr (TCalendarCtrl a) -> Ptr (TColour ()) -> IO ()

-- | usage: (@calendarCtrlGetHolidayColourFg obj@).
calendarCtrlGetHolidayColourFg :: CalendarCtrl  a ->  IO (Color)
calendarCtrlGetHolidayColourFg _obj 
  = withRefColour $ \pref -> 
    withObjectRef "calendarCtrlGetHolidayColourFg" _obj $ \cobj__obj -> 
    wxCalendarCtrl_GetHolidayColourFg cobj__obj   pref
foreign import ccall "wxCalendarCtrl_GetHolidayColourFg" wxCalendarCtrl_GetHolidayColourFg :: Ptr (TCalendarCtrl a) -> Ptr (TColour ()) -> IO ()

-- | usage: (@calendarCtrlHitTest obj xy date wd@).
calendarCtrlHitTest :: CalendarCtrl  a -> Point -> Ptr  c -> Ptr  d ->  IO Int
calendarCtrlHitTest _obj xy date wd 
  = withIntResult $
    withObjectRef "calendarCtrlHitTest" _obj $ \cobj__obj -> 
    wxCalendarCtrl_HitTest cobj__obj  (toCIntPointX xy) (toCIntPointY xy)  date  wd  
foreign import ccall "wxCalendarCtrl_HitTest" wxCalendarCtrl_HitTest :: Ptr (TCalendarCtrl a) -> CInt -> CInt -> Ptr  c -> Ptr  d -> IO CInt

-- | usage: (@calendarCtrlResetAttr obj day@).
calendarCtrlResetAttr :: CalendarCtrl  a -> Int ->  IO ()
calendarCtrlResetAttr _obj day 
  = withObjectRef "calendarCtrlResetAttr" _obj $ \cobj__obj -> 
    wxCalendarCtrl_ResetAttr cobj__obj  (toCInt day)  
foreign import ccall "wxCalendarCtrl_ResetAttr" wxCalendarCtrl_ResetAttr :: Ptr (TCalendarCtrl a) -> CInt -> IO ()

-- | usage: (@calendarCtrlSetAttr obj day attr@).
calendarCtrlSetAttr :: CalendarCtrl  a -> Int -> Ptr  c ->  IO ()
calendarCtrlSetAttr _obj day attr 
  = withObjectRef "calendarCtrlSetAttr" _obj $ \cobj__obj -> 
    wxCalendarCtrl_SetAttr cobj__obj  (toCInt day)  attr  
foreign import ccall "wxCalendarCtrl_SetAttr" wxCalendarCtrl_SetAttr :: Ptr (TCalendarCtrl a) -> CInt -> Ptr  c -> IO ()

-- | usage: (@calendarCtrlSetDate obj date@).
calendarCtrlSetDate :: CalendarCtrl  a -> Ptr  b ->  IO ()
calendarCtrlSetDate _obj date 
  = withObjectRef "calendarCtrlSetDate" _obj $ \cobj__obj -> 
    wxCalendarCtrl_SetDate cobj__obj  date  
foreign import ccall "wxCalendarCtrl_SetDate" wxCalendarCtrl_SetDate :: Ptr (TCalendarCtrl a) -> Ptr  b -> IO ()

-- | usage: (@calendarCtrlSetHeaderColours obj colFg colBg@).
calendarCtrlSetHeaderColours :: CalendarCtrl  a -> Ptr  b -> Ptr  c ->  IO ()
calendarCtrlSetHeaderColours _obj colFg colBg 
  = withObjectRef "calendarCtrlSetHeaderColours" _obj $ \cobj__obj -> 
    wxCalendarCtrl_SetHeaderColours cobj__obj  colFg  colBg  
foreign import ccall "wxCalendarCtrl_SetHeaderColours" wxCalendarCtrl_SetHeaderColours :: Ptr (TCalendarCtrl a) -> Ptr  b -> Ptr  c -> IO ()

-- | usage: (@calendarCtrlSetHighlightColours obj colFg colBg@).
calendarCtrlSetHighlightColours :: CalendarCtrl  a -> Ptr  b -> Ptr  c ->  IO ()
calendarCtrlSetHighlightColours _obj colFg colBg 
  = withObjectRef "calendarCtrlSetHighlightColours" _obj $ \cobj__obj -> 
    wxCalendarCtrl_SetHighlightColours cobj__obj  colFg  colBg  
foreign import ccall "wxCalendarCtrl_SetHighlightColours" wxCalendarCtrl_SetHighlightColours :: Ptr (TCalendarCtrl a) -> Ptr  b -> Ptr  c -> IO ()

-- | usage: (@calendarCtrlSetHoliday obj day@).
calendarCtrlSetHoliday :: CalendarCtrl  a -> Int ->  IO ()
calendarCtrlSetHoliday _obj day 
  = withObjectRef "calendarCtrlSetHoliday" _obj $ \cobj__obj -> 
    wxCalendarCtrl_SetHoliday cobj__obj  (toCInt day)  
foreign import ccall "wxCalendarCtrl_SetHoliday" wxCalendarCtrl_SetHoliday :: Ptr (TCalendarCtrl a) -> CInt -> IO ()

-- | usage: (@calendarCtrlSetHolidayColours obj colFg colBg@).
calendarCtrlSetHolidayColours :: CalendarCtrl  a -> Ptr  b -> Ptr  c ->  IO ()
calendarCtrlSetHolidayColours _obj colFg colBg 
  = withObjectRef "calendarCtrlSetHolidayColours" _obj $ \cobj__obj -> 
    wxCalendarCtrl_SetHolidayColours cobj__obj  colFg  colBg  
foreign import ccall "wxCalendarCtrl_SetHolidayColours" wxCalendarCtrl_SetHolidayColours :: Ptr (TCalendarCtrl a) -> Ptr  b -> Ptr  c -> IO ()

-- | usage: (@calendarDateAttrCreate ctxt cbck cbrd fnt brd@).
calendarDateAttrCreate :: Ptr  a -> Ptr  b -> Ptr  c -> Ptr  d -> Int ->  IO (CalendarDateAttr  ())
calendarDateAttrCreate _ctxt _cbck _cbrd _fnt _brd 
  = withObjectResult $
    wxCalendarDateAttr_Create _ctxt  _cbck  _cbrd  _fnt  (toCInt _brd)  
foreign import ccall "wxCalendarDateAttr_Create" wxCalendarDateAttr_Create :: Ptr  a -> Ptr  b -> Ptr  c -> Ptr  d -> CInt -> IO (Ptr (TCalendarDateAttr ()))

-- | usage: (@calendarDateAttrCreateDefault@).
calendarDateAttrCreateDefault ::  IO (CalendarDateAttr  ())
calendarDateAttrCreateDefault 
  = withObjectResult $
    wxCalendarDateAttr_CreateDefault 
foreign import ccall "wxCalendarDateAttr_CreateDefault" wxCalendarDateAttr_CreateDefault :: IO (Ptr (TCalendarDateAttr ()))

-- | usage: (@calendarDateAttrDelete obj@).
calendarDateAttrDelete :: CalendarDateAttr  a ->  IO ()
calendarDateAttrDelete _obj 
  = withObjectRef "calendarDateAttrDelete" _obj $ \cobj__obj -> 
    wxCalendarDateAttr_Delete cobj__obj  
foreign import ccall "wxCalendarDateAttr_Delete" wxCalendarDateAttr_Delete :: Ptr (TCalendarDateAttr a) -> IO ()

-- | usage: (@calendarDateAttrGetBackgroundColour obj@).
calendarDateAttrGetBackgroundColour :: CalendarDateAttr  a ->  IO (Color)
calendarDateAttrGetBackgroundColour _obj 
  = withRefColour $ \pref -> 
    withObjectRef "calendarDateAttrGetBackgroundColour" _obj $ \cobj__obj -> 
    wxCalendarDateAttr_GetBackgroundColour cobj__obj   pref
foreign import ccall "wxCalendarDateAttr_GetBackgroundColour" wxCalendarDateAttr_GetBackgroundColour :: Ptr (TCalendarDateAttr a) -> Ptr (TColour ()) -> IO ()

-- | usage: (@calendarDateAttrGetBorder obj@).
calendarDateAttrGetBorder :: CalendarDateAttr  a ->  IO Int
calendarDateAttrGetBorder _obj 
  = withIntResult $
    withObjectRef "calendarDateAttrGetBorder" _obj $ \cobj__obj -> 
    wxCalendarDateAttr_GetBorder cobj__obj  
foreign import ccall "wxCalendarDateAttr_GetBorder" wxCalendarDateAttr_GetBorder :: Ptr (TCalendarDateAttr a) -> IO CInt

-- | usage: (@calendarDateAttrGetBorderColour obj@).
calendarDateAttrGetBorderColour :: CalendarDateAttr  a ->  IO (Color)
calendarDateAttrGetBorderColour _obj 
  = withRefColour $ \pref -> 
    withObjectRef "calendarDateAttrGetBorderColour" _obj $ \cobj__obj -> 
    wxCalendarDateAttr_GetBorderColour cobj__obj   pref
foreign import ccall "wxCalendarDateAttr_GetBorderColour" wxCalendarDateAttr_GetBorderColour :: Ptr (TCalendarDateAttr a) -> Ptr (TColour ()) -> IO ()

-- | usage: (@calendarDateAttrGetFont obj@).
calendarDateAttrGetFont :: CalendarDateAttr  a ->  IO (Font  ())
calendarDateAttrGetFont _obj 
  = withRefFont $ \pref -> 
    withObjectRef "calendarDateAttrGetFont" _obj $ \cobj__obj -> 
    wxCalendarDateAttr_GetFont cobj__obj   pref
foreign import ccall "wxCalendarDateAttr_GetFont" wxCalendarDateAttr_GetFont :: Ptr (TCalendarDateAttr a) -> Ptr (TFont ()) -> IO ()

-- | usage: (@calendarDateAttrGetTextColour obj@).
calendarDateAttrGetTextColour :: CalendarDateAttr  a ->  IO (Color)
calendarDateAttrGetTextColour _obj 
  = withRefColour $ \pref -> 
    withObjectRef "calendarDateAttrGetTextColour" _obj $ \cobj__obj -> 
    wxCalendarDateAttr_GetTextColour cobj__obj   pref
foreign import ccall "wxCalendarDateAttr_GetTextColour" wxCalendarDateAttr_GetTextColour :: Ptr (TCalendarDateAttr a) -> Ptr (TColour ()) -> IO ()

-- | usage: (@calendarDateAttrHasBackgroundColour obj@).
calendarDateAttrHasBackgroundColour :: CalendarDateAttr  a ->  IO Bool
calendarDateAttrHasBackgroundColour _obj 
  = withBoolResult $
    withObjectRef "calendarDateAttrHasBackgroundColour" _obj $ \cobj__obj -> 
    wxCalendarDateAttr_HasBackgroundColour cobj__obj  
foreign import ccall "wxCalendarDateAttr_HasBackgroundColour" wxCalendarDateAttr_HasBackgroundColour :: Ptr (TCalendarDateAttr a) -> IO CBool

-- | usage: (@calendarDateAttrHasBorder obj@).
calendarDateAttrHasBorder :: CalendarDateAttr  a ->  IO Bool
calendarDateAttrHasBorder _obj 
  = withBoolResult $
    withObjectRef "calendarDateAttrHasBorder" _obj $ \cobj__obj -> 
    wxCalendarDateAttr_HasBorder cobj__obj  
foreign import ccall "wxCalendarDateAttr_HasBorder" wxCalendarDateAttr_HasBorder :: Ptr (TCalendarDateAttr a) -> IO CBool

-- | usage: (@calendarDateAttrHasBorderColour obj@).
calendarDateAttrHasBorderColour :: CalendarDateAttr  a ->  IO Bool
calendarDateAttrHasBorderColour _obj 
  = withBoolResult $
    withObjectRef "calendarDateAttrHasBorderColour" _obj $ \cobj__obj -> 
    wxCalendarDateAttr_HasBorderColour cobj__obj  
foreign import ccall "wxCalendarDateAttr_HasBorderColour" wxCalendarDateAttr_HasBorderColour :: Ptr (TCalendarDateAttr a) -> IO CBool

-- | usage: (@calendarDateAttrHasFont obj@).
calendarDateAttrHasFont :: CalendarDateAttr  a ->  IO Bool
calendarDateAttrHasFont _obj 
  = withBoolResult $
    withObjectRef "calendarDateAttrHasFont" _obj $ \cobj__obj -> 
    wxCalendarDateAttr_HasFont cobj__obj  
foreign import ccall "wxCalendarDateAttr_HasFont" wxCalendarDateAttr_HasFont :: Ptr (TCalendarDateAttr a) -> IO CBool

-- | usage: (@calendarDateAttrHasTextColour obj@).
calendarDateAttrHasTextColour :: CalendarDateAttr  a ->  IO Bool
calendarDateAttrHasTextColour _obj 
  = withBoolResult $
    withObjectRef "calendarDateAttrHasTextColour" _obj $ \cobj__obj -> 
    wxCalendarDateAttr_HasTextColour cobj__obj  
foreign import ccall "wxCalendarDateAttr_HasTextColour" wxCalendarDateAttr_HasTextColour :: Ptr (TCalendarDateAttr a) -> IO CBool

-- | usage: (@calendarDateAttrIsHoliday obj@).
calendarDateAttrIsHoliday :: CalendarDateAttr  a ->  IO Bool
calendarDateAttrIsHoliday _obj 
  = withBoolResult $
    withObjectRef "calendarDateAttrIsHoliday" _obj $ \cobj__obj -> 
    wxCalendarDateAttr_IsHoliday cobj__obj  
foreign import ccall "wxCalendarDateAttr_IsHoliday" wxCalendarDateAttr_IsHoliday :: Ptr (TCalendarDateAttr a) -> IO CBool

-- | usage: (@calendarDateAttrSetBackgroundColour obj col@).
calendarDateAttrSetBackgroundColour :: CalendarDateAttr  a -> Color ->  IO ()
calendarDateAttrSetBackgroundColour _obj col 
  = withObjectRef "calendarDateAttrSetBackgroundColour" _obj $ \cobj__obj -> 
    withColourPtr col $ \cobj_col -> 
    wxCalendarDateAttr_SetBackgroundColour cobj__obj  cobj_col  
foreign import ccall "wxCalendarDateAttr_SetBackgroundColour" wxCalendarDateAttr_SetBackgroundColour :: Ptr (TCalendarDateAttr a) -> Ptr (TColour b) -> IO ()

-- | usage: (@calendarDateAttrSetBorder obj border@).
calendarDateAttrSetBorder :: CalendarDateAttr  a -> Int ->  IO ()
calendarDateAttrSetBorder _obj border 
  = withObjectRef "calendarDateAttrSetBorder" _obj $ \cobj__obj -> 
    wxCalendarDateAttr_SetBorder cobj__obj  (toCInt border)  
foreign import ccall "wxCalendarDateAttr_SetBorder" wxCalendarDateAttr_SetBorder :: Ptr (TCalendarDateAttr a) -> CInt -> IO ()

-- | usage: (@calendarDateAttrSetBorderColour obj col@).
calendarDateAttrSetBorderColour :: CalendarDateAttr  a -> Color ->  IO ()
calendarDateAttrSetBorderColour _obj col 
  = withObjectRef "calendarDateAttrSetBorderColour" _obj $ \cobj__obj -> 
    withColourPtr col $ \cobj_col -> 
    wxCalendarDateAttr_SetBorderColour cobj__obj  cobj_col  
foreign import ccall "wxCalendarDateAttr_SetBorderColour" wxCalendarDateAttr_SetBorderColour :: Ptr (TCalendarDateAttr a) -> Ptr (TColour b) -> IO ()

-- | usage: (@calendarDateAttrSetFont obj font@).
calendarDateAttrSetFont :: CalendarDateAttr  a -> Font  b ->  IO ()
calendarDateAttrSetFont _obj font 
  = withObjectRef "calendarDateAttrSetFont" _obj $ \cobj__obj -> 
    withObjectPtr font $ \cobj_font -> 
    wxCalendarDateAttr_SetFont cobj__obj  cobj_font  
foreign import ccall "wxCalendarDateAttr_SetFont" wxCalendarDateAttr_SetFont :: Ptr (TCalendarDateAttr a) -> Ptr (TFont b) -> IO ()

-- | usage: (@calendarDateAttrSetHoliday obj holiday@).
calendarDateAttrSetHoliday :: CalendarDateAttr  a -> Int ->  IO ()
calendarDateAttrSetHoliday _obj holiday 
  = withObjectRef "calendarDateAttrSetHoliday" _obj $ \cobj__obj -> 
    wxCalendarDateAttr_SetHoliday cobj__obj  (toCInt holiday)  
foreign import ccall "wxCalendarDateAttr_SetHoliday" wxCalendarDateAttr_SetHoliday :: Ptr (TCalendarDateAttr a) -> CInt -> IO ()

-- | usage: (@calendarDateAttrSetTextColour obj col@).
calendarDateAttrSetTextColour :: CalendarDateAttr  a -> Color ->  IO ()
calendarDateAttrSetTextColour _obj col 
  = withObjectRef "calendarDateAttrSetTextColour" _obj $ \cobj__obj -> 
    withColourPtr col $ \cobj_col -> 
    wxCalendarDateAttr_SetTextColour cobj__obj  cobj_col  
foreign import ccall "wxCalendarDateAttr_SetTextColour" wxCalendarDateAttr_SetTextColour :: Ptr (TCalendarDateAttr a) -> Ptr (TColour b) -> IO ()

-- | usage: (@calendarEventGetDate obj dte@).
calendarEventGetDate :: CalendarEvent  a -> Ptr  b ->  IO ()
calendarEventGetDate _obj _dte 
  = withObjectRef "calendarEventGetDate" _obj $ \cobj__obj -> 
    wxCalendarEvent_GetDate cobj__obj  _dte  
foreign import ccall "wxCalendarEvent_GetDate" wxCalendarEvent_GetDate :: Ptr (TCalendarEvent a) -> Ptr  b -> IO ()

-- | usage: (@calendarEventGetWeekDay obj@).
calendarEventGetWeekDay :: CalendarEvent  a ->  IO Int
calendarEventGetWeekDay _obj 
  = withIntResult $
    withObjectRef "calendarEventGetWeekDay" _obj $ \cobj__obj -> 
    wxCalendarEvent_GetWeekDay cobj__obj  
foreign import ccall "wxCalendarEvent_GetWeekDay" wxCalendarEvent_GetWeekDay :: Ptr (TCalendarEvent a) -> IO CInt

-- | usage: (@caretCreate wnd wth hgt@).
caretCreate :: Window  a -> Int -> Int ->  IO (Caret  ())
caretCreate _wnd _wth _hgt 
  = withObjectResult $
    withObjectPtr _wnd $ \cobj__wnd -> 
    wxCaret_Create cobj__wnd  (toCInt _wth)  (toCInt _hgt)  
foreign import ccall "wxCaret_Create" wxCaret_Create :: Ptr (TWindow a) -> CInt -> CInt -> IO (Ptr (TCaret ()))

-- | usage: (@caretGetBlinkTime@).
caretGetBlinkTime ::  IO Int
caretGetBlinkTime 
  = withIntResult $
    wxCaret_GetBlinkTime 
foreign import ccall "wxCaret_GetBlinkTime" wxCaret_GetBlinkTime :: IO CInt

-- | usage: (@caretGetPosition obj@).
caretGetPosition :: Caret  a ->  IO (Point)
caretGetPosition _obj 
  = withWxPointResult $
    withObjectRef "caretGetPosition" _obj $ \cobj__obj -> 
    wxCaret_GetPosition cobj__obj  
foreign import ccall "wxCaret_GetPosition" wxCaret_GetPosition :: Ptr (TCaret a) -> IO (Ptr (TWxPoint ()))

-- | usage: (@caretGetSize obj@).
caretGetSize :: Caret  a ->  IO (Size)
caretGetSize _obj 
  = withWxSizeResult $
    withObjectRef "caretGetSize" _obj $ \cobj__obj -> 
    wxCaret_GetSize cobj__obj  
foreign import ccall "wxCaret_GetSize" wxCaret_GetSize :: Ptr (TCaret a) -> IO (Ptr (TWxSize ()))

-- | usage: (@caretGetWindow obj@).
caretGetWindow :: Caret  a ->  IO (Window  ())
caretGetWindow _obj 
  = withObjectResult $
    withObjectRef "caretGetWindow" _obj $ \cobj__obj -> 
    wxCaret_GetWindow cobj__obj  
foreign import ccall "wxCaret_GetWindow" wxCaret_GetWindow :: Ptr (TCaret a) -> IO (Ptr (TWindow ()))

-- | usage: (@caretHide obj@).
caretHide :: Caret  a ->  IO ()
caretHide _obj 
  = withObjectRef "caretHide" _obj $ \cobj__obj -> 
    wxCaret_Hide cobj__obj  
foreign import ccall "wxCaret_Hide" wxCaret_Hide :: Ptr (TCaret a) -> IO ()

-- | usage: (@caretIsOk obj@).
caretIsOk :: Caret  a ->  IO Bool
caretIsOk _obj 
  = withBoolResult $
    withObjectRef "caretIsOk" _obj $ \cobj__obj -> 
    wxCaret_IsOk cobj__obj  
foreign import ccall "wxCaret_IsOk" wxCaret_IsOk :: Ptr (TCaret a) -> IO CBool

-- | usage: (@caretIsVisible obj@).
caretIsVisible :: Caret  a ->  IO Bool
caretIsVisible _obj 
  = withBoolResult $
    withObjectRef "caretIsVisible" _obj $ \cobj__obj -> 
    wxCaret_IsVisible cobj__obj  
foreign import ccall "wxCaret_IsVisible" wxCaret_IsVisible :: Ptr (TCaret a) -> IO CBool

-- | usage: (@caretMove obj xy@).
caretMove :: Caret  a -> Point ->  IO ()
caretMove _obj xy 
  = withObjectRef "caretMove" _obj $ \cobj__obj -> 
    wxCaret_Move cobj__obj  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxCaret_Move" wxCaret_Move :: Ptr (TCaret a) -> CInt -> CInt -> IO ()

-- | usage: (@caretSetBlinkTime milliseconds@).
caretSetBlinkTime :: Int ->  IO ()
caretSetBlinkTime milliseconds 
  = wxCaret_SetBlinkTime (toCInt milliseconds)  
foreign import ccall "wxCaret_SetBlinkTime" wxCaret_SetBlinkTime :: CInt -> IO ()

-- | usage: (@caretSetSize obj widthheight@).
caretSetSize :: Caret  a -> Size ->  IO ()
caretSetSize _obj widthheight 
  = withObjectRef "caretSetSize" _obj $ \cobj__obj -> 
    wxCaret_SetSize cobj__obj  (toCIntSizeW widthheight) (toCIntSizeH widthheight)  
foreign import ccall "wxCaret_SetSize" wxCaret_SetSize :: Ptr (TCaret a) -> CInt -> CInt -> IO ()

-- | usage: (@caretShow obj@).
caretShow :: Caret  a ->  IO ()
caretShow _obj 
  = withObjectRef "caretShow" _obj $ \cobj__obj -> 
    wxCaret_Show cobj__obj  
foreign import ccall "wxCaret_Show" wxCaret_Show :: Ptr (TCaret a) -> IO ()

-- | usage: (@checkBoxCreate prt id txt lfttopwdthgt stl@).
checkBoxCreate :: Window  a -> Id -> String -> Rect -> Style ->  IO (CheckBox  ())
checkBoxCreate _prt _id _txt _lfttopwdthgt _stl 
  = withObjectResult $
    withObjectPtr _prt $ \cobj__prt -> 
    withStringPtr _txt $ \cobj__txt -> 
    wxCheckBox_Create cobj__prt  (toCInt _id)  cobj__txt  (toCIntRectX _lfttopwdthgt) (toCIntRectY _lfttopwdthgt)(toCIntRectW _lfttopwdthgt) (toCIntRectH _lfttopwdthgt)  (toCInt _stl)  
foreign import ccall "wxCheckBox_Create" wxCheckBox_Create :: Ptr (TWindow a) -> CInt -> Ptr (TWxString c) -> CInt -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (TCheckBox ()))

-- | usage: (@checkBoxDelete obj@).
checkBoxDelete :: CheckBox  a ->  IO ()
checkBoxDelete
  = objectDelete


-- | usage: (@checkBoxGetValue obj@).
checkBoxGetValue :: CheckBox  a ->  IO Bool
checkBoxGetValue _obj 
  = withBoolResult $
    withObjectRef "checkBoxGetValue" _obj $ \cobj__obj -> 
    wxCheckBox_GetValue cobj__obj  
foreign import ccall "wxCheckBox_GetValue" wxCheckBox_GetValue :: Ptr (TCheckBox a) -> IO CBool

-- | usage: (@checkBoxSetValue obj value@).
checkBoxSetValue :: CheckBox  a -> Bool ->  IO ()
checkBoxSetValue _obj value 
  = withObjectRef "checkBoxSetValue" _obj $ \cobj__obj -> 
    wxCheckBox_SetValue cobj__obj  (toCBool value)  
foreign import ccall "wxCheckBox_SetValue" wxCheckBox_SetValue :: Ptr (TCheckBox a) -> CBool -> IO ()

-- | usage: (@checkListBoxCheck obj item check@).
checkListBoxCheck :: CheckListBox  a -> Int -> Bool ->  IO ()
checkListBoxCheck _obj item check 
  = withObjectRef "checkListBoxCheck" _obj $ \cobj__obj -> 
    wxCheckListBox_Check cobj__obj  (toCInt item)  (toCBool check)  
foreign import ccall "wxCheckListBox_Check" wxCheckListBox_Check :: Ptr (TCheckListBox a) -> CInt -> CBool -> IO ()

-- | usage: (@checkListBoxCreate prt id lfttopwdthgt nstr stl@).
checkListBoxCreate :: Window  a -> Id -> Rect -> [String] -> Style ->  IO (CheckListBox  ())
checkListBoxCreate _prt _id _lfttopwdthgt nstr _stl 
  = withObjectResult $
    withObjectPtr _prt $ \cobj__prt -> 
    withArrayWString nstr $ \carrlen_nstr carr_nstr -> 
    wxCheckListBox_Create cobj__prt  (toCInt _id)  (toCIntRectX _lfttopwdthgt) (toCIntRectY _lfttopwdthgt)(toCIntRectW _lfttopwdthgt) (toCIntRectH _lfttopwdthgt)  carrlen_nstr carr_nstr  (toCInt _stl)  
foreign import ccall "wxCheckListBox_Create" wxCheckListBox_Create :: Ptr (TWindow a) -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr (Ptr CWchar) -> CInt -> IO (Ptr (TCheckListBox ()))

-- | usage: (@checkListBoxDelete obj@).
checkListBoxDelete :: CheckListBox  a ->  IO ()
checkListBoxDelete
  = objectDelete


-- | usage: (@checkListBoxIsChecked obj item@).
checkListBoxIsChecked :: CheckListBox  a -> Int ->  IO Bool
checkListBoxIsChecked _obj item 
  = withBoolResult $
    withObjectRef "checkListBoxIsChecked" _obj $ \cobj__obj -> 
    wxCheckListBox_IsChecked cobj__obj  (toCInt item)  
foreign import ccall "wxCheckListBox_IsChecked" wxCheckListBox_IsChecked :: Ptr (TCheckListBox a) -> CInt -> IO CBool

-- | usage: (@choiceAppend obj item@).
choiceAppend :: Choice  a -> String ->  IO ()
choiceAppend _obj item 
  = withObjectRef "choiceAppend" _obj $ \cobj__obj -> 
    withStringPtr item $ \cobj_item -> 
    wxChoice_Append cobj__obj  cobj_item  
foreign import ccall "wxChoice_Append" wxChoice_Append :: Ptr (TChoice a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@choiceClear obj@).
choiceClear :: Choice  a ->  IO ()
choiceClear _obj 
  = withObjectRef "choiceClear" _obj $ \cobj__obj -> 
    wxChoice_Clear cobj__obj  
foreign import ccall "wxChoice_Clear" wxChoice_Clear :: Ptr (TChoice a) -> IO ()

-- | usage: (@choiceCreate prt id lfttopwdthgt nstr stl@).
choiceCreate :: Window  a -> Id -> Rect -> [String] -> Style ->  IO (Choice  ())
choiceCreate _prt _id _lfttopwdthgt nstr _stl 
  = withObjectResult $
    withObjectPtr _prt $ \cobj__prt -> 
    withArrayWString nstr $ \carrlen_nstr carr_nstr -> 
    wxChoice_Create cobj__prt  (toCInt _id)  (toCIntRectX _lfttopwdthgt) (toCIntRectY _lfttopwdthgt)(toCIntRectW _lfttopwdthgt) (toCIntRectH _lfttopwdthgt)  carrlen_nstr carr_nstr  (toCInt _stl)  
foreign import ccall "wxChoice_Create" wxChoice_Create :: Ptr (TWindow a) -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr (Ptr CWchar) -> CInt -> IO (Ptr (TChoice ()))

-- | usage: (@choiceDelete obj n@).
choiceDelete :: Choice  a -> Int ->  IO ()
choiceDelete _obj n 
  = withObjectRef "choiceDelete" _obj $ \cobj__obj -> 
    wxChoice_Delete cobj__obj  (toCInt n)  
foreign import ccall "wxChoice_Delete" wxChoice_Delete :: Ptr (TChoice a) -> CInt -> IO ()

-- | usage: (@choiceFindString obj s@).
choiceFindString :: Choice  a -> String ->  IO Int
choiceFindString _obj s 
  = withIntResult $
    withObjectRef "choiceFindString" _obj $ \cobj__obj -> 
    withStringPtr s $ \cobj_s -> 
    wxChoice_FindString cobj__obj  cobj_s  
foreign import ccall "wxChoice_FindString" wxChoice_FindString :: Ptr (TChoice a) -> Ptr (TWxString b) -> IO CInt

-- | usage: (@choiceGetCount obj@).
choiceGetCount :: Choice  a ->  IO Int
choiceGetCount _obj 
  = withIntResult $
    withObjectRef "choiceGetCount" _obj $ \cobj__obj -> 
    wxChoice_GetCount cobj__obj  
foreign import ccall "wxChoice_GetCount" wxChoice_GetCount :: Ptr (TChoice a) -> IO CInt

-- | usage: (@choiceGetSelection obj@).
choiceGetSelection :: Choice  a ->  IO Int
choiceGetSelection _obj 
  = withIntResult $
    withObjectRef "choiceGetSelection" _obj $ \cobj__obj -> 
    wxChoice_GetSelection cobj__obj  
foreign import ccall "wxChoice_GetSelection" wxChoice_GetSelection :: Ptr (TChoice a) -> IO CInt

-- | usage: (@choiceGetString obj n@).
choiceGetString :: Choice  a -> Int ->  IO (String)
choiceGetString _obj n 
  = withManagedStringResult $
    withObjectRef "choiceGetString" _obj $ \cobj__obj -> 
    wxChoice_GetString cobj__obj  (toCInt n)  
foreign import ccall "wxChoice_GetString" wxChoice_GetString :: Ptr (TChoice a) -> CInt -> IO (Ptr (TWxString ()))

-- | usage: (@choiceSetSelection obj n@).
choiceSetSelection :: Choice  a -> Int ->  IO ()
choiceSetSelection _obj n 
  = withObjectRef "choiceSetSelection" _obj $ \cobj__obj -> 
    wxChoice_SetSelection cobj__obj  (toCInt n)  
foreign import ccall "wxChoice_SetSelection" wxChoice_SetSelection :: Ptr (TChoice a) -> CInt -> IO ()

-- | usage: (@choiceSetString obj n s@).
choiceSetString :: Choice  a -> Int -> String ->  IO ()
choiceSetString _obj n s 
  = withObjectRef "choiceSetString" _obj $ \cobj__obj -> 
    withStringPtr s $ \cobj_s -> 
    wxChoice_SetString cobj__obj  (toCInt n)  cobj_s  
foreign import ccall "wxChoice_SetString" wxChoice_SetString :: Ptr (TChoice a) -> CInt -> Ptr (TWxString c) -> IO ()

-- | usage: (@classInfoCreateClassByName inf@).
classInfoCreateClassByName :: ClassInfo  a ->  IO (Ptr  ())
classInfoCreateClassByName _inf 
  = withObjectRef "classInfoCreateClassByName" _inf $ \cobj__inf -> 
    wxClassInfo_CreateClassByName cobj__inf  
foreign import ccall "wxClassInfo_CreateClassByName" wxClassInfo_CreateClassByName :: Ptr (TClassInfo a) -> IO (Ptr  ())

-- | usage: (@classInfoFindClass txt@).
classInfoFindClass :: String ->  IO (ClassInfo  ())
classInfoFindClass _txt 
  = withObjectResult $
    withStringPtr _txt $ \cobj__txt -> 
    wxClassInfo_FindClass cobj__txt  
foreign import ccall "wxClassInfo_FindClass" wxClassInfo_FindClass :: Ptr (TWxString a) -> IO (Ptr (TClassInfo ()))

-- | usage: (@classInfoGetBaseClassName1 obj@).
classInfoGetBaseClassName1 :: ClassInfo  a ->  IO (String)
classInfoGetBaseClassName1 _obj 
  = withManagedStringResult $
    withObjectRef "classInfoGetBaseClassName1" _obj $ \cobj__obj -> 
    wxClassInfo_GetBaseClassName1 cobj__obj  
foreign import ccall "wxClassInfo_GetBaseClassName1" wxClassInfo_GetBaseClassName1 :: Ptr (TClassInfo a) -> IO (Ptr (TWxString ()))

-- | usage: (@classInfoGetBaseClassName2 obj@).
classInfoGetBaseClassName2 :: ClassInfo  a ->  IO (String)
classInfoGetBaseClassName2 _obj 
  = withManagedStringResult $
    withObjectRef "classInfoGetBaseClassName2" _obj $ \cobj__obj -> 
    wxClassInfo_GetBaseClassName2 cobj__obj  
foreign import ccall "wxClassInfo_GetBaseClassName2" wxClassInfo_GetBaseClassName2 :: Ptr (TClassInfo a) -> IO (Ptr (TWxString ()))

-- | usage: (@classInfoGetClassName inf@).
classInfoGetClassName :: ClassInfo  a ->  IO (Ptr  ())
classInfoGetClassName _inf 
  = withObjectRef "classInfoGetClassName" _inf $ \cobj__inf -> 
    wxClassInfo_GetClassName cobj__inf  
foreign import ccall "wxClassInfo_GetClassName" wxClassInfo_GetClassName :: Ptr (TClassInfo a) -> IO (Ptr  ())

-- | usage: (@classInfoGetClassNameEx obj@).
classInfoGetClassNameEx :: ClassInfo  a ->  IO (String)
classInfoGetClassNameEx _obj 
  = withManagedStringResult $
    withObjectRef "classInfoGetClassNameEx" _obj $ \cobj__obj -> 
    wxClassInfo_GetClassNameEx cobj__obj  
foreign import ccall "wxClassInfo_GetClassNameEx" wxClassInfo_GetClassNameEx :: Ptr (TClassInfo a) -> IO (Ptr (TWxString ()))

-- | usage: (@classInfoGetSize obj@).
classInfoGetSize :: ClassInfo  a ->  IO Int
classInfoGetSize _obj 
  = withIntResult $
    withObjectRef "classInfoGetSize" _obj $ \cobj__obj -> 
    wxClassInfo_GetSize cobj__obj  
foreign import ccall "wxClassInfo_GetSize" wxClassInfo_GetSize :: Ptr (TClassInfo a) -> IO CInt

-- | usage: (@classInfoIsKindOf obj name@).
classInfoIsKindOf :: ClassInfo  a -> String ->  IO Bool
classInfoIsKindOf _obj _name 
  = withBoolResult $
    withObjectRef "classInfoIsKindOf" _obj $ \cobj__obj -> 
    withStringPtr _name $ \cobj__name -> 
    wxClassInfo_IsKindOf cobj__obj  cobj__name  
foreign import ccall "wxClassInfo_IsKindOf" wxClassInfo_IsKindOf :: Ptr (TClassInfo a) -> Ptr (TWxString b) -> IO CBool

-- | usage: (@classInfoIsKindOfEx obj classInfo@).
classInfoIsKindOfEx :: ClassInfo  a -> ClassInfo  b ->  IO Bool
classInfoIsKindOfEx _obj classInfo 
  = withBoolResult $
    withObjectRef "classInfoIsKindOfEx" _obj $ \cobj__obj -> 
    withObjectPtr classInfo $ \cobj_classInfo -> 
    wxClassInfo_IsKindOfEx cobj__obj  cobj_classInfo  
foreign import ccall "wxClassInfo_IsKindOfEx" wxClassInfo_IsKindOfEx :: Ptr (TClassInfo a) -> Ptr (TClassInfo b) -> IO CBool

-- | usage: (@clientDCCreate win@).
clientDCCreate :: Window  a ->  IO (ClientDC  ())
clientDCCreate win 
  = withObjectResult $
    withObjectPtr win $ \cobj_win -> 
    wxClientDC_Create cobj_win  
foreign import ccall "wxClientDC_Create" wxClientDC_Create :: Ptr (TWindow a) -> IO (Ptr (TClientDC ()))

-- | usage: (@clientDCDelete obj@).
clientDCDelete :: ClientDC  a ->  IO ()
clientDCDelete
  = objectDelete


-- | usage: (@clipboardAddData obj wxdata@).
clipboardAddData :: Clipboard  a -> DataObject  b ->  IO Bool
clipboardAddData _obj wxdata 
  = withBoolResult $
    withObjectRef "clipboardAddData" _obj $ \cobj__obj -> 
    withObjectPtr wxdata $ \cobj_wxdata -> 
    wxClipboard_AddData cobj__obj  cobj_wxdata  
foreign import ccall "wxClipboard_AddData" wxClipboard_AddData :: Ptr (TClipboard a) -> Ptr (TDataObject b) -> IO CBool

-- | usage: (@clipboardClear obj@).
clipboardClear :: Clipboard  a ->  IO ()
clipboardClear _obj 
  = withObjectRef "clipboardClear" _obj $ \cobj__obj -> 
    wxClipboard_Clear cobj__obj  
foreign import ccall "wxClipboard_Clear" wxClipboard_Clear :: Ptr (TClipboard a) -> IO ()

-- | usage: (@clipboardClose obj@).
clipboardClose :: Clipboard  a ->  IO ()
clipboardClose _obj 
  = withObjectRef "clipboardClose" _obj $ \cobj__obj -> 
    wxClipboard_Close cobj__obj  
foreign import ccall "wxClipboard_Close" wxClipboard_Close :: Ptr (TClipboard a) -> IO ()

-- | usage: (@clipboardCreate@).
clipboardCreate ::  IO (Clipboard  ())
clipboardCreate 
  = withObjectResult $
    wxClipboard_Create 
foreign import ccall "wxClipboard_Create" wxClipboard_Create :: IO (Ptr (TClipboard ()))

-- | usage: (@clipboardFlush obj@).
clipboardFlush :: Clipboard  a ->  IO Bool
clipboardFlush _obj 
  = withBoolResult $
    withObjectRef "clipboardFlush" _obj $ \cobj__obj -> 
    wxClipboard_Flush cobj__obj  
foreign import ccall "wxClipboard_Flush" wxClipboard_Flush :: Ptr (TClipboard a) -> IO CBool

-- | usage: (@clipboardGetData obj wxdata@).
clipboardGetData :: Clipboard  a -> DataObject  b ->  IO Bool
clipboardGetData _obj wxdata 
  = withBoolResult $
    withObjectRef "clipboardGetData" _obj $ \cobj__obj -> 
    withObjectPtr wxdata $ \cobj_wxdata -> 
    wxClipboard_GetData cobj__obj  cobj_wxdata  
foreign import ccall "wxClipboard_GetData" wxClipboard_GetData :: Ptr (TClipboard a) -> Ptr (TDataObject b) -> IO CBool

-- | usage: (@clipboardIsOpened obj@).
clipboardIsOpened :: Clipboard  a ->  IO Bool
clipboardIsOpened _obj 
  = withBoolResult $
    withObjectRef "clipboardIsOpened" _obj $ \cobj__obj -> 
    wxClipboard_IsOpened cobj__obj  
foreign import ccall "wxClipboard_IsOpened" wxClipboard_IsOpened :: Ptr (TClipboard a) -> IO CBool

-- | usage: (@clipboardIsSupported obj format@).
clipboardIsSupported :: Clipboard  a -> DataFormat  b ->  IO Bool
clipboardIsSupported _obj format 
  = withBoolResult $
    withObjectRef "clipboardIsSupported" _obj $ \cobj__obj -> 
    withObjectPtr format $ \cobj_format -> 
    wxClipboard_IsSupported cobj__obj  cobj_format  
foreign import ccall "wxClipboard_IsSupported" wxClipboard_IsSupported :: Ptr (TClipboard a) -> Ptr (TDataFormat b) -> IO CBool

-- | usage: (@clipboardOpen obj@).
clipboardOpen :: Clipboard  a ->  IO Bool
clipboardOpen _obj 
  = withBoolResult $
    withObjectRef "clipboardOpen" _obj $ \cobj__obj -> 
    wxClipboard_Open cobj__obj  
foreign import ccall "wxClipboard_Open" wxClipboard_Open :: Ptr (TClipboard a) -> IO CBool

-- | usage: (@clipboardSetData obj wxdata@).
clipboardSetData :: Clipboard  a -> DataObject  b ->  IO Bool
clipboardSetData _obj wxdata 
  = withBoolResult $
    withObjectRef "clipboardSetData" _obj $ \cobj__obj -> 
    withObjectPtr wxdata $ \cobj_wxdata -> 
    wxClipboard_SetData cobj__obj  cobj_wxdata  
foreign import ccall "wxClipboard_SetData" wxClipboard_SetData :: Ptr (TClipboard a) -> Ptr (TDataObject b) -> IO CBool

-- | usage: (@clipboardUsePrimarySelection obj primary@).
clipboardUsePrimarySelection :: Clipboard  a -> Bool ->  IO ()
clipboardUsePrimarySelection _obj primary 
  = withObjectRef "clipboardUsePrimarySelection" _obj $ \cobj__obj -> 
    wxClipboard_UsePrimarySelection cobj__obj  (toCBool primary)  
foreign import ccall "wxClipboard_UsePrimarySelection" wxClipboard_UsePrimarySelection :: Ptr (TClipboard a) -> CBool -> IO ()

-- | usage: (@closeEventCanVeto obj@).
closeEventCanVeto :: CloseEvent  a ->  IO Bool
closeEventCanVeto _obj 
  = withBoolResult $
    withObjectRef "closeEventCanVeto" _obj $ \cobj__obj -> 
    wxCloseEvent_CanVeto cobj__obj  
foreign import ccall "wxCloseEvent_CanVeto" wxCloseEvent_CanVeto :: Ptr (TCloseEvent a) -> IO CBool

-- | usage: (@closeEventCopyObject obj obj@).
closeEventCopyObject :: CloseEvent  a -> WxObject  b ->  IO ()
closeEventCopyObject _obj obj 
  = withObjectRef "closeEventCopyObject" _obj $ \cobj__obj -> 
    withObjectPtr obj $ \cobj_obj -> 
    wxCloseEvent_CopyObject cobj__obj  cobj_obj  
foreign import ccall "wxCloseEvent_CopyObject" wxCloseEvent_CopyObject :: Ptr (TCloseEvent a) -> Ptr (TWxObject b) -> IO ()

-- | usage: (@closeEventGetLoggingOff obj@).
closeEventGetLoggingOff :: CloseEvent  a ->  IO Bool
closeEventGetLoggingOff _obj 
  = withBoolResult $
    withObjectRef "closeEventGetLoggingOff" _obj $ \cobj__obj -> 
    wxCloseEvent_GetLoggingOff cobj__obj  
foreign import ccall "wxCloseEvent_GetLoggingOff" wxCloseEvent_GetLoggingOff :: Ptr (TCloseEvent a) -> IO CBool

-- | usage: (@closeEventGetVeto obj@).
closeEventGetVeto :: CloseEvent  a ->  IO Bool
closeEventGetVeto _obj 
  = withBoolResult $
    withObjectRef "closeEventGetVeto" _obj $ \cobj__obj -> 
    wxCloseEvent_GetVeto cobj__obj  
foreign import ccall "wxCloseEvent_GetVeto" wxCloseEvent_GetVeto :: Ptr (TCloseEvent a) -> IO CBool

-- | usage: (@closeEventSetCanVeto obj canVeto@).
closeEventSetCanVeto :: CloseEvent  a -> Bool ->  IO ()
closeEventSetCanVeto _obj canVeto 
  = withObjectRef "closeEventSetCanVeto" _obj $ \cobj__obj -> 
    wxCloseEvent_SetCanVeto cobj__obj  (toCBool canVeto)  
foreign import ccall "wxCloseEvent_SetCanVeto" wxCloseEvent_SetCanVeto :: Ptr (TCloseEvent a) -> CBool -> IO ()

-- | usage: (@closeEventSetLoggingOff obj logOff@).
closeEventSetLoggingOff :: CloseEvent  a -> Bool ->  IO ()
closeEventSetLoggingOff _obj logOff 
  = withObjectRef "closeEventSetLoggingOff" _obj $ \cobj__obj -> 
    wxCloseEvent_SetLoggingOff cobj__obj  (toCBool logOff)  
foreign import ccall "wxCloseEvent_SetLoggingOff" wxCloseEvent_SetLoggingOff :: Ptr (TCloseEvent a) -> CBool -> IO ()

-- | usage: (@closeEventVeto obj veto@).
closeEventVeto :: CloseEvent  a -> Bool ->  IO ()
closeEventVeto _obj veto 
  = withObjectRef "closeEventVeto" _obj $ \cobj__obj -> 
    wxCloseEvent_Veto cobj__obj  (toCBool veto)  
foreign import ccall "wxCloseEvent_Veto" wxCloseEvent_Veto :: Ptr (TCloseEvent a) -> CBool -> IO ()

-- | usage: (@closureCreate funCEvent wxdata@).
closureCreate :: FunPtr (Ptr fun -> Ptr state -> Ptr (TEvent evt) -> IO ()) -> Ptr  b ->  IO (Closure  ())
closureCreate _funCEvent _data 
  = withObjectResult $
    wxClosure_Create (toCFunPtr _funCEvent)  _data  
foreign import ccall "wxClosure_Create" wxClosure_Create :: Ptr (Ptr fun -> Ptr state -> Ptr (TEvent evt) -> IO ()) -> Ptr  b -> IO (Ptr (TClosure ()))

-- | usage: (@closureGetData obj@).
closureGetData :: Closure  a ->  IO (Ptr  ())
closureGetData _obj 
  = withObjectRef "closureGetData" _obj $ \cobj__obj -> 
    wxClosure_GetData cobj__obj  
foreign import ccall "wxClosure_GetData" wxClosure_GetData :: Ptr (TClosure a) -> IO (Ptr  ())

-- | usage: (@comboBoxAppend obj item@).
comboBoxAppend :: ComboBox  a -> String ->  IO ()
comboBoxAppend _obj item 
  = withObjectRef "comboBoxAppend" _obj $ \cobj__obj -> 
    withStringPtr item $ \cobj_item -> 
    wxComboBox_Append cobj__obj  cobj_item  
foreign import ccall "wxComboBox_Append" wxComboBox_Append :: Ptr (TComboBox a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@comboBoxAppendData obj item d@).
comboBoxAppendData :: ComboBox  a -> String -> Ptr  c ->  IO ()
comboBoxAppendData _obj item d 
  = withObjectRef "comboBoxAppendData" _obj $ \cobj__obj -> 
    withStringPtr item $ \cobj_item -> 
    wxComboBox_AppendData cobj__obj  cobj_item  d  
foreign import ccall "wxComboBox_AppendData" wxComboBox_AppendData :: Ptr (TComboBox a) -> Ptr (TWxString b) -> Ptr  c -> IO ()

-- | usage: (@comboBoxClear obj@).
comboBoxClear :: ComboBox  a ->  IO ()
comboBoxClear _obj 
  = withObjectRef "comboBoxClear" _obj $ \cobj__obj -> 
    wxComboBox_Clear cobj__obj  
foreign import ccall "wxComboBox_Clear" wxComboBox_Clear :: Ptr (TComboBox a) -> IO ()

-- | usage: (@comboBoxCopy obj@).
comboBoxCopy :: ComboBox  a ->  IO ()
comboBoxCopy _obj 
  = withObjectRef "comboBoxCopy" _obj $ \cobj__obj -> 
    wxComboBox_Copy cobj__obj  
foreign import ccall "wxComboBox_Copy" wxComboBox_Copy :: Ptr (TComboBox a) -> IO ()

-- | usage: (@comboBoxCreate prt id txt lfttopwdthgt nstr stl@).
comboBoxCreate :: Window  a -> Id -> String -> Rect -> [String] -> Style ->  IO (ComboBox  ())
comboBoxCreate _prt _id _txt _lfttopwdthgt nstr _stl 
  = withObjectResult $
    withObjectPtr _prt $ \cobj__prt -> 
    withStringPtr _txt $ \cobj__txt -> 
    withArrayWString nstr $ \carrlen_nstr carr_nstr -> 
    wxComboBox_Create cobj__prt  (toCInt _id)  cobj__txt  (toCIntRectX _lfttopwdthgt) (toCIntRectY _lfttopwdthgt)(toCIntRectW _lfttopwdthgt) (toCIntRectH _lfttopwdthgt)  carrlen_nstr carr_nstr  (toCInt _stl)  
foreign import ccall "wxComboBox_Create" wxComboBox_Create :: Ptr (TWindow a) -> CInt -> Ptr (TWxString c) -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr (Ptr CWchar) -> CInt -> IO (Ptr (TComboBox ()))

-- | usage: (@comboBoxCut obj@).
comboBoxCut :: ComboBox  a ->  IO ()
comboBoxCut _obj 
  = withObjectRef "comboBoxCut" _obj $ \cobj__obj -> 
    wxComboBox_Cut cobj__obj  
foreign import ccall "wxComboBox_Cut" wxComboBox_Cut :: Ptr (TComboBox a) -> IO ()

-- | usage: (@comboBoxDelete obj n@).
comboBoxDelete :: ComboBox  a -> Int ->  IO ()
comboBoxDelete _obj n 
  = withObjectRef "comboBoxDelete" _obj $ \cobj__obj -> 
    wxComboBox_Delete cobj__obj  (toCInt n)  
foreign import ccall "wxComboBox_Delete" wxComboBox_Delete :: Ptr (TComboBox a) -> CInt -> IO ()

-- | usage: (@comboBoxFindString obj s@).
comboBoxFindString :: ComboBox  a -> String ->  IO Int
comboBoxFindString _obj s 
  = withIntResult $
    withObjectRef "comboBoxFindString" _obj $ \cobj__obj -> 
    withStringPtr s $ \cobj_s -> 
    wxComboBox_FindString cobj__obj  cobj_s  
foreign import ccall "wxComboBox_FindString" wxComboBox_FindString :: Ptr (TComboBox a) -> Ptr (TWxString b) -> IO CInt

-- | usage: (@comboBoxGetClientData obj n@).
comboBoxGetClientData :: ComboBox  a -> Int ->  IO (ClientData  ())
comboBoxGetClientData _obj n 
  = withObjectResult $
    withObjectRef "comboBoxGetClientData" _obj $ \cobj__obj -> 
    wxComboBox_GetClientData cobj__obj  (toCInt n)  
foreign import ccall "wxComboBox_GetClientData" wxComboBox_GetClientData :: Ptr (TComboBox a) -> CInt -> IO (Ptr (TClientData ()))

-- | usage: (@comboBoxGetCount obj@).
comboBoxGetCount :: ComboBox  a ->  IO Int
comboBoxGetCount _obj 
  = withIntResult $
    withObjectRef "comboBoxGetCount" _obj $ \cobj__obj -> 
    wxComboBox_GetCount cobj__obj  
foreign import ccall "wxComboBox_GetCount" wxComboBox_GetCount :: Ptr (TComboBox a) -> IO CInt

-- | usage: (@comboBoxGetInsertionPoint obj@).
comboBoxGetInsertionPoint :: ComboBox  a ->  IO Int
comboBoxGetInsertionPoint _obj 
  = withIntResult $
    withObjectRef "comboBoxGetInsertionPoint" _obj $ \cobj__obj -> 
    wxComboBox_GetInsertionPoint cobj__obj  
foreign import ccall "wxComboBox_GetInsertionPoint" wxComboBox_GetInsertionPoint :: Ptr (TComboBox a) -> IO CInt

-- | usage: (@comboBoxGetLastPosition obj@).
comboBoxGetLastPosition :: ComboBox  a ->  IO Int
comboBoxGetLastPosition _obj 
  = withIntResult $
    withObjectRef "comboBoxGetLastPosition" _obj $ \cobj__obj -> 
    wxComboBox_GetLastPosition cobj__obj  
foreign import ccall "wxComboBox_GetLastPosition" wxComboBox_GetLastPosition :: Ptr (TComboBox a) -> IO CInt

-- | usage: (@comboBoxGetSelection obj@).
comboBoxGetSelection :: ComboBox  a ->  IO Int
comboBoxGetSelection _obj 
  = withIntResult $
    withObjectRef "comboBoxGetSelection" _obj $ \cobj__obj -> 
    wxComboBox_GetSelection cobj__obj  
foreign import ccall "wxComboBox_GetSelection" wxComboBox_GetSelection :: Ptr (TComboBox a) -> IO CInt

-- | usage: (@comboBoxGetString obj n@).
comboBoxGetString :: ComboBox  a -> Int ->  IO (String)
comboBoxGetString _obj n 
  = withManagedStringResult $
    withObjectRef "comboBoxGetString" _obj $ \cobj__obj -> 
    wxComboBox_GetString cobj__obj  (toCInt n)  
foreign import ccall "wxComboBox_GetString" wxComboBox_GetString :: Ptr (TComboBox a) -> CInt -> IO (Ptr (TWxString ()))

-- | usage: (@comboBoxGetStringSelection obj@).
comboBoxGetStringSelection :: ComboBox  a ->  IO (String)
comboBoxGetStringSelection _obj 
  = withManagedStringResult $
    withObjectRef "comboBoxGetStringSelection" _obj $ \cobj__obj -> 
    wxComboBox_GetStringSelection cobj__obj  
foreign import ccall "wxComboBox_GetStringSelection" wxComboBox_GetStringSelection :: Ptr (TComboBox a) -> IO (Ptr (TWxString ()))

-- | usage: (@comboBoxGetValue obj@).
comboBoxGetValue :: ComboBox  a ->  IO (String)
comboBoxGetValue _obj 
  = withManagedStringResult $
    withObjectRef "comboBoxGetValue" _obj $ \cobj__obj -> 
    wxComboBox_GetValue cobj__obj  
foreign import ccall "wxComboBox_GetValue" wxComboBox_GetValue :: Ptr (TComboBox a) -> IO (Ptr (TWxString ()))

-- | usage: (@comboBoxPaste obj@).
comboBoxPaste :: ComboBox  a ->  IO ()
comboBoxPaste _obj 
  = withObjectRef "comboBoxPaste" _obj $ \cobj__obj -> 
    wxComboBox_Paste cobj__obj  
foreign import ccall "wxComboBox_Paste" wxComboBox_Paste :: Ptr (TComboBox a) -> IO ()

-- | usage: (@comboBoxRemove obj from to@).
comboBoxRemove :: ComboBox  a -> Int -> Int ->  IO ()
comboBoxRemove _obj from to 
  = withObjectRef "comboBoxRemove" _obj $ \cobj__obj -> 
    wxComboBox_Remove cobj__obj  (toCInt from)  (toCInt to)  
foreign import ccall "wxComboBox_Remove" wxComboBox_Remove :: Ptr (TComboBox a) -> CInt -> CInt -> IO ()

-- | usage: (@comboBoxReplace obj from to value@).
comboBoxReplace :: ComboBox  a -> Int -> Int -> String ->  IO ()
comboBoxReplace _obj from to value 
  = withObjectRef "comboBoxReplace" _obj $ \cobj__obj -> 
    withStringPtr value $ \cobj_value -> 
    wxComboBox_Replace cobj__obj  (toCInt from)  (toCInt to)  cobj_value  
foreign import ccall "wxComboBox_Replace" wxComboBox_Replace :: Ptr (TComboBox a) -> CInt -> CInt -> Ptr (TWxString d) -> IO ()

-- | usage: (@comboBoxSetClientData obj n clientData@).
comboBoxSetClientData :: ComboBox  a -> Int -> ClientData  c ->  IO ()
comboBoxSetClientData _obj n clientData 
  = withObjectRef "comboBoxSetClientData" _obj $ \cobj__obj -> 
    withObjectPtr clientData $ \cobj_clientData -> 
    wxComboBox_SetClientData cobj__obj  (toCInt n)  cobj_clientData  
foreign import ccall "wxComboBox_SetClientData" wxComboBox_SetClientData :: Ptr (TComboBox a) -> CInt -> Ptr (TClientData c) -> IO ()

-- | usage: (@comboBoxSetEditable obj editable@).
comboBoxSetEditable :: ComboBox  a -> Bool ->  IO ()
comboBoxSetEditable _obj editable 
  = withObjectRef "comboBoxSetEditable" _obj $ \cobj__obj -> 
    wxComboBox_SetEditable cobj__obj  (toCBool editable)  
foreign import ccall "wxComboBox_SetEditable" wxComboBox_SetEditable :: Ptr (TComboBox a) -> CBool -> IO ()

-- | usage: (@comboBoxSetInsertionPoint obj pos@).
comboBoxSetInsertionPoint :: ComboBox  a -> Int ->  IO ()
comboBoxSetInsertionPoint _obj pos 
  = withObjectRef "comboBoxSetInsertionPoint" _obj $ \cobj__obj -> 
    wxComboBox_SetInsertionPoint cobj__obj  (toCInt pos)  
foreign import ccall "wxComboBox_SetInsertionPoint" wxComboBox_SetInsertionPoint :: Ptr (TComboBox a) -> CInt -> IO ()

-- | usage: (@comboBoxSetInsertionPointEnd obj@).
comboBoxSetInsertionPointEnd :: ComboBox  a ->  IO ()
comboBoxSetInsertionPointEnd _obj 
  = withObjectRef "comboBoxSetInsertionPointEnd" _obj $ \cobj__obj -> 
    wxComboBox_SetInsertionPointEnd cobj__obj  
foreign import ccall "wxComboBox_SetInsertionPointEnd" wxComboBox_SetInsertionPointEnd :: Ptr (TComboBox a) -> IO ()

-- | usage: (@comboBoxSetSelection obj n@).
comboBoxSetSelection :: ComboBox  a -> Int ->  IO ()
comboBoxSetSelection _obj n 
  = withObjectRef "comboBoxSetSelection" _obj $ \cobj__obj -> 
    wxComboBox_SetSelection cobj__obj  (toCInt n)  
foreign import ccall "wxComboBox_SetSelection" wxComboBox_SetSelection :: Ptr (TComboBox a) -> CInt -> IO ()

-- | usage: (@comboBoxSetTextSelection obj from to@).
comboBoxSetTextSelection :: ComboBox  a -> Int -> Int ->  IO ()
comboBoxSetTextSelection _obj from to 
  = withObjectRef "comboBoxSetTextSelection" _obj $ \cobj__obj -> 
    wxComboBox_SetTextSelection cobj__obj  (toCInt from)  (toCInt to)  
foreign import ccall "wxComboBox_SetTextSelection" wxComboBox_SetTextSelection :: Ptr (TComboBox a) -> CInt -> CInt -> IO ()

-- | usage: (@commandEventCopyObject obj objectdest@).
commandEventCopyObject :: CommandEvent  a -> Ptr  b ->  IO ()
commandEventCopyObject _obj objectdest 
  = withObjectRef "commandEventCopyObject" _obj $ \cobj__obj -> 
    wxCommandEvent_CopyObject cobj__obj  objectdest  
foreign import ccall "wxCommandEvent_CopyObject" wxCommandEvent_CopyObject :: Ptr (TCommandEvent a) -> Ptr  b -> IO ()

-- | usage: (@commandEventCreate typ id@).
commandEventCreate :: Int -> Id ->  IO (CommandEvent  ())
commandEventCreate _typ _id 
  = withObjectResult $
    wxCommandEvent_Create (toCInt _typ)  (toCInt _id)  
foreign import ccall "wxCommandEvent_Create" wxCommandEvent_Create :: CInt -> CInt -> IO (Ptr (TCommandEvent ()))

-- | usage: (@commandEventDelete obj@).
commandEventDelete :: CommandEvent  a ->  IO ()
commandEventDelete
  = objectDelete


-- | usage: (@commandEventGetClientData obj@).
commandEventGetClientData :: CommandEvent  a ->  IO (ClientData  ())
commandEventGetClientData _obj 
  = withObjectResult $
    withObjectRef "commandEventGetClientData" _obj $ \cobj__obj -> 
    wxCommandEvent_GetClientData cobj__obj  
foreign import ccall "wxCommandEvent_GetClientData" wxCommandEvent_GetClientData :: Ptr (TCommandEvent a) -> IO (Ptr (TClientData ()))

-- | usage: (@commandEventGetClientObject obj@).
commandEventGetClientObject :: CommandEvent  a ->  IO (ClientData  ())
commandEventGetClientObject _obj 
  = withObjectResult $
    withObjectRef "commandEventGetClientObject" _obj $ \cobj__obj -> 
    wxCommandEvent_GetClientObject cobj__obj  
foreign import ccall "wxCommandEvent_GetClientObject" wxCommandEvent_GetClientObject :: Ptr (TCommandEvent a) -> IO (Ptr (TClientData ()))

-- | usage: (@commandEventGetExtraLong obj@).
commandEventGetExtraLong :: CommandEvent  a ->  IO Int
commandEventGetExtraLong _obj 
  = withIntResult $
    withObjectRef "commandEventGetExtraLong" _obj $ \cobj__obj -> 
    wxCommandEvent_GetExtraLong cobj__obj  
foreign import ccall "wxCommandEvent_GetExtraLong" wxCommandEvent_GetExtraLong :: Ptr (TCommandEvent a) -> IO CInt

-- | usage: (@commandEventGetInt obj@).
commandEventGetInt :: CommandEvent  a ->  IO Int
commandEventGetInt _obj 
  = withIntResult $
    withObjectRef "commandEventGetInt" _obj $ \cobj__obj -> 
    wxCommandEvent_GetInt cobj__obj  
foreign import ccall "wxCommandEvent_GetInt" wxCommandEvent_GetInt :: Ptr (TCommandEvent a) -> IO CInt

-- | usage: (@commandEventGetSelection obj@).
commandEventGetSelection :: CommandEvent  a ->  IO Int
commandEventGetSelection _obj 
  = withIntResult $
    withObjectRef "commandEventGetSelection" _obj $ \cobj__obj -> 
    wxCommandEvent_GetSelection cobj__obj  
foreign import ccall "wxCommandEvent_GetSelection" wxCommandEvent_GetSelection :: Ptr (TCommandEvent a) -> IO CInt

-- | usage: (@commandEventGetString obj@).
commandEventGetString :: CommandEvent  a ->  IO (String)
commandEventGetString _obj 
  = withManagedStringResult $
    withObjectRef "commandEventGetString" _obj $ \cobj__obj -> 
    wxCommandEvent_GetString cobj__obj  
foreign import ccall "wxCommandEvent_GetString" wxCommandEvent_GetString :: Ptr (TCommandEvent a) -> IO (Ptr (TWxString ()))

-- | usage: (@commandEventIsChecked obj@).
commandEventIsChecked :: CommandEvent  a ->  IO Bool
commandEventIsChecked _obj 
  = withBoolResult $
    withObjectRef "commandEventIsChecked" _obj $ \cobj__obj -> 
    wxCommandEvent_IsChecked cobj__obj  
foreign import ccall "wxCommandEvent_IsChecked" wxCommandEvent_IsChecked :: Ptr (TCommandEvent a) -> IO CBool

-- | usage: (@commandEventIsSelection obj@).
commandEventIsSelection :: CommandEvent  a ->  IO Bool
commandEventIsSelection _obj 
  = withBoolResult $
    withObjectRef "commandEventIsSelection" _obj $ \cobj__obj -> 
    wxCommandEvent_IsSelection cobj__obj  
foreign import ccall "wxCommandEvent_IsSelection" wxCommandEvent_IsSelection :: Ptr (TCommandEvent a) -> IO CBool

-- | usage: (@commandEventSetClientData obj clientData@).
commandEventSetClientData :: CommandEvent  a -> ClientData  b ->  IO ()
commandEventSetClientData _obj clientData 
  = withObjectRef "commandEventSetClientData" _obj $ \cobj__obj -> 
    withObjectPtr clientData $ \cobj_clientData -> 
    wxCommandEvent_SetClientData cobj__obj  cobj_clientData  
foreign import ccall "wxCommandEvent_SetClientData" wxCommandEvent_SetClientData :: Ptr (TCommandEvent a) -> Ptr (TClientData b) -> IO ()

-- | usage: (@commandEventSetClientObject obj clientObject@).
commandEventSetClientObject :: CommandEvent  a -> ClientData  b ->  IO ()
commandEventSetClientObject _obj clientObject 
  = withObjectRef "commandEventSetClientObject" _obj $ \cobj__obj -> 
    withObjectPtr clientObject $ \cobj_clientObject -> 
    wxCommandEvent_SetClientObject cobj__obj  cobj_clientObject  
foreign import ccall "wxCommandEvent_SetClientObject" wxCommandEvent_SetClientObject :: Ptr (TCommandEvent a) -> Ptr (TClientData b) -> IO ()

-- | usage: (@commandEventSetExtraLong obj extraLong@).
commandEventSetExtraLong :: CommandEvent  a -> Int ->  IO ()
commandEventSetExtraLong _obj extraLong 
  = withObjectRef "commandEventSetExtraLong" _obj $ \cobj__obj -> 
    wxCommandEvent_SetExtraLong cobj__obj  (toCInt extraLong)  
foreign import ccall "wxCommandEvent_SetExtraLong" wxCommandEvent_SetExtraLong :: Ptr (TCommandEvent a) -> CInt -> IO ()

-- | usage: (@commandEventSetInt obj i@).
commandEventSetInt :: CommandEvent  a -> Int ->  IO ()
commandEventSetInt _obj i 
  = withObjectRef "commandEventSetInt" _obj $ \cobj__obj -> 
    wxCommandEvent_SetInt cobj__obj  (toCInt i)  
foreign import ccall "wxCommandEvent_SetInt" wxCommandEvent_SetInt :: Ptr (TCommandEvent a) -> CInt -> IO ()

-- | usage: (@commandEventSetString obj s@).
commandEventSetString :: CommandEvent  a -> String ->  IO ()
commandEventSetString _obj s 
  = withObjectRef "commandEventSetString" _obj $ \cobj__obj -> 
    withStringPtr s $ \cobj_s -> 
    wxCommandEvent_SetString cobj__obj  cobj_s  
foreign import ccall "wxCommandEvent_SetString" wxCommandEvent_SetString :: Ptr (TCommandEvent a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@configBaseCreate@).
configBaseCreate ::  IO (ConfigBase  ())
configBaseCreate 
  = withObjectResult $
    wxConfigBase_Create 
foreign import ccall "wxConfigBase_Create" wxConfigBase_Create :: IO (Ptr (TConfigBase ()))

-- | usage: (@configBaseDelete obj@).
configBaseDelete :: ConfigBase  a ->  IO ()
configBaseDelete _obj 
  = withObjectRef "configBaseDelete" _obj $ \cobj__obj -> 
    wxConfigBase_Delete cobj__obj  
foreign import ccall "wxConfigBase_Delete" wxConfigBase_Delete :: Ptr (TConfigBase a) -> IO ()

-- | usage: (@configBaseDeleteAll obj@).
configBaseDeleteAll :: ConfigBase  a ->  IO Bool
configBaseDeleteAll _obj 
  = withBoolResult $
    withObjectRef "configBaseDeleteAll" _obj $ \cobj__obj -> 
    wxConfigBase_DeleteAll cobj__obj  
foreign import ccall "wxConfigBase_DeleteAll" wxConfigBase_DeleteAll :: Ptr (TConfigBase a) -> IO CBool

-- | usage: (@configBaseDeleteEntry obj key bDeleteGroupIfEmpty@).
configBaseDeleteEntry :: ConfigBase  a -> String -> Bool ->  IO Bool
configBaseDeleteEntry _obj key bDeleteGroupIfEmpty 
  = withBoolResult $
    withObjectRef "configBaseDeleteEntry" _obj $ \cobj__obj -> 
    withStringPtr key $ \cobj_key -> 
    wxConfigBase_DeleteEntry cobj__obj  cobj_key  (toCBool bDeleteGroupIfEmpty)  
foreign import ccall "wxConfigBase_DeleteEntry" wxConfigBase_DeleteEntry :: Ptr (TConfigBase a) -> Ptr (TWxString b) -> CBool -> IO CBool

-- | usage: (@configBaseDeleteGroup obj key@).
configBaseDeleteGroup :: ConfigBase  a -> String ->  IO Bool
configBaseDeleteGroup _obj key 
  = withBoolResult $
    withObjectRef "configBaseDeleteGroup" _obj $ \cobj__obj -> 
    withStringPtr key $ \cobj_key -> 
    wxConfigBase_DeleteGroup cobj__obj  cobj_key  
foreign import ccall "wxConfigBase_DeleteGroup" wxConfigBase_DeleteGroup :: Ptr (TConfigBase a) -> Ptr (TWxString b) -> IO CBool

-- | usage: (@configBaseExists obj strName@).
configBaseExists :: ConfigBase  a -> String ->  IO Bool
configBaseExists _obj strName 
  = withBoolResult $
    withObjectRef "configBaseExists" _obj $ \cobj__obj -> 
    withStringPtr strName $ \cobj_strName -> 
    wxConfigBase_Exists cobj__obj  cobj_strName  
foreign import ccall "wxConfigBase_Exists" wxConfigBase_Exists :: Ptr (TConfigBase a) -> Ptr (TWxString b) -> IO CBool

-- | usage: (@configBaseExpandEnvVars obj str@).
configBaseExpandEnvVars :: ConfigBase  a -> String ->  IO (String)
configBaseExpandEnvVars _obj str 
  = withManagedStringResult $
    withObjectRef "configBaseExpandEnvVars" _obj $ \cobj__obj -> 
    withStringPtr str $ \cobj_str -> 
    wxConfigBase_ExpandEnvVars cobj__obj  cobj_str  
foreign import ccall "wxConfigBase_ExpandEnvVars" wxConfigBase_ExpandEnvVars :: Ptr (TConfigBase a) -> Ptr (TWxString b) -> IO (Ptr (TWxString ()))

-- | usage: (@configBaseFlush obj bCurrentOnly@).
configBaseFlush :: ConfigBase  a -> Bool ->  IO Bool
configBaseFlush _obj bCurrentOnly 
  = withBoolResult $
    withObjectRef "configBaseFlush" _obj $ \cobj__obj -> 
    wxConfigBase_Flush cobj__obj  (toCBool bCurrentOnly)  
foreign import ccall "wxConfigBase_Flush" wxConfigBase_Flush :: Ptr (TConfigBase a) -> CBool -> IO CBool

-- | usage: (@configBaseGet@).
configBaseGet ::  IO (ConfigBase  ())
configBaseGet 
  = withObjectResult $
    wxConfigBase_Get 
foreign import ccall "wxConfigBase_Get" wxConfigBase_Get :: IO (Ptr (TConfigBase ()))

-- | usage: (@configBaseGetAppName obj@).
configBaseGetAppName :: ConfigBase  a ->  IO (String)
configBaseGetAppName _obj 
  = withManagedStringResult $
    withObjectRef "configBaseGetAppName" _obj $ \cobj__obj -> 
    wxConfigBase_GetAppName cobj__obj  
foreign import ccall "wxConfigBase_GetAppName" wxConfigBase_GetAppName :: Ptr (TConfigBase a) -> IO (Ptr (TWxString ()))

-- | usage: (@configBaseGetEntryType obj name@).
configBaseGetEntryType :: ConfigBase  a -> String ->  IO Int
configBaseGetEntryType _obj name 
  = withIntResult $
    withObjectRef "configBaseGetEntryType" _obj $ \cobj__obj -> 
    withStringPtr name $ \cobj_name -> 
    wxConfigBase_GetEntryType cobj__obj  cobj_name  
foreign import ccall "wxConfigBase_GetEntryType" wxConfigBase_GetEntryType :: Ptr (TConfigBase a) -> Ptr (TWxString b) -> IO CInt

-- | usage: (@configBaseGetFirstEntry obj lIndex@).
configBaseGetFirstEntry :: ConfigBase  a -> Ptr  b ->  IO (String)
configBaseGetFirstEntry _obj lIndex 
  = withManagedStringResult $
    withObjectRef "configBaseGetFirstEntry" _obj $ \cobj__obj -> 
    wxConfigBase_GetFirstEntry cobj__obj  lIndex  
foreign import ccall "wxConfigBase_GetFirstEntry" wxConfigBase_GetFirstEntry :: Ptr (TConfigBase a) -> Ptr  b -> IO (Ptr (TWxString ()))

-- | usage: (@configBaseGetFirstGroup obj lIndex@).
configBaseGetFirstGroup :: ConfigBase  a -> Ptr  b ->  IO (String)
configBaseGetFirstGroup _obj lIndex 
  = withManagedStringResult $
    withObjectRef "configBaseGetFirstGroup" _obj $ \cobj__obj -> 
    wxConfigBase_GetFirstGroup cobj__obj  lIndex  
foreign import ccall "wxConfigBase_GetFirstGroup" wxConfigBase_GetFirstGroup :: Ptr (TConfigBase a) -> Ptr  b -> IO (Ptr (TWxString ()))

-- | usage: (@configBaseGetNextEntry obj lIndex@).
configBaseGetNextEntry :: ConfigBase  a -> Ptr  b ->  IO (String)
configBaseGetNextEntry _obj lIndex 
  = withManagedStringResult $
    withObjectRef "configBaseGetNextEntry" _obj $ \cobj__obj -> 
    wxConfigBase_GetNextEntry cobj__obj  lIndex  
foreign import ccall "wxConfigBase_GetNextEntry" wxConfigBase_GetNextEntry :: Ptr (TConfigBase a) -> Ptr  b -> IO (Ptr (TWxString ()))

-- | usage: (@configBaseGetNextGroup obj lIndex@).
configBaseGetNextGroup :: ConfigBase  a -> Ptr  b ->  IO (String)
configBaseGetNextGroup _obj lIndex 
  = withManagedStringResult $
    withObjectRef "configBaseGetNextGroup" _obj $ \cobj__obj -> 
    wxConfigBase_GetNextGroup cobj__obj  lIndex  
foreign import ccall "wxConfigBase_GetNextGroup" wxConfigBase_GetNextGroup :: Ptr (TConfigBase a) -> Ptr  b -> IO (Ptr (TWxString ()))

-- | usage: (@configBaseGetNumberOfEntries obj bRecursive@).
configBaseGetNumberOfEntries :: ConfigBase  a -> Bool ->  IO Int
configBaseGetNumberOfEntries _obj bRecursive 
  = withIntResult $
    withObjectRef "configBaseGetNumberOfEntries" _obj $ \cobj__obj -> 
    wxConfigBase_GetNumberOfEntries cobj__obj  (toCBool bRecursive)  
foreign import ccall "wxConfigBase_GetNumberOfEntries" wxConfigBase_GetNumberOfEntries :: Ptr (TConfigBase a) -> CBool -> IO CInt

-- | usage: (@configBaseGetNumberOfGroups obj bRecursive@).
configBaseGetNumberOfGroups :: ConfigBase  a -> Bool ->  IO Int
configBaseGetNumberOfGroups _obj bRecursive 
  = withIntResult $
    withObjectRef "configBaseGetNumberOfGroups" _obj $ \cobj__obj -> 
    wxConfigBase_GetNumberOfGroups cobj__obj  (toCBool bRecursive)  
foreign import ccall "wxConfigBase_GetNumberOfGroups" wxConfigBase_GetNumberOfGroups :: Ptr (TConfigBase a) -> CBool -> IO CInt

-- | usage: (@configBaseGetPath obj@).
configBaseGetPath :: ConfigBase  a ->  IO (String)
configBaseGetPath _obj 
  = withManagedStringResult $
    withObjectRef "configBaseGetPath" _obj $ \cobj__obj -> 
    wxConfigBase_GetPath cobj__obj  
foreign import ccall "wxConfigBase_GetPath" wxConfigBase_GetPath :: Ptr (TConfigBase a) -> IO (Ptr (TWxString ()))

-- | usage: (@configBaseGetStyle obj@).
configBaseGetStyle :: ConfigBase  a ->  IO Int
configBaseGetStyle _obj 
  = withIntResult $
    withObjectRef "configBaseGetStyle" _obj $ \cobj__obj -> 
    wxConfigBase_GetStyle cobj__obj  
foreign import ccall "wxConfigBase_GetStyle" wxConfigBase_GetStyle :: Ptr (TConfigBase a) -> IO CInt

-- | usage: (@configBaseGetVendorName obj@).
configBaseGetVendorName :: ConfigBase  a ->  IO (String)
configBaseGetVendorName _obj 
  = withManagedStringResult $
    withObjectRef "configBaseGetVendorName" _obj $ \cobj__obj -> 
    wxConfigBase_GetVendorName cobj__obj  
foreign import ccall "wxConfigBase_GetVendorName" wxConfigBase_GetVendorName :: Ptr (TConfigBase a) -> IO (Ptr (TWxString ()))

-- | usage: (@configBaseHasEntry obj strName@).
configBaseHasEntry :: ConfigBase  a -> String ->  IO Bool
configBaseHasEntry _obj strName 
  = withBoolResult $
    withObjectRef "configBaseHasEntry" _obj $ \cobj__obj -> 
    withStringPtr strName $ \cobj_strName -> 
    wxConfigBase_HasEntry cobj__obj  cobj_strName  
foreign import ccall "wxConfigBase_HasEntry" wxConfigBase_HasEntry :: Ptr (TConfigBase a) -> Ptr (TWxString b) -> IO CBool

-- | usage: (@configBaseHasGroup obj strName@).
configBaseHasGroup :: ConfigBase  a -> String ->  IO Bool
configBaseHasGroup _obj strName 
  = withBoolResult $
    withObjectRef "configBaseHasGroup" _obj $ \cobj__obj -> 
    withStringPtr strName $ \cobj_strName -> 
    wxConfigBase_HasGroup cobj__obj  cobj_strName  
foreign import ccall "wxConfigBase_HasGroup" wxConfigBase_HasGroup :: Ptr (TConfigBase a) -> Ptr (TWxString b) -> IO CBool

-- | usage: (@configBaseIsExpandingEnvVars obj@).
configBaseIsExpandingEnvVars :: ConfigBase  a ->  IO Bool
configBaseIsExpandingEnvVars _obj 
  = withBoolResult $
    withObjectRef "configBaseIsExpandingEnvVars" _obj $ \cobj__obj -> 
    wxConfigBase_IsExpandingEnvVars cobj__obj  
foreign import ccall "wxConfigBase_IsExpandingEnvVars" wxConfigBase_IsExpandingEnvVars :: Ptr (TConfigBase a) -> IO CBool

-- | usage: (@configBaseIsRecordingDefaults obj@).
configBaseIsRecordingDefaults :: ConfigBase  a ->  IO Bool
configBaseIsRecordingDefaults _obj 
  = withBoolResult $
    withObjectRef "configBaseIsRecordingDefaults" _obj $ \cobj__obj -> 
    wxConfigBase_IsRecordingDefaults cobj__obj  
foreign import ccall "wxConfigBase_IsRecordingDefaults" wxConfigBase_IsRecordingDefaults :: Ptr (TConfigBase a) -> IO CBool

-- | usage: (@configBaseReadBool obj key defVal@).
configBaseReadBool :: ConfigBase  a -> String -> Bool ->  IO Bool
configBaseReadBool _obj key defVal 
  = withBoolResult $
    withObjectRef "configBaseReadBool" _obj $ \cobj__obj -> 
    withStringPtr key $ \cobj_key -> 
    wxConfigBase_ReadBool cobj__obj  cobj_key  (toCBool defVal)  
foreign import ccall "wxConfigBase_ReadBool" wxConfigBase_ReadBool :: Ptr (TConfigBase a) -> Ptr (TWxString b) -> CBool -> IO CBool

-- | usage: (@configBaseReadDouble obj key defVal@).
configBaseReadDouble :: ConfigBase  a -> String -> Double ->  IO Double
configBaseReadDouble _obj key defVal 
  = withObjectRef "configBaseReadDouble" _obj $ \cobj__obj -> 
    withStringPtr key $ \cobj_key -> 
    wxConfigBase_ReadDouble cobj__obj  cobj_key  defVal  
foreign import ccall "wxConfigBase_ReadDouble" wxConfigBase_ReadDouble :: Ptr (TConfigBase a) -> Ptr (TWxString b) -> Double -> IO Double

-- | usage: (@configBaseReadInteger obj key defVal@).
configBaseReadInteger :: ConfigBase  a -> String -> Int ->  IO Int
configBaseReadInteger _obj key defVal 
  = withIntResult $
    withObjectRef "configBaseReadInteger" _obj $ \cobj__obj -> 
    withStringPtr key $ \cobj_key -> 
    wxConfigBase_ReadInteger cobj__obj  cobj_key  (toCInt defVal)  
foreign import ccall "wxConfigBase_ReadInteger" wxConfigBase_ReadInteger :: Ptr (TConfigBase a) -> Ptr (TWxString b) -> CInt -> IO CInt

-- | usage: (@configBaseReadString obj key defVal@).
configBaseReadString :: ConfigBase  a -> String -> String ->  IO (String)
configBaseReadString _obj key defVal 
  = withManagedStringResult $
    withObjectRef "configBaseReadString" _obj $ \cobj__obj -> 
    withStringPtr key $ \cobj_key -> 
    withStringPtr defVal $ \cobj_defVal -> 
    wxConfigBase_ReadString cobj__obj  cobj_key  cobj_defVal  
foreign import ccall "wxConfigBase_ReadString" wxConfigBase_ReadString :: Ptr (TConfigBase a) -> Ptr (TWxString b) -> Ptr (TWxString c) -> IO (Ptr (TWxString ()))

-- | usage: (@configBaseRenameEntry obj oldName newName@).
configBaseRenameEntry :: ConfigBase  a -> String -> String ->  IO Bool
configBaseRenameEntry _obj oldName newName 
  = withBoolResult $
    withObjectRef "configBaseRenameEntry" _obj $ \cobj__obj -> 
    withStringPtr oldName $ \cobj_oldName -> 
    withStringPtr newName $ \cobj_newName -> 
    wxConfigBase_RenameEntry cobj__obj  cobj_oldName  cobj_newName  
foreign import ccall "wxConfigBase_RenameEntry" wxConfigBase_RenameEntry :: Ptr (TConfigBase a) -> Ptr (TWxString b) -> Ptr (TWxString c) -> IO CBool

-- | usage: (@configBaseRenameGroup obj oldName newName@).
configBaseRenameGroup :: ConfigBase  a -> String -> String ->  IO Bool
configBaseRenameGroup _obj oldName newName 
  = withBoolResult $
    withObjectRef "configBaseRenameGroup" _obj $ \cobj__obj -> 
    withStringPtr oldName $ \cobj_oldName -> 
    withStringPtr newName $ \cobj_newName -> 
    wxConfigBase_RenameGroup cobj__obj  cobj_oldName  cobj_newName  
foreign import ccall "wxConfigBase_RenameGroup" wxConfigBase_RenameGroup :: Ptr (TConfigBase a) -> Ptr (TWxString b) -> Ptr (TWxString c) -> IO CBool

-- | usage: (@configBaseSet self@).
configBaseSet :: ConfigBase  a ->  IO ()
configBaseSet self 
  = withObjectRef "configBaseSet" self $ \cobj_self -> 
    wxConfigBase_Set cobj_self  
foreign import ccall "wxConfigBase_Set" wxConfigBase_Set :: Ptr (TConfigBase a) -> IO ()

-- | usage: (@configBaseSetAppName obj appName@).
configBaseSetAppName :: ConfigBase  a -> String ->  IO ()
configBaseSetAppName _obj appName 
  = withObjectRef "configBaseSetAppName" _obj $ \cobj__obj -> 
    withStringPtr appName $ \cobj_appName -> 
    wxConfigBase_SetAppName cobj__obj  cobj_appName  
foreign import ccall "wxConfigBase_SetAppName" wxConfigBase_SetAppName :: Ptr (TConfigBase a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@configBaseSetExpandEnvVars obj bDoIt@).
configBaseSetExpandEnvVars :: ConfigBase  a -> Bool ->  IO ()
configBaseSetExpandEnvVars _obj bDoIt 
  = withObjectRef "configBaseSetExpandEnvVars" _obj $ \cobj__obj -> 
    wxConfigBase_SetExpandEnvVars cobj__obj  (toCBool bDoIt)  
foreign import ccall "wxConfigBase_SetExpandEnvVars" wxConfigBase_SetExpandEnvVars :: Ptr (TConfigBase a) -> CBool -> IO ()

-- | usage: (@configBaseSetPath obj strPath@).
configBaseSetPath :: ConfigBase  a -> String ->  IO ()
configBaseSetPath _obj strPath 
  = withObjectRef "configBaseSetPath" _obj $ \cobj__obj -> 
    withStringPtr strPath $ \cobj_strPath -> 
    wxConfigBase_SetPath cobj__obj  cobj_strPath  
foreign import ccall "wxConfigBase_SetPath" wxConfigBase_SetPath :: Ptr (TConfigBase a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@configBaseSetRecordDefaults obj bDoIt@).
configBaseSetRecordDefaults :: ConfigBase  a -> Bool ->  IO ()
configBaseSetRecordDefaults _obj bDoIt 
  = withObjectRef "configBaseSetRecordDefaults" _obj $ \cobj__obj -> 
    wxConfigBase_SetRecordDefaults cobj__obj  (toCBool bDoIt)  
foreign import ccall "wxConfigBase_SetRecordDefaults" wxConfigBase_SetRecordDefaults :: Ptr (TConfigBase a) -> CBool -> IO ()

-- | usage: (@configBaseSetStyle obj style@).
configBaseSetStyle :: ConfigBase  a -> Int ->  IO ()
configBaseSetStyle _obj style 
  = withObjectRef "configBaseSetStyle" _obj $ \cobj__obj -> 
    wxConfigBase_SetStyle cobj__obj  (toCInt style)  
foreign import ccall "wxConfigBase_SetStyle" wxConfigBase_SetStyle :: Ptr (TConfigBase a) -> CInt -> IO ()

-- | usage: (@configBaseSetVendorName obj vendorName@).
configBaseSetVendorName :: ConfigBase  a -> String ->  IO ()
configBaseSetVendorName _obj vendorName 
  = withObjectRef "configBaseSetVendorName" _obj $ \cobj__obj -> 
    withStringPtr vendorName $ \cobj_vendorName -> 
    wxConfigBase_SetVendorName cobj__obj  cobj_vendorName  
foreign import ccall "wxConfigBase_SetVendorName" wxConfigBase_SetVendorName :: Ptr (TConfigBase a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@configBaseWriteBool obj key value@).
configBaseWriteBool :: ConfigBase  a -> String -> Bool ->  IO Bool
configBaseWriteBool _obj key value 
  = withBoolResult $
    withObjectRef "configBaseWriteBool" _obj $ \cobj__obj -> 
    withStringPtr key $ \cobj_key -> 
    wxConfigBase_WriteBool cobj__obj  cobj_key  (toCBool value)  
foreign import ccall "wxConfigBase_WriteBool" wxConfigBase_WriteBool :: Ptr (TConfigBase a) -> Ptr (TWxString b) -> CBool -> IO CBool

-- | usage: (@configBaseWriteDouble obj key value@).
configBaseWriteDouble :: ConfigBase  a -> String -> Double ->  IO Bool
configBaseWriteDouble _obj key value 
  = withBoolResult $
    withObjectRef "configBaseWriteDouble" _obj $ \cobj__obj -> 
    withStringPtr key $ \cobj_key -> 
    wxConfigBase_WriteDouble cobj__obj  cobj_key  value  
foreign import ccall "wxConfigBase_WriteDouble" wxConfigBase_WriteDouble :: Ptr (TConfigBase a) -> Ptr (TWxString b) -> Double -> IO CBool

-- | usage: (@configBaseWriteInteger obj key value@).
configBaseWriteInteger :: ConfigBase  a -> String -> Int ->  IO Bool
configBaseWriteInteger _obj key value 
  = withBoolResult $
    withObjectRef "configBaseWriteInteger" _obj $ \cobj__obj -> 
    withStringPtr key $ \cobj_key -> 
    wxConfigBase_WriteInteger cobj__obj  cobj_key  (toCInt value)  
foreign import ccall "wxConfigBase_WriteInteger" wxConfigBase_WriteInteger :: Ptr (TConfigBase a) -> Ptr (TWxString b) -> CInt -> IO CBool

-- | usage: (@configBaseWriteLong obj key value@).
configBaseWriteLong :: ConfigBase  a -> String -> Int ->  IO Bool
configBaseWriteLong _obj key value 
  = withBoolResult $
    withObjectRef "configBaseWriteLong" _obj $ \cobj__obj -> 
    withStringPtr key $ \cobj_key -> 
    wxConfigBase_WriteLong cobj__obj  cobj_key  (toCInt value)  
foreign import ccall "wxConfigBase_WriteLong" wxConfigBase_WriteLong :: Ptr (TConfigBase a) -> Ptr (TWxString b) -> CInt -> IO CBool

-- | usage: (@configBaseWriteString obj key value@).
configBaseWriteString :: ConfigBase  a -> String -> String ->  IO Bool
configBaseWriteString _obj key value 
  = withBoolResult $
    withObjectRef "configBaseWriteString" _obj $ \cobj__obj -> 
    withStringPtr key $ \cobj_key -> 
    withStringPtr value $ \cobj_value -> 
    wxConfigBase_WriteString cobj__obj  cobj_key  cobj_value  
foreign import ccall "wxConfigBase_WriteString" wxConfigBase_WriteString :: Ptr (TConfigBase a) -> Ptr (TWxString b) -> Ptr (TWxString c) -> IO CBool

-- | usage: (@contextHelpBeginContextHelp obj win@).
contextHelpBeginContextHelp :: ContextHelp  a -> Window  b ->  IO Bool
contextHelpBeginContextHelp _obj win 
  = withBoolResult $
    withObjectRef "contextHelpBeginContextHelp" _obj $ \cobj__obj -> 
    withObjectPtr win $ \cobj_win -> 
    wxContextHelp_BeginContextHelp cobj__obj  cobj_win  
foreign import ccall "wxContextHelp_BeginContextHelp" wxContextHelp_BeginContextHelp :: Ptr (TContextHelp a) -> Ptr (TWindow b) -> IO CBool

-- | usage: (@contextHelpButtonCreate parent id xywh style@).
contextHelpButtonCreate :: Window  a -> Id -> Rect -> Int ->  IO (ContextHelpButton  ())
contextHelpButtonCreate parent id xywh style 
  = withObjectResult $
    withObjectPtr parent $ \cobj_parent -> 
    wxContextHelpButton_Create cobj_parent  (toCInt id)  (toCIntRectX xywh) (toCIntRectY xywh)(toCIntRectW xywh) (toCIntRectH xywh)  (toCInt style)  
foreign import ccall "wxContextHelpButton_Create" wxContextHelpButton_Create :: Ptr (TWindow a) -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (TContextHelpButton ()))

-- | usage: (@contextHelpCreate win beginHelp@).
contextHelpCreate :: Window  a -> Bool ->  IO (ContextHelp  ())
contextHelpCreate win beginHelp 
  = withObjectResult $
    withObjectPtr win $ \cobj_win -> 
    wxContextHelp_Create cobj_win  (toCBool beginHelp)  
foreign import ccall "wxContextHelp_Create" wxContextHelp_Create :: Ptr (TWindow a) -> CBool -> IO (Ptr (TContextHelp ()))

-- | usage: (@contextHelpDelete obj@).
contextHelpDelete :: ContextHelp  a ->  IO ()
contextHelpDelete
  = objectDelete


-- | usage: (@contextHelpEndContextHelp obj@).
contextHelpEndContextHelp :: ContextHelp  a ->  IO Bool
contextHelpEndContextHelp _obj 
  = withBoolResult $
    withObjectRef "contextHelpEndContextHelp" _obj $ \cobj__obj -> 
    wxContextHelp_EndContextHelp cobj__obj  
foreign import ccall "wxContextHelp_EndContextHelp" wxContextHelp_EndContextHelp :: Ptr (TContextHelp a) -> IO CBool

-- | usage: (@controlCommand obj event@).
controlCommand :: Control  a -> Event  b ->  IO ()
controlCommand _obj event 
  = withObjectRef "controlCommand" _obj $ \cobj__obj -> 
    withObjectPtr event $ \cobj_event -> 
    wxControl_Command cobj__obj  cobj_event  
foreign import ccall "wxControl_Command" wxControl_Command :: Ptr (TControl a) -> Ptr (TEvent b) -> IO ()

-- | usage: (@controlGetLabel obj@).
controlGetLabel :: Control  a ->  IO (String)
controlGetLabel _obj 
  = withManagedStringResult $
    withObjectRef "controlGetLabel" _obj $ \cobj__obj -> 
    wxControl_GetLabel cobj__obj  
foreign import ccall "wxControl_GetLabel" wxControl_GetLabel :: Ptr (TControl a) -> IO (Ptr (TWxString ()))

-- | usage: (@controlSetLabel obj text@).
controlSetLabel :: Control  a -> String ->  IO ()
controlSetLabel _obj text 
  = withObjectRef "controlSetLabel" _obj $ \cobj__obj -> 
    withStringPtr text $ \cobj_text -> 
    wxControl_SetLabel cobj__obj  cobj_text  
foreign import ccall "wxControl_SetLabel" wxControl_SetLabel :: Ptr (TControl a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@cursorCreateFromImage image@).
cursorCreateFromImage :: Image  a ->  IO (Cursor  ())
cursorCreateFromImage image 
  = withManagedCursorResult $
    withObjectPtr image $ \cobj_image -> 
    wx_Cursor_CreateFromImage cobj_image  
foreign import ccall "Cursor_CreateFromImage" wx_Cursor_CreateFromImage :: Ptr (TImage a) -> IO (Ptr (TCursor ()))

-- | usage: (@cursorCreateFromStock id@).
cursorCreateFromStock :: Id ->  IO (Cursor  ())
cursorCreateFromStock _id 
  = withManagedCursorResult $
    wx_Cursor_CreateFromStock (toCInt _id)  
foreign import ccall "Cursor_CreateFromStock" wx_Cursor_CreateFromStock :: CInt -> IO (Ptr (TCursor ()))

-- | usage: (@cursorCreateLoad name wxtype widthheight@).
cursorCreateLoad :: String -> Int -> Size ->  IO (Cursor  ())
cursorCreateLoad name wxtype widthheight 
  = withManagedCursorResult $
    withStringPtr name $ \cobj_name -> 
    wx_Cursor_CreateLoad cobj_name  (toCInt wxtype)  (toCIntSizeW widthheight) (toCIntSizeH widthheight)  
foreign import ccall "Cursor_CreateLoad" wx_Cursor_CreateLoad :: Ptr (TWxString a) -> CInt -> CInt -> CInt -> IO (Ptr (TCursor ()))

-- | usage: (@cursorDelete obj@).
cursorDelete :: Cursor  a ->  IO ()
cursorDelete
  = objectDelete


-- | usage: (@cursorIsStatic self@).
cursorIsStatic :: Cursor  a ->  IO Bool
cursorIsStatic self 
  = withBoolResult $
    withObjectPtr self $ \cobj_self -> 
    wxCursor_IsStatic cobj_self  
foreign import ccall "wxCursor_IsStatic" wxCursor_IsStatic :: Ptr (TCursor a) -> IO CBool

-- | usage: (@cursorSafeDelete self@).
cursorSafeDelete :: Cursor  a ->  IO ()
cursorSafeDelete self 
  = withObjectPtr self $ \cobj_self -> 
    wxCursor_SafeDelete cobj_self  
foreign import ccall "wxCursor_SafeDelete" wxCursor_SafeDelete :: Ptr (TCursor a) -> IO ()

-- | usage: (@dataFormatCreateFromId name@).
dataFormatCreateFromId :: String ->  IO (DataFormat  ())
dataFormatCreateFromId name 
  = withObjectResult $
    withStringPtr name $ \cobj_name -> 
    wxDataFormat_CreateFromId cobj_name  
foreign import ccall "wxDataFormat_CreateFromId" wxDataFormat_CreateFromId :: Ptr (TWxString a) -> IO (Ptr (TDataFormat ()))

-- | usage: (@dataFormatCreateFromType typ@).
dataFormatCreateFromType :: Int ->  IO (DataFormat  ())
dataFormatCreateFromType typ 
  = withObjectResult $
    wxDataFormat_CreateFromType (toCInt typ)  
foreign import ccall "wxDataFormat_CreateFromType" wxDataFormat_CreateFromType :: CInt -> IO (Ptr (TDataFormat ()))

-- | usage: (@dataFormatDelete obj@).
dataFormatDelete :: DataFormat  a ->  IO ()
dataFormatDelete _obj 
  = withObjectRef "dataFormatDelete" _obj $ \cobj__obj -> 
    wxDataFormat_Delete cobj__obj  
foreign import ccall "wxDataFormat_Delete" wxDataFormat_Delete :: Ptr (TDataFormat a) -> IO ()

-- | usage: (@dataFormatGetId obj@).
dataFormatGetId :: DataFormat  a ->  IO (String)
dataFormatGetId _obj 
  = withManagedStringResult $
    withObjectRef "dataFormatGetId" _obj $ \cobj__obj -> 
    wxDataFormat_GetId cobj__obj  
foreign import ccall "wxDataFormat_GetId" wxDataFormat_GetId :: Ptr (TDataFormat a) -> IO (Ptr (TWxString ()))

-- | usage: (@dataFormatGetType obj@).
dataFormatGetType :: DataFormat  a ->  IO Int
dataFormatGetType _obj 
  = withIntResult $
    withObjectRef "dataFormatGetType" _obj $ \cobj__obj -> 
    wxDataFormat_GetType cobj__obj  
foreign import ccall "wxDataFormat_GetType" wxDataFormat_GetType :: Ptr (TDataFormat a) -> IO CInt

-- | usage: (@dataFormatIsEqual obj other@).
dataFormatIsEqual :: DataFormat  a -> Ptr  b ->  IO Bool
dataFormatIsEqual _obj other 
  = withBoolResult $
    withObjectRef "dataFormatIsEqual" _obj $ \cobj__obj -> 
    wxDataFormat_IsEqual cobj__obj  other  
foreign import ccall "wxDataFormat_IsEqual" wxDataFormat_IsEqual :: Ptr (TDataFormat a) -> Ptr  b -> IO CBool

-- | usage: (@dataFormatSetId obj id@).
dataFormatSetId :: DataFormat  a -> Ptr  b ->  IO ()
dataFormatSetId _obj id 
  = withObjectRef "dataFormatSetId" _obj $ \cobj__obj -> 
    wxDataFormat_SetId cobj__obj  id  
foreign import ccall "wxDataFormat_SetId" wxDataFormat_SetId :: Ptr (TDataFormat a) -> Ptr  b -> IO ()

-- | usage: (@dataFormatSetType obj typ@).
dataFormatSetType :: DataFormat  a -> Int ->  IO ()
dataFormatSetType _obj typ 
  = withObjectRef "dataFormatSetType" _obj $ \cobj__obj -> 
    wxDataFormat_SetType cobj__obj  (toCInt typ)  
foreign import ccall "wxDataFormat_SetType" wxDataFormat_SetType :: Ptr (TDataFormat a) -> CInt -> IO ()

-- | usage: (@dataObjectCompositeAdd obj dat preferred@).
dataObjectCompositeAdd :: DataObjectComposite  a -> Ptr  b -> Int ->  IO ()
dataObjectCompositeAdd _obj _dat _preferred 
  = withObjectRef "dataObjectCompositeAdd" _obj $ \cobj__obj -> 
    wxDataObjectComposite_Add cobj__obj  _dat  (toCInt _preferred)  
foreign import ccall "wxDataObjectComposite_Add" wxDataObjectComposite_Add :: Ptr (TDataObjectComposite a) -> Ptr  b -> CInt -> IO ()

-- | usage: (@dataObjectCompositeCreate@).
dataObjectCompositeCreate ::  IO (DataObjectComposite  ())
dataObjectCompositeCreate 
  = withObjectResult $
    wxDataObjectComposite_Create 
foreign import ccall "wxDataObjectComposite_Create" wxDataObjectComposite_Create :: IO (Ptr (TDataObjectComposite ()))

-- | usage: (@dataObjectCompositeDelete obj@).
dataObjectCompositeDelete :: DataObjectComposite  a ->  IO ()
dataObjectCompositeDelete _obj 
  = withObjectRef "dataObjectCompositeDelete" _obj $ \cobj__obj -> 
    wxDataObjectComposite_Delete cobj__obj  
foreign import ccall "wxDataObjectComposite_Delete" wxDataObjectComposite_Delete :: Ptr (TDataObjectComposite a) -> IO ()

-- | usage: (@dateTimeAddDate obj diff@).
dateTimeAddDate :: DateTime  a -> Ptr  b ->  IO (DateTime  ())
dateTimeAddDate _obj diff 
  = withRefDateTime $ \pref -> 
    withObjectRef "dateTimeAddDate" _obj $ \cobj__obj -> 
    wxDateTime_AddDate cobj__obj  diff   pref
foreign import ccall "wxDateTime_AddDate" wxDateTime_AddDate :: Ptr (TDateTime a) -> Ptr  b -> Ptr (TDateTime ()) -> IO ()

-- | usage: (@dateTimeAddDateValues obj yrs mnt wek day@).
dateTimeAddDateValues :: DateTime  a -> Int -> Int -> Int -> Int ->  IO ()
dateTimeAddDateValues _obj _yrs _mnt _wek _day 
  = withObjectRef "dateTimeAddDateValues" _obj $ \cobj__obj -> 
    wxDateTime_AddDateValues cobj__obj  (toCInt _yrs)  (toCInt _mnt)  (toCInt _wek)  (toCInt _day)  
foreign import ccall "wxDateTime_AddDateValues" wxDateTime_AddDateValues :: Ptr (TDateTime a) -> CInt -> CInt -> CInt -> CInt -> IO ()

-- | usage: (@dateTimeAddTime obj diff@).
dateTimeAddTime :: DateTime  a -> Ptr  b ->  IO (DateTime  ())
dateTimeAddTime _obj diff 
  = withRefDateTime $ \pref -> 
    withObjectRef "dateTimeAddTime" _obj $ \cobj__obj -> 
    wxDateTime_AddTime cobj__obj  diff   pref
foreign import ccall "wxDateTime_AddTime" wxDateTime_AddTime :: Ptr (TDateTime a) -> Ptr  b -> Ptr (TDateTime ()) -> IO ()

-- | usage: (@dateTimeAddTimeValues obj hrs min sec mls@).
dateTimeAddTimeValues :: DateTime  a -> Int -> Int -> Int -> Int ->  IO ()
dateTimeAddTimeValues _obj _hrs _min _sec _mls 
  = withObjectRef "dateTimeAddTimeValues" _obj $ \cobj__obj -> 
    wxDateTime_AddTimeValues cobj__obj  (toCInt _hrs)  (toCInt _min)  (toCInt _sec)  (toCInt _mls)  
foreign import ccall "wxDateTime_AddTimeValues" wxDateTime_AddTimeValues :: Ptr (TDateTime a) -> CInt -> CInt -> CInt -> CInt -> IO ()

-- | usage: (@dateTimeConvertYearToBC year@).
dateTimeConvertYearToBC :: Int ->  IO Int
dateTimeConvertYearToBC year 
  = withIntResult $
    wxDateTime_ConvertYearToBC (toCInt year)  
foreign import ccall "wxDateTime_ConvertYearToBC" wxDateTime_ConvertYearToBC :: CInt -> IO CInt

-- | usage: (@dateTimeCreate@).
dateTimeCreate ::  IO (DateTime  ())
dateTimeCreate 
  = withManagedDateTimeResult $
    wxDateTime_Create 
foreign import ccall "wxDateTime_Create" wxDateTime_Create :: IO (Ptr (TDateTime ()))

-- | usage: (@dateTimeDelete obj@).
dateTimeDelete :: DateTime  a ->  IO ()
dateTimeDelete
  = dateTimeDelete


-- | usage: (@dateTimeFormat obj format tz@).
dateTimeFormat :: DateTime  a -> Ptr  b -> Int ->  IO (String)
dateTimeFormat _obj format tz 
  = withManagedStringResult $
    withObjectRef "dateTimeFormat" _obj $ \cobj__obj -> 
    wxDateTime_Format cobj__obj  format  (toCInt tz)  
foreign import ccall "wxDateTime_Format" wxDateTime_Format :: Ptr (TDateTime a) -> Ptr  b -> CInt -> IO (Ptr (TWxString ()))

-- | usage: (@dateTimeFormatDate obj@).
dateTimeFormatDate :: DateTime  a ->  IO (String)
dateTimeFormatDate _obj 
  = withManagedStringResult $
    withObjectRef "dateTimeFormatDate" _obj $ \cobj__obj -> 
    wxDateTime_FormatDate cobj__obj  
foreign import ccall "wxDateTime_FormatDate" wxDateTime_FormatDate :: Ptr (TDateTime a) -> IO (Ptr (TWxString ()))

-- | usage: (@dateTimeFormatISODate obj@).
dateTimeFormatISODate :: DateTime  a ->  IO (String)
dateTimeFormatISODate _obj 
  = withManagedStringResult $
    withObjectRef "dateTimeFormatISODate" _obj $ \cobj__obj -> 
    wxDateTime_FormatISODate cobj__obj  
foreign import ccall "wxDateTime_FormatISODate" wxDateTime_FormatISODate :: Ptr (TDateTime a) -> IO (Ptr (TWxString ()))

-- | usage: (@dateTimeFormatISOTime obj@).
dateTimeFormatISOTime :: DateTime  a ->  IO (String)
dateTimeFormatISOTime _obj 
  = withManagedStringResult $
    withObjectRef "dateTimeFormatISOTime" _obj $ \cobj__obj -> 
    wxDateTime_FormatISOTime cobj__obj  
foreign import ccall "wxDateTime_FormatISOTime" wxDateTime_FormatISOTime :: Ptr (TDateTime a) -> IO (Ptr (TWxString ()))

-- | usage: (@dateTimeFormatTime obj@).
dateTimeFormatTime :: DateTime  a ->  IO (String)
dateTimeFormatTime _obj 
  = withManagedStringResult $
    withObjectRef "dateTimeFormatTime" _obj $ \cobj__obj -> 
    wxDateTime_FormatTime cobj__obj  
foreign import ccall "wxDateTime_FormatTime" wxDateTime_FormatTime :: Ptr (TDateTime a) -> IO (Ptr (TWxString ()))

-- | usage: (@dateTimeGetAmString@).
dateTimeGetAmString ::  IO (String)
dateTimeGetAmString 
  = withManagedStringResult $
    wxDateTime_GetAmString 
foreign import ccall "wxDateTime_GetAmString" wxDateTime_GetAmString :: IO (Ptr (TWxString ()))

-- | usage: (@dateTimeGetBeginDST year country dt@).
dateTimeGetBeginDST :: Int -> Int -> DateTime  c ->  IO ()
dateTimeGetBeginDST year country dt 
  = withObjectPtr dt $ \cobj_dt -> 
    wxDateTime_GetBeginDST (toCInt year)  (toCInt country)  cobj_dt  
foreign import ccall "wxDateTime_GetBeginDST" wxDateTime_GetBeginDST :: CInt -> CInt -> Ptr (TDateTime c) -> IO ()

-- | usage: (@dateTimeGetCentury year@).
dateTimeGetCentury :: Int ->  IO Int
dateTimeGetCentury year 
  = withIntResult $
    wxDateTime_GetCentury (toCInt year)  
foreign import ccall "wxDateTime_GetCentury" wxDateTime_GetCentury :: CInt -> IO CInt

-- | usage: (@dateTimeGetCountry@).
dateTimeGetCountry ::  IO Int
dateTimeGetCountry 
  = withIntResult $
    wxDateTime_GetCountry 
foreign import ccall "wxDateTime_GetCountry" wxDateTime_GetCountry :: IO CInt

-- | usage: (@dateTimeGetCurrentMonth cal@).
dateTimeGetCurrentMonth :: Int ->  IO Int
dateTimeGetCurrentMonth cal 
  = withIntResult $
    wxDateTime_GetCurrentMonth (toCInt cal)  
foreign import ccall "wxDateTime_GetCurrentMonth" wxDateTime_GetCurrentMonth :: CInt -> IO CInt

-- | usage: (@dateTimeGetCurrentYear cal@).
dateTimeGetCurrentYear :: Int ->  IO Int
dateTimeGetCurrentYear cal 
  = withIntResult $
    wxDateTime_GetCurrentYear (toCInt cal)  
foreign import ccall "wxDateTime_GetCurrentYear" wxDateTime_GetCurrentYear :: CInt -> IO CInt

-- | usage: (@dateTimeGetDay obj tz@).
dateTimeGetDay :: DateTime  a -> Int ->  IO Int
dateTimeGetDay _obj tz 
  = withIntResult $
    withObjectRef "dateTimeGetDay" _obj $ \cobj__obj -> 
    wxDateTime_GetDay cobj__obj  (toCInt tz)  
foreign import ccall "wxDateTime_GetDay" wxDateTime_GetDay :: Ptr (TDateTime a) -> CInt -> IO CInt

-- | usage: (@dateTimeGetDayOfYear obj tz@).
dateTimeGetDayOfYear :: DateTime  a -> Int ->  IO Int
dateTimeGetDayOfYear _obj tz 
  = withIntResult $
    withObjectRef "dateTimeGetDayOfYear" _obj $ \cobj__obj -> 
    wxDateTime_GetDayOfYear cobj__obj  (toCInt tz)  
foreign import ccall "wxDateTime_GetDayOfYear" wxDateTime_GetDayOfYear :: Ptr (TDateTime a) -> CInt -> IO CInt

-- | usage: (@dateTimeGetEndDST year country dt@).
dateTimeGetEndDST :: Int -> Int -> DateTime  c ->  IO ()
dateTimeGetEndDST year country dt 
  = withObjectPtr dt $ \cobj_dt -> 
    wxDateTime_GetEndDST (toCInt year)  (toCInt country)  cobj_dt  
foreign import ccall "wxDateTime_GetEndDST" wxDateTime_GetEndDST :: CInt -> CInt -> Ptr (TDateTime c) -> IO ()

-- | usage: (@dateTimeGetHour obj tz@).
dateTimeGetHour :: DateTime  a -> Int ->  IO Int
dateTimeGetHour _obj tz 
  = withIntResult $
    withObjectRef "dateTimeGetHour" _obj $ \cobj__obj -> 
    wxDateTime_GetHour cobj__obj  (toCInt tz)  
foreign import ccall "wxDateTime_GetHour" wxDateTime_GetHour :: Ptr (TDateTime a) -> CInt -> IO CInt

-- | usage: (@dateTimeGetLastMonthDay obj month year@).
dateTimeGetLastMonthDay :: DateTime  a -> Int -> Int ->  IO (DateTime  ())
dateTimeGetLastMonthDay _obj month year 
  = withRefDateTime $ \pref -> 
    withObjectRef "dateTimeGetLastMonthDay" _obj $ \cobj__obj -> 
    wxDateTime_GetLastMonthDay cobj__obj  (toCInt month)  (toCInt year)   pref
foreign import ccall "wxDateTime_GetLastMonthDay" wxDateTime_GetLastMonthDay :: Ptr (TDateTime a) -> CInt -> CInt -> Ptr (TDateTime ()) -> IO ()

-- | usage: (@dateTimeGetLastWeekDay obj weekday month year@).
dateTimeGetLastWeekDay :: DateTime  a -> Int -> Int -> Int ->  IO (DateTime  ())
dateTimeGetLastWeekDay _obj weekday month year 
  = withRefDateTime $ \pref -> 
    withObjectRef "dateTimeGetLastWeekDay" _obj $ \cobj__obj -> 
    wxDateTime_GetLastWeekDay cobj__obj  (toCInt weekday)  (toCInt month)  (toCInt year)   pref
foreign import ccall "wxDateTime_GetLastWeekDay" wxDateTime_GetLastWeekDay :: Ptr (TDateTime a) -> CInt -> CInt -> CInt -> Ptr (TDateTime ()) -> IO ()

-- | usage: (@dateTimeGetMillisecond obj tz@).
dateTimeGetMillisecond :: DateTime  a -> Int ->  IO Int
dateTimeGetMillisecond _obj tz 
  = withIntResult $
    withObjectRef "dateTimeGetMillisecond" _obj $ \cobj__obj -> 
    wxDateTime_GetMillisecond cobj__obj  (toCInt tz)  
foreign import ccall "wxDateTime_GetMillisecond" wxDateTime_GetMillisecond :: Ptr (TDateTime a) -> CInt -> IO CInt

-- | usage: (@dateTimeGetMinute obj tz@).
dateTimeGetMinute :: DateTime  a -> Int ->  IO Int
dateTimeGetMinute _obj tz 
  = withIntResult $
    withObjectRef "dateTimeGetMinute" _obj $ \cobj__obj -> 
    wxDateTime_GetMinute cobj__obj  (toCInt tz)  
foreign import ccall "wxDateTime_GetMinute" wxDateTime_GetMinute :: Ptr (TDateTime a) -> CInt -> IO CInt

-- | usage: (@dateTimeGetMonth obj tz@).
dateTimeGetMonth :: DateTime  a -> Int ->  IO Int
dateTimeGetMonth _obj tz 
  = withIntResult $
    withObjectRef "dateTimeGetMonth" _obj $ \cobj__obj -> 
    wxDateTime_GetMonth cobj__obj  (toCInt tz)  
foreign import ccall "wxDateTime_GetMonth" wxDateTime_GetMonth :: Ptr (TDateTime a) -> CInt -> IO CInt

-- | usage: (@dateTimeGetMonthName month flags@).
dateTimeGetMonthName :: Int -> Int ->  IO (String)
dateTimeGetMonthName month flags 
  = withManagedStringResult $
    wxDateTime_GetMonthName (toCInt month)  (toCInt flags)  
foreign import ccall "wxDateTime_GetMonthName" wxDateTime_GetMonthName :: CInt -> CInt -> IO (Ptr (TWxString ()))

-- | usage: (@dateTimeGetNextWeekDay obj weekday@).
dateTimeGetNextWeekDay :: DateTime  a -> Int ->  IO (DateTime  ())
dateTimeGetNextWeekDay _obj weekday 
  = withRefDateTime $ \pref -> 
    withObjectRef "dateTimeGetNextWeekDay" _obj $ \cobj__obj -> 
    wxDateTime_GetNextWeekDay cobj__obj  (toCInt weekday)   pref
foreign import ccall "wxDateTime_GetNextWeekDay" wxDateTime_GetNextWeekDay :: Ptr (TDateTime a) -> CInt -> Ptr (TDateTime ()) -> IO ()

-- | usage: (@dateTimeGetNumberOfDays year cal@).
dateTimeGetNumberOfDays :: Int -> Int ->  IO Int
dateTimeGetNumberOfDays year cal 
  = withIntResult $
    wxDateTime_GetNumberOfDays (toCInt year)  (toCInt cal)  
foreign import ccall "wxDateTime_GetNumberOfDays" wxDateTime_GetNumberOfDays :: CInt -> CInt -> IO CInt

-- | usage: (@dateTimeGetNumberOfDaysMonth month year cal@).
dateTimeGetNumberOfDaysMonth :: Int -> Int -> Int ->  IO Int
dateTimeGetNumberOfDaysMonth month year cal 
  = withIntResult $
    wxDateTime_GetNumberOfDaysMonth (toCInt month)  (toCInt year)  (toCInt cal)  
foreign import ccall "wxDateTime_GetNumberOfDaysMonth" wxDateTime_GetNumberOfDaysMonth :: CInt -> CInt -> CInt -> IO CInt

-- | usage: (@dateTimeGetPmString@).
dateTimeGetPmString ::  IO (String)
dateTimeGetPmString 
  = withManagedStringResult $
    wxDateTime_GetPmString 
foreign import ccall "wxDateTime_GetPmString" wxDateTime_GetPmString :: IO (Ptr (TWxString ()))

-- | usage: (@dateTimeGetPrevWeekDay obj weekday@).
dateTimeGetPrevWeekDay :: DateTime  a -> Int ->  IO (DateTime  ())
dateTimeGetPrevWeekDay _obj weekday 
  = withRefDateTime $ \pref -> 
    withObjectRef "dateTimeGetPrevWeekDay" _obj $ \cobj__obj -> 
    wxDateTime_GetPrevWeekDay cobj__obj  (toCInt weekday)   pref
foreign import ccall "wxDateTime_GetPrevWeekDay" wxDateTime_GetPrevWeekDay :: Ptr (TDateTime a) -> CInt -> Ptr (TDateTime ()) -> IO ()

-- | usage: (@dateTimeGetSecond obj tz@).
dateTimeGetSecond :: DateTime  a -> Int ->  IO Int
dateTimeGetSecond _obj tz 
  = withIntResult $
    withObjectRef "dateTimeGetSecond" _obj $ \cobj__obj -> 
    wxDateTime_GetSecond cobj__obj  (toCInt tz)  
foreign import ccall "wxDateTime_GetSecond" wxDateTime_GetSecond :: Ptr (TDateTime a) -> CInt -> IO CInt

-- | usage: (@dateTimeGetTicks obj@).
dateTimeGetTicks :: DateTime  a ->  IO Int
dateTimeGetTicks _obj 
  = withIntResult $
    withObjectRef "dateTimeGetTicks" _obj $ \cobj__obj -> 
    wxDateTime_GetTicks cobj__obj  
foreign import ccall "wxDateTime_GetTicks" wxDateTime_GetTicks :: Ptr (TDateTime a) -> IO CInt

-- | usage: (@dateTimeGetTimeNow@).
dateTimeGetTimeNow ::  IO Int
dateTimeGetTimeNow 
  = withIntResult $
    wxDateTime_GetTimeNow 
foreign import ccall "wxDateTime_GetTimeNow" wxDateTime_GetTimeNow :: IO CInt

-- | usage: (@dateTimeGetValue obj hilong lolong@).
dateTimeGetValue :: DateTime  a -> Ptr  b -> Ptr  c ->  IO ()
dateTimeGetValue _obj hilong lolong 
  = withObjectRef "dateTimeGetValue" _obj $ \cobj__obj -> 
    wxDateTime_GetValue cobj__obj  hilong  lolong  
foreign import ccall "wxDateTime_GetValue" wxDateTime_GetValue :: Ptr (TDateTime a) -> Ptr  b -> Ptr  c -> IO ()

-- | usage: (@dateTimeGetWeekDay obj weekday n month year@).
dateTimeGetWeekDay :: DateTime  a -> Int -> Int -> Int -> Int ->  IO (DateTime  ())
dateTimeGetWeekDay _obj weekday n month year 
  = withRefDateTime $ \pref -> 
    withObjectRef "dateTimeGetWeekDay" _obj $ \cobj__obj -> 
    wxDateTime_GetWeekDay cobj__obj  (toCInt weekday)  (toCInt n)  (toCInt month)  (toCInt year)   pref
foreign import ccall "wxDateTime_GetWeekDay" wxDateTime_GetWeekDay :: Ptr (TDateTime a) -> CInt -> CInt -> CInt -> CInt -> Ptr (TDateTime ()) -> IO ()

-- | usage: (@dateTimeGetWeekDayInSameWeek obj weekday@).
dateTimeGetWeekDayInSameWeek :: DateTime  a -> Int ->  IO (DateTime  ())
dateTimeGetWeekDayInSameWeek _obj weekday 
  = withRefDateTime $ \pref -> 
    withObjectRef "dateTimeGetWeekDayInSameWeek" _obj $ \cobj__obj -> 
    wxDateTime_GetWeekDayInSameWeek cobj__obj  (toCInt weekday)   pref
foreign import ccall "wxDateTime_GetWeekDayInSameWeek" wxDateTime_GetWeekDayInSameWeek :: Ptr (TDateTime a) -> CInt -> Ptr (TDateTime ()) -> IO ()

-- | usage: (@dateTimeGetWeekDayName weekday flags@).
dateTimeGetWeekDayName :: Int -> Int ->  IO (String)
dateTimeGetWeekDayName weekday flags 
  = withManagedStringResult $
    wxDateTime_GetWeekDayName (toCInt weekday)  (toCInt flags)  
foreign import ccall "wxDateTime_GetWeekDayName" wxDateTime_GetWeekDayName :: CInt -> CInt -> IO (Ptr (TWxString ()))

-- | usage: (@dateTimeGetWeekDayTZ obj tz@).
dateTimeGetWeekDayTZ :: DateTime  a -> Int ->  IO Int
dateTimeGetWeekDayTZ _obj tz 
  = withIntResult $
    withObjectRef "dateTimeGetWeekDayTZ" _obj $ \cobj__obj -> 
    wxDateTime_GetWeekDayTZ cobj__obj  (toCInt tz)  
foreign import ccall "wxDateTime_GetWeekDayTZ" wxDateTime_GetWeekDayTZ :: Ptr (TDateTime a) -> CInt -> IO CInt

-- | usage: (@dateTimeGetWeekOfMonth obj flags tz@).
dateTimeGetWeekOfMonth :: DateTime  a -> Int -> Int ->  IO Int
dateTimeGetWeekOfMonth _obj flags tz 
  = withIntResult $
    withObjectRef "dateTimeGetWeekOfMonth" _obj $ \cobj__obj -> 
    wxDateTime_GetWeekOfMonth cobj__obj  (toCInt flags)  (toCInt tz)  
foreign import ccall "wxDateTime_GetWeekOfMonth" wxDateTime_GetWeekOfMonth :: Ptr (TDateTime a) -> CInt -> CInt -> IO CInt

-- | usage: (@dateTimeGetWeekOfYear obj flags tz@).
dateTimeGetWeekOfYear :: DateTime  a -> Int -> Int ->  IO Int
dateTimeGetWeekOfYear _obj flags tz 
  = withIntResult $
    withObjectRef "dateTimeGetWeekOfYear" _obj $ \cobj__obj -> 
    wxDateTime_GetWeekOfYear cobj__obj  (toCInt flags)  (toCInt tz)  
foreign import ccall "wxDateTime_GetWeekOfYear" wxDateTime_GetWeekOfYear :: Ptr (TDateTime a) -> CInt -> CInt -> IO CInt

-- | usage: (@dateTimeGetYear obj tz@).
dateTimeGetYear :: DateTime  a -> Int ->  IO Int
dateTimeGetYear _obj tz 
  = withIntResult $
    withObjectRef "dateTimeGetYear" _obj $ \cobj__obj -> 
    wxDateTime_GetYear cobj__obj  (toCInt tz)  
foreign import ccall "wxDateTime_GetYear" wxDateTime_GetYear :: Ptr (TDateTime a) -> CInt -> IO CInt

-- | usage: (@dateTimeIsBetween obj t1 t2@).
dateTimeIsBetween :: DateTime  a -> DateTime  b -> DateTime  c ->  IO Bool
dateTimeIsBetween _obj t1 t2 
  = withBoolResult $
    withObjectRef "dateTimeIsBetween" _obj $ \cobj__obj -> 
    withObjectPtr t1 $ \cobj_t1 -> 
    withObjectPtr t2 $ \cobj_t2 -> 
    wxDateTime_IsBetween cobj__obj  cobj_t1  cobj_t2  
foreign import ccall "wxDateTime_IsBetween" wxDateTime_IsBetween :: Ptr (TDateTime a) -> Ptr (TDateTime b) -> Ptr (TDateTime c) -> IO CBool

-- | usage: (@dateTimeIsDST obj country@).
dateTimeIsDST :: DateTime  a -> Int ->  IO Bool
dateTimeIsDST _obj country 
  = withBoolResult $
    withObjectRef "dateTimeIsDST" _obj $ \cobj__obj -> 
    wxDateTime_IsDST cobj__obj  (toCInt country)  
foreign import ccall "wxDateTime_IsDST" wxDateTime_IsDST :: Ptr (TDateTime a) -> CInt -> IO CBool

-- | usage: (@dateTimeIsDSTApplicable year country@).
dateTimeIsDSTApplicable :: Int -> Int ->  IO Bool
dateTimeIsDSTApplicable year country 
  = withBoolResult $
    wxDateTime_IsDSTApplicable (toCInt year)  (toCInt country)  
foreign import ccall "wxDateTime_IsDSTApplicable" wxDateTime_IsDSTApplicable :: CInt -> CInt -> IO CBool

-- | usage: (@dateTimeIsEarlierThan obj datetime@).
dateTimeIsEarlierThan :: DateTime  a -> Ptr  b ->  IO Bool
dateTimeIsEarlierThan _obj datetime 
  = withBoolResult $
    withObjectRef "dateTimeIsEarlierThan" _obj $ \cobj__obj -> 
    wxDateTime_IsEarlierThan cobj__obj  datetime  
foreign import ccall "wxDateTime_IsEarlierThan" wxDateTime_IsEarlierThan :: Ptr (TDateTime a) -> Ptr  b -> IO CBool

-- | usage: (@dateTimeIsEqualTo obj datetime@).
dateTimeIsEqualTo :: DateTime  a -> Ptr  b ->  IO Bool
dateTimeIsEqualTo _obj datetime 
  = withBoolResult $
    withObjectRef "dateTimeIsEqualTo" _obj $ \cobj__obj -> 
    wxDateTime_IsEqualTo cobj__obj  datetime  
foreign import ccall "wxDateTime_IsEqualTo" wxDateTime_IsEqualTo :: Ptr (TDateTime a) -> Ptr  b -> IO CBool

-- | usage: (@dateTimeIsEqualUpTo obj dt ts@).
dateTimeIsEqualUpTo :: DateTime  a -> DateTime  b -> Ptr  c ->  IO Bool
dateTimeIsEqualUpTo _obj dt ts 
  = withBoolResult $
    withObjectRef "dateTimeIsEqualUpTo" _obj $ \cobj__obj -> 
    withObjectPtr dt $ \cobj_dt -> 
    wxDateTime_IsEqualUpTo cobj__obj  cobj_dt  ts  
foreign import ccall "wxDateTime_IsEqualUpTo" wxDateTime_IsEqualUpTo :: Ptr (TDateTime a) -> Ptr (TDateTime b) -> Ptr  c -> IO CBool

-- | usage: (@dateTimeIsLaterThan obj datetime@).
dateTimeIsLaterThan :: DateTime  a -> Ptr  b ->  IO Bool
dateTimeIsLaterThan _obj datetime 
  = withBoolResult $
    withObjectRef "dateTimeIsLaterThan" _obj $ \cobj__obj -> 
    wxDateTime_IsLaterThan cobj__obj  datetime  
foreign import ccall "wxDateTime_IsLaterThan" wxDateTime_IsLaterThan :: Ptr (TDateTime a) -> Ptr  b -> IO CBool

-- | usage: (@dateTimeIsLeapYear year cal@).
dateTimeIsLeapYear :: Int -> Int ->  IO Bool
dateTimeIsLeapYear year cal 
  = withBoolResult $
    wxDateTime_IsLeapYear (toCInt year)  (toCInt cal)  
foreign import ccall "wxDateTime_IsLeapYear" wxDateTime_IsLeapYear :: CInt -> CInt -> IO CBool

-- | usage: (@dateTimeIsSameDate obj dt@).
dateTimeIsSameDate :: DateTime  a -> DateTime  b ->  IO Bool
dateTimeIsSameDate _obj dt 
  = withBoolResult $
    withObjectRef "dateTimeIsSameDate" _obj $ \cobj__obj -> 
    withObjectPtr dt $ \cobj_dt -> 
    wxDateTime_IsSameDate cobj__obj  cobj_dt  
foreign import ccall "wxDateTime_IsSameDate" wxDateTime_IsSameDate :: Ptr (TDateTime a) -> Ptr (TDateTime b) -> IO CBool

-- | usage: (@dateTimeIsSameTime obj dt@).
dateTimeIsSameTime :: DateTime  a -> DateTime  b ->  IO Bool
dateTimeIsSameTime _obj dt 
  = withBoolResult $
    withObjectRef "dateTimeIsSameTime" _obj $ \cobj__obj -> 
    withObjectPtr dt $ \cobj_dt -> 
    wxDateTime_IsSameTime cobj__obj  cobj_dt  
foreign import ccall "wxDateTime_IsSameTime" wxDateTime_IsSameTime :: Ptr (TDateTime a) -> Ptr (TDateTime b) -> IO CBool

-- | usage: (@dateTimeIsStrictlyBetween obj t1 t2@).
dateTimeIsStrictlyBetween :: DateTime  a -> DateTime  b -> DateTime  c ->  IO Bool
dateTimeIsStrictlyBetween _obj t1 t2 
  = withBoolResult $
    withObjectRef "dateTimeIsStrictlyBetween" _obj $ \cobj__obj -> 
    withObjectPtr t1 $ \cobj_t1 -> 
    withObjectPtr t2 $ \cobj_t2 -> 
    wxDateTime_IsStrictlyBetween cobj__obj  cobj_t1  cobj_t2  
foreign import ccall "wxDateTime_IsStrictlyBetween" wxDateTime_IsStrictlyBetween :: Ptr (TDateTime a) -> Ptr (TDateTime b) -> Ptr (TDateTime c) -> IO CBool

-- | usage: (@dateTimeIsValid obj@).
dateTimeIsValid :: DateTime  a ->  IO Bool
dateTimeIsValid _obj 
  = withBoolResult $
    withObjectRef "dateTimeIsValid" _obj $ \cobj__obj -> 
    wxDateTime_IsValid cobj__obj  
foreign import ccall "wxDateTime_IsValid" wxDateTime_IsValid :: Ptr (TDateTime a) -> IO CBool

-- | usage: (@dateTimeIsWestEuropeanCountry country@).
dateTimeIsWestEuropeanCountry :: Int ->  IO Bool
dateTimeIsWestEuropeanCountry country 
  = withBoolResult $
    wxDateTime_IsWestEuropeanCountry (toCInt country)  
foreign import ccall "wxDateTime_IsWestEuropeanCountry" wxDateTime_IsWestEuropeanCountry :: CInt -> IO CBool

-- | usage: (@dateTimeIsWorkDay obj country@).
dateTimeIsWorkDay :: DateTime  a -> Int ->  IO Bool
dateTimeIsWorkDay _obj country 
  = withBoolResult $
    withObjectRef "dateTimeIsWorkDay" _obj $ \cobj__obj -> 
    wxDateTime_IsWorkDay cobj__obj  (toCInt country)  
foreign import ccall "wxDateTime_IsWorkDay" wxDateTime_IsWorkDay :: Ptr (TDateTime a) -> CInt -> IO CBool

-- | usage: (@dateTimeMakeGMT obj noDST@).
dateTimeMakeGMT :: DateTime  a -> Int ->  IO ()
dateTimeMakeGMT _obj noDST 
  = withObjectRef "dateTimeMakeGMT" _obj $ \cobj__obj -> 
    wxDateTime_MakeGMT cobj__obj  (toCInt noDST)  
foreign import ccall "wxDateTime_MakeGMT" wxDateTime_MakeGMT :: Ptr (TDateTime a) -> CInt -> IO ()

-- | usage: (@dateTimeMakeTimezone obj tz noDST@).
dateTimeMakeTimezone :: DateTime  a -> Int -> Int ->  IO ()
dateTimeMakeTimezone _obj tz noDST 
  = withObjectRef "dateTimeMakeTimezone" _obj $ \cobj__obj -> 
    wxDateTime_MakeTimezone cobj__obj  (toCInt tz)  (toCInt noDST)  
foreign import ccall "wxDateTime_MakeTimezone" wxDateTime_MakeTimezone :: Ptr (TDateTime a) -> CInt -> CInt -> IO ()

-- | usage: (@dateTimeNow dt@).
dateTimeNow :: DateTime  a ->  IO ()
dateTimeNow dt 
  = withObjectRef "dateTimeNow" dt $ \cobj_dt -> 
    wxDateTime_Now cobj_dt  
foreign import ccall "wxDateTime_Now" wxDateTime_Now :: Ptr (TDateTime a) -> IO ()

-- | usage: (@dateTimeParseDate obj date@).
dateTimeParseDate :: DateTime  a -> Ptr  b ->  IO (Ptr  ())
dateTimeParseDate _obj date 
  = withObjectRef "dateTimeParseDate" _obj $ \cobj__obj -> 
    wxDateTime_ParseDate cobj__obj  date  
foreign import ccall "wxDateTime_ParseDate" wxDateTime_ParseDate :: Ptr (TDateTime a) -> Ptr  b -> IO (Ptr  ())

-- | usage: (@dateTimeParseDateTime obj datetime@).
dateTimeParseDateTime :: DateTime  a -> Ptr  b ->  IO (Ptr  ())
dateTimeParseDateTime _obj datetime 
  = withObjectRef "dateTimeParseDateTime" _obj $ \cobj__obj -> 
    wxDateTime_ParseDateTime cobj__obj  datetime  
foreign import ccall "wxDateTime_ParseDateTime" wxDateTime_ParseDateTime :: Ptr (TDateTime a) -> Ptr  b -> IO (Ptr  ())

-- | usage: (@dateTimeParseFormat obj date format dateDef@).
dateTimeParseFormat :: DateTime  a -> Ptr  b -> Ptr  c -> Ptr  d ->  IO (Ptr  ())
dateTimeParseFormat _obj date format dateDef 
  = withObjectRef "dateTimeParseFormat" _obj $ \cobj__obj -> 
    wxDateTime_ParseFormat cobj__obj  date  format  dateDef  
foreign import ccall "wxDateTime_ParseFormat" wxDateTime_ParseFormat :: Ptr (TDateTime a) -> Ptr  b -> Ptr  c -> Ptr  d -> IO (Ptr  ())

-- | usage: (@dateTimeParseRfc822Date obj date@).
dateTimeParseRfc822Date :: DateTime  a -> Ptr  b ->  IO (Ptr  ())
dateTimeParseRfc822Date _obj date 
  = withObjectRef "dateTimeParseRfc822Date" _obj $ \cobj__obj -> 
    wxDateTime_ParseRfc822Date cobj__obj  date  
foreign import ccall "wxDateTime_ParseRfc822Date" wxDateTime_ParseRfc822Date :: Ptr (TDateTime a) -> Ptr  b -> IO (Ptr  ())

-- | usage: (@dateTimeParseTime obj time@).
dateTimeParseTime :: DateTime  a -> Time  b ->  IO (Ptr  ())
dateTimeParseTime _obj time 
  = withObjectRef "dateTimeParseTime" _obj $ \cobj__obj -> 
    withObjectPtr time $ \cobj_time -> 
    wxDateTime_ParseTime cobj__obj  cobj_time  
foreign import ccall "wxDateTime_ParseTime" wxDateTime_ParseTime :: Ptr (TDateTime a) -> Ptr (TTime b) -> IO (Ptr  ())

-- | usage: (@dateTimeResetTime obj@).
dateTimeResetTime :: DateTime  a ->  IO ()
dateTimeResetTime _obj 
  = withObjectRef "dateTimeResetTime" _obj $ \cobj__obj -> 
    wxDateTime_ResetTime cobj__obj  
foreign import ccall "wxDateTime_ResetTime" wxDateTime_ResetTime :: Ptr (TDateTime a) -> IO ()

-- | usage: (@dateTimeSet obj day month year hour minute second millisec@).
dateTimeSet :: DateTime  a -> Int -> Int -> Int -> Int -> Int -> Int -> Int ->  IO ()
dateTimeSet _obj day month year hour minute second millisec 
  = withObjectRef "dateTimeSet" _obj $ \cobj__obj -> 
    wxDateTime_Set cobj__obj  (toCInt day)  (toCInt month)  (toCInt year)  (toCInt hour)  (toCInt minute)  (toCInt second)  (toCInt millisec)  
foreign import ccall "wxDateTime_Set" wxDateTime_Set :: Ptr (TDateTime a) -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()

-- | usage: (@dateTimeSetCountry country@).
dateTimeSetCountry :: Int ->  IO ()
dateTimeSetCountry country 
  = wxDateTime_SetCountry (toCInt country)  
foreign import ccall "wxDateTime_SetCountry" wxDateTime_SetCountry :: CInt -> IO ()

-- | usage: (@dateTimeSetDay obj day@).
dateTimeSetDay :: DateTime  a -> Int ->  IO ()
dateTimeSetDay _obj day 
  = withObjectRef "dateTimeSetDay" _obj $ \cobj__obj -> 
    wxDateTime_SetDay cobj__obj  (toCInt day)  
foreign import ccall "wxDateTime_SetDay" wxDateTime_SetDay :: Ptr (TDateTime a) -> CInt -> IO ()

-- | usage: (@dateTimeSetHour obj hour@).
dateTimeSetHour :: DateTime  a -> Int ->  IO ()
dateTimeSetHour _obj hour 
  = withObjectRef "dateTimeSetHour" _obj $ \cobj__obj -> 
    wxDateTime_SetHour cobj__obj  (toCInt hour)  
foreign import ccall "wxDateTime_SetHour" wxDateTime_SetHour :: Ptr (TDateTime a) -> CInt -> IO ()

-- | usage: (@dateTimeSetMillisecond obj millisecond@).
dateTimeSetMillisecond :: DateTime  a -> Int ->  IO ()
dateTimeSetMillisecond _obj millisecond 
  = withObjectRef "dateTimeSetMillisecond" _obj $ \cobj__obj -> 
    wxDateTime_SetMillisecond cobj__obj  (toCInt millisecond)  
foreign import ccall "wxDateTime_SetMillisecond" wxDateTime_SetMillisecond :: Ptr (TDateTime a) -> CInt -> IO ()

-- | usage: (@dateTimeSetMinute obj minute@).
dateTimeSetMinute :: DateTime  a -> Int ->  IO ()
dateTimeSetMinute _obj minute 
  = withObjectRef "dateTimeSetMinute" _obj $ \cobj__obj -> 
    wxDateTime_SetMinute cobj__obj  (toCInt minute)  
foreign import ccall "wxDateTime_SetMinute" wxDateTime_SetMinute :: Ptr (TDateTime a) -> CInt -> IO ()

-- | usage: (@dateTimeSetMonth obj month@).
dateTimeSetMonth :: DateTime  a -> Int ->  IO ()
dateTimeSetMonth _obj month 
  = withObjectRef "dateTimeSetMonth" _obj $ \cobj__obj -> 
    wxDateTime_SetMonth cobj__obj  (toCInt month)  
foreign import ccall "wxDateTime_SetMonth" wxDateTime_SetMonth :: Ptr (TDateTime a) -> CInt -> IO ()

-- | usage: (@dateTimeSetSecond obj second@).
dateTimeSetSecond :: DateTime  a -> Int ->  IO ()
dateTimeSetSecond _obj second 
  = withObjectRef "dateTimeSetSecond" _obj $ \cobj__obj -> 
    wxDateTime_SetSecond cobj__obj  (toCInt second)  
foreign import ccall "wxDateTime_SetSecond" wxDateTime_SetSecond :: Ptr (TDateTime a) -> CInt -> IO ()

-- | usage: (@dateTimeSetTime obj hour minute second millisec@).
dateTimeSetTime :: DateTime  a -> Int -> Int -> Int -> Int ->  IO ()
dateTimeSetTime _obj hour minute second millisec 
  = withObjectRef "dateTimeSetTime" _obj $ \cobj__obj -> 
    wxDateTime_SetTime cobj__obj  (toCInt hour)  (toCInt minute)  (toCInt second)  (toCInt millisec)  
foreign import ccall "wxDateTime_SetTime" wxDateTime_SetTime :: Ptr (TDateTime a) -> CInt -> CInt -> CInt -> CInt -> IO ()

-- | usage: (@dateTimeSetToCurrent obj@).
dateTimeSetToCurrent :: DateTime  a ->  IO ()
dateTimeSetToCurrent _obj 
  = withObjectRef "dateTimeSetToCurrent" _obj $ \cobj__obj -> 
    wxDateTime_SetToCurrent cobj__obj  
foreign import ccall "wxDateTime_SetToCurrent" wxDateTime_SetToCurrent :: Ptr (TDateTime a) -> IO ()

-- | usage: (@dateTimeSetToLastMonthDay obj month year@).
dateTimeSetToLastMonthDay :: DateTime  a -> Int -> Int ->  IO ()
dateTimeSetToLastMonthDay _obj month year 
  = withObjectRef "dateTimeSetToLastMonthDay" _obj $ \cobj__obj -> 
    wxDateTime_SetToLastMonthDay cobj__obj  (toCInt month)  (toCInt year)  
foreign import ccall "wxDateTime_SetToLastMonthDay" wxDateTime_SetToLastMonthDay :: Ptr (TDateTime a) -> CInt -> CInt -> IO ()

-- | usage: (@dateTimeSetToLastWeekDay obj weekday month year@).
dateTimeSetToLastWeekDay :: DateTime  a -> Int -> Int -> Int ->  IO Bool
dateTimeSetToLastWeekDay _obj weekday month year 
  = withBoolResult $
    withObjectRef "dateTimeSetToLastWeekDay" _obj $ \cobj__obj -> 
    wxDateTime_SetToLastWeekDay cobj__obj  (toCInt weekday)  (toCInt month)  (toCInt year)  
foreign import ccall "wxDateTime_SetToLastWeekDay" wxDateTime_SetToLastWeekDay :: Ptr (TDateTime a) -> CInt -> CInt -> CInt -> IO CBool

-- | usage: (@dateTimeSetToNextWeekDay obj weekday@).
dateTimeSetToNextWeekDay :: DateTime  a -> Int ->  IO ()
dateTimeSetToNextWeekDay _obj weekday 
  = withObjectRef "dateTimeSetToNextWeekDay" _obj $ \cobj__obj -> 
    wxDateTime_SetToNextWeekDay cobj__obj  (toCInt weekday)  
foreign import ccall "wxDateTime_SetToNextWeekDay" wxDateTime_SetToNextWeekDay :: Ptr (TDateTime a) -> CInt -> IO ()

-- | usage: (@dateTimeSetToPrevWeekDay obj weekday@).
dateTimeSetToPrevWeekDay :: DateTime  a -> Int ->  IO ()
dateTimeSetToPrevWeekDay _obj weekday 
  = withObjectRef "dateTimeSetToPrevWeekDay" _obj $ \cobj__obj -> 
    wxDateTime_SetToPrevWeekDay cobj__obj  (toCInt weekday)  
foreign import ccall "wxDateTime_SetToPrevWeekDay" wxDateTime_SetToPrevWeekDay :: Ptr (TDateTime a) -> CInt -> IO ()

-- | usage: (@dateTimeSetToWeekDay obj weekday n month year@).
dateTimeSetToWeekDay :: DateTime  a -> Int -> Int -> Int -> Int ->  IO Bool
dateTimeSetToWeekDay _obj weekday n month year 
  = withBoolResult $
    withObjectRef "dateTimeSetToWeekDay" _obj $ \cobj__obj -> 
    wxDateTime_SetToWeekDay cobj__obj  (toCInt weekday)  (toCInt n)  (toCInt month)  (toCInt year)  
foreign import ccall "wxDateTime_SetToWeekDay" wxDateTime_SetToWeekDay :: Ptr (TDateTime a) -> CInt -> CInt -> CInt -> CInt -> IO CBool

-- | usage: (@dateTimeSetToWeekDayInSameWeek obj weekday@).
dateTimeSetToWeekDayInSameWeek :: DateTime  a -> Int ->  IO ()
dateTimeSetToWeekDayInSameWeek _obj weekday 
  = withObjectRef "dateTimeSetToWeekDayInSameWeek" _obj $ \cobj__obj -> 
    wxDateTime_SetToWeekDayInSameWeek cobj__obj  (toCInt weekday)  
foreign import ccall "wxDateTime_SetToWeekDayInSameWeek" wxDateTime_SetToWeekDayInSameWeek :: Ptr (TDateTime a) -> CInt -> IO ()

-- | usage: (@dateTimeSetYear obj year@).
dateTimeSetYear :: DateTime  a -> Int ->  IO ()
dateTimeSetYear _obj year 
  = withObjectRef "dateTimeSetYear" _obj $ \cobj__obj -> 
    wxDateTime_SetYear cobj__obj  (toCInt year)  
foreign import ccall "wxDateTime_SetYear" wxDateTime_SetYear :: Ptr (TDateTime a) -> CInt -> IO ()

-- | usage: (@dateTimeSubtractDate obj diff@).
dateTimeSubtractDate :: DateTime  a -> Ptr  b ->  IO (DateTime  ())
dateTimeSubtractDate _obj diff 
  = withRefDateTime $ \pref -> 
    withObjectRef "dateTimeSubtractDate" _obj $ \cobj__obj -> 
    wxDateTime_SubtractDate cobj__obj  diff   pref
foreign import ccall "wxDateTime_SubtractDate" wxDateTime_SubtractDate :: Ptr (TDateTime a) -> Ptr  b -> Ptr (TDateTime ()) -> IO ()

-- | usage: (@dateTimeSubtractTime obj diff@).
dateTimeSubtractTime :: DateTime  a -> Ptr  b ->  IO (DateTime  ())
dateTimeSubtractTime _obj diff 
  = withRefDateTime $ \pref -> 
    withObjectRef "dateTimeSubtractTime" _obj $ \cobj__obj -> 
    wxDateTime_SubtractTime cobj__obj  diff   pref
foreign import ccall "wxDateTime_SubtractTime" wxDateTime_SubtractTime :: Ptr (TDateTime a) -> Ptr  b -> Ptr (TDateTime ()) -> IO ()

-- | usage: (@dateTimeToGMT obj noDST@).
dateTimeToGMT :: DateTime  a -> Int ->  IO ()
dateTimeToGMT _obj noDST 
  = withObjectRef "dateTimeToGMT" _obj $ \cobj__obj -> 
    wxDateTime_ToGMT cobj__obj  (toCInt noDST)  
foreign import ccall "wxDateTime_ToGMT" wxDateTime_ToGMT :: Ptr (TDateTime a) -> CInt -> IO ()

-- | usage: (@dateTimeToTimezone obj tz noDST@).
dateTimeToTimezone :: DateTime  a -> Int -> Int ->  IO ()
dateTimeToTimezone _obj tz noDST 
  = withObjectRef "dateTimeToTimezone" _obj $ \cobj__obj -> 
    wxDateTime_ToTimezone cobj__obj  (toCInt tz)  (toCInt noDST)  
foreign import ccall "wxDateTime_ToTimezone" wxDateTime_ToTimezone :: Ptr (TDateTime a) -> CInt -> CInt -> IO ()

-- | usage: (@dateTimeToday dt@).
dateTimeToday :: DateTime  a ->  IO ()
dateTimeToday dt 
  = withObjectRef "dateTimeToday" dt $ \cobj_dt -> 
    wxDateTime_Today cobj_dt  
foreign import ccall "wxDateTime_Today" wxDateTime_Today :: Ptr (TDateTime a) -> IO ()

-- | usage: (@dateTimeUNow dt@).
dateTimeUNow :: DateTime  a ->  IO ()
dateTimeUNow dt 
  = withObjectRef "dateTimeUNow" dt $ \cobj_dt -> 
    wxDateTime_UNow cobj_dt  
foreign import ccall "wxDateTime_UNow" wxDateTime_UNow :: Ptr (TDateTime a) -> IO ()

-- | usage: (@dateTimewxDateTime hilong lolong@).
dateTimewxDateTime :: Int -> Int ->  IO (Ptr  ())
dateTimewxDateTime hilong lolong 
  = wxDateTime_wxDateTime (toCInt hilong)  (toCInt lolong)  
foreign import ccall "wxDateTime_wxDateTime" wxDateTime_wxDateTime :: CInt -> CInt -> IO (Ptr  ())

-- | usage: (@dbClose db@).
dbClose :: Db  a ->  IO ()
dbClose db 
  = withObjectRef "dbClose" db $ \cobj_db -> 
    wxDb_Close cobj_db  
foreign import ccall "wxDb_Close" wxDb_Close :: Ptr (TDb a) -> IO ()

-- | usage: (@dbCloseConnections@).
dbCloseConnections ::  IO ()
dbCloseConnections 
  = wxDb_CloseConnections 
foreign import ccall "wxDb_CloseConnections" wxDb_CloseConnections :: IO ()

-- | usage: (@dbColInfArrayDelete self@).
dbColInfArrayDelete :: DbColInfArray  a ->  IO ()
dbColInfArrayDelete self 
  = withObjectRef "dbColInfArrayDelete" self $ \cobj_self -> 
    wxDbColInfArray_Delete cobj_self  
foreign import ccall "wxDbColInfArray_Delete" wxDbColInfArray_Delete :: Ptr (TDbColInfArray a) -> IO ()

-- | usage: (@dbColInfArrayGetColInf self index@).
dbColInfArrayGetColInf :: DbColInfArray  a -> Int ->  IO (DbColInf  ())
dbColInfArrayGetColInf self index 
  = withObjectResult $
    withObjectRef "dbColInfArrayGetColInf" self $ \cobj_self -> 
    wxDbColInfArray_GetColInf cobj_self  (toCInt index)  
foreign import ccall "wxDbColInfArray_GetColInf" wxDbColInfArray_GetColInf :: Ptr (TDbColInfArray a) -> CInt -> IO (Ptr (TDbColInf ()))

-- | usage: (@dbColInfGetBufferLength self@).
dbColInfGetBufferLength :: DbColInf  a ->  IO Int
dbColInfGetBufferLength self 
  = withIntResult $
    withObjectRef "dbColInfGetBufferLength" self $ \cobj_self -> 
    wxDbColInf_GetBufferLength cobj_self  
foreign import ccall "wxDbColInf_GetBufferLength" wxDbColInf_GetBufferLength :: Ptr (TDbColInf a) -> IO CInt

-- | usage: (@dbColInfGetCatalog self@).
dbColInfGetCatalog :: DbColInf  a ->  IO (String)
dbColInfGetCatalog self 
  = withManagedStringResult $
    withObjectRef "dbColInfGetCatalog" self $ \cobj_self -> 
    wxDbColInf_GetCatalog cobj_self  
foreign import ccall "wxDbColInf_GetCatalog" wxDbColInf_GetCatalog :: Ptr (TDbColInf a) -> IO (Ptr (TWxString ()))

-- | usage: (@dbColInfGetColName self@).
dbColInfGetColName :: DbColInf  a ->  IO (String)
dbColInfGetColName self 
  = withManagedStringResult $
    withObjectRef "dbColInfGetColName" self $ \cobj_self -> 
    wxDbColInf_GetColName cobj_self  
foreign import ccall "wxDbColInf_GetColName" wxDbColInf_GetColName :: Ptr (TDbColInf a) -> IO (Ptr (TWxString ()))

-- | usage: (@dbColInfGetColumnSize self@).
dbColInfGetColumnSize :: DbColInf  a ->  IO Int
dbColInfGetColumnSize self 
  = withIntResult $
    withObjectRef "dbColInfGetColumnSize" self $ \cobj_self -> 
    wxDbColInf_GetColumnSize cobj_self  
foreign import ccall "wxDbColInf_GetColumnSize" wxDbColInf_GetColumnSize :: Ptr (TDbColInf a) -> IO CInt

-- | usage: (@dbColInfGetDbDataType self@).
dbColInfGetDbDataType :: DbColInf  a ->  IO Int
dbColInfGetDbDataType self 
  = withIntResult $
    withObjectRef "dbColInfGetDbDataType" self $ \cobj_self -> 
    wxDbColInf_GetDbDataType cobj_self  
foreign import ccall "wxDbColInf_GetDbDataType" wxDbColInf_GetDbDataType :: Ptr (TDbColInf a) -> IO CInt

-- | usage: (@dbColInfGetDecimalDigits self@).
dbColInfGetDecimalDigits :: DbColInf  a ->  IO Int
dbColInfGetDecimalDigits self 
  = withIntResult $
    withObjectRef "dbColInfGetDecimalDigits" self $ \cobj_self -> 
    wxDbColInf_GetDecimalDigits cobj_self  
foreign import ccall "wxDbColInf_GetDecimalDigits" wxDbColInf_GetDecimalDigits :: Ptr (TDbColInf a) -> IO CInt

-- | usage: (@dbColInfGetFkCol self@).
dbColInfGetFkCol :: DbColInf  a ->  IO Int
dbColInfGetFkCol self 
  = withIntResult $
    withObjectRef "dbColInfGetFkCol" self $ \cobj_self -> 
    wxDbColInf_GetFkCol cobj_self  
foreign import ccall "wxDbColInf_GetFkCol" wxDbColInf_GetFkCol :: Ptr (TDbColInf a) -> IO CInt

-- | usage: (@dbColInfGetFkTableName self@).
dbColInfGetFkTableName :: DbColInf  a ->  IO (String)
dbColInfGetFkTableName self 
  = withManagedStringResult $
    withObjectRef "dbColInfGetFkTableName" self $ \cobj_self -> 
    wxDbColInf_GetFkTableName cobj_self  
foreign import ccall "wxDbColInf_GetFkTableName" wxDbColInf_GetFkTableName :: Ptr (TDbColInf a) -> IO (Ptr (TWxString ()))

-- | usage: (@dbColInfGetNumPrecRadix self@).
dbColInfGetNumPrecRadix :: DbColInf  a ->  IO Int
dbColInfGetNumPrecRadix self 
  = withIntResult $
    withObjectRef "dbColInfGetNumPrecRadix" self $ \cobj_self -> 
    wxDbColInf_GetNumPrecRadix cobj_self  
foreign import ccall "wxDbColInf_GetNumPrecRadix" wxDbColInf_GetNumPrecRadix :: Ptr (TDbColInf a) -> IO CInt

-- | usage: (@dbColInfGetPkCol self@).
dbColInfGetPkCol :: DbColInf  a ->  IO Int
dbColInfGetPkCol self 
  = withIntResult $
    withObjectRef "dbColInfGetPkCol" self $ \cobj_self -> 
    wxDbColInf_GetPkCol cobj_self  
foreign import ccall "wxDbColInf_GetPkCol" wxDbColInf_GetPkCol :: Ptr (TDbColInf a) -> IO CInt

-- | usage: (@dbColInfGetPkTableName self@).
dbColInfGetPkTableName :: DbColInf  a ->  IO (String)
dbColInfGetPkTableName self 
  = withManagedStringResult $
    withObjectRef "dbColInfGetPkTableName" self $ \cobj_self -> 
    wxDbColInf_GetPkTableName cobj_self  
foreign import ccall "wxDbColInf_GetPkTableName" wxDbColInf_GetPkTableName :: Ptr (TDbColInf a) -> IO (Ptr (TWxString ()))

-- | usage: (@dbColInfGetRemarks self@).
dbColInfGetRemarks :: DbColInf  a ->  IO (String)
dbColInfGetRemarks self 
  = withManagedStringResult $
    withObjectRef "dbColInfGetRemarks" self $ \cobj_self -> 
    wxDbColInf_GetRemarks cobj_self  
foreign import ccall "wxDbColInf_GetRemarks" wxDbColInf_GetRemarks :: Ptr (TDbColInf a) -> IO (Ptr (TWxString ()))

-- | usage: (@dbColInfGetSchema self@).
dbColInfGetSchema :: DbColInf  a ->  IO (String)
dbColInfGetSchema self 
  = withManagedStringResult $
    withObjectRef "dbColInfGetSchema" self $ \cobj_self -> 
    wxDbColInf_GetSchema cobj_self  
foreign import ccall "wxDbColInf_GetSchema" wxDbColInf_GetSchema :: Ptr (TDbColInf a) -> IO (Ptr (TWxString ()))

-- | usage: (@dbColInfGetSqlDataType self@).
dbColInfGetSqlDataType :: DbColInf  a ->  IO Int
dbColInfGetSqlDataType self 
  = withIntResult $
    withObjectRef "dbColInfGetSqlDataType" self $ \cobj_self -> 
    wxDbColInf_GetSqlDataType cobj_self  
foreign import ccall "wxDbColInf_GetSqlDataType" wxDbColInf_GetSqlDataType :: Ptr (TDbColInf a) -> IO CInt

-- | usage: (@dbColInfGetTableName self@).
dbColInfGetTableName :: DbColInf  a ->  IO (String)
dbColInfGetTableName self 
  = withManagedStringResult $
    withObjectRef "dbColInfGetTableName" self $ \cobj_self -> 
    wxDbColInf_GetTableName cobj_self  
foreign import ccall "wxDbColInf_GetTableName" wxDbColInf_GetTableName :: Ptr (TDbColInf a) -> IO (Ptr (TWxString ()))

-- | usage: (@dbColInfGetTypeName self@).
dbColInfGetTypeName :: DbColInf  a ->  IO (String)
dbColInfGetTypeName self 
  = withManagedStringResult $
    withObjectRef "dbColInfGetTypeName" self $ \cobj_self -> 
    wxDbColInf_GetTypeName cobj_self  
foreign import ccall "wxDbColInf_GetTypeName" wxDbColInf_GetTypeName :: Ptr (TDbColInf a) -> IO (Ptr (TWxString ()))

-- | usage: (@dbColInfIsNullable self@).
dbColInfIsNullable :: DbColInf  a ->  IO Bool
dbColInfIsNullable self 
  = withBoolResult $
    withObjectRef "dbColInfIsNullable" self $ \cobj_self -> 
    wxDbColInf_IsNullable cobj_self  
foreign import ccall "wxDbColInf_IsNullable" wxDbColInf_IsNullable :: Ptr (TDbColInf a) -> IO CBool

-- | usage: (@dbCommitTrans db@).
dbCommitTrans :: Db  a ->  IO Bool
dbCommitTrans db 
  = withBoolResult $
    withObjectRef "dbCommitTrans" db $ \cobj_db -> 
    wxDb_CommitTrans cobj_db  
foreign import ccall "wxDb_CommitTrans" wxDb_CommitTrans :: Ptr (TDb a) -> IO CBool

-- | usage: (@dbConnectInfAllocHenv self@).
dbConnectInfAllocHenv :: DbConnectInf  a ->  IO ()
dbConnectInfAllocHenv self 
  = withObjectRef "dbConnectInfAllocHenv" self $ \cobj_self -> 
    wxDbConnectInf_AllocHenv cobj_self  
foreign import ccall "wxDbConnectInf_AllocHenv" wxDbConnectInf_AllocHenv :: Ptr (TDbConnectInf a) -> IO ()

-- | usage: (@dbConnectInfCreate henv dsn userID password defaultDir description fileType@).
dbConnectInfCreate :: HENV  a -> String -> String -> String -> String -> String -> String ->  IO (DbConnectInf  ())
dbConnectInfCreate henv dsn userID password defaultDir description fileType 
  = withObjectResult $
    withObjectPtr henv $ \cobj_henv -> 
    withStringPtr dsn $ \cobj_dsn -> 
    withStringPtr userID $ \cobj_userID -> 
    withStringPtr password $ \cobj_password -> 
    withStringPtr defaultDir $ \cobj_defaultDir -> 
    withStringPtr description $ \cobj_description -> 
    withStringPtr fileType $ \cobj_fileType -> 
    wxDbConnectInf_Create cobj_henv  cobj_dsn  cobj_userID  cobj_password  cobj_defaultDir  cobj_description  cobj_fileType  
foreign import ccall "wxDbConnectInf_Create" wxDbConnectInf_Create :: Ptr (THENV a) -> Ptr (TWxString b) -> Ptr (TWxString c) -> Ptr (TWxString d) -> Ptr (TWxString e) -> Ptr (TWxString f) -> Ptr (TWxString g) -> IO (Ptr (TDbConnectInf ()))

-- | usage: (@dbConnectInfDelete self@).
dbConnectInfDelete :: DbConnectInf  a ->  IO ()
dbConnectInfDelete self 
  = withObjectRef "dbConnectInfDelete" self $ \cobj_self -> 
    wxDbConnectInf_Delete cobj_self  
foreign import ccall "wxDbConnectInf_Delete" wxDbConnectInf_Delete :: Ptr (TDbConnectInf a) -> IO ()

-- | usage: (@dbConnectInfFreeHenv self@).
dbConnectInfFreeHenv :: DbConnectInf  a ->  IO ()
dbConnectInfFreeHenv self 
  = withObjectRef "dbConnectInfFreeHenv" self $ \cobj_self -> 
    wxDbConnectInf_FreeHenv cobj_self  
foreign import ccall "wxDbConnectInf_FreeHenv" wxDbConnectInf_FreeHenv :: Ptr (TDbConnectInf a) -> IO ()

-- | usage: (@dbConnectInfGetHenv self@).
dbConnectInfGetHenv :: DbConnectInf  a ->  IO (HENV  ())
dbConnectInfGetHenv self 
  = withObjectResult $
    withObjectRef "dbConnectInfGetHenv" self $ \cobj_self -> 
    wxDbConnectInf_GetHenv cobj_self  
foreign import ccall "wxDbConnectInf_GetHenv" wxDbConnectInf_GetHenv :: Ptr (TDbConnectInf a) -> IO (Ptr (THENV ()))

-- | usage: (@dbConnectionsInUse@).
dbConnectionsInUse ::  IO Int
dbConnectionsInUse 
  = withIntResult $
    wxDb_ConnectionsInUse 
foreign import ccall "wxDb_ConnectionsInUse" wxDb_ConnectionsInUse :: IO CInt

-- | usage: (@dbCreate henv fwdOnlyCursors@).
dbCreate :: HENV  a -> Bool ->  IO (Db  ())
dbCreate henv fwdOnlyCursors 
  = withObjectResult $
    withObjectPtr henv $ \cobj_henv -> 
    wxDb_Create cobj_henv  (toCBool fwdOnlyCursors)  
foreign import ccall "wxDb_Create" wxDb_Create :: Ptr (THENV a) -> CBool -> IO (Ptr (TDb ()))

-- | usage: (@dbDbms db@).
dbDbms :: Db  a ->  IO Int
dbDbms db 
  = withIntResult $
    withObjectRef "dbDbms" db $ \cobj_db -> 
    wxDb_Dbms cobj_db  
foreign import ccall "wxDb_Dbms" wxDb_Dbms :: Ptr (TDb a) -> IO CInt

-- | usage: (@dbDelete db@).
dbDelete :: Db  a ->  IO ()
dbDelete db 
  = withObjectRef "dbDelete" db $ \cobj_db -> 
    wxDb_Delete cobj_db  
foreign import ccall "wxDb_Delete" wxDb_Delete :: Ptr (TDb a) -> IO ()

-- | usage: (@dbExecSql db sql@).
dbExecSql :: Db  a -> String ->  IO Bool
dbExecSql db sql 
  = withBoolResult $
    withObjectRef "dbExecSql" db $ \cobj_db -> 
    withStringPtr sql $ \cobj_sql -> 
    wxDb_ExecSql cobj_db  cobj_sql  
foreign import ccall "wxDb_ExecSql" wxDb_ExecSql :: Ptr (TDb a) -> Ptr (TWxString b) -> IO CBool

-- | usage: (@dbFreeConnection db@).
dbFreeConnection :: Db  a ->  IO Bool
dbFreeConnection db 
  = withBoolResult $
    withObjectRef "dbFreeConnection" db $ \cobj_db -> 
    wxDb_FreeConnection cobj_db  
foreign import ccall "wxDb_FreeConnection" wxDb_FreeConnection :: Ptr (TDb a) -> IO CBool

-- | usage: (@dbGetCatalog db userName@).
dbGetCatalog :: Db  a -> String ->  IO (DbInf  ())
dbGetCatalog db userName 
  = withObjectResult $
    withObjectRef "dbGetCatalog" db $ \cobj_db -> 
    withStringPtr userName $ \cobj_userName -> 
    wxDb_GetCatalog cobj_db  cobj_userName  
foreign import ccall "wxDb_GetCatalog" wxDb_GetCatalog :: Ptr (TDb a) -> Ptr (TWxString b) -> IO (Ptr (TDbInf ()))

-- | usage: (@dbGetColumnCount db tableName userName@).
dbGetColumnCount :: Db  a -> String -> String ->  IO Int
dbGetColumnCount db tableName userName 
  = withIntResult $
    withObjectRef "dbGetColumnCount" db $ \cobj_db -> 
    withStringPtr tableName $ \cobj_tableName -> 
    withStringPtr userName $ \cobj_userName -> 
    wxDb_GetColumnCount cobj_db  cobj_tableName  cobj_userName  
foreign import ccall "wxDb_GetColumnCount" wxDb_GetColumnCount :: Ptr (TDb a) -> Ptr (TWxString b) -> Ptr (TWxString c) -> IO CInt

-- | usage: (@dbGetColumns db tableName columnCount userName@).
dbGetColumns :: Db  a -> String -> Ptr CInt -> String ->  IO (DbColInfArray  ())
dbGetColumns db tableName columnCount userName 
  = withObjectResult $
    withObjectRef "dbGetColumns" db $ \cobj_db -> 
    withStringPtr tableName $ \cobj_tableName -> 
    withStringPtr userName $ \cobj_userName -> 
    wxDb_GetColumns cobj_db  cobj_tableName  columnCount  cobj_userName  
foreign import ccall "wxDb_GetColumns" wxDb_GetColumns :: Ptr (TDb a) -> Ptr (TWxString b) -> Ptr CInt -> Ptr (TWxString d) -> IO (Ptr (TDbColInfArray ()))

-- | usage: (@dbGetConnection connectInf fwdCursorsOnly@).
dbGetConnection :: DbConnectInf  a -> Bool ->  IO (Db  ())
dbGetConnection connectInf fwdCursorsOnly 
  = withObjectResult $
    withObjectPtr connectInf $ \cobj_connectInf -> 
    wxDb_GetConnection cobj_connectInf  (toCBool fwdCursorsOnly)  
foreign import ccall "wxDb_GetConnection" wxDb_GetConnection :: Ptr (TDbConnectInf a) -> CBool -> IO (Ptr (TDb ()))

-- | usage: (@dbGetData db column ctype wxdata dataLen usedLen@).
dbGetData :: Db  a -> Int -> Int -> Ptr  d -> Int -> Ptr CInt ->  IO Bool
dbGetData db column ctype wxdata dataLen usedLen 
  = withBoolResult $
    withObjectRef "dbGetData" db $ \cobj_db -> 
    wxDb_GetData cobj_db  (toCInt column)  (toCInt ctype)  wxdata  (toCInt dataLen)  usedLen  
foreign import ccall "wxDb_GetData" wxDb_GetData :: Ptr (TDb a) -> CInt -> CInt -> Ptr  d -> CInt -> Ptr CInt -> IO CBool

{- |  usage: @dbGetDataBinary db column asChars pbuffer plen@. Returns binary data to given buffer (that must be deallocated using 'wxcFree'). The return length is 'wxSQL_NULL_DATA' if @NULL@ data was encountered. If @asChars@ is 'True', the data is returned as characters, true binary data is than returned as a string of hex values (@3E002C...@).* -}
dbGetDataBinary :: Db  a -> Int -> Bool -> Ptr  d -> Ptr CInt ->  IO Bool
dbGetDataBinary db column asChars pbuf len 
  = withBoolResult $
    withObjectRef "dbGetDataBinary" db $ \cobj_db -> 
    wxDb_GetDataBinary cobj_db  (toCInt column)  (toCBool asChars)  pbuf  len  
foreign import ccall "wxDb_GetDataBinary" wxDb_GetDataBinary :: Ptr (TDb a) -> CInt -> CBool -> Ptr  d -> Ptr CInt -> IO CBool

-- | usage: (@dbGetDataDate db column ctime usedLen@).
dbGetDataDate :: Db  a -> Int -> Ptr CInt -> Ptr CInt ->  IO Bool
dbGetDataDate db column ctime usedLen 
  = withBoolResult $
    withObjectRef "dbGetDataDate" db $ \cobj_db -> 
    wxDb_GetDataDate cobj_db  (toCInt column)  ctime  usedLen  
foreign import ccall "wxDb_GetDataDate" wxDb_GetDataDate :: Ptr (TDb a) -> CInt -> Ptr CInt -> Ptr CInt -> IO CBool

-- | usage: (@dbGetDataDouble db column d usedLen@).
dbGetDataDouble :: Db  a -> Int -> Ptr Double -> Ptr CInt ->  IO Bool
dbGetDataDouble db column d usedLen 
  = withBoolResult $
    withObjectRef "dbGetDataDouble" db $ \cobj_db -> 
    wxDb_GetDataDouble cobj_db  (toCInt column)  d  usedLen  
foreign import ccall "wxDb_GetDataDouble" wxDb_GetDataDouble :: Ptr (TDb a) -> CInt -> Ptr Double -> Ptr CInt -> IO CBool

-- | usage: (@dbGetDataInt db column i usedLen@).
dbGetDataInt :: Db  a -> Int -> Ptr CInt -> Ptr CInt ->  IO Bool
dbGetDataInt db column i usedLen 
  = withBoolResult $
    withObjectRef "dbGetDataInt" db $ \cobj_db -> 
    wxDb_GetDataInt cobj_db  (toCInt column)  i  usedLen  
foreign import ccall "wxDb_GetDataInt" wxDb_GetDataInt :: Ptr (TDb a) -> CInt -> Ptr CInt -> Ptr CInt -> IO CBool

-- | usage: (@dbGetDataSource henv dsn dsnLen description descLen direction@).
dbGetDataSource :: HENV  a -> Ptr  b -> Int -> Ptr  d -> Int -> Int ->  IO Bool
dbGetDataSource henv dsn dsnLen description descLen direction 
  = withBoolResult $
    withObjectPtr henv $ \cobj_henv -> 
    wxDb_GetDataSource cobj_henv  dsn  (toCInt dsnLen)  description  (toCInt descLen)  (toCInt direction)  
foreign import ccall "wxDb_GetDataSource" wxDb_GetDataSource :: Ptr (THENV a) -> Ptr  b -> CInt -> Ptr  d -> CInt -> CInt -> IO CBool

-- | usage: (@dbGetDataTime db column secs usedLen@).
dbGetDataTime :: Db  a -> Int -> Ptr CInt -> Ptr CInt ->  IO Bool
dbGetDataTime db column secs usedLen 
  = withBoolResult $
    withObjectRef "dbGetDataTime" db $ \cobj_db -> 
    wxDb_GetDataTime cobj_db  (toCInt column)  secs  usedLen  
foreign import ccall "wxDb_GetDataTime" wxDb_GetDataTime :: Ptr (TDb a) -> CInt -> Ptr CInt -> Ptr CInt -> IO CBool

-- | usage: (@dbGetDataTimeStamp db column ctime fraction usedLen@).
dbGetDataTimeStamp :: Db  a -> Int -> Ptr CInt -> Ptr CInt -> Ptr CInt ->  IO Bool
dbGetDataTimeStamp db column ctime fraction usedLen 
  = withBoolResult $
    withObjectRef "dbGetDataTimeStamp" db $ \cobj_db -> 
    wxDb_GetDataTimeStamp cobj_db  (toCInt column)  ctime  fraction  usedLen  
foreign import ccall "wxDb_GetDataTimeStamp" wxDb_GetDataTimeStamp :: Ptr (TDb a) -> CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO CBool

-- | usage: (@dbGetDatabaseName db@).
dbGetDatabaseName :: Db  a ->  IO (String)
dbGetDatabaseName db 
  = withManagedStringResult $
    withObjectRef "dbGetDatabaseName" db $ \cobj_db -> 
    wxDb_GetDatabaseName cobj_db  
foreign import ccall "wxDb_GetDatabaseName" wxDb_GetDatabaseName :: Ptr (TDb a) -> IO (Ptr (TWxString ()))

-- | usage: (@dbGetDatasourceName db@).
dbGetDatasourceName :: Db  a ->  IO (String)
dbGetDatasourceName db 
  = withManagedStringResult $
    withObjectRef "dbGetDatasourceName" db $ \cobj_db -> 
    wxDb_GetDatasourceName cobj_db  
foreign import ccall "wxDb_GetDatasourceName" wxDb_GetDatasourceName :: Ptr (TDb a) -> IO (Ptr (TWxString ()))

{- |  Retrieve the last /n/ error messages, where
    /n/ is 'dbGetNumErrorMessages'. Index 0 is the most recent error
   that corresponds with 'dbGetStatus' and 'dbGetNativeError' * -}
dbGetErrorMessage :: Db  a -> Int ->  IO (String)
dbGetErrorMessage db index 
  = withManagedStringResult $
    withObjectRef "dbGetErrorMessage" db $ \cobj_db -> 
    wxDb_GetErrorMessage cobj_db  (toCInt index)  
foreign import ccall "wxDb_GetErrorMessage" wxDb_GetErrorMessage :: Ptr (TDb a) -> CInt -> IO (Ptr (TWxString ()))

{- |  Retrieve error message set by 'dbGetNextError' * -}
dbGetErrorMsg :: Db  a ->  IO (String)
dbGetErrorMsg db 
  = withManagedStringResult $
    withObjectRef "dbGetErrorMsg" db $ \cobj_db -> 
    wxDb_GetErrorMsg cobj_db  
foreign import ccall "wxDb_GetErrorMsg" wxDb_GetErrorMsg :: Ptr (TDb a) -> IO (Ptr (TWxString ()))

-- | usage: (@dbGetHDBC db@).
dbGetHDBC :: Db  a ->  IO (HDBC  ())
dbGetHDBC db 
  = withObjectResult $
    withObjectRef "dbGetHDBC" db $ \cobj_db -> 
    wxDb_GetHDBC cobj_db  
foreign import ccall "wxDb_GetHDBC" wxDb_GetHDBC :: Ptr (TDb a) -> IO (Ptr (THDBC ()))

-- | usage: (@dbGetHENV db@).
dbGetHENV :: Db  a ->  IO (HENV  ())
dbGetHENV db 
  = withObjectResult $
    withObjectRef "dbGetHENV" db $ \cobj_db -> 
    wxDb_GetHENV cobj_db  
foreign import ccall "wxDb_GetHENV" wxDb_GetHENV :: Ptr (TDb a) -> IO (Ptr (THENV ()))

-- | usage: (@dbGetHSTMT db@).
dbGetHSTMT :: Db  a ->  IO (HSTMT  ())
dbGetHSTMT db 
  = withObjectResult $
    withObjectRef "dbGetHSTMT" db $ \cobj_db -> 
    wxDb_GetHSTMT cobj_db  
foreign import ccall "wxDb_GetHSTMT" wxDb_GetHSTMT :: Ptr (TDb a) -> IO (Ptr (THSTMT ()))

-- | usage: (@dbGetNativeError db@).
dbGetNativeError :: Db  a ->  IO Int
dbGetNativeError db 
  = withIntResult $
    withObjectRef "dbGetNativeError" db $ \cobj_db -> 
    wxDb_GetNativeError cobj_db  
foreign import ccall "wxDb_GetNativeError" wxDb_GetNativeError :: Ptr (TDb a) -> IO CInt

-- | usage: (@dbGetNext db@).
dbGetNext :: Db  a ->  IO Bool
dbGetNext db 
  = withBoolResult $
    withObjectRef "dbGetNext" db $ \cobj_db -> 
    wxDb_GetNext cobj_db  
foreign import ccall "wxDb_GetNext" wxDb_GetNext :: Ptr (TDb a) -> IO CBool

-- | usage: (@dbGetNextError db henv hdbc hstmt@).
dbGetNextError :: Db  a -> HENV  b -> HDBC  c -> HSTMT  d ->  IO Bool
dbGetNextError db henv hdbc hstmt 
  = withBoolResult $
    withObjectRef "dbGetNextError" db $ \cobj_db -> 
    withObjectPtr henv $ \cobj_henv -> 
    withObjectPtr hdbc $ \cobj_hdbc -> 
    withObjectPtr hstmt $ \cobj_hstmt -> 
    wxDb_GetNextError cobj_db  cobj_henv  cobj_hdbc  cobj_hstmt  
foreign import ccall "wxDb_GetNextError" wxDb_GetNextError :: Ptr (TDb a) -> Ptr (THENV b) -> Ptr (THDBC c) -> Ptr (THSTMT d) -> IO CBool

{- |  Get the number of stored error messages. * -}
dbGetNumErrorMessages :: Db  a ->  IO Int
dbGetNumErrorMessages db 
  = withIntResult $
    withObjectRef "dbGetNumErrorMessages" db $ \cobj_db -> 
    wxDb_GetNumErrorMessages cobj_db  
foreign import ccall "wxDb_GetNumErrorMessages" wxDb_GetNumErrorMessages :: Ptr (TDb a) -> IO CInt

-- | usage: (@dbGetPassword db@).
dbGetPassword :: Db  a ->  IO (String)
dbGetPassword db 
  = withManagedStringResult $
    withObjectRef "dbGetPassword" db $ \cobj_db -> 
    wxDb_GetPassword cobj_db  
foreign import ccall "wxDb_GetPassword" wxDb_GetPassword :: Ptr (TDb a) -> IO (Ptr (TWxString ()))

{- |  Return dynamic column information about a result set of a query. * -}
dbGetResultColumns :: Db  a -> Ptr CInt ->  IO (DbColInfArray  ())
dbGetResultColumns db pnumCols 
  = withObjectResult $
    withObjectRef "dbGetResultColumns" db $ \cobj_db -> 
    wxDb_GetResultColumns cobj_db  pnumCols  
foreign import ccall "wxDb_GetResultColumns" wxDb_GetResultColumns :: Ptr (TDb a) -> Ptr CInt -> IO (Ptr (TDbColInfArray ()))

-- | usage: (@dbGetStatus db@).
dbGetStatus :: Db  a ->  IO Int
dbGetStatus db 
  = withIntResult $
    withObjectRef "dbGetStatus" db $ \cobj_db -> 
    wxDb_GetStatus cobj_db  
foreign import ccall "wxDb_GetStatus" wxDb_GetStatus :: Ptr (TDb a) -> IO CInt

-- | usage: (@dbGetTableCount db@).
dbGetTableCount :: Db  a ->  IO Int
dbGetTableCount db 
  = withIntResult $
    withObjectRef "dbGetTableCount" db $ \cobj_db -> 
    wxDb_GetTableCount cobj_db  
foreign import ccall "wxDb_GetTableCount" wxDb_GetTableCount :: Ptr (TDb a) -> IO CInt

-- | usage: (@dbGetUsername db@).
dbGetUsername :: Db  a ->  IO (String)
dbGetUsername db 
  = withManagedStringResult $
    withObjectRef "dbGetUsername" db $ \cobj_db -> 
    wxDb_GetUsername cobj_db  
foreign import ccall "wxDb_GetUsername" wxDb_GetUsername :: Ptr (TDb a) -> IO (Ptr (TWxString ()))

-- | usage: (@dbGrant db privileges tableName userList@).
dbGrant :: Db  a -> Int -> String -> String ->  IO Bool
dbGrant db privileges tableName userList 
  = withBoolResult $
    withObjectRef "dbGrant" db $ \cobj_db -> 
    withStringPtr tableName $ \cobj_tableName -> 
    withStringPtr userList $ \cobj_userList -> 
    wxDb_Grant cobj_db  (toCInt privileges)  cobj_tableName  cobj_userList  
foreign import ccall "wxDb_Grant" wxDb_Grant :: Ptr (TDb a) -> CInt -> Ptr (TWxString c) -> Ptr (TWxString d) -> IO CBool

-- | usage: (@dbInfDelete self@).
dbInfDelete :: DbInf  a ->  IO ()
dbInfDelete self 
  = withObjectRef "dbInfDelete" self $ \cobj_self -> 
    wxDbInf_Delete cobj_self  
foreign import ccall "wxDbInf_Delete" wxDbInf_Delete :: Ptr (TDbInf a) -> IO ()

-- | usage: (@dbInfGetCatalogName self@).
dbInfGetCatalogName :: DbInf  a ->  IO (String)
dbInfGetCatalogName self 
  = withManagedStringResult $
    withObjectRef "dbInfGetCatalogName" self $ \cobj_self -> 
    wxDbInf_GetCatalogName cobj_self  
foreign import ccall "wxDbInf_GetCatalogName" wxDbInf_GetCatalogName :: Ptr (TDbInf a) -> IO (Ptr (TWxString ()))

-- | usage: (@dbInfGetNumTables self@).
dbInfGetNumTables :: DbInf  a ->  IO Int
dbInfGetNumTables self 
  = withIntResult $
    withObjectRef "dbInfGetNumTables" self $ \cobj_self -> 
    wxDbInf_GetNumTables cobj_self  
foreign import ccall "wxDbInf_GetNumTables" wxDbInf_GetNumTables :: Ptr (TDbInf a) -> IO CInt

-- | usage: (@dbInfGetSchemaName self@).
dbInfGetSchemaName :: DbInf  a ->  IO (String)
dbInfGetSchemaName self 
  = withManagedStringResult $
    withObjectRef "dbInfGetSchemaName" self $ \cobj_self -> 
    wxDbInf_GetSchemaName cobj_self  
foreign import ccall "wxDbInf_GetSchemaName" wxDbInf_GetSchemaName :: Ptr (TDbInf a) -> IO (Ptr (TWxString ()))

-- | usage: (@dbInfGetTableInf self index@).
dbInfGetTableInf :: DbInf  a -> Int ->  IO (DbTableInf  ())
dbInfGetTableInf self index 
  = withObjectResult $
    withObjectRef "dbInfGetTableInf" self $ \cobj_self -> 
    wxDbInf_GetTableInf cobj_self  (toCInt index)  
foreign import ccall "wxDbInf_GetTableInf" wxDbInf_GetTableInf :: Ptr (TDbInf a) -> CInt -> IO (Ptr (TDbTableInf ()))

-- | usage: (@dbIsOpen db@).
dbIsOpen :: Db  a ->  IO Bool
dbIsOpen db 
  = withBoolResult $
    withObjectRef "dbIsOpen" db $ \cobj_db -> 
    wxDb_IsOpen cobj_db  
foreign import ccall "wxDb_IsOpen" wxDb_IsOpen :: Ptr (TDb a) -> IO CBool

{- |  Are the database classes supported on this platform ? * -}
dbIsSupported ::  IO Bool
dbIsSupported 
  = withBoolResult $
    wxDb_IsSupported 
foreign import ccall "wxDb_IsSupported" wxDb_IsSupported :: IO CBool

-- | usage: (@dbOpen db dsn userId password@).
dbOpen :: Db  a -> String -> String -> String ->  IO Bool
dbOpen db dsn userId password 
  = withBoolResult $
    withObjectRef "dbOpen" db $ \cobj_db -> 
    withStringPtr dsn $ \cobj_dsn -> 
    withStringPtr userId $ \cobj_userId -> 
    withStringPtr password $ \cobj_password -> 
    wxDb_Open cobj_db  cobj_dsn  cobj_userId  cobj_password  
foreign import ccall "wxDb_Open" wxDb_Open :: Ptr (TDb a) -> Ptr (TWxString b) -> Ptr (TWxString c) -> Ptr (TWxString d) -> IO CBool

-- | usage: (@dbRollbackTrans db@).
dbRollbackTrans :: Db  a ->  IO Bool
dbRollbackTrans db 
  = withBoolResult $
    withObjectRef "dbRollbackTrans" db $ \cobj_db -> 
    wxDb_RollbackTrans cobj_db  
foreign import ccall "wxDb_RollbackTrans" wxDb_RollbackTrans :: Ptr (TDb a) -> IO CBool

-- | usage: (@dbSQLColumnName db columnName@).
dbSQLColumnName :: Db  a -> String ->  IO (String)
dbSQLColumnName db columnName 
  = withManagedStringResult $
    withObjectRef "dbSQLColumnName" db $ \cobj_db -> 
    withStringPtr columnName $ \cobj_columnName -> 
    wxDb_SQLColumnName cobj_db  cobj_columnName  
foreign import ccall "wxDb_SQLColumnName" wxDb_SQLColumnName :: Ptr (TDb a) -> Ptr (TWxString b) -> IO (Ptr (TWxString ()))

-- | usage: (@dbSQLTableName db tableName@).
dbSQLTableName :: Db  a -> String ->  IO (String)
dbSQLTableName db tableName 
  = withManagedStringResult $
    withObjectRef "dbSQLTableName" db $ \cobj_db -> 
    withStringPtr tableName $ \cobj_tableName -> 
    wxDb_SQLTableName cobj_db  cobj_tableName  
foreign import ccall "wxDb_SQLTableName" wxDb_SQLTableName :: Ptr (TDb a) -> Ptr (TWxString b) -> IO (Ptr (TWxString ()))

-- | usage: (@dbSqlTypeToStandardSqlType sqlType@).
dbSqlTypeToStandardSqlType :: Int ->  IO Int
dbSqlTypeToStandardSqlType sqlType 
  = withIntResult $
    wxDb_SqlTypeToStandardSqlType (toCInt sqlType)  
foreign import ccall "wxDb_SqlTypeToStandardSqlType" wxDb_SqlTypeToStandardSqlType :: CInt -> IO CInt

-- | usage: (@dbStandardSqlTypeToSqlType sqlType@).
dbStandardSqlTypeToSqlType :: Int ->  IO Int
dbStandardSqlTypeToSqlType sqlType 
  = withIntResult $
    wxDb_StandardSqlTypeToSqlType (toCInt sqlType)  
foreign import ccall "wxDb_StandardSqlTypeToSqlType" wxDb_StandardSqlTypeToSqlType :: CInt -> IO CInt

-- | usage: (@dbTableExists db tableName userName path@).
dbTableExists :: Db  a -> String -> String -> String ->  IO Bool
dbTableExists db tableName userName path 
  = withBoolResult $
    withObjectRef "dbTableExists" db $ \cobj_db -> 
    withStringPtr tableName $ \cobj_tableName -> 
    withStringPtr userName $ \cobj_userName -> 
    withStringPtr path $ \cobj_path -> 
    wxDb_TableExists cobj_db  cobj_tableName  cobj_userName  cobj_path  
foreign import ccall "wxDb_TableExists" wxDb_TableExists :: Ptr (TDb a) -> Ptr (TWxString b) -> Ptr (TWxString c) -> Ptr (TWxString d) -> IO CBool

-- | usage: (@dbTableInfGetNumCols self@).
dbTableInfGetNumCols :: DbTableInf  a ->  IO Int
dbTableInfGetNumCols self 
  = withIntResult $
    withObjectRef "dbTableInfGetNumCols" self $ \cobj_self -> 
    wxDbTableInf_GetNumCols cobj_self  
foreign import ccall "wxDbTableInf_GetNumCols" wxDbTableInf_GetNumCols :: Ptr (TDbTableInf a) -> IO CInt

-- | usage: (@dbTableInfGetTableName self@).
dbTableInfGetTableName :: DbTableInf  a ->  IO (String)
dbTableInfGetTableName self 
  = withManagedStringResult $
    withObjectRef "dbTableInfGetTableName" self $ \cobj_self -> 
    wxDbTableInf_GetTableName cobj_self  
foreign import ccall "wxDbTableInf_GetTableName" wxDbTableInf_GetTableName :: Ptr (TDbTableInf a) -> IO (Ptr (TWxString ()))

-- | usage: (@dbTableInfGetTableRemarks self@).
dbTableInfGetTableRemarks :: DbTableInf  a ->  IO (String)
dbTableInfGetTableRemarks self 
  = withManagedStringResult $
    withObjectRef "dbTableInfGetTableRemarks" self $ \cobj_self -> 
    wxDbTableInf_GetTableRemarks cobj_self  
foreign import ccall "wxDbTableInf_GetTableRemarks" wxDbTableInf_GetTableRemarks :: Ptr (TDbTableInf a) -> IO (Ptr (TWxString ()))

-- | usage: (@dbTableInfGetTableType self@).
dbTableInfGetTableType :: DbTableInf  a ->  IO (String)
dbTableInfGetTableType self 
  = withManagedStringResult $
    withObjectRef "dbTableInfGetTableType" self $ \cobj_self -> 
    wxDbTableInf_GetTableType cobj_self  
foreign import ccall "wxDbTableInf_GetTableType" wxDbTableInf_GetTableType :: Ptr (TDbTableInf a) -> IO (Ptr (TWxString ()))

-- | usage: (@dbTablePrivileges db tableName privileges userName schema path@).
dbTablePrivileges :: Db  a -> String -> String -> String -> String -> String ->  IO Bool
dbTablePrivileges db tableName privileges userName schema path 
  = withBoolResult $
    withObjectRef "dbTablePrivileges" db $ \cobj_db -> 
    withStringPtr tableName $ \cobj_tableName -> 
    withStringPtr privileges $ \cobj_privileges -> 
    withStringPtr userName $ \cobj_userName -> 
    withStringPtr schema $ \cobj_schema -> 
    withStringPtr path $ \cobj_path -> 
    wxDb_TablePrivileges cobj_db  cobj_tableName  cobj_privileges  cobj_userName  cobj_schema  cobj_path  
foreign import ccall "wxDb_TablePrivileges" wxDb_TablePrivileges :: Ptr (TDb a) -> Ptr (TWxString b) -> Ptr (TWxString c) -> Ptr (TWxString d) -> Ptr (TWxString e) -> Ptr (TWxString f) -> IO CBool

-- | usage: (@dbTranslateSqlState db sqlState@).
dbTranslateSqlState :: Db  a -> String ->  IO Int
dbTranslateSqlState db sqlState 
  = withIntResult $
    withObjectRef "dbTranslateSqlState" db $ \cobj_db -> 
    withStringPtr sqlState $ \cobj_sqlState -> 
    wxDb_TranslateSqlState cobj_db  cobj_sqlState  
foreign import ccall "wxDb_TranslateSqlState" wxDb_TranslateSqlState :: Ptr (TDb a) -> Ptr (TWxString b) -> IO CInt

-- | usage: (@dcBeginDrawing obj@).
dcBeginDrawing :: DC  a ->  IO ()
dcBeginDrawing _obj 
  = withObjectRef "dcBeginDrawing" _obj $ \cobj__obj -> 
    wxDC_BeginDrawing cobj__obj  
foreign import ccall "wxDC_BeginDrawing" wxDC_BeginDrawing :: Ptr (TDC a) -> IO ()

-- | usage: (@dcBlit obj xdestydestwidthheight source xsrcysrc rop useMask@).
dcBlit :: DC  a -> Rect -> DC  c -> Point -> Int -> Bool ->  IO Bool
dcBlit _obj xdestydestwidthheight source xsrcysrc rop useMask 
  = withBoolResult $
    withObjectRef "dcBlit" _obj $ \cobj__obj -> 
    withObjectPtr source $ \cobj_source -> 
    wxDC_Blit cobj__obj  (toCIntRectX xdestydestwidthheight) (toCIntRectY xdestydestwidthheight)(toCIntRectW xdestydestwidthheight) (toCIntRectH xdestydestwidthheight)  cobj_source  (toCIntPointX xsrcysrc) (toCIntPointY xsrcysrc)  (toCInt rop)  (toCBool useMask)  
foreign import ccall "wxDC_Blit" wxDC_Blit :: Ptr (TDC a) -> CInt -> CInt -> CInt -> CInt -> Ptr (TDC c) -> CInt -> CInt -> CInt -> CBool -> IO CBool

-- | usage: (@dcCalcBoundingBox obj xy@).
dcCalcBoundingBox :: DC  a -> Point ->  IO ()
dcCalcBoundingBox _obj xy 
  = withObjectRef "dcCalcBoundingBox" _obj $ \cobj__obj -> 
    wxDC_CalcBoundingBox cobj__obj  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxDC_CalcBoundingBox" wxDC_CalcBoundingBox :: Ptr (TDC a) -> CInt -> CInt -> IO ()

-- | usage: (@dcCanDrawBitmap obj@).
dcCanDrawBitmap :: DC  a ->  IO Bool
dcCanDrawBitmap _obj 
  = withBoolResult $
    withObjectRef "dcCanDrawBitmap" _obj $ \cobj__obj -> 
    wxDC_CanDrawBitmap cobj__obj  
foreign import ccall "wxDC_CanDrawBitmap" wxDC_CanDrawBitmap :: Ptr (TDC a) -> IO CBool

-- | usage: (@dcCanGetTextExtent obj@).
dcCanGetTextExtent :: DC  a ->  IO Bool
dcCanGetTextExtent _obj 
  = withBoolResult $
    withObjectRef "dcCanGetTextExtent" _obj $ \cobj__obj -> 
    wxDC_CanGetTextExtent cobj__obj  
foreign import ccall "wxDC_CanGetTextExtent" wxDC_CanGetTextExtent :: Ptr (TDC a) -> IO CBool

-- | usage: (@dcClear obj@).
dcClear :: DC  a ->  IO ()
dcClear _obj 
  = withObjectRef "dcClear" _obj $ \cobj__obj -> 
    wxDC_Clear cobj__obj  
foreign import ccall "wxDC_Clear" wxDC_Clear :: Ptr (TDC a) -> IO ()

-- | usage: (@dcComputeScaleAndOrigin obj@).
dcComputeScaleAndOrigin :: DC  a ->  IO ()
dcComputeScaleAndOrigin obj 
  = withObjectRef "dcComputeScaleAndOrigin" obj $ \cobj_obj -> 
    wxDC_ComputeScaleAndOrigin cobj_obj  
foreign import ccall "wxDC_ComputeScaleAndOrigin" wxDC_ComputeScaleAndOrigin :: Ptr (TDC a) -> IO ()

-- | usage: (@dcCrossHair obj xy@).
dcCrossHair :: DC  a -> Point ->  IO ()
dcCrossHair _obj xy 
  = withObjectRef "dcCrossHair" _obj $ \cobj__obj -> 
    wxDC_CrossHair cobj__obj  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxDC_CrossHair" wxDC_CrossHair :: Ptr (TDC a) -> CInt -> CInt -> IO ()

-- | usage: (@dcDelete obj@).
dcDelete :: DC  a ->  IO ()
dcDelete
  = objectDelete


-- | usage: (@dcDestroyClippingRegion obj@).
dcDestroyClippingRegion :: DC  a ->  IO ()
dcDestroyClippingRegion _obj 
  = withObjectRef "dcDestroyClippingRegion" _obj $ \cobj__obj -> 
    wxDC_DestroyClippingRegion cobj__obj  
foreign import ccall "wxDC_DestroyClippingRegion" wxDC_DestroyClippingRegion :: Ptr (TDC a) -> IO ()

-- | usage: (@dcDeviceToLogicalX obj x@).
dcDeviceToLogicalX :: DC  a -> Int ->  IO Int
dcDeviceToLogicalX _obj x 
  = withIntResult $
    withObjectRef "dcDeviceToLogicalX" _obj $ \cobj__obj -> 
    wxDC_DeviceToLogicalX cobj__obj  (toCInt x)  
foreign import ccall "wxDC_DeviceToLogicalX" wxDC_DeviceToLogicalX :: Ptr (TDC a) -> CInt -> IO CInt

-- | usage: (@dcDeviceToLogicalXRel obj x@).
dcDeviceToLogicalXRel :: DC  a -> Int ->  IO Int
dcDeviceToLogicalXRel _obj x 
  = withIntResult $
    withObjectRef "dcDeviceToLogicalXRel" _obj $ \cobj__obj -> 
    wxDC_DeviceToLogicalXRel cobj__obj  (toCInt x)  
foreign import ccall "wxDC_DeviceToLogicalXRel" wxDC_DeviceToLogicalXRel :: Ptr (TDC a) -> CInt -> IO CInt

-- | usage: (@dcDeviceToLogicalY obj y@).
dcDeviceToLogicalY :: DC  a -> Int ->  IO Int
dcDeviceToLogicalY _obj y 
  = withIntResult $
    withObjectRef "dcDeviceToLogicalY" _obj $ \cobj__obj -> 
    wxDC_DeviceToLogicalY cobj__obj  (toCInt y)  
foreign import ccall "wxDC_DeviceToLogicalY" wxDC_DeviceToLogicalY :: Ptr (TDC a) -> CInt -> IO CInt

-- | usage: (@dcDeviceToLogicalYRel obj y@).
dcDeviceToLogicalYRel :: DC  a -> Int ->  IO Int
dcDeviceToLogicalYRel _obj y 
  = withIntResult $
    withObjectRef "dcDeviceToLogicalYRel" _obj $ \cobj__obj -> 
    wxDC_DeviceToLogicalYRel cobj__obj  (toCInt y)  
foreign import ccall "wxDC_DeviceToLogicalYRel" wxDC_DeviceToLogicalYRel :: Ptr (TDC a) -> CInt -> IO CInt

-- | usage: (@dcDrawArc obj x1y1 x2y2 xcyc@).
dcDrawArc :: DC  a -> Point -> Point -> Point ->  IO ()
dcDrawArc _obj x1y1 x2y2 xcyc 
  = withObjectRef "dcDrawArc" _obj $ \cobj__obj -> 
    wxDC_DrawArc cobj__obj  (toCIntPointX x1y1) (toCIntPointY x1y1)  (toCIntPointX x2y2) (toCIntPointY x2y2)  (toCIntPointX xcyc) (toCIntPointY xcyc)  
foreign import ccall "wxDC_DrawArc" wxDC_DrawArc :: Ptr (TDC a) -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()

-- | usage: (@dcDrawBitmap obj bmp xy useMask@).
dcDrawBitmap :: DC  a -> Bitmap  b -> Point -> Bool ->  IO ()
dcDrawBitmap _obj bmp xy useMask 
  = withObjectRef "dcDrawBitmap" _obj $ \cobj__obj -> 
    withObjectPtr bmp $ \cobj_bmp -> 
    wxDC_DrawBitmap cobj__obj  cobj_bmp  (toCIntPointX xy) (toCIntPointY xy)  (toCBool useMask)  
foreign import ccall "wxDC_DrawBitmap" wxDC_DrawBitmap :: Ptr (TDC a) -> Ptr (TBitmap b) -> CInt -> CInt -> CBool -> IO ()

-- | usage: (@dcDrawCheckMark obj xywidthheight@).
dcDrawCheckMark :: DC  a -> Rect ->  IO ()
dcDrawCheckMark _obj xywidthheight 
  = withObjectRef "dcDrawCheckMark" _obj $ \cobj__obj -> 
    wxDC_DrawCheckMark cobj__obj  (toCIntRectX xywidthheight) (toCIntRectY xywidthheight)(toCIntRectW xywidthheight) (toCIntRectH xywidthheight)  
foreign import ccall "wxDC_DrawCheckMark" wxDC_DrawCheckMark :: Ptr (TDC a) -> CInt -> CInt -> CInt -> CInt -> IO ()

-- | usage: (@dcDrawCircle obj xy radius@).
dcDrawCircle :: DC  a -> Point -> Int ->  IO ()
dcDrawCircle _obj xy radius 
  = withObjectRef "dcDrawCircle" _obj $ \cobj__obj -> 
    wxDC_DrawCircle cobj__obj  (toCIntPointX xy) (toCIntPointY xy)  (toCInt radius)  
foreign import ccall "wxDC_DrawCircle" wxDC_DrawCircle :: Ptr (TDC a) -> CInt -> CInt -> CInt -> IO ()

-- | usage: (@dcDrawEllipse obj xywidthheight@).
dcDrawEllipse :: DC  a -> Rect ->  IO ()
dcDrawEllipse _obj xywidthheight 
  = withObjectRef "dcDrawEllipse" _obj $ \cobj__obj -> 
    wxDC_DrawEllipse cobj__obj  (toCIntRectX xywidthheight) (toCIntRectY xywidthheight)(toCIntRectW xywidthheight) (toCIntRectH xywidthheight)  
foreign import ccall "wxDC_DrawEllipse" wxDC_DrawEllipse :: Ptr (TDC a) -> CInt -> CInt -> CInt -> CInt -> IO ()

-- | usage: (@dcDrawEllipticArc obj xywh sa ea@).
dcDrawEllipticArc :: DC  a -> Rect -> Double -> Double ->  IO ()
dcDrawEllipticArc _obj xywh sa ea 
  = withObjectRef "dcDrawEllipticArc" _obj $ \cobj__obj -> 
    wxDC_DrawEllipticArc cobj__obj  (toCIntRectX xywh) (toCIntRectY xywh)(toCIntRectW xywh) (toCIntRectH xywh)  sa  ea  
foreign import ccall "wxDC_DrawEllipticArc" wxDC_DrawEllipticArc :: Ptr (TDC a) -> CInt -> CInt -> CInt -> CInt -> Double -> Double -> IO ()

-- | usage: (@dcDrawIcon obj icon xy@).
dcDrawIcon :: DC  a -> Icon  b -> Point ->  IO ()
dcDrawIcon _obj icon xy 
  = withObjectRef "dcDrawIcon" _obj $ \cobj__obj -> 
    withObjectPtr icon $ \cobj_icon -> 
    wxDC_DrawIcon cobj__obj  cobj_icon  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxDC_DrawIcon" wxDC_DrawIcon :: Ptr (TDC a) -> Ptr (TIcon b) -> CInt -> CInt -> IO ()

-- | usage: (@dcDrawLabel obj str xywh align indexAccel@).
dcDrawLabel :: DC  a -> String -> Rect -> Int -> Int ->  IO ()
dcDrawLabel _obj str xywh align indexAccel 
  = withObjectRef "dcDrawLabel" _obj $ \cobj__obj -> 
    withStringPtr str $ \cobj_str -> 
    wxDC_DrawLabel cobj__obj  cobj_str  (toCIntRectX xywh) (toCIntRectY xywh)(toCIntRectW xywh) (toCIntRectH xywh)  (toCInt align)  (toCInt indexAccel)  
foreign import ccall "wxDC_DrawLabel" wxDC_DrawLabel :: Ptr (TDC a) -> Ptr (TWxString b) -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()

-- | usage: (@dcDrawLabelBitmap obj str bmp xywh align indexAccel@).
dcDrawLabelBitmap :: DC  a -> String -> Bitmap  c -> Rect -> Int -> Int ->  IO (Rect)
dcDrawLabelBitmap _obj str bmp xywh align indexAccel 
  = withWxRectResult $
    withObjectRef "dcDrawLabelBitmap" _obj $ \cobj__obj -> 
    withStringPtr str $ \cobj_str -> 
    withObjectPtr bmp $ \cobj_bmp -> 
    wxDC_DrawLabelBitmap cobj__obj  cobj_str  cobj_bmp  (toCIntRectX xywh) (toCIntRectY xywh)(toCIntRectW xywh) (toCIntRectH xywh)  (toCInt align)  (toCInt indexAccel)  
foreign import ccall "wxDC_DrawLabelBitmap" wxDC_DrawLabelBitmap :: Ptr (TDC a) -> Ptr (TWxString b) -> Ptr (TBitmap c) -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (TWxRect ()))

-- | usage: (@dcDrawLine obj x1y1 x2y2@).
dcDrawLine :: DC  a -> Point -> Point ->  IO ()
dcDrawLine _obj x1y1 x2y2 
  = withObjectRef "dcDrawLine" _obj $ \cobj__obj -> 
    wxDC_DrawLine cobj__obj  (toCIntPointX x1y1) (toCIntPointY x1y1)  (toCIntPointX x2y2) (toCIntPointY x2y2)  
foreign import ccall "wxDC_DrawLine" wxDC_DrawLine :: Ptr (TDC a) -> CInt -> CInt -> CInt -> CInt -> IO ()

-- | usage: (@dcDrawLines obj n x y xoffsetyoffset@).
dcDrawLines :: DC  a -> Int -> Ptr  c -> Ptr  d -> Point ->  IO ()
dcDrawLines _obj n x y xoffsetyoffset 
  = withObjectRef "dcDrawLines" _obj $ \cobj__obj -> 
    wxDC_DrawLines cobj__obj  (toCInt n)  x  y  (toCIntPointX xoffsetyoffset) (toCIntPointY xoffsetyoffset)  
foreign import ccall "wxDC_DrawLines" wxDC_DrawLines :: Ptr (TDC a) -> CInt -> Ptr  c -> Ptr  d -> CInt -> CInt -> IO ()

-- | usage: (@dcDrawPoint obj xy@).
dcDrawPoint :: DC  a -> Point ->  IO ()
dcDrawPoint _obj xy 
  = withObjectRef "dcDrawPoint" _obj $ \cobj__obj -> 
    wxDC_DrawPoint cobj__obj  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxDC_DrawPoint" wxDC_DrawPoint :: Ptr (TDC a) -> CInt -> CInt -> IO ()

-- | usage: (@dcDrawPolyPolygon obj n count x y xoffsetyoffset fillStyle@).
dcDrawPolyPolygon :: DC  a -> Int -> Ptr  c -> Ptr  d -> Ptr  e -> Point -> Int ->  IO ()
dcDrawPolyPolygon _obj n count x y xoffsetyoffset fillStyle 
  = withObjectRef "dcDrawPolyPolygon" _obj $ \cobj__obj -> 
    wxDC_DrawPolyPolygon cobj__obj  (toCInt n)  count  x  y  (toCIntPointX xoffsetyoffset) (toCIntPointY xoffsetyoffset)  (toCInt fillStyle)  
foreign import ccall "wxDC_DrawPolyPolygon" wxDC_DrawPolyPolygon :: Ptr (TDC a) -> CInt -> Ptr  c -> Ptr  d -> Ptr  e -> CInt -> CInt -> CInt -> IO ()

-- | usage: (@dcDrawPolygon obj n x y xoffsetyoffset fillStyle@).
dcDrawPolygon :: DC  a -> Int -> Ptr  c -> Ptr  d -> Point -> Int ->  IO ()
dcDrawPolygon _obj n x y xoffsetyoffset fillStyle 
  = withObjectRef "dcDrawPolygon" _obj $ \cobj__obj -> 
    wxDC_DrawPolygon cobj__obj  (toCInt n)  x  y  (toCIntPointX xoffsetyoffset) (toCIntPointY xoffsetyoffset)  (toCInt fillStyle)  
foreign import ccall "wxDC_DrawPolygon" wxDC_DrawPolygon :: Ptr (TDC a) -> CInt -> Ptr  c -> Ptr  d -> CInt -> CInt -> CInt -> IO ()

-- | usage: (@dcDrawRectangle obj xywidthheight@).
dcDrawRectangle :: DC  a -> Rect ->  IO ()
dcDrawRectangle _obj xywidthheight 
  = withObjectRef "dcDrawRectangle" _obj $ \cobj__obj -> 
    wxDC_DrawRectangle cobj__obj  (toCIntRectX xywidthheight) (toCIntRectY xywidthheight)(toCIntRectW xywidthheight) (toCIntRectH xywidthheight)  
foreign import ccall "wxDC_DrawRectangle" wxDC_DrawRectangle :: Ptr (TDC a) -> CInt -> CInt -> CInt -> CInt -> IO ()

-- | usage: (@dcDrawRotatedText obj text xy angle@).
dcDrawRotatedText :: DC  a -> String -> Point -> Double ->  IO ()
dcDrawRotatedText _obj text xy angle 
  = withObjectRef "dcDrawRotatedText" _obj $ \cobj__obj -> 
    withStringPtr text $ \cobj_text -> 
    wxDC_DrawRotatedText cobj__obj  cobj_text  (toCIntPointX xy) (toCIntPointY xy)  angle  
foreign import ccall "wxDC_DrawRotatedText" wxDC_DrawRotatedText :: Ptr (TDC a) -> Ptr (TWxString b) -> CInt -> CInt -> Double -> IO ()

-- | usage: (@dcDrawRoundedRectangle obj xywidthheight radius@).
dcDrawRoundedRectangle :: DC  a -> Rect -> Double ->  IO ()
dcDrawRoundedRectangle _obj xywidthheight radius 
  = withObjectRef "dcDrawRoundedRectangle" _obj $ \cobj__obj -> 
    wxDC_DrawRoundedRectangle cobj__obj  (toCIntRectX xywidthheight) (toCIntRectY xywidthheight)(toCIntRectW xywidthheight) (toCIntRectH xywidthheight)  radius  
foreign import ccall "wxDC_DrawRoundedRectangle" wxDC_DrawRoundedRectangle :: Ptr (TDC a) -> CInt -> CInt -> CInt -> CInt -> Double -> IO ()

-- | usage: (@dcDrawText obj text xy@).
dcDrawText :: DC  a -> String -> Point ->  IO ()
dcDrawText _obj text xy 
  = withObjectRef "dcDrawText" _obj $ \cobj__obj -> 
    withStringPtr text $ \cobj_text -> 
    wxDC_DrawText cobj__obj  cobj_text  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxDC_DrawText" wxDC_DrawText :: Ptr (TDC a) -> Ptr (TWxString b) -> CInt -> CInt -> IO ()

-- | usage: (@dcEndDoc obj@).
dcEndDoc :: DC  a ->  IO ()
dcEndDoc _obj 
  = withObjectRef "dcEndDoc" _obj $ \cobj__obj -> 
    wxDC_EndDoc cobj__obj  
foreign import ccall "wxDC_EndDoc" wxDC_EndDoc :: Ptr (TDC a) -> IO ()

-- | usage: (@dcEndDrawing obj@).
dcEndDrawing :: DC  a ->  IO ()
dcEndDrawing _obj 
  = withObjectRef "dcEndDrawing" _obj $ \cobj__obj -> 
    wxDC_EndDrawing cobj__obj  
foreign import ccall "wxDC_EndDrawing" wxDC_EndDrawing :: Ptr (TDC a) -> IO ()

-- | usage: (@dcEndPage obj@).
dcEndPage :: DC  a ->  IO ()
dcEndPage _obj 
  = withObjectRef "dcEndPage" _obj $ \cobj__obj -> 
    wxDC_EndPage cobj__obj  
foreign import ccall "wxDC_EndPage" wxDC_EndPage :: Ptr (TDC a) -> IO ()

-- | usage: (@dcFloodFill obj xy col style@).
dcFloodFill :: DC  a -> Point -> Color -> Int ->  IO ()
dcFloodFill _obj xy col style 
  = withObjectRef "dcFloodFill" _obj $ \cobj__obj -> 
    withColourPtr col $ \cobj_col -> 
    wxDC_FloodFill cobj__obj  (toCIntPointX xy) (toCIntPointY xy)  cobj_col  (toCInt style)  
foreign import ccall "wxDC_FloodFill" wxDC_FloodFill :: Ptr (TDC a) -> CInt -> CInt -> Ptr (TColour c) -> CInt -> IO ()

-- | usage: (@dcGetBackground obj@).
dcGetBackground :: DC  a ->  IO (Brush  ())
dcGetBackground _obj 
  = withRefBrush $ \pref -> 
    withObjectRef "dcGetBackground" _obj $ \cobj__obj -> 
    wxDC_GetBackground cobj__obj   pref
foreign import ccall "wxDC_GetBackground" wxDC_GetBackground :: Ptr (TDC a) -> Ptr (TBrush ()) -> IO ()

-- | usage: (@dcGetBackgroundMode obj@).
dcGetBackgroundMode :: DC  a ->  IO Int
dcGetBackgroundMode _obj 
  = withIntResult $
    withObjectRef "dcGetBackgroundMode" _obj $ \cobj__obj -> 
    wxDC_GetBackgroundMode cobj__obj  
foreign import ccall "wxDC_GetBackgroundMode" wxDC_GetBackgroundMode :: Ptr (TDC a) -> IO CInt

-- | usage: (@dcGetBrush obj@).
dcGetBrush :: DC  a ->  IO (Brush  ())
dcGetBrush _obj 
  = withRefBrush $ \pref -> 
    withObjectRef "dcGetBrush" _obj $ \cobj__obj -> 
    wxDC_GetBrush cobj__obj   pref
foreign import ccall "wxDC_GetBrush" wxDC_GetBrush :: Ptr (TDC a) -> Ptr (TBrush ()) -> IO ()

-- | usage: (@dcGetCharHeight obj@).
dcGetCharHeight :: DC  a ->  IO Int
dcGetCharHeight _obj 
  = withIntResult $
    withObjectRef "dcGetCharHeight" _obj $ \cobj__obj -> 
    wxDC_GetCharHeight cobj__obj  
foreign import ccall "wxDC_GetCharHeight" wxDC_GetCharHeight :: Ptr (TDC a) -> IO CInt

-- | usage: (@dcGetCharWidth obj@).
dcGetCharWidth :: DC  a ->  IO Int
dcGetCharWidth _obj 
  = withIntResult $
    withObjectRef "dcGetCharWidth" _obj $ \cobj__obj -> 
    wxDC_GetCharWidth cobj__obj  
foreign import ccall "wxDC_GetCharWidth" wxDC_GetCharWidth :: Ptr (TDC a) -> IO CInt

-- | usage: (@dcGetClippingBox obj@).
dcGetClippingBox :: DC  a ->  IO Rect
dcGetClippingBox _obj 
  = withRectResult $ \px py pw ph -> 
    withObjectRef "dcGetClippingBox" _obj $ \cobj__obj -> 
    wxDC_GetClippingBox cobj__obj  px py pw ph
foreign import ccall "wxDC_GetClippingBox" wxDC_GetClippingBox :: Ptr (TDC a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()

-- | usage: (@dcGetDepth obj@).
dcGetDepth :: DC  a ->  IO Int
dcGetDepth _obj 
  = withIntResult $
    withObjectRef "dcGetDepth" _obj $ \cobj__obj -> 
    wxDC_GetDepth cobj__obj  
foreign import ccall "wxDC_GetDepth" wxDC_GetDepth :: Ptr (TDC a) -> IO CInt

-- | usage: (@dcGetDeviceOrigin obj@).
dcGetDeviceOrigin :: DC  a ->  IO Point
dcGetDeviceOrigin _obj 
  = withPointResult $ \px py -> 
    withObjectRef "dcGetDeviceOrigin" _obj $ \cobj__obj -> 
    wxDC_GetDeviceOrigin cobj__obj   px py
foreign import ccall "wxDC_GetDeviceOrigin" wxDC_GetDeviceOrigin :: Ptr (TDC a) -> Ptr CInt -> Ptr CInt -> IO ()

-- | usage: (@dcGetFont obj@).
dcGetFont :: DC  a ->  IO (Font  ())
dcGetFont _obj 
  = withRefFont $ \pref -> 
    withObjectRef "dcGetFont" _obj $ \cobj__obj -> 
    wxDC_GetFont cobj__obj   pref
foreign import ccall "wxDC_GetFont" wxDC_GetFont :: Ptr (TDC a) -> Ptr (TFont ()) -> IO ()

-- | usage: (@dcGetLogicalFunction obj@).
dcGetLogicalFunction :: DC  a ->  IO Int
dcGetLogicalFunction _obj 
  = withIntResult $
    withObjectRef "dcGetLogicalFunction" _obj $ \cobj__obj -> 
    wxDC_GetLogicalFunction cobj__obj  
foreign import ccall "wxDC_GetLogicalFunction" wxDC_GetLogicalFunction :: Ptr (TDC a) -> IO CInt

-- | usage: (@dcGetLogicalOrigin obj@).
dcGetLogicalOrigin :: DC  a ->  IO Point
dcGetLogicalOrigin _obj 
  = withPointResult $ \px py -> 
    withObjectRef "dcGetLogicalOrigin" _obj $ \cobj__obj -> 
    wxDC_GetLogicalOrigin cobj__obj   px py
foreign import ccall "wxDC_GetLogicalOrigin" wxDC_GetLogicalOrigin :: Ptr (TDC a) -> Ptr CInt -> Ptr CInt -> IO ()

-- | usage: (@dcGetLogicalScale obj@).
dcGetLogicalScale :: DC  a ->  IO (Size2D Double)
dcGetLogicalScale _obj 
  = withSizeDoubleResult $ \pw ph -> 
    withObjectRef "dcGetLogicalScale" _obj $ \cobj__obj -> 
    wxDC_GetLogicalScale cobj__obj   pw ph
foreign import ccall "wxDC_GetLogicalScale" wxDC_GetLogicalScale :: Ptr (TDC a) -> Ptr CDouble -> Ptr CDouble -> IO ()

-- | usage: (@dcGetMapMode obj@).
dcGetMapMode :: DC  a ->  IO Int
dcGetMapMode _obj 
  = withIntResult $
    withObjectRef "dcGetMapMode" _obj $ \cobj__obj -> 
    wxDC_GetMapMode cobj__obj  
foreign import ccall "wxDC_GetMapMode" wxDC_GetMapMode :: Ptr (TDC a) -> IO CInt

-- | usage: (@dcGetMultiLineTextExtent self string w h heightLine theFont@).
dcGetMultiLineTextExtent :: DC  a -> String -> Ptr  c -> Ptr  d -> Ptr  e -> Font  f ->  IO ()
dcGetMultiLineTextExtent self string w h heightLine theFont 
  = withObjectRef "dcGetMultiLineTextExtent" self $ \cobj_self -> 
    withStringPtr string $ \cobj_string -> 
    withObjectPtr theFont $ \cobj_theFont -> 
    wxDC_GetMultiLineTextExtent cobj_self  cobj_string  w  h  heightLine  cobj_theFont  
foreign import ccall "wxDC_GetMultiLineTextExtent" wxDC_GetMultiLineTextExtent :: Ptr (TDC a) -> Ptr (TWxString b) -> Ptr  c -> Ptr  d -> Ptr  e -> Ptr (TFont f) -> IO ()

-- | usage: (@dcGetPPI obj@).
dcGetPPI :: DC  a ->  IO (Size)
dcGetPPI _obj 
  = withWxSizeResult $
    withObjectRef "dcGetPPI" _obj $ \cobj__obj -> 
    wxDC_GetPPI cobj__obj  
foreign import ccall "wxDC_GetPPI" wxDC_GetPPI :: Ptr (TDC a) -> IO (Ptr (TWxSize ()))

-- | usage: (@dcGetPen obj@).
dcGetPen :: DC  a ->  IO (Pen  ())
dcGetPen _obj 
  = withRefPen $ \pref -> 
    withObjectRef "dcGetPen" _obj $ \cobj__obj -> 
    wxDC_GetPen cobj__obj   pref
foreign import ccall "wxDC_GetPen" wxDC_GetPen :: Ptr (TDC a) -> Ptr (TPen ()) -> IO ()

-- | usage: (@dcGetPixel obj xy col@).
dcGetPixel :: DC  a -> Point -> Color ->  IO Bool
dcGetPixel _obj xy col 
  = withBoolResult $
    withObjectRef "dcGetPixel" _obj $ \cobj__obj -> 
    withColourPtr col $ \cobj_col -> 
    wxDC_GetPixel cobj__obj  (toCIntPointX xy) (toCIntPointY xy)  cobj_col  
foreign import ccall "wxDC_GetPixel" wxDC_GetPixel :: Ptr (TDC a) -> CInt -> CInt -> Ptr (TColour c) -> IO CBool

{- |  Get the color of pixel. Note: this is not a portable method at the moment and its use is discouraged. * -}
dcGetPixel2 :: DC  a -> Point ->  IO (Color)
dcGetPixel2 _obj xy 
  = withRefColour $ \pref -> 
    withObjectRef "dcGetPixel2" _obj $ \cobj__obj -> 
    wxDC_GetPixel2 cobj__obj  (toCIntPointX xy) (toCIntPointY xy)   pref
foreign import ccall "wxDC_GetPixel2" wxDC_GetPixel2 :: Ptr (TDC a) -> CInt -> CInt -> Ptr (TColour ()) -> IO ()

-- | usage: (@dcGetSize obj@).
dcGetSize :: DC  a ->  IO (Size)
dcGetSize _obj 
  = withWxSizeResult $
    withObjectRef "dcGetSize" _obj $ \cobj__obj -> 
    wxDC_GetSize cobj__obj  
foreign import ccall "wxDC_GetSize" wxDC_GetSize :: Ptr (TDC a) -> IO (Ptr (TWxSize ()))

-- | usage: (@dcGetSizeMM obj@).
dcGetSizeMM :: DC  a ->  IO (Size)
dcGetSizeMM _obj 
  = withWxSizeResult $
    withObjectRef "dcGetSizeMM" _obj $ \cobj__obj -> 
    wxDC_GetSizeMM cobj__obj  
foreign import ccall "wxDC_GetSizeMM" wxDC_GetSizeMM :: Ptr (TDC a) -> IO (Ptr (TWxSize ()))

-- | usage: (@dcGetTextBackground obj@).
dcGetTextBackground :: DC  a ->  IO (Color)
dcGetTextBackground _obj 
  = withRefColour $ \pref -> 
    withObjectRef "dcGetTextBackground" _obj $ \cobj__obj -> 
    wxDC_GetTextBackground cobj__obj   pref
foreign import ccall "wxDC_GetTextBackground" wxDC_GetTextBackground :: Ptr (TDC a) -> Ptr (TColour ()) -> IO ()

-- | usage: (@dcGetTextExtent self string w h descent externalLeading theFont@).
dcGetTextExtent :: DC  a -> String -> Ptr  c -> Ptr  d -> Ptr  e -> Ptr  f -> Font  g ->  IO ()
dcGetTextExtent self string w h descent externalLeading theFont 
  = withObjectRef "dcGetTextExtent" self $ \cobj_self -> 
    withStringPtr string $ \cobj_string -> 
    withObjectPtr theFont $ \cobj_theFont -> 
    wxDC_GetTextExtent cobj_self  cobj_string  w  h  descent  externalLeading  cobj_theFont  
foreign import ccall "wxDC_GetTextExtent" wxDC_GetTextExtent :: Ptr (TDC a) -> Ptr (TWxString b) -> Ptr  c -> Ptr  d -> Ptr  e -> Ptr  f -> Ptr (TFont g) -> IO ()

-- | usage: (@dcGetTextForeground obj@).
dcGetTextForeground :: DC  a ->  IO (Color)
dcGetTextForeground _obj 
  = withRefColour $ \pref -> 
    withObjectRef "dcGetTextForeground" _obj $ \cobj__obj -> 
    wxDC_GetTextForeground cobj__obj   pref
foreign import ccall "wxDC_GetTextForeground" wxDC_GetTextForeground :: Ptr (TDC a) -> Ptr (TColour ()) -> IO ()

-- | usage: (@dcGetUserScale obj@).
dcGetUserScale :: DC  a ->  IO (Size2D Double)
dcGetUserScale _obj 
  = withSizeDoubleResult $ \pw ph -> 
    withObjectRef "dcGetUserScale" _obj $ \cobj__obj -> 
    wxDC_GetUserScale cobj__obj   pw ph
foreign import ccall "wxDC_GetUserScale" wxDC_GetUserScale :: Ptr (TDC a) -> Ptr CDouble -> Ptr CDouble -> IO ()

-- | usage: (@dcGetUserScaleX dc@).
dcGetUserScaleX :: DC  a ->  IO Double
dcGetUserScaleX dc 
  = withObjectRef "dcGetUserScaleX" dc $ \cobj_dc -> 
    wxDC_GetUserScaleX cobj_dc  
foreign import ccall "wxDC_GetUserScaleX" wxDC_GetUserScaleX :: Ptr (TDC a) -> IO Double

-- | usage: (@dcGetUserScaleY dc@).
dcGetUserScaleY :: DC  a ->  IO Double
dcGetUserScaleY dc 
  = withObjectRef "dcGetUserScaleY" dc $ \cobj_dc -> 
    wxDC_GetUserScaleY cobj_dc  
foreign import ccall "wxDC_GetUserScaleY" wxDC_GetUserScaleY :: Ptr (TDC a) -> IO Double

-- | usage: (@dcIsOk obj@).
dcIsOk :: DC  a ->  IO Bool
dcIsOk _obj 
  = withBoolResult $
    withObjectRef "dcIsOk" _obj $ \cobj__obj -> 
    wxDC_IsOk cobj__obj  
foreign import ccall "wxDC_IsOk" wxDC_IsOk :: Ptr (TDC a) -> IO CBool

-- | usage: (@dcLogicalToDeviceX obj x@).
dcLogicalToDeviceX :: DC  a -> Int ->  IO Int
dcLogicalToDeviceX _obj x 
  = withIntResult $
    withObjectRef "dcLogicalToDeviceX" _obj $ \cobj__obj -> 
    wxDC_LogicalToDeviceX cobj__obj  (toCInt x)  
foreign import ccall "wxDC_LogicalToDeviceX" wxDC_LogicalToDeviceX :: Ptr (TDC a) -> CInt -> IO CInt

-- | usage: (@dcLogicalToDeviceXRel obj x@).
dcLogicalToDeviceXRel :: DC  a -> Int ->  IO Int
dcLogicalToDeviceXRel _obj x 
  = withIntResult $
    withObjectRef "dcLogicalToDeviceXRel" _obj $ \cobj__obj -> 
    wxDC_LogicalToDeviceXRel cobj__obj  (toCInt x)  
foreign import ccall "wxDC_LogicalToDeviceXRel" wxDC_LogicalToDeviceXRel :: Ptr (TDC a) -> CInt -> IO CInt

-- | usage: (@dcLogicalToDeviceY obj y@).
dcLogicalToDeviceY :: DC  a -> Int ->  IO Int
dcLogicalToDeviceY _obj y 
  = withIntResult $
    withObjectRef "dcLogicalToDeviceY" _obj $ \cobj__obj -> 
    wxDC_LogicalToDeviceY cobj__obj  (toCInt y)  
foreign import ccall "wxDC_LogicalToDeviceY" wxDC_LogicalToDeviceY :: Ptr (TDC a) -> CInt -> IO CInt

-- | usage: (@dcLogicalToDeviceYRel obj y@).
dcLogicalToDeviceYRel :: DC  a -> Int ->  IO Int
dcLogicalToDeviceYRel _obj y 
  = withIntResult $
    withObjectRef "dcLogicalToDeviceYRel" _obj $ \cobj__obj -> 
    wxDC_LogicalToDeviceYRel cobj__obj  (toCInt y)  
foreign import ccall "wxDC_LogicalToDeviceYRel" wxDC_LogicalToDeviceYRel :: Ptr (TDC a) -> CInt -> IO CInt

-- | usage: (@dcMaxX obj@).
dcMaxX :: DC  a ->  IO Int
dcMaxX _obj 
  = withIntResult $
    withObjectRef "dcMaxX" _obj $ \cobj__obj -> 
    wxDC_MaxX cobj__obj  
foreign import ccall "wxDC_MaxX" wxDC_MaxX :: Ptr (TDC a) -> IO CInt

-- | usage: (@dcMaxY obj@).
dcMaxY :: DC  a ->  IO Int
dcMaxY _obj 
  = withIntResult $
    withObjectRef "dcMaxY" _obj $ \cobj__obj -> 
    wxDC_MaxY cobj__obj  
foreign import ccall "wxDC_MaxY" wxDC_MaxY :: Ptr (TDC a) -> IO CInt

-- | usage: (@dcMinX obj@).
dcMinX :: DC  a ->  IO Int
dcMinX _obj 
  = withIntResult $
    withObjectRef "dcMinX" _obj $ \cobj__obj -> 
    wxDC_MinX cobj__obj  
foreign import ccall "wxDC_MinX" wxDC_MinX :: Ptr (TDC a) -> IO CInt

-- | usage: (@dcMinY obj@).
dcMinY :: DC  a ->  IO Int
dcMinY _obj 
  = withIntResult $
    withObjectRef "dcMinY" _obj $ \cobj__obj -> 
    wxDC_MinY cobj__obj  
foreign import ccall "wxDC_MinY" wxDC_MinY :: Ptr (TDC a) -> IO CInt

-- | usage: (@dcResetBoundingBox obj@).
dcResetBoundingBox :: DC  a ->  IO ()
dcResetBoundingBox _obj 
  = withObjectRef "dcResetBoundingBox" _obj $ \cobj__obj -> 
    wxDC_ResetBoundingBox cobj__obj  
foreign import ccall "wxDC_ResetBoundingBox" wxDC_ResetBoundingBox :: Ptr (TDC a) -> IO ()

-- | usage: (@dcSetAxisOrientation obj xLeftRight yBottomUp@).
dcSetAxisOrientation :: DC  a -> Bool -> Bool ->  IO ()
dcSetAxisOrientation _obj xLeftRight yBottomUp 
  = withObjectRef "dcSetAxisOrientation" _obj $ \cobj__obj -> 
    wxDC_SetAxisOrientation cobj__obj  (toCBool xLeftRight)  (toCBool yBottomUp)  
foreign import ccall "wxDC_SetAxisOrientation" wxDC_SetAxisOrientation :: Ptr (TDC a) -> CBool -> CBool -> IO ()

-- | usage: (@dcSetBackground obj brush@).
dcSetBackground :: DC  a -> Brush  b ->  IO ()
dcSetBackground _obj brush 
  = withObjectRef "dcSetBackground" _obj $ \cobj__obj -> 
    withObjectPtr brush $ \cobj_brush -> 
    wxDC_SetBackground cobj__obj  cobj_brush  
foreign import ccall "wxDC_SetBackground" wxDC_SetBackground :: Ptr (TDC a) -> Ptr (TBrush b) -> IO ()

-- | usage: (@dcSetBackgroundMode obj mode@).
dcSetBackgroundMode :: DC  a -> Int ->  IO ()
dcSetBackgroundMode _obj mode 
  = withObjectRef "dcSetBackgroundMode" _obj $ \cobj__obj -> 
    wxDC_SetBackgroundMode cobj__obj  (toCInt mode)  
foreign import ccall "wxDC_SetBackgroundMode" wxDC_SetBackgroundMode :: Ptr (TDC a) -> CInt -> IO ()

-- | usage: (@dcSetBrush obj brush@).
dcSetBrush :: DC  a -> Brush  b ->  IO ()
dcSetBrush _obj brush 
  = withObjectRef "dcSetBrush" _obj $ \cobj__obj -> 
    withObjectPtr brush $ \cobj_brush -> 
    wxDC_SetBrush cobj__obj  cobj_brush  
foreign import ccall "wxDC_SetBrush" wxDC_SetBrush :: Ptr (TDC a) -> Ptr (TBrush b) -> IO ()

-- | usage: (@dcSetClippingRegion obj xywidthheight@).
dcSetClippingRegion :: DC  a -> Rect ->  IO ()
dcSetClippingRegion _obj xywidthheight 
  = withObjectRef "dcSetClippingRegion" _obj $ \cobj__obj -> 
    wxDC_SetClippingRegion cobj__obj  (toCIntRectX xywidthheight) (toCIntRectY xywidthheight)(toCIntRectW xywidthheight) (toCIntRectH xywidthheight)  
foreign import ccall "wxDC_SetClippingRegion" wxDC_SetClippingRegion :: Ptr (TDC a) -> CInt -> CInt -> CInt -> CInt -> IO ()

-- | usage: (@dcSetClippingRegionFromRegion obj region@).
dcSetClippingRegionFromRegion :: DC  a -> Region  b ->  IO ()
dcSetClippingRegionFromRegion _obj region 
  = withObjectRef "dcSetClippingRegionFromRegion" _obj $ \cobj__obj -> 
    withObjectPtr region $ \cobj_region -> 
    wxDC_SetClippingRegionFromRegion cobj__obj  cobj_region  
foreign import ccall "wxDC_SetClippingRegionFromRegion" wxDC_SetClippingRegionFromRegion :: Ptr (TDC a) -> Ptr (TRegion b) -> IO ()

-- | usage: (@dcSetDeviceOrigin obj xy@).
dcSetDeviceOrigin :: DC  a -> Point ->  IO ()
dcSetDeviceOrigin _obj xy 
  = withObjectRef "dcSetDeviceOrigin" _obj $ \cobj__obj -> 
    wxDC_SetDeviceOrigin cobj__obj  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxDC_SetDeviceOrigin" wxDC_SetDeviceOrigin :: Ptr (TDC a) -> CInt -> CInt -> IO ()

-- | usage: (@dcSetFont obj font@).
dcSetFont :: DC  a -> Font  b ->  IO ()
dcSetFont _obj font 
  = withObjectRef "dcSetFont" _obj $ \cobj__obj -> 
    withObjectPtr font $ \cobj_font -> 
    wxDC_SetFont cobj__obj  cobj_font  
foreign import ccall "wxDC_SetFont" wxDC_SetFont :: Ptr (TDC a) -> Ptr (TFont b) -> IO ()

-- | usage: (@dcSetLogicalFunction obj function@).
dcSetLogicalFunction :: DC  a -> Int ->  IO ()
dcSetLogicalFunction _obj function 
  = withObjectRef "dcSetLogicalFunction" _obj $ \cobj__obj -> 
    wxDC_SetLogicalFunction cobj__obj  (toCInt function)  
foreign import ccall "wxDC_SetLogicalFunction" wxDC_SetLogicalFunction :: Ptr (TDC a) -> CInt -> IO ()

-- | usage: (@dcSetLogicalOrigin obj xy@).
dcSetLogicalOrigin :: DC  a -> Point ->  IO ()
dcSetLogicalOrigin _obj xy 
  = withObjectRef "dcSetLogicalOrigin" _obj $ \cobj__obj -> 
    wxDC_SetLogicalOrigin cobj__obj  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxDC_SetLogicalOrigin" wxDC_SetLogicalOrigin :: Ptr (TDC a) -> CInt -> CInt -> IO ()

-- | usage: (@dcSetLogicalScale obj x y@).
dcSetLogicalScale :: DC  a -> Double -> Double ->  IO ()
dcSetLogicalScale _obj x y 
  = withObjectRef "dcSetLogicalScale" _obj $ \cobj__obj -> 
    wxDC_SetLogicalScale cobj__obj  x  y  
foreign import ccall "wxDC_SetLogicalScale" wxDC_SetLogicalScale :: Ptr (TDC a) -> Double -> Double -> IO ()

-- | usage: (@dcSetMapMode obj mode@).
dcSetMapMode :: DC  a -> Int ->  IO ()
dcSetMapMode _obj mode 
  = withObjectRef "dcSetMapMode" _obj $ \cobj__obj -> 
    wxDC_SetMapMode cobj__obj  (toCInt mode)  
foreign import ccall "wxDC_SetMapMode" wxDC_SetMapMode :: Ptr (TDC a) -> CInt -> IO ()

-- | usage: (@dcSetPalette obj palette@).
dcSetPalette :: DC  a -> Palette  b ->  IO ()
dcSetPalette _obj palette 
  = withObjectRef "dcSetPalette" _obj $ \cobj__obj -> 
    withObjectPtr palette $ \cobj_palette -> 
    wxDC_SetPalette cobj__obj  cobj_palette  
foreign import ccall "wxDC_SetPalette" wxDC_SetPalette :: Ptr (TDC a) -> Ptr (TPalette b) -> IO ()

-- | usage: (@dcSetPen obj pen@).
dcSetPen :: DC  a -> Pen  b ->  IO ()
dcSetPen _obj pen 
  = withObjectRef "dcSetPen" _obj $ \cobj__obj -> 
    withObjectPtr pen $ \cobj_pen -> 
    wxDC_SetPen cobj__obj  cobj_pen  
foreign import ccall "wxDC_SetPen" wxDC_SetPen :: Ptr (TDC a) -> Ptr (TPen b) -> IO ()

-- | usage: (@dcSetTextBackground obj colour@).
dcSetTextBackground :: DC  a -> Color ->  IO ()
dcSetTextBackground _obj colour 
  = withObjectRef "dcSetTextBackground" _obj $ \cobj__obj -> 
    withColourPtr colour $ \cobj_colour -> 
    wxDC_SetTextBackground cobj__obj  cobj_colour  
foreign import ccall "wxDC_SetTextBackground" wxDC_SetTextBackground :: Ptr (TDC a) -> Ptr (TColour b) -> IO ()

-- | usage: (@dcSetTextForeground obj colour@).
dcSetTextForeground :: DC  a -> Color ->  IO ()
dcSetTextForeground _obj colour 
  = withObjectRef "dcSetTextForeground" _obj $ \cobj__obj -> 
    withColourPtr colour $ \cobj_colour -> 
    wxDC_SetTextForeground cobj__obj  cobj_colour  
foreign import ccall "wxDC_SetTextForeground" wxDC_SetTextForeground :: Ptr (TDC a) -> Ptr (TColour b) -> IO ()

-- | usage: (@dcSetUserScale obj x y@).
dcSetUserScale :: DC  a -> Double -> Double ->  IO ()
dcSetUserScale _obj x y 
  = withObjectRef "dcSetUserScale" _obj $ \cobj__obj -> 
    wxDC_SetUserScale cobj__obj  x  y  
foreign import ccall "wxDC_SetUserScale" wxDC_SetUserScale :: Ptr (TDC a) -> Double -> Double -> IO ()

-- | usage: (@dcStartDoc obj msg@).
dcStartDoc :: DC  a -> String ->  IO Bool
dcStartDoc _obj msg 
  = withBoolResult $
    withObjectRef "dcStartDoc" _obj $ \cobj__obj -> 
    withStringPtr msg $ \cobj_msg -> 
    wxDC_StartDoc cobj__obj  cobj_msg  
foreign import ccall "wxDC_StartDoc" wxDC_StartDoc :: Ptr (TDC a) -> Ptr (TWxString b) -> IO CBool

-- | usage: (@dcStartPage obj@).
dcStartPage :: DC  a ->  IO ()
dcStartPage _obj 
  = withObjectRef "dcStartPage" _obj $ \cobj__obj -> 
    wxDC_StartPage cobj__obj  
foreign import ccall "wxDC_StartPage" wxDC_StartPage :: Ptr (TDC a) -> IO ()

-- | usage: (@dialogCreate prt id txt lfttopwdthgt stl@).
dialogCreate :: Window  a -> Id -> String -> Rect -> Style ->  IO (Dialog  ())
dialogCreate _prt _id _txt _lfttopwdthgt _stl 
  = withObjectResult $
    withObjectPtr _prt $ \cobj__prt -> 
    withStringPtr _txt $ \cobj__txt -> 
    wxDialog_Create cobj__prt  (toCInt _id)  cobj__txt  (toCIntRectX _lfttopwdthgt) (toCIntRectY _lfttopwdthgt)(toCIntRectW _lfttopwdthgt) (toCIntRectH _lfttopwdthgt)  (toCInt _stl)  
foreign import ccall "wxDialog_Create" wxDialog_Create :: Ptr (TWindow a) -> CInt -> Ptr (TWxString c) -> CInt -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (TDialog ()))

-- | usage: (@dialogEndModal obj retCode@).
dialogEndModal :: Dialog  a -> Int ->  IO ()
dialogEndModal _obj retCode 
  = withObjectRef "dialogEndModal" _obj $ \cobj__obj -> 
    wxDialog_EndModal cobj__obj  (toCInt retCode)  
foreign import ccall "wxDialog_EndModal" wxDialog_EndModal :: Ptr (TDialog a) -> CInt -> IO ()

-- | usage: (@dialogGetReturnCode obj@).
dialogGetReturnCode :: Dialog  a ->  IO Int
dialogGetReturnCode _obj 
  = withIntResult $
    withObjectRef "dialogGetReturnCode" _obj $ \cobj__obj -> 
    wxDialog_GetReturnCode cobj__obj  
foreign import ccall "wxDialog_GetReturnCode" wxDialog_GetReturnCode :: Ptr (TDialog a) -> IO CInt

-- | usage: (@dialogIsModal obj@).
dialogIsModal :: Dialog  a ->  IO Bool
dialogIsModal _obj 
  = withBoolResult $
    withObjectRef "dialogIsModal" _obj $ \cobj__obj -> 
    wxDialog_IsModal cobj__obj  
foreign import ccall "wxDialog_IsModal" wxDialog_IsModal :: Ptr (TDialog a) -> IO CBool

-- | usage: (@dialogSetReturnCode obj returnCode@).
dialogSetReturnCode :: Dialog  a -> Int ->  IO ()
dialogSetReturnCode _obj returnCode 
  = withObjectRef "dialogSetReturnCode" _obj $ \cobj__obj -> 
    wxDialog_SetReturnCode cobj__obj  (toCInt returnCode)  
foreign import ccall "wxDialog_SetReturnCode" wxDialog_SetReturnCode :: Ptr (TDialog a) -> CInt -> IO ()

-- | usage: (@dialogShowModal obj@).
dialogShowModal :: Dialog  a ->  IO Int
dialogShowModal _obj 
  = withIntResult $
    withObjectRef "dialogShowModal" _obj $ \cobj__obj -> 
    wxDialog_ShowModal cobj__obj  
foreign import ccall "wxDialog_ShowModal" wxDialog_ShowModal :: Ptr (TDialog a) -> IO CInt

-- | usage: (@dirDialogCreate prt msg dir lfttop stl@).
dirDialogCreate :: Window  a -> String -> String -> Point -> Style ->  IO (DirDialog  ())
dirDialogCreate _prt _msg _dir _lfttop _stl 
  = withObjectResult $
    withObjectPtr _prt $ \cobj__prt -> 
    withStringPtr _msg $ \cobj__msg -> 
    withStringPtr _dir $ \cobj__dir -> 
    wxDirDialog_Create cobj__prt  cobj__msg  cobj__dir  (toCIntPointX _lfttop) (toCIntPointY _lfttop)  (toCInt _stl)  
foreign import ccall "wxDirDialog_Create" wxDirDialog_Create :: Ptr (TWindow a) -> Ptr (TWxString b) -> Ptr (TWxString c) -> CInt -> CInt -> CInt -> IO (Ptr (TDirDialog ()))

-- | usage: (@dirDialogGetMessage obj@).
dirDialogGetMessage :: DirDialog  a ->  IO (String)
dirDialogGetMessage _obj 
  = withManagedStringResult $
    withObjectRef "dirDialogGetMessage" _obj $ \cobj__obj -> 
    wxDirDialog_GetMessage cobj__obj  
foreign import ccall "wxDirDialog_GetMessage" wxDirDialog_GetMessage :: Ptr (TDirDialog a) -> IO (Ptr (TWxString ()))

-- | usage: (@dirDialogGetPath obj@).
dirDialogGetPath :: DirDialog  a ->  IO (String)
dirDialogGetPath _obj 
  = withManagedStringResult $
    withObjectRef "dirDialogGetPath" _obj $ \cobj__obj -> 
    wxDirDialog_GetPath cobj__obj  
foreign import ccall "wxDirDialog_GetPath" wxDirDialog_GetPath :: Ptr (TDirDialog a) -> IO (Ptr (TWxString ()))

-- | usage: (@dirDialogGetStyle obj@).
dirDialogGetStyle :: DirDialog  a ->  IO Int
dirDialogGetStyle _obj 
  = withIntResult $
    withObjectRef "dirDialogGetStyle" _obj $ \cobj__obj -> 
    wxDirDialog_GetStyle cobj__obj  
foreign import ccall "wxDirDialog_GetStyle" wxDirDialog_GetStyle :: Ptr (TDirDialog a) -> IO CInt

-- | usage: (@dirDialogSetMessage obj msg@).
dirDialogSetMessage :: DirDialog  a -> String ->  IO ()
dirDialogSetMessage _obj msg 
  = withObjectRef "dirDialogSetMessage" _obj $ \cobj__obj -> 
    withStringPtr msg $ \cobj_msg -> 
    wxDirDialog_SetMessage cobj__obj  cobj_msg  
foreign import ccall "wxDirDialog_SetMessage" wxDirDialog_SetMessage :: Ptr (TDirDialog a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@dirDialogSetPath obj pth@).
dirDialogSetPath :: DirDialog  a -> String ->  IO ()
dirDialogSetPath _obj pth 
  = withObjectRef "dirDialogSetPath" _obj $ \cobj__obj -> 
    withStringPtr pth $ \cobj_pth -> 
    wxDirDialog_SetPath cobj__obj  cobj_pth  
foreign import ccall "wxDirDialog_SetPath" wxDirDialog_SetPath :: Ptr (TDirDialog a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@dirDialogSetStyle obj style@).
dirDialogSetStyle :: DirDialog  a -> Int ->  IO ()
dirDialogSetStyle _obj style 
  = withObjectRef "dirDialogSetStyle" _obj $ \cobj__obj -> 
    wxDirDialog_SetStyle cobj__obj  (toCInt style)  
foreign import ccall "wxDirDialog_SetStyle" wxDirDialog_SetStyle :: Ptr (TDirDialog a) -> CInt -> IO ()

-- | usage: (@dragIcon icon xy@).
dragIcon :: Icon  a -> Point ->  IO (DragImage  ())
dragIcon icon xy 
  = withObjectResult $
    withObjectPtr icon $ \cobj_icon -> 
    wx_wxDragIcon cobj_icon  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxDragIcon" wx_wxDragIcon :: Ptr (TIcon a) -> CInt -> CInt -> IO (Ptr (TDragImage ()))

-- | usage: (@dragImageBeginDrag self xy window boundingWindow@).
dragImageBeginDrag :: DragImage  a -> Point -> Window  c -> Window  d ->  IO Bool
dragImageBeginDrag self xy window boundingWindow 
  = withBoolResult $
    withObjectRef "dragImageBeginDrag" self $ \cobj_self -> 
    withObjectPtr window $ \cobj_window -> 
    withObjectPtr boundingWindow $ \cobj_boundingWindow -> 
    wxDragImage_BeginDrag cobj_self  (toCIntPointX xy) (toCIntPointY xy)  cobj_window  cobj_boundingWindow  
foreign import ccall "wxDragImage_BeginDrag" wxDragImage_BeginDrag :: Ptr (TDragImage a) -> CInt -> CInt -> Ptr (TWindow c) -> Ptr (TWindow d) -> IO CBool

-- | usage: (@dragImageBeginDragFullScreen self xposypos window fullScreen rect@).
dragImageBeginDragFullScreen :: DragImage  a -> Point -> Window  c -> Bool -> Rect ->  IO Bool
dragImageBeginDragFullScreen self xposypos window fullScreen rect 
  = withBoolResult $
    withObjectRef "dragImageBeginDragFullScreen" self $ \cobj_self -> 
    withObjectPtr window $ \cobj_window -> 
    withWxRectPtr rect $ \cobj_rect -> 
    wxDragImage_BeginDragFullScreen cobj_self  (toCIntPointX xposypos) (toCIntPointY xposypos)  cobj_window  (toCBool fullScreen)  cobj_rect  
foreign import ccall "wxDragImage_BeginDragFullScreen" wxDragImage_BeginDragFullScreen :: Ptr (TDragImage a) -> CInt -> CInt -> Ptr (TWindow c) -> CBool -> Ptr (TWxRect e) -> IO CBool

-- | usage: (@dragImageCreate image xy@).
dragImageCreate :: Bitmap  a -> Point ->  IO (DragImage  ())
dragImageCreate image xy 
  = withObjectResult $
    withObjectPtr image $ \cobj_image -> 
    wxDragImage_Create cobj_image  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxDragImage_Create" wxDragImage_Create :: Ptr (TBitmap a) -> CInt -> CInt -> IO (Ptr (TDragImage ()))

-- | usage: (@dragImageDelete self@).
dragImageDelete :: DragImage  a ->  IO ()
dragImageDelete
  = objectDelete


-- | usage: (@dragImageEndDrag self@).
dragImageEndDrag :: DragImage  a ->  IO ()
dragImageEndDrag self 
  = withObjectRef "dragImageEndDrag" self $ \cobj_self -> 
    wxDragImage_EndDrag cobj_self  
foreign import ccall "wxDragImage_EndDrag" wxDragImage_EndDrag :: Ptr (TDragImage a) -> IO ()

-- | usage: (@dragImageHide self@).
dragImageHide :: DragImage  a ->  IO Bool
dragImageHide self 
  = withBoolResult $
    withObjectRef "dragImageHide" self $ \cobj_self -> 
    wxDragImage_Hide cobj_self  
foreign import ccall "wxDragImage_Hide" wxDragImage_Hide :: Ptr (TDragImage a) -> IO CBool

-- | usage: (@dragImageMove self xy@).
dragImageMove :: DragImage  a -> Point ->  IO Bool
dragImageMove self xy 
  = withBoolResult $
    withObjectRef "dragImageMove" self $ \cobj_self -> 
    wxDragImage_Move cobj_self  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxDragImage_Move" wxDragImage_Move :: Ptr (TDragImage a) -> CInt -> CInt -> IO CBool

-- | usage: (@dragImageShow self@).
dragImageShow :: DragImage  a ->  IO Bool
dragImageShow self 
  = withBoolResult $
    withObjectRef "dragImageShow" self $ \cobj_self -> 
    wxDragImage_Show cobj_self  
foreign import ccall "wxDragImage_Show" wxDragImage_Show :: Ptr (TDragImage a) -> IO CBool

-- | usage: (@dragListItem treeCtrl id@).
dragListItem :: ListCtrl  a -> Id ->  IO (DragImage  ())
dragListItem treeCtrl id 
  = withObjectResult $
    withObjectPtr treeCtrl $ \cobj_treeCtrl -> 
    wx_wxDragListItem cobj_treeCtrl  (toCInt id)  
foreign import ccall "wxDragListItem" wx_wxDragListItem :: Ptr (TListCtrl a) -> CInt -> IO (Ptr (TDragImage ()))

-- | usage: (@dragString test xy@).
dragString :: String -> Point ->  IO (DragImage  ())
dragString test xy 
  = withObjectResult $
    withStringPtr test $ \cobj_test -> 
    wx_wxDragString cobj_test  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxDragString" wx_wxDragString :: Ptr (TWxString a) -> CInt -> CInt -> IO (Ptr (TDragImage ()))

-- | usage: (@dragTreeItem treeCtrl id@).
dragTreeItem :: TreeCtrl  a -> TreeItem ->  IO (DragImage  ())
dragTreeItem treeCtrl id 
  = withObjectResult $
    withObjectPtr treeCtrl $ \cobj_treeCtrl -> 
    withTreeItemIdPtr id $ \cobj_id -> 
    wx_wxDragTreeItem cobj_treeCtrl  cobj_id  
foreign import ccall "wxDragTreeItem" wx_wxDragTreeItem :: Ptr (TTreeCtrl a) -> Ptr (TTreeItemId b) -> IO (Ptr (TDragImage ()))

-- | usage: (@drawControlCreate prt id lfttopwdthgt stl@).
drawControlCreate :: Window  a -> Id -> Rect -> Style ->  IO (DrawControl  ())
drawControlCreate _prt _id _lfttopwdthgt _stl 
  = withObjectResult $
    withObjectPtr _prt $ \cobj__prt -> 
    wxDrawControl_Create cobj__prt  (toCInt _id)  (toCIntRectX _lfttopwdthgt) (toCIntRectY _lfttopwdthgt)(toCIntRectW _lfttopwdthgt) (toCIntRectH _lfttopwdthgt)  (toCInt _stl)  
foreign import ccall "wxDrawControl_Create" wxDrawControl_Create :: Ptr (TWindow a) -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (TDrawControl ()))

-- | usage: (@drawWindowCreate prt id lfttopwdthgt stl@).
drawWindowCreate :: Window  a -> Id -> Rect -> Style ->  IO (DrawWindow  ())
drawWindowCreate _prt _id _lfttopwdthgt _stl 
  = withObjectResult $
    withObjectPtr _prt $ \cobj__prt -> 
    wxDrawWindow_Create cobj__prt  (toCInt _id)  (toCIntRectX _lfttopwdthgt) (toCIntRectY _lfttopwdthgt)(toCIntRectW _lfttopwdthgt) (toCIntRectH _lfttopwdthgt)  (toCInt _stl)  
foreign import ccall "wxDrawWindow_Create" wxDrawWindow_Create :: Ptr (TWindow a) -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (TDrawWindow ()))

-- | usage: (@dropSourceCreate wxdata win copy move none@).
dropSourceCreate :: DataObject  a -> Window  b -> Ptr  c -> Ptr  d -> Ptr  e ->  IO (DropSource  ())
dropSourceCreate wxdata win copy move none 
  = withObjectResult $
    withObjectPtr wxdata $ \cobj_wxdata -> 
    withObjectPtr win $ \cobj_win -> 
    wx_DropSource_Create cobj_wxdata  cobj_win  copy  move  none  
foreign import ccall "DropSource_Create" wx_DropSource_Create :: Ptr (TDataObject a) -> Ptr (TWindow b) -> Ptr  c -> Ptr  d -> Ptr  e -> IO (Ptr (TDropSource ()))

-- | usage: (@dropSourceDelete obj@).
dropSourceDelete :: DropSource  a ->  IO ()
dropSourceDelete _obj 
  = withObjectPtr _obj $ \cobj__obj -> 
    wx_DropSource_Delete cobj__obj  
foreign import ccall "DropSource_Delete" wx_DropSource_Delete :: Ptr (TDropSource a) -> IO ()

-- | usage: (@dropSourceDoDragDrop obj move@).
dropSourceDoDragDrop :: DropSource  a -> Int ->  IO Int
dropSourceDoDragDrop _obj _move 
  = withIntResult $
    withObjectPtr _obj $ \cobj__obj -> 
    wx_DropSource_DoDragDrop cobj__obj  (toCInt _move)  
foreign import ccall "DropSource_DoDragDrop" wx_DropSource_DoDragDrop :: Ptr (TDropSource a) -> CInt -> IO CInt

-- | usage: (@dropTargetGetData obj@).
dropTargetGetData :: DropTarget  a ->  IO ()
dropTargetGetData _obj 
  = withObjectRef "dropTargetGetData" _obj $ \cobj__obj -> 
    wxDropTarget_GetData cobj__obj  
foreign import ccall "wxDropTarget_GetData" wxDropTarget_GetData :: Ptr (TDropTarget a) -> IO ()

-- | usage: (@dropTargetSetDataObject obj dat@).
dropTargetSetDataObject :: DropTarget  a -> DataObject  b ->  IO ()
dropTargetSetDataObject _obj _dat 
  = withObjectRef "dropTargetSetDataObject" _obj $ \cobj__obj -> 
    withObjectPtr _dat $ \cobj__dat -> 
    wxDropTarget_SetDataObject cobj__obj  cobj__dat  
foreign import ccall "wxDropTarget_SetDataObject" wxDropTarget_SetDataObject :: Ptr (TDropTarget a) -> Ptr (TDataObject b) -> IO ()

-- | usage: (@encodingConverterConvert obj input output@).
encodingConverterConvert :: EncodingConverter  a -> Ptr  b -> Ptr  c ->  IO ()
encodingConverterConvert _obj input output 
  = withObjectRef "encodingConverterConvert" _obj $ \cobj__obj -> 
    wxEncodingConverter_Convert cobj__obj  input  output  
foreign import ccall "wxEncodingConverter_Convert" wxEncodingConverter_Convert :: Ptr (TEncodingConverter a) -> Ptr  b -> Ptr  c -> IO ()

-- | usage: (@encodingConverterCreate@).
encodingConverterCreate ::  IO (EncodingConverter  ())
encodingConverterCreate 
  = withObjectResult $
    wxEncodingConverter_Create 
foreign import ccall "wxEncodingConverter_Create" wxEncodingConverter_Create :: IO (Ptr (TEncodingConverter ()))

-- | usage: (@encodingConverterDelete obj@).
encodingConverterDelete :: EncodingConverter  a ->  IO ()
encodingConverterDelete
  = objectDelete


-- | usage: (@encodingConverterGetAllEquivalents obj enc lst@).
encodingConverterGetAllEquivalents :: EncodingConverter  a -> Int -> List  c ->  IO Int
encodingConverterGetAllEquivalents _obj enc _lst 
  = withIntResult $
    withObjectRef "encodingConverterGetAllEquivalents" _obj $ \cobj__obj -> 
    withObjectPtr _lst $ \cobj__lst -> 
    wxEncodingConverter_GetAllEquivalents cobj__obj  (toCInt enc)  cobj__lst  
foreign import ccall "wxEncodingConverter_GetAllEquivalents" wxEncodingConverter_GetAllEquivalents :: Ptr (TEncodingConverter a) -> CInt -> Ptr (TList c) -> IO CInt

-- | usage: (@encodingConverterGetPlatformEquivalents obj enc platform lst@).
encodingConverterGetPlatformEquivalents :: EncodingConverter  a -> Int -> Int -> List  d ->  IO Int
encodingConverterGetPlatformEquivalents _obj enc platform _lst 
  = withIntResult $
    withObjectRef "encodingConverterGetPlatformEquivalents" _obj $ \cobj__obj -> 
    withObjectPtr _lst $ \cobj__lst -> 
    wxEncodingConverter_GetPlatformEquivalents cobj__obj  (toCInt enc)  (toCInt platform)  cobj__lst  
foreign import ccall "wxEncodingConverter_GetPlatformEquivalents" wxEncodingConverter_GetPlatformEquivalents :: Ptr (TEncodingConverter a) -> CInt -> CInt -> Ptr (TList d) -> IO CInt

-- | usage: (@encodingConverterInit obj inputenc outputenc method@).
encodingConverterInit :: EncodingConverter  a -> Int -> Int -> Int ->  IO Int
encodingConverterInit _obj inputenc outputenc method 
  = withIntResult $
    withObjectRef "encodingConverterInit" _obj $ \cobj__obj -> 
    wxEncodingConverter_Init cobj__obj  (toCInt inputenc)  (toCInt outputenc)  (toCInt method)  
foreign import ccall "wxEncodingConverter_Init" wxEncodingConverter_Init :: Ptr (TEncodingConverter a) -> CInt -> CInt -> CInt -> IO CInt

-- | usage: (@eraseEventCopyObject obj obj@).
eraseEventCopyObject :: EraseEvent  a -> Ptr  b ->  IO ()
eraseEventCopyObject _obj obj 
  = withObjectRef "eraseEventCopyObject" _obj $ \cobj__obj -> 
    wxEraseEvent_CopyObject cobj__obj  obj  
foreign import ccall "wxEraseEvent_CopyObject" wxEraseEvent_CopyObject :: Ptr (TEraseEvent a) -> Ptr  b -> IO ()

-- | usage: (@eraseEventGetDC obj@).
eraseEventGetDC :: EraseEvent  a ->  IO (DC  ())
eraseEventGetDC _obj 
  = withObjectResult $
    withObjectRef "eraseEventGetDC" _obj $ \cobj__obj -> 
    wxEraseEvent_GetDC cobj__obj  
foreign import ccall "wxEraseEvent_GetDC" wxEraseEvent_GetDC :: Ptr (TEraseEvent a) -> IO (Ptr (TDC ()))

-- | usage: (@eventCopyObject obj objectdest@).
eventCopyObject :: Event  a -> Ptr  b ->  IO ()
eventCopyObject _obj objectdest 
  = withObjectRef "eventCopyObject" _obj $ \cobj__obj -> 
    wxEvent_CopyObject cobj__obj  objectdest  
foreign import ccall "wxEvent_CopyObject" wxEvent_CopyObject :: Ptr (TEvent a) -> Ptr  b -> IO ()

-- | usage: (@eventGetEventObject obj@).
eventGetEventObject :: Event  a ->  IO (WxObject  ())
eventGetEventObject _obj 
  = withObjectResult $
    withObjectRef "eventGetEventObject" _obj $ \cobj__obj -> 
    wxEvent_GetEventObject cobj__obj  
foreign import ccall "wxEvent_GetEventObject" wxEvent_GetEventObject :: Ptr (TEvent a) -> IO (Ptr (TWxObject ()))

-- | usage: (@eventGetEventType obj@).
eventGetEventType :: Event  a ->  IO Int
eventGetEventType _obj 
  = withIntResult $
    withObjectRef "eventGetEventType" _obj $ \cobj__obj -> 
    wxEvent_GetEventType cobj__obj  
foreign import ccall "wxEvent_GetEventType" wxEvent_GetEventType :: Ptr (TEvent a) -> IO CInt

-- | usage: (@eventGetId obj@).
eventGetId :: Event  a ->  IO Int
eventGetId _obj 
  = withIntResult $
    withObjectRef "eventGetId" _obj $ \cobj__obj -> 
    wxEvent_GetId cobj__obj  
foreign import ccall "wxEvent_GetId" wxEvent_GetId :: Ptr (TEvent a) -> IO CInt

-- | usage: (@eventGetSkipped obj@).
eventGetSkipped :: Event  a ->  IO Bool
eventGetSkipped _obj 
  = withBoolResult $
    withObjectRef "eventGetSkipped" _obj $ \cobj__obj -> 
    wxEvent_GetSkipped cobj__obj  
foreign import ccall "wxEvent_GetSkipped" wxEvent_GetSkipped :: Ptr (TEvent a) -> IO CBool

-- | usage: (@eventGetTimestamp obj@).
eventGetTimestamp :: Event  a ->  IO Int
eventGetTimestamp _obj 
  = withIntResult $
    withObjectRef "eventGetTimestamp" _obj $ \cobj__obj -> 
    wxEvent_GetTimestamp cobj__obj  
foreign import ccall "wxEvent_GetTimestamp" wxEvent_GetTimestamp :: Ptr (TEvent a) -> IO CInt

-- | usage: (@eventIsCommandEvent obj@).
eventIsCommandEvent :: Event  a ->  IO Bool
eventIsCommandEvent _obj 
  = withBoolResult $
    withObjectRef "eventIsCommandEvent" _obj $ \cobj__obj -> 
    wxEvent_IsCommandEvent cobj__obj  
foreign import ccall "wxEvent_IsCommandEvent" wxEvent_IsCommandEvent :: Ptr (TEvent a) -> IO CBool

-- | usage: (@eventNewEventType@).
eventNewEventType ::  IO Int
eventNewEventType 
  = withIntResult $
    wxEvent_NewEventType 
foreign import ccall "wxEvent_NewEventType" wxEvent_NewEventType :: IO CInt

-- | usage: (@eventSetEventObject obj obj@).
eventSetEventObject :: Event  a -> WxObject  b ->  IO ()
eventSetEventObject _obj obj 
  = withObjectRef "eventSetEventObject" _obj $ \cobj__obj -> 
    withObjectPtr obj $ \cobj_obj -> 
    wxEvent_SetEventObject cobj__obj  cobj_obj  
foreign import ccall "wxEvent_SetEventObject" wxEvent_SetEventObject :: Ptr (TEvent a) -> Ptr (TWxObject b) -> IO ()

-- | usage: (@eventSetEventType obj typ@).
eventSetEventType :: Event  a -> Int ->  IO ()
eventSetEventType _obj typ 
  = withObjectRef "eventSetEventType" _obj $ \cobj__obj -> 
    wxEvent_SetEventType cobj__obj  (toCInt typ)  
foreign import ccall "wxEvent_SetEventType" wxEvent_SetEventType :: Ptr (TEvent a) -> CInt -> IO ()

-- | usage: (@eventSetId obj id@).
eventSetId :: Event  a -> Int ->  IO ()
eventSetId _obj id 
  = withObjectRef "eventSetId" _obj $ \cobj__obj -> 
    wxEvent_SetId cobj__obj  (toCInt id)  
foreign import ccall "wxEvent_SetId" wxEvent_SetId :: Ptr (TEvent a) -> CInt -> IO ()

-- | usage: (@eventSetTimestamp obj ts@).
eventSetTimestamp :: Event  a -> Int ->  IO ()
eventSetTimestamp _obj ts 
  = withObjectRef "eventSetTimestamp" _obj $ \cobj__obj -> 
    wxEvent_SetTimestamp cobj__obj  (toCInt ts)  
foreign import ccall "wxEvent_SetTimestamp" wxEvent_SetTimestamp :: Ptr (TEvent a) -> CInt -> IO ()

-- | usage: (@eventSkip obj@).
eventSkip :: Event  a ->  IO ()
eventSkip _obj 
  = withObjectRef "eventSkip" _obj $ \cobj__obj -> 
    wxEvent_Skip cobj__obj  
foreign import ccall "wxEvent_Skip" wxEvent_Skip :: Ptr (TEvent a) -> IO ()

-- | usage: (@evtHandlerAddPendingEvent obj event@).
evtHandlerAddPendingEvent :: EvtHandler  a -> Event  b ->  IO ()
evtHandlerAddPendingEvent _obj event 
  = withObjectRef "evtHandlerAddPendingEvent" _obj $ \cobj__obj -> 
    withObjectPtr event $ \cobj_event -> 
    wxEvtHandler_AddPendingEvent cobj__obj  cobj_event  
foreign import ccall "wxEvtHandler_AddPendingEvent" wxEvtHandler_AddPendingEvent :: Ptr (TEvtHandler a) -> Ptr (TEvent b) -> IO ()

-- | usage: (@evtHandlerConnect obj first last wxtype wxdata@).
evtHandlerConnect :: EvtHandler  a -> Int -> Int -> Int -> Ptr  e ->  IO Int
evtHandlerConnect _obj first last wxtype wxdata 
  = withIntResult $
    withObjectRef "evtHandlerConnect" _obj $ \cobj__obj -> 
    wxEvtHandler_Connect cobj__obj  (toCInt first)  (toCInt last)  (toCInt wxtype)  wxdata  
foreign import ccall "wxEvtHandler_Connect" wxEvtHandler_Connect :: Ptr (TEvtHandler a) -> CInt -> CInt -> CInt -> Ptr  e -> IO CInt

-- | usage: (@evtHandlerCreate@).
evtHandlerCreate ::  IO (EvtHandler  ())
evtHandlerCreate 
  = withObjectResult $
    wxEvtHandler_Create 
foreign import ccall "wxEvtHandler_Create" wxEvtHandler_Create :: IO (Ptr (TEvtHandler ()))

-- | usage: (@evtHandlerDelete obj@).
evtHandlerDelete :: EvtHandler  a ->  IO ()
evtHandlerDelete
  = objectDelete


-- | usage: (@evtHandlerDisconnect obj first last wxtype id@).
evtHandlerDisconnect :: EvtHandler  a -> Int -> Int -> Int -> Id ->  IO Int
evtHandlerDisconnect _obj first last wxtype id 
  = withIntResult $
    withObjectRef "evtHandlerDisconnect" _obj $ \cobj__obj -> 
    wxEvtHandler_Disconnect cobj__obj  (toCInt first)  (toCInt last)  (toCInt wxtype)  (toCInt id)  
foreign import ccall "wxEvtHandler_Disconnect" wxEvtHandler_Disconnect :: Ptr (TEvtHandler a) -> CInt -> CInt -> CInt -> CInt -> IO CInt

{- |  Get the client data in the form of a closure. Use 'closureGetData' to get to the actual data. -}
evtHandlerGetClientClosure :: EvtHandler  a ->  IO (Closure  ())
evtHandlerGetClientClosure _obj 
  = withObjectResult $
    withObjectRef "evtHandlerGetClientClosure" _obj $ \cobj__obj -> 
    wxEvtHandler_GetClientClosure cobj__obj  
foreign import ccall "wxEvtHandler_GetClientClosure" wxEvtHandler_GetClientClosure :: Ptr (TEvtHandler a) -> IO (Ptr (TClosure ()))

-- | usage: (@evtHandlerGetClosure obj id wxtype@).
evtHandlerGetClosure :: EvtHandler  a -> Id -> Int ->  IO (Closure  ())
evtHandlerGetClosure _obj id wxtype 
  = withObjectResult $
    withObjectRef "evtHandlerGetClosure" _obj $ \cobj__obj -> 
    wxEvtHandler_GetClosure cobj__obj  (toCInt id)  (toCInt wxtype)  
foreign import ccall "wxEvtHandler_GetClosure" wxEvtHandler_GetClosure :: Ptr (TEvtHandler a) -> CInt -> CInt -> IO (Ptr (TClosure ()))

-- | usage: (@evtHandlerGetEvtHandlerEnabled obj@).
evtHandlerGetEvtHandlerEnabled :: EvtHandler  a ->  IO Bool
evtHandlerGetEvtHandlerEnabled _obj 
  = withBoolResult $
    withObjectRef "evtHandlerGetEvtHandlerEnabled" _obj $ \cobj__obj -> 
    wxEvtHandler_GetEvtHandlerEnabled cobj__obj  
foreign import ccall "wxEvtHandler_GetEvtHandlerEnabled" wxEvtHandler_GetEvtHandlerEnabled :: Ptr (TEvtHandler a) -> IO CBool

-- | usage: (@evtHandlerGetNextHandler obj@).
evtHandlerGetNextHandler :: EvtHandler  a ->  IO (EvtHandler  ())
evtHandlerGetNextHandler _obj 
  = withObjectResult $
    withObjectRef "evtHandlerGetNextHandler" _obj $ \cobj__obj -> 
    wxEvtHandler_GetNextHandler cobj__obj  
foreign import ccall "wxEvtHandler_GetNextHandler" wxEvtHandler_GetNextHandler :: Ptr (TEvtHandler a) -> IO (Ptr (TEvtHandler ()))

-- | usage: (@evtHandlerGetPreviousHandler obj@).
evtHandlerGetPreviousHandler :: EvtHandler  a ->  IO (EvtHandler  ())
evtHandlerGetPreviousHandler _obj 
  = withObjectResult $
    withObjectRef "evtHandlerGetPreviousHandler" _obj $ \cobj__obj -> 
    wxEvtHandler_GetPreviousHandler cobj__obj  
foreign import ccall "wxEvtHandler_GetPreviousHandler" wxEvtHandler_GetPreviousHandler :: Ptr (TEvtHandler a) -> IO (Ptr (TEvtHandler ()))

-- | usage: (@evtHandlerProcessEvent obj event@).
evtHandlerProcessEvent :: EvtHandler  a -> Event  b ->  IO Bool
evtHandlerProcessEvent _obj event 
  = withBoolResult $
    withObjectRef "evtHandlerProcessEvent" _obj $ \cobj__obj -> 
    withObjectPtr event $ \cobj_event -> 
    wxEvtHandler_ProcessEvent cobj__obj  cobj_event  
foreign import ccall "wxEvtHandler_ProcessEvent" wxEvtHandler_ProcessEvent :: Ptr (TEvtHandler a) -> Ptr (TEvent b) -> IO CBool

-- | usage: (@evtHandlerProcessPendingEvents obj@).
evtHandlerProcessPendingEvents :: EvtHandler  a ->  IO ()
evtHandlerProcessPendingEvents _obj 
  = withObjectRef "evtHandlerProcessPendingEvents" _obj $ \cobj__obj -> 
    wxEvtHandler_ProcessPendingEvents cobj__obj  
foreign import ccall "wxEvtHandler_ProcessPendingEvents" wxEvtHandler_ProcessPendingEvents :: Ptr (TEvtHandler a) -> IO ()

{- |  Set the client data as a closure. The closure data contains the data while the function is called on deletion.  -}
evtHandlerSetClientClosure :: EvtHandler  a -> Closure  b ->  IO ()
evtHandlerSetClientClosure _obj closure 
  = withObjectRef "evtHandlerSetClientClosure" _obj $ \cobj__obj -> 
    withObjectPtr closure $ \cobj_closure -> 
    wxEvtHandler_SetClientClosure cobj__obj  cobj_closure  
foreign import ccall "wxEvtHandler_SetClientClosure" wxEvtHandler_SetClientClosure :: Ptr (TEvtHandler a) -> Ptr (TClosure b) -> IO ()

-- | usage: (@evtHandlerSetEvtHandlerEnabled obj enabled@).
evtHandlerSetEvtHandlerEnabled :: EvtHandler  a -> Bool ->  IO ()
evtHandlerSetEvtHandlerEnabled _obj enabled 
  = withObjectRef "evtHandlerSetEvtHandlerEnabled" _obj $ \cobj__obj -> 
    wxEvtHandler_SetEvtHandlerEnabled cobj__obj  (toCBool enabled)  
foreign import ccall "wxEvtHandler_SetEvtHandlerEnabled" wxEvtHandler_SetEvtHandlerEnabled :: Ptr (TEvtHandler a) -> CBool -> IO ()

-- | usage: (@evtHandlerSetNextHandler obj handler@).
evtHandlerSetNextHandler :: EvtHandler  a -> EvtHandler  b ->  IO ()
evtHandlerSetNextHandler _obj handler 
  = withObjectRef "evtHandlerSetNextHandler" _obj $ \cobj__obj -> 
    withObjectPtr handler $ \cobj_handler -> 
    wxEvtHandler_SetNextHandler cobj__obj  cobj_handler  
foreign import ccall "wxEvtHandler_SetNextHandler" wxEvtHandler_SetNextHandler :: Ptr (TEvtHandler a) -> Ptr (TEvtHandler b) -> IO ()

-- | usage: (@evtHandlerSetPreviousHandler obj handler@).
evtHandlerSetPreviousHandler :: EvtHandler  a -> EvtHandler  b ->  IO ()
evtHandlerSetPreviousHandler _obj handler 
  = withObjectRef "evtHandlerSetPreviousHandler" _obj $ \cobj__obj -> 
    withObjectPtr handler $ \cobj_handler -> 
    wxEvtHandler_SetPreviousHandler cobj__obj  cobj_handler  
foreign import ccall "wxEvtHandler_SetPreviousHandler" wxEvtHandler_SetPreviousHandler :: Ptr (TEvtHandler a) -> Ptr (TEvtHandler b) -> IO ()

-- | usage: (@fileConfigCreate inp@).
fileConfigCreate :: InputStream  a ->  IO (FileConfig  ())
fileConfigCreate inp 
  = withObjectResult $
    withObjectPtr inp $ \cobj_inp -> 
    wxFileConfig_Create cobj_inp  
foreign import ccall "wxFileConfig_Create" wxFileConfig_Create :: Ptr (TInputStream a) -> IO (Ptr (TFileConfig ()))

-- | usage: (@fileDataObjectAddFile obj fle@).
fileDataObjectAddFile :: FileDataObject  a -> String ->  IO ()
fileDataObjectAddFile _obj _fle 
  = withObjectPtr _obj $ \cobj__obj -> 
    withStringPtr _fle $ \cobj__fle -> 
    wx_FileDataObject_AddFile cobj__obj  cobj__fle  
foreign import ccall "FileDataObject_AddFile" wx_FileDataObject_AddFile :: Ptr (TFileDataObject a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@fileDataObjectCreate cntlst@).
fileDataObjectCreate :: [String] ->  IO (FileDataObject  ())
fileDataObjectCreate _cntlst 
  = withObjectResult $
    withArrayWString _cntlst $ \carrlen__cntlst carr__cntlst -> 
    wx_FileDataObject_Create carrlen__cntlst carr__cntlst  
foreign import ccall "FileDataObject_Create" wx_FileDataObject_Create :: CInt -> Ptr (Ptr CWchar) -> IO (Ptr (TFileDataObject ()))

-- | usage: (@fileDataObjectDelete obj@).
fileDataObjectDelete :: FileDataObject  a ->  IO ()
fileDataObjectDelete _obj 
  = withObjectPtr _obj $ \cobj__obj -> 
    wx_FileDataObject_Delete cobj__obj  
foreign import ccall "FileDataObject_Delete" wx_FileDataObject_Delete :: Ptr (TFileDataObject a) -> IO ()

-- | usage: (@fileDataObjectGetFilenames obj@).
fileDataObjectGetFilenames :: FileDataObject  a ->  IO [String]
fileDataObjectGetFilenames _obj 
  = withArrayWStringResult $ \arr -> 
    withObjectPtr _obj $ \cobj__obj -> 
    wx_FileDataObject_GetFilenames cobj__obj   arr
foreign import ccall "FileDataObject_GetFilenames" wx_FileDataObject_GetFilenames :: Ptr (TFileDataObject a) -> Ptr (Ptr CWchar) -> IO CInt

-- | usage: (@fileDialogCreate prt msg dir fle wcd lfttop stl@).
fileDialogCreate :: Window  a -> String -> String -> String -> String -> Point -> Style ->  IO (FileDialog  ())
fileDialogCreate _prt _msg _dir _fle _wcd _lfttop _stl 
  = withObjectResult $
    withObjectPtr _prt $ \cobj__prt -> 
    withStringPtr _msg $ \cobj__msg -> 
    withStringPtr _dir $ \cobj__dir -> 
    withStringPtr _fle $ \cobj__fle -> 
    withStringPtr _wcd $ \cobj__wcd -> 
    wxFileDialog_Create cobj__prt  cobj__msg  cobj__dir  cobj__fle  cobj__wcd  (toCIntPointX _lfttop) (toCIntPointY _lfttop)  (toCInt _stl)  
foreign import ccall "wxFileDialog_Create" wxFileDialog_Create :: Ptr (TWindow a) -> Ptr (TWxString b) -> Ptr (TWxString c) -> Ptr (TWxString d) -> Ptr (TWxString e) -> CInt -> CInt -> CInt -> IO (Ptr (TFileDialog ()))

-- | usage: (@fileDialogGetDirectory obj@).
fileDialogGetDirectory :: FileDialog  a ->  IO (String)
fileDialogGetDirectory _obj 
  = withManagedStringResult $
    withObjectRef "fileDialogGetDirectory" _obj $ \cobj__obj -> 
    wxFileDialog_GetDirectory cobj__obj  
foreign import ccall "wxFileDialog_GetDirectory" wxFileDialog_GetDirectory :: Ptr (TFileDialog a) -> IO (Ptr (TWxString ()))

-- | usage: (@fileDialogGetFilename obj@).
fileDialogGetFilename :: FileDialog  a ->  IO (String)
fileDialogGetFilename _obj 
  = withManagedStringResult $
    withObjectRef "fileDialogGetFilename" _obj $ \cobj__obj -> 
    wxFileDialog_GetFilename cobj__obj  
foreign import ccall "wxFileDialog_GetFilename" wxFileDialog_GetFilename :: Ptr (TFileDialog a) -> IO (Ptr (TWxString ()))

-- | usage: (@fileDialogGetFilenames obj@).
fileDialogGetFilenames :: FileDialog  a ->  IO [String]
fileDialogGetFilenames _obj 
  = withArrayWStringResult $ \arr -> 
    withObjectRef "fileDialogGetFilenames" _obj $ \cobj__obj -> 
    wxFileDialog_GetFilenames cobj__obj   arr
foreign import ccall "wxFileDialog_GetFilenames" wxFileDialog_GetFilenames :: Ptr (TFileDialog a) -> Ptr (Ptr CWchar) -> IO CInt

-- | usage: (@fileDialogGetFilterIndex obj@).
fileDialogGetFilterIndex :: FileDialog  a ->  IO Int
fileDialogGetFilterIndex _obj 
  = withIntResult $
    withObjectRef "fileDialogGetFilterIndex" _obj $ \cobj__obj -> 
    wxFileDialog_GetFilterIndex cobj__obj  
foreign import ccall "wxFileDialog_GetFilterIndex" wxFileDialog_GetFilterIndex :: Ptr (TFileDialog a) -> IO CInt

-- | usage: (@fileDialogGetMessage obj@).
fileDialogGetMessage :: FileDialog  a ->  IO (String)
fileDialogGetMessage _obj 
  = withManagedStringResult $
    withObjectRef "fileDialogGetMessage" _obj $ \cobj__obj -> 
    wxFileDialog_GetMessage cobj__obj  
foreign import ccall "wxFileDialog_GetMessage" wxFileDialog_GetMessage :: Ptr (TFileDialog a) -> IO (Ptr (TWxString ()))

-- | usage: (@fileDialogGetPath obj@).
fileDialogGetPath :: FileDialog  a ->  IO (String)
fileDialogGetPath _obj 
  = withManagedStringResult $
    withObjectRef "fileDialogGetPath" _obj $ \cobj__obj -> 
    wxFileDialog_GetPath cobj__obj  
foreign import ccall "wxFileDialog_GetPath" wxFileDialog_GetPath :: Ptr (TFileDialog a) -> IO (Ptr (TWxString ()))

-- | usage: (@fileDialogGetPaths obj@).
fileDialogGetPaths :: FileDialog  a ->  IO [String]
fileDialogGetPaths _obj 
  = withArrayWStringResult $ \arr -> 
    withObjectRef "fileDialogGetPaths" _obj $ \cobj__obj -> 
    wxFileDialog_GetPaths cobj__obj   arr
foreign import ccall "wxFileDialog_GetPaths" wxFileDialog_GetPaths :: Ptr (TFileDialog a) -> Ptr (Ptr CWchar) -> IO CInt

-- | usage: (@fileDialogGetStyle obj@).
fileDialogGetStyle :: FileDialog  a ->  IO Int
fileDialogGetStyle _obj 
  = withIntResult $
    withObjectRef "fileDialogGetStyle" _obj $ \cobj__obj -> 
    wxFileDialog_GetStyle cobj__obj  
foreign import ccall "wxFileDialog_GetStyle" wxFileDialog_GetStyle :: Ptr (TFileDialog a) -> IO CInt

-- | usage: (@fileDialogGetWildcard obj@).
fileDialogGetWildcard :: FileDialog  a ->  IO (String)
fileDialogGetWildcard _obj 
  = withManagedStringResult $
    withObjectRef "fileDialogGetWildcard" _obj $ \cobj__obj -> 
    wxFileDialog_GetWildcard cobj__obj  
foreign import ccall "wxFileDialog_GetWildcard" wxFileDialog_GetWildcard :: Ptr (TFileDialog a) -> IO (Ptr (TWxString ()))

-- | usage: (@fileDialogSetDirectory obj dir@).
fileDialogSetDirectory :: FileDialog  a -> String ->  IO ()
fileDialogSetDirectory _obj dir 
  = withObjectRef "fileDialogSetDirectory" _obj $ \cobj__obj -> 
    withStringPtr dir $ \cobj_dir -> 
    wxFileDialog_SetDirectory cobj__obj  cobj_dir  
foreign import ccall "wxFileDialog_SetDirectory" wxFileDialog_SetDirectory :: Ptr (TFileDialog a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@fileDialogSetFilename obj name@).
fileDialogSetFilename :: FileDialog  a -> String ->  IO ()
fileDialogSetFilename _obj name 
  = withObjectRef "fileDialogSetFilename" _obj $ \cobj__obj -> 
    withStringPtr name $ \cobj_name -> 
    wxFileDialog_SetFilename cobj__obj  cobj_name  
foreign import ccall "wxFileDialog_SetFilename" wxFileDialog_SetFilename :: Ptr (TFileDialog a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@fileDialogSetFilterIndex obj filterIndex@).
fileDialogSetFilterIndex :: FileDialog  a -> Int ->  IO ()
fileDialogSetFilterIndex _obj filterIndex 
  = withObjectRef "fileDialogSetFilterIndex" _obj $ \cobj__obj -> 
    wxFileDialog_SetFilterIndex cobj__obj  (toCInt filterIndex)  
foreign import ccall "wxFileDialog_SetFilterIndex" wxFileDialog_SetFilterIndex :: Ptr (TFileDialog a) -> CInt -> IO ()

-- | usage: (@fileDialogSetMessage obj message@).
fileDialogSetMessage :: FileDialog  a -> String ->  IO ()
fileDialogSetMessage _obj message 
  = withObjectRef "fileDialogSetMessage" _obj $ \cobj__obj -> 
    withStringPtr message $ \cobj_message -> 
    wxFileDialog_SetMessage cobj__obj  cobj_message  
foreign import ccall "wxFileDialog_SetMessage" wxFileDialog_SetMessage :: Ptr (TFileDialog a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@fileDialogSetPath obj path@).
fileDialogSetPath :: FileDialog  a -> String ->  IO ()
fileDialogSetPath _obj path 
  = withObjectRef "fileDialogSetPath" _obj $ \cobj__obj -> 
    withStringPtr path $ \cobj_path -> 
    wxFileDialog_SetPath cobj__obj  cobj_path  
foreign import ccall "wxFileDialog_SetPath" wxFileDialog_SetPath :: Ptr (TFileDialog a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@fileDialogSetStyle obj style@).
fileDialogSetStyle :: FileDialog  a -> Int ->  IO ()
fileDialogSetStyle _obj style 
  = withObjectRef "fileDialogSetStyle" _obj $ \cobj__obj -> 
    wxFileDialog_SetStyle cobj__obj  (toCInt style)  
foreign import ccall "wxFileDialog_SetStyle" wxFileDialog_SetStyle :: Ptr (TFileDialog a) -> CInt -> IO ()

-- | usage: (@fileDialogSetWildcard obj wildCard@).
fileDialogSetWildcard :: FileDialog  a -> String ->  IO ()
fileDialogSetWildcard _obj wildCard 
  = withObjectRef "fileDialogSetWildcard" _obj $ \cobj__obj -> 
    withStringPtr wildCard $ \cobj_wildCard -> 
    wxFileDialog_SetWildcard cobj__obj  cobj_wildCard  
foreign import ccall "wxFileDialog_SetWildcard" wxFileDialog_SetWildcard :: Ptr (TFileDialog a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@fileHistoryAddFileToHistory obj file@).
fileHistoryAddFileToHistory :: FileHistory  a -> String ->  IO ()
fileHistoryAddFileToHistory _obj file 
  = withObjectRef "fileHistoryAddFileToHistory" _obj $ \cobj__obj -> 
    withStringPtr file $ \cobj_file -> 
    wxFileHistory_AddFileToHistory cobj__obj  cobj_file  
foreign import ccall "wxFileHistory_AddFileToHistory" wxFileHistory_AddFileToHistory :: Ptr (TFileHistory a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@fileHistoryAddFilesToMenu obj menu@).
fileHistoryAddFilesToMenu :: FileHistory  a -> Menu  b ->  IO ()
fileHistoryAddFilesToMenu _obj menu 
  = withObjectRef "fileHistoryAddFilesToMenu" _obj $ \cobj__obj -> 
    withObjectPtr menu $ \cobj_menu -> 
    wxFileHistory_AddFilesToMenu cobj__obj  cobj_menu  
foreign import ccall "wxFileHistory_AddFilesToMenu" wxFileHistory_AddFilesToMenu :: Ptr (TFileHistory a) -> Ptr (TMenu b) -> IO ()

-- | usage: (@fileHistoryCreate maxFiles@).
fileHistoryCreate :: Int ->  IO (FileHistory  ())
fileHistoryCreate maxFiles 
  = withObjectResult $
    wxFileHistory_Create (toCInt maxFiles)  
foreign import ccall "wxFileHistory_Create" wxFileHistory_Create :: CInt -> IO (Ptr (TFileHistory ()))

-- | usage: (@fileHistoryDelete obj@).
fileHistoryDelete :: FileHistory  a ->  IO ()
fileHistoryDelete
  = objectDelete


-- | usage: (@fileHistoryGetCount obj@).
fileHistoryGetCount :: FileHistory  a ->  IO Int
fileHistoryGetCount _obj 
  = withIntResult $
    withObjectRef "fileHistoryGetCount" _obj $ \cobj__obj -> 
    wxFileHistory_GetCount cobj__obj  
foreign import ccall "wxFileHistory_GetCount" wxFileHistory_GetCount :: Ptr (TFileHistory a) -> IO CInt

-- | usage: (@fileHistoryGetHistoryFile obj i@).
fileHistoryGetHistoryFile :: FileHistory  a -> Int ->  IO (String)
fileHistoryGetHistoryFile _obj i 
  = withManagedStringResult $
    withObjectRef "fileHistoryGetHistoryFile" _obj $ \cobj__obj -> 
    wxFileHistory_GetHistoryFile cobj__obj  (toCInt i)  
foreign import ccall "wxFileHistory_GetHistoryFile" wxFileHistory_GetHistoryFile :: Ptr (TFileHistory a) -> CInt -> IO (Ptr (TWxString ()))

-- | usage: (@fileHistoryGetMaxFiles obj@).
fileHistoryGetMaxFiles :: FileHistory  a ->  IO Int
fileHistoryGetMaxFiles _obj 
  = withIntResult $
    withObjectRef "fileHistoryGetMaxFiles" _obj $ \cobj__obj -> 
    wxFileHistory_GetMaxFiles cobj__obj  
foreign import ccall "wxFileHistory_GetMaxFiles" wxFileHistory_GetMaxFiles :: Ptr (TFileHistory a) -> IO CInt

-- | usage: (@fileHistoryGetMenus obj@).
fileHistoryGetMenus :: FileHistory  a ->  IO [Menu ()]
fileHistoryGetMenus _obj 
  = withArrayObjectResult $ \arr -> 
    withObjectRef "fileHistoryGetMenus" _obj $ \cobj__obj -> 
    wxFileHistory_GetMenus cobj__obj   arr
foreign import ccall "wxFileHistory_GetMenus" wxFileHistory_GetMenus :: Ptr (TFileHistory a) -> Ptr (Ptr (TMenu ())) -> IO CInt

-- | usage: (@fileHistoryLoad obj config@).
fileHistoryLoad :: FileHistory  a -> ConfigBase  b ->  IO ()
fileHistoryLoad _obj config 
  = withObjectRef "fileHistoryLoad" _obj $ \cobj__obj -> 
    withObjectPtr config $ \cobj_config -> 
    wxFileHistory_Load cobj__obj  cobj_config  
foreign import ccall "wxFileHistory_Load" wxFileHistory_Load :: Ptr (TFileHistory a) -> Ptr (TConfigBase b) -> IO ()

-- | usage: (@fileHistoryRemoveFileFromHistory obj i@).
fileHistoryRemoveFileFromHistory :: FileHistory  a -> Int ->  IO ()
fileHistoryRemoveFileFromHistory _obj i 
  = withObjectRef "fileHistoryRemoveFileFromHistory" _obj $ \cobj__obj -> 
    wxFileHistory_RemoveFileFromHistory cobj__obj  (toCInt i)  
foreign import ccall "wxFileHistory_RemoveFileFromHistory" wxFileHistory_RemoveFileFromHistory :: Ptr (TFileHistory a) -> CInt -> IO ()

-- | usage: (@fileHistoryRemoveMenu obj menu@).
fileHistoryRemoveMenu :: FileHistory  a -> Menu  b ->  IO ()
fileHistoryRemoveMenu _obj menu 
  = withObjectRef "fileHistoryRemoveMenu" _obj $ \cobj__obj -> 
    withObjectPtr menu $ \cobj_menu -> 
    wxFileHistory_RemoveMenu cobj__obj  cobj_menu  
foreign import ccall "wxFileHistory_RemoveMenu" wxFileHistory_RemoveMenu :: Ptr (TFileHistory a) -> Ptr (TMenu b) -> IO ()

-- | usage: (@fileHistorySave obj config@).
fileHistorySave :: FileHistory  a -> ConfigBase  b ->  IO ()
fileHistorySave _obj config 
  = withObjectRef "fileHistorySave" _obj $ \cobj__obj -> 
    withObjectPtr config $ \cobj_config -> 
    wxFileHistory_Save cobj__obj  cobj_config  
foreign import ccall "wxFileHistory_Save" wxFileHistory_Save :: Ptr (TFileHistory a) -> Ptr (TConfigBase b) -> IO ()

-- | usage: (@fileHistoryUseMenu obj menu@).
fileHistoryUseMenu :: FileHistory  a -> Menu  b ->  IO ()
fileHistoryUseMenu _obj menu 
  = withObjectRef "fileHistoryUseMenu" _obj $ \cobj__obj -> 
    withObjectPtr menu $ \cobj_menu -> 
    wxFileHistory_UseMenu cobj__obj  cobj_menu  
foreign import ccall "wxFileHistory_UseMenu" wxFileHistory_UseMenu :: Ptr (TFileHistory a) -> Ptr (TMenu b) -> IO ()

-- | usage: (@fileTypeDelete obj@).
fileTypeDelete :: FileType  a ->  IO ()
fileTypeDelete _obj 
  = withObjectRef "fileTypeDelete" _obj $ \cobj__obj -> 
    wxFileType_Delete cobj__obj  
foreign import ccall "wxFileType_Delete" wxFileType_Delete :: Ptr (TFileType a) -> IO ()

-- | usage: (@fileTypeExpandCommand obj cmd params@).
fileTypeExpandCommand :: FileType  a -> Ptr  b -> Ptr  c ->  IO (String)
fileTypeExpandCommand _obj _cmd _params 
  = withManagedStringResult $
    withObjectRef "fileTypeExpandCommand" _obj $ \cobj__obj -> 
    wxFileType_ExpandCommand cobj__obj  _cmd  _params  
foreign import ccall "wxFileType_ExpandCommand" wxFileType_ExpandCommand :: Ptr (TFileType a) -> Ptr  b -> Ptr  c -> IO (Ptr (TWxString ()))

-- | usage: (@fileTypeGetDescription obj@).
fileTypeGetDescription :: FileType  a ->  IO (String)
fileTypeGetDescription _obj 
  = withManagedStringResult $
    withObjectRef "fileTypeGetDescription" _obj $ \cobj__obj -> 
    wxFileType_GetDescription cobj__obj  
foreign import ccall "wxFileType_GetDescription" wxFileType_GetDescription :: Ptr (TFileType a) -> IO (Ptr (TWxString ()))

-- | usage: (@fileTypeGetExtensions obj lst@).
fileTypeGetExtensions :: FileType  a -> List  b ->  IO Int
fileTypeGetExtensions _obj _lst 
  = withIntResult $
    withObjectRef "fileTypeGetExtensions" _obj $ \cobj__obj -> 
    withObjectPtr _lst $ \cobj__lst -> 
    wxFileType_GetExtensions cobj__obj  cobj__lst  
foreign import ccall "wxFileType_GetExtensions" wxFileType_GetExtensions :: Ptr (TFileType a) -> Ptr (TList b) -> IO CInt

-- | usage: (@fileTypeGetIcon obj icon@).
fileTypeGetIcon :: FileType  a -> Icon  b ->  IO Int
fileTypeGetIcon _obj icon 
  = withIntResult $
    withObjectRef "fileTypeGetIcon" _obj $ \cobj__obj -> 
    withObjectPtr icon $ \cobj_icon -> 
    wxFileType_GetIcon cobj__obj  cobj_icon  
foreign import ccall "wxFileType_GetIcon" wxFileType_GetIcon :: Ptr (TFileType a) -> Ptr (TIcon b) -> IO CInt

-- | usage: (@fileTypeGetMimeType obj@).
fileTypeGetMimeType :: FileType  a ->  IO (String)
fileTypeGetMimeType _obj 
  = withManagedStringResult $
    withObjectRef "fileTypeGetMimeType" _obj $ \cobj__obj -> 
    wxFileType_GetMimeType cobj__obj  
foreign import ccall "wxFileType_GetMimeType" wxFileType_GetMimeType :: Ptr (TFileType a) -> IO (Ptr (TWxString ()))

-- | usage: (@fileTypeGetMimeTypes obj lst@).
fileTypeGetMimeTypes :: FileType  a -> List  b ->  IO Int
fileTypeGetMimeTypes _obj _lst 
  = withIntResult $
    withObjectRef "fileTypeGetMimeTypes" _obj $ \cobj__obj -> 
    withObjectPtr _lst $ \cobj__lst -> 
    wxFileType_GetMimeTypes cobj__obj  cobj__lst  
foreign import ccall "wxFileType_GetMimeTypes" wxFileType_GetMimeTypes :: Ptr (TFileType a) -> Ptr (TList b) -> IO CInt

-- | usage: (@fileTypeGetOpenCommand obj buf params@).
fileTypeGetOpenCommand :: FileType  a -> Ptr  b -> Ptr  c ->  IO Int
fileTypeGetOpenCommand _obj _buf _params 
  = withIntResult $
    withObjectRef "fileTypeGetOpenCommand" _obj $ \cobj__obj -> 
    wxFileType_GetOpenCommand cobj__obj  _buf  _params  
foreign import ccall "wxFileType_GetOpenCommand" wxFileType_GetOpenCommand :: Ptr (TFileType a) -> Ptr  b -> Ptr  c -> IO CInt

-- | usage: (@fileTypeGetPrintCommand obj buf params@).
fileTypeGetPrintCommand :: FileType  a -> Ptr  b -> Ptr  c ->  IO Int
fileTypeGetPrintCommand _obj _buf _params 
  = withIntResult $
    withObjectRef "fileTypeGetPrintCommand" _obj $ \cobj__obj -> 
    wxFileType_GetPrintCommand cobj__obj  _buf  _params  
foreign import ccall "wxFileType_GetPrintCommand" wxFileType_GetPrintCommand :: Ptr (TFileType a) -> Ptr  b -> Ptr  c -> IO CInt

-- | usage: (@findDialogEventGetFindString obj ref@).
findDialogEventGetFindString :: FindDialogEvent  a -> Ptr  b ->  IO Int
findDialogEventGetFindString _obj _ref 
  = withIntResult $
    withObjectRef "findDialogEventGetFindString" _obj $ \cobj__obj -> 
    wxFindDialogEvent_GetFindString cobj__obj  _ref  
foreign import ccall "wxFindDialogEvent_GetFindString" wxFindDialogEvent_GetFindString :: Ptr (TFindDialogEvent a) -> Ptr  b -> IO CInt

-- | usage: (@findDialogEventGetFlags obj@).
findDialogEventGetFlags :: FindDialogEvent  a ->  IO Int
findDialogEventGetFlags _obj 
  = withIntResult $
    withObjectRef "findDialogEventGetFlags" _obj $ \cobj__obj -> 
    wxFindDialogEvent_GetFlags cobj__obj  
foreign import ccall "wxFindDialogEvent_GetFlags" wxFindDialogEvent_GetFlags :: Ptr (TFindDialogEvent a) -> IO CInt

-- | usage: (@findDialogEventGetReplaceString obj ref@).
findDialogEventGetReplaceString :: FindDialogEvent  a -> Ptr  b ->  IO Int
findDialogEventGetReplaceString _obj _ref 
  = withIntResult $
    withObjectRef "findDialogEventGetReplaceString" _obj $ \cobj__obj -> 
    wxFindDialogEvent_GetReplaceString cobj__obj  _ref  
foreign import ccall "wxFindDialogEvent_GetReplaceString" wxFindDialogEvent_GetReplaceString :: Ptr (TFindDialogEvent a) -> Ptr  b -> IO CInt

-- | usage: (@findReplaceDataCreate flags@).
findReplaceDataCreate :: Int ->  IO (FindReplaceData  ())
findReplaceDataCreate flags 
  = withObjectResult $
    wxFindReplaceData_Create (toCInt flags)  
foreign import ccall "wxFindReplaceData_Create" wxFindReplaceData_Create :: CInt -> IO (Ptr (TFindReplaceData ()))

-- | usage: (@findReplaceDataCreateDefault@).
findReplaceDataCreateDefault ::  IO (FindReplaceData  ())
findReplaceDataCreateDefault 
  = withObjectResult $
    wxFindReplaceData_CreateDefault 
foreign import ccall "wxFindReplaceData_CreateDefault" wxFindReplaceData_CreateDefault :: IO (Ptr (TFindReplaceData ()))

-- | usage: (@findReplaceDataDelete obj@).
findReplaceDataDelete :: FindReplaceData  a ->  IO ()
findReplaceDataDelete
  = objectDelete


-- | usage: (@findReplaceDataGetFindString obj@).
findReplaceDataGetFindString :: FindReplaceData  a ->  IO (String)
findReplaceDataGetFindString _obj 
  = withManagedStringResult $
    withObjectRef "findReplaceDataGetFindString" _obj $ \cobj__obj -> 
    wxFindReplaceData_GetFindString cobj__obj  
foreign import ccall "wxFindReplaceData_GetFindString" wxFindReplaceData_GetFindString :: Ptr (TFindReplaceData a) -> IO (Ptr (TWxString ()))

-- | usage: (@findReplaceDataGetFlags obj@).
findReplaceDataGetFlags :: FindReplaceData  a ->  IO Int
findReplaceDataGetFlags _obj 
  = withIntResult $
    withObjectRef "findReplaceDataGetFlags" _obj $ \cobj__obj -> 
    wxFindReplaceData_GetFlags cobj__obj  
foreign import ccall "wxFindReplaceData_GetFlags" wxFindReplaceData_GetFlags :: Ptr (TFindReplaceData a) -> IO CInt

-- | usage: (@findReplaceDataGetReplaceString obj@).
findReplaceDataGetReplaceString :: FindReplaceData  a ->  IO (String)
findReplaceDataGetReplaceString _obj 
  = withManagedStringResult $
    withObjectRef "findReplaceDataGetReplaceString" _obj $ \cobj__obj -> 
    wxFindReplaceData_GetReplaceString cobj__obj  
foreign import ccall "wxFindReplaceData_GetReplaceString" wxFindReplaceData_GetReplaceString :: Ptr (TFindReplaceData a) -> IO (Ptr (TWxString ()))

-- | usage: (@findReplaceDataSetFindString obj str@).
findReplaceDataSetFindString :: FindReplaceData  a -> String ->  IO ()
findReplaceDataSetFindString _obj str 
  = withObjectRef "findReplaceDataSetFindString" _obj $ \cobj__obj -> 
    withStringPtr str $ \cobj_str -> 
    wxFindReplaceData_SetFindString cobj__obj  cobj_str  
foreign import ccall "wxFindReplaceData_SetFindString" wxFindReplaceData_SetFindString :: Ptr (TFindReplaceData a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@findReplaceDataSetFlags obj flags@).
findReplaceDataSetFlags :: FindReplaceData  a -> Int ->  IO ()
findReplaceDataSetFlags _obj flags 
  = withObjectRef "findReplaceDataSetFlags" _obj $ \cobj__obj -> 
    wxFindReplaceData_SetFlags cobj__obj  (toCInt flags)  
foreign import ccall "wxFindReplaceData_SetFlags" wxFindReplaceData_SetFlags :: Ptr (TFindReplaceData a) -> CInt -> IO ()

-- | usage: (@findReplaceDataSetReplaceString obj str@).
findReplaceDataSetReplaceString :: FindReplaceData  a -> String ->  IO ()
findReplaceDataSetReplaceString _obj str 
  = withObjectRef "findReplaceDataSetReplaceString" _obj $ \cobj__obj -> 
    withStringPtr str $ \cobj_str -> 
    wxFindReplaceData_SetReplaceString cobj__obj  cobj_str  
foreign import ccall "wxFindReplaceData_SetReplaceString" wxFindReplaceData_SetReplaceString :: Ptr (TFindReplaceData a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@findReplaceDialogCreate parent wxdata title style@).
findReplaceDialogCreate :: Window  a -> FindReplaceData  b -> String -> Int ->  IO (FindReplaceDialog  ())
findReplaceDialogCreate parent wxdata title style 
  = withObjectResult $
    withObjectPtr parent $ \cobj_parent -> 
    withObjectPtr wxdata $ \cobj_wxdata -> 
    withStringPtr title $ \cobj_title -> 
    wxFindReplaceDialog_Create cobj_parent  cobj_wxdata  cobj_title  (toCInt style)  
foreign import ccall "wxFindReplaceDialog_Create" wxFindReplaceDialog_Create :: Ptr (TWindow a) -> Ptr (TFindReplaceData b) -> Ptr (TWxString c) -> CInt -> IO (Ptr (TFindReplaceDialog ()))

-- | usage: (@findReplaceDialogGetData obj@).
findReplaceDialogGetData :: FindReplaceDialog  a ->  IO (FindReplaceData  ())
findReplaceDialogGetData _obj 
  = withObjectResult $
    withObjectRef "findReplaceDialogGetData" _obj $ \cobj__obj -> 
    wxFindReplaceDialog_GetData cobj__obj  
foreign import ccall "wxFindReplaceDialog_GetData" wxFindReplaceDialog_GetData :: Ptr (TFindReplaceDialog a) -> IO (Ptr (TFindReplaceData ()))

-- | usage: (@findReplaceDialogSetData obj wxdata@).
findReplaceDialogSetData :: FindReplaceDialog  a -> FindReplaceData  b ->  IO ()
findReplaceDialogSetData _obj wxdata 
  = withObjectRef "findReplaceDialogSetData" _obj $ \cobj__obj -> 
    withObjectPtr wxdata $ \cobj_wxdata -> 
    wxFindReplaceDialog_SetData cobj__obj  cobj_wxdata  
foreign import ccall "wxFindReplaceDialog_SetData" wxFindReplaceDialog_SetData :: Ptr (TFindReplaceDialog a) -> Ptr (TFindReplaceData b) -> IO ()

-- | usage: (@flexGridSizerAddGrowableCol obj idx@).
flexGridSizerAddGrowableCol :: FlexGridSizer  a -> Int ->  IO ()
flexGridSizerAddGrowableCol _obj idx 
  = withObjectRef "flexGridSizerAddGrowableCol" _obj $ \cobj__obj -> 
    wxFlexGridSizer_AddGrowableCol cobj__obj  (toCInt idx)  
foreign import ccall "wxFlexGridSizer_AddGrowableCol" wxFlexGridSizer_AddGrowableCol :: Ptr (TFlexGridSizer a) -> CInt -> IO ()

-- | usage: (@flexGridSizerAddGrowableRow obj idx@).
flexGridSizerAddGrowableRow :: FlexGridSizer  a -> Int ->  IO ()
flexGridSizerAddGrowableRow _obj idx 
  = withObjectRef "flexGridSizerAddGrowableRow" _obj $ \cobj__obj -> 
    wxFlexGridSizer_AddGrowableRow cobj__obj  (toCInt idx)  
foreign import ccall "wxFlexGridSizer_AddGrowableRow" wxFlexGridSizer_AddGrowableRow :: Ptr (TFlexGridSizer a) -> CInt -> IO ()

-- | usage: (@flexGridSizerCalcMin obj@).
flexGridSizerCalcMin :: FlexGridSizer  a ->  IO (Size)
flexGridSizerCalcMin _obj 
  = withWxSizeResult $
    withObjectRef "flexGridSizerCalcMin" _obj $ \cobj__obj -> 
    wxFlexGridSizer_CalcMin cobj__obj  
foreign import ccall "wxFlexGridSizer_CalcMin" wxFlexGridSizer_CalcMin :: Ptr (TFlexGridSizer a) -> IO (Ptr (TWxSize ()))

-- | usage: (@flexGridSizerCreate rows cols vgap hgap@).
flexGridSizerCreate :: Int -> Int -> Int -> Int ->  IO (FlexGridSizer  ())
flexGridSizerCreate rows cols vgap hgap 
  = withObjectResult $
    wxFlexGridSizer_Create (toCInt rows)  (toCInt cols)  (toCInt vgap)  (toCInt hgap)  
foreign import ccall "wxFlexGridSizer_Create" wxFlexGridSizer_Create :: CInt -> CInt -> CInt -> CInt -> IO (Ptr (TFlexGridSizer ()))

-- | usage: (@flexGridSizerRecalcSizes obj@).
flexGridSizerRecalcSizes :: FlexGridSizer  a ->  IO ()
flexGridSizerRecalcSizes _obj 
  = withObjectRef "flexGridSizerRecalcSizes" _obj $ \cobj__obj -> 
    wxFlexGridSizer_RecalcSizes cobj__obj  
foreign import ccall "wxFlexGridSizer_RecalcSizes" wxFlexGridSizer_RecalcSizes :: Ptr (TFlexGridSizer a) -> IO ()

-- | usage: (@flexGridSizerRemoveGrowableCol obj idx@).
flexGridSizerRemoveGrowableCol :: FlexGridSizer  a -> Int ->  IO ()
flexGridSizerRemoveGrowableCol _obj idx 
  = withObjectRef "flexGridSizerRemoveGrowableCol" _obj $ \cobj__obj -> 
    wxFlexGridSizer_RemoveGrowableCol cobj__obj  (toCInt idx)  
foreign import ccall "wxFlexGridSizer_RemoveGrowableCol" wxFlexGridSizer_RemoveGrowableCol :: Ptr (TFlexGridSizer a) -> CInt -> IO ()

-- | usage: (@flexGridSizerRemoveGrowableRow obj idx@).
flexGridSizerRemoveGrowableRow :: FlexGridSizer  a -> Int ->  IO ()
flexGridSizerRemoveGrowableRow _obj idx 
  = withObjectRef "flexGridSizerRemoveGrowableRow" _obj $ \cobj__obj -> 
    wxFlexGridSizer_RemoveGrowableRow cobj__obj  (toCInt idx)  
foreign import ccall "wxFlexGridSizer_RemoveGrowableRow" wxFlexGridSizer_RemoveGrowableRow :: Ptr (TFlexGridSizer a) -> CInt -> IO ()

-- | usage: (@fontCreate pointSize family style weight underlined face enc@).
fontCreate :: Int -> Int -> Int -> Int -> Bool -> String -> Int ->  IO (Font  ())
fontCreate pointSize family style weight underlined face enc 
  = withManagedFontResult $
    withStringPtr face $ \cobj_face -> 
    wxFont_Create (toCInt pointSize)  (toCInt family)  (toCInt style)  (toCInt weight)  (toCBool underlined)  cobj_face  (toCInt enc)  
foreign import ccall "wxFont_Create" wxFont_Create :: CInt -> CInt -> CInt -> CInt -> CBool -> Ptr (TWxString f) -> CInt -> IO (Ptr (TFont ()))

-- | usage: (@fontCreateDefault@).
fontCreateDefault ::  IO (Font  ())
fontCreateDefault 
  = withManagedFontResult $
    wxFont_CreateDefault 
foreign import ccall "wxFont_CreateDefault" wxFont_CreateDefault :: IO (Ptr (TFont ()))

-- | usage: (@fontCreateFromStock id@).
fontCreateFromStock :: Id ->  IO (Font  ())
fontCreateFromStock id 
  = withManagedFontResult $
    wxFont_CreateFromStock (toCInt id)  
foreign import ccall "wxFont_CreateFromStock" wxFont_CreateFromStock :: CInt -> IO (Ptr (TFont ()))

-- | usage: (@fontDataCreate@).
fontDataCreate ::  IO (FontData  ())
fontDataCreate 
  = withManagedObjectResult $
    wxFontData_Create 
foreign import ccall "wxFontData_Create" wxFontData_Create :: IO (Ptr (TFontData ()))

-- | usage: (@fontDataDelete obj@).
fontDataDelete :: FontData  a ->  IO ()
fontDataDelete
  = objectDelete


-- | usage: (@fontDataEnableEffects obj flag@).
fontDataEnableEffects :: FontData  a -> Bool ->  IO ()
fontDataEnableEffects _obj flag 
  = withObjectRef "fontDataEnableEffects" _obj $ \cobj__obj -> 
    wxFontData_EnableEffects cobj__obj  (toCBool flag)  
foreign import ccall "wxFontData_EnableEffects" wxFontData_EnableEffects :: Ptr (TFontData a) -> CBool -> IO ()

-- | usage: (@fontDataGetAllowSymbols obj@).
fontDataGetAllowSymbols :: FontData  a ->  IO Bool
fontDataGetAllowSymbols _obj 
  = withBoolResult $
    withObjectRef "fontDataGetAllowSymbols" _obj $ \cobj__obj -> 
    wxFontData_GetAllowSymbols cobj__obj  
foreign import ccall "wxFontData_GetAllowSymbols" wxFontData_GetAllowSymbols :: Ptr (TFontData a) -> IO CBool

-- | usage: (@fontDataGetChosenFont obj@).
fontDataGetChosenFont :: FontData  a ->  IO (Font  ())
fontDataGetChosenFont _obj 
  = withRefFont $ \pref -> 
    withObjectRef "fontDataGetChosenFont" _obj $ \cobj__obj -> 
    wxFontData_GetChosenFont cobj__obj   pref
foreign import ccall "wxFontData_GetChosenFont" wxFontData_GetChosenFont :: Ptr (TFontData a) -> Ptr (TFont ()) -> IO ()

-- | usage: (@fontDataGetColour obj@).
fontDataGetColour :: FontData  a ->  IO (Color)
fontDataGetColour _obj 
  = withRefColour $ \pref -> 
    withObjectRef "fontDataGetColour" _obj $ \cobj__obj -> 
    wxFontData_GetColour cobj__obj   pref
foreign import ccall "wxFontData_GetColour" wxFontData_GetColour :: Ptr (TFontData a) -> Ptr (TColour ()) -> IO ()

-- | usage: (@fontDataGetEnableEffects obj@).
fontDataGetEnableEffects :: FontData  a ->  IO Bool
fontDataGetEnableEffects _obj 
  = withBoolResult $
    withObjectRef "fontDataGetEnableEffects" _obj $ \cobj__obj -> 
    wxFontData_GetEnableEffects cobj__obj  
foreign import ccall "wxFontData_GetEnableEffects" wxFontData_GetEnableEffects :: Ptr (TFontData a) -> IO CBool

-- | usage: (@fontDataGetEncoding obj@).
fontDataGetEncoding :: FontData  a ->  IO Int
fontDataGetEncoding _obj 
  = withIntResult $
    withObjectRef "fontDataGetEncoding" _obj $ \cobj__obj -> 
    wxFontData_GetEncoding cobj__obj  
foreign import ccall "wxFontData_GetEncoding" wxFontData_GetEncoding :: Ptr (TFontData a) -> IO CInt

-- | usage: (@fontDataGetInitialFont obj@).
fontDataGetInitialFont :: FontData  a ->  IO (Font  ())
fontDataGetInitialFont _obj 
  = withRefFont $ \pref -> 
    withObjectRef "fontDataGetInitialFont" _obj $ \cobj__obj -> 
    wxFontData_GetInitialFont cobj__obj   pref
foreign import ccall "wxFontData_GetInitialFont" wxFontData_GetInitialFont :: Ptr (TFontData a) -> Ptr (TFont ()) -> IO ()

-- | usage: (@fontDataGetShowHelp obj@).
fontDataGetShowHelp :: FontData  a ->  IO Int
fontDataGetShowHelp _obj 
  = withIntResult $
    withObjectRef "fontDataGetShowHelp" _obj $ \cobj__obj -> 
    wxFontData_GetShowHelp cobj__obj  
foreign import ccall "wxFontData_GetShowHelp" wxFontData_GetShowHelp :: Ptr (TFontData a) -> IO CInt

-- | usage: (@fontDataSetAllowSymbols obj flag@).
fontDataSetAllowSymbols :: FontData  a -> Bool ->  IO ()
fontDataSetAllowSymbols _obj flag 
  = withObjectRef "fontDataSetAllowSymbols" _obj $ \cobj__obj -> 
    wxFontData_SetAllowSymbols cobj__obj  (toCBool flag)  
foreign import ccall "wxFontData_SetAllowSymbols" wxFontData_SetAllowSymbols :: Ptr (TFontData a) -> CBool -> IO ()

-- | usage: (@fontDataSetChosenFont obj font@).
fontDataSetChosenFont :: FontData  a -> Font  b ->  IO ()
fontDataSetChosenFont _obj font 
  = withObjectRef "fontDataSetChosenFont" _obj $ \cobj__obj -> 
    withObjectPtr font $ \cobj_font -> 
    wxFontData_SetChosenFont cobj__obj  cobj_font  
foreign import ccall "wxFontData_SetChosenFont" wxFontData_SetChosenFont :: Ptr (TFontData a) -> Ptr (TFont b) -> IO ()

-- | usage: (@fontDataSetColour obj colour@).
fontDataSetColour :: FontData  a -> Color ->  IO ()
fontDataSetColour _obj colour 
  = withObjectRef "fontDataSetColour" _obj $ \cobj__obj -> 
    withColourPtr colour $ \cobj_colour -> 
    wxFontData_SetColour cobj__obj  cobj_colour  
foreign import ccall "wxFontData_SetColour" wxFontData_SetColour :: Ptr (TFontData a) -> Ptr (TColour b) -> IO ()

-- | usage: (@fontDataSetEncoding obj encoding@).
fontDataSetEncoding :: FontData  a -> Int ->  IO ()
fontDataSetEncoding _obj encoding 
  = withObjectRef "fontDataSetEncoding" _obj $ \cobj__obj -> 
    wxFontData_SetEncoding cobj__obj  (toCInt encoding)  
foreign import ccall "wxFontData_SetEncoding" wxFontData_SetEncoding :: Ptr (TFontData a) -> CInt -> IO ()

-- | usage: (@fontDataSetInitialFont obj font@).
fontDataSetInitialFont :: FontData  a -> Font  b ->  IO ()
fontDataSetInitialFont _obj font 
  = withObjectRef "fontDataSetInitialFont" _obj $ \cobj__obj -> 
    withObjectPtr font $ \cobj_font -> 
    wxFontData_SetInitialFont cobj__obj  cobj_font  
foreign import ccall "wxFontData_SetInitialFont" wxFontData_SetInitialFont :: Ptr (TFontData a) -> Ptr (TFont b) -> IO ()

-- | usage: (@fontDataSetRange obj minRange maxRange@).
fontDataSetRange :: FontData  a -> Int -> Int ->  IO ()
fontDataSetRange _obj minRange maxRange 
  = withObjectRef "fontDataSetRange" _obj $ \cobj__obj -> 
    wxFontData_SetRange cobj__obj  (toCInt minRange)  (toCInt maxRange)  
foreign import ccall "wxFontData_SetRange" wxFontData_SetRange :: Ptr (TFontData a) -> CInt -> CInt -> IO ()

-- | usage: (@fontDataSetShowHelp obj flag@).
fontDataSetShowHelp :: FontData  a -> Bool ->  IO ()
fontDataSetShowHelp _obj flag 
  = withObjectRef "fontDataSetShowHelp" _obj $ \cobj__obj -> 
    wxFontData_SetShowHelp cobj__obj  (toCBool flag)  
foreign import ccall "wxFontData_SetShowHelp" wxFontData_SetShowHelp :: Ptr (TFontData a) -> CBool -> IO ()

-- | usage: (@fontDelete obj@).
fontDelete :: Font  a ->  IO ()
fontDelete
  = objectDelete


-- | usage: (@fontDialogCreate prt fnt@).
fontDialogCreate :: Window  a -> FontData  b ->  IO (FontDialog  ())
fontDialogCreate _prt fnt 
  = withObjectResult $
    withObjectPtr _prt $ \cobj__prt -> 
    withObjectPtr fnt $ \cobj_fnt -> 
    wxFontDialog_Create cobj__prt  cobj_fnt  
foreign import ccall "wxFontDialog_Create" wxFontDialog_Create :: Ptr (TWindow a) -> Ptr (TFontData b) -> IO (Ptr (TFontDialog ()))

-- | usage: (@fontDialogGetFontData obj@).
fontDialogGetFontData :: FontDialog  a ->  IO (FontData  ())
fontDialogGetFontData _obj 
  = withRefFontData $ \pref -> 
    withObjectRef "fontDialogGetFontData" _obj $ \cobj__obj -> 
    wxFontDialog_GetFontData cobj__obj   pref
foreign import ccall "wxFontDialog_GetFontData" wxFontDialog_GetFontData :: Ptr (TFontDialog a) -> Ptr (TFontData ()) -> IO ()

-- | usage: (@fontEnumeratorCreate obj fnc@).
fontEnumeratorCreate :: Ptr  a -> Ptr  b ->  IO (FontEnumerator  ())
fontEnumeratorCreate _obj _fnc 
  = withObjectResult $
    wxFontEnumerator_Create _obj  _fnc  
foreign import ccall "wxFontEnumerator_Create" wxFontEnumerator_Create :: Ptr  a -> Ptr  b -> IO (Ptr (TFontEnumerator ()))

-- | usage: (@fontEnumeratorDelete obj@).
fontEnumeratorDelete :: FontEnumerator  a ->  IO ()
fontEnumeratorDelete _obj 
  = withObjectRef "fontEnumeratorDelete" _obj $ \cobj__obj -> 
    wxFontEnumerator_Delete cobj__obj  
foreign import ccall "wxFontEnumerator_Delete" wxFontEnumerator_Delete :: Ptr (TFontEnumerator a) -> IO ()

-- | usage: (@fontEnumeratorEnumerateEncodings obj facename@).
fontEnumeratorEnumerateEncodings :: FontEnumerator  a -> String ->  IO Bool
fontEnumeratorEnumerateEncodings _obj facename 
  = withBoolResult $
    withObjectRef "fontEnumeratorEnumerateEncodings" _obj $ \cobj__obj -> 
    withStringPtr facename $ \cobj_facename -> 
    wxFontEnumerator_EnumerateEncodings cobj__obj  cobj_facename  
foreign import ccall "wxFontEnumerator_EnumerateEncodings" wxFontEnumerator_EnumerateEncodings :: Ptr (TFontEnumerator a) -> Ptr (TWxString b) -> IO CBool

-- | usage: (@fontEnumeratorEnumerateFacenames obj encoding fixedWidthOnly@).
fontEnumeratorEnumerateFacenames :: FontEnumerator  a -> Int -> Int ->  IO Bool
fontEnumeratorEnumerateFacenames _obj encoding fixedWidthOnly 
  = withBoolResult $
    withObjectRef "fontEnumeratorEnumerateFacenames" _obj $ \cobj__obj -> 
    wxFontEnumerator_EnumerateFacenames cobj__obj  (toCInt encoding)  (toCInt fixedWidthOnly)  
foreign import ccall "wxFontEnumerator_EnumerateFacenames" wxFontEnumerator_EnumerateFacenames :: Ptr (TFontEnumerator a) -> CInt -> CInt -> IO CBool

-- | usage: (@fontGetDefaultEncoding obj@).
fontGetDefaultEncoding :: Font  a ->  IO Int
fontGetDefaultEncoding _obj 
  = withIntResult $
    withObjectRef "fontGetDefaultEncoding" _obj $ \cobj__obj -> 
    wxFont_GetDefaultEncoding cobj__obj  
foreign import ccall "wxFont_GetDefaultEncoding" wxFont_GetDefaultEncoding :: Ptr (TFont a) -> IO CInt

-- | usage: (@fontGetEncoding obj@).
fontGetEncoding :: Font  a ->  IO Int
fontGetEncoding _obj 
  = withIntResult $
    withObjectRef "fontGetEncoding" _obj $ \cobj__obj -> 
    wxFont_GetEncoding cobj__obj  
foreign import ccall "wxFont_GetEncoding" wxFont_GetEncoding :: Ptr (TFont a) -> IO CInt

-- | usage: (@fontGetFaceName obj@).
fontGetFaceName :: Font  a ->  IO (String)
fontGetFaceName _obj 
  = withManagedStringResult $
    withObjectRef "fontGetFaceName" _obj $ \cobj__obj -> 
    wxFont_GetFaceName cobj__obj  
foreign import ccall "wxFont_GetFaceName" wxFont_GetFaceName :: Ptr (TFont a) -> IO (Ptr (TWxString ()))

-- | usage: (@fontGetFamily obj@).
fontGetFamily :: Font  a ->  IO Int
fontGetFamily _obj 
  = withIntResult $
    withObjectRef "fontGetFamily" _obj $ \cobj__obj -> 
    wxFont_GetFamily cobj__obj  
foreign import ccall "wxFont_GetFamily" wxFont_GetFamily :: Ptr (TFont a) -> IO CInt

-- | usage: (@fontGetFamilyString obj@).
fontGetFamilyString :: Font  a ->  IO (String)
fontGetFamilyString _obj 
  = withManagedStringResult $
    withObjectRef "fontGetFamilyString" _obj $ \cobj__obj -> 
    wxFont_GetFamilyString cobj__obj  
foreign import ccall "wxFont_GetFamilyString" wxFont_GetFamilyString :: Ptr (TFont a) -> IO (Ptr (TWxString ()))

-- | usage: (@fontGetPointSize obj@).
fontGetPointSize :: Font  a ->  IO Int
fontGetPointSize _obj 
  = withIntResult $
    withObjectRef "fontGetPointSize" _obj $ \cobj__obj -> 
    wxFont_GetPointSize cobj__obj  
foreign import ccall "wxFont_GetPointSize" wxFont_GetPointSize :: Ptr (TFont a) -> IO CInt

-- | usage: (@fontGetStyle obj@).
fontGetStyle :: Font  a ->  IO Int
fontGetStyle _obj 
  = withIntResult $
    withObjectRef "fontGetStyle" _obj $ \cobj__obj -> 
    wxFont_GetStyle cobj__obj  
foreign import ccall "wxFont_GetStyle" wxFont_GetStyle :: Ptr (TFont a) -> IO CInt

-- | usage: (@fontGetStyleString obj@).
fontGetStyleString :: Font  a ->  IO (String)
fontGetStyleString _obj 
  = withManagedStringResult $
    withObjectRef "fontGetStyleString" _obj $ \cobj__obj -> 
    wxFont_GetStyleString cobj__obj  
foreign import ccall "wxFont_GetStyleString" wxFont_GetStyleString :: Ptr (TFont a) -> IO (Ptr (TWxString ()))

-- | usage: (@fontGetUnderlined obj@).
fontGetUnderlined :: Font  a ->  IO Int
fontGetUnderlined _obj 
  = withIntResult $
    withObjectRef "fontGetUnderlined" _obj $ \cobj__obj -> 
    wxFont_GetUnderlined cobj__obj  
foreign import ccall "wxFont_GetUnderlined" wxFont_GetUnderlined :: Ptr (TFont a) -> IO CInt

-- | usage: (@fontGetWeight obj@).
fontGetWeight :: Font  a ->  IO Int
fontGetWeight _obj 
  = withIntResult $
    withObjectRef "fontGetWeight" _obj $ \cobj__obj -> 
    wxFont_GetWeight cobj__obj  
foreign import ccall "wxFont_GetWeight" wxFont_GetWeight :: Ptr (TFont a) -> IO CInt

-- | usage: (@fontGetWeightString obj@).
fontGetWeightString :: Font  a ->  IO (String)
fontGetWeightString _obj 
  = withManagedStringResult $
    withObjectRef "fontGetWeightString" _obj $ \cobj__obj -> 
    wxFont_GetWeightString cobj__obj  
foreign import ccall "wxFont_GetWeightString" wxFont_GetWeightString :: Ptr (TFont a) -> IO (Ptr (TWxString ()))

-- | usage: (@fontIsOk obj@).
fontIsOk :: Font  a ->  IO Bool
fontIsOk _obj 
  = withBoolResult $
    withObjectRef "fontIsOk" _obj $ \cobj__obj -> 
    wxFont_IsOk cobj__obj  
foreign import ccall "wxFont_IsOk" wxFont_IsOk :: Ptr (TFont a) -> IO CBool

-- | usage: (@fontIsStatic self@).
fontIsStatic :: Font  a ->  IO Bool
fontIsStatic self 
  = withBoolResult $
    withObjectPtr self $ \cobj_self -> 
    wxFont_IsStatic cobj_self  
foreign import ccall "wxFont_IsStatic" wxFont_IsStatic :: Ptr (TFont a) -> IO CBool

-- | usage: (@fontMapperCreate@).
fontMapperCreate ::  IO (FontMapper  ())
fontMapperCreate 
  = withObjectResult $
    wxFontMapper_Create 
foreign import ccall "wxFontMapper_Create" wxFontMapper_Create :: IO (Ptr (TFontMapper ()))

-- | usage: (@fontMapperGetAltForEncoding obj encoding altencoding buf@).
fontMapperGetAltForEncoding :: FontMapper  a -> Int -> Ptr  c -> String ->  IO Bool
fontMapperGetAltForEncoding _obj encoding altencoding _buf 
  = withBoolResult $
    withObjectRef "fontMapperGetAltForEncoding" _obj $ \cobj__obj -> 
    withStringPtr _buf $ \cobj__buf -> 
    wxFontMapper_GetAltForEncoding cobj__obj  (toCInt encoding)  altencoding  cobj__buf  
foreign import ccall "wxFontMapper_GetAltForEncoding" wxFontMapper_GetAltForEncoding :: Ptr (TFontMapper a) -> CInt -> Ptr  c -> Ptr (TWxString d) -> IO CBool

-- | usage: (@fontMapperIsEncodingAvailable obj encoding buf@).
fontMapperIsEncodingAvailable :: FontMapper  a -> Int -> String ->  IO Bool
fontMapperIsEncodingAvailable _obj encoding _buf 
  = withBoolResult $
    withObjectRef "fontMapperIsEncodingAvailable" _obj $ \cobj__obj -> 
    withStringPtr _buf $ \cobj__buf -> 
    wxFontMapper_IsEncodingAvailable cobj__obj  (toCInt encoding)  cobj__buf  
foreign import ccall "wxFontMapper_IsEncodingAvailable" wxFontMapper_IsEncodingAvailable :: Ptr (TFontMapper a) -> CInt -> Ptr (TWxString c) -> IO CBool

-- | usage: (@fontSafeDelete self@).
fontSafeDelete :: Font  a ->  IO ()
fontSafeDelete self 
  = withObjectPtr self $ \cobj_self -> 
    wxFont_SafeDelete cobj_self  
foreign import ccall "wxFont_SafeDelete" wxFont_SafeDelete :: Ptr (TFont a) -> IO ()

-- | usage: (@fontSetDefaultEncoding obj encoding@).
fontSetDefaultEncoding :: Font  a -> Int ->  IO ()
fontSetDefaultEncoding _obj encoding 
  = withObjectRef "fontSetDefaultEncoding" _obj $ \cobj__obj -> 
    wxFont_SetDefaultEncoding cobj__obj  (toCInt encoding)  
foreign import ccall "wxFont_SetDefaultEncoding" wxFont_SetDefaultEncoding :: Ptr (TFont a) -> CInt -> IO ()

-- | usage: (@fontSetEncoding obj encoding@).
fontSetEncoding :: Font  a -> Int ->  IO ()
fontSetEncoding _obj encoding 
  = withObjectRef "fontSetEncoding" _obj $ \cobj__obj -> 
    wxFont_SetEncoding cobj__obj  (toCInt encoding)  
foreign import ccall "wxFont_SetEncoding" wxFont_SetEncoding :: Ptr (TFont a) -> CInt -> IO ()

-- | usage: (@fontSetFaceName obj faceName@).
fontSetFaceName :: Font  a -> String ->  IO ()
fontSetFaceName _obj faceName 
  = withObjectRef "fontSetFaceName" _obj $ \cobj__obj -> 
    withStringPtr faceName $ \cobj_faceName -> 
    wxFont_SetFaceName cobj__obj  cobj_faceName  
foreign import ccall "wxFont_SetFaceName" wxFont_SetFaceName :: Ptr (TFont a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@fontSetFamily obj family@).
fontSetFamily :: Font  a -> Int ->  IO ()
fontSetFamily _obj family 
  = withObjectRef "fontSetFamily" _obj $ \cobj__obj -> 
    wxFont_SetFamily cobj__obj  (toCInt family)  
foreign import ccall "wxFont_SetFamily" wxFont_SetFamily :: Ptr (TFont a) -> CInt -> IO ()

-- | usage: (@fontSetPointSize obj pointSize@).
fontSetPointSize :: Font  a -> Int ->  IO ()
fontSetPointSize _obj pointSize 
  = withObjectRef "fontSetPointSize" _obj $ \cobj__obj -> 
    wxFont_SetPointSize cobj__obj  (toCInt pointSize)  
foreign import ccall "wxFont_SetPointSize" wxFont_SetPointSize :: Ptr (TFont a) -> CInt -> IO ()

-- | usage: (@fontSetStyle obj style@).
fontSetStyle :: Font  a -> Int ->  IO ()
fontSetStyle _obj style 
  = withObjectRef "fontSetStyle" _obj $ \cobj__obj -> 
    wxFont_SetStyle cobj__obj  (toCInt style)  
foreign import ccall "wxFont_SetStyle" wxFont_SetStyle :: Ptr (TFont a) -> CInt -> IO ()

-- | usage: (@fontSetUnderlined obj underlined@).
fontSetUnderlined :: Font  a -> Int ->  IO ()
fontSetUnderlined _obj underlined 
  = withObjectRef "fontSetUnderlined" _obj $ \cobj__obj -> 
    wxFont_SetUnderlined cobj__obj  (toCInt underlined)  
foreign import ccall "wxFont_SetUnderlined" wxFont_SetUnderlined :: Ptr (TFont a) -> CInt -> IO ()

-- | usage: (@fontSetWeight obj weight@).
fontSetWeight :: Font  a -> Int ->  IO ()
fontSetWeight _obj weight 
  = withObjectRef "fontSetWeight" _obj $ \cobj__obj -> 
    wxFont_SetWeight cobj__obj  (toCInt weight)  
foreign import ccall "wxFont_SetWeight" wxFont_SetWeight :: Ptr (TFont a) -> CInt -> IO ()

-- | usage: (@frameCentre self orientation@).
frameCentre :: Frame  a -> Int ->  IO ()
frameCentre self orientation 
  = withObjectRef "frameCentre" self $ \cobj_self -> 
    wxFrame_Centre cobj_self  (toCInt orientation)  
foreign import ccall "wxFrame_Centre" wxFrame_Centre :: Ptr (TFrame a) -> CInt -> IO ()

-- | usage: (@frameCreate prt id txt lfttopwdthgt stl@).
frameCreate :: Window  a -> Id -> String -> Rect -> Style ->  IO (Frame  ())
frameCreate _prt _id _txt _lfttopwdthgt _stl 
  = withObjectResult $
    withObjectPtr _prt $ \cobj__prt -> 
    withStringPtr _txt $ \cobj__txt -> 
    wxFrame_Create cobj__prt  (toCInt _id)  cobj__txt  (toCIntRectX _lfttopwdthgt) (toCIntRectY _lfttopwdthgt)(toCIntRectW _lfttopwdthgt) (toCIntRectH _lfttopwdthgt)  (toCInt _stl)  
foreign import ccall "wxFrame_Create" wxFrame_Create :: Ptr (TWindow a) -> CInt -> Ptr (TWxString c) -> CInt -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (TFrame ()))

-- | usage: (@frameCreateStatusBar obj number style@).
frameCreateStatusBar :: Frame  a -> Int -> Int ->  IO (StatusBar  ())
frameCreateStatusBar _obj number style 
  = withObjectResult $
    withObjectRef "frameCreateStatusBar" _obj $ \cobj__obj -> 
    wxFrame_CreateStatusBar cobj__obj  (toCInt number)  (toCInt style)  
foreign import ccall "wxFrame_CreateStatusBar" wxFrame_CreateStatusBar :: Ptr (TFrame a) -> CInt -> CInt -> IO (Ptr (TStatusBar ()))

-- | usage: (@frameCreateToolBar obj style@).
frameCreateToolBar :: Frame  a -> Int ->  IO (ToolBar  ())
frameCreateToolBar _obj style 
  = withObjectResult $
    withObjectRef "frameCreateToolBar" _obj $ \cobj__obj -> 
    wxFrame_CreateToolBar cobj__obj  (toCInt style)  
foreign import ccall "wxFrame_CreateToolBar" wxFrame_CreateToolBar :: Ptr (TFrame a) -> CInt -> IO (Ptr (TToolBar ()))

-- | usage: (@frameGetClientAreaOriginleft obj@).
frameGetClientAreaOriginleft :: Frame  a ->  IO Int
frameGetClientAreaOriginleft _obj 
  = withIntResult $
    withObjectRef "frameGetClientAreaOriginleft" _obj $ \cobj__obj -> 
    wxFrame_GetClientAreaOrigin_left cobj__obj  
foreign import ccall "wxFrame_GetClientAreaOrigin_left" wxFrame_GetClientAreaOrigin_left :: Ptr (TFrame a) -> IO CInt

-- | usage: (@frameGetClientAreaOrigintop obj@).
frameGetClientAreaOrigintop :: Frame  a ->  IO Int
frameGetClientAreaOrigintop _obj 
  = withIntResult $
    withObjectRef "frameGetClientAreaOrigintop" _obj $ \cobj__obj -> 
    wxFrame_GetClientAreaOrigin_top cobj__obj  
foreign import ccall "wxFrame_GetClientAreaOrigin_top" wxFrame_GetClientAreaOrigin_top :: Ptr (TFrame a) -> IO CInt

-- | usage: (@frameGetMenuBar obj@).
frameGetMenuBar :: Frame  a ->  IO (MenuBar  ())
frameGetMenuBar _obj 
  = withObjectResult $
    withObjectRef "frameGetMenuBar" _obj $ \cobj__obj -> 
    wxFrame_GetMenuBar cobj__obj  
foreign import ccall "wxFrame_GetMenuBar" wxFrame_GetMenuBar :: Ptr (TFrame a) -> IO (Ptr (TMenuBar ()))

-- | usage: (@frameGetStatusBar obj@).
frameGetStatusBar :: Frame  a ->  IO (StatusBar  ())
frameGetStatusBar _obj 
  = withObjectResult $
    withObjectRef "frameGetStatusBar" _obj $ \cobj__obj -> 
    wxFrame_GetStatusBar cobj__obj  
foreign import ccall "wxFrame_GetStatusBar" wxFrame_GetStatusBar :: Ptr (TFrame a) -> IO (Ptr (TStatusBar ()))

-- | usage: (@frameGetTitle obj@).
frameGetTitle :: Frame  a ->  IO (String)
frameGetTitle _obj 
  = withManagedStringResult $
    withObjectRef "frameGetTitle" _obj $ \cobj__obj -> 
    wxFrame_GetTitle cobj__obj  
foreign import ccall "wxFrame_GetTitle" wxFrame_GetTitle :: Ptr (TFrame a) -> IO (Ptr (TWxString ()))

-- | usage: (@frameGetToolBar obj@).
frameGetToolBar :: Frame  a ->  IO (ToolBar  ())
frameGetToolBar _obj 
  = withObjectResult $
    withObjectRef "frameGetToolBar" _obj $ \cobj__obj -> 
    wxFrame_GetToolBar cobj__obj  
foreign import ccall "wxFrame_GetToolBar" wxFrame_GetToolBar :: Ptr (TFrame a) -> IO (Ptr (TToolBar ()))

-- | usage: (@frameIsFullScreen self@).
frameIsFullScreen :: Frame  a ->  IO Bool
frameIsFullScreen self 
  = withBoolResult $
    withObjectRef "frameIsFullScreen" self $ \cobj_self -> 
    wxFrame_IsFullScreen cobj_self  
foreign import ccall "wxFrame_IsFullScreen" wxFrame_IsFullScreen :: Ptr (TFrame a) -> IO CBool

-- | usage: (@frameRestore obj@).
frameRestore :: Frame  a ->  IO ()
frameRestore _obj 
  = withObjectRef "frameRestore" _obj $ \cobj__obj -> 
    wxFrame_Restore cobj__obj  
foreign import ccall "wxFrame_Restore" wxFrame_Restore :: Ptr (TFrame a) -> IO ()

-- | usage: (@frameSetMenuBar obj menubar@).
frameSetMenuBar :: Frame  a -> MenuBar  b ->  IO ()
frameSetMenuBar _obj menubar 
  = withObjectRef "frameSetMenuBar" _obj $ \cobj__obj -> 
    withObjectPtr menubar $ \cobj_menubar -> 
    wxFrame_SetMenuBar cobj__obj  cobj_menubar  
foreign import ccall "wxFrame_SetMenuBar" wxFrame_SetMenuBar :: Ptr (TFrame a) -> Ptr (TMenuBar b) -> IO ()

-- | usage: (@frameSetShape self region@).
frameSetShape :: Frame  a -> Region  b ->  IO Bool
frameSetShape self region 
  = withBoolResult $
    withObjectRef "frameSetShape" self $ \cobj_self -> 
    withObjectPtr region $ \cobj_region -> 
    wxFrame_SetShape cobj_self  cobj_region  
foreign import ccall "wxFrame_SetShape" wxFrame_SetShape :: Ptr (TFrame a) -> Ptr (TRegion b) -> IO CBool

-- | usage: (@frameSetStatusBar obj statBar@).
frameSetStatusBar :: Frame  a -> StatusBar  b ->  IO ()
frameSetStatusBar _obj statBar 
  = withObjectRef "frameSetStatusBar" _obj $ \cobj__obj -> 
    withObjectPtr statBar $ \cobj_statBar -> 
    wxFrame_SetStatusBar cobj__obj  cobj_statBar  
foreign import ccall "wxFrame_SetStatusBar" wxFrame_SetStatusBar :: Ptr (TFrame a) -> Ptr (TStatusBar b) -> IO ()

-- | usage: (@frameSetStatusText obj txt number@).
frameSetStatusText :: Frame  a -> String -> Int ->  IO ()
frameSetStatusText _obj _txt _number 
  = withObjectRef "frameSetStatusText" _obj $ \cobj__obj -> 
    withStringPtr _txt $ \cobj__txt -> 
    wxFrame_SetStatusText cobj__obj  cobj__txt  (toCInt _number)  
foreign import ccall "wxFrame_SetStatusText" wxFrame_SetStatusText :: Ptr (TFrame a) -> Ptr (TWxString b) -> CInt -> IO ()

-- | usage: (@frameSetStatusWidths obj n widthsfield@).
frameSetStatusWidths :: Frame  a -> Int -> Ptr  c ->  IO ()
frameSetStatusWidths _obj _n _widthsfield 
  = withObjectRef "frameSetStatusWidths" _obj $ \cobj__obj -> 
    wxFrame_SetStatusWidths cobj__obj  (toCInt _n)  _widthsfield  
foreign import ccall "wxFrame_SetStatusWidths" wxFrame_SetStatusWidths :: Ptr (TFrame a) -> CInt -> Ptr  c -> IO ()

-- | usage: (@frameSetTitle frame txt@).
frameSetTitle :: Frame  a -> String ->  IO ()
frameSetTitle _frame _txt 
  = withObjectRef "frameSetTitle" _frame $ \cobj__frame -> 
    withStringPtr _txt $ \cobj__txt -> 
    wxFrame_SetTitle cobj__frame  cobj__txt  
foreign import ccall "wxFrame_SetTitle" wxFrame_SetTitle :: Ptr (TFrame a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@frameSetToolBar obj toolbar@).
frameSetToolBar :: Frame  a -> ToolBar  b ->  IO ()
frameSetToolBar _obj _toolbar 
  = withObjectRef "frameSetToolBar" _obj $ \cobj__obj -> 
    withObjectPtr _toolbar $ \cobj__toolbar -> 
    wxFrame_SetToolBar cobj__obj  cobj__toolbar  
foreign import ccall "wxFrame_SetToolBar" wxFrame_SetToolBar :: Ptr (TFrame a) -> Ptr (TToolBar b) -> IO ()

-- | usage: (@frameShowFullScreen self show style@).
frameShowFullScreen :: Frame  a -> Bool -> Int ->  IO Bool
frameShowFullScreen self show style 
  = withBoolResult $
    withObjectRef "frameShowFullScreen" self $ \cobj_self -> 
    wxFrame_ShowFullScreen cobj_self  (toCBool show)  (toCInt style)  
foreign import ccall "wxFrame_ShowFullScreen" wxFrame_ShowFullScreen :: Ptr (TFrame a) -> CBool -> CInt -> IO CBool

-- | usage: (@gaugeCreate prt id rng lfttopwdthgt stl@).
gaugeCreate :: Window  a -> Id -> Int -> Rect -> Style ->  IO (Gauge  ())
gaugeCreate _prt _id _rng _lfttopwdthgt _stl 
  = withObjectResult $
    withObjectPtr _prt $ \cobj__prt -> 
    wxGauge_Create cobj__prt  (toCInt _id)  (toCInt _rng)  (toCIntRectX _lfttopwdthgt) (toCIntRectY _lfttopwdthgt)(toCIntRectW _lfttopwdthgt) (toCIntRectH _lfttopwdthgt)  (toCInt _stl)  
foreign import ccall "wxGauge_Create" wxGauge_Create :: Ptr (TWindow a) -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (TGauge ()))

-- | usage: (@gaugeGetBezelFace obj@).
gaugeGetBezelFace :: Gauge  a ->  IO Int
gaugeGetBezelFace _obj 
  = withIntResult $
    withObjectRef "gaugeGetBezelFace" _obj $ \cobj__obj -> 
    wxGauge_GetBezelFace cobj__obj  
foreign import ccall "wxGauge_GetBezelFace" wxGauge_GetBezelFace :: Ptr (TGauge a) -> IO CInt

-- | usage: (@gaugeGetRange obj@).
gaugeGetRange :: Gauge  a ->  IO Int
gaugeGetRange _obj 
  = withIntResult $
    withObjectRef "gaugeGetRange" _obj $ \cobj__obj -> 
    wxGauge_GetRange cobj__obj  
foreign import ccall "wxGauge_GetRange" wxGauge_GetRange :: Ptr (TGauge a) -> IO CInt

-- | usage: (@gaugeGetShadowWidth obj@).
gaugeGetShadowWidth :: Gauge  a ->  IO Int
gaugeGetShadowWidth _obj 
  = withIntResult $
    withObjectRef "gaugeGetShadowWidth" _obj $ \cobj__obj -> 
    wxGauge_GetShadowWidth cobj__obj  
foreign import ccall "wxGauge_GetShadowWidth" wxGauge_GetShadowWidth :: Ptr (TGauge a) -> IO CInt

-- | usage: (@gaugeGetValue obj@).
gaugeGetValue :: Gauge  a ->  IO Int
gaugeGetValue _obj 
  = withIntResult $
    withObjectRef "gaugeGetValue" _obj $ \cobj__obj -> 
    wxGauge_GetValue cobj__obj  
foreign import ccall "wxGauge_GetValue" wxGauge_GetValue :: Ptr (TGauge a) -> IO CInt

-- | usage: (@gaugeSetBezelFace obj w@).
gaugeSetBezelFace :: Gauge  a -> Int ->  IO ()
gaugeSetBezelFace _obj w 
  = withObjectRef "gaugeSetBezelFace" _obj $ \cobj__obj -> 
    wxGauge_SetBezelFace cobj__obj  (toCInt w)  
foreign import ccall "wxGauge_SetBezelFace" wxGauge_SetBezelFace :: Ptr (TGauge a) -> CInt -> IO ()

-- | usage: (@gaugeSetRange obj r@).
gaugeSetRange :: Gauge  a -> Int ->  IO ()
gaugeSetRange _obj r 
  = withObjectRef "gaugeSetRange" _obj $ \cobj__obj -> 
    wxGauge_SetRange cobj__obj  (toCInt r)  
foreign import ccall "wxGauge_SetRange" wxGauge_SetRange :: Ptr (TGauge a) -> CInt -> IO ()

-- | usage: (@gaugeSetShadowWidth obj w@).
gaugeSetShadowWidth :: Gauge  a -> Int ->  IO ()
gaugeSetShadowWidth _obj w 
  = withObjectRef "gaugeSetShadowWidth" _obj $ \cobj__obj -> 
    wxGauge_SetShadowWidth cobj__obj  (toCInt w)  
foreign import ccall "wxGauge_SetShadowWidth" wxGauge_SetShadowWidth :: Ptr (TGauge a) -> CInt -> IO ()

-- | usage: (@gaugeSetValue obj pos@).
gaugeSetValue :: Gauge  a -> Int ->  IO ()
gaugeSetValue _obj pos 
  = withObjectRef "gaugeSetValue" _obj $ \cobj__obj -> 
    wxGauge_SetValue cobj__obj  (toCInt pos)  
foreign import ccall "wxGauge_SetValue" wxGauge_SetValue :: Ptr (TGauge a) -> CInt -> IO ()

-- | usage: (@genericDragIcon icon@).
genericDragIcon :: Icon  a ->  IO (GenericDragImage  ())
genericDragIcon icon 
  = withObjectResult $
    withObjectPtr icon $ \cobj_icon -> 
    wx_wxGenericDragIcon cobj_icon  
foreign import ccall "wxGenericDragIcon" wx_wxGenericDragIcon :: Ptr (TIcon a) -> IO (Ptr (TGenericDragImage ()))

-- | usage: (@genericDragImageCreate cursor@).
genericDragImageCreate :: Cursor  a ->  IO (GenericDragImage  ())
genericDragImageCreate cursor 
  = withObjectResult $
    withObjectPtr cursor $ \cobj_cursor -> 
    wxGenericDragImage_Create cobj_cursor  
foreign import ccall "wxGenericDragImage_Create" wxGenericDragImage_Create :: Ptr (TCursor a) -> IO (Ptr (TGenericDragImage ()))

-- | usage: (@genericDragImageDoDrawImage self dc xy@).
genericDragImageDoDrawImage :: GenericDragImage  a -> DC  b -> Point ->  IO Bool
genericDragImageDoDrawImage self dc xy 
  = withBoolResult $
    withObjectRef "genericDragImageDoDrawImage" self $ \cobj_self -> 
    withObjectPtr dc $ \cobj_dc -> 
    wxGenericDragImage_DoDrawImage cobj_self  cobj_dc  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxGenericDragImage_DoDrawImage" wxGenericDragImage_DoDrawImage :: Ptr (TGenericDragImage a) -> Ptr (TDC b) -> CInt -> CInt -> IO CBool

-- | usage: (@genericDragImageGetImageRect self xposypos@).
genericDragImageGetImageRect :: GenericDragImage  a -> Point ->  IO (Rect)
genericDragImageGetImageRect self xposypos 
  = withWxRectResult $
    withObjectRef "genericDragImageGetImageRect" self $ \cobj_self -> 
    wxGenericDragImage_GetImageRect cobj_self  (toCIntPointX xposypos) (toCIntPointY xposypos)  
foreign import ccall "wxGenericDragImage_GetImageRect" wxGenericDragImage_GetImageRect :: Ptr (TGenericDragImage a) -> CInt -> CInt -> IO (Ptr (TWxRect ()))

-- | usage: (@genericDragImageUpdateBackingFromWindow self windowDC destDC xywh xdestydestwidthheight@).
genericDragImageUpdateBackingFromWindow :: GenericDragImage  a -> DC  b -> MemoryDC  c -> Rect -> Rect ->  IO Bool
genericDragImageUpdateBackingFromWindow self windowDC destDC xywh xdestydestwidthheight 
  = withBoolResult $
    withObjectRef "genericDragImageUpdateBackingFromWindow" self $ \cobj_self -> 
    withObjectPtr windowDC $ \cobj_windowDC -> 
    withObjectPtr destDC $ \cobj_destDC -> 
    wxGenericDragImage_UpdateBackingFromWindow cobj_self  cobj_windowDC  cobj_destDC  (toCIntRectX xywh) (toCIntRectY xywh)(toCIntRectW xywh) (toCIntRectH xywh)  (toCIntRectX xdestydestwidthheight) (toCIntRectY xdestydestwidthheight)(toCIntRectW xdestydestwidthheight) (toCIntRectH xdestydestwidthheight)  
foreign import ccall "wxGenericDragImage_UpdateBackingFromWindow" wxGenericDragImage_UpdateBackingFromWindow :: Ptr (TGenericDragImage a) -> Ptr (TDC b) -> Ptr (TMemoryDC c) -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO CBool

-- | usage: (@genericDragListItem treeCtrl id@).
genericDragListItem :: ListCtrl  a -> Id ->  IO (GenericDragImage  ())
genericDragListItem treeCtrl id 
  = withObjectResult $
    withObjectPtr treeCtrl $ \cobj_treeCtrl -> 
    wx_wxGenericDragListItem cobj_treeCtrl  (toCInt id)  
foreign import ccall "wxGenericDragListItem" wx_wxGenericDragListItem :: Ptr (TListCtrl a) -> CInt -> IO (Ptr (TGenericDragImage ()))

-- | usage: (@genericDragString test@).
genericDragString :: String ->  IO (GenericDragImage  ())
genericDragString test 
  = withObjectResult $
    withStringPtr test $ \cobj_test -> 
    wx_wxGenericDragString cobj_test  
foreign import ccall "wxGenericDragString" wx_wxGenericDragString :: Ptr (TWxString a) -> IO (Ptr (TGenericDragImage ()))

-- | usage: (@genericDragTreeItem treeCtrl id@).
genericDragTreeItem :: TreeCtrl  a -> TreeItem ->  IO (GenericDragImage  ())
genericDragTreeItem treeCtrl id 
  = withObjectResult $
    withObjectPtr treeCtrl $ \cobj_treeCtrl -> 
    withTreeItemIdPtr id $ \cobj_id -> 
    wx_wxGenericDragTreeItem cobj_treeCtrl  cobj_id  
foreign import ccall "wxGenericDragTreeItem" wx_wxGenericDragTreeItem :: Ptr (TTreeCtrl a) -> Ptr (TTreeItemId b) -> IO (Ptr (TGenericDragImage ()))

{- |  Return the directory of the application. On unix systems (except MacOS X), it is not always possible to determine this correctly. Therefore, the APPDIR environment variable is returned first if it is defined. * -}
getApplicationDir ::  IO (String)
getApplicationDir 
  = withManagedStringResult $
    wx_wxGetApplicationDir 
foreign import ccall "wxGetApplicationDir" wx_wxGetApplicationDir :: IO (Ptr (TWxString ()))

{- |  Return the full path of the application. On unix systems (except MacOS X), it is not always possible to determine this correctly. * -}
getApplicationPath ::  IO (String)
getApplicationPath 
  = withManagedStringResult $
    wx_wxGetApplicationPath 
foreign import ccall "wxGetApplicationPath" wx_wxGetApplicationPath :: IO (Ptr (TWxString ()))

-- | usage: (@getColourFromUser parent colInit@).
getColourFromUser :: Window  a -> Color ->  IO (Color)
getColourFromUser parent colInit 
  = withRefColour $ \pref -> 
    withObjectPtr parent $ \cobj_parent -> 
    withColourPtr colInit $ \cobj_colInit -> 
    wx_wxGetColourFromUser cobj_parent  cobj_colInit   pref
foreign import ccall "wxGetColourFromUser" wx_wxGetColourFromUser :: Ptr (TWindow a) -> Ptr (TColour b) -> Ptr (TColour ()) -> IO ()

-- | usage: (@getELJLocale@).
getELJLocale ::  IO (WXCLocale  ())
getELJLocale 
  = withObjectResult $
    wx_wxGetELJLocale 
foreign import ccall "wxGetELJLocale" wx_wxGetELJLocale :: IO (Ptr (TWXCLocale ()))

-- | usage: (@getELJTranslation sz@).
getELJTranslation :: String ->  IO (Ptr  ())
getELJTranslation sz 
  = withCWString sz $ \cstr_sz -> 
    wx_wxGetELJTranslation cstr_sz  
foreign import ccall "wxGetELJTranslation" wx_wxGetELJTranslation :: CWString -> IO (Ptr  ())

-- | usage: (@getFontFromUser parent fontInit@).
getFontFromUser :: Window  a -> Font  b ->  IO (Font  ())
getFontFromUser parent fontInit 
  = withRefFont $ \pref -> 
    withObjectPtr parent $ \cobj_parent -> 
    withObjectPtr fontInit $ \cobj_fontInit -> 
    wx_wxGetFontFromUser cobj_parent  cobj_fontInit   pref
foreign import ccall "wxGetFontFromUser" wx_wxGetFontFromUser :: Ptr (TWindow a) -> Ptr (TFont b) -> Ptr (TFont ()) -> IO ()

-- | usage: (@getNumberFromUser message prompt caption value min max parent xy@).
getNumberFromUser :: String -> String -> String -> Int -> Int -> Int -> Window  g -> Point ->  IO Int
getNumberFromUser message prompt caption value min max parent xy 
  = withIntResult $
    withStringPtr message $ \cobj_message -> 
    withStringPtr prompt $ \cobj_prompt -> 
    withStringPtr caption $ \cobj_caption -> 
    withObjectPtr parent $ \cobj_parent -> 
    wx_wxGetNumberFromUser cobj_message  cobj_prompt  cobj_caption  (toCInt value)  (toCInt min)  (toCInt max)  cobj_parent  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxGetNumberFromUser" wx_wxGetNumberFromUser :: Ptr (TWxString a) -> Ptr (TWxString b) -> Ptr (TWxString c) -> CInt -> CInt -> CInt -> Ptr (TWindow g) -> CInt -> CInt -> IO CInt

-- | usage: (@getPasswordFromUser message caption defaultText parent@).
getPasswordFromUser :: String -> String -> String -> Window  d ->  IO String
getPasswordFromUser message caption defaultText parent 
  = withWStringResult $ \buffer -> 
    withCWString message $ \cstr_message -> 
    withCWString caption $ \cstr_caption -> 
    withCWString defaultText $ \cstr_defaultText -> 
    withObjectPtr parent $ \cobj_parent -> 
    wx_wxGetPasswordFromUser cstr_message  cstr_caption  cstr_defaultText  cobj_parent   buffer
foreign import ccall "wxGetPasswordFromUser" wx_wxGetPasswordFromUser :: CWString -> CWString -> CWString -> Ptr (TWindow d) -> Ptr CWchar -> IO CInt

-- | usage: (@getTextFromUser message caption defaultText parent xy center@).
getTextFromUser :: String -> String -> String -> Window  d -> Point -> Bool ->  IO String
getTextFromUser message caption defaultText parent xy center 
  = withWStringResult $ \buffer -> 
    withCWString message $ \cstr_message -> 
    withCWString caption $ \cstr_caption -> 
    withCWString defaultText $ \cstr_defaultText -> 
    withObjectPtr parent $ \cobj_parent -> 
    wx_wxGetTextFromUser cstr_message  cstr_caption  cstr_defaultText  cobj_parent  (toCIntPointX xy) (toCIntPointY xy)  (toCBool center)   buffer
foreign import ccall "wxGetTextFromUser" wx_wxGetTextFromUser :: CWString -> CWString -> CWString -> Ptr (TWindow d) -> CInt -> CInt -> CBool -> Ptr CWchar -> IO CInt

-- | usage: (@graphicsBrushCreate@).
graphicsBrushCreate ::  IO (GraphicsBrush  ())
graphicsBrushCreate 
  = withObjectResult $
    wxGraphicsBrush_Create 
foreign import ccall "wxGraphicsBrush_Create" wxGraphicsBrush_Create :: IO (Ptr (TGraphicsBrush ()))

-- | usage: (@graphicsBrushDelete self@).
graphicsBrushDelete :: GraphicsBrush  a ->  IO ()
graphicsBrushDelete
  = objectDelete


-- | usage: (@graphicsContextClip self region@).
graphicsContextClip :: GraphicsContext  a -> Region  b ->  IO ()
graphicsContextClip self region 
  = withObjectRef "graphicsContextClip" self $ \cobj_self -> 
    withObjectPtr region $ \cobj_region -> 
    wxGraphicsContext_Clip cobj_self  cobj_region  
foreign import ccall "wxGraphicsContext_Clip" wxGraphicsContext_Clip :: Ptr (TGraphicsContext a) -> Ptr (TRegion b) -> IO ()

-- | usage: (@graphicsContextClipByRectangle self xywh@).
graphicsContextClipByRectangle :: GraphicsContext  a -> (Rect2D Double) ->  IO ()
graphicsContextClipByRectangle self xywh 
  = withObjectRef "graphicsContextClipByRectangle" self $ \cobj_self -> 
    wxGraphicsContext_ClipByRectangle cobj_self  (toCDoubleRectX xywh) (toCDoubleRectY xywh)(toCDoubleRectW xywh) (toCDoubleRectH xywh)  
foreign import ccall "wxGraphicsContext_ClipByRectangle" wxGraphicsContext_ClipByRectangle :: Ptr (TGraphicsContext a) -> CDouble -> CDouble -> CDouble -> CDouble -> IO ()

-- | usage: (@graphicsContextConcatTransform self path@).
graphicsContextConcatTransform :: GraphicsContext  a -> GraphicsMatrix  b ->  IO ()
graphicsContextConcatTransform self path 
  = withObjectRef "graphicsContextConcatTransform" self $ \cobj_self -> 
    withObjectPtr path $ \cobj_path -> 
    wxGraphicsContext_ConcatTransform cobj_self  cobj_path  
foreign import ccall "wxGraphicsContext_ConcatTransform" wxGraphicsContext_ConcatTransform :: Ptr (TGraphicsContext a) -> Ptr (TGraphicsMatrix b) -> IO ()

-- | usage: (@graphicsContextCreate dc@).
graphicsContextCreate :: WindowDC  a ->  IO (GraphicsContext  ())
graphicsContextCreate dc 
  = withObjectResult $
    withObjectPtr dc $ \cobj_dc -> 
    wxGraphicsContext_Create cobj_dc  
foreign import ccall "wxGraphicsContext_Create" wxGraphicsContext_Create :: Ptr (TWindowDC a) -> IO (Ptr (TGraphicsContext ()))

-- | usage: (@graphicsContextCreateFromNative context@).
graphicsContextCreateFromNative :: GraphicsContext  a ->  IO (GraphicsContext  ())
graphicsContextCreateFromNative context 
  = withObjectResult $
    withObjectRef "graphicsContextCreateFromNative" context $ \cobj_context -> 
    wxGraphicsContext_CreateFromNative cobj_context  
foreign import ccall "wxGraphicsContext_CreateFromNative" wxGraphicsContext_CreateFromNative :: Ptr (TGraphicsContext a) -> IO (Ptr (TGraphicsContext ()))

-- | usage: (@graphicsContextCreateFromNativeWindow window@).
graphicsContextCreateFromNativeWindow :: Window  a ->  IO (GraphicsContext  ())
graphicsContextCreateFromNativeWindow window 
  = withObjectResult $
    withObjectPtr window $ \cobj_window -> 
    wxGraphicsContext_CreateFromNativeWindow cobj_window  
foreign import ccall "wxGraphicsContext_CreateFromNativeWindow" wxGraphicsContext_CreateFromNativeWindow :: Ptr (TWindow a) -> IO (Ptr (TGraphicsContext ()))

-- | usage: (@graphicsContextCreateFromWindow window@).
graphicsContextCreateFromWindow :: Window  a ->  IO (GraphicsContext  ())
graphicsContextCreateFromWindow window 
  = withObjectResult $
    withObjectPtr window $ \cobj_window -> 
    wxGraphicsContext_CreateFromWindow cobj_window  
foreign import ccall "wxGraphicsContext_CreateFromWindow" wxGraphicsContext_CreateFromWindow :: Ptr (TWindow a) -> IO (Ptr (TGraphicsContext ()))

-- | usage: (@graphicsContextDelete self@).
graphicsContextDelete :: GraphicsContext  a ->  IO ()
graphicsContextDelete
  = objectDelete


-- | usage: (@graphicsContextDrawBitmap self bmp xywh@).
graphicsContextDrawBitmap :: GraphicsContext  a -> Bitmap  b -> (Rect2D Double) ->  IO ()
graphicsContextDrawBitmap self bmp xywh 
  = withObjectRef "graphicsContextDrawBitmap" self $ \cobj_self -> 
    withObjectPtr bmp $ \cobj_bmp -> 
    wxGraphicsContext_DrawBitmap cobj_self  cobj_bmp  (toCDoubleRectX xywh) (toCDoubleRectY xywh)(toCDoubleRectW xywh) (toCDoubleRectH xywh)  
foreign import ccall "wxGraphicsContext_DrawBitmap" wxGraphicsContext_DrawBitmap :: Ptr (TGraphicsContext a) -> Ptr (TBitmap b) -> CDouble -> CDouble -> CDouble -> CDouble -> IO ()

-- | usage: (@graphicsContextDrawEllipse self xywh@).
graphicsContextDrawEllipse :: GraphicsContext  a -> (Rect2D Double) ->  IO ()
graphicsContextDrawEllipse self xywh 
  = withObjectRef "graphicsContextDrawEllipse" self $ \cobj_self -> 
    wxGraphicsContext_DrawEllipse cobj_self  (toCDoubleRectX xywh) (toCDoubleRectY xywh)(toCDoubleRectW xywh) (toCDoubleRectH xywh)  
foreign import ccall "wxGraphicsContext_DrawEllipse" wxGraphicsContext_DrawEllipse :: Ptr (TGraphicsContext a) -> CDouble -> CDouble -> CDouble -> CDouble -> IO ()

-- | usage: (@graphicsContextDrawIcon self icon xywh@).
graphicsContextDrawIcon :: GraphicsContext  a -> Icon  b -> (Rect2D Double) ->  IO ()
graphicsContextDrawIcon self icon xywh 
  = withObjectRef "graphicsContextDrawIcon" self $ \cobj_self -> 
    withObjectPtr icon $ \cobj_icon -> 
    wxGraphicsContext_DrawIcon cobj_self  cobj_icon  (toCDoubleRectX xywh) (toCDoubleRectY xywh)(toCDoubleRectW xywh) (toCDoubleRectH xywh)  
foreign import ccall "wxGraphicsContext_DrawIcon" wxGraphicsContext_DrawIcon :: Ptr (TGraphicsContext a) -> Ptr (TIcon b) -> CDouble -> CDouble -> CDouble -> CDouble -> IO ()

-- | usage: (@graphicsContextDrawLines self n x y style@).
graphicsContextDrawLines :: GraphicsContext  a -> Int -> Ptr  c -> Ptr  d -> Int ->  IO ()
graphicsContextDrawLines self n x y style 
  = withObjectRef "graphicsContextDrawLines" self $ \cobj_self -> 
    wxGraphicsContext_DrawLines cobj_self  (toCInt n)  x  y  (toCInt style)  
foreign import ccall "wxGraphicsContext_DrawLines" wxGraphicsContext_DrawLines :: Ptr (TGraphicsContext a) -> CInt -> Ptr  c -> Ptr  d -> CInt -> IO ()

-- | usage: (@graphicsContextDrawPath self path style@).
graphicsContextDrawPath :: GraphicsContext  a -> GraphicsPath  b -> Int ->  IO ()
graphicsContextDrawPath self path style 
  = withObjectRef "graphicsContextDrawPath" self $ \cobj_self -> 
    withObjectPtr path $ \cobj_path -> 
    wxGraphicsContext_DrawPath cobj_self  cobj_path  (toCInt style)  
foreign import ccall "wxGraphicsContext_DrawPath" wxGraphicsContext_DrawPath :: Ptr (TGraphicsContext a) -> Ptr (TGraphicsPath b) -> CInt -> IO ()

-- | usage: (@graphicsContextDrawRectangle self xywh@).
graphicsContextDrawRectangle :: GraphicsContext  a -> (Rect2D Double) ->  IO ()
graphicsContextDrawRectangle self xywh 
  = withObjectRef "graphicsContextDrawRectangle" self $ \cobj_self -> 
    wxGraphicsContext_DrawRectangle cobj_self  (toCDoubleRectX xywh) (toCDoubleRectY xywh)(toCDoubleRectW xywh) (toCDoubleRectH xywh)  
foreign import ccall "wxGraphicsContext_DrawRectangle" wxGraphicsContext_DrawRectangle :: Ptr (TGraphicsContext a) -> CDouble -> CDouble -> CDouble -> CDouble -> IO ()

-- | usage: (@graphicsContextDrawRoundedRectangle self xywh radius@).
graphicsContextDrawRoundedRectangle :: GraphicsContext  a -> (Rect2D Double) -> Double ->  IO ()
graphicsContextDrawRoundedRectangle self xywh radius 
  = withObjectRef "graphicsContextDrawRoundedRectangle" self $ \cobj_self -> 
    wxGraphicsContext_DrawRoundedRectangle cobj_self  (toCDoubleRectX xywh) (toCDoubleRectY xywh)(toCDoubleRectW xywh) (toCDoubleRectH xywh)  radius  
foreign import ccall "wxGraphicsContext_DrawRoundedRectangle" wxGraphicsContext_DrawRoundedRectangle :: Ptr (TGraphicsContext a) -> CDouble -> CDouble -> CDouble -> CDouble -> Double -> IO ()

-- | usage: (@graphicsContextDrawText self text xy@).
graphicsContextDrawText :: GraphicsContext  a -> String -> (Point2 Double) ->  IO ()
graphicsContextDrawText self text xy 
  = withObjectRef "graphicsContextDrawText" self $ \cobj_self -> 
    withStringPtr text $ \cobj_text -> 
    wxGraphicsContext_DrawText cobj_self  cobj_text  (toCDoublePointX xy) (toCDoublePointY xy)  
foreign import ccall "wxGraphicsContext_DrawText" wxGraphicsContext_DrawText :: Ptr (TGraphicsContext a) -> Ptr (TWxString b) -> CDouble -> CDouble -> IO ()

-- | usage: (@graphicsContextDrawTextWithAngle self text xy radius@).
graphicsContextDrawTextWithAngle :: GraphicsContext  a -> String -> (Point2 Double) -> Double ->  IO ()
graphicsContextDrawTextWithAngle self text xy radius 
  = withObjectRef "graphicsContextDrawTextWithAngle" self $ \cobj_self -> 
    withStringPtr text $ \cobj_text -> 
    wxGraphicsContext_DrawTextWithAngle cobj_self  cobj_text  (toCDoublePointX xy) (toCDoublePointY xy)  radius  
foreign import ccall "wxGraphicsContext_DrawTextWithAngle" wxGraphicsContext_DrawTextWithAngle :: Ptr (TGraphicsContext a) -> Ptr (TWxString b) -> CDouble -> CDouble -> Double -> IO ()

-- | usage: (@graphicsContextFillPath self path style@).
graphicsContextFillPath :: GraphicsContext  a -> GraphicsPath  b -> Int ->  IO ()
graphicsContextFillPath self path style 
  = withObjectRef "graphicsContextFillPath" self $ \cobj_self -> 
    withObjectPtr path $ \cobj_path -> 
    wxGraphicsContext_FillPath cobj_self  cobj_path  (toCInt style)  
foreign import ccall "wxGraphicsContext_FillPath" wxGraphicsContext_FillPath :: Ptr (TGraphicsContext a) -> Ptr (TGraphicsPath b) -> CInt -> IO ()

-- | usage: (@graphicsContextGetNativeContext self@).
graphicsContextGetNativeContext :: GraphicsContext  a ->  IO (Ptr  ())
graphicsContextGetNativeContext self 
  = withObjectRef "graphicsContextGetNativeContext" self $ \cobj_self -> 
    wxGraphicsContext_GetNativeContext cobj_self  
foreign import ccall "wxGraphicsContext_GetNativeContext" wxGraphicsContext_GetNativeContext :: Ptr (TGraphicsContext a) -> IO (Ptr  ())

-- | usage: (@graphicsContextGetTextExtent self text width height descent externalLeading@).
graphicsContextGetTextExtent :: GraphicsContext  a -> String -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double ->  IO ()
graphicsContextGetTextExtent self text width height descent externalLeading 
  = withObjectRef "graphicsContextGetTextExtent" self $ \cobj_self -> 
    withStringPtr text $ \cobj_text -> 
    wxGraphicsContext_GetTextExtent cobj_self  cobj_text  width  height  descent  externalLeading  
foreign import ccall "wxGraphicsContext_GetTextExtent" wxGraphicsContext_GetTextExtent :: Ptr (TGraphicsContext a) -> Ptr (TWxString b) -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> IO ()

-- | usage: (@graphicsContextResetClip self@).
graphicsContextResetClip :: GraphicsContext  a ->  IO ()
graphicsContextResetClip self 
  = withObjectRef "graphicsContextResetClip" self $ \cobj_self -> 
    wxGraphicsContext_ResetClip cobj_self  
foreign import ccall "wxGraphicsContext_ResetClip" wxGraphicsContext_ResetClip :: Ptr (TGraphicsContext a) -> IO ()

-- | usage: (@graphicsContextRotate self angle@).
graphicsContextRotate :: GraphicsContext  a -> Double ->  IO ()
graphicsContextRotate self angle 
  = withObjectRef "graphicsContextRotate" self $ \cobj_self -> 
    wxGraphicsContext_Rotate cobj_self  angle  
foreign import ccall "wxGraphicsContext_Rotate" wxGraphicsContext_Rotate :: Ptr (TGraphicsContext a) -> Double -> IO ()

-- | usage: (@graphicsContextScale self xScaleyScale@).
graphicsContextScale :: GraphicsContext  a -> (Size2D Double) ->  IO ()
graphicsContextScale self xScaleyScale 
  = withObjectRef "graphicsContextScale" self $ \cobj_self -> 
    wxGraphicsContext_Scale cobj_self  (toCDoubleSizeW xScaleyScale) (toCDoubleSizeH xScaleyScale)  
foreign import ccall "wxGraphicsContext_Scale" wxGraphicsContext_Scale :: Ptr (TGraphicsContext a) -> CDouble -> CDouble -> IO ()

-- | usage: (@graphicsContextSetBrush self brush@).
graphicsContextSetBrush :: GraphicsContext  a -> Brush  b ->  IO ()
graphicsContextSetBrush self brush 
  = withObjectRef "graphicsContextSetBrush" self $ \cobj_self -> 
    withObjectPtr brush $ \cobj_brush -> 
    wxGraphicsContext_SetBrush cobj_self  cobj_brush  
foreign import ccall "wxGraphicsContext_SetBrush" wxGraphicsContext_SetBrush :: Ptr (TGraphicsContext a) -> Ptr (TBrush b) -> IO ()

-- | usage: (@graphicsContextSetFont self font colour@).
graphicsContextSetFont :: GraphicsContext  a -> Font  b -> Color ->  IO ()
graphicsContextSetFont self font colour 
  = withObjectRef "graphicsContextSetFont" self $ \cobj_self -> 
    withObjectPtr font $ \cobj_font -> 
    withColourPtr colour $ \cobj_colour -> 
    wxGraphicsContext_SetFont cobj_self  cobj_font  cobj_colour  
foreign import ccall "wxGraphicsContext_SetFont" wxGraphicsContext_SetFont :: Ptr (TGraphicsContext a) -> Ptr (TFont b) -> Ptr (TColour c) -> IO ()

-- | usage: (@graphicsContextSetGraphicsBrush self brush@).
graphicsContextSetGraphicsBrush :: GraphicsContext  a -> GraphicsBrush  b ->  IO ()
graphicsContextSetGraphicsBrush self brush 
  = withObjectRef "graphicsContextSetGraphicsBrush" self $ \cobj_self -> 
    withObjectPtr brush $ \cobj_brush -> 
    wxGraphicsContext_SetGraphicsBrush cobj_self  cobj_brush  
foreign import ccall "wxGraphicsContext_SetGraphicsBrush" wxGraphicsContext_SetGraphicsBrush :: Ptr (TGraphicsContext a) -> Ptr (TGraphicsBrush b) -> IO ()

-- | usage: (@graphicsContextSetGraphicsFont self font@).
graphicsContextSetGraphicsFont :: GraphicsContext  a -> GraphicsFont  b ->  IO ()
graphicsContextSetGraphicsFont self font 
  = withObjectRef "graphicsContextSetGraphicsFont" self $ \cobj_self -> 
    withObjectPtr font $ \cobj_font -> 
    wxGraphicsContext_SetGraphicsFont cobj_self  cobj_font  
foreign import ccall "wxGraphicsContext_SetGraphicsFont" wxGraphicsContext_SetGraphicsFont :: Ptr (TGraphicsContext a) -> Ptr (TGraphicsFont b) -> IO ()

-- | usage: (@graphicsContextSetGraphicsPen self pen@).
graphicsContextSetGraphicsPen :: GraphicsContext  a -> GraphicsPen  b ->  IO ()
graphicsContextSetGraphicsPen self pen 
  = withObjectRef "graphicsContextSetGraphicsPen" self $ \cobj_self -> 
    withObjectPtr pen $ \cobj_pen -> 
    wxGraphicsContext_SetGraphicsPen cobj_self  cobj_pen  
foreign import ccall "wxGraphicsContext_SetGraphicsPen" wxGraphicsContext_SetGraphicsPen :: Ptr (TGraphicsContext a) -> Ptr (TGraphicsPen b) -> IO ()

-- | usage: (@graphicsContextSetPen self pen@).
graphicsContextSetPen :: GraphicsContext  a -> Pen  b ->  IO ()
graphicsContextSetPen self pen 
  = withObjectRef "graphicsContextSetPen" self $ \cobj_self -> 
    withObjectPtr pen $ \cobj_pen -> 
    wxGraphicsContext_SetPen cobj_self  cobj_pen  
foreign import ccall "wxGraphicsContext_SetPen" wxGraphicsContext_SetPen :: Ptr (TGraphicsContext a) -> Ptr (TPen b) -> IO ()

-- | usage: (@graphicsContextSetTransform self path@).
graphicsContextSetTransform :: GraphicsContext  a -> GraphicsMatrix  b ->  IO ()
graphicsContextSetTransform self path 
  = withObjectRef "graphicsContextSetTransform" self $ \cobj_self -> 
    withObjectPtr path $ \cobj_path -> 
    wxGraphicsContext_SetTransform cobj_self  cobj_path  
foreign import ccall "wxGraphicsContext_SetTransform" wxGraphicsContext_SetTransform :: Ptr (TGraphicsContext a) -> Ptr (TGraphicsMatrix b) -> IO ()

-- | usage: (@graphicsContextStrokeLine self x1y1 x2y2@).
graphicsContextStrokeLine :: GraphicsContext  a -> (Point2 Double) -> (Point2 Double) ->  IO ()
graphicsContextStrokeLine self x1y1 x2y2 
  = withObjectRef "graphicsContextStrokeLine" self $ \cobj_self -> 
    wxGraphicsContext_StrokeLine cobj_self  (toCDoublePointX x1y1) (toCDoublePointY x1y1)  (toCDoublePointX x2y2) (toCDoublePointY x2y2)  
foreign import ccall "wxGraphicsContext_StrokeLine" wxGraphicsContext_StrokeLine :: Ptr (TGraphicsContext a) -> CDouble -> CDouble -> CDouble -> CDouble -> IO ()

-- | usage: (@graphicsContextStrokeLines self n x y style@).
graphicsContextStrokeLines :: GraphicsContext  a -> Int -> Ptr  c -> Ptr  d -> Int ->  IO ()
graphicsContextStrokeLines self n x y style 
  = withObjectRef "graphicsContextStrokeLines" self $ \cobj_self -> 
    wxGraphicsContext_StrokeLines cobj_self  (toCInt n)  x  y  (toCInt style)  
foreign import ccall "wxGraphicsContext_StrokeLines" wxGraphicsContext_StrokeLines :: Ptr (TGraphicsContext a) -> CInt -> Ptr  c -> Ptr  d -> CInt -> IO ()

-- | usage: (@graphicsContextStrokePath self path@).
graphicsContextStrokePath :: GraphicsContext  a -> GraphicsPath  b ->  IO ()
graphicsContextStrokePath self path 
  = withObjectRef "graphicsContextStrokePath" self $ \cobj_self -> 
    withObjectPtr path $ \cobj_path -> 
    wxGraphicsContext_StrokePath cobj_self  cobj_path  
foreign import ccall "wxGraphicsContext_StrokePath" wxGraphicsContext_StrokePath :: Ptr (TGraphicsContext a) -> Ptr (TGraphicsPath b) -> IO ()

-- | usage: (@graphicsContextTranslate self dx dy@).
graphicsContextTranslate :: GraphicsContext  a -> Double -> Double ->  IO ()
graphicsContextTranslate self dx dy 
  = withObjectRef "graphicsContextTranslate" self $ \cobj_self -> 
    wxGraphicsContext_Translate cobj_self  dx  dy  
foreign import ccall "wxGraphicsContext_Translate" wxGraphicsContext_Translate :: Ptr (TGraphicsContext a) -> Double -> Double -> IO ()

-- | usage: (@graphicsFontCreate@).
graphicsFontCreate ::  IO (GraphicsFont  ())
graphicsFontCreate 
  = withObjectResult $
    wxGraphicsFont_Create 
foreign import ccall "wxGraphicsFont_Create" wxGraphicsFont_Create :: IO (Ptr (TGraphicsFont ()))

-- | usage: (@graphicsFontDelete self@).
graphicsFontDelete :: GraphicsFont  a ->  IO ()
graphicsFontDelete
  = objectDelete


-- | usage: (@graphicsMatrixConcat self t@).
graphicsMatrixConcat :: GraphicsMatrix  a -> GraphicsMatrix  b ->  IO ()
graphicsMatrixConcat self t 
  = withObjectRef "graphicsMatrixConcat" self $ \cobj_self -> 
    withObjectPtr t $ \cobj_t -> 
    wxGraphicsMatrix_Concat cobj_self  cobj_t  
foreign import ccall "wxGraphicsMatrix_Concat" wxGraphicsMatrix_Concat :: Ptr (TGraphicsMatrix a) -> Ptr (TGraphicsMatrix b) -> IO ()

-- | usage: (@graphicsMatrixCreate@).
graphicsMatrixCreate ::  IO (GraphicsMatrix  ())
graphicsMatrixCreate 
  = withObjectResult $
    wxGraphicsMatrix_Create 
foreign import ccall "wxGraphicsMatrix_Create" wxGraphicsMatrix_Create :: IO (Ptr (TGraphicsMatrix ()))

-- | usage: (@graphicsMatrixDelete self@).
graphicsMatrixDelete :: GraphicsMatrix  a ->  IO ()
graphicsMatrixDelete
  = objectDelete


-- | usage: (@graphicsMatrixGet self a b c d tx ty@).
graphicsMatrixGet :: GraphicsMatrix  a -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double ->  IO ()
graphicsMatrixGet self a b c d tx ty 
  = withObjectRef "graphicsMatrixGet" self $ \cobj_self -> 
    wxGraphicsMatrix_Get cobj_self  a  b  c  d  tx  ty  
foreign import ccall "wxGraphicsMatrix_Get" wxGraphicsMatrix_Get :: Ptr (TGraphicsMatrix a) -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> Ptr Double -> IO ()

-- | usage: (@graphicsMatrixGetNativeMatrix self@).
graphicsMatrixGetNativeMatrix :: GraphicsMatrix  a ->  IO (Ptr  ())
graphicsMatrixGetNativeMatrix self 
  = withObjectRef "graphicsMatrixGetNativeMatrix" self $ \cobj_self -> 
    wxGraphicsMatrix_GetNativeMatrix cobj_self  
foreign import ccall "wxGraphicsMatrix_GetNativeMatrix" wxGraphicsMatrix_GetNativeMatrix :: Ptr (TGraphicsMatrix a) -> IO (Ptr  ())

-- | usage: (@graphicsMatrixInvert self@).
graphicsMatrixInvert :: GraphicsMatrix  a ->  IO ()
graphicsMatrixInvert self 
  = withObjectRef "graphicsMatrixInvert" self $ \cobj_self -> 
    wxGraphicsMatrix_Invert cobj_self  
foreign import ccall "wxGraphicsMatrix_Invert" wxGraphicsMatrix_Invert :: Ptr (TGraphicsMatrix a) -> IO ()

-- | usage: (@graphicsMatrixIsEqual self t@).
graphicsMatrixIsEqual :: GraphicsMatrix  a -> GraphicsMatrix  b ->  IO Bool
graphicsMatrixIsEqual self t 
  = withBoolResult $
    withObjectRef "graphicsMatrixIsEqual" self $ \cobj_self -> 
    withObjectPtr t $ \cobj_t -> 
    wxGraphicsMatrix_IsEqual cobj_self  cobj_t  
foreign import ccall "wxGraphicsMatrix_IsEqual" wxGraphicsMatrix_IsEqual :: Ptr (TGraphicsMatrix a) -> Ptr (TGraphicsMatrix b) -> IO CBool

-- | usage: (@graphicsMatrixIsIdentity self@).
graphicsMatrixIsIdentity :: GraphicsMatrix  a ->  IO Bool
graphicsMatrixIsIdentity self 
  = withBoolResult $
    withObjectRef "graphicsMatrixIsIdentity" self $ \cobj_self -> 
    wxGraphicsMatrix_IsIdentity cobj_self  
foreign import ccall "wxGraphicsMatrix_IsIdentity" wxGraphicsMatrix_IsIdentity :: Ptr (TGraphicsMatrix a) -> IO CBool

-- | usage: (@graphicsMatrixRotate self angle@).
graphicsMatrixRotate :: GraphicsMatrix  a -> Double ->  IO ()
graphicsMatrixRotate self angle 
  = withObjectRef "graphicsMatrixRotate" self $ \cobj_self -> 
    wxGraphicsMatrix_Rotate cobj_self  angle  
foreign import ccall "wxGraphicsMatrix_Rotate" wxGraphicsMatrix_Rotate :: Ptr (TGraphicsMatrix a) -> Double -> IO ()

-- | usage: (@graphicsMatrixScale self xScaleyScale@).
graphicsMatrixScale :: GraphicsMatrix  a -> (Size2D Double) ->  IO ()
graphicsMatrixScale self xScaleyScale 
  = withObjectRef "graphicsMatrixScale" self $ \cobj_self -> 
    wxGraphicsMatrix_Scale cobj_self  (toCDoubleSizeW xScaleyScale) (toCDoubleSizeH xScaleyScale)  
foreign import ccall "wxGraphicsMatrix_Scale" wxGraphicsMatrix_Scale :: Ptr (TGraphicsMatrix a) -> CDouble -> CDouble -> IO ()

-- | usage: (@graphicsMatrixSet self a b c d tx ty@).
graphicsMatrixSet :: GraphicsMatrix  a -> Double -> Double -> Double -> Double -> Double -> Double ->  IO ()
graphicsMatrixSet self a b c d tx ty 
  = withObjectRef "graphicsMatrixSet" self $ \cobj_self -> 
    wxGraphicsMatrix_Set cobj_self  a  b  c  d  tx  ty  
foreign import ccall "wxGraphicsMatrix_Set" wxGraphicsMatrix_Set :: Ptr (TGraphicsMatrix a) -> Double -> Double -> Double -> Double -> Double -> Double -> IO ()

-- | usage: (@graphicsMatrixTransformDistance self dx dy@).
graphicsMatrixTransformDistance :: GraphicsMatrix  a -> Ptr Double -> Ptr Double ->  IO ()
graphicsMatrixTransformDistance self dx dy 
  = withObjectRef "graphicsMatrixTransformDistance" self $ \cobj_self -> 
    wxGraphicsMatrix_TransformDistance cobj_self  dx  dy  
foreign import ccall "wxGraphicsMatrix_TransformDistance" wxGraphicsMatrix_TransformDistance :: Ptr (TGraphicsMatrix a) -> Ptr Double -> Ptr Double -> IO ()

-- | usage: (@graphicsMatrixTransformPoint self@).
graphicsMatrixTransformPoint :: GraphicsMatrix  a ->  IO (Point2 Double)
graphicsMatrixTransformPoint self 
  = withPointDoubleResult $ \px py -> 
    withObjectRef "graphicsMatrixTransformPoint" self $ \cobj_self -> 
    wxGraphicsMatrix_TransformPoint cobj_self   px py
foreign import ccall "wxGraphicsMatrix_TransformPoint" wxGraphicsMatrix_TransformPoint :: Ptr (TGraphicsMatrix a) -> Ptr CDouble -> Ptr CDouble -> IO ()

-- | usage: (@graphicsMatrixTranslate self dx dy@).
graphicsMatrixTranslate :: GraphicsMatrix  a -> Double -> Double ->  IO ()
graphicsMatrixTranslate self dx dy 
  = withObjectRef "graphicsMatrixTranslate" self $ \cobj_self -> 
    wxGraphicsMatrix_Translate cobj_self  dx  dy  
foreign import ccall "wxGraphicsMatrix_Translate" wxGraphicsMatrix_Translate :: Ptr (TGraphicsMatrix a) -> Double -> Double -> IO ()

-- | usage: (@graphicsObjectGetRenderer@).
graphicsObjectGetRenderer ::  IO (GraphicsRenderer  ())
graphicsObjectGetRenderer 
  = withObjectResult $
    wxGraphicsObject_GetRenderer 
foreign import ccall "wxGraphicsObject_GetRenderer" wxGraphicsObject_GetRenderer :: IO (Ptr (TGraphicsRenderer ()))

-- | usage: (@graphicsObjectIsNull self@).
graphicsObjectIsNull :: GraphicsObject  a ->  IO Bool
graphicsObjectIsNull self 
  = withBoolResult $
    withObjectRef "graphicsObjectIsNull" self $ \cobj_self -> 
    wxGraphicsObject_IsNull cobj_self  
foreign import ccall "wxGraphicsObject_IsNull" wxGraphicsObject_IsNull :: Ptr (TGraphicsObject a) -> IO CBool

-- | usage: (@graphicsPathAddArc self xy r startAngle endAngle clockwise@).
graphicsPathAddArc :: GraphicsPath  a -> (Point2 Double) -> Double -> Double -> Double -> Bool ->  IO ()
graphicsPathAddArc self xy r startAngle endAngle clockwise 
  = withObjectRef "graphicsPathAddArc" self $ \cobj_self -> 
    wxGraphicsPath_AddArc cobj_self  (toCDoublePointX xy) (toCDoublePointY xy)  r  startAngle  endAngle  (toCBool clockwise)  
foreign import ccall "wxGraphicsPath_AddArc" wxGraphicsPath_AddArc :: Ptr (TGraphicsPath a) -> CDouble -> CDouble -> Double -> Double -> Double -> CBool -> IO ()

-- | usage: (@graphicsPathAddArcToPoint self x1y1 x2y2 r@).
graphicsPathAddArcToPoint :: GraphicsPath  a -> (Point2 Double) -> (Point2 Double) -> Double ->  IO ()
graphicsPathAddArcToPoint self x1y1 x2y2 r 
  = withObjectRef "graphicsPathAddArcToPoint" self $ \cobj_self -> 
    wxGraphicsPath_AddArcToPoint cobj_self  (toCDoublePointX x1y1) (toCDoublePointY x1y1)  (toCDoublePointX x2y2) (toCDoublePointY x2y2)  r  
foreign import ccall "wxGraphicsPath_AddArcToPoint" wxGraphicsPath_AddArcToPoint :: Ptr (TGraphicsPath a) -> CDouble -> CDouble -> CDouble -> CDouble -> Double -> IO ()

-- | usage: (@graphicsPathAddCircle self xy r@).
graphicsPathAddCircle :: GraphicsPath  a -> (Point2 Double) -> Double ->  IO ()
graphicsPathAddCircle self xy r 
  = withObjectRef "graphicsPathAddCircle" self $ \cobj_self -> 
    wxGraphicsPath_AddCircle cobj_self  (toCDoublePointX xy) (toCDoublePointY xy)  r  
foreign import ccall "wxGraphicsPath_AddCircle" wxGraphicsPath_AddCircle :: Ptr (TGraphicsPath a) -> CDouble -> CDouble -> Double -> IO ()

-- | usage: (@graphicsPathAddCurveToPoint self cx1cy1 cx2cy2 xy@).
graphicsPathAddCurveToPoint :: GraphicsPath  a -> (Point2 Double) -> (Point2 Double) -> (Point2 Double) ->  IO ()
graphicsPathAddCurveToPoint self cx1cy1 cx2cy2 xy 
  = withObjectRef "graphicsPathAddCurveToPoint" self $ \cobj_self -> 
    wxGraphicsPath_AddCurveToPoint cobj_self  (toCDoublePointX cx1cy1) (toCDoublePointY cx1cy1)  (toCDoublePointX cx2cy2) (toCDoublePointY cx2cy2)  (toCDoublePointX xy) (toCDoublePointY xy)  
foreign import ccall "wxGraphicsPath_AddCurveToPoint" wxGraphicsPath_AddCurveToPoint :: Ptr (TGraphicsPath a) -> CDouble -> CDouble -> CDouble -> CDouble -> CDouble -> CDouble -> IO ()

-- | usage: (@graphicsPathAddEllipse self xywh@).
graphicsPathAddEllipse :: GraphicsPath  a -> (Rect2D Double) ->  IO ()
graphicsPathAddEllipse self xywh 
  = withObjectRef "graphicsPathAddEllipse" self $ \cobj_self -> 
    wxGraphicsPath_AddEllipse cobj_self  (toCDoubleRectX xywh) (toCDoubleRectY xywh)(toCDoubleRectW xywh) (toCDoubleRectH xywh)  
foreign import ccall "wxGraphicsPath_AddEllipse" wxGraphicsPath_AddEllipse :: Ptr (TGraphicsPath a) -> CDouble -> CDouble -> CDouble -> CDouble -> IO ()

-- | usage: (@graphicsPathAddLineToPoint self xy@).
graphicsPathAddLineToPoint :: GraphicsPath  a -> (Point2 Double) ->  IO ()
graphicsPathAddLineToPoint self xy 
  = withObjectRef "graphicsPathAddLineToPoint" self $ \cobj_self -> 
    wxGraphicsPath_AddLineToPoint cobj_self  (toCDoublePointX xy) (toCDoublePointY xy)  
foreign import ccall "wxGraphicsPath_AddLineToPoint" wxGraphicsPath_AddLineToPoint :: Ptr (TGraphicsPath a) -> CDouble -> CDouble -> IO ()

-- | usage: (@graphicsPathAddPath self xy path@).
graphicsPathAddPath :: GraphicsPath  a -> (Point2 Double) -> GraphicsPath  c ->  IO ()
graphicsPathAddPath self xy path 
  = withObjectRef "graphicsPathAddPath" self $ \cobj_self -> 
    withObjectPtr path $ \cobj_path -> 
    wxGraphicsPath_AddPath cobj_self  (toCDoublePointX xy) (toCDoublePointY xy)  cobj_path  
foreign import ccall "wxGraphicsPath_AddPath" wxGraphicsPath_AddPath :: Ptr (TGraphicsPath a) -> CDouble -> CDouble -> Ptr (TGraphicsPath c) -> IO ()

-- | usage: (@graphicsPathAddQuadCurveToPoint self cxcy xy@).
graphicsPathAddQuadCurveToPoint :: GraphicsPath  a -> (Point2 Double) -> (Point2 Double) ->  IO ()
graphicsPathAddQuadCurveToPoint self cxcy xy 
  = withObjectRef "graphicsPathAddQuadCurveToPoint" self $ \cobj_self -> 
    wxGraphicsPath_AddQuadCurveToPoint cobj_self  (toCDoublePointX cxcy) (toCDoublePointY cxcy)  (toCDoublePointX xy) (toCDoublePointY xy)  
foreign import ccall "wxGraphicsPath_AddQuadCurveToPoint" wxGraphicsPath_AddQuadCurveToPoint :: Ptr (TGraphicsPath a) -> CDouble -> CDouble -> CDouble -> CDouble -> IO ()

-- | usage: (@graphicsPathAddRectangle self xywh@).
graphicsPathAddRectangle :: GraphicsPath  a -> (Rect2D Double) ->  IO ()
graphicsPathAddRectangle self xywh 
  = withObjectRef "graphicsPathAddRectangle" self $ \cobj_self -> 
    wxGraphicsPath_AddRectangle cobj_self  (toCDoubleRectX xywh) (toCDoubleRectY xywh)(toCDoubleRectW xywh) (toCDoubleRectH xywh)  
foreign import ccall "wxGraphicsPath_AddRectangle" wxGraphicsPath_AddRectangle :: Ptr (TGraphicsPath a) -> CDouble -> CDouble -> CDouble -> CDouble -> IO ()

-- | usage: (@graphicsPathAddRoundedRectangle self xywh radius@).
graphicsPathAddRoundedRectangle :: GraphicsPath  a -> (Rect2D Double) -> Double ->  IO ()
graphicsPathAddRoundedRectangle self xywh radius 
  = withObjectRef "graphicsPathAddRoundedRectangle" self $ \cobj_self -> 
    wxGraphicsPath_AddRoundedRectangle cobj_self  (toCDoubleRectX xywh) (toCDoubleRectY xywh)(toCDoubleRectW xywh) (toCDoubleRectH xywh)  radius  
foreign import ccall "wxGraphicsPath_AddRoundedRectangle" wxGraphicsPath_AddRoundedRectangle :: Ptr (TGraphicsPath a) -> CDouble -> CDouble -> CDouble -> CDouble -> Double -> IO ()

-- | usage: (@graphicsPathCloseSubpath self@).
graphicsPathCloseSubpath :: GraphicsPath  a ->  IO ()
graphicsPathCloseSubpath self 
  = withObjectRef "graphicsPathCloseSubpath" self $ \cobj_self -> 
    wxGraphicsPath_CloseSubpath cobj_self  
foreign import ccall "wxGraphicsPath_CloseSubpath" wxGraphicsPath_CloseSubpath :: Ptr (TGraphicsPath a) -> IO ()

-- | usage: (@graphicsPathContains self xy style@).
graphicsPathContains :: GraphicsPath  a -> (Point2 Double) -> Int ->  IO ()
graphicsPathContains self xy style 
  = withObjectRef "graphicsPathContains" self $ \cobj_self -> 
    wxGraphicsPath_Contains cobj_self  (toCDoublePointX xy) (toCDoublePointY xy)  (toCInt style)  
foreign import ccall "wxGraphicsPath_Contains" wxGraphicsPath_Contains :: Ptr (TGraphicsPath a) -> CDouble -> CDouble -> CInt -> IO ()

-- | usage: (@graphicsPathCreate@).
graphicsPathCreate ::  IO (GraphicsPath  ())
graphicsPathCreate 
  = withObjectResult $
    wxGraphicsPath_Create 
foreign import ccall "wxGraphicsPath_Create" wxGraphicsPath_Create :: IO (Ptr (TGraphicsPath ()))

-- | usage: (@graphicsPathDelete self@).
graphicsPathDelete :: GraphicsPath  a ->  IO ()
graphicsPathDelete
  = objectDelete


-- | usage: (@graphicsPathGetBox self@).
graphicsPathGetBox :: GraphicsPath  a ->  IO (Rect2D Double)
graphicsPathGetBox self 
  = withRectDoubleResult $ \px py pw ph -> 
    withObjectRef "graphicsPathGetBox" self $ \cobj_self -> 
    wxGraphicsPath_GetBox cobj_self  px py pw ph
foreign import ccall "wxGraphicsPath_GetBox" wxGraphicsPath_GetBox :: Ptr (TGraphicsPath a) -> Ptr CDouble -> Ptr CDouble -> Ptr CDouble -> Ptr CDouble -> IO ()

-- | usage: (@graphicsPathGetCurrentPoint self@).
graphicsPathGetCurrentPoint :: GraphicsPath  a ->  IO (Point2 Double)
graphicsPathGetCurrentPoint self 
  = withPointDoubleResult $ \px py -> 
    withObjectRef "graphicsPathGetCurrentPoint" self $ \cobj_self -> 
    wxGraphicsPath_GetCurrentPoint cobj_self   px py
foreign import ccall "wxGraphicsPath_GetCurrentPoint" wxGraphicsPath_GetCurrentPoint :: Ptr (TGraphicsPath a) -> Ptr CDouble -> Ptr CDouble -> IO ()

-- | usage: (@graphicsPathGetNativePath self@).
graphicsPathGetNativePath :: GraphicsPath  a ->  IO (Ptr  ())
graphicsPathGetNativePath self 
  = withObjectRef "graphicsPathGetNativePath" self $ \cobj_self -> 
    wxGraphicsPath_GetNativePath cobj_self  
foreign import ccall "wxGraphicsPath_GetNativePath" wxGraphicsPath_GetNativePath :: Ptr (TGraphicsPath a) -> IO (Ptr  ())

-- | usage: (@graphicsPathMoveToPoint self xy@).
graphicsPathMoveToPoint :: GraphicsPath  a -> (Point2 Double) ->  IO ()
graphicsPathMoveToPoint self xy 
  = withObjectRef "graphicsPathMoveToPoint" self $ \cobj_self -> 
    wxGraphicsPath_MoveToPoint cobj_self  (toCDoublePointX xy) (toCDoublePointY xy)  
foreign import ccall "wxGraphicsPath_MoveToPoint" wxGraphicsPath_MoveToPoint :: Ptr (TGraphicsPath a) -> CDouble -> CDouble -> IO ()

-- | usage: (@graphicsPathTransform self matrix@).
graphicsPathTransform :: GraphicsPath  a -> GraphicsMatrix  b ->  IO ()
graphicsPathTransform self matrix 
  = withObjectRef "graphicsPathTransform" self $ \cobj_self -> 
    withObjectPtr matrix $ \cobj_matrix -> 
    wxGraphicsPath_Transform cobj_self  cobj_matrix  
foreign import ccall "wxGraphicsPath_Transform" wxGraphicsPath_Transform :: Ptr (TGraphicsPath a) -> Ptr (TGraphicsMatrix b) -> IO ()

-- | usage: (@graphicsPathUnGetNativePath p@).
graphicsPathUnGetNativePath :: GraphicsPath  a ->  IO ()
graphicsPathUnGetNativePath p 
  = withObjectRef "graphicsPathUnGetNativePath" p $ \cobj_p -> 
    wxGraphicsPath_UnGetNativePath cobj_p  
foreign import ccall "wxGraphicsPath_UnGetNativePath" wxGraphicsPath_UnGetNativePath :: Ptr (TGraphicsPath a) -> IO ()

-- | usage: (@graphicsPenCreate@).
graphicsPenCreate ::  IO (GraphicsPen  ())
graphicsPenCreate 
  = withObjectResult $
    wxGraphicsPen_Create 
foreign import ccall "wxGraphicsPen_Create" wxGraphicsPen_Create :: IO (Ptr (TGraphicsPen ()))

-- | usage: (@graphicsPenDelete self@).
graphicsPenDelete :: GraphicsPen  a ->  IO ()
graphicsPenDelete
  = objectDelete


-- | usage: (@graphicsRendererCreateContext dc@).
graphicsRendererCreateContext :: WindowDC  a ->  IO (GraphicsContext  ())
graphicsRendererCreateContext dc 
  = withObjectResult $
    withObjectPtr dc $ \cobj_dc -> 
    wxGraphicsRenderer_CreateContext cobj_dc  
foreign import ccall "wxGraphicsRenderer_CreateContext" wxGraphicsRenderer_CreateContext :: Ptr (TWindowDC a) -> IO (Ptr (TGraphicsContext ()))

-- | usage: (@graphicsRendererCreateContextFromNativeContext context@).
graphicsRendererCreateContextFromNativeContext :: GraphicsRenderer  a ->  IO (GraphicsContext  ())
graphicsRendererCreateContextFromNativeContext context 
  = withObjectResult $
    withObjectRef "graphicsRendererCreateContextFromNativeContext" context $ \cobj_context -> 
    wxGraphicsRenderer_CreateContextFromNativeContext cobj_context  
foreign import ccall "wxGraphicsRenderer_CreateContextFromNativeContext" wxGraphicsRenderer_CreateContextFromNativeContext :: Ptr (TGraphicsRenderer a) -> IO (Ptr (TGraphicsContext ()))

-- | usage: (@graphicsRendererCreateContextFromNativeWindow window@).
graphicsRendererCreateContextFromNativeWindow :: Window  a ->  IO (GraphicsContext  ())
graphicsRendererCreateContextFromNativeWindow window 
  = withObjectResult $
    withObjectPtr window $ \cobj_window -> 
    wxGraphicsRenderer_CreateContextFromNativeWindow cobj_window  
foreign import ccall "wxGraphicsRenderer_CreateContextFromNativeWindow" wxGraphicsRenderer_CreateContextFromNativeWindow :: Ptr (TWindow a) -> IO (Ptr (TGraphicsContext ()))

-- | usage: (@graphicsRendererCreateContextFromWindow window@).
graphicsRendererCreateContextFromWindow :: Window  a ->  IO (GraphicsContext  ())
graphicsRendererCreateContextFromWindow window 
  = withObjectResult $
    withObjectPtr window $ \cobj_window -> 
    wxGraphicsRenderer_CreateContextFromWindow cobj_window  
foreign import ccall "wxGraphicsRenderer_CreateContextFromWindow" wxGraphicsRenderer_CreateContextFromWindow :: Ptr (TWindow a) -> IO (Ptr (TGraphicsContext ()))

-- | usage: (@graphicsRendererDelete self@).
graphicsRendererDelete :: GraphicsRenderer  a ->  IO ()
graphicsRendererDelete
  = objectDelete


-- | usage: (@graphicsRendererGetDefaultRenderer self@).
graphicsRendererGetDefaultRenderer :: GraphicsRenderer  a ->  IO (GraphicsRenderer  ())
graphicsRendererGetDefaultRenderer self 
  = withObjectResult $
    withObjectRef "graphicsRendererGetDefaultRenderer" self $ \cobj_self -> 
    wxGraphicsRenderer_GetDefaultRenderer cobj_self  
foreign import ccall "wxGraphicsRenderer_GetDefaultRenderer" wxGraphicsRenderer_GetDefaultRenderer :: Ptr (TGraphicsRenderer a) -> IO (Ptr (TGraphicsRenderer ()))

-- | usage: (@gridAppendCols obj numCols updateLabels@).
gridAppendCols :: Grid  a -> Int -> Bool ->  IO Bool
gridAppendCols _obj numCols updateLabels 
  = withBoolResult $
    withObjectRef "gridAppendCols" _obj $ \cobj__obj -> 
    wxGrid_AppendCols cobj__obj  (toCInt numCols)  (toCBool updateLabels)  
foreign import ccall "wxGrid_AppendCols" wxGrid_AppendCols :: Ptr (TGrid a) -> CInt -> CBool -> IO CBool

-- | usage: (@gridAppendRows obj numRows updateLabels@).
gridAppendRows :: Grid  a -> Int -> Bool ->  IO Bool
gridAppendRows _obj numRows updateLabels 
  = withBoolResult $
    withObjectRef "gridAppendRows" _obj $ \cobj__obj -> 
    wxGrid_AppendRows cobj__obj  (toCInt numRows)  (toCBool updateLabels)  
foreign import ccall "wxGrid_AppendRows" wxGrid_AppendRows :: Ptr (TGrid a) -> CInt -> CBool -> IO CBool

-- | usage: (@gridAutoSize obj@).
gridAutoSize :: Grid  a ->  IO ()
gridAutoSize _obj 
  = withObjectRef "gridAutoSize" _obj $ \cobj__obj -> 
    wxGrid_AutoSize cobj__obj  
foreign import ccall "wxGrid_AutoSize" wxGrid_AutoSize :: Ptr (TGrid a) -> IO ()

-- | usage: (@gridAutoSizeColumn obj col setAsMin@).
gridAutoSizeColumn :: Grid  a -> Int -> Bool ->  IO ()
gridAutoSizeColumn _obj col setAsMin 
  = withObjectRef "gridAutoSizeColumn" _obj $ \cobj__obj -> 
    wxGrid_AutoSizeColumn cobj__obj  (toCInt col)  (toCBool setAsMin)  
foreign import ccall "wxGrid_AutoSizeColumn" wxGrid_AutoSizeColumn :: Ptr (TGrid a) -> CInt -> CBool -> IO ()

-- | usage: (@gridAutoSizeColumns obj setAsMin@).
gridAutoSizeColumns :: Grid  a -> Bool ->  IO ()
gridAutoSizeColumns _obj setAsMin 
  = withObjectRef "gridAutoSizeColumns" _obj $ \cobj__obj -> 
    wxGrid_AutoSizeColumns cobj__obj  (toCBool setAsMin)  
foreign import ccall "wxGrid_AutoSizeColumns" wxGrid_AutoSizeColumns :: Ptr (TGrid a) -> CBool -> IO ()

-- | usage: (@gridAutoSizeRow obj row setAsMin@).
gridAutoSizeRow :: Grid  a -> Int -> Bool ->  IO ()
gridAutoSizeRow _obj row setAsMin 
  = withObjectRef "gridAutoSizeRow" _obj $ \cobj__obj -> 
    wxGrid_AutoSizeRow cobj__obj  (toCInt row)  (toCBool setAsMin)  
foreign import ccall "wxGrid_AutoSizeRow" wxGrid_AutoSizeRow :: Ptr (TGrid a) -> CInt -> CBool -> IO ()

-- | usage: (@gridAutoSizeRows obj setAsMin@).
gridAutoSizeRows :: Grid  a -> Bool ->  IO ()
gridAutoSizeRows _obj setAsMin 
  = withObjectRef "gridAutoSizeRows" _obj $ \cobj__obj -> 
    wxGrid_AutoSizeRows cobj__obj  (toCBool setAsMin)  
foreign import ccall "wxGrid_AutoSizeRows" wxGrid_AutoSizeRows :: Ptr (TGrid a) -> CBool -> IO ()

-- | usage: (@gridBeginBatch obj@).
gridBeginBatch :: Grid  a ->  IO ()
gridBeginBatch _obj 
  = withObjectRef "gridBeginBatch" _obj $ \cobj__obj -> 
    wxGrid_BeginBatch cobj__obj  
foreign import ccall "wxGrid_BeginBatch" wxGrid_BeginBatch :: Ptr (TGrid a) -> IO ()

-- | usage: (@gridBlockToDeviceRect obj top left bottom right@).
gridBlockToDeviceRect :: Grid  a -> Int -> Int -> Int -> Int ->  IO (Rect)
gridBlockToDeviceRect _obj top left bottom right 
  = withWxRectResult $
    withObjectRef "gridBlockToDeviceRect" _obj $ \cobj__obj -> 
    wxGrid_BlockToDeviceRect cobj__obj  (toCInt top)  (toCInt left)  (toCInt bottom)  (toCInt right)  
foreign import ccall "wxGrid_BlockToDeviceRect" wxGrid_BlockToDeviceRect :: Ptr (TGrid a) -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (TWxRect ()))

-- | usage: (@gridCalcCellsExposed obj reg@).
gridCalcCellsExposed :: Grid  a -> Region  b ->  IO ()
gridCalcCellsExposed _obj reg 
  = withObjectRef "gridCalcCellsExposed" _obj $ \cobj__obj -> 
    withObjectPtr reg $ \cobj_reg -> 
    wxGrid_CalcCellsExposed cobj__obj  cobj_reg  
foreign import ccall "wxGrid_CalcCellsExposed" wxGrid_CalcCellsExposed :: Ptr (TGrid a) -> Ptr (TRegion b) -> IO ()

-- | usage: (@gridCalcColLabelsExposed obj reg@).
gridCalcColLabelsExposed :: Grid  a -> Region  b ->  IO ()
gridCalcColLabelsExposed _obj reg 
  = withObjectRef "gridCalcColLabelsExposed" _obj $ \cobj__obj -> 
    withObjectPtr reg $ \cobj_reg -> 
    wxGrid_CalcColLabelsExposed cobj__obj  cobj_reg  
foreign import ccall "wxGrid_CalcColLabelsExposed" wxGrid_CalcColLabelsExposed :: Ptr (TGrid a) -> Ptr (TRegion b) -> IO ()

-- | usage: (@gridCalcRowLabelsExposed obj reg@).
gridCalcRowLabelsExposed :: Grid  a -> Region  b ->  IO ()
gridCalcRowLabelsExposed _obj reg 
  = withObjectRef "gridCalcRowLabelsExposed" _obj $ \cobj__obj -> 
    withObjectPtr reg $ \cobj_reg -> 
    wxGrid_CalcRowLabelsExposed cobj__obj  cobj_reg  
foreign import ccall "wxGrid_CalcRowLabelsExposed" wxGrid_CalcRowLabelsExposed :: Ptr (TGrid a) -> Ptr (TRegion b) -> IO ()

-- | usage: (@gridCanDragColSize obj@).
gridCanDragColSize :: Grid  a ->  IO Bool
gridCanDragColSize _obj 
  = withBoolResult $
    withObjectRef "gridCanDragColSize" _obj $ \cobj__obj -> 
    wxGrid_CanDragColSize cobj__obj  
foreign import ccall "wxGrid_CanDragColSize" wxGrid_CanDragColSize :: Ptr (TGrid a) -> IO CBool

-- | usage: (@gridCanDragGridSize obj@).
gridCanDragGridSize :: Grid  a ->  IO Bool
gridCanDragGridSize _obj 
  = withBoolResult $
    withObjectRef "gridCanDragGridSize" _obj $ \cobj__obj -> 
    wxGrid_CanDragGridSize cobj__obj  
foreign import ccall "wxGrid_CanDragGridSize" wxGrid_CanDragGridSize :: Ptr (TGrid a) -> IO CBool

-- | usage: (@gridCanDragRowSize obj@).
gridCanDragRowSize :: Grid  a ->  IO Bool
gridCanDragRowSize _obj 
  = withBoolResult $
    withObjectRef "gridCanDragRowSize" _obj $ \cobj__obj -> 
    wxGrid_CanDragRowSize cobj__obj  
foreign import ccall "wxGrid_CanDragRowSize" wxGrid_CanDragRowSize :: Ptr (TGrid a) -> IO CBool

-- | usage: (@gridCanEnableCellControl obj@).
gridCanEnableCellControl :: Grid  a ->  IO Bool
gridCanEnableCellControl _obj 
  = withBoolResult $
    withObjectRef "gridCanEnableCellControl" _obj $ \cobj__obj -> 
    wxGrid_CanEnableCellControl cobj__obj  
foreign import ccall "wxGrid_CanEnableCellControl" wxGrid_CanEnableCellControl :: Ptr (TGrid a) -> IO CBool

-- | usage: (@gridCellAttrCtor@).
gridCellAttrCtor ::  IO (GridCellAttr  ())
gridCellAttrCtor 
  = withObjectResult $
    wxGridCellAttr_Ctor 
foreign import ccall "wxGridCellAttr_Ctor" wxGridCellAttr_Ctor :: IO (Ptr (TGridCellAttr ()))

-- | usage: (@gridCellAttrDecRef obj@).
gridCellAttrDecRef :: GridCellAttr  a ->  IO ()
gridCellAttrDecRef _obj 
  = withObjectRef "gridCellAttrDecRef" _obj $ \cobj__obj -> 
    wxGridCellAttr_DecRef cobj__obj  
foreign import ccall "wxGridCellAttr_DecRef" wxGridCellAttr_DecRef :: Ptr (TGridCellAttr a) -> IO ()

-- | usage: (@gridCellAttrGetAlignment obj@).
gridCellAttrGetAlignment :: GridCellAttr  a ->  IO Size
gridCellAttrGetAlignment _obj 
  = withSizeResult $ \pw ph -> 
    withObjectRef "gridCellAttrGetAlignment" _obj $ \cobj__obj -> 
    wxGridCellAttr_GetAlignment cobj__obj   pw ph
foreign import ccall "wxGridCellAttr_GetAlignment" wxGridCellAttr_GetAlignment :: Ptr (TGridCellAttr a) -> Ptr CInt -> Ptr CInt -> IO ()

-- | usage: (@gridCellAttrGetBackgroundColour obj@).
gridCellAttrGetBackgroundColour :: GridCellAttr  a ->  IO (Color)
gridCellAttrGetBackgroundColour _obj 
  = withRefColour $ \pref -> 
    withObjectRef "gridCellAttrGetBackgroundColour" _obj $ \cobj__obj -> 
    wxGridCellAttr_GetBackgroundColour cobj__obj   pref
foreign import ccall "wxGridCellAttr_GetBackgroundColour" wxGridCellAttr_GetBackgroundColour :: Ptr (TGridCellAttr a) -> Ptr (TColour ()) -> IO ()

-- | usage: (@gridCellAttrGetEditor obj grid row col@).
gridCellAttrGetEditor :: GridCellAttr  a -> Grid  b -> Int -> Int ->  IO (GridCellEditor  ())
gridCellAttrGetEditor _obj grid row col 
  = withObjectResult $
    withObjectRef "gridCellAttrGetEditor" _obj $ \cobj__obj -> 
    withObjectPtr grid $ \cobj_grid -> 
    wxGridCellAttr_GetEditor cobj__obj  cobj_grid  (toCInt row)  (toCInt col)  
foreign import ccall "wxGridCellAttr_GetEditor" wxGridCellAttr_GetEditor :: Ptr (TGridCellAttr a) -> Ptr (TGrid b) -> CInt -> CInt -> IO (Ptr (TGridCellEditor ()))

-- | usage: (@gridCellAttrGetFont obj@).
gridCellAttrGetFont :: GridCellAttr  a ->  IO (Font  ())
gridCellAttrGetFont _obj 
  = withRefFont $ \pref -> 
    withObjectRef "gridCellAttrGetFont" _obj $ \cobj__obj -> 
    wxGridCellAttr_GetFont cobj__obj   pref
foreign import ccall "wxGridCellAttr_GetFont" wxGridCellAttr_GetFont :: Ptr (TGridCellAttr a) -> Ptr (TFont ()) -> IO ()

-- | usage: (@gridCellAttrGetRenderer obj grid row col@).
gridCellAttrGetRenderer :: GridCellAttr  a -> Grid  b -> Int -> Int ->  IO (GridCellRenderer  ())
gridCellAttrGetRenderer _obj grid row col 
  = withObjectResult $
    withObjectRef "gridCellAttrGetRenderer" _obj $ \cobj__obj -> 
    withObjectPtr grid $ \cobj_grid -> 
    wxGridCellAttr_GetRenderer cobj__obj  cobj_grid  (toCInt row)  (toCInt col)  
foreign import ccall "wxGridCellAttr_GetRenderer" wxGridCellAttr_GetRenderer :: Ptr (TGridCellAttr a) -> Ptr (TGrid b) -> CInt -> CInt -> IO (Ptr (TGridCellRenderer ()))

-- | usage: (@gridCellAttrGetTextColour obj@).
gridCellAttrGetTextColour :: GridCellAttr  a ->  IO (Color)
gridCellAttrGetTextColour _obj 
  = withRefColour $ \pref -> 
    withObjectRef "gridCellAttrGetTextColour" _obj $ \cobj__obj -> 
    wxGridCellAttr_GetTextColour cobj__obj   pref
foreign import ccall "wxGridCellAttr_GetTextColour" wxGridCellAttr_GetTextColour :: Ptr (TGridCellAttr a) -> Ptr (TColour ()) -> IO ()

-- | usage: (@gridCellAttrHasAlignment obj@).
gridCellAttrHasAlignment :: GridCellAttr  a ->  IO Bool
gridCellAttrHasAlignment _obj 
  = withBoolResult $
    withObjectRef "gridCellAttrHasAlignment" _obj $ \cobj__obj -> 
    wxGridCellAttr_HasAlignment cobj__obj  
foreign import ccall "wxGridCellAttr_HasAlignment" wxGridCellAttr_HasAlignment :: Ptr (TGridCellAttr a) -> IO CBool

-- | usage: (@gridCellAttrHasBackgroundColour obj@).
gridCellAttrHasBackgroundColour :: GridCellAttr  a ->  IO Bool
gridCellAttrHasBackgroundColour _obj 
  = withBoolResult $
    withObjectRef "gridCellAttrHasBackgroundColour" _obj $ \cobj__obj -> 
    wxGridCellAttr_HasBackgroundColour cobj__obj  
foreign import ccall "wxGridCellAttr_HasBackgroundColour" wxGridCellAttr_HasBackgroundColour :: Ptr (TGridCellAttr a) -> IO CBool

-- | usage: (@gridCellAttrHasEditor obj@).
gridCellAttrHasEditor :: GridCellAttr  a ->  IO Bool
gridCellAttrHasEditor _obj 
  = withBoolResult $
    withObjectRef "gridCellAttrHasEditor" _obj $ \cobj__obj -> 
    wxGridCellAttr_HasEditor cobj__obj  
foreign import ccall "wxGridCellAttr_HasEditor" wxGridCellAttr_HasEditor :: Ptr (TGridCellAttr a) -> IO CBool

-- | usage: (@gridCellAttrHasFont obj@).
gridCellAttrHasFont :: GridCellAttr  a ->  IO Bool
gridCellAttrHasFont _obj 
  = withBoolResult $
    withObjectRef "gridCellAttrHasFont" _obj $ \cobj__obj -> 
    wxGridCellAttr_HasFont cobj__obj  
foreign import ccall "wxGridCellAttr_HasFont" wxGridCellAttr_HasFont :: Ptr (TGridCellAttr a) -> IO CBool

-- | usage: (@gridCellAttrHasRenderer obj@).
gridCellAttrHasRenderer :: GridCellAttr  a ->  IO Bool
gridCellAttrHasRenderer _obj 
  = withBoolResult $
    withObjectRef "gridCellAttrHasRenderer" _obj $ \cobj__obj -> 
    wxGridCellAttr_HasRenderer cobj__obj  
foreign import ccall "wxGridCellAttr_HasRenderer" wxGridCellAttr_HasRenderer :: Ptr (TGridCellAttr a) -> IO CBool

-- | usage: (@gridCellAttrHasTextColour obj@).
gridCellAttrHasTextColour :: GridCellAttr  a ->  IO Bool
gridCellAttrHasTextColour _obj 
  = withBoolResult $
    withObjectRef "gridCellAttrHasTextColour" _obj $ \cobj__obj -> 
    wxGridCellAttr_HasTextColour cobj__obj  
foreign import ccall "wxGridCellAttr_HasTextColour" wxGridCellAttr_HasTextColour :: Ptr (TGridCellAttr a) -> IO CBool

-- | usage: (@gridCellAttrIncRef obj@).
gridCellAttrIncRef :: GridCellAttr  a ->  IO ()
gridCellAttrIncRef _obj 
  = withObjectRef "gridCellAttrIncRef" _obj $ \cobj__obj -> 
    wxGridCellAttr_IncRef cobj__obj  
foreign import ccall "wxGridCellAttr_IncRef" wxGridCellAttr_IncRef :: Ptr (TGridCellAttr a) -> IO ()

-- | usage: (@gridCellAttrIsReadOnly obj@).
gridCellAttrIsReadOnly :: GridCellAttr  a ->  IO Bool
gridCellAttrIsReadOnly _obj 
  = withBoolResult $
    withObjectRef "gridCellAttrIsReadOnly" _obj $ \cobj__obj -> 
    wxGridCellAttr_IsReadOnly cobj__obj  
foreign import ccall "wxGridCellAttr_IsReadOnly" wxGridCellAttr_IsReadOnly :: Ptr (TGridCellAttr a) -> IO CBool

-- | usage: (@gridCellAttrSetAlignment obj hAlign vAlign@).
gridCellAttrSetAlignment :: GridCellAttr  a -> Int -> Int ->  IO ()
gridCellAttrSetAlignment _obj hAlign vAlign 
  = withObjectRef "gridCellAttrSetAlignment" _obj $ \cobj__obj -> 
    wxGridCellAttr_SetAlignment cobj__obj  (toCInt hAlign)  (toCInt vAlign)  
foreign import ccall "wxGridCellAttr_SetAlignment" wxGridCellAttr_SetAlignment :: Ptr (TGridCellAttr a) -> CInt -> CInt -> IO ()

-- | usage: (@gridCellAttrSetBackgroundColour obj colBack@).
gridCellAttrSetBackgroundColour :: GridCellAttr  a -> Color ->  IO ()
gridCellAttrSetBackgroundColour _obj colBack 
  = withObjectRef "gridCellAttrSetBackgroundColour" _obj $ \cobj__obj -> 
    withColourPtr colBack $ \cobj_colBack -> 
    wxGridCellAttr_SetBackgroundColour cobj__obj  cobj_colBack  
foreign import ccall "wxGridCellAttr_SetBackgroundColour" wxGridCellAttr_SetBackgroundColour :: Ptr (TGridCellAttr a) -> Ptr (TColour b) -> IO ()

-- | usage: (@gridCellAttrSetDefAttr obj defAttr@).
gridCellAttrSetDefAttr :: GridCellAttr  a -> GridCellAttr  b ->  IO ()
gridCellAttrSetDefAttr _obj defAttr 
  = withObjectRef "gridCellAttrSetDefAttr" _obj $ \cobj__obj -> 
    withObjectPtr defAttr $ \cobj_defAttr -> 
    wxGridCellAttr_SetDefAttr cobj__obj  cobj_defAttr  
foreign import ccall "wxGridCellAttr_SetDefAttr" wxGridCellAttr_SetDefAttr :: Ptr (TGridCellAttr a) -> Ptr (TGridCellAttr b) -> IO ()

-- | usage: (@gridCellAttrSetEditor obj editor@).
gridCellAttrSetEditor :: GridCellAttr  a -> GridCellEditor  b ->  IO ()
gridCellAttrSetEditor _obj editor 
  = withObjectRef "gridCellAttrSetEditor" _obj $ \cobj__obj -> 
    withObjectPtr editor $ \cobj_editor -> 
    wxGridCellAttr_SetEditor cobj__obj  cobj_editor  
foreign import ccall "wxGridCellAttr_SetEditor" wxGridCellAttr_SetEditor :: Ptr (TGridCellAttr a) -> Ptr (TGridCellEditor b) -> IO ()

-- | usage: (@gridCellAttrSetFont obj font@).
gridCellAttrSetFont :: GridCellAttr  a -> Font  b ->  IO ()
gridCellAttrSetFont _obj font 
  = withObjectRef "gridCellAttrSetFont" _obj $ \cobj__obj -> 
    withObjectPtr font $ \cobj_font -> 
    wxGridCellAttr_SetFont cobj__obj  cobj_font  
foreign import ccall "wxGridCellAttr_SetFont" wxGridCellAttr_SetFont :: Ptr (TGridCellAttr a) -> Ptr (TFont b) -> IO ()

-- | usage: (@gridCellAttrSetReadOnly obj isReadOnly@).
gridCellAttrSetReadOnly :: GridCellAttr  a -> Bool ->  IO ()
gridCellAttrSetReadOnly _obj isReadOnly 
  = withObjectRef "gridCellAttrSetReadOnly" _obj $ \cobj__obj -> 
    wxGridCellAttr_SetReadOnly cobj__obj  (toCBool isReadOnly)  
foreign import ccall "wxGridCellAttr_SetReadOnly" wxGridCellAttr_SetReadOnly :: Ptr (TGridCellAttr a) -> CBool -> IO ()

-- | usage: (@gridCellAttrSetRenderer obj renderer@).
gridCellAttrSetRenderer :: GridCellAttr  a -> GridCellRenderer  b ->  IO ()
gridCellAttrSetRenderer _obj renderer 
  = withObjectRef "gridCellAttrSetRenderer" _obj $ \cobj__obj -> 
    withObjectPtr renderer $ \cobj_renderer -> 
    wxGridCellAttr_SetRenderer cobj__obj  cobj_renderer  
foreign import ccall "wxGridCellAttr_SetRenderer" wxGridCellAttr_SetRenderer :: Ptr (TGridCellAttr a) -> Ptr (TGridCellRenderer b) -> IO ()

-- | usage: (@gridCellAttrSetTextColour obj colText@).
gridCellAttrSetTextColour :: GridCellAttr  a -> Color ->  IO ()
gridCellAttrSetTextColour _obj colText 
  = withObjectRef "gridCellAttrSetTextColour" _obj $ \cobj__obj -> 
    withColourPtr colText $ \cobj_colText -> 
    wxGridCellAttr_SetTextColour cobj__obj  cobj_colText  
foreign import ccall "wxGridCellAttr_SetTextColour" wxGridCellAttr_SetTextColour :: Ptr (TGridCellAttr a) -> Ptr (TColour b) -> IO ()

-- | usage: (@gridCellBoolEditorCtor@).
gridCellBoolEditorCtor ::  IO (GridCellBoolEditor  ())
gridCellBoolEditorCtor 
  = withObjectResult $
    wxGridCellBoolEditor_Ctor 
foreign import ccall "wxGridCellBoolEditor_Ctor" wxGridCellBoolEditor_Ctor :: IO (Ptr (TGridCellBoolEditor ()))

-- | usage: (@gridCellChoiceEditorCtor countchoices allowOthers@).
gridCellChoiceEditorCtor :: [String] -> Bool ->  IO (GridCellChoiceEditor  ())
gridCellChoiceEditorCtor countchoices allowOthers 
  = withObjectResult $
    withArrayWString countchoices $ \carrlen_countchoices carr_countchoices -> 
    wxGridCellChoiceEditor_Ctor carrlen_countchoices carr_countchoices  (toCBool allowOthers)  
foreign import ccall "wxGridCellChoiceEditor_Ctor" wxGridCellChoiceEditor_Ctor :: CInt -> Ptr (Ptr CWchar) -> CBool -> IO (Ptr (TGridCellChoiceEditor ()))

-- | usage: (@gridCellCoordsArrayCreate@).
gridCellCoordsArrayCreate ::  IO (GridCellCoordsArray  ())
gridCellCoordsArrayCreate 
  = withManagedGridCellCoordsArrayResult $
    wxGridCellCoordsArray_Create 
foreign import ccall "wxGridCellCoordsArray_Create" wxGridCellCoordsArray_Create :: IO (Ptr (TGridCellCoordsArray ()))

-- | usage: (@gridCellCoordsArrayDelete obj@).
gridCellCoordsArrayDelete :: GridCellCoordsArray  a ->  IO ()
gridCellCoordsArrayDelete
  = gridCellCoordsArrayDelete


-- | usage: (@gridCellCoordsArrayGetCount obj@).
gridCellCoordsArrayGetCount :: GridCellCoordsArray  a ->  IO Int
gridCellCoordsArrayGetCount _obj 
  = withIntResult $
    withObjectRef "gridCellCoordsArrayGetCount" _obj $ \cobj__obj -> 
    wxGridCellCoordsArray_GetCount cobj__obj  
foreign import ccall "wxGridCellCoordsArray_GetCount" wxGridCellCoordsArray_GetCount :: Ptr (TGridCellCoordsArray a) -> IO CInt

-- | usage: (@gridCellCoordsArrayItem obj idx@).
gridCellCoordsArrayItem :: GridCellCoordsArray  a -> Int ->  IO Point
gridCellCoordsArrayItem _obj _idx 
  = withPointResult $ \px py -> 
    withObjectRef "gridCellCoordsArrayItem" _obj $ \cobj__obj -> 
    wxGridCellCoordsArray_Item cobj__obj  (toCInt _idx)   px py
foreign import ccall "wxGridCellCoordsArray_Item" wxGridCellCoordsArray_Item :: Ptr (TGridCellCoordsArray a) -> CInt -> Ptr CInt -> Ptr CInt -> IO ()

-- | usage: (@gridCellEditorBeginEdit obj row col grid@).
gridCellEditorBeginEdit :: GridCellEditor  a -> Int -> Int -> Grid  d ->  IO ()
gridCellEditorBeginEdit _obj row col grid 
  = withObjectRef "gridCellEditorBeginEdit" _obj $ \cobj__obj -> 
    withObjectPtr grid $ \cobj_grid -> 
    wxGridCellEditor_BeginEdit cobj__obj  (toCInt row)  (toCInt col)  cobj_grid  
foreign import ccall "wxGridCellEditor_BeginEdit" wxGridCellEditor_BeginEdit :: Ptr (TGridCellEditor a) -> CInt -> CInt -> Ptr (TGrid d) -> IO ()

-- | usage: (@gridCellEditorCreate obj parent id evtHandler@).
gridCellEditorCreate :: GridCellEditor  a -> Window  b -> Id -> EvtHandler  d ->  IO ()
gridCellEditorCreate _obj parent id evtHandler 
  = withObjectPtr _obj $ \cobj__obj -> 
    withObjectPtr parent $ \cobj_parent -> 
    withObjectPtr evtHandler $ \cobj_evtHandler -> 
    wxGridCellEditor_Create cobj__obj  cobj_parent  (toCInt id)  cobj_evtHandler  
foreign import ccall "wxGridCellEditor_Create" wxGridCellEditor_Create :: Ptr (TGridCellEditor a) -> Ptr (TWindow b) -> CInt -> Ptr (TEvtHandler d) -> IO ()

-- | usage: (@gridCellEditorDestroy obj@).
gridCellEditorDestroy :: GridCellEditor  a ->  IO ()
gridCellEditorDestroy _obj 
  = withObjectRef "gridCellEditorDestroy" _obj $ \cobj__obj -> 
    wxGridCellEditor_Destroy cobj__obj  
foreign import ccall "wxGridCellEditor_Destroy" wxGridCellEditor_Destroy :: Ptr (TGridCellEditor a) -> IO ()

-- | usage: (@gridCellEditorEndEdit obj row col grid@).
gridCellEditorEndEdit :: GridCellEditor  a -> Int -> Int -> Grid  d ->  IO Int
gridCellEditorEndEdit _obj row col grid 
  = withIntResult $
    withObjectRef "gridCellEditorEndEdit" _obj $ \cobj__obj -> 
    withObjectPtr grid $ \cobj_grid -> 
    wxGridCellEditor_EndEdit cobj__obj  (toCInt row)  (toCInt col)  cobj_grid  
foreign import ccall "wxGridCellEditor_EndEdit" wxGridCellEditor_EndEdit :: Ptr (TGridCellEditor a) -> CInt -> CInt -> Ptr (TGrid d) -> IO CInt

-- | usage: (@gridCellEditorGetControl obj@).
gridCellEditorGetControl :: GridCellEditor  a ->  IO (Control  ())
gridCellEditorGetControl _obj 
  = withObjectResult $
    withObjectRef "gridCellEditorGetControl" _obj $ \cobj__obj -> 
    wxGridCellEditor_GetControl cobj__obj  
foreign import ccall "wxGridCellEditor_GetControl" wxGridCellEditor_GetControl :: Ptr (TGridCellEditor a) -> IO (Ptr (TControl ()))

-- | usage: (@gridCellEditorHandleReturn obj event@).
gridCellEditorHandleReturn :: GridCellEditor  a -> Event  b ->  IO ()
gridCellEditorHandleReturn _obj event 
  = withObjectRef "gridCellEditorHandleReturn" _obj $ \cobj__obj -> 
    withObjectPtr event $ \cobj_event -> 
    wxGridCellEditor_HandleReturn cobj__obj  cobj_event  
foreign import ccall "wxGridCellEditor_HandleReturn" wxGridCellEditor_HandleReturn :: Ptr (TGridCellEditor a) -> Ptr (TEvent b) -> IO ()

-- | usage: (@gridCellEditorIsAcceptedKey obj event@).
gridCellEditorIsAcceptedKey :: GridCellEditor  a -> Event  b ->  IO Bool
gridCellEditorIsAcceptedKey _obj event 
  = withBoolResult $
    withObjectRef "gridCellEditorIsAcceptedKey" _obj $ \cobj__obj -> 
    withObjectPtr event $ \cobj_event -> 
    wxGridCellEditor_IsAcceptedKey cobj__obj  cobj_event  
foreign import ccall "wxGridCellEditor_IsAcceptedKey" wxGridCellEditor_IsAcceptedKey :: Ptr (TGridCellEditor a) -> Ptr (TEvent b) -> IO CBool

-- | usage: (@gridCellEditorIsCreated obj@).
gridCellEditorIsCreated :: GridCellEditor  a ->  IO Bool
gridCellEditorIsCreated _obj 
  = withBoolResult $
    withObjectRef "gridCellEditorIsCreated" _obj $ \cobj__obj -> 
    wxGridCellEditor_IsCreated cobj__obj  
foreign import ccall "wxGridCellEditor_IsCreated" wxGridCellEditor_IsCreated :: Ptr (TGridCellEditor a) -> IO CBool

-- | usage: (@gridCellEditorPaintBackground obj xywh attr@).
gridCellEditorPaintBackground :: GridCellEditor  a -> Rect -> GridCellAttr  c ->  IO ()
gridCellEditorPaintBackground _obj xywh attr 
  = withObjectRef "gridCellEditorPaintBackground" _obj $ \cobj__obj -> 
    withObjectPtr attr $ \cobj_attr -> 
    wxGridCellEditor_PaintBackground cobj__obj  (toCIntRectX xywh) (toCIntRectY xywh)(toCIntRectW xywh) (toCIntRectH xywh)  cobj_attr  
foreign import ccall "wxGridCellEditor_PaintBackground" wxGridCellEditor_PaintBackground :: Ptr (TGridCellEditor a) -> CInt -> CInt -> CInt -> CInt -> Ptr (TGridCellAttr c) -> IO ()

-- | usage: (@gridCellEditorReset obj@).
gridCellEditorReset :: GridCellEditor  a ->  IO ()
gridCellEditorReset _obj 
  = withObjectRef "gridCellEditorReset" _obj $ \cobj__obj -> 
    wxGridCellEditor_Reset cobj__obj  
foreign import ccall "wxGridCellEditor_Reset" wxGridCellEditor_Reset :: Ptr (TGridCellEditor a) -> IO ()

-- | usage: (@gridCellEditorSetControl obj control@).
gridCellEditorSetControl :: GridCellEditor  a -> Control  b ->  IO ()
gridCellEditorSetControl _obj control 
  = withObjectRef "gridCellEditorSetControl" _obj $ \cobj__obj -> 
    withObjectPtr control $ \cobj_control -> 
    wxGridCellEditor_SetControl cobj__obj  cobj_control  
foreign import ccall "wxGridCellEditor_SetControl" wxGridCellEditor_SetControl :: Ptr (TGridCellEditor a) -> Ptr (TControl b) -> IO ()

-- | usage: (@gridCellEditorSetParameters obj params@).
gridCellEditorSetParameters :: GridCellEditor  a -> String ->  IO ()
gridCellEditorSetParameters _obj params 
  = withObjectRef "gridCellEditorSetParameters" _obj $ \cobj__obj -> 
    withStringPtr params $ \cobj_params -> 
    wxGridCellEditor_SetParameters cobj__obj  cobj_params  
foreign import ccall "wxGridCellEditor_SetParameters" wxGridCellEditor_SetParameters :: Ptr (TGridCellEditor a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@gridCellEditorSetSize obj xywh@).
gridCellEditorSetSize :: GridCellEditor  a -> Rect ->  IO ()
gridCellEditorSetSize _obj xywh 
  = withObjectRef "gridCellEditorSetSize" _obj $ \cobj__obj -> 
    wxGridCellEditor_SetSize cobj__obj  (toCIntRectX xywh) (toCIntRectY xywh)(toCIntRectW xywh) (toCIntRectH xywh)  
foreign import ccall "wxGridCellEditor_SetSize" wxGridCellEditor_SetSize :: Ptr (TGridCellEditor a) -> CInt -> CInt -> CInt -> CInt -> IO ()

-- | usage: (@gridCellEditorShow obj show attr@).
gridCellEditorShow :: GridCellEditor  a -> Bool -> GridCellAttr  c ->  IO ()
gridCellEditorShow _obj show attr 
  = withObjectRef "gridCellEditorShow" _obj $ \cobj__obj -> 
    withObjectPtr attr $ \cobj_attr -> 
    wxGridCellEditor_Show cobj__obj  (toCBool show)  cobj_attr  
foreign import ccall "wxGridCellEditor_Show" wxGridCellEditor_Show :: Ptr (TGridCellEditor a) -> CBool -> Ptr (TGridCellAttr c) -> IO ()

-- | usage: (@gridCellEditorStartingClick obj@).
gridCellEditorStartingClick :: GridCellEditor  a ->  IO ()
gridCellEditorStartingClick _obj 
  = withObjectRef "gridCellEditorStartingClick" _obj $ \cobj__obj -> 
    wxGridCellEditor_StartingClick cobj__obj  
foreign import ccall "wxGridCellEditor_StartingClick" wxGridCellEditor_StartingClick :: Ptr (TGridCellEditor a) -> IO ()

-- | usage: (@gridCellEditorStartingKey obj event@).
gridCellEditorStartingKey :: GridCellEditor  a -> Event  b ->  IO ()
gridCellEditorStartingKey _obj event 
  = withObjectRef "gridCellEditorStartingKey" _obj $ \cobj__obj -> 
    withObjectPtr event $ \cobj_event -> 
    wxGridCellEditor_StartingKey cobj__obj  cobj_event  
foreign import ccall "wxGridCellEditor_StartingKey" wxGridCellEditor_StartingKey :: Ptr (TGridCellEditor a) -> Ptr (TEvent b) -> IO ()

-- | usage: (@gridCellFloatEditorCtor width precision@).
gridCellFloatEditorCtor :: Int -> Int ->  IO (GridCellFloatEditor  ())
gridCellFloatEditorCtor width precision 
  = withObjectResult $
    wxGridCellFloatEditor_Ctor (toCInt width)  (toCInt precision)  
foreign import ccall "wxGridCellFloatEditor_Ctor" wxGridCellFloatEditor_Ctor :: CInt -> CInt -> IO (Ptr (TGridCellFloatEditor ()))

-- | usage: (@gridCellNumberEditorCtor min max@).
gridCellNumberEditorCtor :: Int -> Int ->  IO (GridCellNumberEditor  ())
gridCellNumberEditorCtor min max 
  = withObjectResult $
    wxGridCellNumberEditor_Ctor (toCInt min)  (toCInt max)  
foreign import ccall "wxGridCellNumberEditor_Ctor" wxGridCellNumberEditor_Ctor :: CInt -> CInt -> IO (Ptr (TGridCellNumberEditor ()))

-- | usage: (@gridCellTextEditorCtor@).
gridCellTextEditorCtor ::  IO (GridCellTextEditor  ())
gridCellTextEditorCtor 
  = withObjectResult $
    wxGridCellTextEditor_Ctor 
foreign import ccall "wxGridCellTextEditor_Ctor" wxGridCellTextEditor_Ctor :: IO (Ptr (TGridCellTextEditor ()))

-- | usage: (@gridCellTextEnterEditorCtor@).
gridCellTextEnterEditorCtor ::  IO (GridCellTextEnterEditor  ())
gridCellTextEnterEditorCtor 
  = withObjectResult $
    wxGridCellTextEnterEditor_Ctor 
foreign import ccall "wxGridCellTextEnterEditor_Ctor" wxGridCellTextEnterEditor_Ctor :: IO (Ptr (TGridCellTextEnterEditor ()))

-- | usage: (@gridCellToRect obj row col@).
gridCellToRect :: Grid  a -> Int -> Int ->  IO (Rect)
gridCellToRect _obj row col 
  = withWxRectResult $
    withObjectRef "gridCellToRect" _obj $ \cobj__obj -> 
    wxGrid_CellToRect cobj__obj  (toCInt row)  (toCInt col)  
foreign import ccall "wxGrid_CellToRect" wxGrid_CellToRect :: Ptr (TGrid a) -> CInt -> CInt -> IO (Ptr (TWxRect ()))

-- | usage: (@gridClearGrid obj@).
gridClearGrid :: Grid  a ->  IO ()
gridClearGrid _obj 
  = withObjectRef "gridClearGrid" _obj $ \cobj__obj -> 
    wxGrid_ClearGrid cobj__obj  
foreign import ccall "wxGrid_ClearGrid" wxGrid_ClearGrid :: Ptr (TGrid a) -> IO ()

-- | usage: (@gridClearSelection obj@).
gridClearSelection :: Grid  a ->  IO ()
gridClearSelection _obj 
  = withObjectRef "gridClearSelection" _obj $ \cobj__obj -> 
    wxGrid_ClearSelection cobj__obj  
foreign import ccall "wxGrid_ClearSelection" wxGrid_ClearSelection :: Ptr (TGrid a) -> IO ()

-- | usage: (@gridCreate prt id lfttopwdthgt stl@).
gridCreate :: Window  a -> Id -> Rect -> Style ->  IO (Grid  ())
gridCreate _prt _id _lfttopwdthgt _stl 
  = withObjectResult $
    withObjectPtr _prt $ \cobj__prt -> 
    wxGrid_Create cobj__prt  (toCInt _id)  (toCIntRectX _lfttopwdthgt) (toCIntRectY _lfttopwdthgt)(toCIntRectW _lfttopwdthgt) (toCIntRectH _lfttopwdthgt)  (toCInt _stl)  
foreign import ccall "wxGrid_Create" wxGrid_Create :: Ptr (TWindow a) -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (TGrid ()))

-- | usage: (@gridCreateGrid obj rows cols selmode@).
gridCreateGrid :: Grid  a -> Int -> Int -> Int ->  IO ()
gridCreateGrid _obj rows cols selmode 
  = withObjectRef "gridCreateGrid" _obj $ \cobj__obj -> 
    wxGrid_CreateGrid cobj__obj  (toCInt rows)  (toCInt cols)  (toCInt selmode)  
foreign import ccall "wxGrid_CreateGrid" wxGrid_CreateGrid :: Ptr (TGrid a) -> CInt -> CInt -> CInt -> IO ()

-- | usage: (@gridDeleteCols obj pos numCols updateLabels@).
gridDeleteCols :: Grid  a -> Int -> Int -> Bool ->  IO Bool
gridDeleteCols _obj pos numCols updateLabels 
  = withBoolResult $
    withObjectRef "gridDeleteCols" _obj $ \cobj__obj -> 
    wxGrid_DeleteCols cobj__obj  (toCInt pos)  (toCInt numCols)  (toCBool updateLabels)  
foreign import ccall "wxGrid_DeleteCols" wxGrid_DeleteCols :: Ptr (TGrid a) -> CInt -> CInt -> CBool -> IO CBool

-- | usage: (@gridDeleteRows obj pos numRows updateLabels@).
gridDeleteRows :: Grid  a -> Int -> Int -> Bool ->  IO Bool
gridDeleteRows _obj pos numRows updateLabels 
  = withBoolResult $
    withObjectRef "gridDeleteRows" _obj $ \cobj__obj -> 
    wxGrid_DeleteRows cobj__obj  (toCInt pos)  (toCInt numRows)  (toCBool updateLabels)  
foreign import ccall "wxGrid_DeleteRows" wxGrid_DeleteRows :: Ptr (TGrid a) -> CInt -> CInt -> CBool -> IO CBool

-- | usage: (@gridDisableCellEditControl obj@).
gridDisableCellEditControl :: Grid  a ->  IO ()
gridDisableCellEditControl _obj 
  = withObjectRef "gridDisableCellEditControl" _obj $ \cobj__obj -> 
    wxGrid_DisableCellEditControl cobj__obj  
foreign import ccall "wxGrid_DisableCellEditControl" wxGrid_DisableCellEditControl :: Ptr (TGrid a) -> IO ()

-- | usage: (@gridDisableDragColSize obj@).
gridDisableDragColSize :: Grid  a ->  IO ()
gridDisableDragColSize _obj 
  = withObjectRef "gridDisableDragColSize" _obj $ \cobj__obj -> 
    wxGrid_DisableDragColSize cobj__obj  
foreign import ccall "wxGrid_DisableDragColSize" wxGrid_DisableDragColSize :: Ptr (TGrid a) -> IO ()

-- | usage: (@gridDisableDragGridSize obj@).
gridDisableDragGridSize :: Grid  a ->  IO ()
gridDisableDragGridSize _obj 
  = withObjectRef "gridDisableDragGridSize" _obj $ \cobj__obj -> 
    wxGrid_DisableDragGridSize cobj__obj  
foreign import ccall "wxGrid_DisableDragGridSize" wxGrid_DisableDragGridSize :: Ptr (TGrid a) -> IO ()

-- | usage: (@gridDisableDragRowSize obj@).
gridDisableDragRowSize :: Grid  a ->  IO ()
gridDisableDragRowSize _obj 
  = withObjectRef "gridDisableDragRowSize" _obj $ \cobj__obj -> 
    wxGrid_DisableDragRowSize cobj__obj  
foreign import ccall "wxGrid_DisableDragRowSize" wxGrid_DisableDragRowSize :: Ptr (TGrid a) -> IO ()

-- | usage: (@gridDoEndDragResizeCol obj@).
gridDoEndDragResizeCol :: Grid  a ->  IO ()
gridDoEndDragResizeCol _obj 
  = withObjectRef "gridDoEndDragResizeCol" _obj $ \cobj__obj -> 
    wxGrid_DoEndDragResizeCol cobj__obj  
foreign import ccall "wxGrid_DoEndDragResizeCol" wxGrid_DoEndDragResizeCol :: Ptr (TGrid a) -> IO ()

-- | usage: (@gridDoEndDragResizeRow obj@).
gridDoEndDragResizeRow :: Grid  a ->  IO ()
gridDoEndDragResizeRow _obj 
  = withObjectRef "gridDoEndDragResizeRow" _obj $ \cobj__obj -> 
    wxGrid_DoEndDragResizeRow cobj__obj  
foreign import ccall "wxGrid_DoEndDragResizeRow" wxGrid_DoEndDragResizeRow :: Ptr (TGrid a) -> IO ()

-- | usage: (@gridDrawAllGridLines obj dc reg@).
gridDrawAllGridLines :: Grid  a -> DC  b -> Region  c ->  IO ()
gridDrawAllGridLines _obj dc reg 
  = withObjectRef "gridDrawAllGridLines" _obj $ \cobj__obj -> 
    withObjectPtr dc $ \cobj_dc -> 
    withObjectPtr reg $ \cobj_reg -> 
    wxGrid_DrawAllGridLines cobj__obj  cobj_dc  cobj_reg  
foreign import ccall "wxGrid_DrawAllGridLines" wxGrid_DrawAllGridLines :: Ptr (TGrid a) -> Ptr (TDC b) -> Ptr (TRegion c) -> IO ()

-- | usage: (@gridDrawCell obj dc row col@).
gridDrawCell :: Grid  a -> DC  b -> Int -> Int ->  IO ()
gridDrawCell _obj dc _row _col 
  = withObjectRef "gridDrawCell" _obj $ \cobj__obj -> 
    withObjectPtr dc $ \cobj_dc -> 
    wxGrid_DrawCell cobj__obj  cobj_dc  (toCInt _row)  (toCInt _col)  
foreign import ccall "wxGrid_DrawCell" wxGrid_DrawCell :: Ptr (TGrid a) -> Ptr (TDC b) -> CInt -> CInt -> IO ()

-- | usage: (@gridDrawCellBorder obj dc row col@).
gridDrawCellBorder :: Grid  a -> DC  b -> Int -> Int ->  IO ()
gridDrawCellBorder _obj dc _row _col 
  = withObjectRef "gridDrawCellBorder" _obj $ \cobj__obj -> 
    withObjectPtr dc $ \cobj_dc -> 
    wxGrid_DrawCellBorder cobj__obj  cobj_dc  (toCInt _row)  (toCInt _col)  
foreign import ccall "wxGrid_DrawCellBorder" wxGrid_DrawCellBorder :: Ptr (TGrid a) -> Ptr (TDC b) -> CInt -> CInt -> IO ()

-- | usage: (@gridDrawCellHighlight obj dc attr@).
gridDrawCellHighlight :: Grid  a -> DC  b -> GridCellAttr  c ->  IO ()
gridDrawCellHighlight _obj dc attr 
  = withObjectRef "gridDrawCellHighlight" _obj $ \cobj__obj -> 
    withObjectPtr dc $ \cobj_dc -> 
    withObjectPtr attr $ \cobj_attr -> 
    wxGrid_DrawCellHighlight cobj__obj  cobj_dc  cobj_attr  
foreign import ccall "wxGrid_DrawCellHighlight" wxGrid_DrawCellHighlight :: Ptr (TGrid a) -> Ptr (TDC b) -> Ptr (TGridCellAttr c) -> IO ()

-- | usage: (@gridDrawColLabel obj dc col@).
gridDrawColLabel :: Grid  a -> DC  b -> Int ->  IO ()
gridDrawColLabel _obj dc col 
  = withObjectRef "gridDrawColLabel" _obj $ \cobj__obj -> 
    withObjectPtr dc $ \cobj_dc -> 
    wxGrid_DrawColLabel cobj__obj  cobj_dc  (toCInt col)  
foreign import ccall "wxGrid_DrawColLabel" wxGrid_DrawColLabel :: Ptr (TGrid a) -> Ptr (TDC b) -> CInt -> IO ()

-- | usage: (@gridDrawColLabels obj dc@).
gridDrawColLabels :: Grid  a -> DC  b ->  IO ()
gridDrawColLabels _obj dc 
  = withObjectRef "gridDrawColLabels" _obj $ \cobj__obj -> 
    withObjectPtr dc $ \cobj_dc -> 
    wxGrid_DrawColLabels cobj__obj  cobj_dc  
foreign import ccall "wxGrid_DrawColLabels" wxGrid_DrawColLabels :: Ptr (TGrid a) -> Ptr (TDC b) -> IO ()

-- | usage: (@gridDrawGridCellArea obj dc@).
gridDrawGridCellArea :: Grid  a -> DC  b ->  IO ()
gridDrawGridCellArea _obj dc 
  = withObjectRef "gridDrawGridCellArea" _obj $ \cobj__obj -> 
    withObjectPtr dc $ \cobj_dc -> 
    wxGrid_DrawGridCellArea cobj__obj  cobj_dc  
foreign import ccall "wxGrid_DrawGridCellArea" wxGrid_DrawGridCellArea :: Ptr (TGrid a) -> Ptr (TDC b) -> IO ()

-- | usage: (@gridDrawGridSpace obj dc@).
gridDrawGridSpace :: Grid  a -> DC  b ->  IO ()
gridDrawGridSpace _obj dc 
  = withObjectRef "gridDrawGridSpace" _obj $ \cobj__obj -> 
    withObjectPtr dc $ \cobj_dc -> 
    wxGrid_DrawGridSpace cobj__obj  cobj_dc  
foreign import ccall "wxGrid_DrawGridSpace" wxGrid_DrawGridSpace :: Ptr (TGrid a) -> Ptr (TDC b) -> IO ()

-- | usage: (@gridDrawHighlight obj dc@).
gridDrawHighlight :: Grid  a -> DC  b ->  IO ()
gridDrawHighlight _obj dc 
  = withObjectRef "gridDrawHighlight" _obj $ \cobj__obj -> 
    withObjectPtr dc $ \cobj_dc -> 
    wxGrid_DrawHighlight cobj__obj  cobj_dc  
foreign import ccall "wxGrid_DrawHighlight" wxGrid_DrawHighlight :: Ptr (TGrid a) -> Ptr (TDC b) -> IO ()

-- | usage: (@gridDrawRowLabel obj dc row@).
gridDrawRowLabel :: Grid  a -> DC  b -> Int ->  IO ()
gridDrawRowLabel _obj dc row 
  = withObjectRef "gridDrawRowLabel" _obj $ \cobj__obj -> 
    withObjectPtr dc $ \cobj_dc -> 
    wxGrid_DrawRowLabel cobj__obj  cobj_dc  (toCInt row)  
foreign import ccall "wxGrid_DrawRowLabel" wxGrid_DrawRowLabel :: Ptr (TGrid a) -> Ptr (TDC b) -> CInt -> IO ()

-- | usage: (@gridDrawRowLabels obj dc@).
gridDrawRowLabels :: Grid  a -> DC  b ->  IO ()
gridDrawRowLabels _obj dc 
  = withObjectRef "gridDrawRowLabels" _obj $ \cobj__obj -> 
    withObjectPtr dc $ \cobj_dc -> 
    wxGrid_DrawRowLabels cobj__obj  cobj_dc  
foreign import ccall "wxGrid_DrawRowLabels" wxGrid_DrawRowLabels :: Ptr (TGrid a) -> Ptr (TDC b) -> IO ()

-- | usage: (@gridDrawTextRectangle obj dc txt xywh horizontalAlignment verticalAlignment@).
gridDrawTextRectangle :: Grid  a -> DC  b -> String -> Rect -> Int -> Int ->  IO ()
gridDrawTextRectangle _obj dc txt xywh horizontalAlignment verticalAlignment 
  = withObjectRef "gridDrawTextRectangle" _obj $ \cobj__obj -> 
    withObjectPtr dc $ \cobj_dc -> 
    withStringPtr txt $ \cobj_txt -> 
    wxGrid_DrawTextRectangle cobj__obj  cobj_dc  cobj_txt  (toCIntRectX xywh) (toCIntRectY xywh)(toCIntRectW xywh) (toCIntRectH xywh)  (toCInt horizontalAlignment)  (toCInt verticalAlignment)  
foreign import ccall "wxGrid_DrawTextRectangle" wxGrid_DrawTextRectangle :: Ptr (TGrid a) -> Ptr (TDC b) -> Ptr (TWxString c) -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()

-- | usage: (@gridEditorCreatedEventGetCol obj@).
gridEditorCreatedEventGetCol :: GridEditorCreatedEvent  a ->  IO Int
gridEditorCreatedEventGetCol _obj 
  = withIntResult $
    withObjectRef "gridEditorCreatedEventGetCol" _obj $ \cobj__obj -> 
    wxGridEditorCreatedEvent_GetCol cobj__obj  
foreign import ccall "wxGridEditorCreatedEvent_GetCol" wxGridEditorCreatedEvent_GetCol :: Ptr (TGridEditorCreatedEvent a) -> IO CInt

-- | usage: (@gridEditorCreatedEventGetControl obj@).
gridEditorCreatedEventGetControl :: GridEditorCreatedEvent  a ->  IO (Control  ())
gridEditorCreatedEventGetControl _obj 
  = withObjectResult $
    withObjectRef "gridEditorCreatedEventGetControl" _obj $ \cobj__obj -> 
    wxGridEditorCreatedEvent_GetControl cobj__obj  
foreign import ccall "wxGridEditorCreatedEvent_GetControl" wxGridEditorCreatedEvent_GetControl :: Ptr (TGridEditorCreatedEvent a) -> IO (Ptr (TControl ()))

-- | usage: (@gridEditorCreatedEventGetRow obj@).
gridEditorCreatedEventGetRow :: GridEditorCreatedEvent  a ->  IO Int
gridEditorCreatedEventGetRow _obj 
  = withIntResult $
    withObjectRef "gridEditorCreatedEventGetRow" _obj $ \cobj__obj -> 
    wxGridEditorCreatedEvent_GetRow cobj__obj  
foreign import ccall "wxGridEditorCreatedEvent_GetRow" wxGridEditorCreatedEvent_GetRow :: Ptr (TGridEditorCreatedEvent a) -> IO CInt

-- | usage: (@gridEditorCreatedEventSetCol obj col@).
gridEditorCreatedEventSetCol :: GridEditorCreatedEvent  a -> Int ->  IO ()
gridEditorCreatedEventSetCol _obj col 
  = withObjectRef "gridEditorCreatedEventSetCol" _obj $ \cobj__obj -> 
    wxGridEditorCreatedEvent_SetCol cobj__obj  (toCInt col)  
foreign import ccall "wxGridEditorCreatedEvent_SetCol" wxGridEditorCreatedEvent_SetCol :: Ptr (TGridEditorCreatedEvent a) -> CInt -> IO ()

-- | usage: (@gridEditorCreatedEventSetControl obj ctrl@).
gridEditorCreatedEventSetControl :: GridEditorCreatedEvent  a -> Control  b ->  IO ()
gridEditorCreatedEventSetControl _obj ctrl 
  = withObjectRef "gridEditorCreatedEventSetControl" _obj $ \cobj__obj -> 
    withObjectPtr ctrl $ \cobj_ctrl -> 
    wxGridEditorCreatedEvent_SetControl cobj__obj  cobj_ctrl  
foreign import ccall "wxGridEditorCreatedEvent_SetControl" wxGridEditorCreatedEvent_SetControl :: Ptr (TGridEditorCreatedEvent a) -> Ptr (TControl b) -> IO ()

-- | usage: (@gridEditorCreatedEventSetRow obj row@).
gridEditorCreatedEventSetRow :: GridEditorCreatedEvent  a -> Int ->  IO ()
gridEditorCreatedEventSetRow _obj row 
  = withObjectRef "gridEditorCreatedEventSetRow" _obj $ \cobj__obj -> 
    wxGridEditorCreatedEvent_SetRow cobj__obj  (toCInt row)  
foreign import ccall "wxGridEditorCreatedEvent_SetRow" wxGridEditorCreatedEvent_SetRow :: Ptr (TGridEditorCreatedEvent a) -> CInt -> IO ()

-- | usage: (@gridEnableCellEditControl obj enable@).
gridEnableCellEditControl :: Grid  a -> Bool ->  IO ()
gridEnableCellEditControl _obj enable 
  = withObjectRef "gridEnableCellEditControl" _obj $ \cobj__obj -> 
    wxGrid_EnableCellEditControl cobj__obj  (toCBool enable)  
foreign import ccall "wxGrid_EnableCellEditControl" wxGrid_EnableCellEditControl :: Ptr (TGrid a) -> CBool -> IO ()

-- | usage: (@gridEnableDragColSize obj enable@).
gridEnableDragColSize :: Grid  a -> Bool ->  IO ()
gridEnableDragColSize _obj enable 
  = withObjectRef "gridEnableDragColSize" _obj $ \cobj__obj -> 
    wxGrid_EnableDragColSize cobj__obj  (toCBool enable)  
foreign import ccall "wxGrid_EnableDragColSize" wxGrid_EnableDragColSize :: Ptr (TGrid a) -> CBool -> IO ()

-- | usage: (@gridEnableDragGridSize obj enable@).
gridEnableDragGridSize :: Grid  a -> Bool ->  IO ()
gridEnableDragGridSize _obj enable 
  = withObjectRef "gridEnableDragGridSize" _obj $ \cobj__obj -> 
    wxGrid_EnableDragGridSize cobj__obj  (toCBool enable)  
foreign import ccall "wxGrid_EnableDragGridSize" wxGrid_EnableDragGridSize :: Ptr (TGrid a) -> CBool -> IO ()

-- | usage: (@gridEnableDragRowSize obj enable@).
gridEnableDragRowSize :: Grid  a -> Bool ->  IO ()
gridEnableDragRowSize _obj enable 
  = withObjectRef "gridEnableDragRowSize" _obj $ \cobj__obj -> 
    wxGrid_EnableDragRowSize cobj__obj  (toCBool enable)  
foreign import ccall "wxGrid_EnableDragRowSize" wxGrid_EnableDragRowSize :: Ptr (TGrid a) -> CBool -> IO ()

-- | usage: (@gridEnableEditing obj edit@).
gridEnableEditing :: Grid  a -> Bool ->  IO ()
gridEnableEditing _obj edit 
  = withObjectRef "gridEnableEditing" _obj $ \cobj__obj -> 
    wxGrid_EnableEditing cobj__obj  (toCBool edit)  
foreign import ccall "wxGrid_EnableEditing" wxGrid_EnableEditing :: Ptr (TGrid a) -> CBool -> IO ()

-- | usage: (@gridEnableGridLines obj enable@).
gridEnableGridLines :: Grid  a -> Bool ->  IO ()
gridEnableGridLines _obj enable 
  = withObjectRef "gridEnableGridLines" _obj $ \cobj__obj -> 
    wxGrid_EnableGridLines cobj__obj  (toCBool enable)  
foreign import ccall "wxGrid_EnableGridLines" wxGrid_EnableGridLines :: Ptr (TGrid a) -> CBool -> IO ()

-- | usage: (@gridEndBatch obj@).
gridEndBatch :: Grid  a ->  IO ()
gridEndBatch _obj 
  = withObjectRef "gridEndBatch" _obj $ \cobj__obj -> 
    wxGrid_EndBatch cobj__obj  
foreign import ccall "wxGrid_EndBatch" wxGrid_EndBatch :: Ptr (TGrid a) -> IO ()

-- | usage: (@gridEventAltDown obj@).
gridEventAltDown :: GridEvent  a ->  IO Bool
gridEventAltDown _obj 
  = withBoolResult $
    withObjectRef "gridEventAltDown" _obj $ \cobj__obj -> 
    wxGridEvent_AltDown cobj__obj  
foreign import ccall "wxGridEvent_AltDown" wxGridEvent_AltDown :: Ptr (TGridEvent a) -> IO CBool

-- | usage: (@gridEventControlDown obj@).
gridEventControlDown :: GridEvent  a ->  IO Bool
gridEventControlDown _obj 
  = withBoolResult $
    withObjectRef "gridEventControlDown" _obj $ \cobj__obj -> 
    wxGridEvent_ControlDown cobj__obj  
foreign import ccall "wxGridEvent_ControlDown" wxGridEvent_ControlDown :: Ptr (TGridEvent a) -> IO CBool

-- | usage: (@gridEventGetCol obj@).
gridEventGetCol :: GridEvent  a ->  IO Int
gridEventGetCol _obj 
  = withIntResult $
    withObjectRef "gridEventGetCol" _obj $ \cobj__obj -> 
    wxGridEvent_GetCol cobj__obj  
foreign import ccall "wxGridEvent_GetCol" wxGridEvent_GetCol :: Ptr (TGridEvent a) -> IO CInt

-- | usage: (@gridEventGetPosition obj@).
gridEventGetPosition :: GridEvent  a ->  IO (Point)
gridEventGetPosition _obj 
  = withWxPointResult $
    withObjectRef "gridEventGetPosition" _obj $ \cobj__obj -> 
    wxGridEvent_GetPosition cobj__obj  
foreign import ccall "wxGridEvent_GetPosition" wxGridEvent_GetPosition :: Ptr (TGridEvent a) -> IO (Ptr (TWxPoint ()))

-- | usage: (@gridEventGetRow obj@).
gridEventGetRow :: GridEvent  a ->  IO Int
gridEventGetRow _obj 
  = withIntResult $
    withObjectRef "gridEventGetRow" _obj $ \cobj__obj -> 
    wxGridEvent_GetRow cobj__obj  
foreign import ccall "wxGridEvent_GetRow" wxGridEvent_GetRow :: Ptr (TGridEvent a) -> IO CInt

-- | usage: (@gridEventMetaDown obj@).
gridEventMetaDown :: GridEvent  a ->  IO Bool
gridEventMetaDown _obj 
  = withBoolResult $
    withObjectRef "gridEventMetaDown" _obj $ \cobj__obj -> 
    wxGridEvent_MetaDown cobj__obj  
foreign import ccall "wxGridEvent_MetaDown" wxGridEvent_MetaDown :: Ptr (TGridEvent a) -> IO CBool

-- | usage: (@gridEventSelecting obj@).
gridEventSelecting :: GridEvent  a ->  IO Bool
gridEventSelecting _obj 
  = withBoolResult $
    withObjectRef "gridEventSelecting" _obj $ \cobj__obj -> 
    wxGridEvent_Selecting cobj__obj  
foreign import ccall "wxGridEvent_Selecting" wxGridEvent_Selecting :: Ptr (TGridEvent a) -> IO CBool

-- | usage: (@gridEventShiftDown obj@).
gridEventShiftDown :: GridEvent  a ->  IO Bool
gridEventShiftDown _obj 
  = withBoolResult $
    withObjectRef "gridEventShiftDown" _obj $ \cobj__obj -> 
    wxGridEvent_ShiftDown cobj__obj  
foreign import ccall "wxGridEvent_ShiftDown" wxGridEvent_ShiftDown :: Ptr (TGridEvent a) -> IO CBool

-- | usage: (@gridGetBatchCount obj@).
gridGetBatchCount :: Grid  a ->  IO Int
gridGetBatchCount _obj 
  = withIntResult $
    withObjectRef "gridGetBatchCount" _obj $ \cobj__obj -> 
    wxGrid_GetBatchCount cobj__obj  
foreign import ccall "wxGrid_GetBatchCount" wxGrid_GetBatchCount :: Ptr (TGrid a) -> IO CInt

-- | usage: (@gridGetCellAlignment obj row col@).
gridGetCellAlignment :: Grid  a -> Int -> Int ->  IO Size
gridGetCellAlignment _obj row col 
  = withSizeResult $ \pw ph -> 
    withObjectRef "gridGetCellAlignment" _obj $ \cobj__obj -> 
    wxGrid_GetCellAlignment cobj__obj  (toCInt row)  (toCInt col)   pw ph
foreign import ccall "wxGrid_GetCellAlignment" wxGrid_GetCellAlignment :: Ptr (TGrid a) -> CInt -> CInt -> Ptr CInt -> Ptr CInt -> IO ()

-- | usage: (@gridGetCellBackgroundColour obj row col colour@).
gridGetCellBackgroundColour :: Grid  a -> Int -> Int -> Color ->  IO ()
gridGetCellBackgroundColour _obj row col colour 
  = withObjectRef "gridGetCellBackgroundColour" _obj $ \cobj__obj -> 
    withColourPtr colour $ \cobj_colour -> 
    wxGrid_GetCellBackgroundColour cobj__obj  (toCInt row)  (toCInt col)  cobj_colour  
foreign import ccall "wxGrid_GetCellBackgroundColour" wxGrid_GetCellBackgroundColour :: Ptr (TGrid a) -> CInt -> CInt -> Ptr (TColour d) -> IO ()

-- | usage: (@gridGetCellEditor obj row col@).
gridGetCellEditor :: Grid  a -> Int -> Int ->  IO (GridCellEditor  ())
gridGetCellEditor _obj row col 
  = withObjectResult $
    withObjectRef "gridGetCellEditor" _obj $ \cobj__obj -> 
    wxGrid_GetCellEditor cobj__obj  (toCInt row)  (toCInt col)  
foreign import ccall "wxGrid_GetCellEditor" wxGrid_GetCellEditor :: Ptr (TGrid a) -> CInt -> CInt -> IO (Ptr (TGridCellEditor ()))

-- | usage: (@gridGetCellFont obj row col font@).
gridGetCellFont :: Grid  a -> Int -> Int -> Font  d ->  IO ()
gridGetCellFont _obj row col font 
  = withObjectRef "gridGetCellFont" _obj $ \cobj__obj -> 
    withObjectPtr font $ \cobj_font -> 
    wxGrid_GetCellFont cobj__obj  (toCInt row)  (toCInt col)  cobj_font  
foreign import ccall "wxGrid_GetCellFont" wxGrid_GetCellFont :: Ptr (TGrid a) -> CInt -> CInt -> Ptr (TFont d) -> IO ()

-- | usage: (@gridGetCellHighlightColour obj@).
gridGetCellHighlightColour :: Grid  a ->  IO (Color)
gridGetCellHighlightColour _obj 
  = withRefColour $ \pref -> 
    withObjectRef "gridGetCellHighlightColour" _obj $ \cobj__obj -> 
    wxGrid_GetCellHighlightColour cobj__obj   pref
foreign import ccall "wxGrid_GetCellHighlightColour" wxGrid_GetCellHighlightColour :: Ptr (TGrid a) -> Ptr (TColour ()) -> IO ()

-- | usage: (@gridGetCellRenderer obj row col@).
gridGetCellRenderer :: Grid  a -> Int -> Int ->  IO (GridCellRenderer  ())
gridGetCellRenderer _obj row col 
  = withObjectResult $
    withObjectRef "gridGetCellRenderer" _obj $ \cobj__obj -> 
    wxGrid_GetCellRenderer cobj__obj  (toCInt row)  (toCInt col)  
foreign import ccall "wxGrid_GetCellRenderer" wxGrid_GetCellRenderer :: Ptr (TGrid a) -> CInt -> CInt -> IO (Ptr (TGridCellRenderer ()))

-- | usage: (@gridGetCellTextColour obj row col colour@).
gridGetCellTextColour :: Grid  a -> Int -> Int -> Color ->  IO ()
gridGetCellTextColour _obj row col colour 
  = withObjectRef "gridGetCellTextColour" _obj $ \cobj__obj -> 
    withColourPtr colour $ \cobj_colour -> 
    wxGrid_GetCellTextColour cobj__obj  (toCInt row)  (toCInt col)  cobj_colour  
foreign import ccall "wxGrid_GetCellTextColour" wxGrid_GetCellTextColour :: Ptr (TGrid a) -> CInt -> CInt -> Ptr (TColour d) -> IO ()

-- | usage: (@gridGetCellValue obj row col@).
gridGetCellValue :: Grid  a -> Int -> Int ->  IO (String)
gridGetCellValue _obj row col 
  = withManagedStringResult $
    withObjectRef "gridGetCellValue" _obj $ \cobj__obj -> 
    wxGrid_GetCellValue cobj__obj  (toCInt row)  (toCInt col)  
foreign import ccall "wxGrid_GetCellValue" wxGrid_GetCellValue :: Ptr (TGrid a) -> CInt -> CInt -> IO (Ptr (TWxString ()))

-- | usage: (@gridGetColLabelAlignment obj@).
gridGetColLabelAlignment :: Grid  a ->  IO Size
gridGetColLabelAlignment _obj 
  = withSizeResult $ \pw ph -> 
    withObjectRef "gridGetColLabelAlignment" _obj $ \cobj__obj -> 
    wxGrid_GetColLabelAlignment cobj__obj   pw ph
foreign import ccall "wxGrid_GetColLabelAlignment" wxGrid_GetColLabelAlignment :: Ptr (TGrid a) -> Ptr CInt -> Ptr CInt -> IO ()

-- | usage: (@gridGetColLabelSize obj@).
gridGetColLabelSize :: Grid  a ->  IO Int
gridGetColLabelSize _obj 
  = withIntResult $
    withObjectRef "gridGetColLabelSize" _obj $ \cobj__obj -> 
    wxGrid_GetColLabelSize cobj__obj  
foreign import ccall "wxGrid_GetColLabelSize" wxGrid_GetColLabelSize :: Ptr (TGrid a) -> IO CInt

-- | usage: (@gridGetColLabelValue obj col@).
gridGetColLabelValue :: Grid  a -> Int ->  IO (String)
gridGetColLabelValue _obj col 
  = withManagedStringResult $
    withObjectRef "gridGetColLabelValue" _obj $ \cobj__obj -> 
    wxGrid_GetColLabelValue cobj__obj  (toCInt col)  
foreign import ccall "wxGrid_GetColLabelValue" wxGrid_GetColLabelValue :: Ptr (TGrid a) -> CInt -> IO (Ptr (TWxString ()))

-- | usage: (@gridGetColSize obj col@).
gridGetColSize :: Grid  a -> Int ->  IO Int
gridGetColSize _obj col 
  = withIntResult $
    withObjectRef "gridGetColSize" _obj $ \cobj__obj -> 
    wxGrid_GetColSize cobj__obj  (toCInt col)  
foreign import ccall "wxGrid_GetColSize" wxGrid_GetColSize :: Ptr (TGrid a) -> CInt -> IO CInt

-- | usage: (@gridGetDefaultCellAlignment obj@).
gridGetDefaultCellAlignment :: Grid  a ->  IO Size
gridGetDefaultCellAlignment _obj 
  = withSizeResult $ \pw ph -> 
    withObjectRef "gridGetDefaultCellAlignment" _obj $ \cobj__obj -> 
    wxGrid_GetDefaultCellAlignment cobj__obj   pw ph
foreign import ccall "wxGrid_GetDefaultCellAlignment" wxGrid_GetDefaultCellAlignment :: Ptr (TGrid a) -> Ptr CInt -> Ptr CInt -> IO ()

-- | usage: (@gridGetDefaultCellBackgroundColour obj@).
gridGetDefaultCellBackgroundColour :: Grid  a ->  IO (Color)
gridGetDefaultCellBackgroundColour _obj 
  = withRefColour $ \pref -> 
    withObjectRef "gridGetDefaultCellBackgroundColour" _obj $ \cobj__obj -> 
    wxGrid_GetDefaultCellBackgroundColour cobj__obj   pref
foreign import ccall "wxGrid_GetDefaultCellBackgroundColour" wxGrid_GetDefaultCellBackgroundColour :: Ptr (TGrid a) -> Ptr (TColour ()) -> IO ()

-- | usage: (@gridGetDefaultCellFont obj@).
gridGetDefaultCellFont :: Grid  a ->  IO (Font  ())
gridGetDefaultCellFont _obj 
  = withRefFont $ \pref -> 
    withObjectRef "gridGetDefaultCellFont" _obj $ \cobj__obj -> 
    wxGrid_GetDefaultCellFont cobj__obj   pref
foreign import ccall "wxGrid_GetDefaultCellFont" wxGrid_GetDefaultCellFont :: Ptr (TGrid a) -> Ptr (TFont ()) -> IO ()

-- | usage: (@gridGetDefaultCellTextColour obj@).
gridGetDefaultCellTextColour :: Grid  a ->  IO (Color)
gridGetDefaultCellTextColour _obj 
  = withRefColour $ \pref -> 
    withObjectRef "gridGetDefaultCellTextColour" _obj $ \cobj__obj -> 
    wxGrid_GetDefaultCellTextColour cobj__obj   pref
foreign import ccall "wxGrid_GetDefaultCellTextColour" wxGrid_GetDefaultCellTextColour :: Ptr (TGrid a) -> Ptr (TColour ()) -> IO ()

-- | usage: (@gridGetDefaultColLabelSize obj@).
gridGetDefaultColLabelSize :: Grid  a ->  IO Int
gridGetDefaultColLabelSize _obj 
  = withIntResult $
    withObjectRef "gridGetDefaultColLabelSize" _obj $ \cobj__obj -> 
    wxGrid_GetDefaultColLabelSize cobj__obj  
foreign import ccall "wxGrid_GetDefaultColLabelSize" wxGrid_GetDefaultColLabelSize :: Ptr (TGrid a) -> IO CInt

-- | usage: (@gridGetDefaultColSize obj@).
gridGetDefaultColSize :: Grid  a ->  IO Int
gridGetDefaultColSize _obj 
  = withIntResult $
    withObjectRef "gridGetDefaultColSize" _obj $ \cobj__obj -> 
    wxGrid_GetDefaultColSize cobj__obj  
foreign import ccall "wxGrid_GetDefaultColSize" wxGrid_GetDefaultColSize :: Ptr (TGrid a) -> IO CInt

-- | usage: (@gridGetDefaultEditor obj@).
gridGetDefaultEditor :: Grid  a ->  IO (GridCellEditor  ())
gridGetDefaultEditor _obj 
  = withObjectResult $
    withObjectRef "gridGetDefaultEditor" _obj $ \cobj__obj -> 
    wxGrid_GetDefaultEditor cobj__obj  
foreign import ccall "wxGrid_GetDefaultEditor" wxGrid_GetDefaultEditor :: Ptr (TGrid a) -> IO (Ptr (TGridCellEditor ()))

-- | usage: (@gridGetDefaultEditorForCell obj row col@).
gridGetDefaultEditorForCell :: Grid  a -> Int -> Int ->  IO (GridCellEditor  ())
gridGetDefaultEditorForCell _obj row col 
  = withObjectResult $
    withObjectRef "gridGetDefaultEditorForCell" _obj $ \cobj__obj -> 
    wxGrid_GetDefaultEditorForCell cobj__obj  (toCInt row)  (toCInt col)  
foreign import ccall "wxGrid_GetDefaultEditorForCell" wxGrid_GetDefaultEditorForCell :: Ptr (TGrid a) -> CInt -> CInt -> IO (Ptr (TGridCellEditor ()))

-- | usage: (@gridGetDefaultEditorForType obj typeName@).
gridGetDefaultEditorForType :: Grid  a -> String ->  IO (GridCellEditor  ())
gridGetDefaultEditorForType _obj typeName 
  = withObjectResult $
    withObjectRef "gridGetDefaultEditorForType" _obj $ \cobj__obj -> 
    withStringPtr typeName $ \cobj_typeName -> 
    wxGrid_GetDefaultEditorForType cobj__obj  cobj_typeName  
foreign import ccall "wxGrid_GetDefaultEditorForType" wxGrid_GetDefaultEditorForType :: Ptr (TGrid a) -> Ptr (TWxString b) -> IO (Ptr (TGridCellEditor ()))

-- | usage: (@gridGetDefaultRenderer obj@).
gridGetDefaultRenderer :: Grid  a ->  IO (GridCellRenderer  ())
gridGetDefaultRenderer _obj 
  = withObjectResult $
    withObjectRef "gridGetDefaultRenderer" _obj $ \cobj__obj -> 
    wxGrid_GetDefaultRenderer cobj__obj  
foreign import ccall "wxGrid_GetDefaultRenderer" wxGrid_GetDefaultRenderer :: Ptr (TGrid a) -> IO (Ptr (TGridCellRenderer ()))

-- | usage: (@gridGetDefaultRendererForCell obj row col@).
gridGetDefaultRendererForCell :: Grid  a -> Int -> Int ->  IO (GridCellRenderer  ())
gridGetDefaultRendererForCell _obj row col 
  = withObjectResult $
    withObjectRef "gridGetDefaultRendererForCell" _obj $ \cobj__obj -> 
    wxGrid_GetDefaultRendererForCell cobj__obj  (toCInt row)  (toCInt col)  
foreign import ccall "wxGrid_GetDefaultRendererForCell" wxGrid_GetDefaultRendererForCell :: Ptr (TGrid a) -> CInt -> CInt -> IO (Ptr (TGridCellRenderer ()))

-- | usage: (@gridGetDefaultRendererForType obj typeName@).
gridGetDefaultRendererForType :: Grid  a -> String ->  IO (GridCellRenderer  ())
gridGetDefaultRendererForType _obj typeName 
  = withObjectResult $
    withObjectRef "gridGetDefaultRendererForType" _obj $ \cobj__obj -> 
    withStringPtr typeName $ \cobj_typeName -> 
    wxGrid_GetDefaultRendererForType cobj__obj  cobj_typeName  
foreign import ccall "wxGrid_GetDefaultRendererForType" wxGrid_GetDefaultRendererForType :: Ptr (TGrid a) -> Ptr (TWxString b) -> IO (Ptr (TGridCellRenderer ()))

-- | usage: (@gridGetDefaultRowLabelSize obj@).
gridGetDefaultRowLabelSize :: Grid  a ->  IO Int
gridGetDefaultRowLabelSize _obj 
  = withIntResult $
    withObjectRef "gridGetDefaultRowLabelSize" _obj $ \cobj__obj -> 
    wxGrid_GetDefaultRowLabelSize cobj__obj  
foreign import ccall "wxGrid_GetDefaultRowLabelSize" wxGrid_GetDefaultRowLabelSize :: Ptr (TGrid a) -> IO CInt

-- | usage: (@gridGetDefaultRowSize obj@).
gridGetDefaultRowSize :: Grid  a ->  IO Int
gridGetDefaultRowSize _obj 
  = withIntResult $
    withObjectRef "gridGetDefaultRowSize" _obj $ \cobj__obj -> 
    wxGrid_GetDefaultRowSize cobj__obj  
foreign import ccall "wxGrid_GetDefaultRowSize" wxGrid_GetDefaultRowSize :: Ptr (TGrid a) -> IO CInt

-- | usage: (@gridGetGridCursorCol obj@).
gridGetGridCursorCol :: Grid  a ->  IO Int
gridGetGridCursorCol _obj 
  = withIntResult $
    withObjectRef "gridGetGridCursorCol" _obj $ \cobj__obj -> 
    wxGrid_GetGridCursorCol cobj__obj  
foreign import ccall "wxGrid_GetGridCursorCol" wxGrid_GetGridCursorCol :: Ptr (TGrid a) -> IO CInt

-- | usage: (@gridGetGridCursorRow obj@).
gridGetGridCursorRow :: Grid  a ->  IO Int
gridGetGridCursorRow _obj 
  = withIntResult $
    withObjectRef "gridGetGridCursorRow" _obj $ \cobj__obj -> 
    wxGrid_GetGridCursorRow cobj__obj  
foreign import ccall "wxGrid_GetGridCursorRow" wxGrid_GetGridCursorRow :: Ptr (TGrid a) -> IO CInt

-- | usage: (@gridGetGridLineColour obj@).
gridGetGridLineColour :: Grid  a ->  IO (Color)
gridGetGridLineColour _obj 
  = withRefColour $ \pref -> 
    withObjectRef "gridGetGridLineColour" _obj $ \cobj__obj -> 
    wxGrid_GetGridLineColour cobj__obj   pref
foreign import ccall "wxGrid_GetGridLineColour" wxGrid_GetGridLineColour :: Ptr (TGrid a) -> Ptr (TColour ()) -> IO ()

-- | usage: (@gridGetLabelBackgroundColour obj@).
gridGetLabelBackgroundColour :: Grid  a ->  IO (Color)
gridGetLabelBackgroundColour _obj 
  = withRefColour $ \pref -> 
    withObjectRef "gridGetLabelBackgroundColour" _obj $ \cobj__obj -> 
    wxGrid_GetLabelBackgroundColour cobj__obj   pref
foreign import ccall "wxGrid_GetLabelBackgroundColour" wxGrid_GetLabelBackgroundColour :: Ptr (TGrid a) -> Ptr (TColour ()) -> IO ()

-- | usage: (@gridGetLabelFont obj@).
gridGetLabelFont :: Grid  a ->  IO (Font  ())
gridGetLabelFont _obj 
  = withRefFont $ \pref -> 
    withObjectRef "gridGetLabelFont" _obj $ \cobj__obj -> 
    wxGrid_GetLabelFont cobj__obj   pref
foreign import ccall "wxGrid_GetLabelFont" wxGrid_GetLabelFont :: Ptr (TGrid a) -> Ptr (TFont ()) -> IO ()

-- | usage: (@gridGetLabelTextColour obj@).
gridGetLabelTextColour :: Grid  a ->  IO (Color)
gridGetLabelTextColour _obj 
  = withRefColour $ \pref -> 
    withObjectRef "gridGetLabelTextColour" _obj $ \cobj__obj -> 
    wxGrid_GetLabelTextColour cobj__obj   pref
foreign import ccall "wxGrid_GetLabelTextColour" wxGrid_GetLabelTextColour :: Ptr (TGrid a) -> Ptr (TColour ()) -> IO ()

-- | usage: (@gridGetNumberCols obj@).
gridGetNumberCols :: Grid  a ->  IO Int
gridGetNumberCols _obj 
  = withIntResult $
    withObjectRef "gridGetNumberCols" _obj $ \cobj__obj -> 
    wxGrid_GetNumberCols cobj__obj  
foreign import ccall "wxGrid_GetNumberCols" wxGrid_GetNumberCols :: Ptr (TGrid a) -> IO CInt

-- | usage: (@gridGetNumberRows obj@).
gridGetNumberRows :: Grid  a ->  IO Int
gridGetNumberRows _obj 
  = withIntResult $
    withObjectRef "gridGetNumberRows" _obj $ \cobj__obj -> 
    wxGrid_GetNumberRows cobj__obj  
foreign import ccall "wxGrid_GetNumberRows" wxGrid_GetNumberRows :: Ptr (TGrid a) -> IO CInt

-- | usage: (@gridGetRowLabelAlignment obj@).
gridGetRowLabelAlignment :: Grid  a ->  IO Size
gridGetRowLabelAlignment _obj 
  = withSizeResult $ \pw ph -> 
    withObjectRef "gridGetRowLabelAlignment" _obj $ \cobj__obj -> 
    wxGrid_GetRowLabelAlignment cobj__obj   pw ph
foreign import ccall "wxGrid_GetRowLabelAlignment" wxGrid_GetRowLabelAlignment :: Ptr (TGrid a) -> Ptr CInt -> Ptr CInt -> IO ()

-- | usage: (@gridGetRowLabelSize obj@).
gridGetRowLabelSize :: Grid  a ->  IO Int
gridGetRowLabelSize _obj 
  = withIntResult $
    withObjectRef "gridGetRowLabelSize" _obj $ \cobj__obj -> 
    wxGrid_GetRowLabelSize cobj__obj  
foreign import ccall "wxGrid_GetRowLabelSize" wxGrid_GetRowLabelSize :: Ptr (TGrid a) -> IO CInt

-- | usage: (@gridGetRowLabelValue obj row@).
gridGetRowLabelValue :: Grid  a -> Int ->  IO (String)
gridGetRowLabelValue _obj row 
  = withManagedStringResult $
    withObjectRef "gridGetRowLabelValue" _obj $ \cobj__obj -> 
    wxGrid_GetRowLabelValue cobj__obj  (toCInt row)  
foreign import ccall "wxGrid_GetRowLabelValue" wxGrid_GetRowLabelValue :: Ptr (TGrid a) -> CInt -> IO (Ptr (TWxString ()))

-- | usage: (@gridGetRowSize obj row@).
gridGetRowSize :: Grid  a -> Int ->  IO Int
gridGetRowSize _obj row 
  = withIntResult $
    withObjectRef "gridGetRowSize" _obj $ \cobj__obj -> 
    wxGrid_GetRowSize cobj__obj  (toCInt row)  
foreign import ccall "wxGrid_GetRowSize" wxGrid_GetRowSize :: Ptr (TGrid a) -> CInt -> IO CInt

-- | usage: (@gridGetSelectedCells obj@).
gridGetSelectedCells :: Grid  a ->  IO (GridCellCoordsArray  ())
gridGetSelectedCells _obj 
  = withRefGridCellCoordsArray $ \pref -> 
    withObjectRef "gridGetSelectedCells" _obj $ \cobj__obj -> 
    wxGrid_GetSelectedCells cobj__obj   pref
foreign import ccall "wxGrid_GetSelectedCells" wxGrid_GetSelectedCells :: Ptr (TGrid a) -> Ptr (TGridCellCoordsArray ()) -> IO ()

-- | usage: (@gridGetSelectedCols obj@).
gridGetSelectedCols :: Grid  a ->  IO [Int]
gridGetSelectedCols _obj 
  = withArrayIntResult $ \arr -> 
    withObjectRef "gridGetSelectedCols" _obj $ \cobj__obj -> 
    wxGrid_GetSelectedCols cobj__obj   arr
foreign import ccall "wxGrid_GetSelectedCols" wxGrid_GetSelectedCols :: Ptr (TGrid a) -> Ptr CInt -> IO CInt

-- | usage: (@gridGetSelectedRows obj@).
gridGetSelectedRows :: Grid  a ->  IO [Int]
gridGetSelectedRows _obj 
  = withArrayIntResult $ \arr -> 
    withObjectRef "gridGetSelectedRows" _obj $ \cobj__obj -> 
    wxGrid_GetSelectedRows cobj__obj   arr
foreign import ccall "wxGrid_GetSelectedRows" wxGrid_GetSelectedRows :: Ptr (TGrid a) -> Ptr CInt -> IO CInt

-- | usage: (@gridGetSelectionBackground obj@).
gridGetSelectionBackground :: Grid  a ->  IO (Color)
gridGetSelectionBackground _obj 
  = withRefColour $ \pref -> 
    withObjectRef "gridGetSelectionBackground" _obj $ \cobj__obj -> 
    wxGrid_GetSelectionBackground cobj__obj   pref
foreign import ccall "wxGrid_GetSelectionBackground" wxGrid_GetSelectionBackground :: Ptr (TGrid a) -> Ptr (TColour ()) -> IO ()

-- | usage: (@gridGetSelectionBlockBottomRight obj@).
gridGetSelectionBlockBottomRight :: Grid  a ->  IO (GridCellCoordsArray  ())
gridGetSelectionBlockBottomRight _obj 
  = withRefGridCellCoordsArray $ \pref -> 
    withObjectRef "gridGetSelectionBlockBottomRight" _obj $ \cobj__obj -> 
    wxGrid_GetSelectionBlockBottomRight cobj__obj   pref
foreign import ccall "wxGrid_GetSelectionBlockBottomRight" wxGrid_GetSelectionBlockBottomRight :: Ptr (TGrid a) -> Ptr (TGridCellCoordsArray ()) -> IO ()

-- | usage: (@gridGetSelectionBlockTopLeft obj@).
gridGetSelectionBlockTopLeft :: Grid  a ->  IO (GridCellCoordsArray  ())
gridGetSelectionBlockTopLeft _obj 
  = withRefGridCellCoordsArray $ \pref -> 
    withObjectRef "gridGetSelectionBlockTopLeft" _obj $ \cobj__obj -> 
    wxGrid_GetSelectionBlockTopLeft cobj__obj   pref
foreign import ccall "wxGrid_GetSelectionBlockTopLeft" wxGrid_GetSelectionBlockTopLeft :: Ptr (TGrid a) -> Ptr (TGridCellCoordsArray ()) -> IO ()

-- | usage: (@gridGetSelectionForeground obj@).
gridGetSelectionForeground :: Grid  a ->  IO (Color)
gridGetSelectionForeground _obj 
  = withRefColour $ \pref -> 
    withObjectRef "gridGetSelectionForeground" _obj $ \cobj__obj -> 
    wxGrid_GetSelectionForeground cobj__obj   pref
foreign import ccall "wxGrid_GetSelectionForeground" wxGrid_GetSelectionForeground :: Ptr (TGrid a) -> Ptr (TColour ()) -> IO ()

-- | usage: (@gridGetTable obj@).
gridGetTable :: Grid  a ->  IO (GridTableBase  ())
gridGetTable _obj 
  = withObjectResult $
    withObjectRef "gridGetTable" _obj $ \cobj__obj -> 
    wxGrid_GetTable cobj__obj  
foreign import ccall "wxGrid_GetTable" wxGrid_GetTable :: Ptr (TGrid a) -> IO (Ptr (TGridTableBase ()))

-- | usage: (@gridGetTextBoxSize obj dc countlines@).
gridGetTextBoxSize :: Grid  a -> DC  b -> [String] ->  IO Size
gridGetTextBoxSize _obj dc countlines 
  = withSizeResult $ \pw ph -> 
    withObjectRef "gridGetTextBoxSize" _obj $ \cobj__obj -> 
    withObjectPtr dc $ \cobj_dc -> 
    withArrayWString countlines $ \carrlen_countlines carr_countlines -> 
    wxGrid_GetTextBoxSize cobj__obj  cobj_dc  carrlen_countlines carr_countlines   pw ph
foreign import ccall "wxGrid_GetTextBoxSize" wxGrid_GetTextBoxSize :: Ptr (TGrid a) -> Ptr (TDC b) -> CInt -> Ptr (Ptr CWchar) -> Ptr CInt -> Ptr CInt -> IO ()

-- | usage: (@gridGridLinesEnabled obj@).
gridGridLinesEnabled :: Grid  a ->  IO Int
gridGridLinesEnabled _obj 
  = withIntResult $
    withObjectRef "gridGridLinesEnabled" _obj $ \cobj__obj -> 
    wxGrid_GridLinesEnabled cobj__obj  
foreign import ccall "wxGrid_GridLinesEnabled" wxGrid_GridLinesEnabled :: Ptr (TGrid a) -> IO CInt

-- | usage: (@gridHideCellEditControl obj@).
gridHideCellEditControl :: Grid  a ->  IO ()
gridHideCellEditControl _obj 
  = withObjectRef "gridHideCellEditControl" _obj $ \cobj__obj -> 
    wxGrid_HideCellEditControl cobj__obj  
foreign import ccall "wxGrid_HideCellEditControl" wxGrid_HideCellEditControl :: Ptr (TGrid a) -> IO ()

-- | usage: (@gridInsertCols obj pos numCols updateLabels@).
gridInsertCols :: Grid  a -> Int -> Int -> Bool ->  IO Bool
gridInsertCols _obj pos numCols updateLabels 
  = withBoolResult $
    withObjectRef "gridInsertCols" _obj $ \cobj__obj -> 
    wxGrid_InsertCols cobj__obj  (toCInt pos)  (toCInt numCols)  (toCBool updateLabels)  
foreign import ccall "wxGrid_InsertCols" wxGrid_InsertCols :: Ptr (TGrid a) -> CInt -> CInt -> CBool -> IO CBool

-- | usage: (@gridInsertRows obj pos numRows updateLabels@).
gridInsertRows :: Grid  a -> Int -> Int -> Bool ->  IO Bool
gridInsertRows _obj pos numRows updateLabels 
  = withBoolResult $
    withObjectRef "gridInsertRows" _obj $ \cobj__obj -> 
    wxGrid_InsertRows cobj__obj  (toCInt pos)  (toCInt numRows)  (toCBool updateLabels)  
foreign import ccall "wxGrid_InsertRows" wxGrid_InsertRows :: Ptr (TGrid a) -> CInt -> CInt -> CBool -> IO CBool

-- | usage: (@gridIsCellEditControlEnabled obj@).
gridIsCellEditControlEnabled :: Grid  a ->  IO Bool
gridIsCellEditControlEnabled _obj 
  = withBoolResult $
    withObjectRef "gridIsCellEditControlEnabled" _obj $ \cobj__obj -> 
    wxGrid_IsCellEditControlEnabled cobj__obj  
foreign import ccall "wxGrid_IsCellEditControlEnabled" wxGrid_IsCellEditControlEnabled :: Ptr (TGrid a) -> IO CBool

-- | usage: (@gridIsCellEditControlShown obj@).
gridIsCellEditControlShown :: Grid  a ->  IO Bool
gridIsCellEditControlShown _obj 
  = withBoolResult $
    withObjectRef "gridIsCellEditControlShown" _obj $ \cobj__obj -> 
    wxGrid_IsCellEditControlShown cobj__obj  
foreign import ccall "wxGrid_IsCellEditControlShown" wxGrid_IsCellEditControlShown :: Ptr (TGrid a) -> IO CBool

-- | usage: (@gridIsCurrentCellReadOnly obj@).
gridIsCurrentCellReadOnly :: Grid  a ->  IO Bool
gridIsCurrentCellReadOnly _obj 
  = withBoolResult $
    withObjectRef "gridIsCurrentCellReadOnly" _obj $ \cobj__obj -> 
    wxGrid_IsCurrentCellReadOnly cobj__obj  
foreign import ccall "wxGrid_IsCurrentCellReadOnly" wxGrid_IsCurrentCellReadOnly :: Ptr (TGrid a) -> IO CBool

-- | usage: (@gridIsEditable obj@).
gridIsEditable :: Grid  a ->  IO Bool
gridIsEditable _obj 
  = withBoolResult $
    withObjectRef "gridIsEditable" _obj $ \cobj__obj -> 
    wxGrid_IsEditable cobj__obj  
foreign import ccall "wxGrid_IsEditable" wxGrid_IsEditable :: Ptr (TGrid a) -> IO CBool

-- | usage: (@gridIsInSelection obj row col@).
gridIsInSelection :: Grid  a -> Int -> Int ->  IO Bool
gridIsInSelection _obj row col 
  = withBoolResult $
    withObjectRef "gridIsInSelection" _obj $ \cobj__obj -> 
    wxGrid_IsInSelection cobj__obj  (toCInt row)  (toCInt col)  
foreign import ccall "wxGrid_IsInSelection" wxGrid_IsInSelection :: Ptr (TGrid a) -> CInt -> CInt -> IO CBool

-- | usage: (@gridIsReadOnly obj row col@).
gridIsReadOnly :: Grid  a -> Int -> Int ->  IO Bool
gridIsReadOnly _obj row col 
  = withBoolResult $
    withObjectRef "gridIsReadOnly" _obj $ \cobj__obj -> 
    wxGrid_IsReadOnly cobj__obj  (toCInt row)  (toCInt col)  
foreign import ccall "wxGrid_IsReadOnly" wxGrid_IsReadOnly :: Ptr (TGrid a) -> CInt -> CInt -> IO CBool

-- | usage: (@gridIsSelection obj@).
gridIsSelection :: Grid  a ->  IO Bool
gridIsSelection _obj 
  = withBoolResult $
    withObjectRef "gridIsSelection" _obj $ \cobj__obj -> 
    wxGrid_IsSelection cobj__obj  
foreign import ccall "wxGrid_IsSelection" wxGrid_IsSelection :: Ptr (TGrid a) -> IO CBool

-- | usage: (@gridIsVisible obj row col wholeCellVisible@).
gridIsVisible :: Grid  a -> Int -> Int -> Bool ->  IO Bool
gridIsVisible _obj row col wholeCellVisible 
  = withBoolResult $
    withObjectRef "gridIsVisible" _obj $ \cobj__obj -> 
    wxGrid_IsVisible cobj__obj  (toCInt row)  (toCInt col)  (toCBool wholeCellVisible)  
foreign import ccall "wxGrid_IsVisible" wxGrid_IsVisible :: Ptr (TGrid a) -> CInt -> CInt -> CBool -> IO CBool

-- | usage: (@gridMakeCellVisible obj row col@).
gridMakeCellVisible :: Grid  a -> Int -> Int ->  IO ()
gridMakeCellVisible _obj row col 
  = withObjectRef "gridMakeCellVisible" _obj $ \cobj__obj -> 
    wxGrid_MakeCellVisible cobj__obj  (toCInt row)  (toCInt col)  
foreign import ccall "wxGrid_MakeCellVisible" wxGrid_MakeCellVisible :: Ptr (TGrid a) -> CInt -> CInt -> IO ()

-- | usage: (@gridMoveCursorDown obj expandSelection@).
gridMoveCursorDown :: Grid  a -> Bool ->  IO Bool
gridMoveCursorDown _obj expandSelection 
  = withBoolResult $
    withObjectRef "gridMoveCursorDown" _obj $ \cobj__obj -> 
    wxGrid_MoveCursorDown cobj__obj  (toCBool expandSelection)  
foreign import ccall "wxGrid_MoveCursorDown" wxGrid_MoveCursorDown :: Ptr (TGrid a) -> CBool -> IO CBool

-- | usage: (@gridMoveCursorDownBlock obj expandSelection@).
gridMoveCursorDownBlock :: Grid  a -> Bool ->  IO Bool
gridMoveCursorDownBlock _obj expandSelection 
  = withBoolResult $
    withObjectRef "gridMoveCursorDownBlock" _obj $ \cobj__obj -> 
    wxGrid_MoveCursorDownBlock cobj__obj  (toCBool expandSelection)  
foreign import ccall "wxGrid_MoveCursorDownBlock" wxGrid_MoveCursorDownBlock :: Ptr (TGrid a) -> CBool -> IO CBool

-- | usage: (@gridMoveCursorLeft obj expandSelection@).
gridMoveCursorLeft :: Grid  a -> Bool ->  IO Bool
gridMoveCursorLeft _obj expandSelection 
  = withBoolResult $
    withObjectRef "gridMoveCursorLeft" _obj $ \cobj__obj -> 
    wxGrid_MoveCursorLeft cobj__obj  (toCBool expandSelection)  
foreign import ccall "wxGrid_MoveCursorLeft" wxGrid_MoveCursorLeft :: Ptr (TGrid a) -> CBool -> IO CBool

-- | usage: (@gridMoveCursorLeftBlock obj expandSelection@).
gridMoveCursorLeftBlock :: Grid  a -> Bool ->  IO Bool
gridMoveCursorLeftBlock _obj expandSelection 
  = withBoolResult $
    withObjectRef "gridMoveCursorLeftBlock" _obj $ \cobj__obj -> 
    wxGrid_MoveCursorLeftBlock cobj__obj  (toCBool expandSelection)  
foreign import ccall "wxGrid_MoveCursorLeftBlock" wxGrid_MoveCursorLeftBlock :: Ptr (TGrid a) -> CBool -> IO CBool

-- | usage: (@gridMoveCursorRight obj expandSelection@).
gridMoveCursorRight :: Grid  a -> Bool ->  IO Bool
gridMoveCursorRight _obj expandSelection 
  = withBoolResult $
    withObjectRef "gridMoveCursorRight" _obj $ \cobj__obj -> 
    wxGrid_MoveCursorRight cobj__obj  (toCBool expandSelection)  
foreign import ccall "wxGrid_MoveCursorRight" wxGrid_MoveCursorRight :: Ptr (TGrid a) -> CBool -> IO CBool

-- | usage: (@gridMoveCursorRightBlock obj expandSelection@).
gridMoveCursorRightBlock :: Grid  a -> Bool ->  IO Bool
gridMoveCursorRightBlock _obj expandSelection 
  = withBoolResult $
    withObjectRef "gridMoveCursorRightBlock" _obj $ \cobj__obj -> 
    wxGrid_MoveCursorRightBlock cobj__obj  (toCBool expandSelection)  
foreign import ccall "wxGrid_MoveCursorRightBlock" wxGrid_MoveCursorRightBlock :: Ptr (TGrid a) -> CBool -> IO CBool

-- | usage: (@gridMoveCursorUp obj expandSelection@).
gridMoveCursorUp :: Grid  a -> Bool ->  IO Bool
gridMoveCursorUp _obj expandSelection 
  = withBoolResult $
    withObjectRef "gridMoveCursorUp" _obj $ \cobj__obj -> 
    wxGrid_MoveCursorUp cobj__obj  (toCBool expandSelection)  
foreign import ccall "wxGrid_MoveCursorUp" wxGrid_MoveCursorUp :: Ptr (TGrid a) -> CBool -> IO CBool

-- | usage: (@gridMoveCursorUpBlock obj expandSelection@).
gridMoveCursorUpBlock :: Grid  a -> Bool ->  IO Bool
gridMoveCursorUpBlock _obj expandSelection 
  = withBoolResult $
    withObjectRef "gridMoveCursorUpBlock" _obj $ \cobj__obj -> 
    wxGrid_MoveCursorUpBlock cobj__obj  (toCBool expandSelection)  
foreign import ccall "wxGrid_MoveCursorUpBlock" wxGrid_MoveCursorUpBlock :: Ptr (TGrid a) -> CBool -> IO CBool

-- | usage: (@gridMovePageDown obj@).
gridMovePageDown :: Grid  a ->  IO Bool
gridMovePageDown _obj 
  = withBoolResult $
    withObjectRef "gridMovePageDown" _obj $ \cobj__obj -> 
    wxGrid_MovePageDown cobj__obj  
foreign import ccall "wxGrid_MovePageDown" wxGrid_MovePageDown :: Ptr (TGrid a) -> IO CBool

-- | usage: (@gridMovePageUp obj@).
gridMovePageUp :: Grid  a ->  IO Bool
gridMovePageUp _obj 
  = withBoolResult $
    withObjectRef "gridMovePageUp" _obj $ \cobj__obj -> 
    wxGrid_MovePageUp cobj__obj  
foreign import ccall "wxGrid_MovePageUp" wxGrid_MovePageUp :: Ptr (TGrid a) -> IO CBool

-- | usage: (@gridNewCalcCellsExposed obj reg@).
gridNewCalcCellsExposed :: Grid  a -> Region  b ->  IO (GridCellCoordsArray  ())
gridNewCalcCellsExposed _obj reg 
  = withRefGridCellCoordsArray $ \pref -> 
    withObjectRef "gridNewCalcCellsExposed" _obj $ \cobj__obj -> 
    withObjectPtr reg $ \cobj_reg -> 
    wxGrid_NewCalcCellsExposed cobj__obj  cobj_reg   pref
foreign import ccall "wxGrid_NewCalcCellsExposed" wxGrid_NewCalcCellsExposed :: Ptr (TGrid a) -> Ptr (TRegion b) -> Ptr (TGridCellCoordsArray ()) -> IO ()

-- | usage: (@gridNewDrawGridCellArea obj dc arr@).
gridNewDrawGridCellArea :: Grid  a -> DC  b -> GridCellCoordsArray  c ->  IO ()
gridNewDrawGridCellArea _obj dc arr 
  = withObjectRef "gridNewDrawGridCellArea" _obj $ \cobj__obj -> 
    withObjectPtr dc $ \cobj_dc -> 
    withObjectPtr arr $ \cobj_arr -> 
    wxGrid_NewDrawGridCellArea cobj__obj  cobj_dc  cobj_arr  
foreign import ccall "wxGrid_NewDrawGridCellArea" wxGrid_NewDrawGridCellArea :: Ptr (TGrid a) -> Ptr (TDC b) -> Ptr (TGridCellCoordsArray c) -> IO ()

-- | usage: (@gridNewDrawHighlight obj dc arr@).
gridNewDrawHighlight :: Grid  a -> DC  b -> GridCellCoordsArray  c ->  IO ()
gridNewDrawHighlight _obj dc arr 
  = withObjectRef "gridNewDrawHighlight" _obj $ \cobj__obj -> 
    withObjectPtr dc $ \cobj_dc -> 
    withObjectPtr arr $ \cobj_arr -> 
    wxGrid_NewDrawHighlight cobj__obj  cobj_dc  cobj_arr  
foreign import ccall "wxGrid_NewDrawHighlight" wxGrid_NewDrawHighlight :: Ptr (TGrid a) -> Ptr (TDC b) -> Ptr (TGridCellCoordsArray c) -> IO ()

-- | usage: (@gridProcessColLabelMouseEvent obj event@).
gridProcessColLabelMouseEvent :: Grid  a -> MouseEvent  b ->  IO ()
gridProcessColLabelMouseEvent _obj event 
  = withObjectRef "gridProcessColLabelMouseEvent" _obj $ \cobj__obj -> 
    withObjectPtr event $ \cobj_event -> 
    wxGrid_ProcessColLabelMouseEvent cobj__obj  cobj_event  
foreign import ccall "wxGrid_ProcessColLabelMouseEvent" wxGrid_ProcessColLabelMouseEvent :: Ptr (TGrid a) -> Ptr (TMouseEvent b) -> IO ()

-- | usage: (@gridProcessCornerLabelMouseEvent obj event@).
gridProcessCornerLabelMouseEvent :: Grid  a -> MouseEvent  b ->  IO ()
gridProcessCornerLabelMouseEvent _obj event 
  = withObjectRef "gridProcessCornerLabelMouseEvent" _obj $ \cobj__obj -> 
    withObjectPtr event $ \cobj_event -> 
    wxGrid_ProcessCornerLabelMouseEvent cobj__obj  cobj_event  
foreign import ccall "wxGrid_ProcessCornerLabelMouseEvent" wxGrid_ProcessCornerLabelMouseEvent :: Ptr (TGrid a) -> Ptr (TMouseEvent b) -> IO ()

-- | usage: (@gridProcessGridCellMouseEvent obj event@).
gridProcessGridCellMouseEvent :: Grid  a -> MouseEvent  b ->  IO ()
gridProcessGridCellMouseEvent _obj event 
  = withObjectRef "gridProcessGridCellMouseEvent" _obj $ \cobj__obj -> 
    withObjectPtr event $ \cobj_event -> 
    wxGrid_ProcessGridCellMouseEvent cobj__obj  cobj_event  
foreign import ccall "wxGrid_ProcessGridCellMouseEvent" wxGrid_ProcessGridCellMouseEvent :: Ptr (TGrid a) -> Ptr (TMouseEvent b) -> IO ()

-- | usage: (@gridProcessRowLabelMouseEvent obj event@).
gridProcessRowLabelMouseEvent :: Grid  a -> MouseEvent  b ->  IO ()
gridProcessRowLabelMouseEvent _obj event 
  = withObjectRef "gridProcessRowLabelMouseEvent" _obj $ \cobj__obj -> 
    withObjectPtr event $ \cobj_event -> 
    wxGrid_ProcessRowLabelMouseEvent cobj__obj  cobj_event  
foreign import ccall "wxGrid_ProcessRowLabelMouseEvent" wxGrid_ProcessRowLabelMouseEvent :: Ptr (TGrid a) -> Ptr (TMouseEvent b) -> IO ()

-- | usage: (@gridProcessTableMessage obj evt@).
gridProcessTableMessage :: Grid  a -> Event  b ->  IO Bool
gridProcessTableMessage _obj evt 
  = withBoolResult $
    withObjectRef "gridProcessTableMessage" _obj $ \cobj__obj -> 
    withObjectPtr evt $ \cobj_evt -> 
    wxGrid_ProcessTableMessage cobj__obj  cobj_evt  
foreign import ccall "wxGrid_ProcessTableMessage" wxGrid_ProcessTableMessage :: Ptr (TGrid a) -> Ptr (TEvent b) -> IO CBool

-- | usage: (@gridRangeSelectEventAltDown obj@).
gridRangeSelectEventAltDown :: GridRangeSelectEvent  a ->  IO Bool
gridRangeSelectEventAltDown _obj 
  = withBoolResult $
    withObjectRef "gridRangeSelectEventAltDown" _obj $ \cobj__obj -> 
    wxGridRangeSelectEvent_AltDown cobj__obj  
foreign import ccall "wxGridRangeSelectEvent_AltDown" wxGridRangeSelectEvent_AltDown :: Ptr (TGridRangeSelectEvent a) -> IO CBool

-- | usage: (@gridRangeSelectEventControlDown obj@).
gridRangeSelectEventControlDown :: GridRangeSelectEvent  a ->  IO Bool
gridRangeSelectEventControlDown _obj 
  = withBoolResult $
    withObjectRef "gridRangeSelectEventControlDown" _obj $ \cobj__obj -> 
    wxGridRangeSelectEvent_ControlDown cobj__obj  
foreign import ccall "wxGridRangeSelectEvent_ControlDown" wxGridRangeSelectEvent_ControlDown :: Ptr (TGridRangeSelectEvent a) -> IO CBool

-- | usage: (@gridRangeSelectEventGetBottomRightCoords obj@).
gridRangeSelectEventGetBottomRightCoords :: GridRangeSelectEvent  a ->  IO Point
gridRangeSelectEventGetBottomRightCoords _obj 
  = withPointResult $ \px py -> 
    withObjectRef "gridRangeSelectEventGetBottomRightCoords" _obj $ \cobj__obj -> 
    wxGridRangeSelectEvent_GetBottomRightCoords cobj__obj   px py
foreign import ccall "wxGridRangeSelectEvent_GetBottomRightCoords" wxGridRangeSelectEvent_GetBottomRightCoords :: Ptr (TGridRangeSelectEvent a) -> Ptr CInt -> Ptr CInt -> IO ()

-- | usage: (@gridRangeSelectEventGetBottomRow obj@).
gridRangeSelectEventGetBottomRow :: GridRangeSelectEvent  a ->  IO Int
gridRangeSelectEventGetBottomRow _obj 
  = withIntResult $
    withObjectRef "gridRangeSelectEventGetBottomRow" _obj $ \cobj__obj -> 
    wxGridRangeSelectEvent_GetBottomRow cobj__obj  
foreign import ccall "wxGridRangeSelectEvent_GetBottomRow" wxGridRangeSelectEvent_GetBottomRow :: Ptr (TGridRangeSelectEvent a) -> IO CInt

-- | usage: (@gridRangeSelectEventGetLeftCol obj@).
gridRangeSelectEventGetLeftCol :: GridRangeSelectEvent  a ->  IO Int
gridRangeSelectEventGetLeftCol _obj 
  = withIntResult $
    withObjectRef "gridRangeSelectEventGetLeftCol" _obj $ \cobj__obj -> 
    wxGridRangeSelectEvent_GetLeftCol cobj__obj  
foreign import ccall "wxGridRangeSelectEvent_GetLeftCol" wxGridRangeSelectEvent_GetLeftCol :: Ptr (TGridRangeSelectEvent a) -> IO CInt

-- | usage: (@gridRangeSelectEventGetRightCol obj@).
gridRangeSelectEventGetRightCol :: GridRangeSelectEvent  a ->  IO Int
gridRangeSelectEventGetRightCol _obj 
  = withIntResult $
    withObjectRef "gridRangeSelectEventGetRightCol" _obj $ \cobj__obj -> 
    wxGridRangeSelectEvent_GetRightCol cobj__obj  
foreign import ccall "wxGridRangeSelectEvent_GetRightCol" wxGridRangeSelectEvent_GetRightCol :: Ptr (TGridRangeSelectEvent a) -> IO CInt

-- | usage: (@gridRangeSelectEventGetTopLeftCoords obj@).
gridRangeSelectEventGetTopLeftCoords :: GridRangeSelectEvent  a ->  IO Point
gridRangeSelectEventGetTopLeftCoords _obj 
  = withPointResult $ \px py -> 
    withObjectRef "gridRangeSelectEventGetTopLeftCoords" _obj $ \cobj__obj -> 
    wxGridRangeSelectEvent_GetTopLeftCoords cobj__obj   px py
foreign import ccall "wxGridRangeSelectEvent_GetTopLeftCoords" wxGridRangeSelectEvent_GetTopLeftCoords :: Ptr (TGridRangeSelectEvent a) -> Ptr CInt -> Ptr CInt -> IO ()

-- | usage: (@gridRangeSelectEventGetTopRow obj@).
gridRangeSelectEventGetTopRow :: GridRangeSelectEvent  a ->  IO Int
gridRangeSelectEventGetTopRow _obj 
  = withIntResult $
    withObjectRef "gridRangeSelectEventGetTopRow" _obj $ \cobj__obj -> 
    wxGridRangeSelectEvent_GetTopRow cobj__obj  
foreign import ccall "wxGridRangeSelectEvent_GetTopRow" wxGridRangeSelectEvent_GetTopRow :: Ptr (TGridRangeSelectEvent a) -> IO CInt

-- | usage: (@gridRangeSelectEventMetaDown obj@).
gridRangeSelectEventMetaDown :: GridRangeSelectEvent  a ->  IO Bool
gridRangeSelectEventMetaDown _obj 
  = withBoolResult $
    withObjectRef "gridRangeSelectEventMetaDown" _obj $ \cobj__obj -> 
    wxGridRangeSelectEvent_MetaDown cobj__obj  
foreign import ccall "wxGridRangeSelectEvent_MetaDown" wxGridRangeSelectEvent_MetaDown :: Ptr (TGridRangeSelectEvent a) -> IO CBool

-- | usage: (@gridRangeSelectEventSelecting obj@).
gridRangeSelectEventSelecting :: GridRangeSelectEvent  a ->  IO Bool
gridRangeSelectEventSelecting _obj 
  = withBoolResult $
    withObjectRef "gridRangeSelectEventSelecting" _obj $ \cobj__obj -> 
    wxGridRangeSelectEvent_Selecting cobj__obj  
foreign import ccall "wxGridRangeSelectEvent_Selecting" wxGridRangeSelectEvent_Selecting :: Ptr (TGridRangeSelectEvent a) -> IO CBool

-- | usage: (@gridRangeSelectEventShiftDown obj@).
gridRangeSelectEventShiftDown :: GridRangeSelectEvent  a ->  IO Bool
gridRangeSelectEventShiftDown _obj 
  = withBoolResult $
    withObjectRef "gridRangeSelectEventShiftDown" _obj $ \cobj__obj -> 
    wxGridRangeSelectEvent_ShiftDown cobj__obj  
foreign import ccall "wxGridRangeSelectEvent_ShiftDown" wxGridRangeSelectEvent_ShiftDown :: Ptr (TGridRangeSelectEvent a) -> IO CBool

-- | usage: (@gridRegisterDataType obj typeName renderer editor@).
gridRegisterDataType :: Grid  a -> String -> GridCellRenderer  c -> GridCellEditor  d ->  IO ()
gridRegisterDataType _obj typeName renderer editor 
  = withObjectRef "gridRegisterDataType" _obj $ \cobj__obj -> 
    withStringPtr typeName $ \cobj_typeName -> 
    withObjectPtr renderer $ \cobj_renderer -> 
    withObjectPtr editor $ \cobj_editor -> 
    wxGrid_RegisterDataType cobj__obj  cobj_typeName  cobj_renderer  cobj_editor  
foreign import ccall "wxGrid_RegisterDataType" wxGrid_RegisterDataType :: Ptr (TGrid a) -> Ptr (TWxString b) -> Ptr (TGridCellRenderer c) -> Ptr (TGridCellEditor d) -> IO ()

-- | usage: (@gridSaveEditControlValue obj@).
gridSaveEditControlValue :: Grid  a ->  IO ()
gridSaveEditControlValue _obj 
  = withObjectRef "gridSaveEditControlValue" _obj $ \cobj__obj -> 
    wxGrid_SaveEditControlValue cobj__obj  
foreign import ccall "wxGrid_SaveEditControlValue" wxGrid_SaveEditControlValue :: Ptr (TGrid a) -> IO ()

-- | usage: (@gridSelectAll obj@).
gridSelectAll :: Grid  a ->  IO ()
gridSelectAll _obj 
  = withObjectRef "gridSelectAll" _obj $ \cobj__obj -> 
    wxGrid_SelectAll cobj__obj  
foreign import ccall "wxGrid_SelectAll" wxGrid_SelectAll :: Ptr (TGrid a) -> IO ()

-- | usage: (@gridSelectBlock obj topRow leftCol bottomRow rightCol addToSelected@).
gridSelectBlock :: Grid  a -> Int -> Int -> Int -> Int -> Bool ->  IO ()
gridSelectBlock _obj topRow leftCol bottomRow rightCol addToSelected 
  = withObjectRef "gridSelectBlock" _obj $ \cobj__obj -> 
    wxGrid_SelectBlock cobj__obj  (toCInt topRow)  (toCInt leftCol)  (toCInt bottomRow)  (toCInt rightCol)  (toCBool addToSelected)  
foreign import ccall "wxGrid_SelectBlock" wxGrid_SelectBlock :: Ptr (TGrid a) -> CInt -> CInt -> CInt -> CInt -> CBool -> IO ()

-- | usage: (@gridSelectCol obj col addToSelected@).
gridSelectCol :: Grid  a -> Int -> Bool ->  IO ()
gridSelectCol _obj col addToSelected 
  = withObjectRef "gridSelectCol" _obj $ \cobj__obj -> 
    wxGrid_SelectCol cobj__obj  (toCInt col)  (toCBool addToSelected)  
foreign import ccall "wxGrid_SelectCol" wxGrid_SelectCol :: Ptr (TGrid a) -> CInt -> CBool -> IO ()

-- | usage: (@gridSelectRow obj row addToSelected@).
gridSelectRow :: Grid  a -> Int -> Bool ->  IO ()
gridSelectRow _obj row addToSelected 
  = withObjectRef "gridSelectRow" _obj $ \cobj__obj -> 
    wxGrid_SelectRow cobj__obj  (toCInt row)  (toCBool addToSelected)  
foreign import ccall "wxGrid_SelectRow" wxGrid_SelectRow :: Ptr (TGrid a) -> CInt -> CBool -> IO ()

-- | usage: (@gridSetCellAlignment obj row col horiz vert@).
gridSetCellAlignment :: Grid  a -> Int -> Int -> Int -> Int ->  IO ()
gridSetCellAlignment _obj row col horiz vert 
  = withObjectRef "gridSetCellAlignment" _obj $ \cobj__obj -> 
    wxGrid_SetCellAlignment cobj__obj  (toCInt row)  (toCInt col)  (toCInt horiz)  (toCInt vert)  
foreign import ccall "wxGrid_SetCellAlignment" wxGrid_SetCellAlignment :: Ptr (TGrid a) -> CInt -> CInt -> CInt -> CInt -> IO ()

-- | usage: (@gridSetCellBackgroundColour obj row col colour@).
gridSetCellBackgroundColour :: Grid  a -> Int -> Int -> Color ->  IO ()
gridSetCellBackgroundColour _obj row col colour 
  = withObjectRef "gridSetCellBackgroundColour" _obj $ \cobj__obj -> 
    withColourPtr colour $ \cobj_colour -> 
    wxGrid_SetCellBackgroundColour cobj__obj  (toCInt row)  (toCInt col)  cobj_colour  
foreign import ccall "wxGrid_SetCellBackgroundColour" wxGrid_SetCellBackgroundColour :: Ptr (TGrid a) -> CInt -> CInt -> Ptr (TColour d) -> IO ()

-- | usage: (@gridSetCellEditor obj row col editor@).
gridSetCellEditor :: Grid  a -> Int -> Int -> GridCellEditor  d ->  IO ()
gridSetCellEditor _obj row col editor 
  = withObjectRef "gridSetCellEditor" _obj $ \cobj__obj -> 
    withObjectPtr editor $ \cobj_editor -> 
    wxGrid_SetCellEditor cobj__obj  (toCInt row)  (toCInt col)  cobj_editor  
foreign import ccall "wxGrid_SetCellEditor" wxGrid_SetCellEditor :: Ptr (TGrid a) -> CInt -> CInt -> Ptr (TGridCellEditor d) -> IO ()

-- | usage: (@gridSetCellFont obj row col font@).
gridSetCellFont :: Grid  a -> Int -> Int -> Font  d ->  IO ()
gridSetCellFont _obj row col font 
  = withObjectRef "gridSetCellFont" _obj $ \cobj__obj -> 
    withObjectPtr font $ \cobj_font -> 
    wxGrid_SetCellFont cobj__obj  (toCInt row)  (toCInt col)  cobj_font  
foreign import ccall "wxGrid_SetCellFont" wxGrid_SetCellFont :: Ptr (TGrid a) -> CInt -> CInt -> Ptr (TFont d) -> IO ()

-- | usage: (@gridSetCellHighlightColour obj col@).
gridSetCellHighlightColour :: Grid  a -> Color ->  IO ()
gridSetCellHighlightColour _obj col 
  = withObjectRef "gridSetCellHighlightColour" _obj $ \cobj__obj -> 
    withColourPtr col $ \cobj_col -> 
    wxGrid_SetCellHighlightColour cobj__obj  cobj_col  
foreign import ccall "wxGrid_SetCellHighlightColour" wxGrid_SetCellHighlightColour :: Ptr (TGrid a) -> Ptr (TColour b) -> IO ()

-- | usage: (@gridSetCellRenderer obj row col renderer@).
gridSetCellRenderer :: Grid  a -> Int -> Int -> GridCellRenderer  d ->  IO ()
gridSetCellRenderer _obj row col renderer 
  = withObjectRef "gridSetCellRenderer" _obj $ \cobj__obj -> 
    withObjectPtr renderer $ \cobj_renderer -> 
    wxGrid_SetCellRenderer cobj__obj  (toCInt row)  (toCInt col)  cobj_renderer  
foreign import ccall "wxGrid_SetCellRenderer" wxGrid_SetCellRenderer :: Ptr (TGrid a) -> CInt -> CInt -> Ptr (TGridCellRenderer d) -> IO ()

-- | usage: (@gridSetCellTextColour obj row col colour@).
gridSetCellTextColour :: Grid  a -> Int -> Int -> Color ->  IO ()
gridSetCellTextColour _obj row col colour 
  = withObjectRef "gridSetCellTextColour" _obj $ \cobj__obj -> 
    withColourPtr colour $ \cobj_colour -> 
    wxGrid_SetCellTextColour cobj__obj  (toCInt row)  (toCInt col)  cobj_colour  
foreign import ccall "wxGrid_SetCellTextColour" wxGrid_SetCellTextColour :: Ptr (TGrid a) -> CInt -> CInt -> Ptr (TColour d) -> IO ()

-- | usage: (@gridSetCellValue obj row col s@).
gridSetCellValue :: Grid  a -> Int -> Int -> String ->  IO ()
gridSetCellValue _obj row col s 
  = withObjectRef "gridSetCellValue" _obj $ \cobj__obj -> 
    withStringPtr s $ \cobj_s -> 
    wxGrid_SetCellValue cobj__obj  (toCInt row)  (toCInt col)  cobj_s  
foreign import ccall "wxGrid_SetCellValue" wxGrid_SetCellValue :: Ptr (TGrid a) -> CInt -> CInt -> Ptr (TWxString d) -> IO ()

-- | usage: (@gridSetColAttr obj col attr@).
gridSetColAttr :: Grid  a -> Int -> GridCellAttr  c ->  IO ()
gridSetColAttr _obj col attr 
  = withObjectRef "gridSetColAttr" _obj $ \cobj__obj -> 
    withObjectPtr attr $ \cobj_attr -> 
    wxGrid_SetColAttr cobj__obj  (toCInt col)  cobj_attr  
foreign import ccall "wxGrid_SetColAttr" wxGrid_SetColAttr :: Ptr (TGrid a) -> CInt -> Ptr (TGridCellAttr c) -> IO ()

-- | usage: (@gridSetColFormatBool obj col@).
gridSetColFormatBool :: Grid  a -> Int ->  IO ()
gridSetColFormatBool _obj col 
  = withObjectRef "gridSetColFormatBool" _obj $ \cobj__obj -> 
    wxGrid_SetColFormatBool cobj__obj  (toCInt col)  
foreign import ccall "wxGrid_SetColFormatBool" wxGrid_SetColFormatBool :: Ptr (TGrid a) -> CInt -> IO ()

-- | usage: (@gridSetColFormatCustom obj col typeName@).
gridSetColFormatCustom :: Grid  a -> Int -> String ->  IO ()
gridSetColFormatCustom _obj col typeName 
  = withObjectRef "gridSetColFormatCustom" _obj $ \cobj__obj -> 
    withStringPtr typeName $ \cobj_typeName -> 
    wxGrid_SetColFormatCustom cobj__obj  (toCInt col)  cobj_typeName  
foreign import ccall "wxGrid_SetColFormatCustom" wxGrid_SetColFormatCustom :: Ptr (TGrid a) -> CInt -> Ptr (TWxString c) -> IO ()

-- | usage: (@gridSetColFormatFloat obj col width precision@).
gridSetColFormatFloat :: Grid  a -> Int -> Int -> Int ->  IO ()
gridSetColFormatFloat _obj col width precision 
  = withObjectRef "gridSetColFormatFloat" _obj $ \cobj__obj -> 
    wxGrid_SetColFormatFloat cobj__obj  (toCInt col)  (toCInt width)  (toCInt precision)  
foreign import ccall "wxGrid_SetColFormatFloat" wxGrid_SetColFormatFloat :: Ptr (TGrid a) -> CInt -> CInt -> CInt -> IO ()

-- | usage: (@gridSetColFormatNumber obj col@).
gridSetColFormatNumber :: Grid  a -> Int ->  IO ()
gridSetColFormatNumber _obj col 
  = withObjectRef "gridSetColFormatNumber" _obj $ \cobj__obj -> 
    wxGrid_SetColFormatNumber cobj__obj  (toCInt col)  
foreign import ccall "wxGrid_SetColFormatNumber" wxGrid_SetColFormatNumber :: Ptr (TGrid a) -> CInt -> IO ()

-- | usage: (@gridSetColLabelAlignment obj horiz vert@).
gridSetColLabelAlignment :: Grid  a -> Int -> Int ->  IO ()
gridSetColLabelAlignment _obj horiz vert 
  = withObjectRef "gridSetColLabelAlignment" _obj $ \cobj__obj -> 
    wxGrid_SetColLabelAlignment cobj__obj  (toCInt horiz)  (toCInt vert)  
foreign import ccall "wxGrid_SetColLabelAlignment" wxGrid_SetColLabelAlignment :: Ptr (TGrid a) -> CInt -> CInt -> IO ()

-- | usage: (@gridSetColLabelSize obj height@).
gridSetColLabelSize :: Grid  a -> Int ->  IO ()
gridSetColLabelSize _obj height 
  = withObjectRef "gridSetColLabelSize" _obj $ \cobj__obj -> 
    wxGrid_SetColLabelSize cobj__obj  (toCInt height)  
foreign import ccall "wxGrid_SetColLabelSize" wxGrid_SetColLabelSize :: Ptr (TGrid a) -> CInt -> IO ()

-- | usage: (@gridSetColLabelValue obj col label@).
gridSetColLabelValue :: Grid  a -> Int -> String ->  IO ()
gridSetColLabelValue _obj col label 
  = withObjectRef "gridSetColLabelValue" _obj $ \cobj__obj -> 
    withStringPtr label $ \cobj_label -> 
    wxGrid_SetColLabelValue cobj__obj  (toCInt col)  cobj_label  
foreign import ccall "wxGrid_SetColLabelValue" wxGrid_SetColLabelValue :: Ptr (TGrid a) -> CInt -> Ptr (TWxString c) -> IO ()

-- | usage: (@gridSetColMinimalWidth obj col width@).
gridSetColMinimalWidth :: Grid  a -> Int -> Int ->  IO ()
gridSetColMinimalWidth _obj col width 
  = withObjectRef "gridSetColMinimalWidth" _obj $ \cobj__obj -> 
    wxGrid_SetColMinimalWidth cobj__obj  (toCInt col)  (toCInt width)  
foreign import ccall "wxGrid_SetColMinimalWidth" wxGrid_SetColMinimalWidth :: Ptr (TGrid a) -> CInt -> CInt -> IO ()

-- | usage: (@gridSetColSize obj col width@).
gridSetColSize :: Grid  a -> Int -> Int ->  IO ()
gridSetColSize _obj col width 
  = withObjectRef "gridSetColSize" _obj $ \cobj__obj -> 
    wxGrid_SetColSize cobj__obj  (toCInt col)  (toCInt width)  
foreign import ccall "wxGrid_SetColSize" wxGrid_SetColSize :: Ptr (TGrid a) -> CInt -> CInt -> IO ()

-- | usage: (@gridSetDefaultCellAlignment obj horiz vert@).
gridSetDefaultCellAlignment :: Grid  a -> Int -> Int ->  IO ()
gridSetDefaultCellAlignment _obj horiz vert 
  = withObjectRef "gridSetDefaultCellAlignment" _obj $ \cobj__obj -> 
    wxGrid_SetDefaultCellAlignment cobj__obj  (toCInt horiz)  (toCInt vert)  
foreign import ccall "wxGrid_SetDefaultCellAlignment" wxGrid_SetDefaultCellAlignment :: Ptr (TGrid a) -> CInt -> CInt -> IO ()

-- | usage: (@gridSetDefaultCellBackgroundColour obj colour@).
gridSetDefaultCellBackgroundColour :: Grid  a -> Color ->  IO ()
gridSetDefaultCellBackgroundColour _obj colour 
  = withObjectRef "gridSetDefaultCellBackgroundColour" _obj $ \cobj__obj -> 
    withColourPtr colour $ \cobj_colour -> 
    wxGrid_SetDefaultCellBackgroundColour cobj__obj  cobj_colour  
foreign import ccall "wxGrid_SetDefaultCellBackgroundColour" wxGrid_SetDefaultCellBackgroundColour :: Ptr (TGrid a) -> Ptr (TColour b) -> IO ()

-- | usage: (@gridSetDefaultCellFont obj font@).
gridSetDefaultCellFont :: Grid  a -> Font  b ->  IO ()
gridSetDefaultCellFont _obj font 
  = withObjectRef "gridSetDefaultCellFont" _obj $ \cobj__obj -> 
    withObjectPtr font $ \cobj_font -> 
    wxGrid_SetDefaultCellFont cobj__obj  cobj_font  
foreign import ccall "wxGrid_SetDefaultCellFont" wxGrid_SetDefaultCellFont :: Ptr (TGrid a) -> Ptr (TFont b) -> IO ()

-- | usage: (@gridSetDefaultCellTextColour obj colour@).
gridSetDefaultCellTextColour :: Grid  a -> Color ->  IO ()
gridSetDefaultCellTextColour _obj colour 
  = withObjectRef "gridSetDefaultCellTextColour" _obj $ \cobj__obj -> 
    withColourPtr colour $ \cobj_colour -> 
    wxGrid_SetDefaultCellTextColour cobj__obj  cobj_colour  
foreign import ccall "wxGrid_SetDefaultCellTextColour" wxGrid_SetDefaultCellTextColour :: Ptr (TGrid a) -> Ptr (TColour b) -> IO ()

-- | usage: (@gridSetDefaultColSize obj width resizeExistingCols@).
gridSetDefaultColSize :: Grid  a -> Int -> Bool ->  IO ()
gridSetDefaultColSize _obj width resizeExistingCols 
  = withObjectRef "gridSetDefaultColSize" _obj $ \cobj__obj -> 
    wxGrid_SetDefaultColSize cobj__obj  (toCInt width)  (toCBool resizeExistingCols)  
foreign import ccall "wxGrid_SetDefaultColSize" wxGrid_SetDefaultColSize :: Ptr (TGrid a) -> CInt -> CBool -> IO ()

-- | usage: (@gridSetDefaultEditor obj editor@).
gridSetDefaultEditor :: Grid  a -> GridCellEditor  b ->  IO ()
gridSetDefaultEditor _obj editor 
  = withObjectRef "gridSetDefaultEditor" _obj $ \cobj__obj -> 
    withObjectPtr editor $ \cobj_editor -> 
    wxGrid_SetDefaultEditor cobj__obj  cobj_editor  
foreign import ccall "wxGrid_SetDefaultEditor" wxGrid_SetDefaultEditor :: Ptr (TGrid a) -> Ptr (TGridCellEditor b) -> IO ()

-- | usage: (@gridSetDefaultRenderer obj renderer@).
gridSetDefaultRenderer :: Grid  a -> GridCellRenderer  b ->  IO ()
gridSetDefaultRenderer _obj renderer 
  = withObjectRef "gridSetDefaultRenderer" _obj $ \cobj__obj -> 
    withObjectPtr renderer $ \cobj_renderer -> 
    wxGrid_SetDefaultRenderer cobj__obj  cobj_renderer  
foreign import ccall "wxGrid_SetDefaultRenderer" wxGrid_SetDefaultRenderer :: Ptr (TGrid a) -> Ptr (TGridCellRenderer b) -> IO ()

-- | usage: (@gridSetDefaultRowSize obj height resizeExistingRows@).
gridSetDefaultRowSize :: Grid  a -> Int -> Bool ->  IO ()
gridSetDefaultRowSize _obj height resizeExistingRows 
  = withObjectRef "gridSetDefaultRowSize" _obj $ \cobj__obj -> 
    wxGrid_SetDefaultRowSize cobj__obj  (toCInt height)  (toCBool resizeExistingRows)  
foreign import ccall "wxGrid_SetDefaultRowSize" wxGrid_SetDefaultRowSize :: Ptr (TGrid a) -> CInt -> CBool -> IO ()

-- | usage: (@gridSetGridCursor obj row col@).
gridSetGridCursor :: Grid  a -> Int -> Int ->  IO ()
gridSetGridCursor _obj row col 
  = withObjectRef "gridSetGridCursor" _obj $ \cobj__obj -> 
    wxGrid_SetGridCursor cobj__obj  (toCInt row)  (toCInt col)  
foreign import ccall "wxGrid_SetGridCursor" wxGrid_SetGridCursor :: Ptr (TGrid a) -> CInt -> CInt -> IO ()

-- | usage: (@gridSetGridLineColour obj col@).
gridSetGridLineColour :: Grid  a -> Color ->  IO ()
gridSetGridLineColour _obj col 
  = withObjectRef "gridSetGridLineColour" _obj $ \cobj__obj -> 
    withColourPtr col $ \cobj_col -> 
    wxGrid_SetGridLineColour cobj__obj  cobj_col  
foreign import ccall "wxGrid_SetGridLineColour" wxGrid_SetGridLineColour :: Ptr (TGrid a) -> Ptr (TColour b) -> IO ()

-- | usage: (@gridSetLabelBackgroundColour obj colour@).
gridSetLabelBackgroundColour :: Grid  a -> Color ->  IO ()
gridSetLabelBackgroundColour _obj colour 
  = withObjectRef "gridSetLabelBackgroundColour" _obj $ \cobj__obj -> 
    withColourPtr colour $ \cobj_colour -> 
    wxGrid_SetLabelBackgroundColour cobj__obj  cobj_colour  
foreign import ccall "wxGrid_SetLabelBackgroundColour" wxGrid_SetLabelBackgroundColour :: Ptr (TGrid a) -> Ptr (TColour b) -> IO ()

-- | usage: (@gridSetLabelFont obj font@).
gridSetLabelFont :: Grid  a -> Font  b ->  IO ()
gridSetLabelFont _obj font 
  = withObjectRef "gridSetLabelFont" _obj $ \cobj__obj -> 
    withObjectPtr font $ \cobj_font -> 
    wxGrid_SetLabelFont cobj__obj  cobj_font  
foreign import ccall "wxGrid_SetLabelFont" wxGrid_SetLabelFont :: Ptr (TGrid a) -> Ptr (TFont b) -> IO ()

-- | usage: (@gridSetLabelTextColour obj colour@).
gridSetLabelTextColour :: Grid  a -> Color ->  IO ()
gridSetLabelTextColour _obj colour 
  = withObjectRef "gridSetLabelTextColour" _obj $ \cobj__obj -> 
    withColourPtr colour $ \cobj_colour -> 
    wxGrid_SetLabelTextColour cobj__obj  cobj_colour  
foreign import ccall "wxGrid_SetLabelTextColour" wxGrid_SetLabelTextColour :: Ptr (TGrid a) -> Ptr (TColour b) -> IO ()

-- | usage: (@gridSetMargins obj extraWidth extraHeight@).
gridSetMargins :: Grid  a -> Int -> Int ->  IO ()
gridSetMargins _obj extraWidth extraHeight 
  = withObjectRef "gridSetMargins" _obj $ \cobj__obj -> 
    wxGrid_SetMargins cobj__obj  (toCInt extraWidth)  (toCInt extraHeight)  
foreign import ccall "wxGrid_SetMargins" wxGrid_SetMargins :: Ptr (TGrid a) -> CInt -> CInt -> IO ()

-- | usage: (@gridSetReadOnly obj row col isReadOnly@).
gridSetReadOnly :: Grid  a -> Int -> Int -> Bool ->  IO ()
gridSetReadOnly _obj row col isReadOnly 
  = withObjectRef "gridSetReadOnly" _obj $ \cobj__obj -> 
    wxGrid_SetReadOnly cobj__obj  (toCInt row)  (toCInt col)  (toCBool isReadOnly)  
foreign import ccall "wxGrid_SetReadOnly" wxGrid_SetReadOnly :: Ptr (TGrid a) -> CInt -> CInt -> CBool -> IO ()

-- | usage: (@gridSetRowAttr obj row attr@).
gridSetRowAttr :: Grid  a -> Int -> GridCellAttr  c ->  IO ()
gridSetRowAttr _obj row attr 
  = withObjectRef "gridSetRowAttr" _obj $ \cobj__obj -> 
    withObjectPtr attr $ \cobj_attr -> 
    wxGrid_SetRowAttr cobj__obj  (toCInt row)  cobj_attr  
foreign import ccall "wxGrid_SetRowAttr" wxGrid_SetRowAttr :: Ptr (TGrid a) -> CInt -> Ptr (TGridCellAttr c) -> IO ()

-- | usage: (@gridSetRowLabelAlignment obj horiz vert@).
gridSetRowLabelAlignment :: Grid  a -> Int -> Int ->  IO ()
gridSetRowLabelAlignment _obj horiz vert 
  = withObjectRef "gridSetRowLabelAlignment" _obj $ \cobj__obj -> 
    wxGrid_SetRowLabelAlignment cobj__obj  (toCInt horiz)  (toCInt vert)  
foreign import ccall "wxGrid_SetRowLabelAlignment" wxGrid_SetRowLabelAlignment :: Ptr (TGrid a) -> CInt -> CInt -> IO ()

-- | usage: (@gridSetRowLabelSize obj width@).
gridSetRowLabelSize :: Grid  a -> Int ->  IO ()
gridSetRowLabelSize _obj width 
  = withObjectRef "gridSetRowLabelSize" _obj $ \cobj__obj -> 
    wxGrid_SetRowLabelSize cobj__obj  (toCInt width)  
foreign import ccall "wxGrid_SetRowLabelSize" wxGrid_SetRowLabelSize :: Ptr (TGrid a) -> CInt -> IO ()

-- | usage: (@gridSetRowLabelValue obj row label@).
gridSetRowLabelValue :: Grid  a -> Int -> String ->  IO ()
gridSetRowLabelValue _obj row label 
  = withObjectRef "gridSetRowLabelValue" _obj $ \cobj__obj -> 
    withStringPtr label $ \cobj_label -> 
    wxGrid_SetRowLabelValue cobj__obj  (toCInt row)  cobj_label  
foreign import ccall "wxGrid_SetRowLabelValue" wxGrid_SetRowLabelValue :: Ptr (TGrid a) -> CInt -> Ptr (TWxString c) -> IO ()

-- | usage: (@gridSetRowMinimalHeight obj row width@).
gridSetRowMinimalHeight :: Grid  a -> Int -> Int ->  IO ()
gridSetRowMinimalHeight _obj row width 
  = withObjectRef "gridSetRowMinimalHeight" _obj $ \cobj__obj -> 
    wxGrid_SetRowMinimalHeight cobj__obj  (toCInt row)  (toCInt width)  
foreign import ccall "wxGrid_SetRowMinimalHeight" wxGrid_SetRowMinimalHeight :: Ptr (TGrid a) -> CInt -> CInt -> IO ()

-- | usage: (@gridSetRowSize obj row height@).
gridSetRowSize :: Grid  a -> Int -> Int ->  IO ()
gridSetRowSize _obj row height 
  = withObjectRef "gridSetRowSize" _obj $ \cobj__obj -> 
    wxGrid_SetRowSize cobj__obj  (toCInt row)  (toCInt height)  
foreign import ccall "wxGrid_SetRowSize" wxGrid_SetRowSize :: Ptr (TGrid a) -> CInt -> CInt -> IO ()

-- | usage: (@gridSetSelectionBackground obj c@).
gridSetSelectionBackground :: Grid  a -> Color ->  IO ()
gridSetSelectionBackground _obj c 
  = withObjectRef "gridSetSelectionBackground" _obj $ \cobj__obj -> 
    withColourPtr c $ \cobj_c -> 
    wxGrid_SetSelectionBackground cobj__obj  cobj_c  
foreign import ccall "wxGrid_SetSelectionBackground" wxGrid_SetSelectionBackground :: Ptr (TGrid a) -> Ptr (TColour b) -> IO ()

-- | usage: (@gridSetSelectionForeground obj c@).
gridSetSelectionForeground :: Grid  a -> Color ->  IO ()
gridSetSelectionForeground _obj c 
  = withObjectRef "gridSetSelectionForeground" _obj $ \cobj__obj -> 
    withColourPtr c $ \cobj_c -> 
    wxGrid_SetSelectionForeground cobj__obj  cobj_c  
foreign import ccall "wxGrid_SetSelectionForeground" wxGrid_SetSelectionForeground :: Ptr (TGrid a) -> Ptr (TColour b) -> IO ()

-- | usage: (@gridSetSelectionMode obj selmode@).
gridSetSelectionMode :: Grid  a -> Int ->  IO ()
gridSetSelectionMode _obj selmode 
  = withObjectRef "gridSetSelectionMode" _obj $ \cobj__obj -> 
    wxGrid_SetSelectionMode cobj__obj  (toCInt selmode)  
foreign import ccall "wxGrid_SetSelectionMode" wxGrid_SetSelectionMode :: Ptr (TGrid a) -> CInt -> IO ()

-- | usage: (@gridSetTable obj table takeOwnership selmode@).
gridSetTable :: Grid  a -> GridTableBase  b -> Bool -> Int ->  IO Bool
gridSetTable _obj table takeOwnership selmode 
  = withBoolResult $
    withObjectRef "gridSetTable" _obj $ \cobj__obj -> 
    withObjectPtr table $ \cobj_table -> 
    wxGrid_SetTable cobj__obj  cobj_table  (toCBool takeOwnership)  (toCInt selmode)  
foreign import ccall "wxGrid_SetTable" wxGrid_SetTable :: Ptr (TGrid a) -> Ptr (TGridTableBase b) -> CBool -> CInt -> IO CBool

-- | usage: (@gridShowCellEditControl obj@).
gridShowCellEditControl :: Grid  a ->  IO ()
gridShowCellEditControl _obj 
  = withObjectRef "gridShowCellEditControl" _obj $ \cobj__obj -> 
    wxGrid_ShowCellEditControl cobj__obj  
foreign import ccall "wxGrid_ShowCellEditControl" wxGrid_ShowCellEditControl :: Ptr (TGrid a) -> IO ()

-- | usage: (@gridSizeEventAltDown obj@).
gridSizeEventAltDown :: GridSizeEvent  a ->  IO Bool
gridSizeEventAltDown _obj 
  = withBoolResult $
    withObjectRef "gridSizeEventAltDown" _obj $ \cobj__obj -> 
    wxGridSizeEvent_AltDown cobj__obj  
foreign import ccall "wxGridSizeEvent_AltDown" wxGridSizeEvent_AltDown :: Ptr (TGridSizeEvent a) -> IO CBool

-- | usage: (@gridSizeEventControlDown obj@).
gridSizeEventControlDown :: GridSizeEvent  a ->  IO Bool
gridSizeEventControlDown _obj 
  = withBoolResult $
    withObjectRef "gridSizeEventControlDown" _obj $ \cobj__obj -> 
    wxGridSizeEvent_ControlDown cobj__obj  
foreign import ccall "wxGridSizeEvent_ControlDown" wxGridSizeEvent_ControlDown :: Ptr (TGridSizeEvent a) -> IO CBool

-- | usage: (@gridSizeEventGetPosition obj@).
gridSizeEventGetPosition :: GridSizeEvent  a ->  IO (Point)
gridSizeEventGetPosition _obj 
  = withWxPointResult $
    withObjectRef "gridSizeEventGetPosition" _obj $ \cobj__obj -> 
    wxGridSizeEvent_GetPosition cobj__obj  
foreign import ccall "wxGridSizeEvent_GetPosition" wxGridSizeEvent_GetPosition :: Ptr (TGridSizeEvent a) -> IO (Ptr (TWxPoint ()))

-- | usage: (@gridSizeEventGetRowOrCol obj@).
gridSizeEventGetRowOrCol :: GridSizeEvent  a ->  IO Int
gridSizeEventGetRowOrCol _obj 
  = withIntResult $
    withObjectRef "gridSizeEventGetRowOrCol" _obj $ \cobj__obj -> 
    wxGridSizeEvent_GetRowOrCol cobj__obj  
foreign import ccall "wxGridSizeEvent_GetRowOrCol" wxGridSizeEvent_GetRowOrCol :: Ptr (TGridSizeEvent a) -> IO CInt

-- | usage: (@gridSizeEventMetaDown obj@).
gridSizeEventMetaDown :: GridSizeEvent  a ->  IO Bool
gridSizeEventMetaDown _obj 
  = withBoolResult $
    withObjectRef "gridSizeEventMetaDown" _obj $ \cobj__obj -> 
    wxGridSizeEvent_MetaDown cobj__obj  
foreign import ccall "wxGridSizeEvent_MetaDown" wxGridSizeEvent_MetaDown :: Ptr (TGridSizeEvent a) -> IO CBool

-- | usage: (@gridSizeEventShiftDown obj@).
gridSizeEventShiftDown :: GridSizeEvent  a ->  IO Bool
gridSizeEventShiftDown _obj 
  = withBoolResult $
    withObjectRef "gridSizeEventShiftDown" _obj $ \cobj__obj -> 
    wxGridSizeEvent_ShiftDown cobj__obj  
foreign import ccall "wxGridSizeEvent_ShiftDown" wxGridSizeEvent_ShiftDown :: Ptr (TGridSizeEvent a) -> IO CBool

-- | usage: (@gridSizerCalcMin obj@).
gridSizerCalcMin :: GridSizer  a ->  IO (Size)
gridSizerCalcMin _obj 
  = withWxSizeResult $
    withObjectRef "gridSizerCalcMin" _obj $ \cobj__obj -> 
    wxGridSizer_CalcMin cobj__obj  
foreign import ccall "wxGridSizer_CalcMin" wxGridSizer_CalcMin :: Ptr (TGridSizer a) -> IO (Ptr (TWxSize ()))

-- | usage: (@gridSizerCreate rows cols vgap hgap@).
gridSizerCreate :: Int -> Int -> Int -> Int ->  IO (GridSizer  ())
gridSizerCreate rows cols vgap hgap 
  = withObjectResult $
    wxGridSizer_Create (toCInt rows)  (toCInt cols)  (toCInt vgap)  (toCInt hgap)  
foreign import ccall "wxGridSizer_Create" wxGridSizer_Create :: CInt -> CInt -> CInt -> CInt -> IO (Ptr (TGridSizer ()))

-- | usage: (@gridSizerGetCols obj@).
gridSizerGetCols :: GridSizer  a ->  IO Int
gridSizerGetCols _obj 
  = withIntResult $
    withObjectRef "gridSizerGetCols" _obj $ \cobj__obj -> 
    wxGridSizer_GetCols cobj__obj  
foreign import ccall "wxGridSizer_GetCols" wxGridSizer_GetCols :: Ptr (TGridSizer a) -> IO CInt

-- | usage: (@gridSizerGetHGap obj@).
gridSizerGetHGap :: GridSizer  a ->  IO Int
gridSizerGetHGap _obj 
  = withIntResult $
    withObjectRef "gridSizerGetHGap" _obj $ \cobj__obj -> 
    wxGridSizer_GetHGap cobj__obj  
foreign import ccall "wxGridSizer_GetHGap" wxGridSizer_GetHGap :: Ptr (TGridSizer a) -> IO CInt

-- | usage: (@gridSizerGetRows obj@).
gridSizerGetRows :: GridSizer  a ->  IO Int
gridSizerGetRows _obj 
  = withIntResult $
    withObjectRef "gridSizerGetRows" _obj $ \cobj__obj -> 
    wxGridSizer_GetRows cobj__obj  
foreign import ccall "wxGridSizer_GetRows" wxGridSizer_GetRows :: Ptr (TGridSizer a) -> IO CInt

-- | usage: (@gridSizerGetVGap obj@).
gridSizerGetVGap :: GridSizer  a ->  IO Int
gridSizerGetVGap _obj 
  = withIntResult $
    withObjectRef "gridSizerGetVGap" _obj $ \cobj__obj -> 
    wxGridSizer_GetVGap cobj__obj  
foreign import ccall "wxGridSizer_GetVGap" wxGridSizer_GetVGap :: Ptr (TGridSizer a) -> IO CInt

-- | usage: (@gridSizerRecalcSizes obj@).
gridSizerRecalcSizes :: GridSizer  a ->  IO ()
gridSizerRecalcSizes _obj 
  = withObjectRef "gridSizerRecalcSizes" _obj $ \cobj__obj -> 
    wxGridSizer_RecalcSizes cobj__obj  
foreign import ccall "wxGridSizer_RecalcSizes" wxGridSizer_RecalcSizes :: Ptr (TGridSizer a) -> IO ()

-- | usage: (@gridSizerSetCols obj cols@).
gridSizerSetCols :: GridSizer  a -> Int ->  IO ()
gridSizerSetCols _obj cols 
  = withObjectRef "gridSizerSetCols" _obj $ \cobj__obj -> 
    wxGridSizer_SetCols cobj__obj  (toCInt cols)  
foreign import ccall "wxGridSizer_SetCols" wxGridSizer_SetCols :: Ptr (TGridSizer a) -> CInt -> IO ()

-- | usage: (@gridSizerSetHGap obj gap@).
gridSizerSetHGap :: GridSizer  a -> Int ->  IO ()
gridSizerSetHGap _obj gap 
  = withObjectRef "gridSizerSetHGap" _obj $ \cobj__obj -> 
    wxGridSizer_SetHGap cobj__obj  (toCInt gap)  
foreign import ccall "wxGridSizer_SetHGap" wxGridSizer_SetHGap :: Ptr (TGridSizer a) -> CInt -> IO ()

-- | usage: (@gridSizerSetRows obj rows@).
gridSizerSetRows :: GridSizer  a -> Int ->  IO ()
gridSizerSetRows _obj rows 
  = withObjectRef "gridSizerSetRows" _obj $ \cobj__obj -> 
    wxGridSizer_SetRows cobj__obj  (toCInt rows)  
foreign import ccall "wxGridSizer_SetRows" wxGridSizer_SetRows :: Ptr (TGridSizer a) -> CInt -> IO ()

-- | usage: (@gridSizerSetVGap obj gap@).
gridSizerSetVGap :: GridSizer  a -> Int ->  IO ()
gridSizerSetVGap _obj gap 
  = withObjectRef "gridSizerSetVGap" _obj $ \cobj__obj -> 
    wxGridSizer_SetVGap cobj__obj  (toCInt gap)  
foreign import ccall "wxGridSizer_SetVGap" wxGridSizer_SetVGap :: Ptr (TGridSizer a) -> CInt -> IO ()

-- | usage: (@gridStringToLines obj value lines@).
gridStringToLines :: Grid  a -> String -> Ptr  c ->  IO Int
gridStringToLines _obj value lines 
  = withIntResult $
    withObjectRef "gridStringToLines" _obj $ \cobj__obj -> 
    withStringPtr value $ \cobj_value -> 
    wxGrid_StringToLines cobj__obj  cobj_value  lines  
foreign import ccall "wxGrid_StringToLines" wxGrid_StringToLines :: Ptr (TGrid a) -> Ptr (TWxString b) -> Ptr  c -> IO CInt

-- | usage: (@gridXToCol obj x@).
gridXToCol :: Grid  a -> Int ->  IO Int
gridXToCol _obj x 
  = withIntResult $
    withObjectRef "gridXToCol" _obj $ \cobj__obj -> 
    wxGrid_XToCol cobj__obj  (toCInt x)  
foreign import ccall "wxGrid_XToCol" wxGrid_XToCol :: Ptr (TGrid a) -> CInt -> IO CInt

-- | usage: (@gridXToEdgeOfCol obj x@).
gridXToEdgeOfCol :: Grid  a -> Int ->  IO Int
gridXToEdgeOfCol _obj x 
  = withIntResult $
    withObjectRef "gridXToEdgeOfCol" _obj $ \cobj__obj -> 
    wxGrid_XToEdgeOfCol cobj__obj  (toCInt x)  
foreign import ccall "wxGrid_XToEdgeOfCol" wxGrid_XToEdgeOfCol :: Ptr (TGrid a) -> CInt -> IO CInt

-- | usage: (@gridXYToCell obj xy@).
gridXYToCell :: Grid  a -> Point ->  IO Point
gridXYToCell _obj xy 
  = withPointResult $ \px py -> 
    withObjectRef "gridXYToCell" _obj $ \cobj__obj -> 
    wxGrid_XYToCell cobj__obj  (toCIntPointX xy) (toCIntPointY xy)   px py
foreign import ccall "wxGrid_XYToCell" wxGrid_XYToCell :: Ptr (TGrid a) -> CInt -> CInt -> Ptr CInt -> Ptr CInt -> IO ()

-- | usage: (@gridYToEdgeOfRow obj y@).
gridYToEdgeOfRow :: Grid  a -> Int ->  IO Int
gridYToEdgeOfRow _obj y 
  = withIntResult $
    withObjectRef "gridYToEdgeOfRow" _obj $ \cobj__obj -> 
    wxGrid_YToEdgeOfRow cobj__obj  (toCInt y)  
foreign import ccall "wxGrid_YToEdgeOfRow" wxGrid_YToEdgeOfRow :: Ptr (TGrid a) -> CInt -> IO CInt

-- | usage: (@gridYToRow obj y@).
gridYToRow :: Grid  a -> Int ->  IO Int
gridYToRow _obj y 
  = withIntResult $
    withObjectRef "gridYToRow" _obj $ \cobj__obj -> 
    wxGrid_YToRow cobj__obj  (toCInt y)  
foreign import ccall "wxGrid_YToRow" wxGrid_YToRow :: Ptr (TGrid a) -> CInt -> IO CInt

-- | usage: (@helpControllerHelpProviderCreate ctr@).
helpControllerHelpProviderCreate :: HelpControllerBase  a ->  IO (HelpControllerHelpProvider  ())
helpControllerHelpProviderCreate ctr 
  = withObjectResult $
    withObjectPtr ctr $ \cobj_ctr -> 
    wxHelpControllerHelpProvider_Create cobj_ctr  
foreign import ccall "wxHelpControllerHelpProvider_Create" wxHelpControllerHelpProvider_Create :: Ptr (THelpControllerBase a) -> IO (Ptr (THelpControllerHelpProvider ()))

-- | usage: (@helpControllerHelpProviderGetHelpController obj@).
helpControllerHelpProviderGetHelpController :: HelpControllerHelpProvider  a ->  IO (HelpControllerBase  ())
helpControllerHelpProviderGetHelpController _obj 
  = withObjectResult $
    withObjectRef "helpControllerHelpProviderGetHelpController" _obj $ \cobj__obj -> 
    wxHelpControllerHelpProvider_GetHelpController cobj__obj  
foreign import ccall "wxHelpControllerHelpProvider_GetHelpController" wxHelpControllerHelpProvider_GetHelpController :: Ptr (THelpControllerHelpProvider a) -> IO (Ptr (THelpControllerBase ()))

-- | usage: (@helpControllerHelpProviderSetHelpController obj hc@).
helpControllerHelpProviderSetHelpController :: HelpControllerHelpProvider  a -> HelpController  b ->  IO ()
helpControllerHelpProviderSetHelpController _obj hc 
  = withObjectRef "helpControllerHelpProviderSetHelpController" _obj $ \cobj__obj -> 
    withObjectPtr hc $ \cobj_hc -> 
    wxHelpControllerHelpProvider_SetHelpController cobj__obj  cobj_hc  
foreign import ccall "wxHelpControllerHelpProvider_SetHelpController" wxHelpControllerHelpProvider_SetHelpController :: Ptr (THelpControllerHelpProvider a) -> Ptr (THelpController b) -> IO ()

-- | usage: (@helpEventGetLink obj@).
helpEventGetLink :: HelpEvent  a ->  IO (String)
helpEventGetLink _obj 
  = withManagedStringResult $
    withObjectRef "helpEventGetLink" _obj $ \cobj__obj -> 
    wxHelpEvent_GetLink cobj__obj  
foreign import ccall "wxHelpEvent_GetLink" wxHelpEvent_GetLink :: Ptr (THelpEvent a) -> IO (Ptr (TWxString ()))

-- | usage: (@helpEventGetPosition obj@).
helpEventGetPosition :: HelpEvent  a ->  IO (Point)
helpEventGetPosition _obj 
  = withWxPointResult $
    withObjectRef "helpEventGetPosition" _obj $ \cobj__obj -> 
    wxHelpEvent_GetPosition cobj__obj  
foreign import ccall "wxHelpEvent_GetPosition" wxHelpEvent_GetPosition :: Ptr (THelpEvent a) -> IO (Ptr (TWxPoint ()))

-- | usage: (@helpEventGetTarget obj@).
helpEventGetTarget :: HelpEvent  a ->  IO (String)
helpEventGetTarget _obj 
  = withManagedStringResult $
    withObjectRef "helpEventGetTarget" _obj $ \cobj__obj -> 
    wxHelpEvent_GetTarget cobj__obj  
foreign import ccall "wxHelpEvent_GetTarget" wxHelpEvent_GetTarget :: Ptr (THelpEvent a) -> IO (Ptr (TWxString ()))

-- | usage: (@helpEventSetLink obj link@).
helpEventSetLink :: HelpEvent  a -> String ->  IO ()
helpEventSetLink _obj link 
  = withObjectRef "helpEventSetLink" _obj $ \cobj__obj -> 
    withStringPtr link $ \cobj_link -> 
    wxHelpEvent_SetLink cobj__obj  cobj_link  
foreign import ccall "wxHelpEvent_SetLink" wxHelpEvent_SetLink :: Ptr (THelpEvent a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@helpEventSetPosition obj xy@).
helpEventSetPosition :: HelpEvent  a -> Point ->  IO ()
helpEventSetPosition _obj xy 
  = withObjectRef "helpEventSetPosition" _obj $ \cobj__obj -> 
    wxHelpEvent_SetPosition cobj__obj  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxHelpEvent_SetPosition" wxHelpEvent_SetPosition :: Ptr (THelpEvent a) -> CInt -> CInt -> IO ()

-- | usage: (@helpEventSetTarget obj target@).
helpEventSetTarget :: HelpEvent  a -> String ->  IO ()
helpEventSetTarget _obj target 
  = withObjectRef "helpEventSetTarget" _obj $ \cobj__obj -> 
    withStringPtr target $ \cobj_target -> 
    wxHelpEvent_SetTarget cobj__obj  cobj_target  
foreign import ccall "wxHelpEvent_SetTarget" wxHelpEvent_SetTarget :: Ptr (THelpEvent a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@helpProviderAddHelp obj window text@).
helpProviderAddHelp :: HelpProvider  a -> Window  b -> String ->  IO ()
helpProviderAddHelp _obj window text 
  = withObjectRef "helpProviderAddHelp" _obj $ \cobj__obj -> 
    withObjectPtr window $ \cobj_window -> 
    withStringPtr text $ \cobj_text -> 
    wxHelpProvider_AddHelp cobj__obj  cobj_window  cobj_text  
foreign import ccall "wxHelpProvider_AddHelp" wxHelpProvider_AddHelp :: Ptr (THelpProvider a) -> Ptr (TWindow b) -> Ptr (TWxString c) -> IO ()

-- | usage: (@helpProviderAddHelpById obj id text@).
helpProviderAddHelpById :: HelpProvider  a -> Id -> String ->  IO ()
helpProviderAddHelpById _obj id text 
  = withObjectRef "helpProviderAddHelpById" _obj $ \cobj__obj -> 
    withStringPtr text $ \cobj_text -> 
    wxHelpProvider_AddHelpById cobj__obj  (toCInt id)  cobj_text  
foreign import ccall "wxHelpProvider_AddHelpById" wxHelpProvider_AddHelpById :: Ptr (THelpProvider a) -> CInt -> Ptr (TWxString c) -> IO ()

-- | usage: (@helpProviderDelete obj@).
helpProviderDelete :: HelpProvider  a ->  IO ()
helpProviderDelete _obj 
  = withObjectRef "helpProviderDelete" _obj $ \cobj__obj -> 
    wxHelpProvider_Delete cobj__obj  
foreign import ccall "wxHelpProvider_Delete" wxHelpProvider_Delete :: Ptr (THelpProvider a) -> IO ()

-- | usage: (@helpProviderGet@).
helpProviderGet ::  IO (HelpProvider  ())
helpProviderGet 
  = withObjectResult $
    wxHelpProvider_Get 
foreign import ccall "wxHelpProvider_Get" wxHelpProvider_Get :: IO (Ptr (THelpProvider ()))

-- | usage: (@helpProviderGetHelp obj window@).
helpProviderGetHelp :: HelpProvider  a -> Window  b ->  IO (String)
helpProviderGetHelp _obj window 
  = withManagedStringResult $
    withObjectRef "helpProviderGetHelp" _obj $ \cobj__obj -> 
    withObjectPtr window $ \cobj_window -> 
    wxHelpProvider_GetHelp cobj__obj  cobj_window  
foreign import ccall "wxHelpProvider_GetHelp" wxHelpProvider_GetHelp :: Ptr (THelpProvider a) -> Ptr (TWindow b) -> IO (Ptr (TWxString ()))

-- | usage: (@helpProviderRemoveHelp obj window@).
helpProviderRemoveHelp :: HelpProvider  a -> Window  b ->  IO ()
helpProviderRemoveHelp _obj window 
  = withObjectRef "helpProviderRemoveHelp" _obj $ \cobj__obj -> 
    withObjectPtr window $ \cobj_window -> 
    wxHelpProvider_RemoveHelp cobj__obj  cobj_window  
foreign import ccall "wxHelpProvider_RemoveHelp" wxHelpProvider_RemoveHelp :: Ptr (THelpProvider a) -> Ptr (TWindow b) -> IO ()

-- | usage: (@helpProviderSet helpProvider@).
helpProviderSet :: HelpProvider  a ->  IO (HelpProvider  ())
helpProviderSet helpProvider 
  = withObjectResult $
    withObjectRef "helpProviderSet" helpProvider $ \cobj_helpProvider -> 
    wxHelpProvider_Set cobj_helpProvider  
foreign import ccall "wxHelpProvider_Set" wxHelpProvider_Set :: Ptr (THelpProvider a) -> IO (Ptr (THelpProvider ()))

-- | usage: (@helpProviderShowHelp obj window@).
helpProviderShowHelp :: HelpProvider  a -> Window  b ->  IO Bool
helpProviderShowHelp _obj window 
  = withBoolResult $
    withObjectRef "helpProviderShowHelp" _obj $ \cobj__obj -> 
    withObjectPtr window $ \cobj_window -> 
    wxHelpProvider_ShowHelp cobj__obj  cobj_window  
foreign import ccall "wxHelpProvider_ShowHelp" wxHelpProvider_ShowHelp :: Ptr (THelpProvider a) -> Ptr (TWindow b) -> IO CBool

-- | usage: (@htmlHelpControllerAddBook obj book showwaitmsg@).
htmlHelpControllerAddBook :: HtmlHelpController  a -> Ptr  b -> Int ->  IO Bool
htmlHelpControllerAddBook _obj book showwaitmsg 
  = withBoolResult $
    withObjectRef "htmlHelpControllerAddBook" _obj $ \cobj__obj -> 
    wxHtmlHelpController_AddBook cobj__obj  book  (toCInt showwaitmsg)  
foreign import ccall "wxHtmlHelpController_AddBook" wxHtmlHelpController_AddBook :: Ptr (THtmlHelpController a) -> Ptr  b -> CInt -> IO CBool

-- | usage: (@htmlHelpControllerCreate style@).
htmlHelpControllerCreate :: Int ->  IO (HtmlHelpController  ())
htmlHelpControllerCreate _style 
  = withObjectResult $
    wxHtmlHelpController_Create (toCInt _style)  
foreign import ccall "wxHtmlHelpController_Create" wxHtmlHelpController_Create :: CInt -> IO (Ptr (THtmlHelpController ()))

-- | usage: (@htmlHelpControllerDelete obj@).
htmlHelpControllerDelete :: HtmlHelpController  a ->  IO ()
htmlHelpControllerDelete
  = objectDelete


-- | usage: (@htmlHelpControllerDisplay obj x@).
htmlHelpControllerDisplay :: HtmlHelpController  a -> Ptr  b ->  IO Int
htmlHelpControllerDisplay _obj x 
  = withIntResult $
    withObjectRef "htmlHelpControllerDisplay" _obj $ \cobj__obj -> 
    wxHtmlHelpController_Display cobj__obj  x  
foreign import ccall "wxHtmlHelpController_Display" wxHtmlHelpController_Display :: Ptr (THtmlHelpController a) -> Ptr  b -> IO CInt

-- | usage: (@htmlHelpControllerDisplayBlock obj blockNo@).
htmlHelpControllerDisplayBlock :: HtmlHelpController  a -> Int ->  IO Bool
htmlHelpControllerDisplayBlock _obj blockNo 
  = withBoolResult $
    withObjectRef "htmlHelpControllerDisplayBlock" _obj $ \cobj__obj -> 
    wxHtmlHelpController_DisplayBlock cobj__obj  (toCInt blockNo)  
foreign import ccall "wxHtmlHelpController_DisplayBlock" wxHtmlHelpController_DisplayBlock :: Ptr (THtmlHelpController a) -> CInt -> IO CBool

-- | usage: (@htmlHelpControllerDisplayContents obj@).
htmlHelpControllerDisplayContents :: HtmlHelpController  a ->  IO Int
htmlHelpControllerDisplayContents _obj 
  = withIntResult $
    withObjectRef "htmlHelpControllerDisplayContents" _obj $ \cobj__obj -> 
    wxHtmlHelpController_DisplayContents cobj__obj  
foreign import ccall "wxHtmlHelpController_DisplayContents" wxHtmlHelpController_DisplayContents :: Ptr (THtmlHelpController a) -> IO CInt

-- | usage: (@htmlHelpControllerDisplayIndex obj@).
htmlHelpControllerDisplayIndex :: HtmlHelpController  a ->  IO Int
htmlHelpControllerDisplayIndex _obj 
  = withIntResult $
    withObjectRef "htmlHelpControllerDisplayIndex" _obj $ \cobj__obj -> 
    wxHtmlHelpController_DisplayIndex cobj__obj  
foreign import ccall "wxHtmlHelpController_DisplayIndex" wxHtmlHelpController_DisplayIndex :: Ptr (THtmlHelpController a) -> IO CInt

-- | usage: (@htmlHelpControllerDisplayNumber obj id@).
htmlHelpControllerDisplayNumber :: HtmlHelpController  a -> Id ->  IO Int
htmlHelpControllerDisplayNumber _obj id 
  = withIntResult $
    withObjectRef "htmlHelpControllerDisplayNumber" _obj $ \cobj__obj -> 
    wxHtmlHelpController_DisplayNumber cobj__obj  (toCInt id)  
foreign import ccall "wxHtmlHelpController_DisplayNumber" wxHtmlHelpController_DisplayNumber :: Ptr (THtmlHelpController a) -> CInt -> IO CInt

-- | usage: (@htmlHelpControllerDisplaySection obj section@).
htmlHelpControllerDisplaySection :: HtmlHelpController  a -> String ->  IO Bool
htmlHelpControllerDisplaySection _obj section 
  = withBoolResult $
    withObjectRef "htmlHelpControllerDisplaySection" _obj $ \cobj__obj -> 
    withStringPtr section $ \cobj_section -> 
    wxHtmlHelpController_DisplaySection cobj__obj  cobj_section  
foreign import ccall "wxHtmlHelpController_DisplaySection" wxHtmlHelpController_DisplaySection :: Ptr (THtmlHelpController a) -> Ptr (TWxString b) -> IO CBool

-- | usage: (@htmlHelpControllerDisplaySectionNumber obj sectionNo@).
htmlHelpControllerDisplaySectionNumber :: HtmlHelpController  a -> Int ->  IO Bool
htmlHelpControllerDisplaySectionNumber _obj sectionNo 
  = withBoolResult $
    withObjectRef "htmlHelpControllerDisplaySectionNumber" _obj $ \cobj__obj -> 
    wxHtmlHelpController_DisplaySectionNumber cobj__obj  (toCInt sectionNo)  
foreign import ccall "wxHtmlHelpController_DisplaySectionNumber" wxHtmlHelpController_DisplaySectionNumber :: Ptr (THtmlHelpController a) -> CInt -> IO CBool

-- | usage: (@htmlHelpControllerGetFrame obj@).
htmlHelpControllerGetFrame :: HtmlHelpController  a ->  IO (Frame  ())
htmlHelpControllerGetFrame _obj 
  = withObjectResult $
    withObjectRef "htmlHelpControllerGetFrame" _obj $ \cobj__obj -> 
    wxHtmlHelpController_GetFrame cobj__obj  
foreign import ccall "wxHtmlHelpController_GetFrame" wxHtmlHelpController_GetFrame :: Ptr (THtmlHelpController a) -> IO (Ptr (TFrame ()))

-- | usage: (@htmlHelpControllerGetFrameParameters obj title width height posx posy newFrameEachTime@).
htmlHelpControllerGetFrameParameters :: HtmlHelpController  a -> Ptr  b -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt ->  IO (Ptr  ())
htmlHelpControllerGetFrameParameters _obj title width height posx posy newFrameEachTime 
  = withObjectRef "htmlHelpControllerGetFrameParameters" _obj $ \cobj__obj -> 
    wxHtmlHelpController_GetFrameParameters cobj__obj  title  width  height  posx  posy  newFrameEachTime  
foreign import ccall "wxHtmlHelpController_GetFrameParameters" wxHtmlHelpController_GetFrameParameters :: Ptr (THtmlHelpController a) -> Ptr  b -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO (Ptr  ())

-- | usage: (@htmlHelpControllerInitialize obj file@).
htmlHelpControllerInitialize :: HtmlHelpController  a -> String ->  IO Bool
htmlHelpControllerInitialize _obj file 
  = withBoolResult $
    withObjectRef "htmlHelpControllerInitialize" _obj $ \cobj__obj -> 
    withStringPtr file $ \cobj_file -> 
    wxHtmlHelpController_Initialize cobj__obj  cobj_file  
foreign import ccall "wxHtmlHelpController_Initialize" wxHtmlHelpController_Initialize :: Ptr (THtmlHelpController a) -> Ptr (TWxString b) -> IO CBool

-- | usage: (@htmlHelpControllerKeywordSearch obj keyword@).
htmlHelpControllerKeywordSearch :: HtmlHelpController  a -> String ->  IO Bool
htmlHelpControllerKeywordSearch _obj keyword 
  = withBoolResult $
    withObjectRef "htmlHelpControllerKeywordSearch" _obj $ \cobj__obj -> 
    withStringPtr keyword $ \cobj_keyword -> 
    wxHtmlHelpController_KeywordSearch cobj__obj  cobj_keyword  
foreign import ccall "wxHtmlHelpController_KeywordSearch" wxHtmlHelpController_KeywordSearch :: Ptr (THtmlHelpController a) -> Ptr (TWxString b) -> IO CBool

-- | usage: (@htmlHelpControllerLoadFile obj file@).
htmlHelpControllerLoadFile :: HtmlHelpController  a -> String ->  IO Bool
htmlHelpControllerLoadFile _obj file 
  = withBoolResult $
    withObjectRef "htmlHelpControllerLoadFile" _obj $ \cobj__obj -> 
    withStringPtr file $ \cobj_file -> 
    wxHtmlHelpController_LoadFile cobj__obj  cobj_file  
foreign import ccall "wxHtmlHelpController_LoadFile" wxHtmlHelpController_LoadFile :: Ptr (THtmlHelpController a) -> Ptr (TWxString b) -> IO CBool

-- | usage: (@htmlHelpControllerQuit obj@).
htmlHelpControllerQuit :: HtmlHelpController  a ->  IO Bool
htmlHelpControllerQuit _obj 
  = withBoolResult $
    withObjectRef "htmlHelpControllerQuit" _obj $ \cobj__obj -> 
    wxHtmlHelpController_Quit cobj__obj  
foreign import ccall "wxHtmlHelpController_Quit" wxHtmlHelpController_Quit :: Ptr (THtmlHelpController a) -> IO CBool

-- | usage: (@htmlHelpControllerReadCustomization obj cfg path@).
htmlHelpControllerReadCustomization :: HtmlHelpController  a -> ConfigBase  b -> String ->  IO ()
htmlHelpControllerReadCustomization _obj cfg path 
  = withObjectRef "htmlHelpControllerReadCustomization" _obj $ \cobj__obj -> 
    withObjectPtr cfg $ \cobj_cfg -> 
    withStringPtr path $ \cobj_path -> 
    wxHtmlHelpController_ReadCustomization cobj__obj  cobj_cfg  cobj_path  
foreign import ccall "wxHtmlHelpController_ReadCustomization" wxHtmlHelpController_ReadCustomization :: Ptr (THtmlHelpController a) -> Ptr (TConfigBase b) -> Ptr (TWxString c) -> IO ()

-- | usage: (@htmlHelpControllerSetFrameParameters obj title widthheight posx posy newFrameEachTime@).
htmlHelpControllerSetFrameParameters :: HtmlHelpController  a -> Ptr  b -> Size -> Int -> Int -> Bool ->  IO ()
htmlHelpControllerSetFrameParameters _obj title widthheight posx posy newFrameEachTime 
  = withObjectRef "htmlHelpControllerSetFrameParameters" _obj $ \cobj__obj -> 
    wxHtmlHelpController_SetFrameParameters cobj__obj  title  (toCIntSizeW widthheight) (toCIntSizeH widthheight)  (toCInt posx)  (toCInt posy)  (toCBool newFrameEachTime)  
foreign import ccall "wxHtmlHelpController_SetFrameParameters" wxHtmlHelpController_SetFrameParameters :: Ptr (THtmlHelpController a) -> Ptr  b -> CInt -> CInt -> CInt -> CInt -> CBool -> IO ()

-- | usage: (@htmlHelpControllerSetTempDir obj path@).
htmlHelpControllerSetTempDir :: HtmlHelpController  a -> String ->  IO ()
htmlHelpControllerSetTempDir _obj path 
  = withObjectRef "htmlHelpControllerSetTempDir" _obj $ \cobj__obj -> 
    withStringPtr path $ \cobj_path -> 
    wxHtmlHelpController_SetTempDir cobj__obj  cobj_path  
foreign import ccall "wxHtmlHelpController_SetTempDir" wxHtmlHelpController_SetTempDir :: Ptr (THtmlHelpController a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@htmlHelpControllerSetTitleFormat obj format@).
htmlHelpControllerSetTitleFormat :: HtmlHelpController  a -> Ptr  b ->  IO ()
htmlHelpControllerSetTitleFormat _obj format 
  = withObjectRef "htmlHelpControllerSetTitleFormat" _obj $ \cobj__obj -> 
    wxHtmlHelpController_SetTitleFormat cobj__obj  format  
foreign import ccall "wxHtmlHelpController_SetTitleFormat" wxHtmlHelpController_SetTitleFormat :: Ptr (THtmlHelpController a) -> Ptr  b -> IO ()

-- | usage: (@htmlHelpControllerSetViewer obj viewer flags@).
htmlHelpControllerSetViewer :: HtmlHelpController  a -> String -> Int ->  IO ()
htmlHelpControllerSetViewer _obj viewer flags 
  = withObjectRef "htmlHelpControllerSetViewer" _obj $ \cobj__obj -> 
    withStringPtr viewer $ \cobj_viewer -> 
    wxHtmlHelpController_SetViewer cobj__obj  cobj_viewer  (toCInt flags)  
foreign import ccall "wxHtmlHelpController_SetViewer" wxHtmlHelpController_SetViewer :: Ptr (THtmlHelpController a) -> Ptr (TWxString b) -> CInt -> IO ()

-- | usage: (@htmlHelpControllerUseConfig obj config rootpath@).
htmlHelpControllerUseConfig :: HtmlHelpController  a -> ConfigBase  b -> String ->  IO ()
htmlHelpControllerUseConfig _obj config rootpath 
  = withObjectRef "htmlHelpControllerUseConfig" _obj $ \cobj__obj -> 
    withObjectPtr config $ \cobj_config -> 
    withStringPtr rootpath $ \cobj_rootpath -> 
    wxHtmlHelpController_UseConfig cobj__obj  cobj_config  cobj_rootpath  
foreign import ccall "wxHtmlHelpController_UseConfig" wxHtmlHelpController_UseConfig :: Ptr (THtmlHelpController a) -> Ptr (TConfigBase b) -> Ptr (TWxString c) -> IO ()

-- | usage: (@htmlHelpControllerWriteCustomization obj cfg path@).
htmlHelpControllerWriteCustomization :: HtmlHelpController  a -> ConfigBase  b -> String ->  IO ()
htmlHelpControllerWriteCustomization _obj cfg path 
  = withObjectRef "htmlHelpControllerWriteCustomization" _obj $ \cobj__obj -> 
    withObjectPtr cfg $ \cobj_cfg -> 
    withStringPtr path $ \cobj_path -> 
    wxHtmlHelpController_WriteCustomization cobj__obj  cobj_cfg  cobj_path  
foreign import ccall "wxHtmlHelpController_WriteCustomization" wxHtmlHelpController_WriteCustomization :: Ptr (THtmlHelpController a) -> Ptr (TConfigBase b) -> Ptr (TWxString c) -> IO ()

-- | usage: (@htmlWindowAppendToPage obj source@).
htmlWindowAppendToPage :: HtmlWindow  a -> String ->  IO Bool
htmlWindowAppendToPage _obj source 
  = withBoolResult $
    withObjectRef "htmlWindowAppendToPage" _obj $ \cobj__obj -> 
    withStringPtr source $ \cobj_source -> 
    wxHtmlWindow_AppendToPage cobj__obj  cobj_source  
foreign import ccall "wxHtmlWindow_AppendToPage" wxHtmlWindow_AppendToPage :: Ptr (THtmlWindow a) -> Ptr (TWxString b) -> IO CBool

-- | usage: (@htmlWindowCreate prt id lfttopwdthgt stl txt@).
htmlWindowCreate :: Window  a -> Id -> Rect -> Style -> String ->  IO (HtmlWindow  ())
htmlWindowCreate _prt _id _lfttopwdthgt _stl _txt 
  = withObjectResult $
    withObjectPtr _prt $ \cobj__prt -> 
    withStringPtr _txt $ \cobj__txt -> 
    wxHtmlWindow_Create cobj__prt  (toCInt _id)  (toCIntRectX _lfttopwdthgt) (toCIntRectY _lfttopwdthgt)(toCIntRectW _lfttopwdthgt) (toCIntRectH _lfttopwdthgt)  (toCInt _stl)  cobj__txt  
foreign import ccall "wxHtmlWindow_Create" wxHtmlWindow_Create :: Ptr (TWindow a) -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr (TWxString e) -> IO (Ptr (THtmlWindow ()))

-- | usage: (@htmlWindowGetInternalRepresentation obj@).
htmlWindowGetInternalRepresentation :: HtmlWindow  a ->  IO (HtmlContainerCell  ())
htmlWindowGetInternalRepresentation _obj 
  = withObjectResult $
    withObjectRef "htmlWindowGetInternalRepresentation" _obj $ \cobj__obj -> 
    wxHtmlWindow_GetInternalRepresentation cobj__obj  
foreign import ccall "wxHtmlWindow_GetInternalRepresentation" wxHtmlWindow_GetInternalRepresentation :: Ptr (THtmlWindow a) -> IO (Ptr (THtmlContainerCell ()))

-- | usage: (@htmlWindowGetOpenedAnchor obj@).
htmlWindowGetOpenedAnchor :: HtmlWindow  a ->  IO (String)
htmlWindowGetOpenedAnchor _obj 
  = withManagedStringResult $
    withObjectRef "htmlWindowGetOpenedAnchor" _obj $ \cobj__obj -> 
    wxHtmlWindow_GetOpenedAnchor cobj__obj  
foreign import ccall "wxHtmlWindow_GetOpenedAnchor" wxHtmlWindow_GetOpenedAnchor :: Ptr (THtmlWindow a) -> IO (Ptr (TWxString ()))

-- | usage: (@htmlWindowGetOpenedPage obj@).
htmlWindowGetOpenedPage :: HtmlWindow  a ->  IO (String)
htmlWindowGetOpenedPage _obj 
  = withManagedStringResult $
    withObjectRef "htmlWindowGetOpenedPage" _obj $ \cobj__obj -> 
    wxHtmlWindow_GetOpenedPage cobj__obj  
foreign import ccall "wxHtmlWindow_GetOpenedPage" wxHtmlWindow_GetOpenedPage :: Ptr (THtmlWindow a) -> IO (Ptr (TWxString ()))

-- | usage: (@htmlWindowGetOpenedPageTitle obj@).
htmlWindowGetOpenedPageTitle :: HtmlWindow  a ->  IO (String)
htmlWindowGetOpenedPageTitle _obj 
  = withManagedStringResult $
    withObjectRef "htmlWindowGetOpenedPageTitle" _obj $ \cobj__obj -> 
    wxHtmlWindow_GetOpenedPageTitle cobj__obj  
foreign import ccall "wxHtmlWindow_GetOpenedPageTitle" wxHtmlWindow_GetOpenedPageTitle :: Ptr (THtmlWindow a) -> IO (Ptr (TWxString ()))

-- | usage: (@htmlWindowGetRelatedFrame obj@).
htmlWindowGetRelatedFrame :: HtmlWindow  a ->  IO (Frame  ())
htmlWindowGetRelatedFrame _obj 
  = withObjectResult $
    withObjectRef "htmlWindowGetRelatedFrame" _obj $ \cobj__obj -> 
    wxHtmlWindow_GetRelatedFrame cobj__obj  
foreign import ccall "wxHtmlWindow_GetRelatedFrame" wxHtmlWindow_GetRelatedFrame :: Ptr (THtmlWindow a) -> IO (Ptr (TFrame ()))

-- | usage: (@htmlWindowHistoryBack obj@).
htmlWindowHistoryBack :: HtmlWindow  a ->  IO Bool
htmlWindowHistoryBack _obj 
  = withBoolResult $
    withObjectRef "htmlWindowHistoryBack" _obj $ \cobj__obj -> 
    wxHtmlWindow_HistoryBack cobj__obj  
foreign import ccall "wxHtmlWindow_HistoryBack" wxHtmlWindow_HistoryBack :: Ptr (THtmlWindow a) -> IO CBool

-- | usage: (@htmlWindowHistoryCanBack obj@).
htmlWindowHistoryCanBack :: HtmlWindow  a ->  IO Bool
htmlWindowHistoryCanBack _obj 
  = withBoolResult $
    withObjectRef "htmlWindowHistoryCanBack" _obj $ \cobj__obj -> 
    wxHtmlWindow_HistoryCanBack cobj__obj  
foreign import ccall "wxHtmlWindow_HistoryCanBack" wxHtmlWindow_HistoryCanBack :: Ptr (THtmlWindow a) -> IO CBool

-- | usage: (@htmlWindowHistoryCanForward obj@).
htmlWindowHistoryCanForward :: HtmlWindow  a ->  IO Bool
htmlWindowHistoryCanForward _obj 
  = withBoolResult $
    withObjectRef "htmlWindowHistoryCanForward" _obj $ \cobj__obj -> 
    wxHtmlWindow_HistoryCanForward cobj__obj  
foreign import ccall "wxHtmlWindow_HistoryCanForward" wxHtmlWindow_HistoryCanForward :: Ptr (THtmlWindow a) -> IO CBool

-- | usage: (@htmlWindowHistoryClear obj@).
htmlWindowHistoryClear :: HtmlWindow  a ->  IO ()
htmlWindowHistoryClear _obj 
  = withObjectRef "htmlWindowHistoryClear" _obj $ \cobj__obj -> 
    wxHtmlWindow_HistoryClear cobj__obj  
foreign import ccall "wxHtmlWindow_HistoryClear" wxHtmlWindow_HistoryClear :: Ptr (THtmlWindow a) -> IO ()

-- | usage: (@htmlWindowHistoryForward obj@).
htmlWindowHistoryForward :: HtmlWindow  a ->  IO Bool
htmlWindowHistoryForward _obj 
  = withBoolResult $
    withObjectRef "htmlWindowHistoryForward" _obj $ \cobj__obj -> 
    wxHtmlWindow_HistoryForward cobj__obj  
foreign import ccall "wxHtmlWindow_HistoryForward" wxHtmlWindow_HistoryForward :: Ptr (THtmlWindow a) -> IO CBool

-- | usage: (@htmlWindowLoadPage obj location@).
htmlWindowLoadPage :: HtmlWindow  a -> String ->  IO Bool
htmlWindowLoadPage _obj location 
  = withBoolResult $
    withObjectRef "htmlWindowLoadPage" _obj $ \cobj__obj -> 
    withStringPtr location $ \cobj_location -> 
    wxHtmlWindow_LoadPage cobj__obj  cobj_location  
foreign import ccall "wxHtmlWindow_LoadPage" wxHtmlWindow_LoadPage :: Ptr (THtmlWindow a) -> Ptr (TWxString b) -> IO CBool

-- | usage: (@htmlWindowReadCustomization obj cfg path@).
htmlWindowReadCustomization :: HtmlWindow  a -> ConfigBase  b -> String ->  IO ()
htmlWindowReadCustomization _obj cfg path 
  = withObjectRef "htmlWindowReadCustomization" _obj $ \cobj__obj -> 
    withObjectPtr cfg $ \cobj_cfg -> 
    withStringPtr path $ \cobj_path -> 
    wxHtmlWindow_ReadCustomization cobj__obj  cobj_cfg  cobj_path  
foreign import ccall "wxHtmlWindow_ReadCustomization" wxHtmlWindow_ReadCustomization :: Ptr (THtmlWindow a) -> Ptr (TConfigBase b) -> Ptr (TWxString c) -> IO ()

-- | usage: (@htmlWindowSetBorders obj b@).
htmlWindowSetBorders :: HtmlWindow  a -> Int ->  IO ()
htmlWindowSetBorders _obj b 
  = withObjectRef "htmlWindowSetBorders" _obj $ \cobj__obj -> 
    wxHtmlWindow_SetBorders cobj__obj  (toCInt b)  
foreign import ccall "wxHtmlWindow_SetBorders" wxHtmlWindow_SetBorders :: Ptr (THtmlWindow a) -> CInt -> IO ()

-- | usage: (@htmlWindowSetFonts obj normalface fixedface sizes@).
htmlWindowSetFonts :: HtmlWindow  a -> String -> String -> Ptr CInt ->  IO ()
htmlWindowSetFonts _obj normalface fixedface sizes 
  = withObjectRef "htmlWindowSetFonts" _obj $ \cobj__obj -> 
    withStringPtr normalface $ \cobj_normalface -> 
    withStringPtr fixedface $ \cobj_fixedface -> 
    wxHtmlWindow_SetFonts cobj__obj  cobj_normalface  cobj_fixedface  sizes  
foreign import ccall "wxHtmlWindow_SetFonts" wxHtmlWindow_SetFonts :: Ptr (THtmlWindow a) -> Ptr (TWxString b) -> Ptr (TWxString c) -> Ptr CInt -> IO ()

-- | usage: (@htmlWindowSetPage obj source@).
htmlWindowSetPage :: HtmlWindow  a -> String ->  IO ()
htmlWindowSetPage _obj source 
  = withObjectRef "htmlWindowSetPage" _obj $ \cobj__obj -> 
    withStringPtr source $ \cobj_source -> 
    wxHtmlWindow_SetPage cobj__obj  cobj_source  
foreign import ccall "wxHtmlWindow_SetPage" wxHtmlWindow_SetPage :: Ptr (THtmlWindow a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@htmlWindowSetRelatedFrame obj frame format@).
htmlWindowSetRelatedFrame :: HtmlWindow  a -> Frame  b -> String ->  IO ()
htmlWindowSetRelatedFrame _obj frame format 
  = withObjectRef "htmlWindowSetRelatedFrame" _obj $ \cobj__obj -> 
    withObjectPtr frame $ \cobj_frame -> 
    withStringPtr format $ \cobj_format -> 
    wxHtmlWindow_SetRelatedFrame cobj__obj  cobj_frame  cobj_format  
foreign import ccall "wxHtmlWindow_SetRelatedFrame" wxHtmlWindow_SetRelatedFrame :: Ptr (THtmlWindow a) -> Ptr (TFrame b) -> Ptr (TWxString c) -> IO ()

-- | usage: (@htmlWindowSetRelatedStatusBar obj bar@).
htmlWindowSetRelatedStatusBar :: HtmlWindow  a -> Int ->  IO ()
htmlWindowSetRelatedStatusBar _obj bar 
  = withObjectRef "htmlWindowSetRelatedStatusBar" _obj $ \cobj__obj -> 
    wxHtmlWindow_SetRelatedStatusBar cobj__obj  (toCInt bar)  
foreign import ccall "wxHtmlWindow_SetRelatedStatusBar" wxHtmlWindow_SetRelatedStatusBar :: Ptr (THtmlWindow a) -> CInt -> IO ()

-- | usage: (@htmlWindowWriteCustomization obj cfg path@).
htmlWindowWriteCustomization :: HtmlWindow  a -> ConfigBase  b -> String ->  IO ()
htmlWindowWriteCustomization _obj cfg path 
  = withObjectRef "htmlWindowWriteCustomization" _obj $ \cobj__obj -> 
    withObjectPtr cfg $ \cobj_cfg -> 
    withStringPtr path $ \cobj_path -> 
    wxHtmlWindow_WriteCustomization cobj__obj  cobj_cfg  cobj_path  
foreign import ccall "wxHtmlWindow_WriteCustomization" wxHtmlWindow_WriteCustomization :: Ptr (THtmlWindow a) -> Ptr (TConfigBase b) -> Ptr (TWxString c) -> IO ()

-- | usage: (@iconAssign obj other@).
iconAssign :: Icon  a -> Ptr  b ->  IO ()
iconAssign _obj other 
  = withObjectRef "iconAssign" _obj $ \cobj__obj -> 
    wxIcon_Assign cobj__obj  other  
foreign import ccall "wxIcon_Assign" wxIcon_Assign :: Ptr (TIcon a) -> Ptr  b -> IO ()

-- | usage: (@iconBundleAddIcon obj icon@).
iconBundleAddIcon :: IconBundle  a -> Icon  b ->  IO ()
iconBundleAddIcon _obj icon 
  = withObjectRef "iconBundleAddIcon" _obj $ \cobj__obj -> 
    withObjectPtr icon $ \cobj_icon -> 
    wxIconBundle_AddIcon cobj__obj  cobj_icon  
foreign import ccall "wxIconBundle_AddIcon" wxIconBundle_AddIcon :: Ptr (TIconBundle a) -> Ptr (TIcon b) -> IO ()

-- | usage: (@iconBundleAddIconFromFile obj file wxtype@).
iconBundleAddIconFromFile :: IconBundle  a -> String -> Int ->  IO ()
iconBundleAddIconFromFile _obj file wxtype 
  = withObjectRef "iconBundleAddIconFromFile" _obj $ \cobj__obj -> 
    withStringPtr file $ \cobj_file -> 
    wxIconBundle_AddIconFromFile cobj__obj  cobj_file  (toCInt wxtype)  
foreign import ccall "wxIconBundle_AddIconFromFile" wxIconBundle_AddIconFromFile :: Ptr (TIconBundle a) -> Ptr (TWxString b) -> CInt -> IO ()

-- | usage: (@iconBundleCreateDefault@).
iconBundleCreateDefault ::  IO (IconBundle  ())
iconBundleCreateDefault 
  = withObjectResult $
    wxIconBundle_CreateDefault 
foreign import ccall "wxIconBundle_CreateDefault" wxIconBundle_CreateDefault :: IO (Ptr (TIconBundle ()))

-- | usage: (@iconBundleCreateFromFile file wxtype@).
iconBundleCreateFromFile :: String -> Int ->  IO (IconBundle  ())
iconBundleCreateFromFile file wxtype 
  = withObjectResult $
    withStringPtr file $ \cobj_file -> 
    wxIconBundle_CreateFromFile cobj_file  (toCInt wxtype)  
foreign import ccall "wxIconBundle_CreateFromFile" wxIconBundle_CreateFromFile :: Ptr (TWxString a) -> CInt -> IO (Ptr (TIconBundle ()))

-- | usage: (@iconBundleCreateFromIcon icon@).
iconBundleCreateFromIcon :: Icon  a ->  IO (IconBundle  ())
iconBundleCreateFromIcon icon 
  = withObjectResult $
    withObjectPtr icon $ \cobj_icon -> 
    wxIconBundle_CreateFromIcon cobj_icon  
foreign import ccall "wxIconBundle_CreateFromIcon" wxIconBundle_CreateFromIcon :: Ptr (TIcon a) -> IO (Ptr (TIconBundle ()))

-- | usage: (@iconBundleDelete obj@).
iconBundleDelete :: IconBundle  a ->  IO ()
iconBundleDelete _obj 
  = withObjectRef "iconBundleDelete" _obj $ \cobj__obj -> 
    wxIconBundle_Delete cobj__obj  
foreign import ccall "wxIconBundle_Delete" wxIconBundle_Delete :: Ptr (TIconBundle a) -> IO ()

-- | usage: (@iconBundleGetIcon obj wh@).
iconBundleGetIcon :: IconBundle  a -> Size ->  IO (Icon  ())
iconBundleGetIcon _obj wh 
  = withRefIcon $ \pref -> 
    withObjectRef "iconBundleGetIcon" _obj $ \cobj__obj -> 
    wxIconBundle_GetIcon cobj__obj  (toCIntSizeW wh) (toCIntSizeH wh)   pref
foreign import ccall "wxIconBundle_GetIcon" wxIconBundle_GetIcon :: Ptr (TIconBundle a) -> CInt -> CInt -> Ptr (TIcon ()) -> IO ()

-- | usage: (@iconCopyFromBitmap obj bmp@).
iconCopyFromBitmap :: Icon  a -> Bitmap  b ->  IO ()
iconCopyFromBitmap _obj bmp 
  = withObjectRef "iconCopyFromBitmap" _obj $ \cobj__obj -> 
    withObjectPtr bmp $ \cobj_bmp -> 
    wxIcon_CopyFromBitmap cobj__obj  cobj_bmp  
foreign import ccall "wxIcon_CopyFromBitmap" wxIcon_CopyFromBitmap :: Ptr (TIcon a) -> Ptr (TBitmap b) -> IO ()

-- | usage: (@iconCreateDefault@).
iconCreateDefault ::  IO (Icon  ())
iconCreateDefault 
  = withManagedIconResult $
    wxIcon_CreateDefault 
foreign import ccall "wxIcon_CreateDefault" wxIcon_CreateDefault :: IO (Ptr (TIcon ()))

-- | usage: (@iconCreateLoad name wxtype widthheight@).
iconCreateLoad :: String -> Int -> Size ->  IO (Icon  ())
iconCreateLoad name wxtype widthheight 
  = withManagedIconResult $
    withStringPtr name $ \cobj_name -> 
    wxIcon_CreateLoad cobj_name  (toCInt wxtype)  (toCIntSizeW widthheight) (toCIntSizeH widthheight)  
foreign import ccall "wxIcon_CreateLoad" wxIcon_CreateLoad :: Ptr (TWxString a) -> CInt -> CInt -> CInt -> IO (Ptr (TIcon ()))

-- | usage: (@iconDelete obj@).
iconDelete :: Icon  a ->  IO ()
iconDelete
  = objectDelete


-- | usage: (@iconFromRaw wxdata widthheight@).
iconFromRaw :: Icon  a -> Size ->  IO (Icon  ())
iconFromRaw wxdata widthheight 
  = withManagedIconResult $
    withObjectRef "iconFromRaw" wxdata $ \cobj_wxdata -> 
    wxIcon_FromRaw cobj_wxdata  (toCIntSizeW widthheight) (toCIntSizeH widthheight)  
foreign import ccall "wxIcon_FromRaw" wxIcon_FromRaw :: Ptr (TIcon a) -> CInt -> CInt -> IO (Ptr (TIcon ()))

-- | usage: (@iconFromXPM wxdata@).
iconFromXPM :: Icon  a ->  IO (Icon  ())
iconFromXPM wxdata 
  = withManagedIconResult $
    withObjectRef "iconFromXPM" wxdata $ \cobj_wxdata -> 
    wxIcon_FromXPM cobj_wxdata  
foreign import ccall "wxIcon_FromXPM" wxIcon_FromXPM :: Ptr (TIcon a) -> IO (Ptr (TIcon ()))

-- | usage: (@iconGetDepth obj@).
iconGetDepth :: Icon  a ->  IO Int
iconGetDepth _obj 
  = withIntResult $
    withObjectRef "iconGetDepth" _obj $ \cobj__obj -> 
    wxIcon_GetDepth cobj__obj  
foreign import ccall "wxIcon_GetDepth" wxIcon_GetDepth :: Ptr (TIcon a) -> IO CInt

-- | usage: (@iconGetHeight obj@).
iconGetHeight :: Icon  a ->  IO Int
iconGetHeight _obj 
  = withIntResult $
    withObjectRef "iconGetHeight" _obj $ \cobj__obj -> 
    wxIcon_GetHeight cobj__obj  
foreign import ccall "wxIcon_GetHeight" wxIcon_GetHeight :: Ptr (TIcon a) -> IO CInt

-- | usage: (@iconGetWidth obj@).
iconGetWidth :: Icon  a ->  IO Int
iconGetWidth _obj 
  = withIntResult $
    withObjectRef "iconGetWidth" _obj $ \cobj__obj -> 
    wxIcon_GetWidth cobj__obj  
foreign import ccall "wxIcon_GetWidth" wxIcon_GetWidth :: Ptr (TIcon a) -> IO CInt

-- | usage: (@iconIsEqual obj other@).
iconIsEqual :: Icon  a -> Icon  b ->  IO Bool
iconIsEqual _obj other 
  = withBoolResult $
    withObjectRef "iconIsEqual" _obj $ \cobj__obj -> 
    withObjectPtr other $ \cobj_other -> 
    wxIcon_IsEqual cobj__obj  cobj_other  
foreign import ccall "wxIcon_IsEqual" wxIcon_IsEqual :: Ptr (TIcon a) -> Ptr (TIcon b) -> IO CBool

-- | usage: (@iconIsOk obj@).
iconIsOk :: Icon  a ->  IO Bool
iconIsOk _obj 
  = withBoolResult $
    withObjectRef "iconIsOk" _obj $ \cobj__obj -> 
    wxIcon_IsOk cobj__obj  
foreign import ccall "wxIcon_IsOk" wxIcon_IsOk :: Ptr (TIcon a) -> IO CBool

-- | usage: (@iconIsStatic self@).
iconIsStatic :: Icon  a ->  IO Bool
iconIsStatic self 
  = withBoolResult $
    withObjectPtr self $ \cobj_self -> 
    wxIcon_IsStatic cobj_self  
foreign import ccall "wxIcon_IsStatic" wxIcon_IsStatic :: Ptr (TIcon a) -> IO CBool

-- | usage: (@iconLoad obj name wxtype widthheight@).
iconLoad :: Icon  a -> String -> Int -> Size ->  IO Int
iconLoad _obj name wxtype widthheight 
  = withIntResult $
    withObjectRef "iconLoad" _obj $ \cobj__obj -> 
    withStringPtr name $ \cobj_name -> 
    wxIcon_Load cobj__obj  cobj_name  (toCInt wxtype)  (toCIntSizeW widthheight) (toCIntSizeH widthheight)  
foreign import ccall "wxIcon_Load" wxIcon_Load :: Ptr (TIcon a) -> Ptr (TWxString b) -> CInt -> CInt -> CInt -> IO CInt

-- | usage: (@iconSafeDelete self@).
iconSafeDelete :: Icon  a ->  IO ()
iconSafeDelete self 
  = withObjectPtr self $ \cobj_self -> 
    wxIcon_SafeDelete cobj_self  
foreign import ccall "wxIcon_SafeDelete" wxIcon_SafeDelete :: Ptr (TIcon a) -> IO ()

-- | usage: (@iconSetDepth obj depth@).
iconSetDepth :: Icon  a -> Int ->  IO ()
iconSetDepth _obj depth 
  = withObjectRef "iconSetDepth" _obj $ \cobj__obj -> 
    wxIcon_SetDepth cobj__obj  (toCInt depth)  
foreign import ccall "wxIcon_SetDepth" wxIcon_SetDepth :: Ptr (TIcon a) -> CInt -> IO ()

-- | usage: (@iconSetHeight obj height@).
iconSetHeight :: Icon  a -> Int ->  IO ()
iconSetHeight _obj height 
  = withObjectRef "iconSetHeight" _obj $ \cobj__obj -> 
    wxIcon_SetHeight cobj__obj  (toCInt height)  
foreign import ccall "wxIcon_SetHeight" wxIcon_SetHeight :: Ptr (TIcon a) -> CInt -> IO ()

-- | usage: (@iconSetWidth obj width@).
iconSetWidth :: Icon  a -> Int ->  IO ()
iconSetWidth _obj width 
  = withObjectRef "iconSetWidth" _obj $ \cobj__obj -> 
    wxIcon_SetWidth cobj__obj  (toCInt width)  
foreign import ccall "wxIcon_SetWidth" wxIcon_SetWidth :: Ptr (TIcon a) -> CInt -> IO ()

-- | usage: (@idleEventCopyObject obj objectdest@).
idleEventCopyObject :: IdleEvent  a -> WxObject  b ->  IO ()
idleEventCopyObject _obj objectdest 
  = withObjectRef "idleEventCopyObject" _obj $ \cobj__obj -> 
    withObjectPtr objectdest $ \cobj_objectdest -> 
    wxIdleEvent_CopyObject cobj__obj  cobj_objectdest  
foreign import ccall "wxIdleEvent_CopyObject" wxIdleEvent_CopyObject :: Ptr (TIdleEvent a) -> Ptr (TWxObject b) -> IO ()

-- | usage: (@idleEventMoreRequested obj@).
idleEventMoreRequested :: IdleEvent  a ->  IO Bool
idleEventMoreRequested _obj 
  = withBoolResult $
    withObjectRef "idleEventMoreRequested" _obj $ \cobj__obj -> 
    wxIdleEvent_MoreRequested cobj__obj  
foreign import ccall "wxIdleEvent_MoreRequested" wxIdleEvent_MoreRequested :: Ptr (TIdleEvent a) -> IO CBool

-- | usage: (@idleEventRequestMore obj needMore@).
idleEventRequestMore :: IdleEvent  a -> Bool ->  IO ()
idleEventRequestMore _obj needMore 
  = withObjectRef "idleEventRequestMore" _obj $ \cobj__obj -> 
    wxIdleEvent_RequestMore cobj__obj  (toCBool needMore)  
foreign import ccall "wxIdleEvent_RequestMore" wxIdleEvent_RequestMore :: Ptr (TIdleEvent a) -> CBool -> IO ()

-- | usage: (@imageCanRead name@).
imageCanRead :: String ->  IO Bool
imageCanRead name 
  = withBoolResult $
    withStringPtr name $ \cobj_name -> 
    wxImage_CanRead cobj_name  
foreign import ccall "wxImage_CanRead" wxImage_CanRead :: Ptr (TWxString a) -> IO CBool

-- | usage: (@imageConvertToBitmap obj@).
imageConvertToBitmap :: Image  a ->  IO (Bitmap  ())
imageConvertToBitmap _obj 
  = withRefBitmap $ \pref -> 
    withObjectRef "imageConvertToBitmap" _obj $ \cobj__obj -> 
    wxImage_ConvertToBitmap cobj__obj   pref
foreign import ccall "wxImage_ConvertToBitmap" wxImage_ConvertToBitmap :: Ptr (TImage a) -> Ptr (TBitmap ()) -> IO ()

-- | usage: (@imageConvertToByteString obj wxtype@).
imageConvertToByteString :: Image  a -> Int ->  IO B.ByteString
imageConvertToByteString _obj wxtype 
  = withByteStringResult $ \buffer -> 
    withObjectRef "imageConvertToByteString" _obj $ \cobj__obj -> 
    wxImage_ConvertToByteString cobj__obj  (toCInt wxtype)   buffer
foreign import ccall "wxImage_ConvertToByteString" wxImage_ConvertToByteString :: Ptr (TImage a) -> CInt -> Ptr CChar -> IO CInt

-- | usage: (@imageConvertToLazyByteString obj wxtype@).
imageConvertToLazyByteString :: Image  a -> Int ->  IO LB.ByteString
imageConvertToLazyByteString _obj wxtype 
  = withLazyByteStringResult $ \buffer -> 
    withObjectRef "imageConvertToLazyByteString" _obj $ \cobj__obj -> 
    wxImage_ConvertToLazyByteString cobj__obj  (toCInt wxtype)   buffer
foreign import ccall "wxImage_ConvertToLazyByteString" wxImage_ConvertToLazyByteString :: Ptr (TImage a) -> CInt -> Ptr CChar -> IO CInt

-- | usage: (@imageCountColours obj stopafter@).
imageCountColours :: Image  a -> Int ->  IO Int
imageCountColours _obj stopafter 
  = withIntResult $
    withObjectRef "imageCountColours" _obj $ \cobj__obj -> 
    wxImage_CountColours cobj__obj  (toCInt stopafter)  
foreign import ccall "wxImage_CountColours" wxImage_CountColours :: Ptr (TImage a) -> CInt -> IO CInt

-- | usage: (@imageCreateDefault@).
imageCreateDefault ::  IO (Image  ())
imageCreateDefault 
  = withManagedObjectResult $
    wxImage_CreateDefault 
foreign import ccall "wxImage_CreateDefault" wxImage_CreateDefault :: IO (Ptr (TImage ()))

-- | usage: (@imageCreateFromBitmap bitmap@).
imageCreateFromBitmap :: Bitmap  a ->  IO (Image  ())
imageCreateFromBitmap bitmap 
  = withManagedObjectResult $
    withObjectPtr bitmap $ \cobj_bitmap -> 
    wxImage_CreateFromBitmap cobj_bitmap  
foreign import ccall "wxImage_CreateFromBitmap" wxImage_CreateFromBitmap :: Ptr (TBitmap a) -> IO (Ptr (TImage ()))

-- | usage: (@imageCreateFromByteString datalength wxtype@).
imageCreateFromByteString :: B.ByteString -> Int ->  IO (Image  ())
imageCreateFromByteString datalength wxtype 
  = withManagedObjectResult $
    B.useAsCStringLen datalength $ \(bs_datalength, bslen_datalength)  -> 
    wxImage_CreateFromByteString bs_datalength bslen_datalength  (toCInt wxtype)  
foreign import ccall "wxImage_CreateFromByteString" wxImage_CreateFromByteString :: Ptr CChar -> Int -> CInt -> IO (Ptr (TImage ()))

-- | usage: (@imageCreateFromData widthheight wxdata@).
imageCreateFromData :: Size -> Ptr  b ->  IO (Image  ())
imageCreateFromData widthheight wxdata 
  = withManagedObjectResult $
    wxImage_CreateFromData (toCIntSizeW widthheight) (toCIntSizeH widthheight)  wxdata  
foreign import ccall "wxImage_CreateFromData" wxImage_CreateFromData :: CInt -> CInt -> Ptr  b -> IO (Ptr (TImage ()))

-- | usage: (@imageCreateFromDataEx widthheight wxdata isStaticData@).
imageCreateFromDataEx :: Size -> Ptr  b -> Bool ->  IO (Image  ())
imageCreateFromDataEx widthheight wxdata isStaticData 
  = withManagedObjectResult $
    wxImage_CreateFromDataEx (toCIntSizeW widthheight) (toCIntSizeH widthheight)  wxdata  (toCBool isStaticData)  
foreign import ccall "wxImage_CreateFromDataEx" wxImage_CreateFromDataEx :: CInt -> CInt -> Ptr  b -> CBool -> IO (Ptr (TImage ()))

-- | usage: (@imageCreateFromFile name@).
imageCreateFromFile :: String ->  IO (Image  ())
imageCreateFromFile name 
  = withManagedObjectResult $
    withStringPtr name $ \cobj_name -> 
    wxImage_CreateFromFile cobj_name  
foreign import ccall "wxImage_CreateFromFile" wxImage_CreateFromFile :: Ptr (TWxString a) -> IO (Ptr (TImage ()))

-- | usage: (@imageCreateFromLazyByteString datalength wxtype@).
imageCreateFromLazyByteString :: LB.ByteString -> Int ->  IO (Image  ())
imageCreateFromLazyByteString datalength wxtype 
  = withManagedObjectResult $
    withArray (LB.unpack datalength) $ \bs_datalength -> 
    wxImage_CreateFromLazyByteString bs_datalength (fromIntegral $ LB.length datalength)  (toCInt wxtype)  
foreign import ccall "wxImage_CreateFromLazyByteString" wxImage_CreateFromLazyByteString :: Ptr Word8 -> Int -> CInt -> IO (Ptr (TImage ()))

-- | usage: (@imageCreateSized widthheight@).
imageCreateSized :: Size ->  IO (Image  ())
imageCreateSized widthheight 
  = withManagedObjectResult $
    wxImage_CreateSized (toCIntSizeW widthheight) (toCIntSizeH widthheight)  
foreign import ccall "wxImage_CreateSized" wxImage_CreateSized :: CInt -> CInt -> IO (Ptr (TImage ()))

-- | usage: (@imageDelete image@).
imageDelete :: Image  a ->  IO ()
imageDelete
  = objectDelete


-- | usage: (@imageDestroy obj@).
imageDestroy :: Image  a ->  IO ()
imageDestroy _obj 
  = withObjectRef "imageDestroy" _obj $ \cobj__obj -> 
    wxImage_Destroy cobj__obj  
foreign import ccall "wxImage_Destroy" wxImage_Destroy :: Ptr (TImage a) -> IO ()

-- | usage: (@imageGetBlue obj xy@).
imageGetBlue :: Image  a -> Point ->  IO Char
imageGetBlue _obj xy 
  = withCharResult $
    withObjectRef "imageGetBlue" _obj $ \cobj__obj -> 
    wxImage_GetBlue cobj__obj  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxImage_GetBlue" wxImage_GetBlue :: Ptr (TImage a) -> CInt -> CInt -> IO CWchar

-- | usage: (@imageGetData obj@).
imageGetData :: Image  a ->  IO (Ptr  ())
imageGetData _obj 
  = withObjectRef "imageGetData" _obj $ \cobj__obj -> 
    wxImage_GetData cobj__obj  
foreign import ccall "wxImage_GetData" wxImage_GetData :: Ptr (TImage a) -> IO (Ptr  ())

-- | usage: (@imageGetGreen obj xy@).
imageGetGreen :: Image  a -> Point ->  IO Char
imageGetGreen _obj xy 
  = withCharResult $
    withObjectRef "imageGetGreen" _obj $ \cobj__obj -> 
    wxImage_GetGreen cobj__obj  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxImage_GetGreen" wxImage_GetGreen :: Ptr (TImage a) -> CInt -> CInt -> IO CWchar

-- | usage: (@imageGetHeight obj@).
imageGetHeight :: Image  a ->  IO Int
imageGetHeight _obj 
  = withIntResult $
    withObjectRef "imageGetHeight" _obj $ \cobj__obj -> 
    wxImage_GetHeight cobj__obj  
foreign import ccall "wxImage_GetHeight" wxImage_GetHeight :: Ptr (TImage a) -> IO CInt

-- | usage: (@imageGetMaskBlue obj@).
imageGetMaskBlue :: Image  a ->  IO Char
imageGetMaskBlue _obj 
  = withCharResult $
    withObjectRef "imageGetMaskBlue" _obj $ \cobj__obj -> 
    wxImage_GetMaskBlue cobj__obj  
foreign import ccall "wxImage_GetMaskBlue" wxImage_GetMaskBlue :: Ptr (TImage a) -> IO CWchar

-- | usage: (@imageGetMaskGreen obj@).
imageGetMaskGreen :: Image  a ->  IO Char
imageGetMaskGreen _obj 
  = withCharResult $
    withObjectRef "imageGetMaskGreen" _obj $ \cobj__obj -> 
    wxImage_GetMaskGreen cobj__obj  
foreign import ccall "wxImage_GetMaskGreen" wxImage_GetMaskGreen :: Ptr (TImage a) -> IO CWchar

-- | usage: (@imageGetMaskRed obj@).
imageGetMaskRed :: Image  a ->  IO Char
imageGetMaskRed _obj 
  = withCharResult $
    withObjectRef "imageGetMaskRed" _obj $ \cobj__obj -> 
    wxImage_GetMaskRed cobj__obj  
foreign import ccall "wxImage_GetMaskRed" wxImage_GetMaskRed :: Ptr (TImage a) -> IO CWchar

-- | usage: (@imageGetOption obj name@).
imageGetOption :: Image  a -> String ->  IO (String)
imageGetOption _obj name 
  = withManagedStringResult $
    withObjectRef "imageGetOption" _obj $ \cobj__obj -> 
    withStringPtr name $ \cobj_name -> 
    wxImage_GetOption cobj__obj  cobj_name  
foreign import ccall "wxImage_GetOption" wxImage_GetOption :: Ptr (TImage a) -> Ptr (TWxString b) -> IO (Ptr (TWxString ()))

-- | usage: (@imageGetOptionInt obj name@).
imageGetOptionInt :: Image  a -> String ->  IO Bool
imageGetOptionInt _obj name 
  = withBoolResult $
    withObjectRef "imageGetOptionInt" _obj $ \cobj__obj -> 
    withStringPtr name $ \cobj_name -> 
    wxImage_GetOptionInt cobj__obj  cobj_name  
foreign import ccall "wxImage_GetOptionInt" wxImage_GetOptionInt :: Ptr (TImage a) -> Ptr (TWxString b) -> IO CBool

-- | usage: (@imageGetRed obj xy@).
imageGetRed :: Image  a -> Point ->  IO Char
imageGetRed _obj xy 
  = withCharResult $
    withObjectRef "imageGetRed" _obj $ \cobj__obj -> 
    wxImage_GetRed cobj__obj  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxImage_GetRed" wxImage_GetRed :: Ptr (TImage a) -> CInt -> CInt -> IO CWchar

-- | usage: (@imageGetSubImage obj xywh@).
imageGetSubImage :: Image  a -> Rect ->  IO (Image  ())
imageGetSubImage _obj xywh 
  = withRefImage $ \pref -> 
    withObjectRef "imageGetSubImage" _obj $ \cobj__obj -> 
    wxImage_GetSubImage cobj__obj  (toCIntRectX xywh) (toCIntRectY xywh)(toCIntRectW xywh) (toCIntRectH xywh)   pref
foreign import ccall "wxImage_GetSubImage" wxImage_GetSubImage :: Ptr (TImage a) -> CInt -> CInt -> CInt -> CInt -> Ptr (TImage ()) -> IO ()

-- | usage: (@imageGetWidth obj@).
imageGetWidth :: Image  a ->  IO Int
imageGetWidth _obj 
  = withIntResult $
    withObjectRef "imageGetWidth" _obj $ \cobj__obj -> 
    wxImage_GetWidth cobj__obj  
foreign import ccall "wxImage_GetWidth" wxImage_GetWidth :: Ptr (TImage a) -> IO CInt

-- | usage: (@imageHasMask obj@).
imageHasMask :: Image  a ->  IO Bool
imageHasMask _obj 
  = withBoolResult $
    withObjectRef "imageHasMask" _obj $ \cobj__obj -> 
    wxImage_HasMask cobj__obj  
foreign import ccall "wxImage_HasMask" wxImage_HasMask :: Ptr (TImage a) -> IO CBool

-- | usage: (@imageHasOption obj name@).
imageHasOption :: Image  a -> String ->  IO Bool
imageHasOption _obj name 
  = withBoolResult $
    withObjectRef "imageHasOption" _obj $ \cobj__obj -> 
    withStringPtr name $ \cobj_name -> 
    wxImage_HasOption cobj__obj  cobj_name  
foreign import ccall "wxImage_HasOption" wxImage_HasOption :: Ptr (TImage a) -> Ptr (TWxString b) -> IO CBool

-- | usage: (@imageInitialize obj widthheight@).
imageInitialize :: Image  a -> Size ->  IO ()
imageInitialize _obj widthheight 
  = withObjectRef "imageInitialize" _obj $ \cobj__obj -> 
    wxImage_Initialize cobj__obj  (toCIntSizeW widthheight) (toCIntSizeH widthheight)  
foreign import ccall "wxImage_Initialize" wxImage_Initialize :: Ptr (TImage a) -> CInt -> CInt -> IO ()

-- | usage: (@imageInitializeFromData obj widthheight wxdata@).
imageInitializeFromData :: Image  a -> Size -> Ptr  c ->  IO ()
imageInitializeFromData _obj widthheight wxdata 
  = withObjectRef "imageInitializeFromData" _obj $ \cobj__obj -> 
    wxImage_InitializeFromData cobj__obj  (toCIntSizeW widthheight) (toCIntSizeH widthheight)  wxdata  
foreign import ccall "wxImage_InitializeFromData" wxImage_InitializeFromData :: Ptr (TImage a) -> CInt -> CInt -> Ptr  c -> IO ()

-- | usage: (@imageIsOk obj@).
imageIsOk :: Image  a ->  IO Bool
imageIsOk _obj 
  = withBoolResult $
    withObjectRef "imageIsOk" _obj $ \cobj__obj -> 
    wxImage_IsOk cobj__obj  
foreign import ccall "wxImage_IsOk" wxImage_IsOk :: Ptr (TImage a) -> IO CBool

-- | usage: (@imageListAddBitmap obj bitmap mask@).
imageListAddBitmap :: ImageList  a -> Bitmap  b -> Bitmap  c ->  IO Int
imageListAddBitmap _obj bitmap mask 
  = withIntResult $
    withObjectRef "imageListAddBitmap" _obj $ \cobj__obj -> 
    withObjectPtr bitmap $ \cobj_bitmap -> 
    withObjectPtr mask $ \cobj_mask -> 
    wxImageList_AddBitmap cobj__obj  cobj_bitmap  cobj_mask  
foreign import ccall "wxImageList_AddBitmap" wxImageList_AddBitmap :: Ptr (TImageList a) -> Ptr (TBitmap b) -> Ptr (TBitmap c) -> IO CInt

-- | usage: (@imageListAddIcon obj icon@).
imageListAddIcon :: ImageList  a -> Icon  b ->  IO Int
imageListAddIcon _obj icon 
  = withIntResult $
    withObjectRef "imageListAddIcon" _obj $ \cobj__obj -> 
    withObjectPtr icon $ \cobj_icon -> 
    wxImageList_AddIcon cobj__obj  cobj_icon  
foreign import ccall "wxImageList_AddIcon" wxImageList_AddIcon :: Ptr (TImageList a) -> Ptr (TIcon b) -> IO CInt

-- | usage: (@imageListAddMasked obj bitmap maskColour@).
imageListAddMasked :: ImageList  a -> Bitmap  b -> Color ->  IO Int
imageListAddMasked _obj bitmap maskColour 
  = withIntResult $
    withObjectRef "imageListAddMasked" _obj $ \cobj__obj -> 
    withObjectPtr bitmap $ \cobj_bitmap -> 
    withColourPtr maskColour $ \cobj_maskColour -> 
    wxImageList_AddMasked cobj__obj  cobj_bitmap  cobj_maskColour  
foreign import ccall "wxImageList_AddMasked" wxImageList_AddMasked :: Ptr (TImageList a) -> Ptr (TBitmap b) -> Ptr (TColour c) -> IO CInt

-- | usage: (@imageListCreate widthheight mask initialCount@).
imageListCreate :: Size -> Bool -> Int ->  IO (ImageList  ())
imageListCreate widthheight mask initialCount 
  = withObjectResult $
    wxImageList_Create (toCIntSizeW widthheight) (toCIntSizeH widthheight)  (toCBool mask)  (toCInt initialCount)  
foreign import ccall "wxImageList_Create" wxImageList_Create :: CInt -> CInt -> CBool -> CInt -> IO (Ptr (TImageList ()))

-- | usage: (@imageListDelete obj@).
imageListDelete :: ImageList  a ->  IO ()
imageListDelete
  = objectDelete


-- | usage: (@imageListDraw obj index dc xy flags solidBackground@).
imageListDraw :: ImageList  a -> Int -> DC  c -> Point -> Int -> Bool ->  IO Bool
imageListDraw _obj index dc xy flags solidBackground 
  = withBoolResult $
    withObjectRef "imageListDraw" _obj $ \cobj__obj -> 
    withObjectPtr dc $ \cobj_dc -> 
    wxImageList_Draw cobj__obj  (toCInt index)  cobj_dc  (toCIntPointX xy) (toCIntPointY xy)  (toCInt flags)  (toCBool solidBackground)  
foreign import ccall "wxImageList_Draw" wxImageList_Draw :: Ptr (TImageList a) -> CInt -> Ptr (TDC c) -> CInt -> CInt -> CInt -> CBool -> IO CBool

-- | usage: (@imageListGetImageCount obj@).
imageListGetImageCount :: ImageList  a ->  IO Int
imageListGetImageCount _obj 
  = withIntResult $
    withObjectRef "imageListGetImageCount" _obj $ \cobj__obj -> 
    wxImageList_GetImageCount cobj__obj  
foreign import ccall "wxImageList_GetImageCount" wxImageList_GetImageCount :: Ptr (TImageList a) -> IO CInt

-- | usage: (@imageListGetSize obj index@).
imageListGetSize :: ImageList  a -> Int ->  IO Size
imageListGetSize _obj index 
  = withSizeResult $ \pw ph -> 
    withObjectRef "imageListGetSize" _obj $ \cobj__obj -> 
    wxImageList_GetSize cobj__obj  (toCInt index)   pw ph
foreign import ccall "wxImageList_GetSize" wxImageList_GetSize :: Ptr (TImageList a) -> CInt -> Ptr CInt -> Ptr CInt -> IO ()

-- | usage: (@imageListRemove obj index@).
imageListRemove :: ImageList  a -> Int ->  IO Bool
imageListRemove _obj index 
  = withBoolResult $
    withObjectRef "imageListRemove" _obj $ \cobj__obj -> 
    wxImageList_Remove cobj__obj  (toCInt index)  
foreign import ccall "wxImageList_Remove" wxImageList_Remove :: Ptr (TImageList a) -> CInt -> IO CBool

-- | usage: (@imageListRemoveAll obj@).
imageListRemoveAll :: ImageList  a ->  IO Bool
imageListRemoveAll _obj 
  = withBoolResult $
    withObjectRef "imageListRemoveAll" _obj $ \cobj__obj -> 
    wxImageList_RemoveAll cobj__obj  
foreign import ccall "wxImageList_RemoveAll" wxImageList_RemoveAll :: Ptr (TImageList a) -> IO CBool

-- | usage: (@imageListReplace obj index bitmap mask@).
imageListReplace :: ImageList  a -> Int -> Bitmap  c -> Bitmap  d ->  IO Bool
imageListReplace _obj index bitmap mask 
  = withBoolResult $
    withObjectRef "imageListReplace" _obj $ \cobj__obj -> 
    withObjectPtr bitmap $ \cobj_bitmap -> 
    withObjectPtr mask $ \cobj_mask -> 
    wxImageList_Replace cobj__obj  (toCInt index)  cobj_bitmap  cobj_mask  
foreign import ccall "wxImageList_Replace" wxImageList_Replace :: Ptr (TImageList a) -> CInt -> Ptr (TBitmap c) -> Ptr (TBitmap d) -> IO CBool

-- | usage: (@imageListReplaceIcon obj index icon@).
imageListReplaceIcon :: ImageList  a -> Int -> Icon  c ->  IO Bool
imageListReplaceIcon _obj index icon 
  = withBoolResult $
    withObjectRef "imageListReplaceIcon" _obj $ \cobj__obj -> 
    withObjectPtr icon $ \cobj_icon -> 
    wxImageList_ReplaceIcon cobj__obj  (toCInt index)  cobj_icon  
foreign import ccall "wxImageList_ReplaceIcon" wxImageList_ReplaceIcon :: Ptr (TImageList a) -> CInt -> Ptr (TIcon c) -> IO CBool

-- | usage: (@imageLoadFile obj name wxtype@).
imageLoadFile :: Image  a -> String -> Int ->  IO Bool
imageLoadFile _obj name wxtype 
  = withBoolResult $
    withObjectRef "imageLoadFile" _obj $ \cobj__obj -> 
    withStringPtr name $ \cobj_name -> 
    wxImage_LoadFile cobj__obj  cobj_name  (toCInt wxtype)  
foreign import ccall "wxImage_LoadFile" wxImage_LoadFile :: Ptr (TImage a) -> Ptr (TWxString b) -> CInt -> IO CBool

-- | usage: (@imageMirror obj horizontally@).
imageMirror :: Image  a -> Bool ->  IO (Image  ())
imageMirror _obj horizontally 
  = withRefImage $ \pref -> 
    withObjectRef "imageMirror" _obj $ \cobj__obj -> 
    wxImage_Mirror cobj__obj  (toCBool horizontally)   pref
foreign import ccall "wxImage_Mirror" wxImage_Mirror :: Ptr (TImage a) -> CBool -> Ptr (TImage ()) -> IO ()

-- | usage: (@imagePaste obj image xy@).
imagePaste :: Image  a -> Image  b -> Point ->  IO ()
imagePaste _obj image xy 
  = withObjectRef "imagePaste" _obj $ \cobj__obj -> 
    withObjectPtr image $ \cobj_image -> 
    wxImage_Paste cobj__obj  cobj_image  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxImage_Paste" wxImage_Paste :: Ptr (TImage a) -> Ptr (TImage b) -> CInt -> CInt -> IO ()

-- | usage: (@imageReplace obj r1g1b1 r2g2b2@).
imageReplace :: Image  a -> Color -> Color ->  IO ()
imageReplace _obj r1g1b1 r2g2b2 
  = withObjectRef "imageReplace" _obj $ \cobj__obj -> 
    wxImage_Replace cobj__obj  (colorRed r1g1b1) (colorGreen r1g1b1) (colorBlue r1g1b1)  (colorRed r2g2b2) (colorGreen r2g2b2) (colorBlue r2g2b2)  
foreign import ccall "wxImage_Replace" wxImage_Replace :: Ptr (TImage a) -> Word8 -> Word8 -> Word8 -> Word8 -> Word8 -> Word8 -> IO ()

-- | usage: (@imageRescale obj widthheight@).
imageRescale :: Image  a -> Size ->  IO ()
imageRescale _obj widthheight 
  = withObjectRef "imageRescale" _obj $ \cobj__obj -> 
    wxImage_Rescale cobj__obj  (toCIntSizeW widthheight) (toCIntSizeH widthheight)  
foreign import ccall "wxImage_Rescale" wxImage_Rescale :: Ptr (TImage a) -> CInt -> CInt -> IO ()

-- | usage: (@imageRotate obj angle cxcy interpolating offsetafterrotation@).
imageRotate :: Image  a -> Double -> Point -> Bool -> Ptr  e ->  IO (Image  ())
imageRotate _obj angle cxcy interpolating offsetafterrotation 
  = withRefImage $ \pref -> 
    withObjectRef "imageRotate" _obj $ \cobj__obj -> 
    wxImage_Rotate cobj__obj  angle  (toCIntPointX cxcy) (toCIntPointY cxcy)  (toCBool interpolating)  offsetafterrotation   pref
foreign import ccall "wxImage_Rotate" wxImage_Rotate :: Ptr (TImage a) -> Double -> CInt -> CInt -> CBool -> Ptr  e -> Ptr (TImage ()) -> IO ()

-- | usage: (@imageRotate90 obj clockwise@).
imageRotate90 :: Image  a -> Bool ->  IO (Image  ())
imageRotate90 _obj clockwise 
  = withRefImage $ \pref -> 
    withObjectRef "imageRotate90" _obj $ \cobj__obj -> 
    wxImage_Rotate90 cobj__obj  (toCBool clockwise)   pref
foreign import ccall "wxImage_Rotate90" wxImage_Rotate90 :: Ptr (TImage a) -> CBool -> Ptr (TImage ()) -> IO ()

-- | usage: (@imageSaveFile obj name wxtype@).
imageSaveFile :: Image  a -> String -> Int ->  IO Bool
imageSaveFile _obj name wxtype 
  = withBoolResult $
    withObjectRef "imageSaveFile" _obj $ \cobj__obj -> 
    withStringPtr name $ \cobj_name -> 
    wxImage_SaveFile cobj__obj  cobj_name  (toCInt wxtype)  
foreign import ccall "wxImage_SaveFile" wxImage_SaveFile :: Ptr (TImage a) -> Ptr (TWxString b) -> CInt -> IO CBool

-- | usage: (@imageScale obj widthheight@).
imageScale :: Image  a -> Size ->  IO (Image  ())
imageScale _obj widthheight 
  = withRefImage $ \pref -> 
    withObjectRef "imageScale" _obj $ \cobj__obj -> 
    wxImage_Scale cobj__obj  (toCIntSizeW widthheight) (toCIntSizeH widthheight)   pref
foreign import ccall "wxImage_Scale" wxImage_Scale :: Ptr (TImage a) -> CInt -> CInt -> Ptr (TImage ()) -> IO ()

-- | usage: (@imageSetData obj wxdata@).
imageSetData :: Image  a -> Ptr  b ->  IO ()
imageSetData _obj wxdata 
  = withObjectRef "imageSetData" _obj $ \cobj__obj -> 
    wxImage_SetData cobj__obj  wxdata  
foreign import ccall "wxImage_SetData" wxImage_SetData :: Ptr (TImage a) -> Ptr  b -> IO ()

-- | usage: (@imageSetDataAndSize obj wxdata newwidthnewheight@).
imageSetDataAndSize :: Image  a -> Ptr  b -> Size ->  IO ()
imageSetDataAndSize _obj wxdata newwidthnewheight 
  = withObjectRef "imageSetDataAndSize" _obj $ \cobj__obj -> 
    wxImage_SetDataAndSize cobj__obj  wxdata  (toCIntSizeW newwidthnewheight) (toCIntSizeH newwidthnewheight)  
foreign import ccall "wxImage_SetDataAndSize" wxImage_SetDataAndSize :: Ptr (TImage a) -> Ptr  b -> CInt -> CInt -> IO ()

-- | usage: (@imageSetMask obj mask@).
imageSetMask :: Image  a -> Int ->  IO ()
imageSetMask _obj mask 
  = withObjectRef "imageSetMask" _obj $ \cobj__obj -> 
    wxImage_SetMask cobj__obj  (toCInt mask)  
foreign import ccall "wxImage_SetMask" wxImage_SetMask :: Ptr (TImage a) -> CInt -> IO ()

-- | usage: (@imageSetMaskColour obj rgb@).
imageSetMaskColour :: Image  a -> Color ->  IO ()
imageSetMaskColour _obj rgb 
  = withObjectRef "imageSetMaskColour" _obj $ \cobj__obj -> 
    wxImage_SetMaskColour cobj__obj  (colorRed rgb) (colorGreen rgb) (colorBlue rgb)  
foreign import ccall "wxImage_SetMaskColour" wxImage_SetMaskColour :: Ptr (TImage a) -> Word8 -> Word8 -> Word8 -> IO ()

-- | usage: (@imageSetOption obj name value@).
imageSetOption :: Image  a -> String -> String ->  IO ()
imageSetOption _obj name value 
  = withObjectRef "imageSetOption" _obj $ \cobj__obj -> 
    withStringPtr name $ \cobj_name -> 
    withStringPtr value $ \cobj_value -> 
    wxImage_SetOption cobj__obj  cobj_name  cobj_value  
foreign import ccall "wxImage_SetOption" wxImage_SetOption :: Ptr (TImage a) -> Ptr (TWxString b) -> Ptr (TWxString c) -> IO ()

-- | usage: (@imageSetOptionInt obj name value@).
imageSetOptionInt :: Image  a -> String -> Int ->  IO ()
imageSetOptionInt _obj name value 
  = withObjectRef "imageSetOptionInt" _obj $ \cobj__obj -> 
    withStringPtr name $ \cobj_name -> 
    wxImage_SetOptionInt cobj__obj  cobj_name  (toCInt value)  
foreign import ccall "wxImage_SetOptionInt" wxImage_SetOptionInt :: Ptr (TImage a) -> Ptr (TWxString b) -> CInt -> IO ()

-- | usage: (@imageSetRGB obj xy rgb@).
imageSetRGB :: Image  a -> Point -> Color ->  IO ()
imageSetRGB _obj xy rgb 
  = withObjectRef "imageSetRGB" _obj $ \cobj__obj -> 
    wxImage_SetRGB cobj__obj  (toCIntPointX xy) (toCIntPointY xy)  (colorRed rgb) (colorGreen rgb) (colorBlue rgb)  
foreign import ccall "wxImage_SetRGB" wxImage_SetRGB :: Ptr (TImage a) -> CInt -> CInt -> Word8 -> Word8 -> Word8 -> IO ()

-- | usage: (@individualLayoutConstraintAbove obj sibling marg@).
individualLayoutConstraintAbove :: IndividualLayoutConstraint  a -> Window  b -> Int ->  IO ()
individualLayoutConstraintAbove _obj sibling marg 
  = withObjectRef "individualLayoutConstraintAbove" _obj $ \cobj__obj -> 
    withObjectPtr sibling $ \cobj_sibling -> 
    wxIndividualLayoutConstraint_Above cobj__obj  cobj_sibling  (toCInt marg)  
foreign import ccall "wxIndividualLayoutConstraint_Above" wxIndividualLayoutConstraint_Above :: Ptr (TIndividualLayoutConstraint a) -> Ptr (TWindow b) -> CInt -> IO ()

-- | usage: (@individualLayoutConstraintAbsolute obj val@).
individualLayoutConstraintAbsolute :: IndividualLayoutConstraint  a -> Int ->  IO ()
individualLayoutConstraintAbsolute _obj val 
  = withObjectRef "individualLayoutConstraintAbsolute" _obj $ \cobj__obj -> 
    wxIndividualLayoutConstraint_Absolute cobj__obj  (toCInt val)  
foreign import ccall "wxIndividualLayoutConstraint_Absolute" wxIndividualLayoutConstraint_Absolute :: Ptr (TIndividualLayoutConstraint a) -> CInt -> IO ()

-- | usage: (@individualLayoutConstraintAsIs obj@).
individualLayoutConstraintAsIs :: IndividualLayoutConstraint  a ->  IO ()
individualLayoutConstraintAsIs _obj 
  = withObjectRef "individualLayoutConstraintAsIs" _obj $ \cobj__obj -> 
    wxIndividualLayoutConstraint_AsIs cobj__obj  
foreign import ccall "wxIndividualLayoutConstraint_AsIs" wxIndividualLayoutConstraint_AsIs :: Ptr (TIndividualLayoutConstraint a) -> IO ()

-- | usage: (@individualLayoutConstraintBelow obj sibling marg@).
individualLayoutConstraintBelow :: IndividualLayoutConstraint  a -> Window  b -> Int ->  IO ()
individualLayoutConstraintBelow _obj sibling marg 
  = withObjectRef "individualLayoutConstraintBelow" _obj $ \cobj__obj -> 
    withObjectPtr sibling $ \cobj_sibling -> 
    wxIndividualLayoutConstraint_Below cobj__obj  cobj_sibling  (toCInt marg)  
foreign import ccall "wxIndividualLayoutConstraint_Below" wxIndividualLayoutConstraint_Below :: Ptr (TIndividualLayoutConstraint a) -> Ptr (TWindow b) -> CInt -> IO ()

-- | usage: (@individualLayoutConstraintGetDone obj@).
individualLayoutConstraintGetDone :: IndividualLayoutConstraint  a ->  IO Bool
individualLayoutConstraintGetDone _obj 
  = withBoolResult $
    withObjectRef "individualLayoutConstraintGetDone" _obj $ \cobj__obj -> 
    wxIndividualLayoutConstraint_GetDone cobj__obj  
foreign import ccall "wxIndividualLayoutConstraint_GetDone" wxIndividualLayoutConstraint_GetDone :: Ptr (TIndividualLayoutConstraint a) -> IO CBool

-- | usage: (@individualLayoutConstraintGetEdge obj which thisWin other@).
individualLayoutConstraintGetEdge :: IndividualLayoutConstraint  a -> Int -> Ptr  c -> Ptr  d ->  IO Int
individualLayoutConstraintGetEdge _obj which thisWin other 
  = withIntResult $
    withObjectRef "individualLayoutConstraintGetEdge" _obj $ \cobj__obj -> 
    wxIndividualLayoutConstraint_GetEdge cobj__obj  (toCInt which)  thisWin  other  
foreign import ccall "wxIndividualLayoutConstraint_GetEdge" wxIndividualLayoutConstraint_GetEdge :: Ptr (TIndividualLayoutConstraint a) -> CInt -> Ptr  c -> Ptr  d -> IO CInt

-- | usage: (@individualLayoutConstraintGetMargin obj@).
individualLayoutConstraintGetMargin :: IndividualLayoutConstraint  a ->  IO Int
individualLayoutConstraintGetMargin _obj 
  = withIntResult $
    withObjectRef "individualLayoutConstraintGetMargin" _obj $ \cobj__obj -> 
    wxIndividualLayoutConstraint_GetMargin cobj__obj  
foreign import ccall "wxIndividualLayoutConstraint_GetMargin" wxIndividualLayoutConstraint_GetMargin :: Ptr (TIndividualLayoutConstraint a) -> IO CInt

-- | usage: (@individualLayoutConstraintGetMyEdge obj@).
individualLayoutConstraintGetMyEdge :: IndividualLayoutConstraint  a ->  IO Int
individualLayoutConstraintGetMyEdge _obj 
  = withIntResult $
    withObjectRef "individualLayoutConstraintGetMyEdge" _obj $ \cobj__obj -> 
    wxIndividualLayoutConstraint_GetMyEdge cobj__obj  
foreign import ccall "wxIndividualLayoutConstraint_GetMyEdge" wxIndividualLayoutConstraint_GetMyEdge :: Ptr (TIndividualLayoutConstraint a) -> IO CInt

-- | usage: (@individualLayoutConstraintGetOtherEdge obj@).
individualLayoutConstraintGetOtherEdge :: IndividualLayoutConstraint  a ->  IO Int
individualLayoutConstraintGetOtherEdge _obj 
  = withIntResult $
    withObjectRef "individualLayoutConstraintGetOtherEdge" _obj $ \cobj__obj -> 
    wxIndividualLayoutConstraint_GetOtherEdge cobj__obj  
foreign import ccall "wxIndividualLayoutConstraint_GetOtherEdge" wxIndividualLayoutConstraint_GetOtherEdge :: Ptr (TIndividualLayoutConstraint a) -> IO CInt

-- | usage: (@individualLayoutConstraintGetOtherWindow obj@).
individualLayoutConstraintGetOtherWindow :: IndividualLayoutConstraint  a ->  IO (Ptr  ())
individualLayoutConstraintGetOtherWindow _obj 
  = withObjectRef "individualLayoutConstraintGetOtherWindow" _obj $ \cobj__obj -> 
    wxIndividualLayoutConstraint_GetOtherWindow cobj__obj  
foreign import ccall "wxIndividualLayoutConstraint_GetOtherWindow" wxIndividualLayoutConstraint_GetOtherWindow :: Ptr (TIndividualLayoutConstraint a) -> IO (Ptr  ())

-- | usage: (@individualLayoutConstraintGetPercent obj@).
individualLayoutConstraintGetPercent :: IndividualLayoutConstraint  a ->  IO Int
individualLayoutConstraintGetPercent _obj 
  = withIntResult $
    withObjectRef "individualLayoutConstraintGetPercent" _obj $ \cobj__obj -> 
    wxIndividualLayoutConstraint_GetPercent cobj__obj  
foreign import ccall "wxIndividualLayoutConstraint_GetPercent" wxIndividualLayoutConstraint_GetPercent :: Ptr (TIndividualLayoutConstraint a) -> IO CInt

-- | usage: (@individualLayoutConstraintGetRelationship obj@).
individualLayoutConstraintGetRelationship :: IndividualLayoutConstraint  a ->  IO Int
individualLayoutConstraintGetRelationship _obj 
  = withIntResult $
    withObjectRef "individualLayoutConstraintGetRelationship" _obj $ \cobj__obj -> 
    wxIndividualLayoutConstraint_GetRelationship cobj__obj  
foreign import ccall "wxIndividualLayoutConstraint_GetRelationship" wxIndividualLayoutConstraint_GetRelationship :: Ptr (TIndividualLayoutConstraint a) -> IO CInt

-- | usage: (@individualLayoutConstraintGetValue obj@).
individualLayoutConstraintGetValue :: IndividualLayoutConstraint  a ->  IO Int
individualLayoutConstraintGetValue _obj 
  = withIntResult $
    withObjectRef "individualLayoutConstraintGetValue" _obj $ \cobj__obj -> 
    wxIndividualLayoutConstraint_GetValue cobj__obj  
foreign import ccall "wxIndividualLayoutConstraint_GetValue" wxIndividualLayoutConstraint_GetValue :: Ptr (TIndividualLayoutConstraint a) -> IO CInt

-- | usage: (@individualLayoutConstraintLeftOf obj sibling marg@).
individualLayoutConstraintLeftOf :: IndividualLayoutConstraint  a -> Window  b -> Int ->  IO ()
individualLayoutConstraintLeftOf _obj sibling marg 
  = withObjectRef "individualLayoutConstraintLeftOf" _obj $ \cobj__obj -> 
    withObjectPtr sibling $ \cobj_sibling -> 
    wxIndividualLayoutConstraint_LeftOf cobj__obj  cobj_sibling  (toCInt marg)  
foreign import ccall "wxIndividualLayoutConstraint_LeftOf" wxIndividualLayoutConstraint_LeftOf :: Ptr (TIndividualLayoutConstraint a) -> Ptr (TWindow b) -> CInt -> IO ()

-- | usage: (@individualLayoutConstraintPercentOf obj otherW wh per@).
individualLayoutConstraintPercentOf :: IndividualLayoutConstraint  a -> Window  b -> Int -> Int ->  IO ()
individualLayoutConstraintPercentOf _obj otherW wh per 
  = withObjectRef "individualLayoutConstraintPercentOf" _obj $ \cobj__obj -> 
    withObjectPtr otherW $ \cobj_otherW -> 
    wxIndividualLayoutConstraint_PercentOf cobj__obj  cobj_otherW  (toCInt wh)  (toCInt per)  
foreign import ccall "wxIndividualLayoutConstraint_PercentOf" wxIndividualLayoutConstraint_PercentOf :: Ptr (TIndividualLayoutConstraint a) -> Ptr (TWindow b) -> CInt -> CInt -> IO ()

-- | usage: (@individualLayoutConstraintResetIfWin obj otherW@).
individualLayoutConstraintResetIfWin :: IndividualLayoutConstraint  a -> Window  b ->  IO Bool
individualLayoutConstraintResetIfWin _obj otherW 
  = withBoolResult $
    withObjectRef "individualLayoutConstraintResetIfWin" _obj $ \cobj__obj -> 
    withObjectPtr otherW $ \cobj_otherW -> 
    wxIndividualLayoutConstraint_ResetIfWin cobj__obj  cobj_otherW  
foreign import ccall "wxIndividualLayoutConstraint_ResetIfWin" wxIndividualLayoutConstraint_ResetIfWin :: Ptr (TIndividualLayoutConstraint a) -> Ptr (TWindow b) -> IO CBool

-- | usage: (@individualLayoutConstraintRightOf obj sibling marg@).
individualLayoutConstraintRightOf :: IndividualLayoutConstraint  a -> Window  b -> Int ->  IO ()
individualLayoutConstraintRightOf _obj sibling marg 
  = withObjectRef "individualLayoutConstraintRightOf" _obj $ \cobj__obj -> 
    withObjectPtr sibling $ \cobj_sibling -> 
    wxIndividualLayoutConstraint_RightOf cobj__obj  cobj_sibling  (toCInt marg)  
foreign import ccall "wxIndividualLayoutConstraint_RightOf" wxIndividualLayoutConstraint_RightOf :: Ptr (TIndividualLayoutConstraint a) -> Ptr (TWindow b) -> CInt -> IO ()

-- | usage: (@individualLayoutConstraintSameAs obj otherW edge marg@).
individualLayoutConstraintSameAs :: IndividualLayoutConstraint  a -> Window  b -> Int -> Int ->  IO ()
individualLayoutConstraintSameAs _obj otherW edge marg 
  = withObjectRef "individualLayoutConstraintSameAs" _obj $ \cobj__obj -> 
    withObjectPtr otherW $ \cobj_otherW -> 
    wxIndividualLayoutConstraint_SameAs cobj__obj  cobj_otherW  (toCInt edge)  (toCInt marg)  
foreign import ccall "wxIndividualLayoutConstraint_SameAs" wxIndividualLayoutConstraint_SameAs :: Ptr (TIndividualLayoutConstraint a) -> Ptr (TWindow b) -> CInt -> CInt -> IO ()

-- | usage: (@individualLayoutConstraintSatisfyConstraint obj constraints win@).
individualLayoutConstraintSatisfyConstraint :: IndividualLayoutConstraint  a -> Ptr  b -> Window  c ->  IO Bool
individualLayoutConstraintSatisfyConstraint _obj constraints win 
  = withBoolResult $
    withObjectRef "individualLayoutConstraintSatisfyConstraint" _obj $ \cobj__obj -> 
    withObjectPtr win $ \cobj_win -> 
    wxIndividualLayoutConstraint_SatisfyConstraint cobj__obj  constraints  cobj_win  
foreign import ccall "wxIndividualLayoutConstraint_SatisfyConstraint" wxIndividualLayoutConstraint_SatisfyConstraint :: Ptr (TIndividualLayoutConstraint a) -> Ptr  b -> Ptr (TWindow c) -> IO CBool

-- | usage: (@individualLayoutConstraintSet obj rel otherW otherE val marg@).
individualLayoutConstraintSet :: IndividualLayoutConstraint  a -> Int -> Window  c -> Int -> Int -> Int ->  IO ()
individualLayoutConstraintSet _obj rel otherW otherE val marg 
  = withObjectRef "individualLayoutConstraintSet" _obj $ \cobj__obj -> 
    withObjectPtr otherW $ \cobj_otherW -> 
    wxIndividualLayoutConstraint_Set cobj__obj  (toCInt rel)  cobj_otherW  (toCInt otherE)  (toCInt val)  (toCInt marg)  
foreign import ccall "wxIndividualLayoutConstraint_Set" wxIndividualLayoutConstraint_Set :: Ptr (TIndividualLayoutConstraint a) -> CInt -> Ptr (TWindow c) -> CInt -> CInt -> CInt -> IO ()

-- | usage: (@individualLayoutConstraintSetDone obj d@).
individualLayoutConstraintSetDone :: IndividualLayoutConstraint  a -> Bool ->  IO ()
individualLayoutConstraintSetDone _obj d 
  = withObjectRef "individualLayoutConstraintSetDone" _obj $ \cobj__obj -> 
    wxIndividualLayoutConstraint_SetDone cobj__obj  (toCBool d)  
foreign import ccall "wxIndividualLayoutConstraint_SetDone" wxIndividualLayoutConstraint_SetDone :: Ptr (TIndividualLayoutConstraint a) -> CBool -> IO ()

-- | usage: (@individualLayoutConstraintSetEdge obj which@).
individualLayoutConstraintSetEdge :: IndividualLayoutConstraint  a -> Int ->  IO ()
individualLayoutConstraintSetEdge _obj which 
  = withObjectRef "individualLayoutConstraintSetEdge" _obj $ \cobj__obj -> 
    wxIndividualLayoutConstraint_SetEdge cobj__obj  (toCInt which)  
foreign import ccall "wxIndividualLayoutConstraint_SetEdge" wxIndividualLayoutConstraint_SetEdge :: Ptr (TIndividualLayoutConstraint a) -> CInt -> IO ()

-- | usage: (@individualLayoutConstraintSetMargin obj m@).
individualLayoutConstraintSetMargin :: IndividualLayoutConstraint  a -> Int ->  IO ()
individualLayoutConstraintSetMargin _obj m 
  = withObjectRef "individualLayoutConstraintSetMargin" _obj $ \cobj__obj -> 
    wxIndividualLayoutConstraint_SetMargin cobj__obj  (toCInt m)  
foreign import ccall "wxIndividualLayoutConstraint_SetMargin" wxIndividualLayoutConstraint_SetMargin :: Ptr (TIndividualLayoutConstraint a) -> CInt -> IO ()

-- | usage: (@individualLayoutConstraintSetRelationship obj r@).
individualLayoutConstraintSetRelationship :: IndividualLayoutConstraint  a -> Int ->  IO ()
individualLayoutConstraintSetRelationship _obj r 
  = withObjectRef "individualLayoutConstraintSetRelationship" _obj $ \cobj__obj -> 
    wxIndividualLayoutConstraint_SetRelationship cobj__obj  (toCInt r)  
foreign import ccall "wxIndividualLayoutConstraint_SetRelationship" wxIndividualLayoutConstraint_SetRelationship :: Ptr (TIndividualLayoutConstraint a) -> CInt -> IO ()

-- | usage: (@individualLayoutConstraintSetValue obj v@).
individualLayoutConstraintSetValue :: IndividualLayoutConstraint  a -> Int ->  IO ()
individualLayoutConstraintSetValue _obj v 
  = withObjectRef "individualLayoutConstraintSetValue" _obj $ \cobj__obj -> 
    wxIndividualLayoutConstraint_SetValue cobj__obj  (toCInt v)  
foreign import ccall "wxIndividualLayoutConstraint_SetValue" wxIndividualLayoutConstraint_SetValue :: Ptr (TIndividualLayoutConstraint a) -> CInt -> IO ()

-- | usage: (@individualLayoutConstraintUnconstrained obj@).
individualLayoutConstraintUnconstrained :: IndividualLayoutConstraint  a ->  IO ()
individualLayoutConstraintUnconstrained _obj 
  = withObjectRef "individualLayoutConstraintUnconstrained" _obj $ \cobj__obj -> 
    wxIndividualLayoutConstraint_Unconstrained cobj__obj  
foreign import ccall "wxIndividualLayoutConstraint_Unconstrained" wxIndividualLayoutConstraint_Unconstrained :: Ptr (TIndividualLayoutConstraint a) -> IO ()

{- |  Create an event driven input stream. It is unsafe to reference the original inputStream after this call! The last parameter @bufferLen@ gives the default input batch size. The sink is automatically destroyed whenever the input stream has no more input.  -}
inputSinkCreate :: InputStream  a -> EvtHandler  b -> Int ->  IO (InputSink  ())
inputSinkCreate input evtHandler bufferLen 
  = withObjectResult $
    withObjectPtr input $ \cobj_input -> 
    withObjectPtr evtHandler $ \cobj_evtHandler -> 
    wxInputSink_Create cobj_input  cobj_evtHandler  (toCInt bufferLen)  
foreign import ccall "wxInputSink_Create" wxInputSink_Create :: Ptr (TInputStream a) -> Ptr (TEvtHandler b) -> CInt -> IO (Ptr (TInputSink ()))

{- |  Get the input status (@wxSTREAM_NO_ERROR@ is ok).  -}
inputSinkEventLastError :: InputSinkEvent  a ->  IO Int
inputSinkEventLastError obj 
  = withIntResult $
    withObjectRef "inputSinkEventLastError" obj $ \cobj_obj -> 
    wxInputSinkEvent_LastError cobj_obj  
foreign import ccall "wxInputSinkEvent_LastError" wxInputSinkEvent_LastError :: Ptr (TInputSinkEvent a) -> IO CInt

{- |  The input buffer.  -}
inputSinkEventLastInput :: InputSinkEvent  a ->  IO (Ptr CWchar)
inputSinkEventLastInput obj 
  = withObjectRef "inputSinkEventLastInput" obj $ \cobj_obj -> 
    wxInputSinkEvent_LastInput cobj_obj  
foreign import ccall "wxInputSinkEvent_LastInput" wxInputSinkEvent_LastInput :: Ptr (TInputSinkEvent a) -> IO (Ptr CWchar)

{- |  The number of characters in the input buffer.  -}
inputSinkEventLastRead :: InputSinkEvent  a ->  IO Int
inputSinkEventLastRead obj 
  = withIntResult $
    withObjectRef "inputSinkEventLastRead" obj $ \cobj_obj -> 
    wxInputSinkEvent_LastRead cobj_obj  
foreign import ccall "wxInputSinkEvent_LastRead" wxInputSinkEvent_LastRead :: Ptr (TInputSinkEvent a) -> IO CInt

{- |  After creation, retrieve the @id@ of the sink to connect to @wxEVT_INPUT_SINK@ events.  -}
inputSinkGetId :: InputSink  a ->  IO Int
inputSinkGetId obj 
  = withIntResult $
    withObjectRef "inputSinkGetId" obj $ \cobj_obj -> 
    wxInputSink_GetId cobj_obj  
foreign import ccall "wxInputSink_GetId" wxInputSink_GetId :: Ptr (TInputSink a) -> IO CInt

{- |  After event connection, start non-blocking reading of the inputstream. This will generate @inputSinkEvent@ events.  -}
inputSinkStart :: InputSink  a ->  IO ()
inputSinkStart obj 
  = withObjectRef "inputSinkStart" obj $ \cobj_obj -> 
    wxInputSink_Start cobj_obj  
foreign import ccall "wxInputSink_Start" wxInputSink_Start :: Ptr (TInputSink a) -> IO ()

-- | usage: (@inputStreamCanRead self@).
inputStreamCanRead :: InputStream  a ->  IO Bool
inputStreamCanRead self 
  = withBoolResult $
    withObjectRef "inputStreamCanRead" self $ \cobj_self -> 
    wxInputStream_CanRead cobj_self  
foreign import ccall "wxInputStream_CanRead" wxInputStream_CanRead :: Ptr (TInputStream a) -> IO CBool

-- | usage: (@inputStreamDelete obj@).
inputStreamDelete :: InputStream  a ->  IO ()
inputStreamDelete _obj 
  = withObjectRef "inputStreamDelete" _obj $ \cobj__obj -> 
    wxInputStream_Delete cobj__obj  
foreign import ccall "wxInputStream_Delete" wxInputStream_Delete :: Ptr (TInputStream a) -> IO ()

-- | usage: (@inputStreamEof obj@).
inputStreamEof :: InputStream  a ->  IO Bool
inputStreamEof _obj 
  = withBoolResult $
    withObjectRef "inputStreamEof" _obj $ \cobj__obj -> 
    wxInputStream_Eof cobj__obj  
foreign import ccall "wxInputStream_Eof" wxInputStream_Eof :: Ptr (TInputStream a) -> IO CBool

-- | usage: (@inputStreamGetC obj@).
inputStreamGetC :: InputStream  a ->  IO Char
inputStreamGetC _obj 
  = withCharResult $
    withObjectRef "inputStreamGetC" _obj $ \cobj__obj -> 
    wxInputStream_GetC cobj__obj  
foreign import ccall "wxInputStream_GetC" wxInputStream_GetC :: Ptr (TInputStream a) -> IO CWchar

-- | usage: (@inputStreamLastRead obj@).
inputStreamLastRead :: InputStream  a ->  IO Int
inputStreamLastRead _obj 
  = withIntResult $
    withObjectRef "inputStreamLastRead" _obj $ \cobj__obj -> 
    wxInputStream_LastRead cobj__obj  
foreign import ccall "wxInputStream_LastRead" wxInputStream_LastRead :: Ptr (TInputStream a) -> IO CInt

-- | usage: (@inputStreamPeek obj@).
inputStreamPeek :: InputStream  a ->  IO Char
inputStreamPeek _obj 
  = withCharResult $
    withObjectRef "inputStreamPeek" _obj $ \cobj__obj -> 
    wxInputStream_Peek cobj__obj  
foreign import ccall "wxInputStream_Peek" wxInputStream_Peek :: Ptr (TInputStream a) -> IO CWchar

-- | usage: (@inputStreamRead obj buffer size@).
inputStreamRead :: InputStream  a -> Ptr  b -> Int ->  IO ()
inputStreamRead _obj buffer size 
  = withObjectRef "inputStreamRead" _obj $ \cobj__obj -> 
    wxInputStream_Read cobj__obj  buffer  (toCInt size)  
foreign import ccall "wxInputStream_Read" wxInputStream_Read :: Ptr (TInputStream a) -> Ptr  b -> CInt -> IO ()

-- | usage: (@inputStreamSeekI obj pos mode@).
inputStreamSeekI :: InputStream  a -> Int -> Int ->  IO Int
inputStreamSeekI _obj pos mode 
  = withIntResult $
    withObjectRef "inputStreamSeekI" _obj $ \cobj__obj -> 
    wxInputStream_SeekI cobj__obj  (toCInt pos)  (toCInt mode)  
foreign import ccall "wxInputStream_SeekI" wxInputStream_SeekI :: Ptr (TInputStream a) -> CInt -> CInt -> IO CInt

-- | usage: (@inputStreamTell obj@).
inputStreamTell :: InputStream  a ->  IO Int
inputStreamTell _obj 
  = withIntResult $
    withObjectRef "inputStreamTell" _obj $ \cobj__obj -> 
    wxInputStream_Tell cobj__obj  
foreign import ccall "wxInputStream_Tell" wxInputStream_Tell :: Ptr (TInputStream a) -> IO CInt

-- | usage: (@inputStreamUngetBuffer obj buffer size@).
inputStreamUngetBuffer :: InputStream  a -> Ptr  b -> Int ->  IO Int
inputStreamUngetBuffer _obj buffer size 
  = withIntResult $
    withObjectRef "inputStreamUngetBuffer" _obj $ \cobj__obj -> 
    wxInputStream_UngetBuffer cobj__obj  buffer  (toCInt size)  
foreign import ccall "wxInputStream_UngetBuffer" wxInputStream_UngetBuffer :: Ptr (TInputStream a) -> Ptr  b -> CInt -> IO CInt

-- | usage: (@inputStreamUngetch obj c@).
inputStreamUngetch :: InputStream  a -> Char ->  IO Int
inputStreamUngetch _obj c 
  = withIntResult $
    withObjectRef "inputStreamUngetch" _obj $ \cobj__obj -> 
    wxInputStream_Ungetch cobj__obj  (toCWchar c)  
foreign import ccall "wxInputStream_Ungetch" wxInputStream_Ungetch :: Ptr (TInputStream a) -> CWchar -> IO CInt

{- |  Check if a preprocessor macro is defined. For example, @wxIsDefined("__WXGTK__")@ or @wxIsDefined("wxUSE_GIF")@.  -}
isDefined :: String ->  IO Bool
isDefined s 
  = withBoolResult $
    withCWString s $ \cstr_s -> 
    wx_wxIsDefined cstr_s  
foreign import ccall "wxIsDefined" wx_wxIsDefined :: CWString -> IO CBool

-- | usage: (@keyEventAltDown obj@).
keyEventAltDown :: KeyEvent  a ->  IO Bool
keyEventAltDown _obj 
  = withBoolResult $
    withObjectRef "keyEventAltDown" _obj $ \cobj__obj -> 
    wxKeyEvent_AltDown cobj__obj  
foreign import ccall "wxKeyEvent_AltDown" wxKeyEvent_AltDown :: Ptr (TKeyEvent a) -> IO CBool

-- | usage: (@keyEventControlDown obj@).
keyEventControlDown :: KeyEvent  a ->  IO Bool
keyEventControlDown _obj 
  = withBoolResult $
    withObjectRef "keyEventControlDown" _obj $ \cobj__obj -> 
    wxKeyEvent_ControlDown cobj__obj  
foreign import ccall "wxKeyEvent_ControlDown" wxKeyEvent_ControlDown :: Ptr (TKeyEvent a) -> IO CBool

-- | usage: (@keyEventCopyObject obj obj@).
keyEventCopyObject :: KeyEvent  a -> Ptr  b ->  IO ()
keyEventCopyObject _obj obj 
  = withObjectRef "keyEventCopyObject" _obj $ \cobj__obj -> 
    wxKeyEvent_CopyObject cobj__obj  obj  
foreign import ccall "wxKeyEvent_CopyObject" wxKeyEvent_CopyObject :: Ptr (TKeyEvent a) -> Ptr  b -> IO ()

-- | usage: (@keyEventGetKeyCode obj@).
keyEventGetKeyCode :: KeyEvent  a ->  IO Int
keyEventGetKeyCode _obj 
  = withIntResult $
    withObjectRef "keyEventGetKeyCode" _obj $ \cobj__obj -> 
    wxKeyEvent_GetKeyCode cobj__obj  
foreign import ccall "wxKeyEvent_GetKeyCode" wxKeyEvent_GetKeyCode :: Ptr (TKeyEvent a) -> IO CInt

-- | usage: (@keyEventGetModifiers obj@).
keyEventGetModifiers :: KeyEvent  a ->  IO Int
keyEventGetModifiers _obj 
  = withIntResult $
    withObjectRef "keyEventGetModifiers" _obj $ \cobj__obj -> 
    wxKeyEvent_GetModifiers cobj__obj  
foreign import ccall "wxKeyEvent_GetModifiers" wxKeyEvent_GetModifiers :: Ptr (TKeyEvent a) -> IO CInt

-- | usage: (@keyEventGetPosition obj@).
keyEventGetPosition :: KeyEvent  a ->  IO (Point)
keyEventGetPosition _obj 
  = withWxPointResult $
    withObjectRef "keyEventGetPosition" _obj $ \cobj__obj -> 
    wxKeyEvent_GetPosition cobj__obj  
foreign import ccall "wxKeyEvent_GetPosition" wxKeyEvent_GetPosition :: Ptr (TKeyEvent a) -> IO (Ptr (TWxPoint ()))

-- | usage: (@keyEventGetX obj@).
keyEventGetX :: KeyEvent  a ->  IO Int
keyEventGetX _obj 
  = withIntResult $
    withObjectRef "keyEventGetX" _obj $ \cobj__obj -> 
    wxKeyEvent_GetX cobj__obj  
foreign import ccall "wxKeyEvent_GetX" wxKeyEvent_GetX :: Ptr (TKeyEvent a) -> IO CInt

-- | usage: (@keyEventGetY obj@).
keyEventGetY :: KeyEvent  a ->  IO Int
keyEventGetY _obj 
  = withIntResult $
    withObjectRef "keyEventGetY" _obj $ \cobj__obj -> 
    wxKeyEvent_GetY cobj__obj  
foreign import ccall "wxKeyEvent_GetY" wxKeyEvent_GetY :: Ptr (TKeyEvent a) -> IO CInt

-- | usage: (@keyEventHasModifiers obj@).
keyEventHasModifiers :: KeyEvent  a ->  IO Bool
keyEventHasModifiers _obj 
  = withBoolResult $
    withObjectRef "keyEventHasModifiers" _obj $ \cobj__obj -> 
    wxKeyEvent_HasModifiers cobj__obj  
foreign import ccall "wxKeyEvent_HasModifiers" wxKeyEvent_HasModifiers :: Ptr (TKeyEvent a) -> IO CBool

-- | usage: (@keyEventMetaDown obj@).
keyEventMetaDown :: KeyEvent  a ->  IO Bool
keyEventMetaDown _obj 
  = withBoolResult $
    withObjectRef "keyEventMetaDown" _obj $ \cobj__obj -> 
    wxKeyEvent_MetaDown cobj__obj  
foreign import ccall "wxKeyEvent_MetaDown" wxKeyEvent_MetaDown :: Ptr (TKeyEvent a) -> IO CBool

-- | usage: (@keyEventSetKeyCode obj code@).
keyEventSetKeyCode :: KeyEvent  a -> Int ->  IO ()
keyEventSetKeyCode _obj code 
  = withObjectRef "keyEventSetKeyCode" _obj $ \cobj__obj -> 
    wxKeyEvent_SetKeyCode cobj__obj  (toCInt code)  
foreign import ccall "wxKeyEvent_SetKeyCode" wxKeyEvent_SetKeyCode :: Ptr (TKeyEvent a) -> CInt -> IO ()

-- | usage: (@keyEventShiftDown obj@).
keyEventShiftDown :: KeyEvent  a ->  IO Bool
keyEventShiftDown _obj 
  = withBoolResult $
    withObjectRef "keyEventShiftDown" _obj $ \cobj__obj -> 
    wxKeyEvent_ShiftDown cobj__obj  
foreign import ccall "wxKeyEvent_ShiftDown" wxKeyEvent_ShiftDown :: Ptr (TKeyEvent a) -> IO CBool

-- | usage: (@kill pid signal@).
kill :: Int -> Int ->  IO Int
kill pid signal 
  = withIntResult $
    wx_wxKill (toCInt pid)  (toCInt signal)  
foreign import ccall "wxKill" wx_wxKill :: CInt -> CInt -> IO CInt

-- | usage: (@layoutAlgorithmCreate@).
layoutAlgorithmCreate ::  IO (LayoutAlgorithm  ())
layoutAlgorithmCreate 
  = withObjectResult $
    wxLayoutAlgorithm_Create 
foreign import ccall "wxLayoutAlgorithm_Create" wxLayoutAlgorithm_Create :: IO (Ptr (TLayoutAlgorithm ()))

-- | usage: (@layoutAlgorithmDelete obj@).
layoutAlgorithmDelete :: LayoutAlgorithm  a ->  IO ()
layoutAlgorithmDelete
  = objectDelete


-- | usage: (@layoutAlgorithmLayoutFrame obj frame mainWindow@).
layoutAlgorithmLayoutFrame :: LayoutAlgorithm  a -> Frame  b -> Ptr  c ->  IO Bool
layoutAlgorithmLayoutFrame _obj frame mainWindow 
  = withBoolResult $
    withObjectRef "layoutAlgorithmLayoutFrame" _obj $ \cobj__obj -> 
    withObjectPtr frame $ \cobj_frame -> 
    wxLayoutAlgorithm_LayoutFrame cobj__obj  cobj_frame  mainWindow  
foreign import ccall "wxLayoutAlgorithm_LayoutFrame" wxLayoutAlgorithm_LayoutFrame :: Ptr (TLayoutAlgorithm a) -> Ptr (TFrame b) -> Ptr  c -> IO CBool

-- | usage: (@layoutAlgorithmLayoutMDIFrame obj frame xywh use@).
layoutAlgorithmLayoutMDIFrame :: LayoutAlgorithm  a -> Frame  b -> Rect -> Int ->  IO Bool
layoutAlgorithmLayoutMDIFrame _obj frame xywh use 
  = withBoolResult $
    withObjectRef "layoutAlgorithmLayoutMDIFrame" _obj $ \cobj__obj -> 
    withObjectPtr frame $ \cobj_frame -> 
    wxLayoutAlgorithm_LayoutMDIFrame cobj__obj  cobj_frame  (toCIntRectX xywh) (toCIntRectY xywh)(toCIntRectW xywh) (toCIntRectH xywh)  (toCInt use)  
foreign import ccall "wxLayoutAlgorithm_LayoutMDIFrame" wxLayoutAlgorithm_LayoutMDIFrame :: Ptr (TLayoutAlgorithm a) -> Ptr (TFrame b) -> CInt -> CInt -> CInt -> CInt -> CInt -> IO CBool

-- | usage: (@layoutAlgorithmLayoutWindow obj frame mainWindow@).
layoutAlgorithmLayoutWindow :: LayoutAlgorithm  a -> Frame  b -> Ptr  c ->  IO Bool
layoutAlgorithmLayoutWindow _obj frame mainWindow 
  = withBoolResult $
    withObjectRef "layoutAlgorithmLayoutWindow" _obj $ \cobj__obj -> 
    withObjectPtr frame $ \cobj_frame -> 
    wxLayoutAlgorithm_LayoutWindow cobj__obj  cobj_frame  mainWindow  
foreign import ccall "wxLayoutAlgorithm_LayoutWindow" wxLayoutAlgorithm_LayoutWindow :: Ptr (TLayoutAlgorithm a) -> Ptr (TFrame b) -> Ptr  c -> IO CBool

-- | usage: (@layoutConstraintsCreate@).
layoutConstraintsCreate ::  IO (LayoutConstraints  ())
layoutConstraintsCreate 
  = withObjectResult $
    wxLayoutConstraints_Create 
foreign import ccall "wxLayoutConstraints_Create" wxLayoutConstraints_Create :: IO (Ptr (TLayoutConstraints ()))

-- | usage: (@layoutConstraintsbottom obj@).
layoutConstraintsbottom :: LayoutConstraints  a ->  IO (Ptr  ())
layoutConstraintsbottom _obj 
  = withObjectRef "layoutConstraintsbottom" _obj $ \cobj__obj -> 
    wxLayoutConstraints_bottom cobj__obj  
foreign import ccall "wxLayoutConstraints_bottom" wxLayoutConstraints_bottom :: Ptr (TLayoutConstraints a) -> IO (Ptr  ())

-- | usage: (@layoutConstraintscentreX obj@).
layoutConstraintscentreX :: LayoutConstraints  a ->  IO (Ptr  ())
layoutConstraintscentreX _obj 
  = withObjectRef "layoutConstraintscentreX" _obj $ \cobj__obj -> 
    wxLayoutConstraints_centreX cobj__obj  
foreign import ccall "wxLayoutConstraints_centreX" wxLayoutConstraints_centreX :: Ptr (TLayoutConstraints a) -> IO (Ptr  ())

-- | usage: (@layoutConstraintscentreY obj@).
layoutConstraintscentreY :: LayoutConstraints  a ->  IO (Ptr  ())
layoutConstraintscentreY _obj 
  = withObjectRef "layoutConstraintscentreY" _obj $ \cobj__obj -> 
    wxLayoutConstraints_centreY cobj__obj  
foreign import ccall "wxLayoutConstraints_centreY" wxLayoutConstraints_centreY :: Ptr (TLayoutConstraints a) -> IO (Ptr  ())

-- | usage: (@layoutConstraintsheight obj@).
layoutConstraintsheight :: LayoutConstraints  a ->  IO (Ptr  ())
layoutConstraintsheight _obj 
  = withObjectRef "layoutConstraintsheight" _obj $ \cobj__obj -> 
    wxLayoutConstraints_height cobj__obj  
foreign import ccall "wxLayoutConstraints_height" wxLayoutConstraints_height :: Ptr (TLayoutConstraints a) -> IO (Ptr  ())

-- | usage: (@layoutConstraintsleft obj@).
layoutConstraintsleft :: LayoutConstraints  a ->  IO (Ptr  ())
layoutConstraintsleft _obj 
  = withObjectRef "layoutConstraintsleft" _obj $ \cobj__obj -> 
    wxLayoutConstraints_left cobj__obj  
foreign import ccall "wxLayoutConstraints_left" wxLayoutConstraints_left :: Ptr (TLayoutConstraints a) -> IO (Ptr  ())

-- | usage: (@layoutConstraintsright obj@).
layoutConstraintsright :: LayoutConstraints  a ->  IO (Ptr  ())
layoutConstraintsright _obj 
  = withObjectRef "layoutConstraintsright" _obj $ \cobj__obj -> 
    wxLayoutConstraints_right cobj__obj  
foreign import ccall "wxLayoutConstraints_right" wxLayoutConstraints_right :: Ptr (TLayoutConstraints a) -> IO (Ptr  ())

-- | usage: (@layoutConstraintstop obj@).
layoutConstraintstop :: LayoutConstraints  a ->  IO (Ptr  ())
layoutConstraintstop _obj 
  = withObjectRef "layoutConstraintstop" _obj $ \cobj__obj -> 
    wxLayoutConstraints_top cobj__obj  
foreign import ccall "wxLayoutConstraints_top" wxLayoutConstraints_top :: Ptr (TLayoutConstraints a) -> IO (Ptr  ())

-- | usage: (@layoutConstraintswidth obj@).
layoutConstraintswidth :: LayoutConstraints  a ->  IO (Ptr  ())
layoutConstraintswidth _obj 
  = withObjectRef "layoutConstraintswidth" _obj $ \cobj__obj -> 
    wxLayoutConstraints_width cobj__obj  
foreign import ccall "wxLayoutConstraints_width" wxLayoutConstraints_width :: Ptr (TLayoutConstraints a) -> IO (Ptr  ())

-- | usage: (@listBoxAppend obj item@).
listBoxAppend :: ListBox  a -> String ->  IO ()
listBoxAppend _obj item 
  = withObjectRef "listBoxAppend" _obj $ \cobj__obj -> 
    withStringPtr item $ \cobj_item -> 
    wxListBox_Append cobj__obj  cobj_item  
foreign import ccall "wxListBox_Append" wxListBox_Append :: Ptr (TListBox a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@listBoxAppendData obj item wxdata@).
listBoxAppendData :: ListBox  a -> String -> Ptr  c ->  IO ()
listBoxAppendData _obj item wxdata 
  = withObjectRef "listBoxAppendData" _obj $ \cobj__obj -> 
    withStringPtr item $ \cobj_item -> 
    wxListBox_AppendData cobj__obj  cobj_item  wxdata  
foreign import ccall "wxListBox_AppendData" wxListBox_AppendData :: Ptr (TListBox a) -> Ptr (TWxString b) -> Ptr  c -> IO ()

-- | usage: (@listBoxClear obj@).
listBoxClear :: ListBox  a ->  IO ()
listBoxClear _obj 
  = withObjectRef "listBoxClear" _obj $ \cobj__obj -> 
    wxListBox_Clear cobj__obj  
foreign import ccall "wxListBox_Clear" wxListBox_Clear :: Ptr (TListBox a) -> IO ()

-- | usage: (@listBoxCreate prt id lfttopwdthgt nstr stl@).
listBoxCreate :: Window  a -> Id -> Rect -> [String] -> Style ->  IO (ListBox  ())
listBoxCreate _prt _id _lfttopwdthgt nstr _stl 
  = withObjectResult $
    withObjectPtr _prt $ \cobj__prt -> 
    withArrayWString nstr $ \carrlen_nstr carr_nstr -> 
    wxListBox_Create cobj__prt  (toCInt _id)  (toCIntRectX _lfttopwdthgt) (toCIntRectY _lfttopwdthgt)(toCIntRectW _lfttopwdthgt) (toCIntRectH _lfttopwdthgt)  carrlen_nstr carr_nstr  (toCInt _stl)  
foreign import ccall "wxListBox_Create" wxListBox_Create :: Ptr (TWindow a) -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> Ptr (Ptr CWchar) -> CInt -> IO (Ptr (TListBox ()))

-- | usage: (@listBoxDelete obj n@).
listBoxDelete :: ListBox  a -> Int ->  IO ()
listBoxDelete _obj n 
  = withObjectRef "listBoxDelete" _obj $ \cobj__obj -> 
    wxListBox_Delete cobj__obj  (toCInt n)  
foreign import ccall "wxListBox_Delete" wxListBox_Delete :: Ptr (TListBox a) -> CInt -> IO ()

-- | usage: (@listBoxFindString obj s@).
listBoxFindString :: ListBox  a -> String ->  IO Int
listBoxFindString _obj s 
  = withIntResult $
    withObjectRef "listBoxFindString" _obj $ \cobj__obj -> 
    withStringPtr s $ \cobj_s -> 
    wxListBox_FindString cobj__obj  cobj_s  
foreign import ccall "wxListBox_FindString" wxListBox_FindString :: Ptr (TListBox a) -> Ptr (TWxString b) -> IO CInt

-- | usage: (@listBoxGetClientData obj n@).
listBoxGetClientData :: ListBox  a -> Int ->  IO (ClientData  ())
listBoxGetClientData _obj n 
  = withObjectResult $
    withObjectRef "listBoxGetClientData" _obj $ \cobj__obj -> 
    wxListBox_GetClientData cobj__obj  (toCInt n)  
foreign import ccall "wxListBox_GetClientData" wxListBox_GetClientData :: Ptr (TListBox a) -> CInt -> IO (Ptr (TClientData ()))

-- | usage: (@listBoxGetCount obj@).
listBoxGetCount :: ListBox  a ->  IO Int
listBoxGetCount _obj 
  = withIntResult $
    withObjectRef "listBoxGetCount" _obj $ \cobj__obj -> 
    wxListBox_GetCount cobj__obj  
foreign import ccall "wxListBox_GetCount" wxListBox_GetCount :: Ptr (TListBox a) -> IO CInt

-- | usage: (@listBoxGetSelection obj@).
listBoxGetSelection :: ListBox  a ->  IO Int
listBoxGetSelection _obj 
  = withIntResult $
    withObjectRef "listBoxGetSelection" _obj $ \cobj__obj -> 
    wxListBox_GetSelection cobj__obj  
foreign import ccall "wxListBox_GetSelection" wxListBox_GetSelection :: Ptr (TListBox a) -> IO CInt

-- | usage: (@listBoxGetSelections obj aSelections allocated@).
listBoxGetSelections :: ListBox  a -> Ptr CInt -> Int ->  IO Int
listBoxGetSelections _obj aSelections allocated 
  = withIntResult $
    withObjectRef "listBoxGetSelections" _obj $ \cobj__obj -> 
    wxListBox_GetSelections cobj__obj  aSelections  (toCInt allocated)  
foreign import ccall "wxListBox_GetSelections" wxListBox_GetSelections :: Ptr (TListBox a) -> Ptr CInt -> CInt -> IO CInt

-- | usage: (@listBoxGetString obj n@).
listBoxGetString :: ListBox  a -> Int ->  IO (String)
listBoxGetString _obj n 
  = withManagedStringResult $
    withObjectRef "listBoxGetString" _obj $ \cobj__obj -> 
    wxListBox_GetString cobj__obj  (toCInt n)  
foreign import ccall "wxListBox_GetString" wxListBox_GetString :: Ptr (TListBox a) -> CInt -> IO (Ptr (TWxString ()))

-- | usage: (@listBoxInsertItems obj items pos count@).
listBoxInsertItems :: ListBox  a -> Ptr  b -> Int -> Int ->  IO ()
listBoxInsertItems _obj items pos count 
  = withObjectRef "listBoxInsertItems" _obj $ \cobj__obj -> 
    wxListBox_InsertItems cobj__obj  items  (toCInt pos)  (toCInt count)  
foreign import ccall "wxListBox_InsertItems" wxListBox_InsertItems :: Ptr (TListBox a) -> Ptr  b -> CInt -> CInt -> IO ()

-- | usage: (@listBoxIsSelected obj n@).
listBoxIsSelected :: ListBox  a -> Int ->  IO Bool
listBoxIsSelected _obj n 
  = withBoolResult $
    withObjectRef "listBoxIsSelected" _obj $ \cobj__obj -> 
    wxListBox_IsSelected cobj__obj  (toCInt n)  
foreign import ccall "wxListBox_IsSelected" wxListBox_IsSelected :: Ptr (TListBox a) -> CInt -> IO CBool

-- | usage: (@listBoxSetClientData obj n clientData@).
listBoxSetClientData :: ListBox  a -> Int -> ClientData  c ->  IO ()
listBoxSetClientData _obj n clientData 
  = withObjectRef "listBoxSetClientData" _obj $ \cobj__obj -> 
    withObjectPtr clientData $ \cobj_clientData -> 
    wxListBox_SetClientData cobj__obj  (toCInt n)  cobj_clientData  
foreign import ccall "wxListBox_SetClientData" wxListBox_SetClientData :: Ptr (TListBox a) -> CInt -> Ptr (TClientData c) -> IO ()

-- | usage: (@listBoxSetFirstItem obj n@).
listBoxSetFirstItem :: ListBox  a -> Int ->  IO ()
listBoxSetFirstItem _obj n 
  = withObjectRef "listBoxSetFirstItem" _obj $ \cobj__obj -> 
    wxListBox_SetFirstItem cobj__obj  (toCInt n)  
foreign import ccall "wxListBox_SetFirstItem" wxListBox_SetFirstItem :: Ptr (TListBox a) -> CInt -> IO ()

-- | usage: (@listBoxSetSelection obj n select@).
listBoxSetSelection :: ListBox  a -> Int -> Bool ->  IO ()
listBoxSetSelection _obj n select 
  = withObjectRef "listBoxSetSelection" _obj $ \cobj__obj -> 
    wxListBox_SetSelection cobj__obj  (toCInt n)  (toCBool select)  
foreign import ccall "wxListBox_SetSelection" wxListBox_SetSelection :: Ptr (TListBox a) -> CInt -> CBool -> IO ()

-- | usage: (@listBoxSetString obj n s@).
listBoxSetString :: ListBox  a -> Int -> String ->  IO ()
listBoxSetString _obj n s 
  = withObjectRef "listBoxSetString" _obj $ \cobj__obj -> 
    withStringPtr s $ \cobj_s -> 
    wxListBox_SetString cobj__obj  (toCInt n)  cobj_s  
foreign import ccall "wxListBox_SetString" wxListBox_SetString :: Ptr (TListBox a) -> CInt -> Ptr (TWxString c) -> IO ()

-- | usage: (@listBoxSetStringSelection obj str sel@).
listBoxSetStringSelection :: ListBox  a -> String -> Bool ->  IO ()
listBoxSetStringSelection _obj str sel 
  = withObjectRef "listBoxSetStringSelection" _obj $ \cobj__obj -> 
    withStringPtr str $ \cobj_str -> 
    wxListBox_SetStringSelection cobj__obj  cobj_str  (toCBool sel)  
foreign import ccall "wxListBox_SetStringSelection" wxListBox_SetStringSelection :: Ptr (TListBox a) -> Ptr (TWxString b) -> CBool -> IO ()

-- | usage: (@listCtrlArrange obj flag@).
listCtrlArrange :: ListCtrl  a -> Int ->  IO Bool
listCtrlArrange _obj flag 
  = withBoolResult $
    withObjectRef "listCtrlArrange" _obj $ \cobj__obj -> 
    wxListCtrl_Arrange cobj__obj  (toCInt flag)  
foreign import ccall "wxListCtrl_Arrange" wxListCtrl_Arrange :: Ptr (TListCtrl a) -> CInt -> IO CBool

-- | usage: (@listCtrlAssignImageList obj images which@).
listCtrlAssignImageList :: ListCtrl  a -> ImageList  b -> Int ->  IO ()
listCtrlAssignImageList _obj images which 
  = withObjectRef "listCtrlAssignImageList" _obj $ \cobj__obj -> 
    withObjectPtr images $ \cobj_images -> 
    wxListCtrl_AssignImageList cobj__obj  cobj_images  (toCInt which)  
foreign import ccall "wxListCtrl_AssignImageList" wxListCtrl_AssignImageList :: Ptr (TListCtrl a) -> Ptr (TImageList b) -> CInt -> IO ()

-- | usage: (@listCtrlClearAll obj@).
listCtrlClearAll :: ListCtrl  a ->  IO ()
listCtrlClearAll _obj 
  = withObjectRef "listCtrlClearAll" _obj $ \cobj__obj -> 
    wxListCtrl_ClearAll cobj__obj  
foreign import ccall "wxListCtrl_ClearAll" wxListCtrl_ClearAll :: Ptr (TListCtrl a) -> IO ()

-- | usage: (@listCtrlCreate prt id lfttopwdthgt stl@).
listCtrlCreate :: Window  a -> Id -> Rect -> Style ->  IO (ListCtrl  ())
listCtrlCreate _prt _id _lfttopwdthgt _stl 
  = withObjectResult $
    withObjectPtr _prt $ \cobj__prt -> 
    wxListCtrl_Create cobj__prt  (toCInt _id)  (toCIntRectX _lfttopwdthgt) (toCIntRectY _lfttopwdthgt)(toCIntRectW _lfttopwdthgt) (toCIntRectH _lfttopwdthgt)  (toCInt _stl)  
foreign import ccall "wxListCtrl_Create" wxListCtrl_Create :: Ptr (TWindow a) -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (TListCtrl ()))

-- | usage: (@listCtrlDeleteAllColumns obj@).
listCtrlDeleteAllColumns :: ListCtrl  a ->  IO Bool
listCtrlDeleteAllColumns _obj 
  = withBoolResult $
    withObjectRef "listCtrlDeleteAllColumns" _obj $ \cobj__obj -> 
    wxListCtrl_DeleteAllColumns cobj__obj  
foreign import ccall "wxListCtrl_DeleteAllColumns" wxListCtrl_DeleteAllColumns :: Ptr (TListCtrl a) -> IO CBool

-- | usage: (@listCtrlDeleteAllItems obj@).
listCtrlDeleteAllItems :: ListCtrl  a ->  IO Bool
listCtrlDeleteAllItems _obj 
  = withBoolResult $
    withObjectRef "listCtrlDeleteAllItems" _obj $ \cobj__obj -> 
    wxListCtrl_DeleteAllItems cobj__obj  
foreign import ccall "wxListCtrl_DeleteAllItems" wxListCtrl_DeleteAllItems :: Ptr (TListCtrl a) -> IO CBool

-- | usage: (@listCtrlDeleteColumn obj col@).
listCtrlDeleteColumn :: ListCtrl  a -> Int ->  IO Bool
listCtrlDeleteColumn _obj col 
  = withBoolResult $
    withObjectRef "listCtrlDeleteColumn" _obj $ \cobj__obj -> 
    wxListCtrl_DeleteColumn cobj__obj  (toCInt col)  
foreign import ccall "wxListCtrl_DeleteColumn" wxListCtrl_DeleteColumn :: Ptr (TListCtrl a) -> CInt -> IO CBool

-- | usage: (@listCtrlDeleteItem obj item@).
listCtrlDeleteItem :: ListCtrl  a -> Int ->  IO Bool
listCtrlDeleteItem _obj item 
  = withBoolResult $
    withObjectRef "listCtrlDeleteItem" _obj $ \cobj__obj -> 
    wxListCtrl_DeleteItem cobj__obj  (toCInt item)  
foreign import ccall "wxListCtrl_DeleteItem" wxListCtrl_DeleteItem :: Ptr (TListCtrl a) -> CInt -> IO CBool

-- | usage: (@listCtrlEditLabel obj item@).
listCtrlEditLabel :: ListCtrl  a -> Int ->  IO ()
listCtrlEditLabel _obj item 
  = withObjectRef "listCtrlEditLabel" _obj $ \cobj__obj -> 
    wxListCtrl_EditLabel cobj__obj  (toCInt item)  
foreign import ccall "wxListCtrl_EditLabel" wxListCtrl_EditLabel :: Ptr (TListCtrl a) -> CInt -> IO ()

-- | usage: (@listCtrlEndEditLabel obj cancel@).
listCtrlEndEditLabel :: ListCtrl  a -> Int ->  IO Bool
listCtrlEndEditLabel _obj cancel 
  = withBoolResult $
    withObjectRef "listCtrlEndEditLabel" _obj $ \cobj__obj -> 
    wxListCtrl_EndEditLabel cobj__obj  (toCInt cancel)  
foreign import ccall "wxListCtrl_EndEditLabel" wxListCtrl_EndEditLabel :: Ptr (TListCtrl a) -> CInt -> IO CBool

-- | usage: (@listCtrlEnsureVisible obj item@).
listCtrlEnsureVisible :: ListCtrl  a -> Int ->  IO Bool
listCtrlEnsureVisible _obj item 
  = withBoolResult $
    withObjectRef "listCtrlEnsureVisible" _obj $ \cobj__obj -> 
    wxListCtrl_EnsureVisible cobj__obj  (toCInt item)  
foreign import ccall "wxListCtrl_EnsureVisible" wxListCtrl_EnsureVisible :: Ptr (TListCtrl a) -> CInt -> IO CBool

-- | usage: (@listCtrlFindItem obj start str partial@).
listCtrlFindItem :: ListCtrl  a -> Int -> String -> Bool ->  IO Int
listCtrlFindItem _obj start str partial 
  = withIntResult $
    withObjectRef "listCtrlFindItem" _obj $ \cobj__obj -> 
    withStringPtr str $ \cobj_str -> 
    wxListCtrl_FindItem cobj__obj  (toCInt start)  cobj_str  (toCBool partial)  
foreign import ccall "wxListCtrl_FindItem" wxListCtrl_FindItem :: Ptr (TListCtrl a) -> CInt -> Ptr (TWxString c) -> CBool -> IO CInt

-- | usage: (@listCtrlFindItemByData obj start wxdata@).
listCtrlFindItemByData :: ListCtrl  a -> Int -> Int ->  IO Int
listCtrlFindItemByData _obj start wxdata 
  = withIntResult $
    withObjectRef "listCtrlFindItemByData" _obj $ \cobj__obj -> 
    wxListCtrl_FindItemByData cobj__obj  (toCInt start)  (toCInt wxdata)  
foreign import ccall "wxListCtrl_FindItemByData" wxListCtrl_FindItemByData :: Ptr (TListCtrl a) -> CInt -> CInt -> IO CInt

-- | usage: (@listCtrlFindItemByPosition obj start xy direction@).
listCtrlFindItemByPosition :: ListCtrl  a -> Int -> Point -> Int ->  IO Int
listCtrlFindItemByPosition _obj start xy direction 
  = withIntResult $
    withObjectRef "listCtrlFindItemByPosition" _obj $ \cobj__obj -> 
    wxListCtrl_FindItemByPosition cobj__obj  (toCInt start)  (toCIntPointX xy) (toCIntPointY xy)  (toCInt direction)  
foreign import ccall "wxListCtrl_FindItemByPosition" wxListCtrl_FindItemByPosition :: Ptr (TListCtrl a) -> CInt -> CInt -> CInt -> CInt -> IO CInt

-- | usage: (@listCtrlGetColumn obj col item@).
listCtrlGetColumn :: ListCtrl  a -> Int -> ListItem  c ->  IO Bool
listCtrlGetColumn _obj col item 
  = withBoolResult $
    withObjectRef "listCtrlGetColumn" _obj $ \cobj__obj -> 
    withObjectPtr item $ \cobj_item -> 
    wxListCtrl_GetColumn cobj__obj  (toCInt col)  cobj_item  
foreign import ccall "wxListCtrl_GetColumn" wxListCtrl_GetColumn :: Ptr (TListCtrl a) -> CInt -> Ptr (TListItem c) -> IO CBool

-- | usage: (@listCtrlGetColumn2 obj col@).
listCtrlGetColumn2 :: ListCtrl  a -> Int ->  IO (ListItem  ())
listCtrlGetColumn2 _obj col 
  = withRefListItem $ \pref -> 
    withObjectRef "listCtrlGetColumn2" _obj $ \cobj__obj -> 
    wxListCtrl_GetColumn2 cobj__obj  (toCInt col)   pref
foreign import ccall "wxListCtrl_GetColumn2" wxListCtrl_GetColumn2 :: Ptr (TListCtrl a) -> CInt -> Ptr (TListItem ()) -> IO ()

-- | usage: (@listCtrlGetColumnCount obj@).
listCtrlGetColumnCount :: ListCtrl  a ->  IO Int
listCtrlGetColumnCount _obj 
  = withIntResult $
    withObjectRef "listCtrlGetColumnCount" _obj $ \cobj__obj -> 
    wxListCtrl_GetColumnCount cobj__obj  
foreign import ccall "wxListCtrl_GetColumnCount" wxListCtrl_GetColumnCount :: Ptr (TListCtrl a) -> IO CInt

-- | usage: (@listCtrlGetColumnWidth obj col@).
listCtrlGetColumnWidth :: ListCtrl  a -> Int ->  IO Int
listCtrlGetColumnWidth _obj col 
  = withIntResult $
    withObjectRef "listCtrlGetColumnWidth" _obj $ \cobj__obj -> 
    wxListCtrl_GetColumnWidth cobj__obj  (toCInt col)  
foreign import ccall "wxListCtrl_GetColumnWidth" wxListCtrl_GetColumnWidth :: Ptr (TListCtrl a) -> CInt -> IO CInt

-- | usage: (@listCtrlGetCountPerPage obj@).
listCtrlGetCountPerPage :: ListCtrl  a ->  IO Int
listCtrlGetCountPerPage _obj 
  = withIntResult $
    withObjectRef "listCtrlGetCountPerPage" _obj $ \cobj__obj -> 
    wxListCtrl_GetCountPerPage cobj__obj  
foreign import ccall "wxListCtrl_GetCountPerPage" wxListCtrl_GetCountPerPage :: Ptr (TListCtrl a) -> IO CInt

-- | usage: (@listCtrlGetEditControl obj@).
listCtrlGetEditControl :: ListCtrl  a ->  IO (TextCtrl  ())
listCtrlGetEditControl _obj 
  = withObjectResult $
    withObjectRef "listCtrlGetEditControl" _obj $ \cobj__obj -> 
    wxListCtrl_GetEditControl cobj__obj  
foreign import ccall "wxListCtrl_GetEditControl" wxListCtrl_GetEditControl :: Ptr (TListCtrl a) -> IO (Ptr (TTextCtrl ()))

-- | usage: (@listCtrlGetImageList obj which@).
listCtrlGetImageList :: ListCtrl  a -> Int ->  IO (ImageList  ())
listCtrlGetImageList _obj which 
  = withObjectResult $
    withObjectRef "listCtrlGetImageList" _obj $ \cobj__obj -> 
    wxListCtrl_GetImageList cobj__obj  (toCInt which)  
foreign import ccall "wxListCtrl_GetImageList" wxListCtrl_GetImageList :: Ptr (TListCtrl a) -> CInt -> IO (Ptr (TImageList ()))

-- | usage: (@listCtrlGetItem obj info@).
listCtrlGetItem :: ListCtrl  a -> ListItem  b ->  IO Bool
listCtrlGetItem _obj info 
  = withBoolResult $
    withObjectRef "listCtrlGetItem" _obj $ \cobj__obj -> 
    withObjectPtr info $ \cobj_info -> 
    wxListCtrl_GetItem cobj__obj  cobj_info  
foreign import ccall "wxListCtrl_GetItem" wxListCtrl_GetItem :: Ptr (TListCtrl a) -> Ptr (TListItem b) -> IO CBool

-- | usage: (@listCtrlGetItem2 obj@).
listCtrlGetItem2 :: ListCtrl  a ->  IO (ListItem  ())
listCtrlGetItem2 _obj 
  = withRefListItem $ \pref -> 
    withObjectRef "listCtrlGetItem2" _obj $ \cobj__obj -> 
    wxListCtrl_GetItem2 cobj__obj   pref
foreign import ccall "wxListCtrl_GetItem2" wxListCtrl_GetItem2 :: Ptr (TListCtrl a) -> Ptr (TListItem ()) -> IO ()

-- | usage: (@listCtrlGetItemCount obj@).
listCtrlGetItemCount :: ListCtrl  a ->  IO Int
listCtrlGetItemCount _obj 
  = withIntResult $
    withObjectRef "listCtrlGetItemCount" _obj $ \cobj__obj -> 
    wxListCtrl_GetItemCount cobj__obj  
foreign import ccall "wxListCtrl_GetItemCount" wxListCtrl_GetItemCount :: Ptr (TListCtrl a) -> IO CInt

-- | usage: (@listCtrlGetItemData obj item@).
listCtrlGetItemData :: ListCtrl  a -> Int ->  IO Int
listCtrlGetItemData _obj item 
  = withIntResult $
    withObjectRef "listCtrlGetItemData" _obj $ \cobj__obj -> 
    wxListCtrl_GetItemData cobj__obj  (toCInt item)  
foreign import ccall "wxListCtrl_GetItemData" wxListCtrl_GetItemData :: Ptr (TListCtrl a) -> CInt -> IO CInt

-- | usage: (@listCtrlGetItemPosition obj item@).
listCtrlGetItemPosition :: ListCtrl  a -> Int ->  IO (Point)
listCtrlGetItemPosition _obj item 
  = withWxPointResult $
    withObjectRef "listCtrlGetItemPosition" _obj $ \cobj__obj -> 
    wxListCtrl_GetItemPosition cobj__obj  (toCInt item)  
foreign import ccall "wxListCtrl_GetItemPosition" wxListCtrl_GetItemPosition :: Ptr (TListCtrl a) -> CInt -> IO (Ptr (TWxPoint ()))

-- | usage: (@listCtrlGetItemPosition2 obj item@).
listCtrlGetItemPosition2 :: ListCtrl  a -> Int ->  IO (Point)
listCtrlGetItemPosition2 _obj item 
  = withWxPointResult $
    withObjectRef "listCtrlGetItemPosition2" _obj $ \cobj__obj -> 
    wxListCtrl_GetItemPosition2 cobj__obj  (toCInt item)  
foreign import ccall "wxListCtrl_GetItemPosition2" wxListCtrl_GetItemPosition2 :: Ptr (TListCtrl a) -> CInt -> IO (Ptr (TWxPoint ()))

-- | usage: (@listCtrlGetItemRect obj item code@).
listCtrlGetItemRect :: ListCtrl  a -> Int -> Int ->  IO (Rect)
listCtrlGetItemRect _obj item code 
  = withWxRectResult $
    withObjectRef "listCtrlGetItemRect" _obj $ \cobj__obj -> 
    wxListCtrl_GetItemRect cobj__obj  (toCInt item)  (toCInt code)  
foreign import ccall "wxListCtrl_GetItemRect" wxListCtrl_GetItemRect :: Ptr (TListCtrl a) -> CInt -> CInt -> IO (Ptr (TWxRect ()))

-- | usage: (@listCtrlGetItemSpacing obj isSmall@).
listCtrlGetItemSpacing :: ListCtrl  a -> Bool ->  IO (Size)
listCtrlGetItemSpacing _obj isSmall 
  = withWxSizeResult $
    withObjectRef "listCtrlGetItemSpacing" _obj $ \cobj__obj -> 
    wxListCtrl_GetItemSpacing cobj__obj  (toCBool isSmall)  
foreign import ccall "wxListCtrl_GetItemSpacing" wxListCtrl_GetItemSpacing :: Ptr (TListCtrl a) -> CBool -> IO (Ptr (TWxSize ()))

-- | usage: (@listCtrlGetItemState obj item stateMask@).
listCtrlGetItemState :: ListCtrl  a -> Int -> Int ->  IO Int
listCtrlGetItemState _obj item stateMask 
  = withIntResult $
    withObjectRef "listCtrlGetItemState" _obj $ \cobj__obj -> 
    wxListCtrl_GetItemState cobj__obj  (toCInt item)  (toCInt stateMask)  
foreign import ccall "wxListCtrl_GetItemState" wxListCtrl_GetItemState :: Ptr (TListCtrl a) -> CInt -> CInt -> IO CInt

-- | usage: (@listCtrlGetItemText obj item@).
listCtrlGetItemText :: ListCtrl  a -> Int ->  IO (String)
listCtrlGetItemText _obj item 
  = withManagedStringResult $
    withObjectRef "listCtrlGetItemText" _obj $ \cobj__obj -> 
    wxListCtrl_GetItemText cobj__obj  (toCInt item)  
foreign import ccall "wxListCtrl_GetItemText" wxListCtrl_GetItemText :: Ptr (TListCtrl a) -> CInt -> IO (Ptr (TWxString ()))

-- | usage: (@listCtrlGetNextItem obj item geometry state@).
listCtrlGetNextItem :: ListCtrl  a -> Int -> Int -> Int ->  IO Int
listCtrlGetNextItem _obj item geometry state 
  = withIntResult $
    withObjectRef "listCtrlGetNextItem" _obj $ \cobj__obj -> 
    wxListCtrl_GetNextItem cobj__obj  (toCInt item)  (toCInt geometry)  (toCInt state)  
foreign import ccall "wxListCtrl_GetNextItem" wxListCtrl_GetNextItem :: Ptr (TListCtrl a) -> CInt -> CInt -> CInt -> IO CInt

-- | usage: (@listCtrlGetSelectedItemCount obj@).
listCtrlGetSelectedItemCount :: ListCtrl  a ->  IO Int
listCtrlGetSelectedItemCount _obj 
  = withIntResult $
    withObjectRef "listCtrlGetSelectedItemCount" _obj $ \cobj__obj -> 
    wxListCtrl_GetSelectedItemCount cobj__obj  
foreign import ccall "wxListCtrl_GetSelectedItemCount" wxListCtrl_GetSelectedItemCount :: Ptr (TListCtrl a) -> IO CInt

-- | usage: (@listCtrlGetTextColour obj@).
listCtrlGetTextColour :: ListCtrl  a ->  IO (Color)
listCtrlGetTextColour _obj 
  = withRefColour $ \pref -> 
    withObjectRef "listCtrlGetTextColour" _obj $ \cobj__obj -> 
    wxListCtrl_GetTextColour cobj__obj   pref
foreign import ccall "wxListCtrl_GetTextColour" wxListCtrl_GetTextColour :: Ptr (TListCtrl a) -> Ptr (TColour ()) -> IO ()

-- | usage: (@listCtrlGetTopItem obj@).
listCtrlGetTopItem :: ListCtrl  a ->  IO Int
listCtrlGetTopItem _obj 
  = withIntResult $
    withObjectRef "listCtrlGetTopItem" _obj $ \cobj__obj -> 
    wxListCtrl_GetTopItem cobj__obj  
foreign import ccall "wxListCtrl_GetTopItem" wxListCtrl_GetTopItem :: Ptr (TListCtrl a) -> IO CInt

-- | usage: (@listCtrlHitTest obj xy flags@).
listCtrlHitTest :: ListCtrl  a -> Point -> Ptr  c ->  IO Int
listCtrlHitTest _obj xy flags 
  = withIntResult $
    withObjectRef "listCtrlHitTest" _obj $ \cobj__obj -> 
    wxListCtrl_HitTest cobj__obj  (toCIntPointX xy) (toCIntPointY xy)  flags  
foreign import ccall "wxListCtrl_HitTest" wxListCtrl_HitTest :: Ptr (TListCtrl a) -> CInt -> CInt -> Ptr  c -> IO CInt

-- | usage: (@listCtrlInsertColumn obj col heading format width@).
listCtrlInsertColumn :: ListCtrl  a -> Int -> String -> Int -> Int ->  IO Int
listCtrlInsertColumn _obj col heading format width 
  = withIntResult $
    withObjectRef "listCtrlInsertColumn" _obj $ \cobj__obj -> 
    withStringPtr heading $ \cobj_heading -> 
    wxListCtrl_InsertColumn cobj__obj  (toCInt col)  cobj_heading  (toCInt format)  (toCInt width)  
foreign import ccall "wxListCtrl_InsertColumn" wxListCtrl_InsertColumn :: Ptr (TListCtrl a) -> CInt -> Ptr (TWxString c) -> CInt -> CInt -> IO CInt

-- | usage: (@listCtrlInsertColumnFromInfo obj col info@).
listCtrlInsertColumnFromInfo :: ListCtrl  a -> Int -> ListItem  c ->  IO Int
listCtrlInsertColumnFromInfo _obj col info 
  = withIntResult $
    withObjectRef "listCtrlInsertColumnFromInfo" _obj $ \cobj__obj -> 
    withObjectPtr info $ \cobj_info -> 
    wxListCtrl_InsertColumnFromInfo cobj__obj  (toCInt col)  cobj_info  
foreign import ccall "wxListCtrl_InsertColumnFromInfo" wxListCtrl_InsertColumnFromInfo :: Ptr (TListCtrl a) -> CInt -> Ptr (TListItem c) -> IO CInt

-- | usage: (@listCtrlInsertItem obj info@).
listCtrlInsertItem :: ListCtrl  a -> ListItem  b ->  IO Int
listCtrlInsertItem _obj info 
  = withIntResult $
    withObjectRef "listCtrlInsertItem" _obj $ \cobj__obj -> 
    withObjectPtr info $ \cobj_info -> 
    wxListCtrl_InsertItem cobj__obj  cobj_info  
foreign import ccall "wxListCtrl_InsertItem" wxListCtrl_InsertItem :: Ptr (TListCtrl a) -> Ptr (TListItem b) -> IO CInt

-- | usage: (@listCtrlInsertItemWithData obj index label@).
listCtrlInsertItemWithData :: ListCtrl  a -> Int -> String ->  IO Int
listCtrlInsertItemWithData _obj index label 
  = withIntResult $
    withObjectRef "listCtrlInsertItemWithData" _obj $ \cobj__obj -> 
    withStringPtr label $ \cobj_label -> 
    wxListCtrl_InsertItemWithData cobj__obj  (toCInt index)  cobj_label  
foreign import ccall "wxListCtrl_InsertItemWithData" wxListCtrl_InsertItemWithData :: Ptr (TListCtrl a) -> CInt -> Ptr (TWxString c) -> IO CInt

-- | usage: (@listCtrlInsertItemWithImage obj index imageIndex@).
listCtrlInsertItemWithImage :: ListCtrl  a -> Int -> Int ->  IO Int
listCtrlInsertItemWithImage _obj index imageIndex 
  = withIntResult $
    withObjectRef "listCtrlInsertItemWithImage" _obj $ \cobj__obj -> 
    wxListCtrl_InsertItemWithImage cobj__obj  (toCInt index)  (toCInt imageIndex)  
foreign import ccall "wxListCtrl_InsertItemWithImage" wxListCtrl_InsertItemWithImage :: Ptr (TListCtrl a) -> CInt -> CInt -> IO CInt

-- | usage: (@listCtrlInsertItemWithLabel obj index label imageIndex@).
listCtrlInsertItemWithLabel :: ListCtrl  a -> Int -> String -> Int ->  IO Int
listCtrlInsertItemWithLabel _obj index label imageIndex 
  = withIntResult $
    withObjectRef "listCtrlInsertItemWithLabel" _obj $ \cobj__obj -> 
    withStringPtr label $ \cobj_label -> 
    wxListCtrl_InsertItemWithLabel cobj__obj  (toCInt index)  cobj_label  (toCInt imageIndex)  
foreign import ccall "wxListCtrl_InsertItemWithLabel" wxListCtrl_InsertItemWithLabel :: Ptr (TListCtrl a) -> CInt -> Ptr (TWxString c) -> CInt -> IO CInt

-- | usage: (@listCtrlScrollList obj dxdy@).
listCtrlScrollList :: ListCtrl  a -> Vector ->  IO Bool
listCtrlScrollList _obj dxdy 
  = withBoolResult $
    withObjectRef "listCtrlScrollList" _obj $ \cobj__obj -> 
    wxListCtrl_ScrollList cobj__obj  (toCIntVectorX dxdy) (toCIntVectorY dxdy)  
foreign import ccall "wxListCtrl_ScrollList" wxListCtrl_ScrollList :: Ptr (TListCtrl a) -> CInt -> CInt -> IO CBool

-- | usage: (@listCtrlSetBackgroundColour obj col@).
listCtrlSetBackgroundColour :: ListCtrl  a -> Color ->  IO ()
listCtrlSetBackgroundColour _obj col 
  = withObjectRef "listCtrlSetBackgroundColour" _obj $ \cobj__obj -> 
    withColourPtr col $ \cobj_col -> 
    wxListCtrl_SetBackgroundColour cobj__obj  cobj_col  
foreign import ccall "wxListCtrl_SetBackgroundColour" wxListCtrl_SetBackgroundColour :: Ptr (TListCtrl a) -> Ptr (TColour b) -> IO ()

-- | usage: (@listCtrlSetColumn obj col item@).
listCtrlSetColumn :: ListCtrl  a -> Int -> ListItem  c ->  IO Bool
listCtrlSetColumn _obj col item 
  = withBoolResult $
    withObjectRef "listCtrlSetColumn" _obj $ \cobj__obj -> 
    withObjectPtr item $ \cobj_item -> 
    wxListCtrl_SetColumn cobj__obj  (toCInt col)  cobj_item  
foreign import ccall "wxListCtrl_SetColumn" wxListCtrl_SetColumn :: Ptr (TListCtrl a) -> CInt -> Ptr (TListItem c) -> IO CBool

-- | usage: (@listCtrlSetColumnWidth obj col width@).
listCtrlSetColumnWidth :: ListCtrl  a -> Int -> Int ->  IO Bool
listCtrlSetColumnWidth _obj col width 
  = withBoolResult $
    withObjectRef "listCtrlSetColumnWidth" _obj $ \cobj__obj -> 
    wxListCtrl_SetColumnWidth cobj__obj  (toCInt col)  (toCInt width)  
foreign import ccall "wxListCtrl_SetColumnWidth" wxListCtrl_SetColumnWidth :: Ptr (TListCtrl a) -> CInt -> CInt -> IO CBool

-- | usage: (@listCtrlSetForegroundColour obj col@).
listCtrlSetForegroundColour :: ListCtrl  a -> Color ->  IO Int
listCtrlSetForegroundColour _obj col 
  = withIntResult $
    withObjectRef "listCtrlSetForegroundColour" _obj $ \cobj__obj -> 
    withColourPtr col $ \cobj_col -> 
    wxListCtrl_SetForegroundColour cobj__obj  cobj_col  
foreign import ccall "wxListCtrl_SetForegroundColour" wxListCtrl_SetForegroundColour :: Ptr (TListCtrl a) -> Ptr (TColour b) -> IO CInt

-- | usage: (@listCtrlSetImageList obj imageList which@).
listCtrlSetImageList :: ListCtrl  a -> ImageList  b -> Int ->  IO ()
listCtrlSetImageList _obj imageList which 
  = withObjectRef "listCtrlSetImageList" _obj $ \cobj__obj -> 
    withObjectPtr imageList $ \cobj_imageList -> 
    wxListCtrl_SetImageList cobj__obj  cobj_imageList  (toCInt which)  
foreign import ccall "wxListCtrl_SetImageList" wxListCtrl_SetImageList :: Ptr (TListCtrl a) -> Ptr (TImageList b) -> CInt -> IO ()

-- | usage: (@listCtrlSetItem obj index col label imageId@).
listCtrlSetItem :: ListCtrl  a -> Int -> Int -> String -> Int ->  IO Bool
listCtrlSetItem _obj index col label imageId 
  = withBoolResult $
    withObjectRef "listCtrlSetItem" _obj $ \cobj__obj -> 
    withStringPtr label $ \cobj_label -> 
    wxListCtrl_SetItem cobj__obj  (toCInt index)  (toCInt col)  cobj_label  (toCInt imageId)  
foreign import ccall "wxListCtrl_SetItem" wxListCtrl_SetItem :: Ptr (TListCtrl a) -> CInt -> CInt -> Ptr (TWxString d) -> CInt -> IO CBool

-- | usage: (@listCtrlSetItemData obj item wxdata@).
listCtrlSetItemData :: ListCtrl  a -> Int -> Int ->  IO Bool
listCtrlSetItemData _obj item wxdata 
  = withBoolResult $
    withObjectRef "listCtrlSetItemData" _obj $ \cobj__obj -> 
    wxListCtrl_SetItemData cobj__obj  (toCInt item)  (toCInt wxdata)  
foreign import ccall "wxListCtrl_SetItemData" wxListCtrl_SetItemData :: Ptr (TListCtrl a) -> CInt -> CInt -> IO CBool

-- | usage: (@listCtrlSetItemFromInfo obj info@).
listCtrlSetItemFromInfo :: ListCtrl  a -> ListItem  b ->  IO Bool
listCtrlSetItemFromInfo _obj info 
  = withBoolResult $
    withObjectRef "listCtrlSetItemFromInfo" _obj $ \cobj__obj -> 
    withObjectPtr info $ \cobj_info -> 
    wxListCtrl_SetItemFromInfo cobj__obj  cobj_info  
foreign import ccall "wxListCtrl_SetItemFromInfo" wxListCtrl_SetItemFromInfo :: Ptr (TListCtrl a) -> Ptr (TListItem b) -> IO CBool

-- | usage: (@listCtrlSetItemImage obj item image selImage@).
listCtrlSetItemImage :: ListCtrl  a -> Int -> Int -> Int ->  IO Bool
listCtrlSetItemImage _obj item image selImage 
  = withBoolResult $
    withObjectRef "listCtrlSetItemImage" _obj $ \cobj__obj -> 
    wxListCtrl_SetItemImage cobj__obj  (toCInt item)  (toCInt image)  (toCInt selImage)  
foreign import ccall "wxListCtrl_SetItemImage" wxListCtrl_SetItemImage :: Ptr (TListCtrl a) -> CInt -> CInt -> CInt -> IO CBool

-- | usage: (@listCtrlSetItemPosition obj item xy@).
listCtrlSetItemPosition :: ListCtrl  a -> Int -> Point ->  IO Bool
listCtrlSetItemPosition _obj item xy 
  = withBoolResult $
    withObjectRef "listCtrlSetItemPosition" _obj $ \cobj__obj -> 
    wxListCtrl_SetItemPosition cobj__obj  (toCInt item)  (toCIntPointX xy) (toCIntPointY xy)  
foreign import ccall "wxListCtrl_SetItemPosition" wxListCtrl_SetItemPosition :: Ptr (TListCtrl a) -> CInt -> CInt -> CInt -> IO CBool

-- | usage: (@listCtrlSetItemState obj item state stateMask@).
listCtrlSetItemState :: ListCtrl  a -> Int -> Int -> Int ->  IO Bool
listCtrlSetItemState _obj item state stateMask 
  = withBoolResult $
    withObjectRef "listCtrlSetItemState" _obj $ \cobj__obj -> 
    wxListCtrl_SetItemState cobj__obj  (toCInt item)  (toCInt state)  (toCInt stateMask)  
foreign import ccall "wxListCtrl_SetItemState" wxListCtrl_SetItemState :: Ptr (TListCtrl a) -> CInt -> CInt -> CInt -> IO CBool

-- | usage: (@listCtrlSetItemText obj item str@).
listCtrlSetItemText :: ListCtrl  a -> Int -> String ->  IO ()
listCtrlSetItemText _obj item str 
  = withObjectRef "listCtrlSetItemText" _obj $ \cobj__obj -> 
    withStringPtr str $ \cobj_str -> 
    wxListCtrl_SetItemText cobj__obj  (toCInt item)  cobj_str  
foreign import ccall "wxListCtrl_SetItemText" wxListCtrl_SetItemText :: Ptr (TListCtrl a) -> CInt -> Ptr (TWxString c) -> IO ()

-- | usage: (@listCtrlSetSingleStyle obj style add@).
listCtrlSetSingleStyle :: ListCtrl  a -> Int -> Bool ->  IO ()
listCtrlSetSingleStyle _obj style add 
  = withObjectRef "listCtrlSetSingleStyle" _obj $ \cobj__obj -> 
    wxListCtrl_SetSingleStyle cobj__obj  (toCInt style)  (toCBool add)  
foreign import ccall "wxListCtrl_SetSingleStyle" wxListCtrl_SetSingleStyle :: Ptr (TListCtrl a) -> CInt -> CBool -> IO ()

-- | usage: (@listCtrlSetTextColour obj col@).
listCtrlSetTextColour :: ListCtrl  a -> Color ->  IO ()
listCtrlSetTextColour _obj col 
  = withObjectRef "listCtrlSetTextColour" _obj $ \cobj__obj -> 
    withColourPtr col $ \cobj_col -> 
    wxListCtrl_SetTextColour cobj__obj  cobj_col  
foreign import ccall "wxListCtrl_SetTextColour" wxListCtrl_SetTextColour :: Ptr (TListCtrl a) -> Ptr (TColour b) -> IO ()

-- | usage: (@listCtrlSetWindowStyleFlag obj style@).
listCtrlSetWindowStyleFlag :: ListCtrl  a -> Int ->  IO ()
listCtrlSetWindowStyleFlag _obj style 
  = withObjectRef "listCtrlSetWindowStyleFlag" _obj $ \cobj__obj -> 
    wxListCtrl_SetWindowStyleFlag cobj__obj  (toCInt style)  
foreign import ccall "wxListCtrl_SetWindowStyleFlag" wxListCtrl_SetWindowStyleFlag :: Ptr (TListCtrl a) -> CInt -> IO ()

-- | usage: (@listCtrlSortItems obj fn eifobj@).
listCtrlSortItems :: ListCtrl  a -> Ptr  b -> Ptr  c ->  IO Bool
listCtrlSortItems _obj fn eifobj 
  = withBoolResult $
    withObjectRef "listCtrlSortItems" _obj $ \cobj__obj -> 
    wxListCtrl_SortItems cobj__obj  fn  eifobj  
foreign import ccall "wxListCtrl_SortItems" wxListCtrl_SortItems :: Ptr (TListCtrl a) -> Ptr  b -> Ptr  c -> IO CBool

{- |  Sort items in a list control. Takes a closure that is called with a 'CommandEvent' where the @Int@ is the item data of the first item and the @ExtraLong@ the item data of the second item. The event handler should set the @Int@ to 0 when the items are equal, -1 when the first is less, and 1 when the second is less. * -}
listCtrlSortItems2 :: ListCtrl  a -> Closure  b ->  IO Bool
listCtrlSortItems2 _obj closure 
  = withBoolResult $
    withObjectRef "listCtrlSortItems2" _obj $ \cobj__obj -> 
    withObjectPtr closure $ \cobj_closure -> 
    wxListCtrl_SortItems2 cobj__obj  cobj_closure  
foreign import ccall "wxListCtrl_SortItems2" wxListCtrl_SortItems2 :: Ptr (TListCtrl a) -> Ptr (TClosure b) -> IO CBool

-- | usage: (@listCtrlUpdateStyle obj@).
listCtrlUpdateStyle :: ListCtrl  a ->  IO ()
listCtrlUpdateStyle _obj 
  = withObjectRef "listCtrlUpdateStyle" _obj $ \cobj__obj -> 
    wxListCtrl_UpdateStyle cobj__obj  
foreign import ccall "wxListCtrl_UpdateStyle" wxListCtrl_UpdateStyle :: Ptr (TListCtrl a) -> IO ()

-- | usage: (@listEventCancelled obj@).
listEventCancelled :: ListEvent  a ->  IO Bool
listEventCancelled _obj 
  = withBoolResult $
    withObjectRef "listEventCancelled" _obj $ \cobj__obj -> 
    wxListEvent_Cancelled cobj__obj  
foreign import ccall "wxListEvent_Cancelled" wxListEvent_Cancelled :: Ptr (TListEvent a) -> IO CBool

-- | usage: (@listEventGetCacheFrom obj@).
listEventGetCacheFrom :: ListEvent  a ->  IO Int
listEventGetCacheFrom _obj 
  = withIntResult $
    withObjectRef "listEventGetCacheFrom" _obj $ \cobj__obj -> 
    wxListEvent_GetCacheFrom cobj__obj  
foreign import ccall "wxListEvent_GetCacheFrom" wxListEvent_GetCacheFrom :: Ptr (TListEvent a) -> IO CInt

-- | usage: (@listEventGetCacheTo obj@).
listEventGetCacheTo :: ListEvent  a ->  IO Int
listEventGetCacheTo _obj 
  = withIntResult $
    withObjectRef "listEventGetCacheTo" _obj $ \cobj__obj -> 
    wxListEvent_GetCacheTo cobj__obj  
foreign import ccall "wxListEvent_GetCacheTo" wxListEvent_GetCacheTo :: Ptr (TListEvent a) -> IO CInt

-- | usage: (@listEventGetCode obj@).
listEventGetCode :: ListEvent  a ->  IO Int
listEventGetCode _obj 
  = withIntResult $
    withObjectRef "listEventGetCode" _obj $ \cobj__obj -> 
    wxListEvent_GetCode cobj__obj  
foreign import ccall "wxListEvent_GetCode" wxListEvent_GetCode :: Ptr (TListEvent a) -> IO CInt

-- | usage: (@listEventGetColumn obj@).
listEventGetColumn :: ListEvent  a ->  IO Int
listEventGetColumn _obj 
  = withIntResult $
    withObjectRef "listEventGetColumn" _obj $ \cobj__obj -> 
    wxListEvent_GetColumn cobj__obj  
foreign import ccall "wxListEvent_GetColumn" wxListEvent_GetColumn :: Ptr (TListEvent a) -> IO CInt

-- | usage: (@listEventGetData obj@).
listEventGetData :: ListEvent  a ->  IO Int
listEventGetData _obj 
  = withIntResult $
    withObjectRef "listEventGetData" _obj $ \cobj__obj -> 
    wxListEvent_GetData cobj__obj  
foreign import ccall "wxListEvent_GetData" wxListEvent_GetData :: Ptr (TListEvent a) -> IO CInt

-- | usage: (@listEventGetImage obj@).
listEventGetImage :: ListEvent  a ->  IO Int
listEventGetImage _obj 
  = withIntResult $
    withObjectRef "listEventGetImage" _obj $ \cobj__obj -> 
    wxListEvent_GetImage cobj__obj  
foreign import ccall "wxListEvent_GetImage" wxListEvent_GetImage :: Ptr (TListEvent a) -> IO CInt

-- | usage: (@listEventGetIndex obj@).
listEventGetIndex :: ListEvent  a ->  IO Int
listEventGetIndex _obj 
  = withIntResult $
    withObjectRef "listEventGetIndex" _obj $ \cobj__obj -> 
    wxListEvent_GetIndex cobj__obj  
foreign import ccall "wxListEvent_GetIndex" wxListEvent_GetIndex :: Ptr (TListEvent a) -> IO CInt

-- | usage: (@listEventGetItem obj@).
listEventGetItem :: ListEvent  a ->  IO (ListItem  ())
listEventGetItem _obj 
  = withRefListItem $ \pref -> 
    withObjectRef "listEventGetItem" _obj $ \cobj__obj -> 
    wxListEvent_GetItem cobj__obj   pref
foreign import ccall "wxListEvent_GetItem" wxListEvent_GetItem :: Ptr (TListEvent a) -> Ptr (TListItem ()) -> IO ()

-- | usage: (@listEventGetLabel obj@).
listEventGetLabel :: ListEvent  a ->  IO (String)
listEventGetLabel _obj 
  = withManagedStringResult $
    withObjectRef "listEventGetLabel" _obj $ \cobj__obj -> 
    wxListEvent_GetLabel cobj__obj  
foreign import ccall "wxListEvent_GetLabel" wxListEvent_GetLabel :: Ptr (TListEvent a) -> IO (Ptr (TWxString ()))

-- | usage: (@listEventGetMask obj@).
listEventGetMask :: ListEvent  a ->  IO Int
listEventGetMask _obj 
  = withIntResult $
    withObjectRef "listEventGetMask" _obj $ \cobj__obj -> 
    wxListEvent_GetMask cobj__obj  
foreign import ccall "wxListEvent_GetMask" wxListEvent_GetMask :: Ptr (TListEvent a) -> IO CInt

-- | usage: (@listEventGetPoint obj@).
listEventGetPoint :: ListEvent  a ->  IO (Point)
listEventGetPoint _obj 
  = withWxPointResult $
    withObjectRef "listEventGetPoint" _obj $ \cobj__obj -> 
    wxListEvent_GetPoint cobj__obj  
foreign import ccall "wxListEvent_GetPoint" wxListEvent_GetPoint :: Ptr (TListEvent a) -> IO (Ptr (TWxPoint ()))

-- | usage: (@listEventGetText obj@).
listEventGetText :: ListEvent  a ->  IO (String)
listEventGetText _obj 
  = withManagedStringResult $
    withObjectRef "listEventGetText" _obj $ \cobj__obj -> 
    wxListEvent_GetText cobj__obj  
foreign import ccall "wxListEvent_GetText" wxListEvent_GetText :: Ptr (TListEvent a) -> IO (Ptr (TWxString ()))

-- | usage: (@listItemClear obj@).
listItemClear :: ListItem  a ->  IO ()
listItemClear _obj 
  = withObjectRef "listItemClear" _obj $ \cobj__obj -> 
    wxListItem_Clear cobj__obj  
foreign import ccall "wxListItem_Clear" wxListItem_Clear :: Ptr (TListItem a) -> IO ()

-- | usage: (@listItemClearAttributes obj@).
listItemClearAttributes :: ListItem  a ->  IO ()
listItemClearAttributes _obj 
  = withObjectRef "listItemClearAttributes" _obj $ \cobj__obj -> 
    wxListItem_ClearAttributes cobj__obj  
foreign import ccall "wxListItem_ClearAttributes" wxListItem_ClearAttributes :: Ptr (TListItem a) -> IO ()

-- | usage: (@listItemCreate@).
listItemCreate ::  IO (ListItem  ())
listItemCreate 
  = withManagedObjectResult $
    wxListItem_Create 
foreign import ccall "wxListItem_Create" wxListItem_Create :: IO (Ptr (TListItem ()))

-- | usage: (@listItemDelete obj@).
listItemDelete :: ListItem  a ->  IO ()
listItemDelete
  = objectDelete


-- | usage: (@listItemGetAlign obj@).
listItemGetAlign :: ListItem  a ->  IO Int
listItemGetAlign _obj 
  = withIntResult $
    withObjectRef "listItemGetAlign" _obj $ \cobj__obj -> 
    wxListItem_GetAlign cobj__obj  
foreign import ccall "wxListItem_GetAlign" wxListItem_GetAlign :: Ptr (TListItem a) -> IO CInt

-- | usage: (@listItemGetAttributes obj@).
listItemGetAttributes :: ListItem  a ->  IO (Ptr  ())
listItemGetAttributes _obj 
  = withObjectRef "listItemGetAttributes" _obj $ \cobj__obj -> 
    wxListItem_GetAttributes cobj__obj  
foreign import ccall "wxListItem_GetAttributes" wxListItem_GetAttributes :: Ptr (TListItem a) -> IO (Ptr  ())

-- | usage: (@listItemGetBackgroundColour obj@).
listItemGetBackgroundColour :: ListItem  a ->  IO (Color)
listItemGetBackgroundColour _obj 
  = withRefColour $ \pref -> 
    withObjectRef "listItemGetBackgroundColour" _obj $ \cobj__obj -> 
    wxListItem_GetBackgroundColour cobj__obj   pref
foreign import ccall "wxListItem_GetBackgroundColour" wxListItem_GetBackgroundColour :: Ptr (TListItem a) -> Ptr (TColour ()) -> IO ()

-- | usage: (@listItemGetColumn obj@).
listItemGetColumn :: ListItem  a ->  IO Int
listItemGetColumn _obj 
  = withIntResult $
    withObjectRef "listItemGetColumn" _obj $ \cobj__obj -> 
    wxListItem_GetColumn cobj__obj  
foreign import ccall "wxListItem_GetColumn" wxListItem_GetColumn :: Ptr (TListItem a) -> IO CInt

-- | usage: (@listItemGetData obj@).
listItemGetData :: ListItem  a ->  IO Int
listItemGetData _obj 
  = withIntResult $
    withObjectRef "listItemGetData" _obj $ \cobj__obj -> 
    wxListItem_GetData cobj__obj  
foreign import ccall "wxListItem_GetData" wxListItem_GetData :: Ptr (TListItem a) -> IO CInt

-- | usage: (@listItemGetFont obj@).
listItemGetFont :: ListItem  a ->  IO (Font  ())
listItemGetFont _obj 
  = withRefFont $ \pref -> 
    withObjectRef "listItemGetFont" _obj $ \cobj__obj -> 
    wxListItem_GetFont cobj__obj   pref
foreign import ccall "wxListItem_GetFont" wxListItem_GetFont :: Ptr (TListItem a) -> Ptr (TFont ()) -> IO ()

-- | usage: (@listItemGetId obj@).
listItemGetId :: ListItem  a ->  IO Int
listItemGetId _obj 
  = withIntResult $
    withObjectRef "listItemGetId" _obj $ \cobj__obj -> 
    wxListItem_GetId cobj__obj  
foreign import ccall "wxListItem_GetId" wxListItem_GetId :: Ptr (TListItem a) -> IO CInt

-- | usage: (@listItemGetImage obj@).
listItemGetImage :: ListItem  a ->  IO Int
listItemGetImage _obj 
  = withIntResult $
    withObjectRef "listItemGetImage" _obj $ \cobj__obj -> 
    wxListItem_GetImage cobj__obj  
foreign import ccall "wxListItem_GetImage" wxListItem_GetImage :: Ptr (TListItem a) -> IO CInt

-- | usage: (@listItemGetMask obj@).
listItemGetMask :: ListItem  a ->  IO Int
listItemGetMask _obj 
  = withIntResult $
    withObjectRef "listItemGetMask" _obj $ \cobj__obj -> 
    wxListItem_GetMask cobj__obj  
foreign import ccall "wxListItem_GetMask" wxListItem_GetMask :: Ptr (TListItem a) -> IO CInt

-- | usage: (@listItemGetState obj@).
listItemGetState :: ListItem  a ->  IO Int
listItemGetState _obj 
  = withIntResult $
    withObjectRef "listItemGetState" _obj $ \cobj__obj -> 
    wxListItem_GetState cobj__obj  
foreign import ccall "wxListItem_GetState" wxListItem_GetState :: Ptr (TListItem a) -> IO CInt

-- | usage: (@listItemGetText obj@).
listItemGetText :: ListItem  a ->  IO (String)
listItemGetText _obj 
  = withManagedStringResult $
    withObjectRef "listItemGetText" _obj $ \cobj__obj -> 
    wxListItem_GetText cobj__obj  
foreign import ccall "wxListItem_GetText" wxListItem_GetText :: Ptr (TListItem a) -> IO (Ptr (TWxString ()))

-- | usage: (@listItemGetTextColour obj@).
listItemGetTextColour :: ListItem  a ->  IO (Color)
listItemGetTextColour _obj 
  = withRefColour $ \pref -> 
    withObjectRef "listItemGetTextColour" _obj $ \cobj__obj -> 
    wxListItem_GetTextColour cobj__obj   pref
foreign import ccall "wxListItem_GetTextColour" wxListItem_GetTextColour :: Ptr (TListItem a) -> Ptr (TColour ()) -> IO ()

-- | usage: (@listItemGetWidth obj@).
listItemGetWidth :: ListItem  a ->  IO Int
listItemGetWidth _obj 
  = withIntResult $
    withObjectRef "listItemGetWidth" _obj $ \cobj__obj -> 
    wxListItem_GetWidth cobj__obj  
foreign import ccall "wxListItem_GetWidth" wxListItem_GetWidth :: Ptr (TListItem a) -> IO CInt

-- | usage: (@listItemHasAttributes obj@).
listItemHasAttributes :: ListItem  a ->  IO Bool
listItemHasAttributes _obj 
  = withBoolResult $
    withObjectRef "listItemHasAttributes" _obj $ \cobj__obj -> 
    wxListItem_HasAttributes cobj__obj  
foreign import ccall "wxListItem_HasAttributes" wxListItem_HasAttributes :: Ptr (TListItem a) -> IO CBool

-- | usage: (@listItemSetAlign obj align@).
listItemSetAlign :: ListItem  a -> Int ->  IO ()
listItemSetAlign _obj align 
  = withObjectRef "listItemSetAlign" _obj $ \cobj__obj -> 
    wxListItem_SetAlign cobj__obj  (toCInt align)  
foreign import ccall "wxListItem_SetAlign" wxListItem_SetAlign :: Ptr (TListItem a) -> CInt -> IO ()

-- | usage: (@listItemSetBackgroundColour obj colBack@).
listItemSetBackgroundColour :: ListItem  a -> Color ->  IO ()
listItemSetBackgroundColour _obj colBack 
  = withObjectRef "listItemSetBackgroundColour" _obj $ \cobj__obj -> 
    withColourPtr colBack $ \cobj_colBack -> 
    wxListItem_SetBackgroundColour cobj__obj  cobj_colBack  
foreign import ccall "wxListItem_SetBackgroundColour" wxListItem_SetBackgroundColour :: Ptr (TListItem a) -> Ptr (TColour b) -> IO ()

-- | usage: (@listItemSetColumn obj col@).
listItemSetColumn :: ListItem  a -> Int ->  IO ()
listItemSetColumn _obj col 
  = withObjectRef "listItemSetColumn" _obj $ \cobj__obj -> 
    wxListItem_SetColumn cobj__obj  (toCInt col)  
foreign import ccall "wxListItem_SetColumn" wxListItem_SetColumn :: Ptr (TListItem a) -> CInt -> IO ()

-- | usage: (@listItemSetData obj wxdata@).
listItemSetData :: ListItem  a -> Int ->  IO ()
listItemSetData _obj wxdata 
  = withObjectRef "listItemSetData" _obj $ \cobj__obj -> 
    wxListItem_SetData cobj__obj  (toCInt wxdata)  
foreign import ccall "wxListItem_SetData" wxListItem_SetData :: Ptr (TListItem a) -> CInt -> IO ()

-- | usage: (@listItemSetDataPointer obj wxdata@).
listItemSetDataPointer :: ListItem  a -> Ptr  b ->  IO ()
listItemSetDataPointer _obj wxdata 
  = withObjectRef "listItemSetDataPointer" _obj $ \cobj__obj -> 
    wxListItem_SetDataPointer cobj__obj  wxdata  
foreign import ccall "wxListItem_SetDataPointer" wxListItem_SetDataPointer :: Ptr (TListItem a) -> Ptr  b -> IO ()

-- | usage: (@listItemSetFont obj font@).
listItemSetFont :: ListItem  a -> Font  b ->  IO ()
listItemSetFont _obj font 
  = withObjectRef "listItemSetFont" _obj $ \cobj__obj -> 
    withObjectPtr font $ \cobj_font -> 
    wxListItem_SetFont cobj__obj  cobj_font  
foreign import ccall "wxListItem_SetFont" wxListItem_SetFont :: Ptr (TListItem a) -> Ptr (TFont b) -> IO ()

-- | usage: (@listItemSetId obj id@).
listItemSetId :: ListItem  a -> Id ->  IO ()
listItemSetId _obj id 
  = withObjectRef "listItemSetId" _obj $ \cobj__obj -> 
    wxListItem_SetId cobj__obj  (toCInt id)  
foreign import ccall "wxListItem_SetId" wxListItem_SetId :: Ptr (TListItem a) -> CInt -> IO ()

-- | usage: (@listItemSetImage obj image@).
listItemSetImage :: ListItem  a -> Int ->  IO ()
listItemSetImage _obj image 
  = withObjectRef "listItemSetImage" _obj $ \cobj__obj -> 
    wxListItem_SetImage cobj__obj  (toCInt image)  
foreign import ccall "wxListItem_SetImage" wxListItem_SetImage :: Ptr (TListItem a) -> CInt -> IO ()

-- | usage: (@listItemSetMask obj mask@).
listItemSetMask :: ListItem  a -> Int ->  IO ()
listItemSetMask _obj mask 
  = withObjectRef "listItemSetMask" _obj $ \cobj__obj -> 
    wxListItem_SetMask cobj__obj  (toCInt mask)  
foreign import ccall "wxListItem_SetMask" wxListItem_SetMask :: Ptr (TListItem a) -> CInt -> IO ()

-- | usage: (@listItemSetState obj state@).
listItemSetState :: ListItem  a -> Int ->  IO ()
listItemSetState _obj state 
  = withObjectRef "listItemSetState" _obj $ \cobj__obj -> 
    wxListItem_SetState cobj__obj  (toCInt state)  
foreign import ccall "wxListItem_SetState" wxListItem_SetState :: Ptr (TListItem a) -> CInt -> IO ()

-- | usage: (@listItemSetStateMask obj stateMask@).
listItemSetStateMask :: ListItem  a -> Int ->  IO ()
listItemSetStateMask _obj stateMask 
  = withObjectRef "listItemSetStateMask" _obj $ \cobj__obj -> 
    wxListItem_SetStateMask cobj__obj  (toCInt stateMask)  
foreign import ccall "wxListItem_SetStateMask" wxListItem_SetStateMask :: Ptr (TListItem a) -> CInt -> IO ()

-- | usage: (@listItemSetText obj text@).
listItemSetText :: ListItem  a -> String ->  IO ()
listItemSetText _obj text 
  = withObjectRef "listItemSetText" _obj $ \cobj__obj -> 
    withStringPtr text $ \cobj_text -> 
    wxListItem_SetText cobj__obj  cobj_text  
foreign import ccall "wxListItem_SetText" wxListItem_SetText :: Ptr (TListItem a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@listItemSetTextColour obj colText@).
listItemSetTextColour :: ListItem  a -> Color ->  IO ()
listItemSetTextColour _obj colText 
  = withObjectRef "listItemSetTextColour" _obj $ \cobj__obj -> 
    withColourPtr colText $ \cobj_colText -> 
    wxListItem_SetTextColour cobj__obj  cobj_colText  
foreign import ccall "wxListItem_SetTextColour" wxListItem_SetTextColour :: Ptr (TListItem a) -> Ptr (TColour b) -> IO ()

-- | usage: (@listItemSetWidth obj width@).
listItemSetWidth :: ListItem  a -> Int ->  IO ()
listItemSetWidth _obj width 
  = withObjectRef "listItemSetWidth" _obj $ \cobj__obj -> 
    wxListItem_SetWidth cobj__obj  (toCInt width)  
foreign import ccall "wxListItem_SetWidth" wxListItem_SetWidth :: Ptr (TListItem a) -> CInt -> IO ()

-- | usage: (@localeAddCatalog obj szDomain@).
localeAddCatalog :: Locale  a -> Ptr  b ->  IO Int
localeAddCatalog _obj szDomain 
  = withIntResult $
    withObjectRef "localeAddCatalog" _obj $ \cobj__obj -> 
    wxLocale_AddCatalog cobj__obj  szDomain  
foreign import ccall "wxLocale_AddCatalog" wxLocale_AddCatalog :: Ptr (TLocale a) -> Ptr  b -> IO CInt

-- | usage: (@localeAddCatalogLookupPathPrefix obj prefix@).
localeAddCatalogLookupPathPrefix :: Locale  a -> Ptr  b ->  IO ()
localeAddCatalogLookupPathPrefix _obj prefix 
  = withObjectRef "localeAddCatalogLookupPathPrefix" _obj $ \cobj__obj -> 
    wxLocale_AddCatalogLookupPathPrefix cobj__obj  prefix  
foreign import ccall "wxLocale_AddCatalogLookupPathPrefix" wxLocale_AddCatalogLookupPathPrefix :: Ptr (TLocale a) -> Ptr  b -> IO ()

-- | usage: (@localeCreate name flags@).
localeCreate :: Int -> Int ->  IO (Locale  ())
localeCreate _name _flags 
  = withObjectResult $
    wxLocale_Create (toCInt _name)  (toCInt _flags)  
foreign import ccall "wxLocale_Create" wxLocale_Create :: CInt -> CInt -> IO (Ptr (TLocale ()))

-- | usage: (@localeDelete obj@).
localeDelete :: Locale  a ->  IO ()
localeDelete _obj 
  = withObjectRef "localeDelete" _obj $ \cobj__obj -> 
    wxLocale_Delete cobj__obj  
foreign import ccall "wxLocale_Delete" wxLocale_Delete :: Ptr (TLocale a) -> IO ()

-- | usage: (@localeGetLocale obj@).
localeGetLocale :: Locale  a ->  IO (Locale  ())
localeGetLocale _obj 
  = withObjectResult $
    withObjectRef "localeGetLocale" _obj $ \cobj__obj -> 
    wxLocale_GetLocale cobj__obj  
foreign import ccall "wxLocale_GetLocale" wxLocale_GetLocale :: Ptr (TLocale a) -> IO (Ptr (TLocale ()))

-- | usage: (@localeGetName obj@).
localeGetName :: Locale  a ->  IO (String)
localeGetName _obj 
  = withManagedStringResult $
    withObjectRef "localeGetName" _obj $ \cobj__obj -> 
    wxLocale_GetName cobj__obj  
foreign import ccall "wxLocale_GetName" wxLocale_GetName :: Ptr (TLocale a) -> IO (Ptr (TWxString ()))

-- | usage: (@localeGetString obj szOrigString szDomain@).
localeGetString :: Locale  a -> Ptr  b -> Ptr  c ->  IO String
localeGetString _obj szOrigString szDomain 
  = withWStringResult $ \buffer -> 
    withObjectRef "localeGetString" _obj $ \cobj__obj -> 
    wxLocale_GetString cobj__obj  szOrigString  szDomain   buffer
foreign import ccall "wxLocale_GetString" wxLocale_GetString :: Ptr (TLocale a) -> Ptr  b -> Ptr  c -> Ptr CWchar -> IO CInt

-- | usage: (@localeIsLoaded obj szDomain@).
localeIsLoaded :: Locale  a -> Ptr  b ->  IO Bool
localeIsLoaded _obj szDomain 
  = withBoolResult $
    withObjectRef "localeIsLoaded" _obj $ \cobj__obj -> 
    wxLocale_IsLoaded cobj__obj  szDomain  
foreign import ccall "wxLocale_IsLoaded" wxLocale_IsLoaded :: Ptr (TLocale a) -> Ptr  b -> IO CBool

-- | usage: (@localeIsOk obj@).
localeIsOk :: Locale  a ->  IO Bool
localeIsOk _obj 
  = withBoolResult $
    withObjectRef "localeIsOk" _obj $ \cobj__obj -> 
    wxLocale_IsOk cobj__obj  
foreign import ccall "wxLocale_IsOk" wxLocale_IsOk :: Ptr (TLocale a) -> IO CBool

-- | usage: (@logAddTraceMask obj str@).
logAddTraceMask :: Log  a -> String ->  IO ()
logAddTraceMask _obj str 
  = withObjectRef "logAddTraceMask" _obj $ \cobj__obj -> 
    withStringPtr str $ \cobj_str -> 
    wxLog_AddTraceMask cobj__obj  cobj_str  
foreign import ccall "wxLog_AddTraceMask" wxLog_AddTraceMask :: Ptr (TLog a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@logChainCreate logger@).
logChainCreate :: Log  a ->  IO (LogChain  ())
logChainCreate logger 
  = withObjectResult $
    withObjectPtr logger $ \cobj_logger -> 
    wxLogChain_Create cobj_logger  
foreign import ccall "wxLogChain_Create" wxLogChain_Create :: Ptr (TLog a) -> IO (Ptr (TLogChain ()))

-- | usage: (@logChainDelete obj@).
logChainDelete :: LogChain  a ->  IO ()
logChainDelete _obj 
  = withObjectRef "logChainDelete" _obj $ \cobj__obj -> 
    wxLogChain_Delete cobj__obj  
foreign import ccall "wxLogChain_Delete" wxLogChain_Delete :: Ptr (TLogChain a) -> IO ()

-- | usage: (@logChainGetOldLog obj@).
logChainGetOldLog :: LogChain  a ->  IO (Log  ())
logChainGetOldLog _obj 
  = withObjectResult $
    withObjectRef "logChainGetOldLog" _obj $ \cobj__obj -> 
    wxLogChain_GetOldLog cobj__obj  
foreign import ccall "wxLogChain_GetOldLog" wxLogChain_GetOldLog :: Ptr (TLogChain a) -> IO (Ptr (TLog ()))

-- | usage: (@logChainIsPassingMessages obj@).
logChainIsPassingMessages :: LogChain  a ->  IO Bool
logChainIsPassingMessages _obj 
  = withBoolResult $
    withObjectRef "logChainIsPassingMessages" _obj $ \cobj__obj -> 
    wxLogChain_IsPassingMessages cobj__obj  
foreign import ccall "wxLogChain_IsPassingMessages" wxLogChain_IsPassingMessages :: Ptr (TLogChain a) -> IO CBool

-- | usage: (@logChainPassMessages obj bDoPass@).
logChainPassMessages :: LogChain  a -> Bool ->  IO ()
logChainPassMessages _obj bDoPass 
  = withObjectRef "logChainPassMessages" _obj $ \cobj__obj -> 
    wxLogChain_PassMessages cobj__obj  (toCBool bDoPass)  
foreign import ccall "wxLogChain_PassMessages" wxLogChain_PassMessages :: Ptr (TLogChain a) -> CBool -> IO ()

-- | usage: (@logChainSetLog obj logger@).
logChainSetLog :: LogChain  a -> Log  b ->  IO ()
logChainSetLog _obj logger 
  = withObjectRef "logChainSetLog" _obj $ \cobj__obj -> 
    withObjectPtr logger $ \cobj_logger -> 
    wxLogChain_SetLog cobj__obj  cobj_logger  
foreign import ccall "wxLogChain_SetLog" wxLogChain_SetLog :: Ptr (TLogChain a) -> Ptr (TLog b) -> IO ()

-- | usage: (@logDebug msg@).
logDebug :: String ->  IO ()
logDebug _msg 
  = withStringPtr _msg $ \cobj__msg -> 
    wx_LogDebug cobj__msg  
foreign import ccall "LogDebug" wx_LogDebug :: Ptr (TWxString a) -> IO ()

-- | usage: (@logDelete obj@).
logDelete :: Log  a ->  IO ()
logDelete _obj 
  = withObjectRef "logDelete" _obj $ \cobj__obj -> 
    wxLog_Delete cobj__obj  
foreign import ccall "wxLog_Delete" wxLog_Delete :: Ptr (TLog a) -> IO ()

-- | usage: (@logDontCreateOnDemand obj@).
logDontCreateOnDemand :: Log  a ->  IO ()
logDontCreateOnDemand _obj 
  = withObjectRef "logDontCreateOnDemand" _obj $ \cobj__obj -> 
    wxLog_DontCreateOnDemand cobj__obj  
foreign import ccall "wxLog_DontCreateOnDemand" wxLog_DontCreateOnDemand :: Ptr (TLog a) -> IO ()

-- | usage: (@logError msg@).
logError :: String ->  IO ()
logError _msg 
  = withStringPtr _msg $ \cobj__msg -> 
    wx_LogError cobj__msg  
foreign import ccall "LogError" wx_LogError :: Ptr (TWxString a) -> IO ()

-- | usage: (@logErrorMsg msg@).
logErrorMsg :: String ->  IO ()
logErrorMsg _msg 
  = withStringPtr _msg $ \cobj__msg -> 
    wx_LogErrorMsg cobj__msg  
foreign import ccall "LogErrorMsg" wx_LogErrorMsg :: Ptr (TWxString a) -> IO ()

-- | usage: (@logFatalError msg@).
logFatalError :: String ->  IO ()
logFatalError _msg 
  = withStringPtr _msg $ \cobj__msg -> 
    wx_LogFatalError cobj__msg  
foreign import ccall "LogFatalError" wx_LogFatalError :: Ptr (TWxString a) -> IO ()

-- | usage: (@logFatalErrorMsg msg@).
logFatalErrorMsg :: String ->  IO ()
logFatalErrorMsg _msg 
  = withStringPtr _msg $ \cobj__msg -> 
    wx_LogFatalErrorMsg cobj__msg  
foreign import ccall "LogFatalErrorMsg" wx_LogFatalErrorMsg :: Ptr (TWxString a) -> IO ()

-- | usage: (@logFlush obj@).
logFlush :: Log  a ->  IO ()
logFlush _obj 
  = withObjectRef "logFlush" _obj $ \cobj__obj -> 
    wxLog_Flush cobj__obj  
foreign import ccall "wxLog_Flush" wxLog_Flush :: Ptr (TLog a) -> IO ()

-- | usage: (@logFlushActive obj@).
logFlushActive :: Log  a ->  IO ()
logFlushActive _obj 
  = withObjectRef "logFlushActive" _obj $ \cobj__obj -> 
    wxLog_FlushActive cobj__obj  
foreign import ccall "wxLog_FlushActive" wxLog_FlushActive :: Ptr (TLog a) -> IO ()

-- | usage: (@logGetActiveTarget@).
logGetActiveTarget ::  IO (Log  ())
logGetActiveTarget 
  = withObjectResult $
    wxLog_GetActiveTarget 
foreign import ccall "wxLog_GetActiveTarget" wxLog_GetActiveTarget :: IO (Ptr (TLog ()))

-- | usage: (@logGetTimestamp obj@).
logGetTimestamp :: Log  a ->  IO (Ptr CWchar)
logGetTimestamp _obj 
  = withObjectRef "logGetTimestamp" _obj $ \cobj__obj -> 
    wxLog_GetTimestamp cobj__obj  
foreign import ccall "wxLog_GetTimestamp" wxLog_GetTimestamp :: Ptr (TLog a) -> IO (Ptr CWchar)

-- | usage: (@logGetTraceMask obj@).
logGetTraceMask :: Log  a ->  IO Int
logGetTraceMask _obj 
  = withIntResult $
    withObjectRef "logGetTraceMask" _obj $ \cobj__obj -> 
    wxLog_GetTraceMask cobj__obj  
foreign import ccall "wxLog_GetTraceMask" wxLog_GetTraceMask :: Ptr (TLog a) -> IO CInt

-- | usage: (@logGetVerbose obj@).
logGetVerbose :: Log  a ->  IO Int
logGetVerbose _obj 
  = withIntResult $
    withObjectRef "logGetVerbose" _obj $ \cobj__obj -> 
    wxLog_GetVerbose cobj__obj  
foreign import ccall "wxLog_GetVerbose" wxLog_GetVerbose :: Ptr (TLog a) -> IO CInt

-- | usage: (@logHasPendingMessages obj@).
logHasPendingMessages :: Log  a ->  IO Bool
logHasPendingMessages _obj 
  = withBoolResult $
    withObjectRef "logHasPendingMessages" _obj $ \cobj__obj -> 
    wxLog_HasPendingMessages cobj__obj  
foreign import ccall "wxLog_HasPendingMessages" wxLog_HasPendingMessages :: Ptr (TLog a) -> IO CBool

-- | usage: (@logIsAllowedTraceMask obj mask@).
logIsAllowedTraceMask :: Log  a -> Mask  b ->  IO Bool
logIsAllowedTraceMask _obj mask 
  = withBoolResult $
    withObjectRef "logIsAllowedTraceMask" _obj $ \cobj__obj -> 
    withObjectPtr mask $ \cobj_mask -> 
    wxLog_IsAllowedTraceMask cobj__obj  cobj_mask  
foreign import ccall "wxLog_IsAllowedTraceMask" wxLog_IsAllowedTraceMask :: Ptr (TLog a) -> Ptr (TMask b) -> IO CBool

-- | usage: (@logMessage msg@).
logMessage :: String ->  IO ()
logMessage _msg 
  = withStringPtr _msg $ \cobj__msg -> 
    wx_LogMessage cobj__msg  
foreign import ccall "LogMessage" wx_LogMessage :: Ptr (TWxString a) -> IO ()

-- | usage: (@logMessageMsg msg@).
logMessageMsg :: String ->  IO ()
logMessageMsg _msg 
  = withStringPtr _msg $ \cobj__msg -> 
    wx_LogMessageMsg cobj__msg  
foreign import ccall "LogMessageMsg" wx_LogMessageMsg :: Ptr (TWxString a) -> IO ()

-- | usage: (@logNullCreate@).
logNullCreate ::  IO (LogNull  ())
logNullCreate 
  = withObjectResult $
    wxLogNull_Create 
foreign import ccall "wxLogNull_Create" wxLogNull_Create :: IO (Ptr (TLogNull ()))

-- | usage: (@logOnLog obj level szString t@).
logOnLog :: Log  a -> Int -> String -> Int ->  IO ()
logOnLog _obj level szString t 
  = withObjectRef "logOnLog" _obj $ \cobj__obj -> 
    withCWString szString $ \cstr_szString -> 
    wxLog_OnLog cobj__obj  (toCInt level)  cstr_szString  (toCInt t)  
foreign import ccall "wxLog_OnLog" wxLog_OnLog :: Ptr (TLog a) -> CInt -> CWString -> CInt -> IO ()

-- | usage: (@logRemoveTraceMask obj str@).
logRemoveTraceMask :: Log  a -> String ->  IO ()
logRemoveTraceMask _obj str 
  = withObjectRef "logRemoveTraceMask" _obj $ \cobj__obj -> 
    withStringPtr str $ \cobj_str -> 
    wxLog_RemoveTraceMask cobj__obj  cobj_str  
foreign import ccall "wxLog_RemoveTraceMask" wxLog_RemoveTraceMask :: Ptr (TLog a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@logResume obj@).
logResume :: Log  a ->  IO ()
logResume _obj 
  = withObjectRef "logResume" _obj $ \cobj__obj -> 
    wxLog_Resume cobj__obj  
foreign import ccall "wxLog_Resume" wxLog_Resume :: Ptr (TLog a) -> IO ()

-- | usage: (@logSetActiveTarget pLogger@).
logSetActiveTarget :: Log  a ->  IO (Log  ())
logSetActiveTarget pLogger 
  = withObjectResult $
    withObjectRef "logSetActiveTarget" pLogger $ \cobj_pLogger -> 
    wxLog_SetActiveTarget cobj_pLogger  
foreign import ccall "wxLog_SetActiveTarget" wxLog_SetActiveTarget :: Ptr (TLog a) -> IO (Ptr (TLog ()))

-- | usage: (@logSetTimestamp obj ts@).
logSetTimestamp :: Log  a -> String ->  IO ()
logSetTimestamp _obj ts 
  = withObjectRef "logSetTimestamp" _obj $ \cobj__obj -> 
    withCWString ts $ \cstr_ts -> 
    wxLog_SetTimestamp cobj__obj  cstr_ts  
foreign import ccall "wxLog_SetTimestamp" wxLog_SetTimestamp :: Ptr (TLog a) -> CWString -> IO ()

-- | usage: (@logSetTraceMask obj ulMask@).
logSetTraceMask :: Log  a -> Int ->  IO ()
logSetTraceMask _obj ulMask 
  = withObjectRef "logSetTraceMask" _obj $ \cobj__obj -> 
    wxLog_SetTraceMask cobj__obj  (toCInt ulMask)  
foreign import ccall "wxLog_SetTraceMask" wxLog_SetTraceMask :: Ptr (TLog a) -> CInt -> IO ()

-- | usage: (@logSetVerbose obj bVerbose@).
logSetVerbose :: Log  a -> Bool ->  IO ()
logSetVerbose _obj bVerbose 
  = withObjectRef "logSetVerbose" _obj $ \cobj__obj -> 
    wxLog_SetVerbose cobj__obj  (toCBool bVerbose)  
foreign import ccall "wxLog_SetVerbose" wxLog_SetVerbose :: Ptr (TLog a) -> CBool -> IO ()

-- | usage: (@logStatus msg@).
logStatus :: String ->  IO ()
logStatus _msg 
  = withStringPtr _msg $ \cobj__msg -> 
    wx_LogStatus cobj__msg  
foreign import ccall "LogStatus" wx_LogStatus :: Ptr (TWxString a) -> IO ()

-- | usage: (@logStderrCreate@).
logStderrCreate ::  IO (LogStderr  ())
logStderrCreate 
  = withObjectResult $
    wxLogStderr_Create 
foreign import ccall "wxLogStderr_Create" wxLogStderr_Create :: IO (Ptr (TLogStderr ()))

-- | usage: (@logStderrCreateStdOut@).
logStderrCreateStdOut ::  IO (LogStderr  ())
logStderrCreateStdOut 
  = withObjectResult $
    wxLogStderr_CreateStdOut 
foreign import ccall "wxLogStderr_CreateStdOut" wxLogStderr_CreateStdOut :: IO (Ptr (TLogStderr ()))

-- | usage: (@logSuspend obj@).
logSuspend :: Log  a ->  IO ()
logSuspend _obj 
  = withObjectRef "logSuspend" _obj $ \cobj__obj -> 
    wxLog_Suspend cobj__obj  
foreign import ccall "wxLog_Suspend" wxLog_Suspend :: Ptr (TLog a) -> IO ()

-- | usage: (@logSysError msg@).
logSysError :: String ->  IO ()
logSysError _msg 
  = withStringPtr _msg $ \cobj__msg -> 
    wx_LogSysError cobj__msg  
foreign import ccall "LogSysError" wx_LogSysError :: Ptr (TWxString a) -> IO ()

-- | usage: (@logTextCtrlCreate text@).
logTextCtrlCreate :: TextCtrl  a ->  IO (LogTextCtrl  ())
logTextCtrlCreate text 
  = withObjectResult $
    withObjectPtr text $ \cobj_text -> 
    wxLogTextCtrl_Create cobj_text  
foreign import ccall "wxLogTextCtrl_Create" wxLogTextCtrl_Create :: Ptr (TTextCtrl a) -> IO (Ptr (TLogTextCtrl ()))

-- | usage: (@logTrace mask msg@).
logTrace :: String -> String ->  IO ()
logTrace mask _msg 
  = withStringPtr mask $ \cobj_mask -> 
    withStringPtr _msg $ \cobj__msg -> 
    wx_LogTrace cobj_mask  cobj__msg  
foreign import ccall "LogTrace" wx_LogTrace :: Ptr (TWxString a) -> Ptr (TWxString b) -> IO ()

-- | usage: (@logVerbose msg@).
logVerbose :: String ->  IO ()
logVerbose _msg 
  = withStringPtr _msg $ \cobj__msg -> 
    wx_LogVerbose cobj__msg  
foreign import ccall "LogVerbose" wx_LogVerbose :: Ptr (TWxString a) -> IO ()

-- | usage: (@logWarning msg@).
logWarning :: String ->  IO ()
logWarning _msg 
  = withStringPtr _msg $ \cobj__msg -> 
    wx_LogWarning cobj__msg  
foreign import ccall "LogWarning" wx_LogWarning :: Ptr (TWxString a) -> IO ()

-- | usage: (@logWarningMsg msg@).
logWarningMsg :: String ->  IO ()
logWarningMsg _msg 
  = withStringPtr _msg $ \cobj__msg -> 
    wx_LogWarningMsg cobj__msg  
foreign import ccall "LogWarningMsg" wx_LogWarningMsg :: Ptr (TWxString a) -> IO ()

-- | usage: (@logWindowCreate parent title showit passthrough@).
logWindowCreate :: Window  a -> String -> Bool -> Bool ->  IO (LogWindow  ())
logWindowCreate parent title showit passthrough 
  = withObjectResult $
    withObjectPtr parent $ \cobj_parent -> 
    withCWString title $ \cstr_title -> 
    wxLogWindow_Create cobj_parent  cstr_title  (toCBool showit)  (toCBool passthrough)  
foreign import ccall "wxLogWindow_Create" wxLogWindow_Create :: Ptr (TWindow a) -> CWString -> CBool -> CBool -> IO (Ptr (TLogWindow ()))

-- | usage: (@logWindowGetFrame obj@).
logWindowGetFrame :: LogWindow  a ->  IO (Frame  ())
logWindowGetFrame obj 
  = withObjectResult $
    withObjectRef "logWindowGetFrame" obj $ \cobj_obj -> 
    wxLogWindow_GetFrame cobj_obj  
foreign import ccall "wxLogWindow_GetFrame" wxLogWindow_GetFrame :: Ptr (TLogWindow a) -> IO (Ptr (TFrame ()))